Voir le DS1 2023 2024 Sujet
Exercices : 1 2
Il n’ya pas d’erreur normalement, si il y’en a envoyez un message a deltabot sur WhatsApp et je réglerai le soucis.
Exercice 1
- On définie les structures et les constantes utiles
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXCHAR 50 // Définition de la taille maximale d'une chaîne de caractères
typedef enum {
FOOTBALL,
PATINOIRE,
OMNISPORT,
PISCINE
} Type; // Déclaration d'une énumération pour les différents types de stades
typedef struct
{
char nom[MAXCHAR]; // Nom de la ville
int codepostal; // Code postal de la ville
int pop; // Population de la ville
} Ville; // Déclaration de la structure pour une ville
typedef struct
{
char nom[MAXCHAR]; // Nom du stade
int cap_max; // Capacité maximale du stade
int surface; // Surface du stade
int annee_constru; // Année de construction du stade
Ville ville; // Ville où se trouve le stade
Type type; // Type du stade
} Stade; // Déclaration de la structure pour un stade
|
- On créer la fonction pour afficher les détails d’une ville
1
2
3
4
| void afficheVille(Ville ville){
printf("nom : %s \n code postal : %d \n population %d\n", ville.nom, ville.codepostal, ville.pop);
}
|
- On créer la fonction pour calculer le ratio population/capacité maximale d’un stade
1
2
3
4
| float calculerRatio(Stade stade){
return stade.ville.pop / stade.cap_max;
}
|
- On créer la fonction pour comparer deux stades en fonction de leur capacité maximale et de leur surface
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| int compareStade(Stade s1, Stade s2){
if (s1.cap_max > s2.cap_max){
return 1;
} else if (s1.cap_max < s2.cap_max)
{
return -1;
} else {
if (s1.surface > s2.surface){
return 1;
} else if (s1.surface < s2.surface)
{
return -1;
} else {
return 0;
}
}
}
|
- On créer la fonction pour vérifier si deux villes sont identiques
1
2
3
4
5
6
7
| int memeVille(Ville v1, Ville v2){
if (v1.nom == NULL || v2.nom == NULL){
return -1;
}
return !strcmp(v1.nom, v2.nom) && ( v1.codepostal == v2.codepostal);
}
|
- On créer la fonction pour vérifier si un stade est valide pour accueillir un certain type d’événement
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| int stadeValide(Stade stade){
switch (stade.type)
{
case FOOTBALL:
return stade.cap_max > (stade.ville.pop * 0.01);
case PATINOIRE:
return stade.surface > 1800;
case OMNISPORT:
return (stade.cap_max > (stade.ville.pop * 0.01)) && (stade.surface > 10000 );
case PISCINE :
return stade.surface > 1250;
default:
return 0;
}
}
|
- On créer la fonction pour vérifier si une ville est candidate pour accueillir les jeux olympiques
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| int villeOlympiques(Ville ville, Stade TabStade[], int taille){
int nb_types[] = {0,0,0,0};
for (int i = 0; i < taille; i++)
{
if (stadeValide(TabStade[i]) && (memeVille(ville, TabStade[i].ville) == 1) ){
nb_types[TabStade[i].type] += 1;
}
}
for (int i = 0; i < 4; i++)
{
if (nb_types[i] == 0){
return 0;
}
}
return 1;
}
|
- On créer la fonction pour afficher les villes candidates à accueillir les jeux olympiques
1
2
3
4
5
6
7
8
9
10
11
12
| void villesCandidates(Ville Tabville[], int nb_villes, Stade TabStade[], int nb_stade ){
for (int i = 0; i < nb_villes; i++)
{
if (villeOlympiques(Tabville[i], TabStade, nb_stade))
{
afficheVille(Tabville[i]);
}
}
}
|
- Si vous voulez tester le code n’oublier pas de rajouter une fonction
main
1
2
3
4
| int main() {
return 0;
}
|
Exercice 2
- On définie les structures et les constantes utiles
1
2
3
4
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
- On créer la fonction pour créer un tableau de scores initialisé à zéro pour un nombre de joueurs donné
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| int* Tableau_des_score(int nb_joueur){
// Vérification du nombre de joueurs minimum
if (nb_joueur < 50){
printf("Pas assez de joueurs");
exit(EXIT_FAILURE);
}
// Allocation dynamique de mémoire pour le tableau des scores
int* TabScore = (int*)malloc(sizeof(int)*nb_joueur); //le (int*) est pas obligatoire
// Vérification de l'allocation mémoire
if (TabScore == NULL){
printf("Erreur d'allocation memoire");
exit(EXIT_FAILURE);
}
// Initialisation de tous les scores à zéro
for (int i = 0; i < nb_joueur; i++)
{
TabScore[i] = 0;
}
return TabScore;
}
|
On peut aussi utiliser calloc, la boucle est donc inutile si on utilise calloc car calloc initialise de base tout a 0
EXIT_SUCCESS et EXIT_FAILURE sont définie dans stdlib et permettent une meilleur lecture du code, exit() permet de sortir du programme avec un code d’erreur.
- On créer la fonction pour mettre à jour le score d’un joueur donné
1
2
3
| void majScore(int* TabScore, int numero_joueur, int valeur){
*(TabScore + numero_joueur) += valeur;
}
|
- On créer la fonction pour réallouer de la mémoire pour un tableau de scores en ajoutant des joueurs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| int* reallocScore(int* TabScore, int Nb_joueur, int nb_a_ajouter){
// Création d'un nouveau tableau de scores avec la taille mise à jour
int* NewTabScore = Tableau_des_score( Nb_joueur + nb_a_ajouter );
// Copie des scores du tableau initial vers le nouveau tableau
for (int i = 0; i < Nb_joueur; i++)
{
NewTabScore[i] = TabScore[i];
}
// Libération de la mémoire du tableau initial
free(TabScore);
return NewTabScore;
}
|
On peut aussi utiliser memcpy pour faire la copie du tableau
- On créer la fonction pour déterminer le joueur avec le score le plus élevé
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| void HighScore(int* TabScore, int Taille, int* score_max, int* numero_joueur){
// Initialisation du score maximum et du numéro de joueur
*score_max = TabScore[0];
*numero_joueur = 0;
// Parcours de tous les scores pour trouver le maximum
for (int i = 0; i < Taille; i++)
{
if (*score_max < TabScore[i]){
*score_max = TabScore[i];
*numero_joueur = i;
}
}
}
|
Exercices : 1 2