Alors ici, c'est la page des casses tête : des exercices, encore des exercices et les démarches à suivre pour les résoudre. **SVP** regarder les aides c'est bien (mais c'est tellement mieux si vous trouvez tout seul 8-) ). Mais si vous ne trouvez absolument pas et êtes désespérés, la solution mais en **DERNIER RECOURS** !! C'est important, on ne vous forcera pas bien sur, d'ailleurs, c'est pour ça qu'on met les corrections en ligne, en libre service. Mais si vous voulez réussir travaillez, réfléchissez beaucoup et courage ! Rappelez vous, vous pouvez venir me voir à mes heures de [[etudiant:tutorat|Tutorats]]. Bon courage.
Énoncé :
Calculer la somme de deux entiers en récursif (Classique et Terminale).
Aide:
somme 4 5
9
Énoncé :
Calculer le produit de deux entiers en récursif (Classique et Terminale).
Aide :
produit 4 5
20
Énoncé :
Vous connaissez déjà la fonction PGCD en récusif (non terminale), vous n'avez plus qu'à la réécrire en terminale ;-) !
Aide :
pgcd 34 12
2
Alors ceci est un exemple de récursivité un peu spéciale car c'est une double récursivité.
mais rassurez vous cela reste très simple !!
Énoncé :
La suite de Fibonnaci stipule que fibo(n)=fibo(n-1)+fibo(n-2)
Aide :
- D'abord voyez quelle est la condition d'arrêt.
- le reste est juste la traduction exacte de la formule mathématique. Quand je dis exacte c'est vraiment exacte !!
Énoncé :
Cette fonction prend en paramètre un entier et renvoie le nombre de chiffre(s) qui le compose(nt).
Aide :
- Pensez à la division entière d'un entier par 10.
nb_chiffre 9999
4
Énoncé :
Fonction qui renvoie x à la puissance y.
Aide :
- Pour tout x de IR, x0 = 1.
puissance 10 2
100
Énoncé :
Cette fonction doit renvoyer le nombre total de diviseurs d'un entier naturel.
Aide :
- a est un diviseur de b ssi le reste de la division de b par a est nul.
- On ne fera que la version terminale.
nbdiv 15
4
Énoncé :
Développez une fonction qui vérifie qu'un entier est premier.
Aide :
- Un nombre premier a exactement 2 diviseurs: 1 et lui-même.
premier 97
true
facteur_premier 1024
[2;2;2;2;2;2;2;2;2;2]
parfait 23
false
Énoncé :
Votre fonction doit convertir un entier de n'importe quelle base numérique b en un autre base numérique b'.
Aide :
- Dans un premier temps créez la fonction
//de_b_en_10//
qui convertie un entier d'une base b en base 10.
de_b_en_10 1101 2
13
- Maintenant, une fonction //de_10_en_b// qui convertie un entier de base 10 en base b.
de_10_en_b 10 2
1010
- Enfin pour finir, combiner ces deux fonctions afin de convertir un entier d'une base b à une base b': //de_b_en_b2// .
de_b_en_b2 110 2 8 (* 3 paramètres: la valeur à convertir, sa base et la base d'arrivé *)
6
- On ne fera ici que la version terminale.
Énoncé :
Calculer la longueur d'une liste en terminale.
Aide :
long_liste [1;2;3;4;5;6]
6
Énoncé :
Calculer la somme des entier d'une liste.
Aide :
- L'accumulateur accumulera la somme de la tête de la liste et de lui-même.
- On rappelle la fonction avec la queue de la liste et la nouvelle valeur de l'accumulateur.
somme_liste [1;2;3;4;5;6]
21
Énoncé :
Cette fonction renvoie le miroir d'une liste (si vous n'aviez pas compris :-) )!
Aide :
- Vous pouvez utiliser l'opérateur **@** pour concaténer deux listes.
mirroir [1;2;3]
[3;2;1]
Remarque :
Cet exercice vous permet de réaliser la fonction List.rev.
(voir chapitre sur les Listes).
Énoncé :
Cette fonction doit renvoyer le maximum d'une liste d'entier.
Aide :
- Créer une fonction auxiliaire max qui renvoie le maximum de deux entiers.
max_liste [1;2;3;4;5;789]
789
Énoncé :
La fonction parcourt toute la liste à la recherche de élément envoyé en paramètre.
Aide :
- Dès qu'un élément de la liste est égal à celui que l'on cherche on renvoie **true** et sinon ba ** false ** :-P.
est_element 2 [1;2;3;4]
true
Remarque :
Cet exercice vous permet de réaliser la fonction List.mem.
(voir chapitre sur les Listes).
Énoncé :
Créer une fonction qui ôte tous les éléments x d'une liste.
Aide :
enleve_element 2 [1;2;3;4;564]
[1;3;4;564]
Énoncé :
A la manière d'un langage impératif, créez la fonction qui donne la valeur ième d'une liste.
Aide :
- i doit être compris entre 1 et la longueur de la liste.
acces 3 [1;2;3;4;567]
3
Énoncé :
Calculer le nombre de fois qu'un élément x apparaît dans une liste.
Aide :
nb_element 10 [1;2;3;10;10;1;10;10]
4
Énoncé :
La fonction prend en paramètre une liste et une fonction, la fonction prise en paramètre est appliquée à tous les éléments de la liste.
Aide :
- La fonction en paramètre est de type: //
'a
->
'a
// ou //
'a
->
'b
=
//
list4all (fun x -> 2 * x) [1;2;3;4]
[2;4;6;8]
list4all (fun x -> string_of_float x) [5.; 8.; 189.; 0.]
["5."; "8."; "189."; "0."]
let rec pgcd x y =
if (x mod y = 0) then y
else pgcd y (x mod y);;
list4all (pgcd 10) [1;12;20;234] (*Calcul le pgcd de 10 et de chaque entier de la liste *)
[1; 2; 10; 2]
Remarque :
Cet exercice vous permet de réaliser la fonction List.map.
(voir chapitre sur les Listes).
Énoncé :
Dans cet exercice vous devez créer une ou des fonctions qui vous permet de :
- additionner deux listes et renvoyez le résultat en une liste.
- si une liste est plus petite que l'autre la compléter jusqu’à ce qu'elles est toutes les deux la même taille.
- l'ordre doit être maintenu
- pas de boucle évidement LOL
Aide :
voici une idée de création de fonctions et l'ordre ou les mettre :
- ajoute Zéro qui complète une liste avec des zéro jusqu'à atteindre la taille désirée
- une fonction qui permet d'afficher une liste d'entier(c'est pas obligatoire mais c'est pratique pour réfléchir)
- une fonction qui détecte la plus petite des deux liste et la remplie avec des zéro(à gauche de la liste)
- Et enfin une fonction qui calcule la somme des deux liste et la renvoie dans une troisième liste
somme2listes [1;2] [1;2;3;4] ;;
[1;2;4;6]
Voyons si vous arrivez à manipuler les fonctions que nous venons de créer.
Énoncé :
Nous allons créer une fonction prenant en paramètre une liste d'entier et retourne cette liste dans un ordre croissant.
Aide :
- On aura besoin de trouver minimum de la liste à chaque récursion.
- Une fois le minimum trouver, on le met dans une autre liste et on a plus qu'à s'occuper du reste de la liste.
- On concatène.
tri_croissant [12; 10; 99; 0; -100]
[-100; 0; 10; 12; 99]
Énoncé :
Trier un tableau de nombres entiers dans l'ordre croissant.
Rappel :
Le tri à bulle est un tri permettant d'échanger deux valeurs si le critère n'est pas respecté. La fonction prendra une liste en paramètre pour la trier.
Aide :
- Créer dans un premier temps une fonction pouvant échanger deux entiers.
echange [1;3;2;4];;
- : int list [1;2;3;4]
- Dans un deuxième temps, une fonction permettant de faire un premier tri de la liste. - Enfin une dernière fonction permettant de lancer le tri autant de fois que nécessaire.
Énoncé :
Chercher le plus petit entier d'une liste (d'entiers 8-O !)
Aide :
- Vous aurez besoin d'une fonction qui renvoie le minimum de deux entiers.
- L'accumulateur prend la valeur du minimum des deux premiers entiers.
min_liste [1;2;3;4;5;6]
1
Énoncé :
Cette fonction prend en paramètre deux listes du même type, elle renvoie une liste contenant les éléments communs aux deux liste en arguments.
list_list [1;2;3;4];;
- : int list list = [ [1]; [1;2]; [1;2;3]; [1;2;3;4] ]
Aide :
- Vous ne ferez cette fonction qu'en version Terminale.
- La version Terminale fait apparaître une nouvelle variable (acc), mais rien n'empêche d'en avoir deux.
Énoncé :
Créer une liste de listes à partir d'une liste en suivant cet exemple :
enCommuns [1;2;3;4] [3;4;5;6] ;;
- : int list = [3;4]
Aide :
- Vous aurez besoin d'une fonction qui vérifie qu'un élément appartient à une liste.
- Dès qu'un élément de la liste l1 appartient à la liste l2, vous le concaténez au résultat.
Énoncé :
Partie A :
Déterminer la signatures des fonctions suivantes :
let rec fonction1 x =
if x = 0 then 0
else x + fonction1 (x-1);;
let fonction2 g h w x y z = g w z && h x y;;
let fonction3 a b c = a = b + c;;
let fonction4 (a,z) =
if a > z then a
else a + z;;
Énoncé : Partie B : Maintenant dans l'autre sens, voici des signatures de fonction. Vous devez dire quels sont les arguments et la sortie de ces signatures :
val fonction5 : float * int * bool -> string =
val fonction6 : bool -> bool -> bool -> (bool * bool -> bool) -> bool =
val fonction7 : (float -> int) -> char =
val fonction8 : int * float * int * char -> int list =
Énoncé :
Evaluer une formule logique (déterminer si une formule est vraie ou non).
Aide :
- Définir un somme modélisant les expressions booléennes à base de connecteurs non, ou, et, et une constante pour les valeurs vraie/fausse.
- Définir une fonction eval pour l'évaluation de telles expressions.
# eval (Or (And (Cte true, Cte false), Not (Cte false))) ;;
- : bool = true
Énoncé :
Nous allons utiliser ce que nous avons appris dans le chapitre sur les enregistrements pour créé un tout petit jeu.
Créez un personnage qui est définit par :
- un
Prénom
- un
Niveau
- une
Race
- une
Classe
(libre à vous de créer d'autres champs pour mieux personnaliser votre personnage)
Sachant que les races possibles sont :
-
Humain
-
Gnome
-
Alien
-
Robot
Et que toutes les classes possibles sont :
-
Etudiant
-
Mage
-
Potier
-
PorteurDeau
(là aussi, vous pouvez rajouter des races et des classes )
Créez un fonction
quête
qui prend en argument un personnage et qui créé un petite histoire autour du personnage.
(Je vous fais confiance pour l'histoire)
- Dans la quête le personnage devra faire un choix (exemple: saisir valeur entre 1 et 2), si il a fait le bon choix la quête continue et son niveau augmente d'un niveau sinon la fonction s'arrête.
(y a de la récursivité dans l'air)
Amélioration :
- Rajouter un argument qui représente le nombre de fois successives que le joueur réussit, si ce nombre est égale à 5 alors son niveau augmente de 5 niveaux.
- Augmenter la difficulté: au lieu de choisir entre 1 et 2, choisir entre 1 et 5.
- ...
Énoncé :
- Créer une fonction qui transforme une chaîne de caractères en liste de caractères.
- Créer une fonction qui prend en paramètre une liste de caractères et renvoie un liste de couples char * int (c'est-à-dire un caractère avec le nombre de fois que ce caractère apparaît).
- Créer aussi une fonction qui permettra d'afficher ce résultat.
let l = list_of_string "abracadabra";;
val l : char list = ['a'; 'b'; 'r', 'a'; 'c'; 'a'; 'd'; 'a'; 'b'; 'r'; 'a']
let abra = compte_lettre l;;
val abra : (char * int) list = [('a', 5); ('b', 2); ('c', 1); ('d', 1); ('r', 2)]
affiche_chaque_lettre abra;;
Le caractère 'a' apparaît 5 fois.
Le caractère 'b' apparaît 2 fois.
Le caractère 'c' apparaît 1 fois.
Le caractère 'd' apparaît 1 fois.
Le caractère 'r' apparaît 2 fois.
Voilà un bon paquet d’énoncé d'exercices à faire.
Si vous avez des idées d'exercices à faire, d'autres versions de corrections,... alors n'hésitez pas à nous contacter.