Faire un collatz programme d'automatiser les trucs ennuyeux

Je suis en train d'écrire un collatz programme en utilisant les lignes directrices d'un projet se trouvent à la fin du chapitre 3 de l'Automatiser les Trucs Ennuyeux avec Python. Je suis à l'aide de python 3.4.0. Voici les grandes lignes du projet:

Écrire une fonction nommée collatz() qui a un paramètre nommé numéro. Si le nombre est pair, alors collatz() imprimer numéro d' //2 et renvoie cette valeur. Si le nombre est impair, alors collatz() doit imprimer et return 3 * nombre + 1. Ensuite, écrire un programme qui permet à l'utilisateur de taper un entier et qui continue d'appeler collatz() sur ce numéro jusqu'à ce que la fonction renvoie la valeur 1.

La sortie de ce programme pourrait ressembler à quelque chose comme ceci: Entrez le nombre: 3 10 5 16 8 4 2 1

Je suis en train de faire une fonction qui utilise si et elif instructions à l'intérieur d'une boucle while. Je veux le nombre d'exemplaires à imprimer, puis revenir au début de la boucle et de réduire lui-même à l'aide de la collatz séquence, chaque instance d'un nombre qui en résulte étant imprimé comme il va à travers la boucle. Avec mon code actuel, je suis seulement en mesure d'imprimer la première instance du nombre, et ce nombre ne va pas dans la boucle après que. Voici mon code:

#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)

OriginalL'auteur DeltaFlyer | 2015-11-03

python python-3.4

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))

De sortie:

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

Afin de comprendre la Récursivité vous devez d'abord comprendre la récursivité! EST la clé.
ultrasounder ce DONC, après les propos de la récursivité est tous vous avez vraiment besoin de savoir. stackoverflow.com/questions/33508034/...
Deux choses qui peuvent rendre le code plus propre: print(n) à l'extérieur collatz et seulement en fonte à int une fois après la lecture de l'entrée

OriginalL'auteur Nuncjo

Voici ce que je suis venu avec:

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!

OriginalL'auteur ubundows

2

Votre collatz() la fonction d'impression & return seulement la valeur suivante. (Elle se termine quand il retourne.)

La while boucle ne doit pas être à l'intérieur de la collatz() fonction.

Vous avez aussi incompatible noms de variables (n, number, nnumber), et certains code est commenté.

Oups, j'ai joué un peu le code et renommé les variables 'n' à partir de 'nombre' et puis retour à "numéro" avant de poster. Je ne sais pas quand j'ai fait remarquer que le 'retour', mais je vais le remettre dans le code (il n'était pas censé être commenté, si c'est ce que vous faites allusion).

OriginalL'auteur Jonathan Clede

Mon 17 lignes de code pour le même exercice que j'ai trouvé.

    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.')

OriginalL'auteur Simas

Nuncjo ont la solution qui fonctionne. J'ai modifié un peu pour ajouter de l'essayer et à l'exception des déclarations de gestion d'erreur.

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 != 1:
        n = collatz(int(n))
except ValueError:
    print('whoops, type an integer, bro.')

OriginalL'auteur doc_gunthrop

0
```
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.')
```
C'est ce que j'ai trouvé sur mon propre et basée uniquement sur ce que j'ai appris dans le livre jusqu'à présent. Il m'a fallu un peu, mais l'un des outils que j'ai utilisé qui a été d'une valeur inestimable pour moi de trouver ma solution et a également été précieuse dans l'apprentissage de ce contenu est le python visualizer outil: http://www.pythontutor.com/visualize.html#mode=edit

J'ai été en mesure de voir ce que mon code était en train de faire et où il a été accroché et j'ai été en mesure de continuellement faire des ajustements jusqu'à ce que je l'ai eu droit.

OriginalL'auteur Ryan Hallberg

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)

OriginalL'auteur Maecenas

Mon Code

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')

Alors que cet extrait de code, peut-être de résoudre la question, y compris une explication aide vraiment à améliorer la qualité de votre post. Rappelez-vous que vous répondez à la question pour les lecteurs dans l'avenir, et ces personnes pourraient ne pas connaître les raisons de votre code suggestion.

OriginalL'auteur Jebin

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')

C'est ce que j'ai trouvé pour cet exercice.
Il demande une entrée
Vérifie si c'est un entier. Si pas de reproches et de sorties. Si elle l'est, il parcourt le collatz séquence jusqu'à ce que le résultat est 1, puis vous gagnez.

OriginalL'auteur Christopher Wales

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')

J'ai ajouté de la validation de la saisie

r != int ne sera jamais faux. Vouliez-vous dire isinstance(r, int)?

OriginalL'auteur LuckyMiv

Chaque solution sur ce fil de discussion est le manque d'une chose: si l'utilisateur tape "1" la fonction doit toujours exécuter les calculs de la Collatz séquence. Ma solution:

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')

OriginalL'auteur stevensonmt

def collatz(nombre): 
if(nombre%2==0): 
n=nombre de//2 
print(n) 
de retour n 
autre chose: 
ev=3*nombre+1 
print(ev) 
retour ev 
num1=input("Entrez un nombre: \n") 

essayez: 
num= int(num1) 
if(num==1): 
print("Entrez un entier plus grand que 1") 
elif(num>1): 
a=collatz(num) 
while(True): 
si(a==1): 
pause 
autre chose: 
a=collatz(a) 
autre chose: 
print("Veuillez Entrer un nombre entier positif pour commencer la Collatz séquence") 

à l'exception de: 
print("veuillez Entrer un nombre entier")

Essayer de trouvé une solution basée sur le chapitre de la Fonction d'automatiser les trucs ennuyeux.
Si besoin d'aide liées à la Collatz Problème, puis de vous rendre ici:
http://mathworld.wolfram.com/CollatzProblem.html

OriginalL'auteur Md. Raihan

0

je suis en train de lire le même cours et j'ai fait un très long (solution de l'améliorer quand j'ai appris somethign nouveau). je suggère de garder votre collatz programme jusqu'à la date que vous progressez dans les chapitres, sa bonne formation. la mienne a la manipulation de la chaîne et de la sauvegarde vers un \collatzrecords.txt maintenant!

J'ai résolu le problème en utilisant la récursivité (une méthode qui s'appelle elle-même):
```
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))
```
spam est ma liste pour toutes les valeurs d'un certain nombre "voit" sur son chemin à 1.
comme vous pouvez le voir, lorsque le nombre est encore la méthode est appelée agin avec nombre/2. si le nombre est pair, il est appelé avec le numéro*3+1.

modifié le nombre == 1 vérifier un peu. j'espère qu'il enregistre les temps de calcul - im jusqu'à 23 000 000 déjà! (record actuel est de 15 733 191 avec 704 étapes pour l'obtenir: 1)

OriginalL'auteur Turun ambartanen

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')

Pouvez-vous donner plus d'informations à propos de votre code

OriginalL'auteur Subterranean

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')

Le supplémentaires alors que la Vraie boucle de l'aide au programme de continuer à fonctionner après les entrées de l'utilisateur un non-entier.

OriginalL'auteur zheng yang

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.')

OriginalL'auteur Dylan

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:')

OriginalL'auteur Tossaire

Voici mon 19 lignes:

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.')

OriginalL'auteur toonarmycaptain

Je pense que cette solution peut être encore plus simple pour les apprenants que l'acceptés:

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)

Le résultat sera quelque chose comme ceci:

Enter a number: 5
16
8
4
2
1

OriginalL'auteur Noob

-1

Quelque chose qui m'a beaucoup aidé dans cette étape de mon apprentissage, c'est la compréhension qu'une fonction doit avoir un but bien précis, et l'ajout d'une boucle dans la fonction dilue.

Voici ma solution (quelqu'un m'a aidé à travailler sur ce et a abordé les mêmes erreurs que je vois dans ton code):

def collatz(number): # defining the function here. The function takes 1 argument - number.

    if number % 2 == 0: # if statement where we say that if the remainder of number by 2 is 0, then its an even number.
        even = number // 2 # assign number divided by two to a variable named even.
        print(even) # displaying that even value.
        return even # return that value.
    else: # else if number is not even.
        odd = 3 * number + 1 # then it is an odd number, and if it is an odd number then we will multiple that number by 3 and add 1.
        print(odd) # printing the odd number
        return odd # return that value

try:
    number = int(input('please enter a number:')) # number is an input from a user and here we ask the user for what input
except ValueError:
    print('Error, you must enter an integer.')


while number !=1: # while loop states that while the value of number does not equal 1...
       number = collatz(number) # ... assign the output of the collatz() function as a new value of the number, and run the collatz() function again.

"une fonction doit avoir un but bien précis, et l'ajout d'une boucle dans la fonction dilue." Ah, non. Cette directive sera vaguement utilisable (quoique totalement injustifiée) si Python n'queue appel d'élimination, mais il ne l'a pas, donc il suffit de les éviter toutes les boucles à l'intérieur des fonctions de votre rendement est garanti d'être terrible, dans certains cas, parce que votre algorithmes de force pile hits via la récursivité.
hey @NathanTuggy, merci! Une occasion d'apprentissage pour moi. Je suppose que j'ai lu quelque chose de mal, quelque part.

OriginalL'auteur kashura

Vous devez vous connecter pour publier un commentaire.