Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

FIBONACCI ITÉRATIF ET RÉCURSIF


Information sur la source

Catégorie :Math & Algorithmes Classé sous : fibonacci, générateur, suite fibonacci Niveau : Débutant Date de création : 06/02/2008 Date de mise à jour : 08/02/2008 17:20:59 Vu / téléchargé: 3 235 / 42

Note :
Aucune note

Commentaire sur cette source (8)
Ajouter un commentaire et/ou une note

Description

Ce petit bout de script permet de calculer de différentes façons les termes de la suite de fibonacci.
De plus pour chaque méthodes on a accès au calcul direct et au générateur.
La complexités respective sont O(2^n) pour la méthode récursive et O(n) pour la méthode itérative
 

Source

  • #iterative implementation
  • #complexity O(n)
  • def fibo_it(i):
  • a,b,cpt=0,1,0
  • while cpt <= i:
  • if cpt < 2 :
  • c = cpt
  • else :
  • c=a+b
  • a=b
  • b=c
  • cpt+=1
  • return c
  • #iterative implementation of generator
  • def fibogen_it(i):
  • a,b,cpt=0,1,0
  • while cpt <= i:
  • if cpt < 2 :
  • c = cpt
  • else :
  • c=a+b
  • a=b
  • b=c
  • cpt+=1
  • yield c
  • #simple recursive implementation
  • #complexity O(2^n)
  • def fibo_rec(i):
  • if i < 2 :
  • return i
  • return fibo_rec(i-1)+fibo_rec(i-2)
  • #recursive implementation of generator
  • def fibogen_rec(i):
  • for j in range(i) :
  • yield fibo_rec(j)
#iterative implementation
#complexity O(n)
def fibo_it(i):
	a,b,cpt=0,1,0
	while cpt <= i:
		if cpt < 2 :
			c = cpt
		else :	
			c=a+b	
			a=b
			b=c
		cpt+=1
	return c

#iterative implementation of generator
def fibogen_it(i):
	a,b,cpt=0,1,0
	while cpt <= i:
		if cpt < 2 :
			c = cpt
		else :	
			c=a+b	
			a=b
			b=c
		cpt+=1
		yield c

#simple recursive implementation
#complexity O(2^n)
def fibo_rec(i):
	if i < 2 :
		return i
	return fibo_rec(i-1)+fibo_rec(i-2)

#recursive implementation of generator
def fibogen_rec(i):
	for j in range(i) :
		yield fibo_rec(j)

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

Historique

06 février 2008 00:35:30 :
orthographe + ajout du zip
08 février 2008 17:20:59 :
ajout des complexités

Commentaires et avis

signaler à un administrateur
Commentaire de coucou747 le 08/02/2008 13:38:35

ta fonction recursive est de complexite 2 ^ n et ca c'est mal...

en caml, tu peux le faire en recursif, en complexite n :

let fibo n = let rec a = function | (f0, f1, 1) -> f1 | (f0,
f1, n) -> a( f1, f1+f0, n-1 ) in a (1, 1, n);;

l'idee, c'est de balader un couple de valeurs et pas une valeur

signaler à un administrateur
Commentaire de Renfield le 08/02/2008 15:40:31 administrateur CS

En C je ferai:

long Fibonacci(long Rank)
{
long n1,n2;
if (Rank==0)
return 0;
if (Rank<=2)
return 1;

Rank-=3;

if (Rank & 1) {
n1 = 2;
n2 = 1;
Rank--;
}
else
n1 = n2 = 1;

while(Rank) {
n2 = n1 + n2;
n1 = n1 + n2;
Rank-=2;
}

return n1+n2;
}

signaler à un administrateur
Commentaire de Renfield le 08/02/2008 16:11:06 administrateur CS

le même, en ASM (pour VS)





__declspec(naked) long __fastcall Fibonacci(long Rank)
{
__asm {
test ecx, ecx
jz ZERO
cmp ecx, 2
jle LETWO
mov edx, 1
sub ecx, 3
test ecx, 1
jz PAIR
mov eax, 2
dec ecx
jmp CALCUL
PAIR:
mov eax, 1
CALCUL:
add edx, eax
add eax, edx

sub ecx, 2
jnz CALCUL
END:
add eax, edx
ret
ZERO:
xor eax, eax
ret
LETWO:
mov eax, 1
ret
}
}

signaler à un administrateur
Commentaire de djackows le 08/02/2008 17:18:21

L'idée du code récursif était d'être compacte.
Bien sur la complexité d'un tel code est horrible !
Je vais éditer pour indiquer la complexité des méthodes, mais tu remarqueras que la fonction itérative est  déjà en O(n).
En fait j'ai ajouter ce code car j'étais surpris qu'il ne soit pas sur Codes-Sources ! Il faut faire vivre python c'est tellement joli !

signaler à un administrateur
Commentaire de BruNews le 08/02/2008 18:49:38 administrateur CS

à la demande de Renfield:

Avant tout, on optimise l'algo en C qui a l'avantage de s'écrire comme on respire. L'ASM coulera de source ensuite et sera d'ailleurs inutile sur un algo aussi simple, le compilo sortira direct un ASM optimal si on lui a bien expliqué en C ce qu'on veut.
Suffit pour Fibo de placer la valeur de sortie en 1er et on aura au maxi qu'1 seul saut de code vers la sortie unique vu que EAX deja mis.

DWORD __fastcall FibonacciC(DWORD Rank)
{
  DWORD vret = 0, n2 = 0;
  if(Rank == 0) goto fiboEXIT;
  vret = 1;
  if(Rank <= 2) goto fiboEXIT;
  n2 = 1;
  if((Rank -= 3) == 0) goto goRET;
  if(Rank & 1) {
   vret = 2;
   if(--Rank == 0) goto goRET;
  }
  do {
    n2 += vret;
    vret += n2;
  } while(Rank -= 2);
goRET: vret += n2;
fiboEXIT: return vret;
}

__declspec(naked) DWORD __fastcall FibonacciASM(DWORD Rank)
{ // ECX = Rank
  __asm {
    xor   eax, eax
    test  ecx, ecx
    je    short fiboEXIT
    mov   eax, 1
    cmp   ecx, 2
    jbe   short fiboEXIT
    sub   ecx, 3
    mov   edx, eax
    je    short goRET
    test  cl, al
    je    short goDO
    sub   ecx, edx
    lea   eax, [edx+1]
    je    short goRET
goDO:
    add   edx, eax
    add   eax, edx
    sub   ecx, 2
    jne   short goDO
goRET:
    add   eax, edx
fiboEXIT:
    ret     0
  }
}

signaler à un administrateur
Commentaire de coucou747 le 08/02/2008 19:21:53

mais lol...
pour des maths, on en a quoi a faire du C ou de l'asm ?
le C, ca peut se comprendre pour la vitesse, mais pour cette fonction, osef en fait, vu qu'on depasse la taille d'un int tres vite, une complexite O(n) et pas O(2^n) suffit, on est pas oblige de chercher le mili-cycle ni le O(1)... (il parait qu'une solution en O(1) existe)

mon code caml est recursif et compacte...
let fibo n = let rec a = function | (f0, f1, 1) -> f1 | (f0, f1, n) -> a( f1, f1+f0, n-1 ) in a (1, 1, n);;
une ligne...
il est de complexite O(n), et est relativement rapide
en python, je ne saurais pas le recoder, desole

signaler à un administrateur
Commentaire de BruNews le 08/02/2008 19:31:13 administrateur CS

autant à faire que du caml... vu qu'on connait python aussi bien que toi.

Sérieux, tu as déjà vu une lib maths en interprété profond ?

signaler à un administrateur
Commentaire de coucou747 le 08/02/2008 19:39:56

caml et python offrent de nombreux modes d'executions... python est compile en bytecode avant d'etre interprete, il peut etre compile en bytecode java aussi.
ocaml peut-etre interprete ou compile en bytecode ou en binaire classique.

Ajouter un commentaire



Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Téléchargements

Logiciels à télécharger sur le même thème :

Comparez les prix Nouvelle version

Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,655 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.