Salut

De préférence une procédure récursive ?

J'ai fais quelquechose, vous pouvez regarder ?

function [Un] = fibonacci(n)
if n<=2 then Un=1
else
Un = Un-1 + Un-2
end
endfunction

En maple, un programme récursif tient en qq lignes :

fibo:=proc(n)

    if n=1
           then 1
      elif n=2
           then 1
      elif n<1 then print(`n>1 stp`)
     else fibo(n-1)+fibo(n-2)
    fi:
end:


soit :

Vers le milieu :

c'est un peu ce que j'ai écrit...
J'en ai une autre mais là je n'y arrive vraiment pas...

On définit la suite (Um,n) par :
Um,0 = m
Um,n+1 = (Um,n) /2 si Um,n est pair
       = ((3Um,n) +1) /2 si Um,n est impair

Ecrire une fonction Scilab qui calcule Un en fonction de n et m.
Si vous pouvez m'aider...
Merci d'avance
A+

sûre que c'est divisé par 2 pour n impair ?

b1 oui, c'est mon énoncé...

Oui non je dis ça parce que c'est pas au mot près la suite de Syracuse mais une variante ^^ ()

Je cherche

merci

syra:=proc(m) option remember:
u[0]:=m:
k:=0:
while u[k]>2 do
    if floor(u[k]/2)=u[k]/2
        then u[k+1]:=u[k]/2
      else u[k+1]:=(3*u[k]+1)/2
    fi:
   print(u[k]):k:=k+1:
od:
end:

sachant que dès que le nombre 2 apparaît, il n'y a plus que 2 et 4 qui s'enchaînent.

syra:=proc(m) option remember:                       nom du programme, qui demande m pour tourner
u[0]:=m:                                              rentre m dans la valeur u₀
k:=0:                                                 initialise k à 0
while u[k]>2 do                                                     tant que u_k est >2 le prog tourne
    if floor(u[k]/2)=u[k]/2                            si uk est pair, alors la partie entière de uk/2 est elle-même
        then u[k+1]:=u[k]/2
      else u[k+1]:=(3*u[k]+1)/2
    fi:                                               fin du if
   print(u[k]):k:=k+1:                                 affiche uk et incrémente de 1 la valeur de k
od:                                               fin du while
end:                                          fin de la procédure

je ne comprends pas vraiment...
on ne peut pas la faire en écrivant
function[...] = ...
if....(quand vous mettez u[0]:=m...c'est l'initialisation ?)
while...(ici je ne comprends plus)

le "k" c'est m,n ?

Là je l'ai fait en maple, je ne connais pas le langage de matlab

Mais dans les grandes lignes, ça doit être la même chose.

syra:=proc(m,n) option remember:
u[0]:=m:
for k from 0 ro n do
    if floor(u[k]/2)=u[k]/2
        then u[k+1]:=u[k]/2
      else u[k+1]:=(3*u[k]+1)/2
    fi:
   print(u[k]):
od:
end:

-------------

syra(5,10);
                                  5


                                  8


                                  4


                                  2


                                  1


                                  2


                                  1


                                  2


                                  1


                                  2


                                  1

je vais y réfléchir...
merci pour votre aide.
Bonne soirée

Pardon, le message est parti.

Je viens de relire ce que tu demandes. Voici le code Maple :

au bout d'un moment (n suffisament grand), il n'y a plus que des 1 et des 2

Bonne soirée