Suite de Syracuse sur Python

[robstrk]

Bonsoir, j'ai un dm de maths sur la suite de Syracuse et sur Python. Malheureusement je suis très nul sur Python, j'ai réussi à répondre aux premières questions car elles étaient simples mais pas aux suivantes
notre programme est :

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

def List_Syracuse(u):
L=[u]
while u!=1:
L.append(Syracuse(u))
u=Syracuse(u)
return L

ma question est : Ecrire un programme qui détermine la plus petite valeur de u0 qui donne un temps de vol supérieur à 100 et quelle est l'altitude de ce vol ?
Déterminer deux autres valeurs de u0 qui donnent la même altitude.

Merci beaucoup pour vos réponses et si vous pouviez aussi m'expliquer comment vous avez fait pour que je comprenne, ça serait juste fabuleux !

[GaBuZoMeu]

Tu devrais utiliser le bouton "Code" pour communiquer tes procédures python.
Là, tu écrases toutes les indentations qui sont fondamentales en python.

Est-ce que tu comprends bien ce qu'est le "temps de vol" ?
Quel rapport vois-tu avec la liste produite par la procédure List_Syracuse ?

[robstrk]

ce que j'ai compris que le temps de vol correspond au nombre de chiffres dans la liste que donne la suite de syracuse par apport à un chiffre donné
et list_syracuse permet justement de calculer le temps de vol car elle nous donne la liste

[GaBuZoMeu]

Ne confonds-tu pas chiffre et nombre ?
Les chiffres, ce sont 0,1,2,...,9.

[pierrelouisbourgeois]

Tu peux créer une nouvelle fonction U0 et utiliser l'instruction while avec la fonction liste_syracuse(u)... Par contre tu dois modifier liste_syracuse(u) pour qu'elle retourne juste le temps de vol.

[GaBuZoMeu]

Non, pas besoin de modifier. Il y a juste à utiliser la fonction python qui donne la longueur d'une liste.

Tant que j'y suis : je te montre comment, en utilisant le bouton "Code" de la fenêtre d'édition de message, on conserve la bonne indentation.

Code: Tout sélectionner

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

def List_Syracuse(u):
    L=[u]
    while u!=1:
        L.append(Syracuse(u))
        u=Syracuse(u)
    return L

Encore un ajout : dans ta procédure List_Syracuse, tu calcules deux fois Syracuse(u) à chaque boucle. Il vaut mieux ne le calculer qu'une fois :

Code: Tout sélectionner

def List_Syracuse_modif(u):
    L=[u]
    while u!=1:
        u=Syracuse(u)
        L.append(u)
    return L

Quand on a à calculer beaucoup de fois List_Syracuse, on voit la différence.
Par exemple j'ai une procédure Premier_Vol qui prend en entrée un entier n et ressort un triplet formé du plus petit u donnant une longueur de vol >= n, de la longueur du vol et de l'altitude du vol.
Avec ta procédure List_Syracuse :
In:

Code: Tout sélectionner

%time Premier_Vol_robstrk(400)

donne:

Code: Tout sélectionner

CPU times: user 10.3 s, sys: 3.97 ms, total: 10.3 s
Wall time: 10.3 s

(230631, 443, 76778008)

Avec la procédure List_Syracuse_modif :
In:

Code: Tout sélectionner

%time Premier_Vol(400)

donne:

Code: Tout sélectionner

CPU times: user 5.98 s, sys: 0 ns, total: 5.98 s
Wall time: 5.98 s

(230631, 443, 76778008)

6 secondes au lieu de 10, il n'y a pas de petites économies !

[mathelot]

ce n'est pas un souci que toutes les variables s'appellent u ?

[fatal_error]

hi mathelot,

Ici, u est un int, donc type primitif, donc copié partout (en particulier dans L)

Ca serait plus gênant, si u était une référence et que Syracuse modifiait u (ce qui n'est de toute façon pas le cas), et c'est également un faux problème puisqu'assigner la valeur à une variable nommée différemment ne changerait pas le problème de la valeur modifiée (référée par deux variables nommées différemment)

[GaBuZoMeu]

u est une variable locale à la procédure pour chacune des procédures. Son nom n'a donc pas d'importance, du moment qu'il n'y a pas de variable globale de même nom.