Telechargé par odaim

Algorithmes Complexite

publicité
Algorithmique et Programmation - Banque d'exercices
Remarque : jusqu'en 2018, les conventions du langage algorithmique étaient un peu différentes
– les tableaux sont dynamiques (la taille n'est pas forcément fixée à la déclaration) et l'opération redim
permet de fixer la taille d'un tableau.
– les tableaux et enregistrements sont supposés être toujours passés par référence, les autres
paramètres par valeur.
Thème : algorithmes et complexité
1- Anagramme sans doublon (30 mn - 2009) - Correction
2- Anagramme avec doublon (45 mn - 2009) - Correction
3- Tri à la bretonne (75 mn - 2010) - Correction
4- Élimination des doublons (60 mn - 2010) - Correction
5- Tous différents (30 mn - 2011) - Correction
6- Supérieurs (30 mn - 2011) - Correction
7- Découpage de tableau (45 mn - 2012) - Correction
8- Inversion de tableau (30 mn - 2014) - Correction
9- Numération romaine (30 mn -2015) - Correction
10- Racine entière (30 mn - 2016) - Correction
11- Occurences de lettres (45 mn - 2016) - Correction
12- Comparaison de mots (60mn) - Correction
1- Anagramme sans doublon (30 mn)
Un mot est anagramme d'un autre s'ils sont écrits avec les mêmes lettres, par exemple, algorithme et
logarithme, ou imaginer et migraine. On travaille avec des mots stockés dans des tableaux de caractères. On
suppose que ces tableaux sont sans doublon (un caractère n'est présent au plus qu'une fois dans chaque
tableau).
1- Écrire une fonction qui prend en entrée deux tableaux de caractères représentant deux mots et
renvoie vrai si ces mots sont anagrammes l'un de l'autre et faux sinon.
2- Calculer la complexité au pire de la fonction précédente en expliquant quel est le pire cas et en
expliquant les calculs.
2- Anagramme avec doublon (45 mn)
Un mot est anagramme d'un autre s'ils sont écrits avec les mêmes lettres, par exemple, algorithme et
logarithme, ou imaginer et migraine. On travaille avec des mots stockés dans des tableaux de caractères. On
suppose que des doublons peuvent exister dans les tableaux (chaque caractère d'un tableau peut y apparaitre
plusieurs fois). On donne la fonction suivante :
// renvoie le nombre d'occurences de c dans t
fonction avec retour entier occurences(caractere c, caractere[] t)
entier result,i;
debut
result <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
si (t[i] == c) alors
result <- result + 1;
finpour
retourne result;
fin
1- Écrire une fonction qui prend en entrée deux tableaux de caractères représentant deux mots et
renvoie vrai si ces mots sont anagrammes l'un de l'autre et faux sinon.
2- Calculer la complexité en temps au pire de la fonction précédente en expliquant quel est le pire cas et
en expliquant les calculs.
3- Tri à la bretonne (75 mn)
En Bretagne, les crêpes sont faites sur des biligs (sortes de poêles) sans bords, et il est donc difficile de
faire des crêpes toutes de même taille. Mais une fois qu'une pile de crêpes de tailles différentes est prête, il
existe une méthode simple pour trier les crêpes de la plus grande à la plus petite.
Pour placer la plus grande crêpe en dessous de la pile, on glisse la pelle sous la crêpe la plus grande et
on retourne la pile des crêpes qui se trouvent au dessus de la pelle, ce qui place la crêpe la plus grande tout en
haut de la pile. Puis on glisse la pelle sous la crêpe la plus basse et on retourne toute la pile de crêpes, ce qui
place la crêpe la plus grande tout en bas de la pile. Pour trier toute la pile, il suffit de recommencer l'opération
sur le reste de la pile.
Dans cet exercice, le tas de crêpes est représenté par un tableau d'entiers (les entiers peuvent être vus
comme les diamètres des crêpes).
1- Écrire une fonction qui prend en paramètres un tableau d'entiers t et deux entiers i et j, et inverse
l'ordre des éléments dont les indices sont compris entre i et j inclus. Par exemple, appeler la fonction avec t =
[1,3,4,2,7,3], i = 1 et j = 4 conduira à t = [1,7,2,4,3,3]. On peut supposer que i et j sont compris entre 0 et la
longueur de t moins un et que i < j.
2- Écrire une fonction qui prend en paramètres un tableau d'entiers t et un entier i et renvoie l'indice du
plus grand élément parmi ceux d'indices inférieurs ou égal à i.
3- Écrire une fonction qui prend en paramètre un tableau d'entiers t et le trie par la méthode du tri
breton.
4-Donner, en justifiant vos calculs, les complexités des deux premières fonctions, puis celle de la
fonction de tri (on pourra se limiter à la complexité au pire).
4- Élimination des doublons (60 mn)
On veut éliminer les doublons dans des tableaux de caractères.
1- Écrire une fonction qui prend en paramètre un tableau de caractères t, un caractère c et un entier i
supposé compris entre 0 et la longueur du tableau-1, et renvoie vrai si le caractère c apparait dans le tableau t
dans une case d'indice compris entre 0 et i inclus.
2- Écrire une fonction qui prend en paramètre un tableau de caractères t pouvant contenir des doublons
et renvoie un tableau de caractères contenant les mêmes caractères que le premier, mais sans doublon. On
peut utiliser la méthode suivante :
- parcourir une première fois le tableau t pour compter le nombre de caractères différents qu'il contient
(la fonction du 1 peut être utile).
- créer un deuxième tableau t2 de taille égale au nombre de caractères différents contenus dans t.
- parcourir t et remplir t2 avec les caractères contenus dans t, mais sans doublon.
3- Calculer la complexité en temps au pire de la fonction précédente en expliquant quel est le pire cas et
en expliquant les calculs.
5- Tous différents (30 mn)
1- Écrire un algorithme qui prend en paramètre un tableau d'entiers et renvoie vrai si tous les entiers du
tableau sont différents les uns des autres, et faux sinon.
2- Indiquer quel est le pire cas d'exécution de cet algorithme du point de vue du temps d'exécution.
Donner, en justifiant les calculs, la complexité temporelle au pire de cet algorithme.
6- Supérieurs (30 mn)
1- Écrire un algorithme de complexité temporelle logarithmique qui prend en paramètre un tableau
d'entiers supposés tous différents et triés dans l'ordre croissant, et un entier e et renvoie le nombre d'entiers du
tableau supérieurs strictement à e. Par exemple, l'appel de l'algorithme sur le tableau [2,4,7,8,12,45] et sur
l'entier 7 renverra 3.
2- Indiquer quel est le pire cas d'exécution de l'algorithme du point de vue du temps d'exécution. Justifier
la complexité temporelle logarithmique au pire de cet algorithme.
7- Découpage de tableau (45 mn)
1- Écrire une fonction qui prend en paramètre un tableau de caractères t et un entier i et découpe t en
plusieurs tableaux de caractères de taille i. La fonction doit renvoyer un tableau de tableau de caractères
regroupant tous les morceaux générés. Par exemple, si la fonction est appelée sur le tableau
['d','e','c','o','u','p','a','g','e'] et l'entier 3 le résultat sera [['d','e','c'],['o','u','p'],['a','g','e']]. Si la longueur du tableau t
n'est pas un multiple de i, le dernier tableau généré sera complété par des blancs. Par exemple, si la fonction
est appelée sur le tableau ['d','e','c','o','u','p','a','g','e']} et l'entier 2, le résultat sera [['d','e'],['c','o'],['u','p'],['a','g'],['e','
']].
2- Indiquer quel est le paramètre de complexité de cette fonction, et calculer la complexité temporelle de
cette fonction.
8- Inversion de tableau (30 mn)
La fonction ci_dessous inverse l'ordre des éléments d'un tableau de réels. Elle est optimisée pour
n'échanger deux éléments que s'ils sont différents.
fonction sans retour inverse(reel[] t)
reel j; entier i;
début
pour (i allant de 0 à t.longueur/2 pas 1) faire
si (t[i] ≠ t[t.longueur-1-i]) alors
j <- t[i];
t[i] <- t[t.longueur-1-i];
t[t.longueur-1-i] <- j;
finsi
finpour
fin
Donner le paramètre de complexité de la fonction, indiquez le cas échéant s'il existe des cas au mieux et
au pire et calculez la complexité de la fonction (dans les cas au mieux et au pire s'ils existent, dans le cas
général sinon).
9- Numération romaine (30 mn)
On veut réaliser des calculs en chiffres romains. On a déjà une fonction qui traduit chaque chiffre romain
en son équivalent en chiffres arabes :
fonction avec retour entier equivalent(caractère c)
début
si (c = 'I') alors retourne 1; finsi
si (c = 'V') alors retourne 5; finsi
si (c = 'X') alors retourne 10; finsi
si (c = 'L') alors retourne 50; finsi
si (c = 'C') alors retourne 100; finsi
si (c = 'D') alors retourne 500; finsi
si (c = 'M') alors retourne 1000; finsi
retourne 0;
fin
Le principe pour traduire en chiffres arabes un nombre écrit en chiffres romains est le suivant : si le
premier chiffre du nombre romain a une valeur inférieure au deuxième, alors on le soustrait de la valeur de tout
le reste, sinon on l'additionne à la valeur de tout le reste.
1- Écrire une fonction qui prend en paramètre un tableau de caractères représentant un nombre écrit en
chiffres romains et retourne sa valeur entière.
2- Indiquer le paramètre de complexité de la fonction récursive. Indiquer s'il existe des cas au mieux ou
au pire, et calculer la complexité de la fonction dans le cas au pire s'il existe, dans le cas général sinon.
10- Racine entière (30 mn)
1- Écrire une fonction racine qui prend un entier en paramètre et renvoie sa racine carrée entière. La
racine carrée entière d'un entier e est le plus grand nombre entier r tel que r ² ≤ e. Par exemple la racine carrée
entière de 3 est 1, la racine carrée entière de 10 est 3.
2- Donnez le paramètre de complexité de la fonction racine. Indiquez le cas échéant s'il existe des cas
au mieux et au pire et calculez la complexité de la fonction (dans le cas au pire s'il existe, dans le cas général
sinon).
11- Occurences de lettres (45 mn)
On veut obtenir le nombre d'occurences de chaque lettre dans un mot donné et afficher ces nombres à
l'écran. On se limite aux lettres minuscules non accentuées. Par exemple, si le mot traité est
anticonstitutionnellement, le programme va afficher :
a : 1 fois
b : 0 fois
c : 1 fois
d : 0 fois
e : 3 fois
...
z : 0 fois
1- Écrire une fonction qui prend en entrée un mot, sous forme d'un tableau de caractères, et qui affiche
le nombre d'occurences de chaque lettre dans le mot (le type caractère est doté de l'opération + qui permet de
passer au caractère suivant. Par exemple 'a'+1 donne 'b', 'b'+1 donne 'c', etc.).
2- Indiquer le paramètre de complexité de la fonction. Indiquez s'il existe des cas au mieux ou au pire, et
calculez la complexité de la fonction dans le cas au pire s'il existe, dans le cas général sinon.
12- Comparaison de mots (60mn)
Le but de cet exercice est d'écrire des fonctions permettant de comparer des mots représentés par des
tableaux de caractères. Par exemple, le mot Bonjour sera représenté par le tableau char[] t ←
{'B','o','n','j','o','u','r'}. Ces fonctions peuvent entre autres être utilisées pour la recherche de
documents par mots-clés, dans un moteur de recherche par exemple.
1- Écrire une fonction qui prend en paramètres deux tableaux de caractères et renvoie vrai ou faux selon
que le premier est ou non le début du deuxième, c'est-à-dire si le contenu du deuxième est identique au contenu
du premier, mais avec des cases supplémentaires à la fin. Par exemple, l'appel de la fonction sur les tableaux
['c','h','a','t'] et ['c','h','a','t','o','n'] renvoie vrai, et son appel sur les tableaux ['c','h','a','t'] et ['c','h','a','p','i','t','r','e']
renvoie faux.
2- Écrire une fonction qui prend en paramètres deux tableaux de caractères et renvoie l'indice à partir
duquel on trouve les éléments du premier tableau, tels quel, dans le deuxième tableau. La fonction renvoie -1 si
le contenu du premier tableau n'apparaît pas dans le deuxième. Par exemple, l'appel de la fonction sur les
tableaux ['c','h','a','t'] et ['a','c','h','a','t','-','v','e','n','t','e'] renvoie 1, son appel sur les tableaux ['c','h','a','t'] et
['q','u','e','l','b','e','a','u','c','h','a','t'] renvoie 8, et son appel sur les tableaux ['c','h','a','t'] et ['c','h','o','c','o','l','a','t']
renvoie -1.
3- Écrire une fonction qui prend en paramètres deux tableaux de caractères et renvoie -1 si le deuxième
représente un mot plus petit, au sens lexicographique, que le premier, 0 si les 2 tableaux représentent le même
mot, et 1 si le premier représente un mot plus petit, au sens lexicographique, que le deuxième (l'ordre
lexicographique est l'ordre du dictionnaire). Par exemple, l'appel de cette fonction sur les tableaux ['c','h','a','t'] et
['c','h','i','e','n'] renvoie 1, et l'appel de cette fonction sur les tableaux ['c','h','i','e','n'] et ['c','h','a','t'] renvoie -1. On
suppose que les opérateurs <, ≤, > et ≥ existent sur les caractères.
1- Anagramme sans doublon - CORRECTION
// renvoie vrai si c est dans t, faux sinon
fonction avec retour booleen appartient(caractere c, caractere[] t)
entier i;
booleen b;
debut
b <- faux;
i <- 0;
tantque (i<t.longueur et non b) faire
si (t[i] = c) alors
b <- vrai;
finsi
i <- i+1;
fintantque
retourne b;
fin
// renvoie vrai si t1 et t2 sont anagrammes l'un de l'autre, faux sinon
fonction avec retour booléen anagramme(caractere[] t1, caractere[] t2)
entier i;
booléen b;
debut
b <- faux;
si (t1.longueur == t2.longueur) alors
i <- 0;
b <- vrai;
tantque (i<t1.longueur et b) faire
si (!appartient(t1[i],t2)) alors
b <- faux;
finsi
i <- i;
fintantque
finsi
retourne b;
fin
Le cas au pire pour la fonction appartient
n'est pas dans le tableau. Dans ce cas, si on
l'exécution de la fonction demande n tours de
fonction est donc de la forme n*a + b = O(n) avec
est celui où le caractère cherché
appelle n la taille du tableau,
boucles et la complexité de la
a et b des constantes.
Le cas au pire pour la fonction anagramme est celui où les deux mots sont
anagrammes l'un de l'autre (et donc de même taille) car dès qu'on trouve un
caractère de t1 qui n'est pas dans t2, la boucle tantque s'arrête. Dans ce cas au
pire, si on appelle n la taille des deux tableaux, la complexité de anagramme sera
c + n*O(n) où O(n) est le coût de l'exécution de la fonction appartient et c une
constante. On a donc une complexité en O(n²).
2- Anagramme avec doublons - CORRECTION
// renvoie vrai si t1 et t2 sont anagrammes l'un de l'autre, faux sinon
fonction avec retour booleen anagramme(caractere[] t1, caractere[] t2)
entier i;
booléen b;
debut
b <- faux;
si (t1.longueur == t2.longueur) alors
i <- 0;
b <- vrai;
tantque (i<t1.longueur et b) faire
si (occurences(t1[i],t1) != occurences(t1[i],t2)) alors
b <- faux;
finsi
i <- i;
fintantque
finsi
retourne b;
fin
Le cas au pire pour la fonction occurences est celui où toutes les cases du
tableau contiennent le caractère cherché (l'incrémentation de result a alors lieu à
chaque tour de boucle). Dans ce cas, si on appelle n la taille du tableau,
l'exécution de la fonction demande n tours de boucles et la complexité de la
fonction est donc de la forme n*a + b = O(n) avec a et b des constantes.
Le cas au pire pour la fonction anagramme est celui où les deux mots sont
anagrammes l'un de l'autre (et donc de même taille) car dès qu'on trouve un
caractère de t1 qui n'a pas le même nombre d'occurences dans t2, la boucle tantque
s'arrête. Dans ce cas au pire, si on appelle n la taille des deux tableaux, la
complexité de anagramme sera de la forme c + n*2*O(n) = O(n²) (où c est une
constante et O(n) est le coût de l'exécution de la fonction occurences).
3- Tri à la bretonne - CORRECTION
// inverse la partie du tableau comprise entre les cases i et j (incluses)
fonction sans retour inverse(entier[] t, entier i, entier j)
entier k,temp;
début
pour(k allant de i à (i+j)/2 pas 1) faire
temp <- t[k];
t[k] <- t[j-(k-i)];
t[j-(k-i)] <- temp;
finpour
fin
// renvoie la position de l'element le plus grand, en le cherchant
//entre 0 et la borne (incluse). Les entiers sont supposés positifs.
fonction avec retour entier trouveMax(entier[] t, entier borne)
entier i, max;
début
max <- 0;
pour(i allant de 1 à borne pas de 1) faire
si(t[i] > t[max]) alors
max <- i;
finsi
finpour
retourne max;
fin
// fonction de tri a la bretonne
fonction sans retour triBreton(entier[] t)
entier i,j;
début
pour(i allant de t.longueur-1 à 1 pas de -1) faire
j <- trouveMax(t,i);
si(j != i) alors
inverse(t,0,j);
inverse(t,0,i);
finsi
finpour
fin
La fonction inverse s'exécute toujours en temps linéaire et sa complexité est
de la forme a*n/2 + b où n est la taille du tableau et a et b sont des constantes.
Le pire cas pour l'exécution de la fonction trouvemax correspond à un tableau
où les éléments sont rangés par ordre croissants (l'affectation max <- i a alors
lieu à chaque tour de boucle). Le cas au mieux est celui où l'élément le plus grand
est dans la première case (l'affectation max <- i n'a alors jamais lieu). Mais dans
tous les cas, la fonction trouvemax s'exécute toujours en temps linéaire et sa
complexité est de la forme c*n + d où n est la taille du tableau et c et d sont des
constantes.
Le pire
retourner une
complexité de
constante, ce
cas pour l'exécution de la fonction triBreton est celui où on doit
partie du tableau à chaque tour de boucle. Dans ce pire cas, la
la fonction triBreton est de la forme n*(3*O(n)+e) où e est une
qui donne une complexité quadratique.
4- Élimination des doublons - CORRECTION
Le principe est de parcourir séquentiellement le tableau passé en paramètre
et de ne stocker un caractère dans le tableau résultat que s'il n'a pas déjà été
rencontré avant. On écrit donc une fonction qui permet de savoir si un caractère a
déjà été rencontré. Cette fonction va également permettre de compter le nombre de
caractères du tableau passé en paramètre en omettant les doublons.
// renvoie vrai si c est dans t entre les indices 0 et j
// j est supposé plus petit que t.longueur-1
fonction avec retour booleen appartient(caractere c, caractere[] t, entier j)
entier i;
booléen b;
debut
b <- faux;
i <- 0;
tantque (i<j+1 et non b) faire
si (t[i] == c) alors
b <- vrai;
finsi
i <- i+1;
fintantque
retourne b;
fin
fonction avec retour caractere[] retireDoublons(caractere[] t)
entier cpt,i,j;
caractere[] resultat;
debut
// cette boucle pour sert à calculer le nombre de caractères
// de t en omettant les doublons
cpt <- 1;
pour(i allant de 1 à t.longueur-1 pas 1) faire
si(!appartient(t[i],t,i-1)) alors
cpt <- cpt+1;
finsi
finpour
redim resultat[cpt];
j <- 1;
resultat[0] <- t[0];
pour(i allant de 1 à t.longueur-1 pas 1) faire
si(!appartient(t[i],t,i-1)) alors
resultat[j] <- t[i];
j <- j+1;
finsi
finpour
retourne resultat;
fin
Le pire cas pour la fonction appartient est celui où j vaut t.longueur-1 et c
n'est pas dans t. Dans ce cas, si on appelle n la taille du tableau, n tours de
boucles sont effectués et la complexité vaut n*a+b = O(n) (où a et b sont des
constantes).
Le pire cas pour la fonction retireDoublons est celui où il n'y a
doublon, car alors le tableau résultat contiendra tous les caractères du
paramètre et il y aura une affectation et une incrémentation de j à chaque
la deuxième boucle pour. Dans ce cas, si on appelle n la taille du
d'entrée, la complexité sera c+n*2*O(n) = O(n²).
5- Tous différents - CORRECTION
fonction avec retour booléen tousDiff(entier[] tab)
entier i,j;
booléen b;
début
b <- vrai;
i <- 0;
tantque (i<tab.length-1 et b) faire
pas de
tableau
tour de
tableau
j <- i+1;
tantque (j<tab.length et b) faire
si (tab[i] = tab[j]) alors
b <- faux;
finsi
j <- j+1;
fintantque
i <- i+1;
fintantque
retourne b;
fin
Le cas au pire est celui où les éléments sont tous différents, ce qui oblige
à exécuter les deux boucles pour toutes les valeurs possibles de i et j. En effet,
si deux éléments d'indices a et b sont identiques dans le tableau, le test tab[a] =
tab[b] sera vrai et l'instruction b <- faux mettra fin à l'exécution de la fonction
avant que i atteigne la valeur tab.length-2.
Dans ce cas au pire, si on note n la longueur du tableau, la complexité est
de la forme a*((n-2)+ (n-3) + ... + 2 + 1) = a*(n-2)*(n-1)/2 = O(n²) avec a une
constante.
6- Supérieurs - CORRECTION
fonction avec retour entier superieurs(entier[] tab, entier e, entier i, entier j)
entier n;
début
si(i != j) alors
n <- (i+j)/2;
si (tab[n] == e) alors
retourne tab.longueur - n -1;
sinon
si (tab[n] > e) alors
retourne supérieurs(tab,e,i,n-1);
sinon
retourne superieurs(tab,e,n+1,j);
finsi
finsi
sinon
si (tab[i] = e) alors
retourne tab.longueur - i - 1;
sinon
si (tab[i] > e) alors
retourne tab.longueur - i;
sinon
retourne tab.longueur - i - 1;
finsi
finsi
finsi
fin
Le cas au pire d'exécution de la fonction superieurs est le cas où l'élément
n'est pas dans le tableau. Dans ce cas, la complexité de la fonction vaut C(n) =
C(n/2) + a où a est une constante et donc C(n) = O(log(n)).
7- Découpage de tableau - CORRECTION
fonction avec retour caractere[][] plier(caractere[] t, entier i)
caractere[][] result;
entier j,k,l;
debut
si (t.longueur mod i = 0) alors
redim result[t.longueur/i][i];
sinon
redim result[1+t.longueur/i][i];
finsi
k <- 0;
pour (j allant de 0 à result.longueur-1 pas de 1) faire
pour (l allant de 0 à i-1 pas de 1) faire
si (j*i+l<t.longueur) alors
result[j][l] <- t[k];
k = k+1;
sinon
result[j][l] = ' ';
finsi
finpour
finpour
retourne result;
fin
Le paramètre de complexité de la fonction est la taille du tableau d'entrée
t, qu'on appelle n. Il n'y a pas de cas au pire ou au mieux. L'exécution de la
conditionnelle du début a un coût fixe qu'on appelle a. La boucle pour la plus
générale fera un nombre de tour égal au plus à 1+n/i et la boucle interne fera i
tours. La conditionnelle à l'intérieur des boucles a un coût maximal constant qu'on
appelle b. Le coût total de l'exécution de la fonction est donc au maximum
a+(1+n/i)*i*b = O(n).
8- Inversion de tableau - CORRECTION
Le paramètre de complexité est la taille du tableau, qu'on appelle n. Cas au
mieux : la conditionnelle est toujours fausse, c'est-à-dire que le tableau est
symétrique (c'est un palindrome de réels). Cas au pire : la conditionnelle est
toujours vraie, c'est-à-dire que deux éléments placés symétriquement par rapport au
centre du tableau sont toujours différents.
On appelle a le coût d'une affectation, b le coût d'une comparaison et c le
coût d'une opération numérique. Dans tous les cas, la boucle fera n/2 tours. Cas au
mieux : (n/2)*(a+2b+4c) = O(n). Cas au pire : (n/2)*(4a+2b+8c) = O(n).
9- Numération romaine - CORRECTION
fonction avec retour entier calculIter(caractères[] t)
entier i,nb;
debut
nb <- 0;
pour (i allant de 0 à t.longueur-2 pas de 1) faire
si (valeur(t[i]) < valeur(t[i+1])) alors
nb <- nb - valeur(t[i]);
sinon
nb <- nb + valeur(t[i]);
finsi
finpour
retourne nb + valeur(t[t.length-1]);
fin
Le paramètre de complexité est la taille du tableau t, qu'on appele n. Il n'y a pas
de cas au pire ou au mieux si on considère qu'une soustraction coute autant qu'une
addition. Il y a n-1 tours de boucles, donc la complexité est de la forme a (n-1) +
b avec a et b des constantes, soit O(n).
10- Racine entière - CORRECTION
fonction avec retour entier racine(entier e)
entier r;
début
r <- 1;
tantque (r*r <= e) faire
r = r + 1;
fintantque
retourne r-1;
fin
Le paramètre de complexité est la valeur de l'entier e, il n'y a pas de cas
au pire ou au mieux. Le nombre de tours de boucle est égal au nombre à trouver soit
√e, donc la complexité est en O(√e).
11- Occurences de lettres - CORRECTION
fonction sans retour oocIter(caractère[] t)
entier i,cpt;
caractère c;
début
pour (c allant de 'a' à 'z' pas de 1) faire
cpt <- 0;
pour (i allant de 0 à mot.longueur-1 pas de 1) faire
si (mot[i] = c) alors
cpt++;
finsi
finpour
écrire c + " : " + cpt + " fois";
finpour
fin
Le paramètre de complexité est la taille du tableau t, qu'on appele n. Il n'y
a pas de cas au pire ou au mieux. Il y a n tours de la boucle interne, donc la
complexité est de la forme 26*n*a + b avec a et b des constantes, soit O(n).
12- Comparaison de mots - CORRECTION
fonction avec retour booleen debutTab(caractère[] t1, caractère[] t2)
entier i;
booléen b;
début
b ← vrai;
i ← 0;
tantque (b ET i<t1.longueur) faire
si (i >= t2.longueur) alors
b ← faux;
sinon
si (t1[i] != t2[i]) alors
b ← faux;
finsi
fin
finsi
i ← i+1;
fintantque
retourne b;
// cette fonction renvoie vrai si t1 est inclus dans t2 à partir de l'indice i,
faux sinon
fonction avec retour booléen debutTab2(caractère[] t1, caractère[] t2, entier i)
entier j;
booléen b;
début
j ← 0;
b ← vrai;
tantque (b ET j<t1.longueur) faire
si (i+j >= t2.longueur) alors
b ← faux;
sinon
si (t1[j] != t2[i+j]) alors
b ← faux;
finsi
finsi
j ← j+1;
fintantque
retourne b;
fin
fonction avec retour entier incluTab(caractère[] t1, caractère[] t2)
entier i,j;
début
j ← -1;
si (t1.longueur != 0) alors
i ← 0;
tantque (j==-1 ET i<t2.longueur-t1.longueur+1) faire
si (debutTab2(t1,t2,i)) alors
j← i;
finsi
i ← i+1;
fintantque
finsi
retourne j;
fin
On suppose qu'il existe une fonction entier min(entier i, entier j)
fonction avec retour entier compare(caractère[] t1, caractère[] t2)
entier i,resultat;
début
resultat ← 0;
i ← 0;
tantque (resultat = 0 ET i < min(t1.longueur,t2.longueur)) faire
si (t1[i] > t2[i]) alors
resultat ←-1;
sinon
si (t1[i] < t2[i]) alors
resultat←1;
finsi
finsi
i←i+1;
finpour
si (resultat = 0) alors
si (t1.length > t2.longueur) alors
resultat←-1;
sinon
si (t1.length < t2.longueur) alors
resultats←1;
finsi
finsi
finsi
retourne resultat
fin
Téléchargement
Random flashcards
amour

4 Cartes mariam kasouh

Le lapin

5 Cartes Christine Tourangeau

aaaaaaaaaaaaaaaa

4 Cartes Beniani Ilyes

découpe grammaticale

0 Cartes Beniani Ilyes

Fonction exponentielle.

3 Cartes axlb48

Créer des cartes mémoire