Может ли чисто функциональное решение этой проблемы быть таким же чистым, как императив?

У меня есть упражнение на Python следующим образом:

• многочлен задается в виде набора коэффициентов, так что степени определяются индексами, например: (9,7,5) означает 9 + 7 * x + 5 * x ^ 2

• написать функцию для вычисления ее значения для данного х

Так как в последнее время я занимаюсь функциональным программированием, я написал

def evaluate1(poly, x):
  coeff = 0
  power = 1
  return reduce(lambda accu,pair : accu + pair[coeff] * x**pair[power],
                map(lambda x,y:(x,y), poly, range(len(poly))),
                0)

который я считаю нечитаемым, поэтому я написал

def evaluate2(poly, x):
  power = 0
  result = 1
  return reduce(lambda accu,coeff : (accu[power]+1, accu[result] + coeff * x**accu[power]),
                poly,
                (0,0)
               )[result]

по крайней мере так же нечитабельно, поэтому я написал

def evaluate3(poly, x):
  return poly[0]+x*evaluate(poly[1:],x) if len(poly)>0 else 0

который может быть менее эффективным (правка: я был неправ!), поскольку он использует множество умножений вместо возведения в степень, в принципе, мне здесь наплевать на измерения (правка: как глупо с моей стороны! Измерения указали бы на мое заблуждение!) и все еще не так читабельно (возможно), как итеративное решение:

def evaluate4(poly, x):
  result = 0
  for i in range(0,len(poly)):
      result += poly[i] * x**i
  return result

Есть ли чисто функциональное решение, столь же удобочитаемое, как императив, и близкое к нему по эффективности?

По общему признанию, изменение представления помогло бы, но это было дано упражнением.

Может быть Haskell или Lisp, а не только Python.

Метод Хорнера, вероятно, более вычислительно эффективен, как указывает @delnan, но я бы назвал это довольно читабельным в Python для решения возведения в степень:

def eval_poly(poly, x):
    return sum( [a * x**i for i,a in enumerate(poly)] )

Многие функциональные языки имеют реализации mapi, которые позволяют вам иметь индекс, сплетенный через карту. Объедините это с суммой, и вы получите следующее в F #:

let compute coefficients x = 
    coefficients 
        |> Seq.mapi (fun i c -> c * Math.Pow(x, (float)i))
        |> Seq.sum

Я не понимаю, как ваш код соотносится с областью задачи, которую вы определили, поэтому я приведу свою версию того, что ваш код игнорирует область проблемы (на основе написанного вами императивного кода).

Довольно читаемый haskell (этот подход может быть легко переведен на любой язык FP, который имеет деструктуризацию списка и получается чистым и читаемым):

eval acc exp val [] = acc
eval acc exp val (x:xs) = eval (acc + execPoly) (exp+1) xs
  where execPoly = x * (val^exp)

Иногда такой простой наивный подход в Haskell чище, чем более лаконичный подход к людям, менее привыкшим к FP.

Более четкий императивный подход, который все еще полностью чист:

steval val poly = runST $ do
  accAndExp <- newSTRef (0,1)
  forM_ poly $ \x -> do
    modifySTRef accAndExp (updateAccAndExp x)
  readSTRef accAndExp
  where updateAccAndExp x (acc, exp) = (acc + x*(val^exp), exp + 1)

Бонус ко второму подходу заключается в том, что в монаде ST он будет работать очень хорошо.

Хотя, чтобы быть уверенным, наиболее вероятной реальной реализацией от Haskeller будет zipwith, упомянутый в другом ответе выше. zipWithЭто очень типичный подход, и я верю, что Python может имитировать подход комбинирования функций и индексатора, который можно отобразить.

Если у вас просто есть (фиксированный) кортеж, почему бы не сделать это (в Haskell):

evalPolyTuple (c, b, a) x = c + b*x + a*x^2

Если вместо этого у вас есть список коэффициентов, вы можете использовать:

evalPolyList coefs x = sum $ zipWith (\c p -> c*x^p) coefs [0..]

или с уменьшением, как у вас было:

evalPolyList' coefs x = foldl' (\sum (c, p) -> sum + c*x^p) 0 $ zip coefs [0..]

Существует общий набор шагов, которые вы можете использовать для улучшения читаемости функциональных алгоритмов:

• Поместите имена в свои промежуточные результаты, вместо того, чтобы пытаться втиснуть все в одну строку.
• Используйте именованные функции вместо лямбда-выражений, особенно в языках с подробным лямбда-синтаксисом. Гораздо проще читать что-то вроде evaluateTermдлинного лямбда-выражения. То, что вы можете использовать лямбду, не обязательно означает, что вы должны это делать .
• Если одна из ваших теперь названных функций выглядит так, как будто она появляется довольно часто, скорее всего, она уже есть в стандартной библиотеке. Смотреть по сторонам. Мой питон немного ржавый, но похоже, что вы в основном заново enumerateили zipWith.
• Часто видение названных функций и промежуточных результатов облегчает рассуждение о том, что происходит, и упрощает его, и в этот момент может иметь смысл вернуть обратно лямбду или объединить некоторые строки вместе.
• Если императивный цикл выглядит более читабельным, скорее всего, для понимания будет хорошо работать.