이 문제에 대한 순수한 기능적 해결책이 명령만큼이나 깨끗할 수 있습니까?

다음과 같이 Python에서 운동을합니다.

• 다항식은 거듭 제곱이 지수에 의해 결정되도록 계수의 튜플로 제공됩니다. 예 : (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

지수화 대신 많은 곱셈을 사용하기 때문에 효율성이 떨어질 수 있습니다 (편집 : 잘못되었습니다!) 여전히 반복 솔루션만큼 읽을 수는 없습니다 (논쟁 적으로).

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

명령형으로 읽을 수 있고 효율성에 가까운 순수한 기능 솔루션이 있습니까?

분명히, 표현 변화가 도움이 될 것이지만, 이것은 운동에 의해 주어졌습니다.

Python뿐만 아니라 Haskell 또는 Lisp도 가능합니다.

Horner의 방법은 @delnan이 지적한 것처럼 계산 방식이 더 효율적이지만 지수 솔루션을 위해 파이썬에서 이것을 읽을 수 있습니다.

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

많은 기능적 언어에는 맵을 통해 인덱스를 만들 수있는 맵 구현이 있습니다. 이것을 합계와 결합하면 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의 실제 구현은 위의 다른 답변에서 언급 한 zip입니다. zipWith매우 일반적인 접근 방식이며 파이썬이 함수와 매핑 가능한 인덱서를 결합하는 압축 방법을 모방 할 수 있다고 생각합니다.

당신이 경우 단지 A (고정) 튜플을 가지고, 왜 (하스켈)이 작업을 수행 할 :

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.
• 종종 이름이 지정된 함수와 중간 결과를 보면 상황을 추론하고 단순화하기가 더 쉬워집니다.이 시점에서 람다를 다시 넣거나 일부 줄을 다시 결합하는 것이 좋습니다.
• 명령형 for 루프가 더 읽기 쉬워 보일 경우 이해가 잘 될 가능성이 있습니다.