python中的调和级数

有人知道如何用python编写代码吗

H(n) = 1 + 1/2 + 1/3 + ... + 1/n

注意：我们不允许从预定义模块导入。输出必须是分数形式（最低项）答案的分子和分母

这是我的谐波级数代码

n = input("Enter n:")  

def harmonic(n):  
    a=1  
    b=1  
    for d in range(2, n+1):  
            a = a*d+b  
            b = b*d  
            return (a,b)  
            x == max(a,b)%min(a, b)  
            if x == 0:  
                y=min(a,b)  
                return y  
            else:  
                y=min(a,b)/x  
                return y  
            a=a/y  
            b=b/y  
            return (a,b)  
print harmonic(n)  

怎么了？无论我输入什么，输出总是（3,2）

您总是在第一次迭代时返回（a，b）–沙隆“

Return总是以函数结尾。如果返回（a，b），则代码的其余部分将无法访问

您总是在第一次迭代时返回（a，b）。–Scharron“

---

Return总是结束函数。如果返回（a，b），代码的其余部分将无法访问

您可以通过查找数字1..n的最小公倍数来找到分母

然后，命名者将是所有值的总和

分母/x

，x是1..n中的所有值

下面是一些代码：

def gcd(a, b):
    """Return greatest common divisor using Euclid's Algorithm."""
    while b:      
        a, b = b, a % b
    return a

def lcm(a, b):
    """Return lowest common multiple."""
    return a * b // gcd(a, b)

def lcmm(args):
    """Return lcm of args."""   
    return reduce(lcm, args)


def harmonic(n):
    lowest_common_multiple = lcmm(range(1,n))
    nominator = sum([lowest_common_multiple/i for i in range(1,n)])
    greatest_common_denominator = gcd(lowest_common_multiple, nominator)
    return nominator/greatest_common_denominator, lowest_common_multiple/greatest_common_denominator

print harmonic(7)
print harmonic(10)
print harmonic(20)

---

您可以通过查找数字1..n的最小公倍数来找到分母

然后，命名者将是所有值的总和

分母/x

，x是1..n中的所有值

下面是一些代码：

def gcd(a, b):
    """Return greatest common divisor using Euclid's Algorithm."""
    while b:      
        a, b = b, a % b
    return a

def lcm(a, b):
    """Return lowest common multiple."""
    return a * b // gcd(a, b)

def lcmm(args):
    """Return lcm of args."""   
    return reduce(lcm, args)


def harmonic(n):
    lowest_common_multiple = lcmm(range(1,n))
    nominator = sum([lowest_common_multiple/i for i in range(1,n)])
    greatest_common_denominator = gcd(lowest_common_multiple, nominator)
    return nominator/greatest_common_denominator, lowest_common_multiple/greatest_common_denominator

print harmonic(7)
print harmonic(10)
print harmonic(20)

---

正如其他人指出的，当d=2时返回，即（1+1/2），它应该在for循环之外

下面是我编写的代码，用于执行相同的操作：

#!Python2.7
def gcd(a, b):
    if b: return gcd(b, a%b)
    return a

def lcm(a, b):
    return a*b/gcd(a, b)

def start():
    n = int(raw_input())
    ans = reduce(lambda x, y: (x[0]*lcm(x[1],y[1])/x[1]+y[0]*lcm(x[1],y[1])/y[1], lcm(x[1],y[1])),[(1,x) for x in xrange(1,n+1)])
    _gcd = gcd(ans[0], ans[1])
    print (ans[0]/_gcd, ans[1]/_gcd)

start()

如果要避免使用

reduce

、

lamda

和列表理解：

#!Python2.7
def gcd(a, b):
    if b: return gcd(b, a%b)
    return a

def lcm(a, b):
    assert a != 0
    assert b != 0
    return a*b/gcd(a, b)

def next(x, y):
    lcmxy = lcm(x[1], y[1])
    return (x[0]*lcmxy/x[1]+y[0]*lcmxy/y[1], lcmxy)

def start():
    n = int(raw_input())
    curr = (1,1)
    for x in xrange(2,n+1):
        curr = next(curr, (1,x))
    _gcd = gcd(curr[0], curr[1]) 
    print (curr[0]/_gcd, curr[1]/_gcd)

start()

---

正如其他人指出的，当d=2时返回，即（1+1/2），它应该在for循环之外

下面是我编写的代码，用于执行相同的操作：

#!Python2.7
def gcd(a, b):
    if b: return gcd(b, a%b)
    return a

def lcm(a, b):
    return a*b/gcd(a, b)

def start():
    n = int(raw_input())
    ans = reduce(lambda x, y: (x[0]*lcm(x[1],y[1])/x[1]+y[0]*lcm(x[1],y[1])/y[1], lcm(x[1],y[1])),[(1,x) for x in xrange(1,n+1)])
    _gcd = gcd(ans[0], ans[1])
    print (ans[0]/_gcd, ans[1]/_gcd)

start()

如果要避免使用

reduce

、

lamda

和列表理解：

#!Python2.7
def gcd(a, b):
    if b: return gcd(b, a%b)
    return a

def lcm(a, b):
    assert a != 0
    assert b != 0
    return a*b/gcd(a, b)

def next(x, y):
    lcmxy = lcm(x[1], y[1])
    return (x[0]*lcmxy/x[1]+y[0]*lcmxy/y[1], lcmxy)

def start():
    n = int(raw_input())
    curr = (1,1)
    for x in xrange(2,n+1):
        curr = next(curr, (1,x))
    _gcd = gcd(curr[0], curr[1]) 
    print (curr[0]/_gcd, curr[1]/_gcd)

start()

谐波系列：

1/1 + 1/2 + ... + 1/n == (n!/1 + n!/2 + ... + n!/n)/n!

因此，您可以：

nom = reduce(lambda s, x: s*x, xrange(1, n+1),1)   # n!
denom = sum([nom / x for x in xrange(1, n+1)])

然后需要对

nom

和

denom

进行gcd缩减
使用Thorsten Kranz的版本

请注意，这样只需要调用一次

gcd

示例：

def gcd(a, b):
    while b:      
        a, b = b, a % b
    return a


def harmonic(n):
    nom = reduce(lambda s, x: s*x, xrange(1,n+1), 1)   # n!
    denom = sum([nom / x for x in xrange(1, n+1)])
    f = gcd(denom, nom)
    return (denom / f), (nom / f)


print harmonic(10)
print harmonic(20)

(7381, 2520)
(55835135, 15519504)

谐波系列：

1/1 + 1/2 + ... + 1/n == (n!/1 + n!/2 + ... + n!/n)/n!

因此，您可以：

nom = reduce(lambda s, x: s*x, xrange(1, n+1),1)   # n!
denom = sum([nom / x for x in xrange(1, n+1)])

然后需要对

nom

和

denom

进行gcd缩减
使用Thorsten Kranz的版本

请注意，这样只需要调用一次

gcd

示例：

def gcd(a, b):
    while b:      
        a, b = b, a % b
    return a


def harmonic(n):
    nom = reduce(lambda s, x: s*x, xrange(1,n+1), 1)   # n!
    denom = sum([nom / x for x in xrange(1, n+1)])
    f = gcd(denom, nom)
    return (denom / f), (nom / f)


print harmonic(10)
print harmonic(20)

(7381, 2520)
(55835135, 15519504)

---

我必须检查您的尝试两次-并插入一个简单的gcd（在原始代码的中间）

---

我必须检查您的尝试两次-并插入一个简单的gcd（在原始代码的中间）

---

---

在第一次迭代时，您总是

返回（a，b）

。正如@Scharron所说，您总是返回

a，b

。请注意，您有一个

if…else

bloc，无论发生什么情况，它都会被执行。两个分支都返回一个值。因此，您的

for

循环不会循环多次。提示：您可能希望将其分解为两个步骤。1） 添加一组分数（为此，您需要能够找到2个分数的lcm）和2）减少分数。为什么不把它们分解成不同的函数呢。。我该怎么做才能让它变得更好？我应该用什么来代替退货？谢谢：）@JoelCornett。我们不允许导入分数：（（您总是

返回（a，b）

在第一次迭代时。正如@Scharron所说，您总是返回

a，b

。请注意，您有一个

if…else

bloc，无论发生什么情况都会被执行。两个分支都返回一个值。因此您的

for

循环不会循环不止一次。提示：您可能希望将其分解为两个步骤。1）添加一组分数（为此，您将希望能够找到2个分数的lcm）和2）减少分数。为什么不将它们分解为单独的函数？那么..我应该做些什么使其更好？我应该使用什么来代替返回？谢谢：）@JoelCornett。我们不允许输入分数：（（OP说“输出必须是分数形式的答案的分子和分母（最低项）”-我不认为他想要一个发电机还在运行中…很抱歉混淆了…嗯…这不是谐波级数。我不认为这是完全正确的-你可能仍然会遇到分子和分母有公因子的情况。例如，

谐波（7）==（147，60）

，但实际上应该是

（49，20）

。也许将返回的

n，d

除以

gcd（n，d）

就足够了。你可能想a）向OP（声称是python初学者）解释你的代码，b）重命名你的

lcm

函数，因为它并不总是产生两个数的最小公倍数，而是产生两个数的严格倍数。OP说“输出必须是分数形式的答案的分子和分母（最低项）”-我不认为他想要一个发电机还在运行中…很抱歉混淆了…嗯…这不是谐波级数。我不认为这是完全正确的-你可能仍然会遇到分子和分母有公因子的情况。例如，

谐波（7）==（147，60）

，但实际上应该是

（49，20）

。可能将返回的

n，d

除以

gcd（n，d）

就足够了。您可能想a）向OP（声称是python初学者）解释您的代码，b）重命名

lcm

函数，因为它并不总是产生两个数字中最不常见的倍数，相反，它产生2个数字的严格倍数。那么，我应该怎么做呢？？我很困惑：‘（那么，我该怎么办呢？’我很困惑：‘（这不一定会给出减少的值：例如，

（147，60）

。非常感谢：））顺便问一下，“断言”的目的是什么？谢谢：）这是一种方便的调试方式。在我的代码中，如果a或b为0，它将抛出断言Error.uhm。。顺便问一下，这个语法是什么意思？n*=1.0？谢谢：）这不一定会给出减少的值：例如，

（147，60）

。非常感谢：）顺便问一下，有什么问题