制作一个 collat​​z 程序自动化无聊的东西

Question

我正在尝试使用 Automate the Boring Stuff with Python 第 3 章末尾的一个项目中的指南编写一个 Collat​​z 程序。我正在使用 python 3.4.0。以下是项目大纲：

编写一个名为 collatz() 的函数，它有一个名为 number 的参数。如果数字是偶数，那么collatz() 应该打印number // 2 并返回这个值。如果数字是奇数，则collatz() 应该打印并返回3 * number + 1。然后编写一个程序，让用户输入一个整数，并在该数字上不断调用collatz()，直到函数返回值1。

此程序的输出可能如下所示：

Enter number: 3 10 5 16 8 4 2 1 

我正在尝试创建一个在 while 循环中使用 if 和 elif 语句的函数。我想要打印数字，然后返回到循环的开头并使用 Collat​​z 序列将自身减少为一个，结果数字的每个实例在它通过循环时被打印。使用我当前的代码，我只能打印数字的第一个实例，之后该数字不会通过循环。以下是我的代码：

#collatz

print("enter a number:")
try:
    number = (int(input()))
except ValueError:
          print("Please enter a valid INTEGER.")


def collatz(number):
    while number != 1:

        if number % 2==0:
            number = (number//2)
            #print(number)
            return (print(int(number)))

        elif nnumber % 2==1:
            number = (3*number+1) 
            #print(number)
            return (print(int(number)))

        continue


collatz(number)

Answer 1

def collatz(number):

    if number % 2 == 0:
        print(number // 2)
        return number // 2

    elif number % 2 == 1:
        result = 3 * number + 1
        print(result)
        return result

n = input("Give me a number: ")
while n != 1:
    n = collatz(int(n))

输出：

Give me a number: 3
10
5
16
8
4
2
1

Give me a number: 11
34
17
52
26
13
40
20
10
5
16
8
4
2
1

Answer 2

这是我想出的：

import sys

def collatz(number):
    if number % 2 == 0:           # Even number
        result = number // 2
    elif number % 2 == 1:         # Odd number
        result = 3 * number + 1

    while result == 1:            # It would not print the number 1 without this loop
        print(result)
        sys.exit()                # So 1 is not printed forever.

    while result != 1:            # Goes through this loop until the condition in the previous one is True.
        print(result)
        number = result           # This makes it so collatz() is called with the number it has previously evaluated down to.
        return collatz(number)    

print('Enter a number: ')         # Program starts here!
try:
    number = int(input())         # ERROR! if a text string or float is input.
    collatz(number)
except ValueError:
    print('You must enter an integer type.')

                                  # Fully working!

Answer 3

您的collatz() 函数应该只打印并返回下一个值。 （返回时结束。）

while 循环不应在 collatz() 函数内。

你还有不一致的变量名（n、number、nnumber），一些重要的代码被注释掉了。

Answer 4

我为同一个练习编写的 17 行代码。

    def collatz(number):
    """ check if the number is even or odd and performs calculations.
    """
    if number % 2  == 0: # even
        print(number // 2)
        return number //2
    elif number % 2 != 0: # odd 
        result = 3*number+1
        print(result)
        return result

try:
    n = input('Enter number: ') # takes user input
    while n !=1: # performs while loop until 'n' becomes 1
        n = collatz(int(n)) # passes 'n' to collatz() function until it arrives at '1'
except ValueError:
    print('Value Error. Please enter integer.')

Answer 5

def collatz(number):
    while number != 1:
        if number % 2 == 0:
            number = number // 2
            print(number)

        elif number % 2 == 1:
            number = number * 3 + 1
            print(number)

try:
    num = int(input())
    collatz(num)
except ValueError:
    print('Please use whole numbers only.')

这是我自己提出的，完全基于我迄今为止从这本书中学到的东西。我花了一点时间，但我使用的工具之一是 python 可视化工具，它对我找到我的解决方案非常宝贵，对于学习这些内容也非常宝贵：http://www.pythontutor.com/visualize.html#mode=edit

我能够看到我的代码在做什么以及它在哪里挂起，并且我能够不断地进行调整，直到我做对为止。

Answer 6

我正在阅读相同的课程，我提出了一个很长的解决方案（当我学习一些新的东西时改进它）。我建议随着你在章节中的进展保持你的 collat​​z 程序是最新的，这是很好的训练。我的现在有字符串操作并保存到 \collat​​zrecords.txt！

我通过递归（方法调用自己）解决了核心问题：

def autocollatz(number):
global spam                     
spam.append(number)             
if number % 2 == 0:             
    autocollatz (int(number/2))
elif number % 2 == 1 and number != 1:
    autocollatz(int(number*3+1))

垃圾邮件是我的列表，其中包含一个数字“看到”到 1 的所有值。 正如你所看到的，当数字是偶数时，方法被称为 agin with number/2。如果数字是偶数，则以数字*3+1 调用。

修改了数字 == 1 检查了一下。我希望它可以节省计算时间 - 我已经达到了 23 000 000！ （当前记录是 15 733 191，需要 704 步才能达到 1）

Answer 7

def collatz(number):
    if number % 2 == 0:
        return number // 2
    elif number % 2 == 1:
        return 3 * number + 1

try:
    chosenInt = int(input('Enter an integer greater than 1: '))

    while chosenInt < 2:
        print("Sorry, your number must be greater than 1.")
        chosenInt = int(input('Enter an integer greater than 1: '))

    print(chosenInt)

    while chosenInt != 1:
        chosenInt = collatz(chosenInt)
        print(chosenInt)

except ValueError:
    print('Sorry, you must enter an integer.')

Answer 8

我设法在不使用任何 return 语句的情况下正确处理，并在函数内嵌套了一个 while 循环。

number=int(input('Enter number:\n'))

def collatz(number):

    while number !=1:
        if number% 2 == 0:
            number= number//2
            print(number)

        else:
           number=  3 * number + 1
           print(number)    


collatz(number)

Answer 9

我已经添加了尝试，除了这样（有一个休息）

def collatz(number):
if number %2 == 0:
    print(number//2)
    return number//2
elif number %2 == 1:
    print(3 * number + 1)
    return 3 * number + 1

n = input("Give me a number: ")

while n != 1:
    try:
        isinstance(n, int)
        n = collatz(int(n))
    except:
        print('Error: Invalid argument.')
        break

Answer 10

我的代码

def collatz(number):
    while number != 1:
        if number % 2 == 0:
            print(number // 2)
            number = number // 2
        elif number % 2 == 1:
            print(number * 3 + 1)
            number =  number *3 + 1

try:
    print ('Enter the number to Collatz:')
    collatz(int(input()))
except ValueError:
    print('Enter a valid integer')

Answer 11

def collatz(number):
    if number % 2 == 0:  # Even number
        return number // 2

    elif number % 2 == 1:  # Odd number
        return number * 3 + 1

print('Please enter a number') # Ask for the number


# Check if the number is an integer, if so, see if even or odd. If not, rebuke and exit
try:
    number = int(input())
    while number != 1:
        collatz(number)
        print(number)
        number = collatz(number)
    else:
        print('You Win. The number is now 1!')
except ValueError:
     print('Please enter an integer')

这是我为这个练习想出的。 它要求输入 验证它是否为整数。如果不是，它会责备并退出。如果是，则循环遍历 collat​​z 序列，直到结果为 1，然后您获胜。

Answer 12

此线程上的每个解决方案都缺少一件事：如果用户输入“1”，该函数仍应运行 Collat​​z 序列的计算。我的解决方案：

def collatz(number):
    while number == 1:
        print("3 * " + str(number) + " + 1 = " + str(3*number+1))
        number = 3*number+1 ##this while loop only runs once if at all b/c at end of it the value of the variable is not equal to 1
    else:
        while number != 1:
            if number % 2 == 0:
                print(str(number) + ' // 2 = ' + str(number//2))
                number = number//2
            else:
                print("3 * " + str(number) + " + 1 = " + str(3*number+1))
                number = 3*number+1

 print('Please input any integer to begin the Collatz sequence.')

while True:
    try:
        number = int(input())
        collatz(number)
        break
    except ValueError:
        print('please enter an integer')

Answer 13

def collatz(number):
    while number != 1:
        if number %2==0:
            number = number//2
            yield number
        elif number %2 ==1:
            number=number*3 +1
            yield number

while True:
    try:
        for n in collatz(int(input('Enter number:'))):
            print(n)
        break
    except ValueError:
        print('Please enter an integer')

额外的 while True 循环将帮助程序在用户输入非整数后继续运行。

Answer 14

def collatz(number): 
    if number%2==0:    
        return number//2
    elif number%2==1:
        return number*3+1
step=1 #counter variable for amusement and seeing how many steps for completion.
try: #in case of ValueError   
    number=int(input('Enter a Number for Collatz Sequencing:')) 
    while collatz(number)!=1:    
        print(collatz(number))
        number=int(collatz(number))
        if collatz(number)!=1: 
            print('Calculating step ' + str(step) + '.')
            step=step+1
        else:
            print ('Calculating step ' +str(step) + '.')
            print('1 Has Been Reached.')
except ValueError: 
     print('Enter an Integer please:')

Answer 15

这是我的 19 行：

def collatz(number):
    if number % 2 == 0:
        return number // 2
    else:
        return number*3 + 1


number = 0
while number == 0:
    try:
        number = int(input('Please enter a number: '))
        if number == 0:
            print('Number must be an integer not equal to zero.')
        else:
            while True:
                number = collatz(number)
                print(number)
                if abs(number) == 1 or number == -5 or number == -17: 
                    break #Collatz seq ends/enters recurring loop when number hits -17, -5, -1 or 1
    except ValueError:
        print('Number must be an integer.')

Answer 16

我认为对于学习者来说，这种解决方案可能比公认的解决方案更简单：

def collatzSequence(number):
    if (number % 2 == 0): # if it's even
        number = number // 2
    else:                 # if it's odd
        number = number * 3 + 1
    print (number)
    return (number)

n = int(input('Enter a number: '))
while (n != 1):
    n = collatzSequence(n)

结果会是这样的：

Enter a number: 5
16
8
4
2
1

Answer 17

Nuncjo 得到了有效的解决方案。我稍微调整了一下，添加了 try 和 except 语句以进行错误处理。

def collatz(number):
    if number % 2 == 0:
        print(number // 2)
        return number // 2

    elif number % 2 == 1:
        result = 3 * number + 1
        print(result)
        return result

try:
    n = input("Enter number: ")
    while n > 0 and n!= 1:
        n = collatz(int(n))
except ValueError:
    print('whoops, type an integer, bro.')

Answer 18

14 行：

不明白为什么我们需要“elif number %2 == 1:”而不是简单的“else”？

def  collatz(number):
    while number != 1:
        if number %2 == 0:
            number = number/2
            print(number)
        else:
            number = 3*number+1
            print(number)
print('Enter a number')
try:
    number = (int(input()))
except ValueError:
          print("Please enter an INTEGER.")
collatz(number)

Answer 19

def cyclic(number):
    if number % 2 == 0:
        if number // 2 == 1:
            print(1)
        else:
            print(number//2)
            cyclic(number // 2)
    else:
        print((number * 3) + 1)
        cyclic((number * 3) + 1)


print("Enter a number:")
try:
    n = int(input())
    cyclic(n)
except ValueError:
    print("Unvalied value")

最简单的一个

Answer 20

你可以试试这个

while True:
 number=int(input('Enter next positive number or 0 to quit: '))
 iteration=0
 currentNumber=0
 item=1
 sumOfNumbers=0
 print(number,end='  ')
 if(number):
    while currentNumber !=1 :
        currentNumber=int(number/2) if(number%2==0) else number*3+1
        number=currentNumber
        iteration +=1; item +=1
        sumOfNumbers +=currentNumber
        print(currentNumber,end ='\n' if(item %5==0) else '  ')
    print('\nIt took ',iteration,'iterations to arrive at 1')
    print('The average  is ',round((sumOfNumbers/iteration),2))
 else :
    break

Answer 21

1. 在您的程序（问题）中，执行return语句后，不执行continue。所以它只会循环一次迭代。

2. 您的程序不适用于输入整数 1。您可能想检查方法的结果 1，不应该检查用户输入本身。 1 也是程序的有效输入。

3. 方法将更适合执行一项操作。 （SOLID 编程原理）。最好在循环中调用函数而不是在函数内部循环。增加了方法的可重用性。

def collatz(number):
    if number % 2 == 0:
        print(number // 2)              # logically, floor division is equivalent to division when even number with 2
        return number // 2
    elif number % 2 != 0:
        print(number * 3 + 1)
        return number * 3 + 1


number = int(input("Please enter a number\n"))
result = collatz(number)                # this way the program also takes 1 as input
while result != 1:
    result = collatz(result)



# Output:


Please enter a number
1
4
2
1

Please enter a number
32
16
8
4
2
1

Answer 22

这是一个完美的递归问题，想知道为什么没有这样的正文编码：

def Collatz(Num):
    if Num==1:
        return
    if Num % 2 == 1:
        newNum=int(Num*3+1)
    else:
        newNum=int(Num/2)
    print(newNum)
    Collatz(newNum)
#------------------------------------
Num = input("Enter your value: ")
try:
    val = int(Num)
    if val < 0 :
        print("Error: Please enter a positive integer only")
        exit(1)
except ValueError:
    print("Error: Please enter a positive integer only")
    exit(1)

Collatz(int(Num))
=============================================
Enter your value: 11
34
17
52
26
13
40
20
10
5
16
8
4
2
1

Answer 23

def collatz(num): 
    if num % 2: 
        return 3 * num + 1
    else:
        return num // 2

while True:
    try:
    number = int(input('Enter a positive integer.'))  
    if number <= 0: 
        continue
    break
except ValueError: 
    continue


while number != 1:
    number = collatz(number)
    print(number)

Answer 24

def collatz(number):
    if number % 2 == 0:
        print(number//2)
        return number // 2
    elif number % 2 == 1:
        print(3*+number+1)
        return 3 * number + 1
r=''
print('Enter the number')
while r != int:
    try:
        r=input()
        while r != 1:
            r=collatz(int(r))
        break   
    except ValueError:
            print ('Please enter an integer')

我添加了输入验证

Answer 25

def collat​​z（数字）： 如果（数字%2==0）： n=数字//2 打印（n） 返回 n 别的： ev=3*数字+1 打印（ev） 返回 ev num1=input("请输入一个数字：\n") 尝试： 数字= int(num1) 如果（数量==1）： print("请输入一个大于 1 的整数") elif（数字> 1）： a=collat​​z(数量) 而（真）： 如果（a==1）： 休息 别的： a=科拉茨(a) 别的： print("请输入一个正整数开始 Collat​​z 序列") 除了： print("请输入一个整数")

尝试根据功能从自动化无聊的东西一章提出一个解决方案。 如果需要有关 Collat​​z 问题的帮助，请访问此处： http://mathworld.wolfram.com/CollatzProblem.html

Answer 26

import sys

def collatz(number):
if number % 2 == 0:
    result = number // 2
    print (result)

elif number % 2 == 1:
    result = number * 3 + 1
    print (result)

while result == 1:
    sys.exit

while result != 1:
    number = result
    collatz(number)

print ('Enter a number')

try:
    number = int(input())
    collatz(number)

except ValueError:
    print('Please enter a valid integer')

Answer 27

我很难理解这个练习的逻辑。 但是如果我们有一个负数，我不知道我做错了什么来显示错误。

def collatz(number):
if number % 2 == 0:
    print(number // 2)
    return number // 2

elif number % 2 == 1:
    result = 3 * number + 1
    print(result)
    return result

while True:
try:
    entry = input('enter a positive number: ')
    while entry != 1:
        entry = collatz(int(entry))

    # if we have a negative number
    while entry < 1:
        break

except ValueError:
    print('Error, enter valid number')

Answer 28

import sys   
result = 0   
print('key in any integer:')

def collatz():   

    number = int(input())    
    if number % 2 == 0:    
        result = number//2    
        print (result)    
        if result == 1:    
            print('finally u got it')    
            sys.exit()    
    if number % 2 == 1:    
        result = 3 * number + 1    
        print (result)

while result != 1:  
    collatz()