Créez un dossier/répertoire TPC sur votre compte dans lequel vous écrirez tous les TP de cette UE.

    TP 1 Boucles et tests


    Ecrire un programme minimaliste en langage C, inclure et utiliser les fonctions de flot std::cin et std::cout de la bibliothèque iostream, savoir le compiler et l'exécuter.
  • Écrire un programme qui demande à l'utilisateur d'entrer un entier au clavier et qui affiche le carré et le cube de cet entier.
    entrez un entier : 5
    Le carre de 5 est : 25
    Le cube de 5 est : 125
  • Écrire un programme qui lit un entier au clavier et qui affiche un message indiquant si cet entier est pair ou impair, exemple d'utilisation :
    entrez un entier : 43
    l'entier 43 est impair
  • Écrire un programme qui lit deux entiers au clavier et qui affiche le plus grand des deux, exemple d'utilisation :
    entrez deux entiers : 5 2
    la plus grande valeur est 5
  • Écrire un programme qui demande à l'utilisateur d'entrer un entier n et affiche n fois la chaine de caractère "Bonjour", exemple :
    entrez un entier : 3
    Bonjour 1 fois
    Bonjour 2 fois
    Bonjour 3 fois
  • Écrire un programme qui calcule la factorielle (algorithme itératif) d'un entier entré au clavier :
    entrez un entier : 6
    La factorielle de 6 est : 720
  • Écrire un programme qui demande à l'utilisateur d'entrer un entier au clavier tant que celui-ci est positif et qui affiche Fin lorsque le programme est terminé. Exemple :
    entrez un entier : 5
    entrez un entier : 15
    entrez un entier : 8
    entrez un entier : -25
    Fin
  • Écrire un programme qui calcule et affiche les n premiers termes de la suite de Fibonnacci, n sera saisi par l'utilisateur.
    U1=1, U2=1, Un = Un-2 + Un-1
    Exemple d'utilisation :
    entrez un entier : 8
    1 1 2 3 5 8 13 21
  • Écrire un programme qui effectue la division euclidienne de deux entiers. En entrée le programme demandera la saisie de deux entiers a et b et en sortie il affichera le quotient et le reste de la division entière de a/b. Ne pas utiliser l'opérateur % du langage C. Faites cet exercice en n'utilisant que les opérateurs + et -.
  • Écrire un programme qui affiche la table de multiplication jusqu'à 10 d'un entier lu aus clavier, exemple d'utilisation :
    entrez un entier : 5
    0 5 10 15 20 25 30 35 40 45 50
  • Écrire un programme qui effectue la saisie d'un entier n et qui affiche la somme des n premières puissances de 2 (sans utiliser la bibliothèque mathématique).
    i.e : s = 1 + 2 + 4 + 8 + 16 + .... + 2^n

    TP 2 Procédures et fonctions

    Ecrire des procédures d'affichage permettant de résoudre les exercices suivants, et les tester par des appels. On utilisera un seul fichier procedure.cpp pour rassembler toutes les procédures et les appels de test.
  • Écrire une procédure qui réalise l'échange du contenu de deux variables.
    int a=3, b=2; Permute(a,b); // Donne a=2 et b=3
  • Écrire une procédure Ligne qui affiche une ligne de n caractères * dans lequel le nombre de caractères sera passé par paramètre.
    Ligne(5); // Donne *****
    Modifier la procédure Ligne pour afficher une ligne de n caractères, le nombre de caractères et le caractère seront les paramètres
  • Écrire une procédure Rectangle qui affiche à le un rectangle, le caratère, la largeur et la hauteur seront 3 valeurs saisies par l'utilisateur, par exemple :
    Rectangle(5,3,'#');
    #####
    #####
    #####
  • Écrire une fonction qui teste si un entier est premier
    Afficher tous les nombres premiers inférieurs à 100.
  • Écrire une fonction qui teste si un entier est parfait (un nombre parfait est un entier qui est égale à la somme de ses diviseurs, n exclus).
    Exemple : 6 est parfait car 6 = 1 + 2 + 3

    Afficher tous les nombres parfaits inférieurs à 1000.
  • Écrire une fonction (non récursive et sans utiliser de tableau) ) qui retourne le nème terme de la suite de Syracuse : \(S_0\) sera initialisée par l'utilisateur (valeur entière), et \(S_n = \frac{S_{n-1}}{2}\) si \(S_{n-1}\) est pair, \(S_n = 1 + 3S_{n-1} \) sinon

    Dans cette fonction, n et S(0) seront des paramètres de la fonction
    Ensuite écrire une fonction qui affiche les n premiers termes de cette suite (n et S(0) seront de paramètres de cette fonction)
    Exemple, si S(0)=10 et n=12, cette dernière fonction devra afficher :
    10 5 16 8 4 2 1 4 2 1 4 2
  • Écrire une fonction qui retourne la racine carrée d'un nombre en utilisant l'algorithme suivant : soit a est le nombre dont on veut extraire la racine carrée.
    La racine carrée de ce nombre est obtenue en calculant la limite de la suite : \[x_{n+1} = \frac{x_n + a/x_n}{2} \qquad x_0=a\]
    Pour arrêter la récurrene, on peut se fixer le nombre d'itérations à effectuer ou bien s'arrêter quand le résultat est proche de la solution. Testez les deux.
  • Écrire une fonction qui retourne la racine carrée d'un nombre positif passé en paramètre de fonction en utilisant la dichotomie.
    A est le nombre dont on veut extraire la racine carrée.
    On se donne un intervalle dans lequel on est sur de trouver le résultat, exemple [0 A].
    On teste si la valeur intermédiaire de cet intervalle, A/2, est plus petite ou plus grande que le résultat recherché.
    S'il est plus petit, on réitère sur l'intervalle [1 A/2], s'il est plus grand sur l'intervalle [A/2 A].
    Modifiez l'algorithme afin qu'il fonctionne aussi pour les valeurs comprises entre 0 et 1.
  • Écrire une fonction qui retourne un nombre aléatoire compris entre deux entiers a et b, a < b (utiliser la fonction rand()).

    • Un corrigé est accessible ici.

TP 3 Tableaux

On utilisera un seul fichier tableau.cpp pour rassembler toutes les procédures et les appels de test. Les tableaux seront définis à comme des vecteurs de taille variable de type std::vector .
  • Écrire une fonction qui réalise la saisie au clavier d'un tableau de float.
  • Écrire une fonction qui affiche le contenu du tableau.
  • Écrire une fonction qui renverse le contenu du tableau.
  • Écrire une fonction qui retourne la somme des éléments du tableau.
  • Écrire une fonction qui retourne la moyenne des éléments du tableau. Compléter avec une fonction Ecart qui calcul l'écart type.
  • Écrire une fonction Identique qui passe en paramètre 2 tableaux d'entiers de dimension n et qui retourne la valeur true si les 2 tableaux sont identiques (i.e. meme valeur à la meme position), false sinon.
  • Écrire une fonction qui trie dans l'ordre croissant un tableau d'entier passé en paramètre en utilisant l'algorithme du tri par bulle (utilisez la fonction permutation de deux entiers du TP2.1).
  • Écrire une fonction Alea qui initialise un tableau de n entiers avec des valeurs aléatoires entre 2 bornes a et b (n, a et b seront des paramètres de la fonction)

  • Ecrivez une fonction qui teste si un tableau d'entier est trié dans l'ordre croissant.
    Cette fonction est indispensable pour tester les fonctions de tri, en effet, il n'est pas pensable, dans la suite du tp, d'afficher un tableau de plusieurs dizaines de milliers d'éléments pour vérifier si le tri s'est bien déroulé !

  • Dans le programme principal : tester chacune des fonctions précédentes sur des tableaux de petite dimension, par exemple int T[]={12,1,65,12,876,0,13,87,-14} ;
    Initialiser un tableau de 100 000 entiers compris entre -100 000 et +100 000 avec la fonction Alea. Trier ce grand tableau avec la fonction de tri et tester si ce tableau a ete trie correctement.

    • Un corrigé est accessible ici.

TP 4 Chaines de caractères

On utilisera un seul fichier chaine.cpp pour rassembler toutes les procédures et les appels de test. On utilisera le type std::string.
  • Écrire une fonction qui renvoie la valeur true si une chaine passée en paramètre est un palindrome, false sinon.
  • Écrire une fonction qui transforme en majuscule tous les caractères minuscules d'une chaine de caractères.
  • Écrire une fonction qui renvoie la valeur true si cette chaine est exclusivement composée de caractères de l'alphabet, false sinon.
  • Re-coder une fonction qui analyse deux chaines de caractères composées exclusivement de lettres de l'alphabet et renvoie la valeur -1 si la première est située avant la deuxième dans l'ordre alphabétique, 0 si elles sont égales, 1 si la première est située après la deuxième.
    Note: cette fonction existe dans la classe std::string sous la forme d'une surcharge des opérateurs de comparaison.
  • Écrire une fonction Conversion qui reçoit en paramètre une chaine de caractères composée uniquement des caractères 0 1 2 3 4 5 6 7 8 9 et qui retourne l'entier correspondant : Conversion("23582"); renverra l'entier 23582.
  • Écrire une fonction qui passe en paramètre d'entrée un tableau de caractères de dimension n et en sortie un tableau d'entiers qui comptabilise le nombre d'occurrence de chacun des caractères (en majuscule ou minuscule) du premier tableau. Exemple :
    std::string a = "Bonjour";
    std::vector n;
    Compte(A,n);     // Le vecteur n devrait contenir {0,1,0,0,0,0,0,0,0,1,0,0,0,1,2,0,0,1,0,0,1,0,0,0,0,0}

    • Un corrigé est accessible ici.

TP 5 Structures et classes

    On utilisera un fichier .hpp pour déclarer les nouvelles structures et les déclarations de fonctions, un fichier .cpp pour le code du corps des fonctions. Le programme principal sera codé dans exe.cpp.
  • Définir dans un fichier rationnel.h une classe Rationnel avec deux entiers représentant le numérateur et le dénominateur, avec les champes protégés, et les constructeurs publiques : écrire un constructeur vide, et un constructeur avec paramètres ; on devra pouvoir écrire :
    Rationnel a(2,3), b; // a représente 2/3 et b initialisé à 0/1.
  • Écrire une fonction d'affichage, on traitera les cas particuliers: 0/4 devra afficher 0, 5/1 devra afficher 5.
  • Écrire les fonctions d'addition, de soustraction, de multiplication de nombres rationnels.
  • Écrire une procédure Inverse inversant la fraction.
  • Écrire une procédure transformant le rationnel en une forme irréductible. On rappelle la fonction récursive de calcul du PGCD :
    int pgcd(int a,int b) {
     int r = 1;
     while(r != 0) {
      r = a%b;
      if(r == 0) { return b; }
      else { a = b; b = r; }
     } return r; }
    Appeler cette fonction dans les fonctions de multiplication, d'addition, de soustraction pour simplifier les fractions résultats avant de les retourner.
  • Ecire le fichier Makefile pour compiler le programme à partir des sources exe.cpp, rationnel.h et rationnel.cpp.
  • Surcharger les opérateurs d'addition, de soustraction, de multiplication de nombres rationnels, et l'opérateur de flot ; on devra pouvoir écrire :
    Rationnel c = a + b * 2.0; std::cout << c << std::endl; // Calcul et affichage.
  • Dans un fichier exe.cpp, include l'en-tête rationnel.h et tester les fonctions précédentes en calculant par exemple la somme 1/2+1/3, puis son produit avec 6/7, en affichant le résultat, puis en simplifiant la fraction sous forme irréductible, et en affichant à nouveau le résultat.

TP 6 Classes et documentation

On utilisera un fichier .hpp pour déclarer les nouvelles classes et les déclarations de fonctions, un fichier .cpp pour le code du corps des fonctions. Le programme principal sera codé dans exe.cpp.
La documentation devra être codée au format doxygen et générée à l'aide de la commande doxygen -g code.oxy pour générer le fichier de configuration, puis doxygen code.oxy pour générer la documentation.
  • Définir une classe Entier permettant de représenter de très grands nombres entiers sous leur forme décimale, à l'aide d'un tableau de chiffres codés sur des caractères (prendre par exemple 60 chiffres).
  • Ecrire un constructeur définissant un grand Entier à partir d'un entier de type int.
  • Écrire une fonction permettant d'afficher ce nombre.
  • Ecrire une fonction qui additionne deux nombres de type Entier et une fonction de multiplication. Pour cette dernière, on écrira deux fonctions utilitaires permettant de multiplier un Entier par un nombre à un seul chiffre, et une fonction multipliant un Entier par une puissance de 10 (décalage).
  • Écrire une fonction permettant de calculer la factorielle d'un Entier passé en paramètre.
  • Tester les fonctions précédentes en calculant la factorielle de 27, le résultat doit être 10 888 869 450 418 352 160 768 000 000.
  • Veiller à ce que toutes les classes et fonctions soient documentées, et vérifier la génération de documentation.