Question

我现在讨厌Recursive。任何人都知道如何使用python上的递归解决方案找到平方根。或者至少将其分解为简单的问题。我发现的所有例子都是线性的，只使用函数中的一个参数。我的函数需要平方根（数字，低猜数，高猜数，准确度）我认为准确性应该是基本情况，但我不能弄清楚递归部分。

这就是我的尝试：

L = 1
H = 3
def s(n,L,H):
    if (((L + H)/2)**2) <= 0.05:
        print(((L + H)/2))
    else:
        if (((L + H)/2)**2) > 2:
            L = (L + H)/2
            return s(n,L,H)
        else:
            H = (L + H)/2
            return s(n,J,H)

Answer 1

def sqrt(val):
    accuracy = 0.1
    s = 1.0
    while True:
        prevS = s
        s = (s + val/s) / 2
        if abs(s-prevS)  <= accuracy :
            return s

Haven未经过测试..

编辑：更好的版本

import math

def guess(val):
   if val > 1:
       return 10**(len(val)/2)
   elif val == 1
       return 1
   else
       return 1 # still thinking on this.. thought log10 would be best fit but that kills purpose of iterator      

def sqrt(val):
    accuracy = 0.1
    s = guess(val) # to reduce no of loops
    while True:
        prevS = s
        s = (s + val/s) / 2
        if abs(s-prevS)  <= accuracy :
            return s

Answer 2

def sqroot(n,guessed=1.0):

if abs(guessed**2 - n) <= 1e-15 or n == 1:
    return guessed
else:
    guessed = (guessed+ (n/guessed))/2
    return sqroot(n,guessed)

Answer 3

没有！这个是Ruby。抱歉!但你可以很容易地适应它。这是一个简单的版本。人们可能会把它分解成更多的方法。

例如：

平均

方

good_enough for the guess

改进猜测

def sqrt(x)
  eps = 1.0e-17 # the epsilon desired
  diff = 1      # difference of new guess and result
  g = 1         # the guess
  while (diff > eps) do
    xg = x/g
    g1 = (g + xg)/2.0
    diff = (g - g1).abs
    g = g1
  end
  g
end

p sqrt 2 #=> 1.414213562373095 
p Math.sqrt 2 #=> 1.4142135623730951

def good_enough(x, guess)
  eps = 1.0e-17
  guess2 = square(guess) 
  (guess2 - x).abs < eps
  # true or false
end

def average(x, y)
  (x + y) / 2.0
end

and so on.....

这只是一个例子。摘要所有你可以这样你以后可以使用它们。

顺便问一下你是偶然做麻省理工学院开放式课程吗？

我正在研究CS 6.001但该计划。它始于这种类型的处理或程序。 Ruby有lambdas。你能用Python做lambdas吗？

现在我告诉你这里的计划就是尝试：

(define (square x)
  (* x x))

(define epsilon 0.00001)

(define close_enuf? 
  (lambda (guess x)
    (< (abs (- (square guess) x)) epsilon)))

(define (average x y)
  (/ (+ x y) 2.0))

(define improve 
  (lambda (guess x)
    (average guess (/ x guess))))

(define sqrt_loop
  (lambda (guess x)
    (if (close_enuf? guess x)
      guess
      (sqrt_loop (improve guess x) x))))

(define sqrt
  (lambda (x)
    (sqrt_loop 1.0 x)))

不是很难读懂吗？

平方根使用递归

3 个答案: