bonjour,

qu'as tu fait ?
tu as essayé de répondre à la question 1 ?

Oui, mais je ne suis pas sûre de mes réponses :
Si n est égale au produit des n entiers inférieurs ou égal à n, donc :

u2 = 4
u3 = 9
u4 = 16
u5= 25

toi, tu fais les carrés : produit de n par lui -même.
mais l'énoncé dit : "le produit des entiers < ou =  à n"
exemple :
quand n = 6,       produit = 1*2 *3*4*5*6

rectifie ta réponse.

donc, on obtient :

u2 = 2, 4
u3 = 3,6,9
u4 = 4,8,12,16
u5 = 5,10,15,20,25

Et je peux en déduire que la relation de récurrence serait :

  u_n+1= 2u_n ...

Je ne suis pas sûre non plus de cette relation

je m'excuse je me suis trompée dans la lecture de votre réponse :
Correction :

u2 =1*2
u3 = 1*2*3
u4= 1*2*3*4
u5 = 1*2*3*4*5

On obtient donc :

u2 = 2
u3 = 6
u4= 24
u5 = 120

à présent, c'est correct  

peux tu en déduire la relation de récurrence ?

Je viens d'essayer d'établir la relation de récurrence, mais je n'y arrive pas, car je ne sais pas comment "traduire" dans ma relation le fait que u_n+1 = u_n<u*u_n ...

un+1 = un<u*un

??   d'où sors tu cela ?

la relation de récurrence, c'est dire comment tu fais pour calculer un élément quand tu connais le précédent ..

tu as calculé U2  =  2  
à partir de là, comment calcules tu   U3 ?

si je te dis que U5 = 120, comment peux tu calculer U6 (sans refaire tous les produits) ?

En faisant 120*6 ?

exactement !

U6  =   U5  *   6
U4 =    U3   *   4  

U_n+1 =    ??    *    ??

Excusez-moi pour l'attente, du coup s'y on reprend ce qu'on a dit ça donnerait un+1=un*n

presque

U_n+1  =  U_n * (n+1)    (1)
ou
U_n     =    U _n-1   *  n   (2)

à présent, avec (2), tu dois pouvoir compléter l'algorithme.  

En langage python on aurait :
  def fact (n)
           u=2
           for k in range (1,n-1)
                    u=u+1*(u-1)
           return(u)

claudinelyon,
-   la valeur de départ de U  vaut 1, pas 2.
-   regarde ce que tu écris  et compare avec ce que tu veux obtenir :
tu veux obtenir
U_n     =    U _n-1   *  n  
nouvelle valeur de  U  =    ancienne val de  U    *   rang
(le rang, c'est l'indice de U  ; dans l'algo, c'est k ).

et toi tu écris
U   =    U  +   1 (  U -1) ??

-   d''autre part,  for k in range (1,n-1)  ==>   tu vas tourner dans la boucle jusque n-1
par exemple pour calculer U6, tu feras le calcul  jusque k=5...  

ca ne colle pas.

rectifie !

D'accord :
  def fact (n)
           u=1
           for k in range (n-1)
                    u=k-1*n
           return(u)  
Je ne suis pas très sure concernant la ligne for k  in range

claudinelyon, je suis désolée, mais tu écris un peu n'importe quoi..

tu veux faire du  python, sans écrire l'algo  en langage naturel...

for k in range (1, 5)  par exemple  ça veut dire   "on tourne dans la boucle pour chaque valeur de k, on commence à k=1, on termine à k=5".

tu comprends alors que  "for k in range (n-1)"  ne colle pas..   tu commences à quoi ? tu finis à quoi ?

nous, on veut ""on tourne dans la boucle pour chaque valeur de k, on commence à k=1, on termine à k=n".
qui s'écrit   for k in range (1,n)

ensuite le calcul de U à chaque fois que tu passes dans la boucle :
nouvelle valeur de U  =  ancienne valeur de U   *    rang
je t'ai dit que le rang, c'est  k  dans l'algo.
ça donne U  =   U  * k
je ne comprends  pas pourquoi tu écris u=k-1*n      et sans les parenthèses en plus..

ca donne

def fact (n)
           u=1
           for k in range (1, n)
                    u=u * k
           return(u)  

NB  si on écrit     for k in range (2, n)  ça marche aussi !

est ce que tu comprends ?

Il est tard, je te propose de continuer demain. OK ?

Après avoir relu je comprend certains passages, mais je n'arrive pas à saisir comment on est censé trouver un-1 à partir du langage python.
Sinon, je tiens à vous remercier d'être rester avec moi jusqu'à cette heure !
A demain : )

bonjour,

"je n'arrive pas à saisir comment on est censé trouver un-1 à partir du langage python."

obtenir U_n-1  ?  
l'algo calcule les valeurs de U successives.

au départ U=1.
ensuite, on passe dans la boucle   avec k=2
on calcule U2  =  U1 * k  (  U2 = 1*2   la nouvelle valeur de U=2)
ensuite, on passe dans la boucle   avec k=3
on calcule U3  =  U2 * k   (U = 2*3   ==> U=6)
ensuite, on passe dans la boucle   avec k=4
on calcule U4  =  U3*k    (U= 6*4  ==>   U=24)
etc..

à chaque tour, tu calcules donc U_n   avec  la valeur précedente de U, soit  U_n-1

Bonjour,
Je vous remercie pour cette explication, quant à la dernière question, on aurait :

           def fact (n):
                    n=0
                     while u<=10**10
                      print (n).

l'instruction while  est correcte,
mais que fais tu tant que u <  10¹⁰, .?

là, tu ne fais pas grand chose, puisque tu ne calcules meme pas U..

Tant que u est inférieur à 10*10, on continue jusqu'à trouver la valeur de n pour que un soit supérieur à 10*10.

Donc , ça donnerait :
      def fact (n):
               n=0
               while<=10**10
                u=n+1
                print (n)

claudinelyon

lâche python, stp, on n'y arrivera pas..

En langage naturel on obtient :

n prend la valeur initiale (1 ou 0)
u prend la valeur initiale
tant que u est inférieur ou égal à 10*10
n prend la valeur n+1
afficher n

ça commence à venir !
il te manque juste encore le calcul du U suivant..

n prend la valeur initiale (1 ou 0)==> n=1
u prend la valeur initiale  ==>  U = 1
tant que u est inférieur ou égal à 10¹⁰
                  U prend la valeur   U * n
                  n prend la valeur n+1
fin tant que
afficher n

traduisons cela en python

    def fact (n):
               n=1
               u=1
               while  u<10**10
                                u= u * n
                                n = n+1
                print (n)

(vérifie la syntaxe, svp).
il reste à le faire tourner pour répondre à la question : qu'est ce l'algo affiche ?

Je vous remercie pour votre patience qu'il  vous a fallu avec moi sur cette exercice, l 'algorithme et moi ça fait 2.

je t'en prie.
Un conseil : avant de programmer (en python ou n'importe quel autre langage), il faut écrire avec tes mots comment tu ferais toi, sans algo.

tu as d'abord écrit le "tant que", puis tu avais du mal à savoir quoi faire dans la boucle.
ici, on pourrait réfléchir d'abord sur le calcul à faire, puis ensuite seulement, dire "ce calcul, on le fait tant que...".

Une fois que tu l'as bien écrit avec tes mots, tu complètes en langage naturel, avec les  variables, et seulement ensuite, tu traduis en python.

OK ?

finalement, qu'est ce que tu réponds :
quelle est le rang  n tel que Un > 10¹⁰ ?

Excusez-moi du retard, j'ai du télécharger Python et lorsque j'exécutais le programme, on m'affiche à chaque fois une erreur de syntaxe

excuse ma réponse tardive (pb de connexion).

montre moi ce que tu as tapé exactement, et quelle est l'erreur de syntaxe ?

Je m'excuse, sur le dernier message, la photo ne s'est pas attachée. La voici :

n=1
u=1
while (u<10**10):
      u=u*n
      n=n+1
print(n)

cet algo fonctionne  :     à la fin du while, tu dois mettre   :  

D 'accord je vais réessayer

et mettre ta condition entre ()

Voilà le résultat du programme :

c'est ça !

n=15,
ça veut dire que 1*2*3*4*5*6*7*8*9*10*11*12*13*14  est  <  10¹⁰
et  1*2*3*4*5*6*7*8*9*10*11*12*13*14 *15   >  10¹⁰

NB : le produit de 1 à 5  par exemple, s'appelle factorielle 5  et s'écrit   5!

donc 14! < 10¹⁰   et 15!>10¹⁰   
tu peux vérifier ta réponse avec ta calculatrice.

Bonne soirée.

Vous seriez- t-il possible de m'aider une fois de plus concernant l'exercice de la tour de Hanoï,s'il vous plait.