Le C avancé

Durée : 4h30

Objectifs :

Attention :

À chaque étape de programmation, vous devez vérifier si le programme :

• Compile sans warning
• Obtient les résultats attendus
• Avant de coder, il faut écrire un algo avec un papier et un stylo !

  

Exercice 0 : Avant de commencer

1. Depuis le terminal, ajouter l’arborescence suivante :

2. Déplacer vous dans le répertoire précédement créé

3. Pour compiler un programme, on utilise l’instruction suivante :

gcc -Wall exo.c -o nomExecutable

4. Pour executer un programme, on utilise l’instruction suivante :

./nomExecutable

Exercice 1 : C’est Noël

0. Créer un répertoire exo1 dans lequel on ajoutera le fichier exo1.c contenant le code suivant :

#include <stdio.h>
#include <stdlib.h>

/* exo 1 :  le sapin */
int main(){
    return 0;
}

1. Écrire une procédure qui prend en paramètre un nombre puis affiche un sapin de noël en utilisant uniquement les caractères ASCII. Tout d’abord, le haut du sapin se dessine par un triangle isocèle en utilisant uniquement les caractères ’*’ et ’ ’(espace). Ensuite, le tronc est dessiné par 2 caractères ’@’. L’entier n permet de connaître la taille du haut du sapin.

/* Auteur : ... */
/* Date :  ... */
/* Résumé :  procédure  qui prend en paramètre un nombre puis affiche un sapin de noël en utilisant uniquement les caractères ASCII */
/* Entrée(s) :  La taille du sapin */
/* Sortie(s) :  aucunes */
void sapin (int nbBranches);

Voici un exemple pour n = 5 :

    *
   ***
  *****
 *******
*********
    @
    @

2. Ecrire le programme principal qui demande à l’utilisateur de saisir la taille du sapin.

3. Écrire une nouvelle procédure qui rajoute des boules de noël toutes les 2 lignes et une étoile en haut du sapin.

/* Auteur : ... */
/* Date :  ... */
/* Résumé :  procédure  qui prend en paramètre un nombre puis affiche un sapin de noël en utilisant uniquement les caractères ASCII. Cette procédure rajoute des boules de noël toutes les 2 lignes et une étoile en haut du sapin*/
/* Entrée(s) :  La taille du sapin */
/* Sortie(s) :  aucunes */
void pimpMySapin (int nbBranches);

4. Ajouter dans votre programme principal, l’appel à cette nouvelle procédure.

Exercice 2 : Le nombre d’Armstrong

0. Créer un répertoire exo2 dans lequel on ajoutera le fichier exo2.c contenant le code suivant :

#include <stdio.h>
#include <stdlib.h>

/* exo 2 :  Le nombre d’Armstrong */
int main(){
    return 0;
}

1. Écrire un prédicat qui permet d’identifier si un nombre, passé en paramètre est un nombre d’Armstrong. C’est-à-dire que ce nombre est égal à la somme des cubes des chiffres qui le composent.

Exemple: 153 : 13 + 53 + 33 = 1 + 125 + 27 = 153

Quelques nombres d’Armstrong : 1, 153, 370, 371, 407.

/* Auteur : ... */
/* Date :  ... */
/* Résumé : prédicat qui permet d'identifier si un nombre, passé en paramètre est un nombre d’Armstrong */
/* Entrée(s) :  Le nombre à tester (strictement positif */
/* Sortie(s) :  aucunes */
int estArmstrong (int nb);

2. Écrire le programme principal qui demande à l’utilisateur de saisir un nombre et qui, via le prédicat précédement créé, vérifie si c’est un nombre d’armstrong.

Exercice 3 : Les nombres binaires

0. Créer un répertoire exo3 dans lequel on ajoutera le fichier exo3.c contenant le code suivant :

#include <stdio.h>
#include <stdlib.h>

/* exo 3 : Les nombres binaires */
int main(){
    return 0;
}

1. Écrire une procédure qui prend en paramètre un entier naturel n et affiche son écriture binaire (en base 2).

/* Auteur : ... */
/* Date :  ... */
/* Résumé : procédure qui prend en paramètre un entier naturel n et affiche son écriture binaire (en base 2) */
/* Entrée(s) :  un entier */
/* Sortie(s) :  aucunes */
void nombreBinaire (int nb);

2. Écrire le programme principal qui demande à l’utilisateur de saisir un nombre et qui fait appel à la procédure nombreBinaire

Exercice 4 : Rang de factorielle

0. Créer un répertoire exo4 dans lequel on ajoutera le fichier exo4.c contenant le code suivant :

#include <stdio.h>
#include <stdlib.h>

/* exo 4 : Rang de factorielle */
int main(){
    return 0;
}

2. Écrire une fonction qui calcul la factoriel d’un entier passé en paramétre.

/* Auteur : ... */
/* Date :  ... */
/* Résumé : fonction qui calcule pour un entier k donné, le plus grand entier n tel que n ! ≤ k . Attention, Ne pas faire trop de multiplications  */
/* Entrée(s) :  un entier */
/* Sortie(s) :  un entier */
int rangFactorielle (int k);

3. Écrire le programme principal qui permet de cacluler la factorielle d’un nombre saisie par l’utilisateur.

Exercice 5 : Cryptographie 101

0. Créer un répertoire exo5 dans lequel on ajoutera le fichier exo5.c contenant le code suivant :

#include <stdio.h>
#include <stdlib.h>

/* exo 5 : Cryptographie 101 */
int main(){
    return 0;
}

Un des plus anciens systèmes de cryptographie (aisément déchiffrable) consiste à décaler les lettres d’un message pour le rendre illisible. Ainsi,les A deviennent des B, les B des C, etc.

1. Écrire une procédure qui prend une chaine de caractères et qui la code selon ce principe.

/* Auteur : ... */
/* Date :  ... */
/* Résumé : une procédure qui prend une chaine de caractères et qui la code selon ce principe, puis affiche le résultat à l’écran  */
/* Entrée(s) :  une chaine de caractères */
/* Sortie(s) :  aucunes */
void crypto101 (char maPhrase[100],char maPhraseCryptee[100]);

2. Écrire une procédure qui réalise l’opération inverse.

/* Auteur : ... */
/* Date :  ... */
/* Résumé : une procédure qui prend une chaine de caractères cryptee et qui la decode selon ce principe, puis affiche le résultat à l’écran  */
/* Entrée(s) :  une chaine de caractères */
/* Sortie(s) :  aucunes */
void decrypto101 (char maPhraseCryptee[100],char maPhrase[100]);

3. Écrire le programme principal permettant à un utilisateur de saisir une chaîne de caractères et qui fait appel aux procèdures précédement créées afin d’encrypter les caractères.

Exemple de fonction traitant des chaînes de caractères

Afin de saisir une chaîne complexe, le fichier exCh.c illustre l’utilisation des fonctions fgets et getline. L’utilisation de ces fonctions utilisent néanmoins la notion de pointeurs, qui sera abordée plus tard. Attention à la taille de vos variables. Étudiez le comportement de ce code si vous saisissez des chaînes inférieures à la taille prédéfinie, puis supérieures.

Différence entre gets et scanf

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
  char maPhrase[100];

  printf("Entrez la phrase : \n");
  scanf("%s", maPhrase);

  printf("La phrase que vous avez rentrée avec le scanf : %s ", maPhrase);

  printf("Entrez la phrase : \n");
  fgets(maPhrase,sizeof(char)*100,stdin);

  printf("La phrase que vous avez rentrée avec le fgets : %s ", maPhrase);


  return 0;
}

Comment connaître la taille d’une chaîne de caractères

Pour connaître la taille d’une chaîne de caractères, vous pouvez utiliser la fonction strlen. Attention : pour pouvoir l’utiliser, il faut importer la bibliothéque string.h

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
    int taille;
    char maPhrase[100];

    printf("Entrez la phrase : \n");
    fgets(maPhrase,sizeof(char)*100,stdin);
    taille=strlen(maPhrase)-1;
    printf("La taille de maPhrase est %ld \n",taille);
    return 0;
}

L’encodage des caractères

Afin de décaler les lettres on peut utiliser les notations de l’alphabet de lettre à chiffre. Par exemple, la lettre a si on l’affiche en format Entier ça devient 98.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
    int taille;
    printf("Entrez la phrase : \n");
    fgets(maPhrase,sizeof(char)*100,stdin);
    taille=strlen(maPhrase)-1;

    for (int i=0; i<taille; i++){
        printf("%c => %d ", maPhrase[i],maPhrase[i]);
    }
    printf("\n");
    return 0;
}

Exercice 6 : Le chiffre de César

0. Créer un répertoire exo6 dans lequel on ajoutera le fichier exo6.c contenant le code suivant :

#include <stdio.h>
#include <stdlib.h>

/* exo 6 : Le chiffre de César */
int main(){
    return 0;
}

Une amélioration du principe précédent consiste à opérer avec un décalage arbitraire. Au lieu de décaler de 1 les lettres, c’est l’utilisateur qui choisira le décalage.

Par exemple, si on choisit un décalage de 12, les A deviennent des M, les B des M …

1. Écrire une procédure qui prend une chaine de caractères, le décalage et qui la code selon ce principe.

2. Écrire une procédure qui réalise l’opération inverse.

3. Écrire le programme principal.