exercice langage c

http://www.cmi.univ-mrs.fr/~contensi/coursC/index.php

exercice : permuter circulairement les valeurs de trois variables vers la gauche (solution)

Ecrire un algorithme qui effectue une permutation circulaire des valeurs de trois variables x, y et z. Par exemple, si x contient la valeur 3, y contient la valeur 2 et z la valeur 1, alors on souhaite obtenir 2 dans x, 1 dans y et 3 dans z.x y z3 2 12 1 3

exercice : Ecrire l'algorithme de permutation circulaire qui demande la valeur des 3 variables à permuter et affiche le contenu des variables à chaque étape (solution)

Permutation circulaire vers la gauche de trois variables saisies au clavier

Ecrire ("Entrez les valeurs de x, y et z"); Lire (x, y, z); Ecrire("x vaut ", x, " y vaut ", y, " et z vaut ", z); intermediaire <- x ; x <- y ; Ecrire("x vaut ", x, " y vaut ", y, " et z vaut ", z); y <- z ; Ecrire("x vaut ", x, " y vaut ", y, " et z vaut ", z); z <- intermediaire ; Ecrire("x vaut ", x, " y vaut ", y, " et z vaut ", z);

exercice : On constate que l'algorithme ci-dessous comporte de nombreuses répétitions, sur chaque ligne on va diviser par 8 et multiplier par le nombre de personnes, si la quantité était donnée pour 10 personnes, il faudrait modifier chaque ligne pour passer de 8 à 10. Réécrivez cet algorithme de manière à ce que le nombre de personnes soit lu au clavier et utilisez une fonction qui effectue la division d'un argument par 8 et sa multiplication par le nombre de personnes. Vous commencerez par initialiser la valeur de chaque ingrédient pour 8 personnes. (solution) sucre_semoule <- (300 g / 8) * nb_personnes ; sucre_vanille <- (1 c. à soupe / 8) * nb_personnes ; oeufs <- (4 / 8) * nb_personnes ; farine <- (50 g / 8) * nb_personnes ; beurre <- (250 g / 8) * nb_personnes ; chocolat_noir <- (160 g / 8) * nb_personnes ; noix_de_pecan <- (90 g / 8) * nb_personnes ; amande_en_poudre <- (30 g / 8) * nb_personnes ;

exercice : Ecrire un algorithme qui lit deux nombres au clavier et qui effectue la division du premier nombre par le second si celui-ci est non nul. Cet algorithme affichera soit le résultat de la division, soit un message pour prévenir que la division par zéro est interdite (solution).

Division de deux nombres qui prend en compte le cas du diviseur nul

Ecrire ("Entrez deux nombres : "); Lire (nombre_1, nombre_2);

si nombre_2 = 0 { Ecrire ("on ne peut pas diviser ", nombre_1, "par 0"); } sinon { division <- nombre_1 / nombre_2; Ecrire (nombre_1, " divise par ", nombre_2, " = ", division);

}

exercice : Ecrire un algorithme qui lit deux nombres au clavier et qui affiche le plus grand nombre lu (solution).

exercice : sachant qu'un étudiant est admis lorsqu'il a 10 de moyenne, qu'il a la mention passable si sa note est inférieure à 12, la mention assez bien si sa note est inférieure à 14, la mention bien si sa note est inférieure à 16, la mention très bien si sa note est inférieure à 18 et les félicitations du jury à partir de 18, écrivez l'algorithme qui affiche si l'étudiant est admis, ainsi que sa mention éventuelle. (solution)

exercice : écrivez l'algorithme qui donne la mention d'un étudiant admis en utilisant uniquement des et. (solution)

exercice : écrire l'algorithme qui décide du comportement d'un automobiliste à l'approche d'un feu (rouge, orange, vert). (solution)

exercice : réécrivez l'algorithme ci-dessous en utilisant une négation dans le si (solution)

si x < 0 ou x > 100 alors { Ecrire ("la valeur n'est pas comprise entre 0 et 100");}sinon { Ecrire ("la valeur est comprise entre 0 et 100");

}

Négation dans le si

si non (x >= 0 et x <= 100) alors { Ecrire ("la valeur n'est pas comprise entre 0 et 100");}sinon { Ecrire ("la valeur est comprise entre 0 et 100");

}

exercice : écrivez un algorithme qui donne le plus grand de trois nombres lus au clavier (solution)

Trouver le maximum parmi trois nombres

Ecrire ("Entrez trois nombres :"); Lire (x, y, z); si x > y alors { // comparer x et z si x > z alors { Ecrire ("le plus grand nombre est ", x); }

sinon { Ecrire ("le plus grand nombre est ", z); } } sinon { // comparer y et z si y > z alors { Ecrire ("le plus grand nombre est ", y); } sinon { Ecrire ("le plus grand nombre est ", z); }

}

exercice : écrivez un algorithme qui classe par ordre croissant trois nombres lus au clavier. A la fin de l'algorithme c'est l'instruction : Ecrire (nombre_1, " ", nombre_2, " ", nombre_3); qui affichera les 3 nombres classés.

Faire la trace de l'algorithme pour le jeu de test : x y z 10 10 10 10 20 30 10 30 20 20 10 30 20 30 10 30 10 20 30 20 10

exercice : écrire un algorithme qui permet au robot de se rendre au troisième étage, sachant qu'un étage comporte toujours 20 marches. (solution)

Algorithme qui permet à un robot de se rendre au 3ème étage sachant qu'un étage a 20 marches

nombre_marches <- 0; tant que nombre_marches < 60 répéter { monter_une_marche(); nombre_marches <- nombre_marches + 1;

}

Combien de marches le robot aurait-il monté si on avait mis nombre_marches <= 60 ?

exercice : modifiez l'algorithme qui permet au robot de se rendre à un étage afin que le nombre de marches d'un étage soit entré au clavier et que l'étage à atteindre soit lui aussi entré au clavier. (solution)

exercice : écrivez l'algorithme du robot qui monte à un étage quelconque avec deux structures répétitives. (solution)

Algorithme qui permet à un robot de se rendre à un étage quelconque connaissant le nombre de marches d'un étage avec deux structures répétitives

// demander l'etage et le nombre de marches Ecrire("Bonjour Maitre, a quel etage dois-je me rendre ?"); Lire(etage); Ecrire("Donnez le nombre de marches pour un etage"); Lire(nombre_marches_etage);

nombre_etages_montes <- 0; tant que nombre_etages_montes < etage répéter { nombre_marches_montees <- 0; tant que nombre_marches_montees < nombre_marches_etage répéter { monter_une_marche(); nombre_marches_montees <- nombre_marches_montees + 1; } nombre_etages_montes <- nombre_etages_montes + 1; }

Que se passerait-il si l'instruction nombre_marches_montees <- 0; était placée dans le deuxième tant que ?

exercice : écrivez un algorithme qui calcule la moyenne d'un nombre quelconque de notes. L'utilisateur peut en entrer autant qu'il le souhaite et indique qu'il ne veut plus entrer de notes en tapant au clavier -1.

essayer l'algorithme lorsque l'utilisateur a entré : 10 12 16 14 -1

(solution)

Algorithme qui donne la moyenne d'un nombre quelconque de notes

Rappel de l'algorithme qui permet de donner la moyenne pour 5 notes

note <- 0; note <- Add_2_notes (note, note_1); note <- Add_2_notes (note, note_2); note <- Add_2_notes (note, note_3); note <- Add_2_notes (note, note_4); note <- Add_2_notes (note, note_5); nb_etudiants <- 5; moyenne <- note / nb_etudiants;

Rappel de la fonction Add_2_notes

Add_2_notes(note_1, note_2) { somme_note <- note_1 + note_2;

retourner somme_note; }

Algorithme qui permet de donner la moyenne pour un nombre quelconque de notes

// initialisation somme_des_notes <- 0; note_lue <- 0; nb_etudiants <- 0;

// boucle tant que note_lue != -1 répéter { Ecrire("Entrez une note (-1 pour obtenir la moyenne)"); Lire(note_lue); si note_lue != -1 alors { somme_des_notes <- Add_2_notes (note_lue, somme_des_notes); nb_etudiants <- nb_etudiants + 1; } }

// calcul et affichage de la moyenne moyenne <- somme_des_notes / nb_etudiants; Ecrire("la moyenne est : ", moyenne);

Test sur l'algorithme :L'utilisateur entre successivement 10, 12, 16, 14, -1

instructions somme_des_notes note_lue nb_etudiants moyenne

initialisation 0 0 0 0

itération 1 : 0 != -1 ? oui

0 10 10

10 10 10

0 0 1

0


10 22 22

12 12 12

1 1 2

0


22 38 38

16 16 16

2 2 3

0


38 52 52

14 14 14

3 3 4

0


note_lue != -1 ? non

52 -1 4 0

calcul de la moyenne 52 -1 4 13

Que se serait-il passé à l'itération 5 si nous n'avions pas utilisé un si note_lue != -1 alors ... ?

exercice : écrivez une fonction fact(nombre) qui calcule la factorielle d'un nombre (utilisez une boucle). Rappel n ! = n * (n-1) * (n-2) * (n-3) * ... * 1

exemples : 5 ! = 5 * 4 * 3 * 2 * 1 = 120 4 ! = 4 * 3 * 2 * 1 = 24 3 ! = 3 * 2 * 1 = 6 2 ! = 2 * 1 = 2 1 ! = 1 0 ! = 1 (cas particulier à ne pas oublier)

faire la trace pour fact(5), fact(1) et fact(0).(solution)

Factorielle d'un nombre

fact (nombre) {

factorielle <- 1; // pour stocker le résultat

si nombre = 0 alors { // cas particulier ou il n'y a rien a calculer retourner 1; } sinon { indice <- nombre ; tant que indice > 0 répéter { factorielle <- factorielle * indice; indice <- indice - 1; } } retourner factorielle; }

Tests

fact(5) nombre factorielle indice

factorielle <- 1 5 1

5 = 0 ? non 5 1

indice <- nombre 5 1 5

itération 15 > 0 ? ouifactorielle <- factorielle * indiceindice <- indice - 1

55

55

54


55

2020

43


55

6060

32


55

120120

21


55

120120

10

itération 60 > 0 ? non

5 120 0

retourne 120



1 = 0 ? non 1 1

indice <- nombre 1 1 1

itération 11 > 0 ? ouifactorielle <- factorielle * indice 1 1 1

indice <- indice - 1 1 1 0

itération 20 > 0 ? non

1 1 0

retourne 1



0 = 0 ? oui 0 1

retourne 1

exercice : Le triangle de Pascal

num_colonne ->num_ligne

0 1 2 3 4 5 6 7

0 1

1 1 1

2 1 2 1

3 1 3 3 1

4 1 4 6 4 1

5 1 5 10 10 5 1

6 1 6 15 20 15 6 1

7 1 7 21 35 35 21 7 1

Chaque case du triangle est obtenue en appliquant une formule simple qui utilise la factorielle :

La formule ci-dessus donne le chiffre à afficher pour une ligne et une colonne donnée, par exemple pour la ligne 5, colonne 2, on obtient 10, pour la ligne 6, colonne 3 on obtient 20.

Donnez un algorithme qui utilise deux boucles imbriquées pour afficher tout le triangle lorsqu'il y a 8 lignes (de 0 à 7) (solution)

Triangle de Pascal

l <- 0;tant que l <= 7 répéter { // pour chaque ligne c <- 0; tant que c <= l répéter { // pour chaque colonne de la ligne nombre_a_afficher <- fact(l) / (fact(c) * fact(l - c)) ; Ecrire(nombre_a_afficher," "); c <- c + 1; } Ecrire("\n"); // saut de ligne l <- l + 1; }

exercice : écrivez un algorithme qui affiche cette pyramide en utilisant des boucles. Chaque ligne comporte 19 caractères (espaces ou x), les lignes sont numérotées de 0 à 9.

xxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxx xxxxxxxxxxxxx xxxxxxxxxxx xxxxxxxxx xxxxxxx xxxxx xxx x

indications :la ligne 0 comporte 0 espace puis 19 x puis 0 espace,la ligne 1 comporte 1 espace puis 17 x puis 1 espace,la ligne 2 comporte 2 espaces puis 15 x puis 2 espaces...la ligne 9 comporte 9 espaces puis 1 x puis 9 espaces

(solution)

Pyramide inversée

la ligne 0 comporte 0 espace puis 19 x puis 0 espace,la ligne 1 comporte 1 espace puis 17 x puis 1 espace,la ligne 2 comporte 2 espaces puis 15 x puis 2 espaces...la ligne 9 comporte 9 espaces puis 1 x puis 9 espaces

Nous traiterons l'affichage des espaces à droite (même si ce n'est pas nécessaire puisque l'espace n'est pas visible à l'écran).

nb_l <- 0;

// traitement pour chaque ligne tant que nb_l < 10 répéter { // calculer le nombre de x a afficher sur la ligne nb_espaces <- nb_l; nb_x <- 19 - (nb_espaces * 2); // afficher la premiere serie d'espaces nb_esp_affiches <- 0; tant que nb_esp_affiches < nb_espaces répéter { Ecrire(" "); nb_esp_affiches <- nb_esp_affiches + 1; } // afficher la serie de x nb_x_affiches <- 0; tant que nb_x_affiches < nb_x répéter { Ecrire("x"); nb_x_affiches <- nb_x_affiches + 1; } // afficher la deuxieme serie d'espaces nb_esp_affiches <- 0; tant que nb_esp_affiches <- nb_espaces répéter { Ecrire(" "); nb_esp_affiches <- nb_esp_affiches + 1; }

nb_l <- nb_l + 1; Ecrire("\n"); }

exercice : écrivez un algorithme qui affiche cette pyramide en utilisant des boucles.

x xxx xxxxx xxxxxxx xxxxxxxxx xxxxxxxxxxx xxxxxxxxxxxxx xxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

(solution)

Pyramide

la ligne 0 comporte 9 espaces puis 1 x puis 9 espacesla ligne 1 comporte 8 espaces puis 3 x puis 8 espacesla ligne 2 comporte 7 espaces puis 5 x puis 7 espaces,...

la ligne 9 comporte 0 espaces puis 19 x puis 0 espaces

Nous traiterons l'affichage des espaces à droite (même si ce n'est pas nécessaire puisque l'espace n'est pas visible à l'écran).

nb_l <- 0;

// traitement pour chaque ligne tant que nb_l < 10 répéter { // calculer le nombre de x a afficher sur la ligne nb_espaces <- 9 - nb_l; // pour inverser la pyramide nb_x <- 19 - (nb_espaces * 2); // afficher la premiere serie d'espaces nb_esp_affiches <- 0; tant que nb_esp_affiches < nb_espaces répéter { Ecrire(" "); nb_esp_affiches <- nb_esp_affiches + 1; } // afficher la serie de x nb_x_affiches <- 0; tant que nb_x_affiches < nb_x répéter { Ecrire("x"); nb_x_affiches <- nb_x_affiches + 1; } // afficher la deuxieme serie d'espaces nb_esp_affiches <- 0; tant que nb_esp_affiches <- nb_espaces répéter { Ecrire(" "); nb_esp_affiches <- nb_esp_affiches + 1; }

nb_l <- nb_l + 1; Ecrire("\n"); }

exercice : écrivez un algorithme qui calcule le modulo (le reste de la division entière) des 10 premiers nombres entiers, en fonction du modulo lu au clavier. On dispose d'un opérateur mod qui produit le reste de la division entière.

exemple :

Entrez le modulo : 4 0 modulo 4 = 0 1 modulo 4 = 1 2 modulo 4 = 2 3 modulo 4 = 3 4 modulo 4 = 0 5 modulo 4 = 1 6 modulo 4 = 2 7 modulo 4 = 3

8 modulo 4 = 0 9 modulo 4 = 110 modulo 4 = 2

(solution)

Modulo des 10 premiers entiers

indice <- 0;

Ecrire("Entrez le modulo : ");Lire(modulo);

tant que indice <= 10 répéter { Ecrire(indice, " modulo ", modulo, " = ", indice mod modulo, "\n"); indice <- indice + 1;}

exercice : écrivez un algorithme qui affiche cette pyramide de nombres en utilisant des boucles (utilisez l'exercice qui affiche la pyramide de x et le modulo).

1 232 34543 4567654 567898765 67890109876 7890123210987 890123454321098 901234567654321090123456789876543210

TP 1

1. Écrivez un programme qui permute les valeurs de deux variables lues au clavier

2. Écrivez un programme qui effectue une permutation circulaire vers la droite de 4 variables lues au clavier

3. Écrivez un programme qui donne le maximum de 3 nombres lus au clavier et effectuez des tests pour :2 5 84 2 08 -6 1

4. Écrivez un programme qui calcule la moyenne de 4 nombres lus au clavier et donne le minimum

5. Écrivez un programme qui calcule le prix TTC d'un prix HT entré au clavier

6. Écrivez un programme qui calcule le pourcentage d'un nombre, ce nombre ainsi que le pourcentage sont entrés au clavier

7. Écrivez un programme qui fournit une valeur en francs à partir d'un prix entré en euros

8. Écrivez un programme qui donne une température en degrés celsius à partir d'une température Fahrenheit (C = (5/9) * (F - 32))

9. Écrivez un programme qui donne la mention d'un étudiant en fonction de sa note entrée au clavier

TP 2

1. Écrivez le programme qui affiche chaque numéro de marche montée par un robot qui se rend au 3ème étage, sachant qu'un étage comporte 20 marches

2. Écrivez un programme qui calcule la moyenne des notes entrées itérativement au clavier et qui affiche la moyenne quand l'utilisateur entre -1

3. Écrivez un programme qui calcule la factorielle d'un nombre entré au clavier

4. Modifiez ce programme pour qu'il demande le nombre dont on souhaite calculer la factorielle jusqu'à ce que l'utilisateur entre -1

5. Donnez le programme qui affiche le nombre de marches et le numéro de l'étage montés,

sachant que le nombre de marches par étage et le nombre d'étages à monter sont entrés au clavier. Utilisez deux boucles while.

Qu'est-ce qui sera affiché sur la console si on entre au clavier 2 pour l'étage et 0 pour le nombre de marches par étage ?

Qu'est-ce qui sera affiché sur la console si on entre au clavier 0 pour l'étage et 0 pour le nombre de marches par étage ?

6. Écrivez un programme qui affiche un rectangle du nombre de lignes par le nombre de colonnes donné par l'utilisateur. ex :

7. > entrez la largeur et la hauteur : 4 68. +--+9. | |10. | |11. | |12. | |13. +--+

>

14. Afficher le triangle de Pascal pour 8 lignes (de 0 à 7)

TP 3

1. Écrivez un programme qui trouve la précision de l'ordinateur, i.e. la valeur de la variable precision qui est telle que 1.0 + precision = 1.0.

2. Écrivez un programme qui réalise la pyramide de 19 x (vue en algorithmique) en utilisant un tableau de 19 cases. Ce tableau représente la ligne à afficher, au départ, il contient 19 x, à la ligne suivante deux espaces sont ajoutés (_xx...xx_), et ainsi de suite jusqu'à la dernière ligne qui ne comporte plus qu'un seul x.

3. Reprenez le programme de la factorielle pour qu'il utilise la ligne de commande pour connaître la valeur dont il faut calculer la factorielle.

4. Écrivez un programme qui permet de jouer au jeu du pendu. Le joueur 1 entre le mot, l'ordinateur l'enregistre et affiche une série de lignes blanches pour que le joueur 2 ne puisse pas lire le mot, il affiche ensuite une série d'étoiles qui correspond au nombre de lettres du mot à trouver. Le joueur 2 propose des caractères jusqu'à ce qu'il ait trouvé le mot, ou qu'il ait perdu (nombre de coups > 10). À chaque fois que le joueur 2 propose un caractère l'ordinateur affiche le mot avec des * et les caractères déjà trouvés

Entrez un mot : bonjour

*******caractere ? a*******caractere ? o*o**o**caractere ? u*o**ou*caractere ? n*on*ou*caractere ? j*onjou*caractere ? s

*onjou*caractere ? bbonjou*caractere ? rbonjourVOUS AVEZ GAGNE

5. Écrivez un programme qui permet à deux joueurs de joueur au jeu du morpion à neuf cases. Le principe est le suivant, dès que le joueur 1 a réussi à aligner 3 croix (3 * pour le joueur 2), il a gagné. S'il n'y a plus de cases de libre et qu'aucun joueur n'a gagné il y a match nul.

1 2 3A . . .B . . .C . . .

joueur 1 : A 2 1 2 3A . x .B . . .C . . .

joueur 2 : A 1 1 2 3A * x .B . . .C . . .

joueur 1 : B 2 1 2 3A * x .B . x .C . . .

joueur 2 : C 2 1 2 3A * x .B . x .C . * .

joueur 1 : B 1 1 2 3A * x .B x x .C . * .

joueur 2 : B 3 1 2 3A * x .B x x *C . * .

joueur 1 : A 3 1 2 3A * x xB x x *C . * .

joueur 2 : C 3 1 2 3

A * x xB x x *C . * *

joueur 1 : C 1 1 2 3A * x xB x x *C x * *

Le joueur 1 a gagné

TP 4

1. Écrivez une fonction int somme(int x, int y) qui retourne l'addition de x et y.

2. Écrivez une fonction void somme(int *resultat, int x, int y) qui additionne x et y et place le résultat de cette addition dans la variable resultat.

3. Écrivez une fonction minuscule char minuscule(char car) qui retourne le caractère en minuscule (sinon elle retourne le caractère car sans le modifier).

4. Écrivez une fonction minuscule void minuscule(char *car) qui modifie le caractère passé par adresse, elle le transforme en minuscule s'il est en majuscule.

5. Écrivez une fonction int compter_occurrences(char car, int taille, char *mot) qui retourne le nombre d'occurrences d'un caractère car dans une chaîne mot de taille taille. Utilisez cette fonction dans le main en lisant le mot avec un scanf puis essayez de l'utiliser lorsque le mot est entré sur la ligne de commandes.

6. Écrivez une fonction int compter_voyelles(int taille, char *mot) qui retourne le nombre de voyelles dans la chaîne mot de taille taille.

7. Réécrivez la fonction compter_occurrences avec la taille de la chaîne et le mot qui sont des variables globales.

TP 5

1. Modifiez le programme qui affiche un rectangle en fonction d'une largeur et une longueur donnée afin qu'il affiche des rectangles pour le fichier de test suivant :

2. 5 83. 8 54. 0 35. 1 36. 2 37. 3 38. 4 09. 15 110. 1 9

1 1

Vous écrirez une fonction void afficher_rectangle(int longueur, int hauteur) qui fait appel à la fonction void afficher_ligne(char car_cadre, char car_interieur, int nb) vue dans le cours sur les fonctions. La fonction afficher_rectangle sera appelée pour chaque ligne du fichier avec les données lues sur la ligne (1er nombre = largeur, 2ème nombre = hauteur).

> ./rect test.txt

rectangle de 8 lignes par 5 colonnes :+---+| || || || || || |+---+

rectangle de 5 lignes par 8 colonnes :+------+| || || |+------+

rectangle de 3 lignes par 0 colonnes :++||++



rectangle de 3 lignes par 3 colonnes :+-+| |+-+

rectangle de 0 lignes par 4 colonnes :

rectangle de 1 lignes par 15 colonnes :+-------------+

rectangle de 9 lignes par 1 colonnes :++||||||||||||||

++

rectangle de 1 lignes par 1 colonnes :++

Qu'est-ce que le test fait apparaître lorsque le rectangle a 0 ou 1 colonne ? Comment corriger ce problème ?

11. Écrivez un programme qui prend en entrée le nom du fichier contenant l'annuaire, ainsi que le nom, prénom, numéro de téléphone et l'e-mail d'une personne et qui génère un autre fichier annuaire en classant alphabétiquement la personne. NB : on suppose que les entrées de l'annuaire sont classées alphabétiquement. > more annuaire.txtAlessandra Denis 04 91 11 36 13 [email protected] Magali 04 91 11 36 13 [email protected] Sandrine 04 91 11 35 21 [email protected] > ./ajouter annuaire.txt Dupont Georges 04 91 22 43 44 [email protected]> more annuaire2.txtAlessandra Denis 04 91 11 36 13 [email protected] Magali 04 91 11 36 13 [email protected] Georges 04 91 22 43 44 [email protected] Sandrine 04 91 11 35 21 [email protected] >

12. Modifiez le programme qui affiche toutes les lignes de l'annuaire afin qu'il affiche le numéro de téléphone du nom d'une personne passé sur la ligne de commande. Si ce nom n'existe pas dans l'annuaire, il affichera un message d'erreur.

13. Écrivez un programme qui classe les entrées d'un annuaire alphabétiquement (par rapport uniquement au nom) et stocke l'annuaire trié dans un fichier annuaire_trie.txt

TP 6 : le black jack

But du jeu

Vous allez écrire un programme qui permet à un joueur de faire une partie de Black Jack. L'objectif principal de ce jeu de cartes est d'avoir une main qui vaut plus que celle de la banque, sans toutefois dépasser la valeur 21.

Lorsque le jeu commence, l'ordinateur distribue deux cartes au joueur ainsi qu'à lui-même. Une des deux cartes de l'ordinateur est visible pour le joueur. Le joueur peut demander une nouvelle carte ou s'abstenir. Au coup suivant, l'ordinateur peut lui-même décider de prendre une nouvelle carte ou de s'abstenir.

Le jeu cesse lorsque le joueur ou l'ordinateur ont dépassé 21, ou s'ils ont atteint 21 ou encore s'ils ont passé tous les deux leur tour.

Les cartes marquées de 2 à 10 gardent leur valeur, les figures (reines, rois, et valets) valent 10 points, l'as vaut 11 points ou 1 point. L'as prend la valeur 1 lorsque le score est supérieur à 21

et qu'il avait la valeur 11. ex : 3 de coeur + As de pique + 10 de carreau = 3 + 11 + 10 = 24 lorsque l'as vaut 11 et prend en fait la valeur 14 puisqu'on a dépassé 21 avec la valeur 11.

Variables globales et constantes

Vous utiliserez les variables globales ci-dessous :

short cartes[52];short nb_as_joueur;short nb_as_banque;

cartes est un tableau qui représente les 52 cartes du jeu, si la carte n'a pas encore été tirée la valeur dans la case correspondante est 0, si elle a été tirée par le joueur, la valeur est 2, et la valeur est 1 lorsque c'est la banque et que la carte est visible, 3 si c'est la carte cachée de la banque. Nous avons donc les constantes suivantes :

#define LIBRE 0#define BANQUE 1#define JOUEUR 2#define BANQUE_CACHEE 3

Pour s'y retrouver dans le tableau contenant toutes les cartes on définit des constantes qui donnent le début et la fin de chaque couleur. Les cartes sont classées dans l'ordre as, 2, 3, 4, ..., 10, valet, dame, roi pour chaque couleur, et les couleurs sont dans l'ordre coeur, carreau, pique, trèfle

#define DEB_COEURS 0#define FIN_COEURS 12#define DEB_CARREAUX 13#define FIN_CARREAUX 25#define DEB_PIQUES 26#define FIN_PIQUES 38#define DEB_TREFLES 39#define FIN_TREFLES 51

nb_as_joueur permet de stocker le nombre d'as dans la main du joueur, et nb_as_banque le nombre d'as dans la main de la banque. Lorsqu'on évaluera le score du joueur (ou de la banque) et que ce score sera supérieur à 21, si nb_as_joueur (nb_as_banque) est non nul, nous pourrons décrémenter de 10 pour chaque as de la main du joueur (ou de la banque).

Fonctions

écrivez la fonction short tirer_carte(short joueur) qui tire aléatoirement une carte entre 0 et 51 (52 cartes dans le jeu) et associe le joueur passé en paramètre (banque, banque cachee ou joueur) à cette carte dans le tableau cartes.

écrivez la fonction void afficher_carte(short num) qui affiche la carte num (donne la valeur et la couleur). Cette fonction affichera par exemple : 3 de coeur lorsqu'elle recevra le numero 2.

Pour la couleur on utilisera les constantes DEB_COEURS, FIN_COEURS, .... En ce qui concerne la valeur de la carte, l'opérateur modulo avec la valeur 13 fournit des valeurs de 0 à 12, 0 représentant l'as, 10 le valet, 11 la dame et 12 le roi, les autres

valeurs fournissent la valeur de la carte - 1 (la case 0 correspond a l'as de coeur, la 1 ou 2 de coeur et la case 2 au 3 de coeur...)

écrivez la fonction void afficher_mains(short joueur) qui affiche la main d'un joueur, i.e. elle parcourt le tableau cartes et si le joueur passé en paramètre correspond elle affiche la carte correspondante, en utilisant la fonction afficher_carte. NB : cette fonction n'affichera jamais la carte cachée de la banque puisque nous avons donné un code différent pour la banque et la carte banque cachée.

écrivez la fonction void afficher_mains_cachee(void) qui affiche la main de la banque, carte cachée incluse.

écrivez la fonction short donner_valeur_carte(short joueur, short carte) qui prend un numero de carte entre 0 et 51 et retourne sa valeur (10 pour valet, la dame et le roi, 11 pour l'as et les autres cartes gardent leur valeur). NB : cette fonction devra incrémenter nb_as_joueur ou nb_as_banque lorsqu'elle recevra un as.

écrivez la fonction short evaluer_score(short joueur, short carte_recue, short *score) qui met a jour le score en fonction de la carte reçue. Elle reçoit en paramètre score qui représente le score du joueur ou de la banque en fonction de l'appel evaluer_score(BANQUE, 2, &score_banque) ajoutera 3 au score de la banque par exemple.

La fonction principale

Lorsque le jeu commence, 2 cartes sont attribuées à la banque, la première étant cachée, et 2 cartes sont attribuées au joueur. Le joueur peut, une fois les cartes distribuées, soit demander une carte, soit décider de s'arrêter (par ex. si son score est 20, il s'arrêtera). L'ordinateur qui représente la banque, peut lui aussi demander une carte ( une fois que le joueur a fait son choix) ou s'arrêter. La banque demandera une carte si son score est inférieur à 17. Si le joueur a décidé ne plus demander de carte et que la banque a un score supérieur au joueur, la banque décidera de s'arrêter. La partie se poursuit jusqu'à ce qu'un des joueurs réalise un black jack (21), ou dépasse 21, ou que les deux joueurs aient décidé de s'arrêter.

Conseil : procédez par étapes

1. commencez par distribuer 2 cartes à la banque, et au joueur, affichez les mains et le score. 2. Puis écrivez la partie qui dit si quelqu'un a gagné et qui affiche la main de la banque avec la

carte cachée.3. Lorsque ces deux étapes fonctionnent écrivez une boucle qui tire une carte une fois pour le

joueur, une fois pour la banque et s'arrête lorsqu'il y a un black jack ou que le score est dépassé.

4. Ajoutez des instructions pour demander au joueur s'il souhaite tirer une carte ou arrêter, l'ordinateur continue à jouer jusqu'à ce qu'il dépasse le score

5. Ajoutez les instructions pour que l'ordinateur décide s'il tire une carte ou s'il s'arrête.

Exercice1 :Ecrire une application qui permet d’afficher les tringles d’étoiles suivantes : exemple (n=4)

* ******* * ******* ***** ** ******** *** *** ********* * **** *

Exercice2 :Soit deux suites récurrentes U et V :V0=0 Vn+1= SQRT ((1+Vn)/2)U0=2 Un+1=Un/ (Vn+1)Ecrire un programme qui affiche les n termes de Un avec n>=15

Exercice3 :Ecrire une analyse, un algorithme qui permet de calculer un terme d’indice nDe la suite ROBINSON Définie par :Ui=a alors Ui+1= apparition de chaque chiffre dans apparaît dans Ui

ExempleSi U0=1 alorsU1 = 11 ‘’1 Se répète 1 fois dans U0’’U2=21 ‘’1 Se répète 2 fois dans U1’’U3=1211 ’2 Se répète 1 fois et 1 se répète 1 fois dans U2’’U4=3112 etc-----------------------------------------U5=132112 ---------------------------------------------

Exercice4 :Ecrire un programme pascal qui permettant de calculer la somme suivante :i=n∑ (-1)i x2i / 2i!i=1

Exercice5 :Ecrire une analyse, un algorithme qui permet de saisir un entier N>0 remplir une matrice M par des entiers calculer la somme des éléments paires de M.

Exercice6 :On se propose de remplir une matrice M sous la forme d’une pyramide d’entier de la manière suivanteExemple : n=512 3 23 4 5 4 34 5 6 7 6 5 45 6 7 8 9 8 7 6 5

Exercice6 : (autre formulation de Bac 92)On se donne un entier naturel non nul U0, on se propose de construire la séquence d’entier (Un) définie par : i>=0,

Ui+1 est la somme des carrés des chiffres de Ui

Exemple : si Ui= 423 alors Ui+1=4²+2²+3²=29

On admet que la séquence (suite)Est cyclique, c'est-à-dire :Il existe, i+1Est stationnaire c'est-à-dire :Il existe i>=0 telque j>=i, Ui =Uj =11 – a/ calculer les 15 premiers termes de (Un) dans les cas suivants1-U0=58 2-U0 =28b/ préciser dans chaque cas la nature de suite (cyclique, stationnaire)Le but de ce problème est de trouver et afficher les termes de suite qui constitue un cycle si la suite et cyclique, afficher le nombre de termes de suite s’il est stationnaire pour tout Ui ≠1.2-décomposer le problème en module.3- analyser et déduire un algorithme de programme principal ainsi que les modules envisagés.

exercice langage c

Documents

Transcript of exercice langage c