Bu problemin saf işlevsel bir çözümü, zorunluluk kadar temiz olabilir mi?

Python'da şöyle bir egzersiz yapıyorum:

• bir polinom, güçler indeksler tarafından belirlenecek şekilde bir dizi katsayı olarak verilir, örneğin: (9,7,5), 9 + 7 * x + 5 * x ^ 2 anlamına gelir

• verilen x için değerini hesaplamak için bir fonksiyon yazın

Son zamanlarda fonksiyonel programlamaya başladığım için yazdım

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)

okunamayan sayılırım, bu yüzden yazdım

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]

ki en azından okunamayacak kadar

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

bu daha az verimli olabilir (değiştir: yanlışmışım!) çünkü üs alma yerine birçok çarpma kullanır, prensip olarak, burada ölçümleri umursamıyorum (değiştir: Ne kadar aptalım! Ölçüm yanlış algımı işaret ederdi!) ve yine de yinelemeli çözüm kadar okunabilir (tartışmasız) değil:

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

Zorunlu olduğu kadar okunabilir ve verimlilikte ona yakın, saf fonksiyonel bir çözüm var mı?

Kuşkusuz, bir temsil değişikliği yardımcı olacaktır, ancak bu tatbikat tarafından verildi.

Haskell veya Lisp de olabilir, sadece Python değil.

@ Delnan'ın işaret ettiği gibi Horner'ın yöntemi muhtemelen daha hesaplamalı olarak etkilidir, ancak bu üslü çözüm için Python'da oldukça okunabilir diyebilirim:

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

Birçok işlevsel dilde, bir harita üzerinden bir dizin oluşturmanıza olanak sağlayan mapi uygulamaları vardır. Bunu bir toplamla birleştirin ve F # içinde aşağıdakilere sahip olun:

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

Kodunuzun tanımladığınız sorun kapsamıyla nasıl ilişkili olduğunu anlamıyorum, bu yüzden kodunuzun sorun kapsamını görmezden geldiği şeyin versiyonunu vereceğim (yazdığınız zorunlu koda göre).

Oldukça okunabilir haskell (bu yaklaşım, liste yıkımına sahip olan ve saf ve okunabilir hale gelen herhangi bir FP diline kolayca çevrilebilir):

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

Bazen haskell'deki saf basit yaklaşım, FP'ye daha az alışkın olan insanlara daha kısa yaklaşımdan daha temizdir.

Hala tamamen saf olan daha açıkça zorunlu bir yaklaşım:

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)

İkinci yaklaşıma bonus çok iyi performans gösterecek ST monad'da olmaktır.

Emin olmakla birlikte, bir Haskeller'den en olası gerçek uygulama, yukarıdaki başka bir cevapta belirtilen zipwith olacaktır. zipWithçok tipik bir yaklaşımdır ve Python'un fonksiyonları ve haritalanabilir bir indeksleyiciyi birleştirmenin sıkıştırma yaklaşımını taklit edebileceğine inanıyorum.

Eğer varsa sadece bir (sabit) tuple var, neden (Haskell) bunu:

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

Bunun yerine bir katsayılar listeniz varsa, şunları kullanabilirsiniz:

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

veya sahip olduğunuz gibi bir azalma ile:

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

İşlevsel algoritmaların okunabilirliğini artırmak için kullanabileceğiniz genel bir dizi adım vardır:

• Her şeyi tek bir satırda sıkıştırmaya çalışmak yerine ara sonuçlarınıza adlar koyun.
• Lambda yerine adlandırılmış işlevleri, özellikle ayrıntılı lambda sözdizimi olan dillerde kullanın. evaluateTermUzun bir lambda ifadesinden çok bir şey okumak çok daha kolay . Sadece çünkü edebilirsiniz mutlaka anlamına gelmez lambda kullanmak gerekir .
• Şimdi adlandırılmış işlevlerinizden biri oldukça sık ortaya çıkan bir şeye benziyorsa, zaten standart kütüphanede olma olasılığı vardır. Etrafa bak. Benim piton biraz paslı, ancak temelde yeniden keşfetti gibi görünüyor enumerateya zipWith.
• Genellikle, işlevlerin ve ara sonuçların adlandırılması, neler olup bittiğini düşünmeyi ve basitleştirmeyi kolaylaştırır, bu noktada bir lambda'yı geri koymak veya bazı satırları tekrar birleştirmek mantıklı olabilir.
• Döngü için bir zorunluluk daha okunabilir görünüyorsa, bir kavrama şansı iyi çalışır.