Réalisée par :

Doha Saif & Fadoua Benlabbiji

Décortication du problème : Inverser une chaîne de

caractères

I. Analyse préambule
• Compréhension du problème :
Écrire un programme qui prend une chaîne de caractères et
retourne cette chaîne inversée.
Exemple :
" ruojnoB " → "Bonjour".
• Entrées :
✓ Une chaîne de caractères saisie par l’utilisateur (type char [ ] ).
✓ La taille maximale est fixée à 100 caractères pour éviter les
dépassements de mémoire.
✓ Lecture avec getchar.
• Sorties :
La même chaîne mais afficher en ordre inversé.
• Cas particuliers :
o Chaîne vide → sortie vide.
o Chaîne d’un seul caractère → sortie identique.
o Chaîne avec espaces → inversée en gardant les espaces.
o Chaîne avec caractères spéciaux → inversée normalement.

II. Analyse fonctionnelle :

• Fonction 1 : lire la chaine (lire_chaine)

✓ Rôle : lire une chaîne depuis le buffer et la stocker dans un tableau.

✓ Entrée : Un tableau de caractères , Un caractères lus un par un avec
getchar().
 ✓ Sortie : Un tableau rempli avec la chaine saisie inversée.
✓ Principe : Une boucle qui lit jusqu’à \n ou fin de fichier, puis ajoute
'\0' pour terminer la chaîne.

• Fonction 2 : afficher le tableau en inverse (afficher_tab_inv)

✓Rôle : afficher une chaîne en ordre inversé sans la modifier.

✓ Entrée : tableau de caractères (chaîne).
✓Sortie : affichage direct sur la console
✓Principe : calculer la longueur avec strlen , puis parcourir la
chaîne de la fin vers le début et afficher chaque caractère avec
putchar.
• Fonction 3 : main
✓ Rôle : orchestrer le programme.
✓ Entrée appel de lire_chaine pour remplir le tableau et inverser la
chaine.
✓ Sortie : appel de afficher_tab_inv pour afficher la chaîne inversée.

III. Dossier de programmation

• Structure adaptée :
✓ Utilisation d’un tableau de caractères (char[]).
• Variables utilisées :

✓ char tab[TAILLE_MAX]; → stockage de la chaîne.

✓ char c; → caractère lu avec getchar().
✓ int i; → index pour remplir le tableau.
✓ int n; → longueur de la chaîne calculée avec strlen.

• Algorithme :

1. Initialiser un tableau de taille maximale.

2. Lire la chaîne caractère par caractère avec getchar().
3. Arrêter la lecture à \n ou fin de fichier.
4. Ajouter '\0' pour terminer la chaîne.
5. Calculer la longueur avec strlen.
6. Parcourir la chaîne de la fin vers le début.
7. Afficher chaque caractère avec putchar().
• Le programme :
#include <stdio.h>
#include <string.h>

#define TAILLE_MAX 100

// Fonction 1 : lire la chaîne

void lire_chaine(char tab[]) {
char c;
int i = 0;

printf("Entrer la phrase à inverser : ");

while ((c = getchar()) != '\n' && c != EOF && i < TAILLE_MAX - 1)
{
tab[i++] = c;
}
tab[i] = '\0'; // fin de chaîne
}

// Fonction 2 : afficher le tableau en inverse

void afficher_tab_inv(char tab[]) {

int n = strlen(tab);

printf("Chaine inversée (affichage direct) : ");

for (int i = n - 1; i >= 0; i--) {
putchar(tab[i]); // affiche caractère par caractère
}
printf("\n");
}

// Fonction 3 : main
int main() {
char chaine[TAILLE_MAX];

lire_chaine(chaine); // lecture depuis le buffer

afficher_tab_inv(chaine); // affichage inversé

return 0;
}
 Décortication du problème : Éliminer les doublons
dans un tableau d’entiers

I. Analyse préambule :

• Compréhension du problème :
Écrire un programme qui prend un tableau d’entiers et supprime les
doublons, c’est-à-dire qu’il ne garde qu’une seule occurrence de
chaque valeur.
Exemple :
Entrée : {1, 2, 3, 2, 4, 1} Sortie : {1, 2, 3, 4}
• Entrées :
✓ Un tableau d’entiers saisi par l’utilisateur.
✓ Taille maximale fixée (ex. 100 éléments).

• Sorties :
✓ Le même tableau mais sans doublons.
• Cas particuliers

✓ Tableau vide → sortie vide.

✓ Tableau avec un seul élément → sortie identique.
✓ Tableau avec tous les éléments identiques → sortie avec un seul
élément.
✓ Tableau déjà sans doublons → sortie identique.

II. Analyse fonctionnelle

• Fonction 1 : Lire le tableau (lire_tableau)

 ✓ Rôle : lire les entiers depuis l’utilisateur et les stocker dans un
tableau.
✓ Entrée : nombre d’éléments et valeurs saisies.
✓ Sortie : tableau rempli.

• Fonction 2 : Eliminer les doublants du tableau (eliminer_doublons)

✓ Rôle : supprimer les doublons du tableau.

✓ Entrée : tableau d’entiers et sa taille.
✓ Sortie : tableau modifié sans doublons et ca nouvelle taille.
✓ Principe : comparer chaque élément avec les suivants, supprimer
les répétitions en décalant les cases.

• Fonction 3 : Afficher un tableau (afficher_tableau)

✓ Rôle : afficher le tableau final.

✓ Entrée : tableau d’entiers et sa taille.
✓ Sortie : affichage direct sur la console.

• Fonction 4 : main

• Rôle : orchestrer le programme.

• Entrée : appel de lire_tableau et appel de la fonction
eliminer_doublons puis afficher_tableau.
• Sortie : le tableau afficher sans doublant.

III. Dossier de programmation :

• Structure adaptée

✓ Utilisation d’un tableau d’entiers (int [ ]).

• Variables utilisées :

✓ int tab[TAILLE_MAX]; → stockage du tableau.

✓ int n; → taille du tableau.
✓ int i, j, k; → indices pour parcourir et supprimer les doublons.

• Algorithme :
 1. Lire la taille du tableau et ses éléments.
2. Pour chaque élément du tableau :
o Comparer avec les suivants.
o Si doublon trouvé, décaler les éléments vers la gauche et
réduire la taille.
3. Afficher le tableau final sans doublons.

• Programme :

#include <stdio.h>
#define TAILLE_MAX 100

// Fonction 1 : lire le tableau

void lire_tableau(int tab[], int n) {

printf("Entrez le nombre d'elements : ");

scanf("%d", n);

printf("Entrez les elements du tableau :\n");

for (int i = 0; i < n; i++) {
scanf("%d", &tab[i]);
}
}

// Fonction 2 : éliminer les doublons

void eliminer_doublons(int tab[], int n) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n ) {
if (tab[i] == tab[j]) {
// Décalage vers la gauche
for (int k = j; k < n - 1; k++) {
tab[k] = tab[k + 1];
}
n--; // réduire la taille
} else {
j++; //avancer si n’est pas un doublant
}
 }
}
}

// Fonction 3 : afficher le tableau

void afficher_tableau(int tab[], int n) {
printf("Tableau sans doublons : ");
for (int i = 0; i < n; i++) {
printf("%d ", tab[i]);
}
printf("\n");
}

// Fonction 4 : main
int main() {
int tab[TAILLE_MAX];
int n;

lire_tableau(tab, n);
eliminer_doublons(tab, n);
afficher_tableau(tab, n);

return 0;
}
Décortication du problème : Associer à une date
(1901–2009) son jour de la semaine

I. Analyse préambule :

✓ Comprendre le problème : donner le jour de la semaine pour toute

date comprise entre 1-1-1901 et 31-1-2009.

✓ Entrées : Trois entiers : j (jour), m (mois), a (année).

o Contraintes :

➢ a ∈ [1901, 2099]
➢ m ∈ [1, 12]
➢ j doit être valide selon le mois et l’année (ex. février =
28 ou 29 jours selon bissextile).

✓ Sortie :

➢ Un entier 0...6 représentant le jour de la semaine.

➢ Une chaîne de caractères pour affichage (Dimanche, Lundi,
…).

✓ Contrôles :

➢ rejet si la date est hors intervalle ou invalide (ex. 31-02-

2004).

II. Analyse fonctionnelle :

• Fonction 1 : Tester si l’année est bissextile (est _bissextile ) :

✓ Rôle : dire si l’année est bissextile ou non .

✓ Entrée : l’année.
✓ Sortie : 1 si l’année est bissextile ,0 sinon.
✓ Règle : (année % 4 == 0 && année % 100 != 0) || (année % 400
== 0).
• Fonction 2 : Le nombre de jour par mois (Jours_dans_mois) :

✓ Rôle : donner le nombre de jours dans un mois.

✓ Entrée : l’année et le mois.
✓ Sortie : soit 29,28,30 ou 31.
✓ Contrainte : février dépend de la fonction est_bissextile.

• Fonction 3 : Validation de la date saisie par l’utilisateur (Date_valide) :

✓ Rôle : vérifier que la date est correct et dans l’intervalle

proposé.
✓ Entrée : l’année ,le mois et le jour.
✓ Sortie : 1 si la date est valide ,0 sinon.
✓ Règle : contrôle des bornes et du nombre de jours par mois.

• Fonction 4 :
Le nombre de jour entre la date saisie et celle de référence le 1-1-
1901(jours_écoulées) :

✓ Rôle : calcule le nombre de jours écoulées depuis le 1-1-1901

✓ Entrée : l’année , le mois et le jour.
✓ Sortie : la nombre de jours (entier >=0).

• Fonction 3 : Détermination de jour de le semaine (jour_semaine) :

✓ Rôle :Déterminer l’indice de jour de la semaine convenable a la

date saisie
✓ Entrée : l’année , le mois et le jour.
✓ Sortie : entier 0 …6
✓ Regle : (2 + jours _écoulées) % 7. // le +2 car le jour reference
été un Mardi =2.

• Fonction 6 : nom du jours (nom_jour) :

✓ Rôle : Traduire l‘indice en nom du jour.

✓ Entrée : entier 0 … 6.
 ✓ Sortie : chaine de caractères (nom du jour :
Dimanche , Lundi…),

III. Dossier de programmation :

• Variables utilisées :
➢ int j → jour saisi par l’utilisateur.
➢ int m → mois saisi par l’utilisateur.
➢ int a → année saisie par l’utilisateur.
➢ long days → nombre de jours écoulés depuis le
01/01/1901.
➢ int semaine → indice du jour de la semaine (0 =
Dimanche, …, 6 = Samedi).
➢ int jour_ref → valeur de référence (2, car 01/01/1901
était un Mardi).
➢ int total → compteur utilisé dans jours_écoulées pour
accumuler les jours.
➢ int y → variable de boucle pour parcourir les années
➢ int mm → variable de boucle pour parcourir les mois.
➢ int w → résultat final du calcul du jour de la semaine.

• Algorithme :
Début :
Lire jour, mois, année
// Étape 1 : Vérifier la validité de la date
Si (année < 1901 OU année > 2099) alors
Afficher "Date invalide"
FinSi
Si (mois < 1 OU mois > 12) alors
Afficher "Date invalide"
FinSi
Si (jour < 1 OU jour > jours_dans_mois(mois, année)) alors
Afficher "Date invalide"
FinSi
// Étape 2 : Calculer le nombre de jours écoulés depuis 01/01/1901
nbJours ← 0
Pour chaque année de 1901 à annee-1 :
nbJours ← nbJours + (366 si est_bissextile sinon 365)
Pour chaque mois de 1 à mois-1 :
nbJours ← nbJours + jours_dans_mois(moisCourant, annee)
nbJours ← nbJours + (jour - 1)
 // Étape 3 : Déterminer le jour de la semaine
jourSemaine ← (jourRef + nbJours) mod 7
// Étape 4 : Afficher le résultat
Afficher "Le ", jour, "/", mois, "/", annee, " correspond à : ",
jours[jourSemaine]
Fin
• Programme:
// Fonction : tester si une année est bissextile
int est_bissextile(int annee) {
return ( (annee % 4 == 0 && annee % 100 != 0) || (annee % 400 == 0) );
}

// Fonction : donner le nombre de jours dans un mois

int jours_dans_mois(int mois, int annee) {
switch (mois) {
case 1: return 31;
case 2: return est_bissextile(annee) ? 29 : 28;
case 3: return 31;
case 4: return 30;
case 5: return 31;
case 6: return 30;
case 7: return 31;
case 8: return 31;
case 9: return 30;
case 10: return 31;
case 11: return 30;
case 12: return 31;
default: return 0;
}
}

// Fonction : vérifier si une date est valide

int date_valide(int jour, int mois, int annee) {
if (annee < 1901 || annee > 2099) return 0;
if (mois < 1 || mois > 12) return 0;
int maxj = jours_dans_mois(mois, annee);
if (jour < 1 || jour > maxj) return 0;
return 1;
}

// Fonction : calculer le nombre de jours écoulés depuis 01/01/1901

long jours_depuis_ref(int jour, int mois, int annee) {
 long total = 0;
for (int y = 1901; y < annee; y++) {
total += est_bissextile(y) ? 366 : 365;
}
for (int mm = 1; mm < mois; mm++) {
total += jours_dans_mois(mm, annee);
}
total += (jour - 1);
return total;
}

// Fonction : calculer le jour de la semaine

int jour_semaine(int jour, int mois, int annee) {
long nbJours = jours_depuis_ref(jour, mois, annee);
int jour_ref = 2; // 01/01/1901 était un Mardi
return (jour_ref + nbJours) % 7;
}

// Fonction : traduire l’indice en nom du jour

const char* nom_jour(int code) {
switch (code) {
case 0: return "Dimanche";
case 1: return "Lundi";
case 2: return "Mardi";
case 3: return "Mercredi";
case 4: return "Jeudi";
case 5: return "Vendredi";
case 6: return "Samedi";
default: return "Jour invalide";
}
}

// Programme principal
int main() {
int jour, mois, annee;

printf("Entrez une date (jj mm aaaa) : ");

if (scanf("%d %d %d", &jour, &mois, &annee) != 3) {
printf("Erreur de saisie.\n");
return 1;
}
if (!date_valide(jour, mois, annee)) {
printf("Date invalide ou hors intervalle.\n");
 return 1;
}
int w = jour_semaine(jour, mois, annee);
printf("Le %d/%d/%d correspond à : %s\n", jour, mois, annee, nom_jour(w));
return 0;
}