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 est celui où le caractère cherché n'est pas dans le tableau. 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'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 cas pour l'exécution de la fonction triBreton est celui où on doit retourner une partie du tableau à chaque tour de boucle. Dans ce pire cas, la complexité de la fonction triBreton est de la forme n*(3*O(n)+e) où e est une constante, ce 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 pas de doublon, car alors le tableau résultat contiendra tous les caractères du tableau paramètre et il y aura une affectation et une incrémentation de j à chaque tour de la deuxième boucle pour. Dans ce cas, si on appelle n la taille du tableau 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
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 finsi
i ← i+1;
fintantque retourne b;
fin
// 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
