Ceci est une collection d'exemples de programmes C démontrant diverses fonctionnalités.
Génération de codes uniques (task1.c)
Ce programme génère cinq identifiants uniques en combinant un préfixe fixe avec un nombre aléatoire. ```
#include <stdio.h> #include <stdlib.h> #include <time.h>
#define NOMBRE_IDENTIFIANTS 5
int main() { int nombreAleatoire; int compteur; srand(time(NULL)); // Initialise le générateur de nombres aléatoires
for (compteur = 0; compteur < NOMBRE_IDENTIFIANTS; ++compteur) {
// Génère un nombre aléatoire entre 1 et 65
nombreAleatoire = rand() % 65 + 1;
// Affiche l'identifiant formaté
printf("20238331%04d\n", nombreAleatoire);
}
// system("pause"); // Optionnel : pour maintenir la console ouverte sur certains systèmes
return 0;
}
Le code génère des nombres aléatoires dans l'intervalle \[1, 65\] et les utilise pour former des identifiants de type "20238331XXXX". ### Analyse de caractères pour le contrôle de flux (`task2.c`)
Ce programme lit des caractères d'entrée et exécute différentes actions basées sur la valeur du caractère, simulant le contrôle d'un feu de circulation. ```
#include <stdio.h>
#include <stdlib.h>
int main() {
char entreeCaractere;
// Boucle tant qu'il y a une entrée et qu'elle n'est pas la fin de fichier
while (scanf(" %c", &entreeCaractere) != EOF) { // Notez l'espace avant %c pour consommer les blancs
switch (entreeCaractere) {
case 'r':
printf("stop!\n");
break;
case 'g':
printf("go go go\n");
break;
case 'y':
printf("wait a minute\n");
break;
default:
printf("something must be wrong\n");
break;
}
// Note : L'appel à getchar() après scanf peut consommer des caractères indésirables
// ou être utilisé pour s'assurer que le prochain scanf commence à une nouvelle ligne.
// Si vous voulez ignorer le reste de la ligne après chaque entrée, une approche plus robuste pourrait être nécessaire.
}
// system("pause"); // Optionnel
return 0;
}
Il utilise une structure switch pour réagir aux entrées 'r', 'g', 'y' et à toute autre entrée. ### Jeu de devinette de date (task3.c)
Ce programme génère une "date porte-bonheur" aléatoire (un jour du mois) et permet à l'utilisateur de la deviner en trois tentatives. ```
#include <stdio.h> #include <stdlib.h> #include <time.h>
int main() { int jourChance; int tentative; int nombreTentatives = 3;
srand(time(NULL)); // Initialise le générateur de nombres aléatoires
jourChance = rand() % 31 + 1; // Génère un jour entre 1 et 31
printf("Devinez le jour de chance du mois (entre 1 et 31) : ");
for (int compteurTentatives = 0; compteurTentatives < nombreTentatives; ++compteurTentatives) {
scanf("%d", &tentative);
if (tentative == jourChance) {
printf("Wow, vous avez trouvé !\n");
return 0; // Sortir si la réponse est correcte
} else if (tentative < jourChance) {
printf("Vous avez deviné trop tôt, votre jour de chance n'est pas encore arrivé.\n");
} else {
printf("Vous avez deviné trop tard, votre jour de chance est plus tôt.\n");
}
// Si ce n'est pas la dernière tentative, demander de réessayer
if (compteurTentatives < nombreTentatives - 1) {
printf("Essayez encore : ");
}
}
// Si le joueur n'a pas trouvé après toutes les tentatives
printf("Vous avez épuisé vos tentatives. Je vais vous révéler votre jour de chance : %d\n", jourChance);
return 0;
}
Il donne des indices si la supposition est trop tôt ou trop tard et révèle la réponse si le joueur échoue. ### Calcul de série complexe (`task4.c`)
Ce programme calcule la somme d'une série où chaque terme est une fraction. Le dénominateur de chaque terme est construit en répétant un chiffre `a`, `n` fois. ```
#include <stdio.h>
#include <stdlib.h> // Nécessaire pour exit, bien que non utilisé ici
int main() {
int chiffre_a;
int nombre_n;
double somme_serie = 0.0;
long long denominateur_courant; // Utilise un type plus grand pour le dénominateur
printf("Entrez le chiffre 'a' et le nombre de termes 'n' (séparés par un espace) : ");
// Boucle tant que l'entrée est valide
while (scanf("%d %d", &chiffre_a, &nombre_n) == 2) {
denominateur_courant = chiffre_a; // Initialise le dénominateur avec 'a'
somme_serie = 0.0; // Réinitialise la somme pour chaque nouvelle entrée
for (int i = 1; i <= nombre_n; ++i) {
// Ajoute le terme courant à la somme
// Le terme est i / dénominateur_courant
somme_serie += (double)i / denominateur_courant;
// Construit le prochain dénominateur en répétant 'a'
// Exemple: si a=3, n=1 -> denom=3; n=2 -> denom=33; n=3 -> denom=333
if (i < nombre_n) { // Évite de recalculer pour le dernier terme
denominateur_courant = denominateur_courant * 10 + chiffre_a;
}
}
// Affiche le résultat
printf("Pour n = %d, a = %d, la somme S = %.6lf\n", nombre_n, chiffre_a, somme_serie);
printf("Entrez le chiffre 'a' et le nombre de termes 'n' (séparés par un espace) : ");
}
return 0;
}
La série calculée est S = 1/a + 2/(aa) + 3/(aaa) + ... + n/(a...a) (n fois). ### Table de multiplication (task5.c)
Ce programme affiche une table de multiplication stylisée, allant de 1x1 jusqu'à 9x9. ```
#include <stdio.h>
int main() { int multiplicateur; int multiplicande;
// Boucle pour le multiplicande (la première ligne de la table, 1 à 9)
for (multiplicande = 1; multiplicande <= 9; ++multiplicande) {
// Boucle pour le multiplicateur (la colonne, de 1 jusqu'au multiplicande actuel)
for (multiplicateur = 1; multiplicateur <= multiplicande; ++multiplicateur) {
// Affiche le produit
printf("%d*%d=%-3d\t", multiplicateur, multiplicande, multiplicateur * multiplicande);
}
printf("\n"); // Passe à la ligne suivante après avoir complété une rangée
}
return 0;
}
La sortie forme un triangle rectangle de multiplications. ### Affichage de motif graphique (`task6.c`)
Ce programme dessine un motif pyramidal en utilisant des caractères comme 'O', '<h>' et 'I I', avec une indentation pour créer une forme de diamant ou de pryamide. ```
#include <stdio.h>
#include <stdlib.h>
int main() {
int taille; // La hauteur de la pyramide
int ligne_idx, espace_idx, caract_idx;
printf("Entrez la taille (nombre de lignes) de la pyramide : ");
scanf("%d", &taille);
// Boucle pour chaque niveau de la pyramide, de haut en bas
for (ligne_idx = 0; ligne_idx < taille; ++ligne_idx) {
// Imprime les espaces pour l'indentation
for (espace_idx = 0; espace_idx < taille - 1 - ligne_idx; ++espace_idx) {
printf(" "); // Deux espaces pour un meilleur alignement
}
// Imprime la première ligne de caractères (par exemple, 'O')
// Le nombre de caractères diminue à chaque niveau
for (caract_idx = 0; caract_idx < 2 * (taille - ligne_idx) - 1; ++caract_idx) {
printf(" O "); // Caractère 'O' suivi d'espaces
}
printf("\n"); // Nouvelle ligne après la première rangée de caractères
// Indentation pour la deuxième rangée
for (espace_idx = 0; espace_idx < taille - 1 - ligne_idx; ++espace_idx) {
printf(" ");
}
// Imprime la deuxième ligne de caractères (par exemple, '<h>')
for (caract_idx = 0; caract_idx < 2 * (taille - ligne_idx) - 1; ++caract_idx) {
printf("<h> "); // Caractère '<h>' suivi d'un espace
}
printf("\n"); // Nouvelle ligne
// Indentation pour la troisième rangée
for (espace_idx = 0; espace_idx < taille - 1 - ligne_idx; ++espace_idx) {
printf(" ");
}
// Imprime la troisième ligne de caractères (par exemple, 'I I')
for (caract_idx = 0; caract_idx < 2 * (taille - ligne_idx) - 1; ++caract_idx) {
printf("I I "); // Caractère 'I I' suivi d'un espace
}
printf("\n"); // Nouvelle ligne après la dernière rangée de caractères pour ce niveau
}
return 0;
}
</h></h></h>
Le motif ressemble à une pyramide inversée ou à un diamant composé de répétitions de motifs. ### Synthèse des compétences acquises
- Maîtrise de l'instruction
switchpourr gérer plusieurs conditions. - Compréhension de l'utilisation de
rand()etsrand()pour générer des nombres aléatoires.