liste = liste_deb_0 + liste_deb_1 + liste_deb_2 return liste

• Pourn=1, la fonction renvoie la liste[[0],[1],[2]].

• Pourn=2, il y a 3²=9 éléments :[[0, 0],[0, 1],[0, 2],[1, 0],[1, 1],[1, 2],[2, 0],[2, 1],[2, 2]].

• Pour n = 3, il y a 3³ = 27 éléments : [[0, 0, 0], [0, 0, 1], [0, 0, 2],[0, 1, 0], [0, 1, 1], . . . ,[2, 2, 1], [2, 2, 2]].

Activité 3(Parcours d’arbre).

Objectifs : résoudre des problèmes en parcourant des arbres.

1. Pile ou face.

Programme une fonction

pile_ou_face(n)

qui renvoie la liste de tous les tirages possibles à pile ou face avecnlancers. Par exemple :

• pourn=1 (cas terminal), la fonction renvoie

[

'

P

'

,

'

F

'

]

(soit pile, soit face) ;

• pourn=2, elle renvoie

[

'

PP

'

,

'

PF

'

,

'

FP

'

,

'

FF

'

]

(premier tirage pile/pile, . . . ) ;

• pourn=3 :

[

'

PPP

'

,

'

PPF

'

,

'

PFP

'

,

'

PFF

'

,

'

FPP

'

,

'

FPF

'

,

'

FFP

'

,

'

FFF

'

]

^.

Indications.Base-toi sur le modèle de parcours d’arbre du cours ci-dessus avec ici deux choix au lieu de trois.

P

P

F

F

PP PF FP FF

PPP PPF PFP PFF FPP FPF FFP FFF

2. Réduire des listes emboîtées.

On considère une liste qui peut contenir des entiers, ou bien des listes d’entiers, ou bien des listes contenant des entiers et des listes d’entiers. . .

Par exemple :

[ [1,2], 3, [9,8,7,[6,5]], [[1],[2,3]] ]

On veut en extraire les éléments atomiques (les entiers) :

[1, 2, 3, 9, 8, 7, 6, 5, 1, 2, 3]

Voici comment modéliser les imbrications sous forme d’un arbre : les sommets sont soit des entiers, soit des listes. Pour les sommets qui sont des listes ses enfants sont les éléments de cette liste.

[[1, 2], 3,[9, 8, 7,[6, 5]],[[1],[2, 3]]]

[1, 2]

1 2

3 [9, 8, 7,[6, 5]]

9 8 7 [6, 5]

6 5

[[1],[2, 3]]

[1]

1

[2, 3]

2 3

Programme une fonction

une_seule_liste(liste)

qui effectue la tâche demandée. C’est assez simple avec un algorithme récursif.

• Définir une liste des éléments extraits qui au départ est une liste vide.

• Pour chaque élément de la liste :

— soit c’est un entier (cas terminal) et on l’ajoute à la liste des éléments extraits,

— soit c’est une liste (cas général) et par un appel récursif on en extrait ses éléments. On ajoute ces éléments à la liste des éléments extraits.

• Renvoyer la liste des éléments extraits.

Indications.Pour savoir si un élément est un entier ou bien une liste, tu peux utiliser la fonction

isinstance(element,type)

. Par exemple :

•

isinstance(5,int)

renvoie « Vrai »,

•

isinstance(7,list)

renvoie « Faux ».

Challenge.Essaie de programmer cette fonction sans la récursivité !

Tu trouveras une très belle application de parcours d’arbres dans la fiche « Le compte est bon ».

Activité 4(Diviser pour régner).

Objectifs : séparer un problème en deux morceaux et traiter chaque morceau de façon récursive.

1. Minimum.

Programme une fonction récursive

minimum(liste)

qui renvoie le minimum d’une liste de nombres.

Par exemple avec la liste[7, 5, 3, 9, 1, 12, 13]la fonction renvoie 1.

L’idée est de séparer la liste en une partie gauche et une partie droite.

• On traite chaque partie séparément : un appel récursif renvoie le minimum de la sous-liste de gauche et un appel récursif renvoie le minimum de la sous-liste de droite.

• Le minimum de la liste est donc le plus petit de ces deux minimums.

• Le cas terminal est lorsque la liste est de longueur 1.

2. Distance de Hamming.

Ladistance de Hammingentre deux listes de même longueur est le nombre de rangs pour lesquels éléments sont différents. Par exemple les listes[1, 2, 3, 4, 5, 6, 7]et[1, 2, 0, 4, 5, 0, 7]diffèrent à deux endroits, donc la distance de Hamming entre les deux listes vaut 2.

Programme une fonction récursive

distance_hamming(liste1,liste2)

^.

Réfléchis au cas terminal (la longueur de la liste est 1) et à comment calculer la distance de Hamming entre deux listes connaissant la distance entre les demi-listes à gauche et la distance entre les demi-listes à droites.

3. Factorielle (encore !).

Soientaet bdeux entiers avec b>0. On définit une généralisation de la factorielle : p(a,b) =a(a+1)(a+2)· · ·(b−2)(b−1)

(il y a b−afacteurs).

Par exemplep(10, 16) =10×11×12×13×14×15.

On se propose de calculer p(a,b)par la formule :

p(a,b) =p(a,a+k//2)·p(a+k//2,b) oùk= b−a.

Sur notre exemple cela revient à décomposer le produit en deux sous-produits : p(10, 16) = 10×11×12

× 13×14×15

=p(10, 13)×p(13, 16).

Transforme cette formule en un algorithme récursif et en une fonction récursive

produit(a,b)

^. Utilise ceci pour obtenir une nouvelle méthode de calcul den!

Cours 4(Dérangements).

Des couples arrivent à un bal masqué, chaque couple est déguisé en une paire deWonderwoman/Superman.

Lors de la fête les couples sont séparés et les danseurs se mélangent. Au moment du bal chaque Wonder-womandanse avec unSuperman. Quelle est la probabilité qu’aucun de ces couples de danseurs soit un couple initial ?

Pendant le bal : un exemple de mélange.

0

Permutation.On numérote lesWonderwomande 0 àn−1 et on attribue le même numéroiauSuperman en couple avec laWonderwomannuméroi.

Pendant le bal les couples se reforment et laWonderwomannuméroidanse avec n’importe lequel des Supermandu numéro 0 jusqu’au numéron−1 (y compris son légitime numéroi). On note ce couple i7→ j.

• Unepermutationest une liste d’associationsi7→ j, pouri,j dans{0, . . . ,n−1}.

• Le nombre de permutations possibles estn!

• Un exemple avecn=3 : voici les 3!=6 permutations possibles :

• Undérangementest une permutation qui vérifie i6= j, pour l’associationi7→ j et ce quel que soit i=0, . . . ,n−1.

• Les autres permutations pourn =3 ne sont pas des dérangements, par exemple la permutation suivante vérifie 17→1 donc n’est pas un dérangement :

0

• Pour les deux permutations d’ordren=5 définies en exemple ci-dessus, l’une est un dérangement et l’autre pas. Trouve qui est qui.

Modélisation.On modélise une permutation par la liste des images : 0

Une permutation d’ordrensera donc représentée par une liste dans laquelle les entiers de 0 à n−1 apparaissent chacun une fois et une seule. Voici un exemple de permutation d’ordre 5 et sa représentation par une liste :

Objectifs : calculer le nombre de dérangements par différentes méthodes.

Rappel du problème : Des couples arrivent à un bal masqué, chaque couple est déguisé en une paire deWonderwoman/Superman. Lors de la fête les couples sont séparés et les danseurs se mélangent. Au moment du bal chaqueWonderwomandanse avec unSuperman. Quelle est la probabilité qu’aucun de ces couples de danseurs ne soit un couple initial ?

Lenombre de dérangements d_n est défini par :

d₁=1 et d_n=nd_n−1+ (−1)ⁿ pourn>^2.

1. Programme une fonction

derangement_classique(n)

qui renvoied_nen utilisant une boucle.

Indications.(−1)ⁿ= +1 sinest pair et−1 sinon.

2. Programme une fonction récursive

derangement(n)

qui renvoie aussid_n. 3. La probabilité qu’aucun des couples initiaux ne soit reformé est donnée par :

p_n= d_n n!.

• Calcule cette probabilité pour de petites valeurs den.

• Compare cette probabilité avec 1/e(oùe=exp(1) =2.718 . . .).

• Est-ce que la convergence est rapide (quandn→+∞) ?

• Conclure : « Il y a environ . . . % de chance qu’aucun couple initial ne soit reformé. » 4. Dérangement ?

On se donne une permutation sous la forme d’une liste d’entiers de 0 à n−1. Programme une fonction

est_derangement(permutation)

qui teste si la permutation donnée est (ou pas) un dérangement.

Dérangement.On rappelle que pour un dérangement on n’a jamaisi7→i.

Exemple.La permutation codée par[2, 0, 3, 1]est un dérangement, la fonction renvoie « Vrai ». Par contre la permutation codée par[3, 1, 2, 0]n’est pas un dérangement, car 27→2, la fonction renvoie

« Faux ».

5. Toutes les permutations.

Programme une fonction

toutes_permutations(n)

qui renvoie la liste de toutes les permutations de longueurn.

Par exemple pourn=3, voici la liste de toutes les permutations possibles :

[[2, 1, 0], [1, 2, 0], [1, 0, 2], [2, 0, 1], [0, 2, 1], [0, 1, 2]]

Pour cela l’algorithme est basé sur un principe récursif : par exemple si on connaît toutes les per-mutations à trois éléments (voir juste au-dessus), alors on obtient les perper-mutations à 4 éléments en insérant la valeur 3 à toutes les positions possibles de toutes les permutations à 3 éléments possibles :

• notre première permutation à trois éléments[2, 1, 0], donne par insertion de 3 les permutations à quatre éléments[3, 2, 1, 0],[2, 3, 1, 0],[2, 1, 3, 0]et[2, 1, 0, 3];

• ensuite avec[1, 2, 0]on obtient[3, 1, 2, 0],[1, 3, 2, 0],[1, 2, 3, 0],[1, 2, 0, 3];

• on continue avec les autres permutations pour obtenir en tout 4!=24 permutations d’ordre 4.

Algorithme.

• — Entête :

toutes_permutations(n)

— Entrée : un entiern.

— Sortie : la liste des n! permutations d’ordren.

— Action : fonction récursive.

• Cas terminal.Sin=1 alors renvoyer la liste

[ [0] ]

(qui contient l’unique permutation à un seul élément).

• Cas général.

— On effectue un appel récursif

toutes_permutations(n-1)

qui renvoie une liste

old_liste

de permutations d’ordren−1.

— Une

new_liste

est initialisée à la liste vide.

— Pour chaque permutation de

old_liste

et pour chaquei allant de 0 àn−1, on insère le nouvel élément n−1 au rang i. On ajoute cette nouvelle permutation d’ordre n à

new_liste

^.

— On renvoie

new_liste

^. 6. Tous les dérangements.

Programme une fonction

tous_derangements(n)

qui à partir de la liste de toutes les permutations d’ordrenne renvoie que les dérangements. Vérifie sur les premières valeurs denque ce nombre de dérangements vaut biend_n.

Cours 5(Tortue

Python

^).

Voici un bref rappel des principales fonctions du module

turtle

afin de diriger la tortue de

Python

^:

•

forward(100)

/

backward(100)

^avancer/reculer de 100 pixels,

•

left(90)

/

right(90)

tourner à gauche/droite de 90 degrés,

•

goto(x,y)

aller à la position(x,y),

•

x,y = position()

récupérer les coordonnées courantes de la tortue,

•

setheading(angle)

s’orienter dans la direction donnée,

•

up()

/

down()

^lever/abaisser le stylo,

•

width(3)

^,

color(

'

red

'

)

style du tracé,

•

showturtle()

/

hideturtle()

^affiche/cache le pointeur,

•

speed(

'

fastest

'

)

pour aller plus vite,

•

exitonclick()

à placer à la fin.

Activité 6(Tortue récursive).

Objectifs : tracer des fractales à l’aide de la tortue et des algorithmes récursifs.

1. Le flocon de Koch.

Le flocon de Koch est une fractale définie par un processus récursif. À chaque étape, chaque segment est remplacé par 4 nouveaux segments plus petits formant une dent. Voici les étapes en partant d’un segment horizontal.

Définis une fonction récursive

koch(l,n)

qui trace le flocon de Koch d’ordren;`est un paramètre de longueur.

Le principe du tracé est le suivant :

• Cas terminal.Sin=0, tracer un segment de longueur`.

• Cas général.

— Tracer le flocon de Koch d’ordren−1, associé à la longueur`/3.

— Tourner un peu vers la gauche.

— Tracer le flocon de Koch d’ordren−1, associé à la longueur`/3.

— Tourner vers la droite.

— Tracer le flocon de Koch d’ordren−1, associé à la longueur`/3.

— Tourner un peu vers la gauche.

— Tracer le flocon de Koch d’ordren−1, associé à la longueur`/3.

2. Arbre binaire.

Adapte la fonction précédente en une fonction

arbre(l,n)

pour dessiner des arbres dont la profon-deur dépend d’un paramètren(`est un paramètre de longueur).

Voici les dessins pourn=1,n=2,n=3 etn=6.

3. Triangle de Sierpinski.

Trace les différentes étapes qui conduisent au triangle de Sierpinski par une fonction récursive

triangle(l,n)

⁽`est un paramètre de longueur,nest un paramètre de profondeur).

Voici les dessins pourn=1,n=2,n=3 etn=6.

Le principe récursif est le suivant :

• Sin=0 ne rien faire.

• Sinon répéter trois fois :

— faire un appel récursif

triangle(l/2,n-1)

^,

— avancer de`pas,

— tourner de 120 degrés.

4. Courbe de Hilbert.

Trace les premiers pas de la courbe de Hilbert à l’aide d’une fonction récursive

hilbert(angle,n)

^. Le tracé récursif se fait selon le principe expliqué ci-dessous,`est une longueur fixée à l’avance,θ est l’angle qui vaut±90 degrés,nest l’ordre du tracé.

• Sin=0 ne rien faire.

• Sinon :

— tourner à gauche de−θ,

— faire un appel récursif avec comme paramètres−θ et l’ordren−1,

— avancer de la longueur`,

— tourner à gauche de+θ,

— faire un appel récursif avec comme paramètres+θ et l’ordren−1,

— avancer de la longueur`,

— faire un appel récursif avec comme paramètres+θ et l’ordren−1,

— tourner à gauche de+θ,

— avancer de la longueur`,

— faire un appel récursif avec comme paramètres−θ et l’ordren−1,

— tourner à gauche de−θ.

Voici les dessins pour l’angle initial valantθ= +90 degré et des ordresnallant de 1 à 6.

5. Fractale aléatoire.

Programme une fonction récursive

fractale_cercle(l,n)

qui contient une part d’aléatoire. La fonction dessine un quart de cercle, puis décide au hasard (une chance sur deux par exemple) si elle trace un plus petit cercle par un appel récursif, ensuite elle continue avec le tracé d’un quart du cercle initial et décide alors de tracer éventuellement un plus petit cercle. . .

Voici des dessins pourn=1,n=2,n=3 etn=4. Bien sûr d’une fois sur l’autre le dessin change au hasard.

Dans le document – Suites géométriques 1 (Page 93-103)