TD 3 - Fonctions
1. La fonction tordue
•Ecrire une fonction qui prend comme argument un réelx∈Rpuis qui renvoie la valeur def(x) =
x si x60 ex si x∈]0,1[
ln(x+1) si x>1 ( on écrira une fonction d'entête def f(x) )
•Ecrire ensuite un programme qui demande un entiern∈Npuis qui ache la valeur deunoù
( u0= 2
∀k∈N, uk+1=f(u2k)−f(uk) ( pourn= 10, votre programme devra trouver 0.082591 )
2. Suite complexe
On choisit de modéliser un nombre complexez=a+ibaveca, b∈Rcomme un tableau de 2 réels : z = [a,b]
Par exemple, le tableau [1,1] modélise le complexe1 +i.
•Ecrire deux fonctions add(z1,z2) et mult(z1,z2) qui prennent en paramètres deux complexesz1etz2et qui renvoient leur somme pour add et leur produit pour mult.
•On considère la suite complexe dénie parz0= 1 +i
2 et∀n∈N,zn+1=zn2+ (1−i)zn+i.
Ecrire un programme qui calculez5. ( votre programme devra trouver [-133603.77586364746, 51956.5458984375] ) 3. Méthode de Monte Carlo : calcul empirique d'une moyenne
Ta mère lance une pièce jusqu'à obtenir son 10-ième PILE. On noteM son nombre de lancers.
Ta soeur lance une pièce jusqu'à obtenir son 10-ième PILE. On noteS son nombre de lancers.
On se demande combien de lancers sont nécessaires en moyenne à celle qui a mis le plus grand nombre de lancers pour obtenir son 10-ième PILE.
• Ecrire une fonction X() qui ne prend pas de paramètre et qui simule la variable aléatoire égale au nombre de lancers nécessaires pour obtenir le 10-ième PILE au cours d'une suite de lancers.
(cette fonction renverra donc un entier entre 1 et+∞)
• Ecrire une fonction PlusGdNb() qui simule les suites de lancers de ta mère et ta soeur et qui renvoie le plus grand nombre de lancers qui a été nécessaire entre ta mère et ta soeur pour obtenir leur 10-ième PILE.
• Ecrire un programme qui simule 1000 fois l'expérience décrite ci-dessus, puis qui ache alors une valeur numérique approchée de la moyenne recherchée, basée sur les 1000 expériences.
( Votre programme devra trouver environ 22.5 )
4. Recherche d'un mot dans un texte (Exercice au programme ociel)
•Ecrire une fonction LeMotEstIci(mot,texte,pos), et qui renvoie True si le string mot se trouve dans le string texte exactement à partir de la position pos dans texte, et qui renvoie False sinon.
On fera attention à ce que la fonction LeMotEstIci ne plante jamais, même si l'entier pos passé en paramètre risque de faire dépasser des bornes. Par exemple :
LeMotEstIci ( "go" , "le go est lent" , 12345) renvoie False, mais ne plante pas le programme LeMotEstIci ( "go" , "le go est lent" , 2) renvoie False
LeMotEstIci ( "go" , "le go est lent" , 3) renvoie True
( On rappelle en eet que le 1er caractère d'un string est en position 0, et non pas 1 )
•Ecrire ensuite un programme qui demande un mot et un texte et qui renvoie True si ce mot apparaît dans le texte, et qui renvoie False sinon.
5. Le mot le plus long Le but est de faire un programme qui devine le mot le plus long que l'on peut faire avec des lettres données, comme dans le célèbre jeu télévisé.
• Ecrire une fonction OnPeutFaire(mot, lettres) qui prend comme paramètres deux strings, et qui renvoie True s'il est possible de faire mot avec les lettres du string lettres, et qui renvoie False sinon. Par exemple :
OnPeutFaire( "toto", "ttoarr" ) devra renvoyer False, car il manque un o pour faire toto OnPeutFaire( "toto", "ttofro" ) devra renvoyer True
Indication : un algorithme possible est de créer la variable alpha = "abcdefghijklmnopqrstuvwxyz", puis de compter la fréquence de chaque lettre dans mot et dans lettre.
Si une lettre apparaît strictement plus de fois dans mot que dans lettre, alors OnPeutFaire devra renvoyer False.
•Ecrire un programme qui enregistre un dictionnaire français de 5 mots : Dico = ["vivement" , "les" , "vacances" , "bon" , "sang"]
puis qui demande à l'utilisateur d'entrer des lettres, et qui renvoie :
−→"Rien trouvé" si aucun mot du dictionnaire n'est faisable avec les lettres
−→le mot le plus long faisable avec les lettres, si cela est possible
Par exemple, si l'utilisateur entre les lettres "bgnsortta" le programme devra acher "sang"
1
6. Les allumettes
On considère 55 allumettes réparties en tas. (par exemple : 10 tas de 5 allumettes, un tas de 4, et un tas de 1)
Appliquer "la transformation" consiste à prendre une allumette de chaque tas (ce qui fait disparaître les tas de 1 allumette) et à créer un nouveau tas avec les allumettes ainsi ramassées.
On admet que quelque soit la répartition initiale d'allumettes, on nit toujours par arriver à la même répartition d'allu- mettes au bout d'un certain nombre de transformations.
•Ecrire une fonction CreerTas() qui ne prend aucun paramètre, et qui renvoie un tableau de 6 cases, dont les 5 premières sont des nombres au hasard entre 1 et 10, et dont la somme des 6 cases fasse 55.
Par exemple, CreerTas() pourra renvoyer [6, 5, 1, 9, 9, 25]
• Ecrire une fonction Transfo(a) qui prend un argument un tableau a modélisant le nombre d'allumettes dans chaque tas, et qui renvoie un tableau modélisant le nombre d'allumettes dans chaque tas après "la transformation".
Par exemple, Transfo([10, 6, 4, 4, 6, 25]) pourra renvoyer [9, 5, 3, 3, 5, 24, 6]
• A l'aide de plusieurs tests avec "CreerTas()", constater que "la transformation" dirige toujours les tas d'allumettes vers un point xe de "la transformation".
7. Suite de Conway
On poseu0= 1. Les termes successifs de la suite de Conway sont obtenus en énumérant les chires composant le terme précédent :
u0= 1ce qui s'écrit avec un "1", donc on poseu1= 11 u1= 11ce qui s'écrit avec deux "1", donc on poseu2= 21
u2= 21ce qui s'écrit avec un "2" puis un "1", donc on poseu3= 1211
u3= 1211ce qui s'écrit avec un "1", un "2", puis deux "1", donc on poseu4= 111221, et ainsi de suite . . .
• Ecrire une fonction Transfo(u) qui prend en paramètre une chaine de caractères u correspondant à un terme de la suite de Conway, et qui renvoie un string représentant le terme suivant de la suite de Conway.
Par exemple, Transfo("1211") devra renvoyer 111221
•Ecrire alors un programme qui ache les 10 premiers termes de la suite de Conway.
8. Les permutations
Ecrire une fonction NextPermut(a) qui prend un argument un tableau contenant les permutations des premiers entiers naturels non nuls, et qui renvoie la prochaine "plus petite permutation" de ces entiers par ordre alphabétique :
Par exemple, NextPermut([3,4,5,1,2]) renverra [3,4,5,2,1]
NextPermut([4,5,3,2,1]) renverra [5,1,2,3,4]
NextPermut([5,3,4,2,1]) renverra [5,4,1,2,3]
On s'arrangera pour que NextPermut([5,4,3,2,1]) renvoie [1,2,3,4,5].
On pourra vérier qu'en eecutant5! = 120fois l'opération a=NextPermut(a) on revient à la permutation initiale si on est parti de a=[1,2,3,4,5].
2
