วิธีแก้ปัญหาที่ใช้งานได้จริงสำหรับปัญหานี้จะสะอาดเหมือนความจำเป็นหรือไม่?

ฉันมีแบบฝึกหัดใน Python ดังนี้:

• พหุนามได้รับเป็น tuple ของค่าสัมประสิทธิ์ดังกล่าวว่าอำนาจจะถูกกำหนดโดยดัชนีเช่น: (9,7,5) หมายถึง 9 + 7 * x + 5 * x ^ 2

• เขียนฟังก์ชันเพื่อคำนวณค่าสำหรับ x ที่กำหนด

ตั้งแต่ฉันเข้าสู่การเขียนโปรแกรมการทำงานเมื่อเร็ว ๆ นี้ฉันเขียน

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

ซึ่งอาจมีประสิทธิภาพน้อยกว่า (แก้ไข: ฉันผิด!) เนื่องจากใช้การคูณหลายอย่างแทนการยกกำลังโดยหลักการฉันไม่สนใจการวัดที่นี่ (แก้ไข: ความโง่ของฉัน! การวัดจะชี้ให้เห็นความเข้าใจผิดของฉัน!) และ ยังไม่สามารถอ่านได้ (arguably) เป็นวิธีแก้ซ้ำ:

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

มีวิธีแก้ปัญหาฟังก์ชั่นบริสุทธิ์ที่สามารถอ่านได้ตามความจำเป็นและใกล้เคียงกับประสิทธิภาพหรือไม่?

เป็นที่ยอมรับการเปลี่ยนแปลงการเป็นตัวแทนจะช่วย แต่สิ่งนี้ได้รับจากการฝึก

สามารถเป็น Haskell หรือ Lisp ได้เช่นกันไม่ใช่แค่ Python

วิธีของ Horner น่าจะมีประสิทธิภาพในการคำนวณมากกว่า @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 ใด ๆ ที่มีรายการ destructuring และออกมาอย่างบริสุทธิ์และอ่านง่าย):

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

บางครั้งวิธีการที่เรียบง่ายไร้เดียงสาในฮาเซลเช่นนี้สะอาดกว่าวิธีรัดกุมมากกว่าสำหรับคนที่ไม่คุ้นเคยกับ 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 monad มันจะทำงานได้ดีมาก

แม้ว่าจะมีความแน่นอนการปฏิบัติจริงที่น่าจะเป็นไปได้มากที่สุดจาก Haskeller คือ zipwith ที่กล่าวถึงในคำตอบข้างต้น zipWithเป็นวิธีการทั่วไปมากและฉันเชื่อว่า Python สามารถเลียนแบบวิธีการซิปของการรวมฟังก์ชั่นและตัวทำดัชนีซึ่งสามารถแมปได้

หากคุณเพียงแค่มี (คงที่) tuple ทำไมไม่ทำเช่นนี้ (ใน 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..]

มีชุดของขั้นตอนทั่วไปที่คุณสามารถใช้เพื่อปรับปรุงความสามารถในการอ่านของอัลกอริทึมการทำงาน:

• ใส่ชื่อในผลลัพธ์ระดับกลางของคุณแทนที่จะพยายามยัดทุกอย่างในบรรทัดเดียว
• ใช้ฟังก์ชั่นที่มีชื่อแทน lambdas โดยเฉพาะอย่างยิ่งในภาษาที่มีไวยากรณ์ lambda verbose การอ่านevaluateTermแลมบ์ดานั้นง่ายกว่ามาก เพียงเพราะคุณสามารถใช้แลมบ์ดาไม่ได้หมายความว่าคุณควร
• หากหนึ่งในฟังก์ชั่นที่มีชื่อของคุณดูเหมือนสิ่งที่จะเกิดขึ้นค่อนข้างบ่อยโอกาสที่มันจะอยู่ในไลบรารีมาตรฐานแล้ว มองไปรอบ ๆ. งูหลามของฉันเป็นสนิมเล็ก ๆ น้อย ๆ แต่มันดูเหมือนว่าคุณอัตชีวประวัติพื้นหรือenumeratezipWith
• บ่อยครั้งที่การเห็นฟังก์ชั่นและผลลัพธ์ระดับกลางทำให้ง่ายขึ้นในการคิดว่าเกิดอะไรขึ้นและทำให้มันง่ายขึ้น ณ จุดนี้มันอาจเหมาะสมที่จะนำแลมบ์ดากลับมาหรือรวมบางบรรทัดเข้าด้วยกัน
• หากความจำเป็นในการวนซ้ำดูได้ง่ายขึ้นโอกาสในการเข้าใจก็จะใช้ได้ดี