begin process at 2012 02 05 00:02:44
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Math & Algorithmes

 > FIBONACCI ITÉRATIF ET RÉCURSIF

FIBONACCI ITÉRATIF ET RÉCURSIF


 Information sur la source

Note :
Aucune note
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é :8 017 / 61

Auteur : djackows

Ecrire un message privé
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

Les Membres Club peuvent 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

 Sources de la même categorie

Source avec Zip BASE64 ENCRYPT/DECRYPT PYTHON BY MAXOU56800 par Maxou56800
Source avec Zip Source avec une capture TRIANGULATION par mecrosoft
Source avec Zip Source avec une capture COURBE DE BEZIER par mecrosoft
Source avec Zip Source avec une capture CALCUL D'AIRE D'UN TRIANGLE [INTERFACE GRAPHIQUE] par SeventhSon
Source avec Zip Source avec une capture SUITE DE FIBONACCI [INTERFACE GRAPHIQUE] par SeventhSon

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture SUITE DE FIBONACCI [INTERFACE GRAPHIQUE] par SeventhSon
Source avec Zip Source avec une capture GÉNÉRATEUR DE PASSWORD par PlugnPlay666
Source avec Zip Source avec une capture GÉNÉRATEUR DE MOTS ALÉATOIRES par lomar et lomar
Source avec Zip Source avec une capture ALBUMEUR PHOTO: SCRIPT DE CRÉATION D'ALBUM PHOTO EN HTML À P... par vychnou
GÉNÉRATEUR DE MOT DE PASSE par neoboy_84

Commentaires et avis

Commentaire de coucou747 le 08/02/2008 13:38:35 administrateur CS

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

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;
}

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

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 !

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

Commentaire de coucou747 le 08/02/2008 19:21:53 administrateur CS

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

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 ?

Commentaire de coucou747 le 08/02/2008 19:39:56 administrateur CS

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

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

Photothèque

 
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

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,810 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales