Algorithmique et Programmation - Banque d'exercices

Remarque : jusqu'en 2018, les conventions du langage algorithmique étaient un peu différentes
– les tableaux sont dynamiques (la taille n'est pas forcément fixée à la déclaration) et l'opération redim
permet de fixer la taille d'un tableau.
– les tableaux et enregistrements sont supposés être toujours passés par référence, les autres
paramètres par valeur.

Thème : tableaux et enregistrements

1- L'informatique au service de la santé (45 mn - 2009/1) - Correction

2- L'informatique au service du ministère du travail (45 mn - 2009/2) - Correction

3- L'informatique au service des transports aériens (45 mn - 2010/1) - Correction

4- L'informatique au service des traders (45 mn - 2010/2) - Correction

5- L'informatique au service des rencontres (60 mn - 2011/1) - Correction

6- Analyse de réseau social (60 mn - 2011/2) - Correction

7- Intentions de vote (60 mn - 2012/1) - Correction

8- Jeu, set et match (45 mn - 2012/2) - Correction

9- Traçabilité de la viande (60 mn - 2013/1) - Correction

10- Paradis fiscal (60 mn - 2013/2) - Correction

11- Écoutes téléphoniques (60 mn - 2014/1) - Correction

12- Coupe du monde de football (60 mn - 2014/2) - Correction

13- Épidémie (60 mn - 2015/1) - Correction

14- Séismes (60 mn - 2015/2) - Correction

15- Énergie électrique (60 mn - 2016/1) - Correction

16- Migration (45 mn - 2016/2) - Correction

17- Assistants parlementaires (60 mn - 2017/1) - Correction

18- Trains (60 mn - 2017/2) - Correction

19- ParcourSup (60 mn - 2018/1) - Correction

20- Sécurité routière (45 mn - 2018/2) - Correction

21- Météorologie (60 mn) - Correction

 1- L'informatique au service de la santé (45 mn)
Des épidémiologistes veulent étudier la propagation de la grippe. Ils disposent de données décrivant
trois types d'événements épidémiologiques : contamination, guérison ou décès. À chaque événement est
associé le numéro de sécurité sociale du patient et la date de l'événement.

1- Écrire la déclaration d'un type enregistrement permettant de représenter une date avec un jour, un
mois et une année.

2- Écrire la déclaration d'un type enregistrement permettant de représenter un événement

épidémiologique avec le numéro de sécurité sociale du patient (entier), la date de l'événement et le type de
l'événement (contamination, guérison ou décès).

On suppose que tous les événements épidémiologiques sont stockés dans un tableau
d'enregistrements. On suppose qu'on dispose d'une fonction egalDate qui prend en entrée deux dates et renvoie
vrai si les dates sont les mêmes et faux sinon, et d'une fonction distDate qui prend en entrée deux dates et
renvoie la distance entre les deux dates sous forme d'un entier positif qui représente le nombre de jours
séparant les deux dates.

3- Écrire une fonction qui prend en entrée un tableau d'enregistrements d'événements épidémiologiques
et une date et renvoie le nombre de décès ayant eu lieu à cette date.

4- Les épidémiologistes veulent pouvoir identifier les contaminations proches dans le temps. Écrire une
fonction qui prend en entrée un tableau d'enregistrements d'événements épidémiologiques et une date et qui
renvoie, parmi les événements du tableau qui sont de type contamination, celui dont la date est la plus proche
de celle passée en paramètre (sans qu'elle soit forcément égales).

2- L'informatique au service du ministère du travail (45 mn)

Le ministère du travail veut disposer d'un système d'information permettant d'étudier la population
active. Le ministère veut connaître, pour chaque actif, son diplôme le plus élevé, depuis combien de temps il est
sur le marché du travail (durée en nombre d'années) et l'activité qu'il exerce. Une activité est décrite par un type
d'activité (les 3 types possibles sont fonctionnaire, salarié du privé, profession libérale) et le revenu annuel brut.

1- Écrire la déclaration d'un type enregistrement permettant de représenter une activité.

2- Écrire la déclaration d'un type enregistrement permettant de représenter un actif.

3- Écrire une fonction qui prend en entrée un tableau d'actifs et un entier n supposé positif et renvoie le
nombre de fonctionnaires qui ont fini leurs études depuis plus de n années.

4- Le ministère veut savoir si, pour un diplôme donné, ceux qui en sont titulaires sont plus nombreux à
être fonctionnaires qu'à travailler dans le secteur concurrentiel (salarié du privé ou profession libérale). Écrire
une fonction qui prend en entrée un tableau d'actifs et un diplôme et renvoie vrai si, parmi les personnes
possédant ce diplôme, il y a plus de fonctionnaires que de non fonctionnaires.

3- L'informatique au service des transports aériens (45 mn)

Les compagnies aériennes veulent gérer automatiquement le cas des passagers qui ont raté leur avion
(pour cause d'éruption volcanique ou autre). On suppose qu'un type enregistrement Date est déjà disponible,
ainsi qu'un type énuméré Ville (ses valeurs représentent toutes les villes disposant d'un aéroport). On suppose
également qu'il existe une fonction distance(Date d1, Date d2), qui retourne un entier dont la valeur absolue est
le nombre de jours séparant d1 et d2 (cet entier est positif si d1 est antérieure à d2, nul si d1 = d2 et négatif si
d1 est postérieure à d2). Il faut maintenant représenter les données sur les vols et des fonctions permettant de
traiter ces données.
 1- Écrire la déclaration d'un type enregistrement permettant de représenter un vol avec un numéro de
vol (nombre entier), une ville de départ, une ville d'arrivée, une date et un nombre de places encore disponibles.

2- Écrire une fonction récursive qui prend en paramètre un tableau de vols et un numéro de vol et
décrémente de 1 le nombre de places disponibles sur le vol correspondant au numéro.

3- Écrire une fonction qui prend en paramètres un tableau de vols, une ville de départ, une ville d'arrivée
et une date et renvoie le prochain vol reliant les deux villes sur lequel il reste au moins une place disponible (ce
vol doit avoir lieu le plus tôt possible, mais à une date postérieure à celle donnée en paramètre). Si aucun vol du
tableau ne vérifie ces conditions, on peut retourner la valeur null qui correspond à un "enregistrement vide".

4- L'informatique au service des traders (45 mn)

Une banque d'affaire veut pouvoir gérer informatiquement les transactions de ses traders à la bourse où
sont cotées les entreprises. Une entreprise est caractérisée par un nom, un état de santé économique (A+, A, B
ou C), le prix courant de son action (nombre réel) et le nombre total d'actions émises par l'entreprise. Un paquet
d'actions détenu par la banque est caractérisé par l'entreprise qui a émis les actions, le prix auquel les actions
ont été achetées (prix par action, nombre réel), le nombre d'actions du paquet et le nom du trader qui les a
achetées pour la banque.

1- Écrire les 3 déclarations de type permettant de représenter l'état d'une entreprise, une entreprise et
un paquet d'actions.

2- On veut trouver parmi les paquets d'actions détenus par la banque celui qu'il est préférable de
vendre. Écrire une fonction qui prend en paramètre un tableau de paquets d'actions et renvoie le paquet d'action
qu'il est préférable de vendre, c'est-à-dire le paquet pour lequel le bénéfice est le plus élevé. Ce bénéfice est
égal au prix de vente (nombre d'actions du paquet fois le prix courant de l'action) moins le prix d'achat (nombre
d'actions du paquet fois le prix d'achat de l'action). Seuls les paquets d'actions d'entreprises qui sont dans l'état
C sont à prendre en compte, les actions des entreprises dans les états A+, A ou B pouvant encore voir leur prix
augmenter. Si aucun paquet ne correspond à ces critères, on peut renvoyer la valeur null qui correspond à un
"enregistrement vide".

3- Écrire une fonction qui prend en paramètres un tableau de paquets d'actions et un nom de trader et
renvoie le bonus que la banque verse au trader. Ce bonus dépend de la valeur courante des actions achetées
par le trader et de leur valeur d'achat. La valeur d'achat (respectivement courante) des actions achetées par le
trader est égale à la somme des valeurs d'achat (respectivement courantes) des paquets d'actions qu'il a
achetés, chaque paquet valant le prix d'achat (respectivement courant) de l'action fois le nombre d'actions du
paquet. Si la valeur courante des actions achetées par le trader est inférieure à la valeur d'achat, le bonus est
nul, sinon il est égal à 20% de la différence entre la valeur courante et la valeur d'achat.

5- L'informatique au service des rencontres (60 mn)

Un site Web de rencontre doit permettre de mettre en relation les clients du site en fonction de leurs
passe-temps. Chaque client indiquera donc sur le site ses passe-temps parmi jeu, sport, jardinage, cuisine,
theatre. Vous êtes chargé de développer le programme qui gérera les données relatives aux clients.

1- Écrire la déclaration d'un type Hobby pour pouvoir représenter les passe-temps possibles, puis la
déclaration d'un type Client, chaque client ayant un identifiant entier, une adresse mail et plusieurs passe-temps.
On suppose que chaque client a au moins un passe-temps.

2- Écrire une fonction sameHobbies qui prend en paramètres deux Client et retourne vrai s'ils ont
exactement les mêmes passe-temps, et faux sinon.

3- Écrire une fonction soulmates qui prend en paramètres un Client c, un tableau de Client tab, et
renvoie tous les Client contenus dans tab qui ont les mêmes passe-temps que c. On suppose que c n'est pas
dans le tableau tab.
 6- Analyse de réseau social (60 mn)
On veut écrire un programme pour analyser les pages web d'un réseau social. Une page est
représentée par le nom de son propriétaire, sa date de création et le nombre d'internautes qui visitent la page
chaque jour. On suppose qu'il existe un type de données Date, qui représente une date, et une fonction avec
retour Date creerDate(int a, int m, int j) qui prend en paramètres les année, mois et jour d'une date et renvoie la
Date correspondante.

1- Proposer une structure de données pour représenter les pages du réseau social. Écrire un
programme qui initialise les données relatives à la page de Toto, créée le 13 juin 2010 et visitées tous les jours
par 234 internautes.

2- Écrire une fonction qui prend en entrée un tableau de pages et renvoie le nombre moyen
d'internautes qui visitent les pages du tableau.

3- Écrire une fonction qui prend en entrée un tableau de pages et renvoie vrai s'il existe au moins deux
pages ayant le même propriétaire et faux sinon.

On veut maintenant représenter les liens entre les pages du réseau social. Chaque propriétaire de page
peut en effet lier à sa page les pages de ses amis.

4- Améliorer la structure de données pour pouvoir représenter, pour chaque page, les pages qui lui sont
liées.

5- Écrire une fonction qui prend en entrée un tableau de pages, deux noms d'internautes, et renvoie vrai
s'il existe des pages des deux internautes qui sont liées, et faux sinon. Il est possible que les internautes
possèdent plusieurs pages dans le réseau, ou aucune.

7- Intentions de vote (60 mn)

Un institut de sondage veut réaliser un programme informatique pour analyser les intentions de vote
pour l'élection présidentielle de 2012. Les données à représenter portent sur les candidats à l'élection, les
catégories socio-professionnelles des citoyens et les intentions de votes dans chaque catégorie.

1- Écrire la déclaration d'un type Candidat pour pouvoir représenter les candidats possibles qui sont, par
ordre alphabétique : Bayrou, Hollande, Joly, Lepage, Lepen, Melanchon, Morin, Nihous, Sarkozy, Villepin.

2- Écrire la déclaration d'un type Categorie qui représente les données d'une catégorie socio-
professionnelle avec un nom, un nombre de citoyens, et un revenu moyen. Par exemple la catégorie des agents
de la fonction publique d'état a pour nom "agent de l'état", comprend 3681370 personnes et a pour revenu
annuel net moyen 26362 euros (source INSEE).

3- Écrire la déclaration d'un type Vote qui représente les intentions de vote des catégories socio-
professionnelles. Chaque vote associe une catégorie, un candidat, et le pourcentage de personnes de la
catégorie qui déclarent voter pour le candidat en question. Par exemple 0,01\% des agents de l'état ont
l'intention de voter pour Villepin.

4- Écrire une fonction qui prend en paramètres un tableau de Vote et une Categorie et renvoie le
Candidat préféré de la catégorie, c'est-à-dire celui qui recueille le plus d'intentions de vote dans cette catégorie.

5- Écrire une fonction qui prend en paramètres un Candidat et un tableau de Vote et renvoie le revenu
moyen des citoyens qui ont l'intention de voter pour ce candidat. Pour calculer le revenu moyen, il faut calculer
la somme des revenus de tous ceux qui déclarent voter pour le candidat, et diviser ce revenu total par le nombre
de citoyens déclarant voter pour le candidat.
 8- Jeu, set et match (45 mn)
On veut écrire un programme pour gérer les résultats des matchs de tennis dans les tournois officiels.
Un match est constitué de sets, eux-mêmes constitués de jeux. Un match est décrit par le nom du tournoi dans
le cadre duquel il s'est déroulé, les deux noms des joueurs qui ont disputé le match, et le score. Le score
regroupe les résultat des différents sets (il peut y avoir entre 3 et 5 sets dans un match). Chaque set est décrit
par deux entiers qui donnent le nombre de jeux remportés par chaque joueur (le set le plus disputé de l'histoire
du tennis s'est terminé à 70-68).

Par exemple, le match entre Rafael Nadal et Roger Federer, joué lors de l'Open d'Australie 2012, a eu
pour score 6-7, 6-2, 7-6, 6-4 (cela signifie que dans le premier set Nadal a remporté 6 jeux et Federer en a
remporté 7, dans le deuxième set Nadal a remporté 6 jeux et Federer 2 et ainsi de suite).

1- Proposer une structure de données pour représenter les matchs.

2- Écrire un programme qui initialise les données relatives au match entre Nadal et Federer.

3- Écrire une fonction qui prend en entrée un tableau de matchs (tableau au sens informatique) et le
nom d'un tennisman et renvoie le nombre de jeux perdus par le tennisman durant ses matchs (par exemple,
dans le match décrit plus haut, Nadal a perdu 7+2+6+4=19 jeux et Federer en a perdu 6+6+7+6=25).

9- Traçabilité de la viande (60 mn)

La Commission Européenne veut mettre en place un outil informatique de suivi des lots de viande produits en
Europe.

1- Écrire la déclaration d'un type Viande ayant pour valeurs : cheval, boeuf, canard, poulet, mouton,
porc. Écrire la déclaration d'un type Site représentant les types d'entreprises agroalimentaires : élevage, abattoir,
usine de transformation, usine de conditionnement.

2- Écrire la déclaration d'un type représentant les entreprises agroalimentaires, décrites par un nom, un
type et un pays. On suppose qu'il existe un type énuméré Pays dont les valeurs sont les différents pays.

3- Écrire la déclaration d'un type Lot qui représente les lots de viande. Un lot possède un identifiant
(entier), un type de viande, un poids et la liste des entreprises par lesquelles il est passé. Exemple de lot :
537,45kg de viande de cheval, portant l'identifiant 12345 et passé par les trois entreprises suivantes : l'élevage
Ferma Satu Mare situé en Roumanie, l'abattoir Slachthuis van Maastricht situé aux Pays-Bas et l'usine de
transformation Spanghero située en France.}.

4- On veut pouvoir trouver les lots d'un type donné. Écrire une fonction qui prend en paramètres un
tableau de Lot et un type de viande et retourne un tableau de Lot contenant uniquement les lots du type spécifié.

5- On veut pouvoir trouver tous les lots qui sont passés par une entreprise donnée. Écrire une fonction
qui prend en paramètres un tableau de Lot et le nom d'une entreprise et affiche à l'écran les identifiants des lots
qui sont passés par l'entreprise. La fonction doit également retourner le poids total de viande traitée dans
l'entreprise. On suppose que le tableau ne contient pas deux fois le même lot.

10- Paradis fiscal (60 mn)

Le ministère des finances veut développer un programme pour détecter l'évasion fiscale. Il dispose pour
cela des données concernant les opérations bancaires importantes (de plus de 1000 euros) des banques. Une
opération bancaire est décrite par un numéro de compte bancaire (chaine de caractères), une somme (qui peut
être négative s'il s'agit d'un retrait) et une date. On suppose qu'il existe déjà un type Date représentant les dates
et qu'on peut comparer deux dates avec l'opérateur =.
 Une banque est décrite par un identifiant international (chaine de caractères), un pays (on se limite à
France, Monaco, Suisse, Luxembourg), si elle est suspectée de faire de faciliter la fraude fiscale ou non, et la
liste des opérations bancaires réalisées sur des comptes de cette banque.

1- Proposer des types de données permettant de représenter ces données de façon structurée.

2- Écrire une fonction qui prend en entrée un tableau d'opérations bancaires et une opération o et, s'il
existe dans le tableau une opération réalisée à la même date que o et d'un montant inverse, renvoie l'indice de
cette opération dans le tableau. Si plusieurs opérations de ce type existent, on renvoie l'indice de la première
opération rencontrée. La fonction renvoie -1 si une telle opération n'existe pas. Par exemple, si l'opération o a
pour montant -5000 euros (il s'agit donc d'un retrait) réalisé le 27 mai 2012, il faut trouver une opération de 5000
euros réalisée le 27 mai 2012.

3- Écrire une fonction qui prend en entrée un tableau de banques et une opération o et vérifie s'il existe
dans une banque suspectée de faciliter la fraude une opération du montant inverse du montant de o et réalisée
à la même date. La fonction renvoie l'identifiant de la première banque trouvée et qui a réalisée une telle
opération, et renvoie une chaine vide ("") si aucune banque n'est trouvée.

11- Écoutes téléphoniques (60 mn)

La National Security Agency américaine (NSA) veut mettre en place un outil informatique d'analyse des
conversations téléphoniques. On suppose qu'il existe déjà un type Chaine représentant les chaines de
caractères et qu'il est possible de comparer deux valeurs de ce type à l'aide de l'opération =. On suppose
également qu'il existe déjà un type enregistrement Date qui représente les dates. On suppose qu'on peut
comparer deux valeurs du type Date à l'aide des opérations habituelles < > et =.

1- On veut représenter le niveau de cryptage des appels. Écrire la déclaration d'un type Cryptage avec
pour valeurs possibles : haut, moyen et bas.

2- Écrire la déclaration d'un type Appel représentant les appels téléphoniques décrits par deux
personnes (l'appelant et l'appelé) dont on connait le nom, une date de début, une durée (en secondes), un
niveau de cryptage et un ensemble de mots-clés qui apparaissent dans la conversation téléphonique. Exemple
d'appel (fictif) : A. Merkel a téléphoné à F. Hollande le 23/03/2014 à 15h57 durant 234 secondes sur une ligne
hautement sécurisée pour parler de "Ukraine", "Kiev", "Ianoukovitch", "Poutine", "Sotchi", "médaille d'or".

3- On veut savoir combien de temps une personne donnée a passé au téléphone durant une certaine
période. Écrire une fonction qui prend en entrée un tableau d'Appel, un nom n, deux Date d1 et d2 et renvoie la
somme des durées des appels reçus ou passés par la personne de nom n entre les dates d1 et d2.

4- On veut savoir si une personne parle au téléphone de sujets sensibles (comme par exemple
"bombe", "attentat", "aéroport Notre-Dame des Landes"). Écrire une fonction qui prend en entrée un tableau
d'Appel, un nom n et un tableau de Chaine contenant des mot-clés et renvoie vrai si la personne de nom n a
reçu ou passé au moins un appel dans lequel apparait un des mots-clés du tableau de Chaine.

12- Coupe du monde de football (60 mn)

On veut réaliser un programme pour gérer les données concernant les matchs de la coupe du monde de
football. Chaque match est représenté par les noms des deux équipes qui l'ont disputé, le nombre de buts
marqués par chaque équipe.

1- Proposer un ou des types de données structurés permettant de représenter les données concernant
les matchs de la coupe du monde football.

2- Écrire une fonction qui prend en entrée un tableau des matchs de la coupe du monde et le nom d'une
équipe et renvoie le nombre total de buts marqués par cette équipe au cours de la compétition.
 3- Écrire une fonction qui prend en entrée un tableau des matchs de la coupe du monde et renvoie un
tableau de matchs ne contenant que les matchs nuls (matchs où les deux équipes ont marqué le même nombre
de buts).

13- Épidemie (60 mn)

L'Organisation Mondiale de la Santé veut réaliser un programme pour suivre, analyser et combattre les
épidémies. Pour ce faire, les états sanitaires de différentes villes touchées par une épidémie doivent être
représentés dans le programme.

1- On veut créer une échelle de niveau d'alerte épidémique correspondant à différents types
d'événements épidémiologiques : la détection d'un virus chez les animaux, l'infection d'humains sans
transmission, la transmission inter-humaine, la propagation incontrôlée du virus. Ecrire la déclaration d'un type
NiveauEpidémique avec pour valeurs possibles : détection, infections, transmissions, pandémie.

2- On veut, pour chaque ville, connaitre le nombre de personnes infectées et le nombre de morts pour
chaque semaine de l'épidémie. Ecrire la déclaration d'un type Ville représentant les villes avec un nom, un
nombre d'habitants, un niveau d'alerte épidémique, le nombre de personnes infectées pour chaque semaine, et
le nombre de morts pour chaque semaine. Exemple : dans la ville d'Amiens, 134381 habitants, le niveau d'alerte
est actuellement à "transmissions" et, la première semaine il y a eu 3 personnes infectées et aucune de
décédée, la deuxième semaine 8 infections et 1 décès, et la troisième semaine 7 infections et 5 décès.

3- On veut pouvoir connaitre, pour une ville donnée, le nombre total de personnes ayant survécu à
l'infection, c'est-à-dire qui ont été infectées durant l'épidémie mais qui n'en sont pas (encore) mortes. Exemple :
cette fonction appelée sur la ville exemple de la question 2 renverra 18-6 = 12 survivants. Ecrire une fonction qui
prend en entrée une Ville et renvoie le nombre total de survivants.

4- On veut savoir dans quelle ville il y a eu le plus de morts par rapport à la population de la ville. Ecrire
une fonction qui prend en entrée un tableau de Ville et renvoie le nom de la ville où le rapport [nombre total de
morts / population] est le plus élevé

14- Séismes (60 mn)

On veut réaliser un programme pour analyser les données concernant les tremblements de terre.
Chaque séisme est représenté par le lieu de l'épicentre, la magnitude (un réel de 0 à 10) et la durée (en
secondes). Un lieu est représenté par un nom et deux réels pour la latitude et la longitude.

1- Proposer un ou des types de données structurés permettant de représenter les données concernant
les tremblements de terre.

2- Écrire une fonction qui prend en entrée un tableau de tremblements de terre et le nom d'un lieu et
renvoie la durée totale des séismes ayant eu lieu à cet endroit (c'est-à-dire la somme des durée des séismes
ayant eu lieu à cet endroit).

3- Écrire une fonction qui prend en entrée un tableau de tremblements de terre et renvoie un tableau ne
contenant que les séismes de magnitude supérieure ou égale à 8.

15- Énergie électrique (60 mn)

Dans le cadre de la transition énergétique, on veut analyser la production d'énergie électrique en France
et sa consommation.

1- On veut représenter explicitement les différents types de production électrique. Ecrire la déclaration
d'un type TypeProduction avec pour valeurs possibles : charbon, gaz, nucléaire, hydraulique, eolien, solaire,
biomasse, geothermie.
 2- On veut représenter chaque producteur d'électricité. Ecrire la déclaration d'un type Producteur
représentant les producteurs avec pour chacun un nom, un type de production électrique et une production
annuelle en GWh (gigawatt-heure, la production est un nombre entier). On veut représenter également les
régions. Ecrire la déclaration d'un type Region avec un nom, une consommation électrique annuelle en GWh et
l'ensemble des producteurs d'électricité de la région. Exemple : en région Nord-Picardie, la consommation est
de 46847GWh, les producteurs sont : parc de Bougainville – éolien - 25,8GWh, centrale de Gravelines –
nucléaire – 38400GWh, ... .

3- On veut connaitre pour une région donnée, la part de l'éolien dans sa production totale d'électricité.
Ecrire une fonction qui prend en entrée une Région et renvoie le rapport entre la somme des productions de ses
producteurs d'électricité éolienne et la somme des productions de tous les producteurs. Exemple : en Nord-
Picardie, la part de l'éolien est de 2916GWh / 44576GWh = 6,5%.

4- On veut récupérer les données de tous les producteurs d'électricité éolienne de toutes les régions.
Ecrire une fonction qui prend en entrée un tableau de Region et renvoie un tableau contenant les données de
tous les producteurs d'électricité éolienne.

16- Migration (45 mn)

On veut réaliser un programme pour analyser les données concernant les migrants. Chaque migrant est
décrit par son nom, son âge, son pays d'origine (chaîne de caractères), les pays qu'il a traversés (qui sont notés
sur son passeport) et son statut. Le statut peut prendre trois valeurs : migrant économique, demandeur d'asile et
réfugié (Un réfugié est un quelqu'un qui a demandé asile et s'est vu reconnaitre le statut de réfugié par l'état).

1- Proposer un ou des types de données structurés permettant de représenter les données concernant
les migrants.

2- Écrire une fonction qui prend en entrée un tableau de migrants (de statuts quelconques) et retourne
l'âge moyen des migrants économiques (et uniquement de ceux-là).

3- Écrire une fonction qui prend en entrée un tableau de migrants et renvoie un tableau ne contenant
que les migrants majeurs (c'est-à-dire ayant plus de 18 ans).

17- Assistants parlementaires (60 mn)

L'Assemblée Nationale veut mettre en place un logiciel pour analyser les rémunérations des assistants
parlementaires.

1- On veut représenter explicitement les différentes affiliations politiques des députés. Ecrire la
déclaration d'un type Parti avec pour valeurs possibles : FG, EELV, PS, LR, FN, SE. (SE veut dire sans
étiquette).

2- On veut représenter les députés et les assistants parlementaires. Ecrire la déclaration d'un type
Assistant qui comporte un nom, un salaire mensuel, et indique si l'assistant est membre de la même famille que
son député. Ecrire également la déclaration d'un type Député avec un nom, un parti et les assistants qu'il
emploie. Exemple : le député Machin, sans étiquette, emploie Bidule et Truc. Bidule touche 2000 euros par mois
et n'a pas de lien de parenté avec Machin. Truc touche 1900 euros par mois et a un lien de parenté avec
Machin.

3- Chaque député dispose d'une dotation de 9561 euros par mois pour rémunérer ses assistants. On
veut savoir si les salaires versés par les députés ne dépassent pas cette dotation. Ecrire une fonction qui prend
en entrée un Député et renvoie vrai si la somme des salaires qu'il verse à ses assistants est supérieure
strictement à 9561, faux sinon.
 4- On veut savoir quel député emploie un membre de sa famille. Ecrire une fonction qui prend en entrée
un tableau de Député et renvoie un tableau contenant uniquement les Député qui emploient un membre de leur
famille.

18- Trains (60 mn)

La SNCF veut réaliser un programme pour analyser les données concernant les trains de voyageur.
Chaque train est décrit par son numéro (entier), son type (parmi TER, Intercité et TGV) sa gare de départ et les
gares desservies, y compris le terminus. Les gares sont représentées par leurs noms (chaînes de caractères).
Par exemple, le train 848901 est de type TER, part de Amiens et dessert Poix-de-Picardie, Abancourt, Serqueux
et Rouen-Rive-Droite.

1- Proposez un ou des types de données structurés permettant de représenter les données concernant
les trains.

2- Écrivez une fonction qui prend en entrée un tableau de trains, et deux gares G1 et G2 et retourne vrai
s'il existe dans le tableau un train qui part de G1 et qui dessert G2.

3- Écrivez une fonction qui prend en entrée un tableau de train et renvoie un tableau ne contenant que
les trains de type TER.

19- ParcourSup (60 mn)

Dans le cadre du nouveau système Parcoursup d'inscription des bacheliers dans l'enseignement
supérieur, chaque demande d'inscription dans une formation doit recevoir un avis donné par les responsables
de la formation. Les avis possibles sont :
– OUI : l'inscription est acceptée
– OUI_MAIS : l'inscription est acceptée mais l'étudiant devra suivre une mise à niveau
– ATTENTE : l'inscription est mise en attente et ne sera effective que si le bachelier n'a pas obtenu
d'inscription dans une autre formation
– REFUS (cet avis n'est possible que pour les formations sélectives)

Il faut écrire un programme pour gérer les demandes d'inscription.

1- Écrire la déclaration d'un type Avis avec pour valeurs possibles : OUI, OUI_MAIS, ATTENTE et
REFUS.

2- On veut représenter les bacheliers et leurs demandes d'inscription. Écrire la déclaration d'un type
Demande qui comporte le nom de la formation demandée et l'avis rendu. Écrire la déclaration d'un type
Bachelier avec un nom, un type de bac (chaine de caractère), un âge et les demandes d'inscription qu'il a faites.
Exemple : le bachelier Tartempion, 17 ans, bac ES a demandé une inscription en Licence Economie et Gestion
qui a reçue l'avis OUI, une inscription en Licence Chimie qui a reçue l'avis ATTENTE et une inscription en
Licence Arts du Spectacle qui a reçue l'avis OUI_MAIS.

3- On veut savoir si chaque bachelier a été accepté dans au moins une formation. Écrire une fonction
qui prend en entrée un Bachelier et renvoie vrai s'il a reçu au moins un avis OUI ou un avis OUI_MAIS, et faux
sinon.

4- On veut savoir quels bacheliers n'ont reçu que des avis ATTENTE ou REFUS. Écrire une fonction qui
prend en entrée un tableau de Bachelier et renvoie un tableau contenant uniquement les Bacheliers qui n'ont
reçu que des avis ATTENTE ou REFUS.

5- On veut pouvoir connaitre le taux d'avis positifs. Pour un bachelier, ce taux est égal au nombre de
demandes qu'il a faites ayant reçu un avis positif (OUI ou OUI_MAIS), divisé par le nombre total de demandes
qu'il a faites. Écrire une fonction qui prend en entrée un tableau de Bachelier et renvoie la moyenne des taux
d'avis positifs des bacheliers.
 20- Sécurité routière (45 mn)
Le gouvernement veut un logiciel pour analyser la mortalité sur les routes. Une route a un type
(départementale, nationale ou autoroute), un numéro, et une vitesse maximum autorisée. Un accident de la
route est décrit par la route où a eu lieu l’accident, une date (on suppose qu’il existe un type Date), le nombre de
morts et le nombre de blessés.

1- Proposez un ou des types de données structurés permettant de représenter les données concernant
les routes et les accidents de la route.

2- Écrivez une fonction qui prend en entrée un tableau d’accidents et une route et renvoie le nombre de
morts sur cette route.

3- Écrivez une fonction qui prend en entrée un tableau d’accidents et renvoie un tableau ne contenant
que les accidents ayant eu lieu sur des routes limitées à 80km/h.

21- Météorologie (60 mn)

Dans un programme de simulation météorologique, on modélise l'atmosphère par une juxtaposition
bidimensionnelle de cubes de 1km de coté. Chaque cube est décrit par un nom de zone géographique et par les
conditions météorologiques qui y règnent : la température, la pression atmosphérique, l'hygrométrie.

1- Proposer une structure de données permettant de représenter les données météorologiques.

2- Écrire un programme qui crée et initialise le modèle météorologique, en mettant dans chaque cube de
coordonnées (a,b) le nom zone_a_b, une température aléatoire, une pression moyenne (1013,25 hPa) et une
hygrométrie faible (1%).

3- Écrire une fonction qui prend en entrée un modèle météorologiques et renvoie le nom de la zone où
la pression atmosphérique est la plus élevée.

On affine maintenant le modèle en découpant chaque zone verticalement. Le modèle devient donc
tridimensionnel (lattitude, longitude et altitude), mais chaque cube reste décrit de la même façon (les cubes
empilés au-dessus d'une zone portent le même nom de zone).

4- Écrire une fonction qui prend en entrée le modèle météorologique et un nom de zone et renvoie la
température dans cette zone à l'altitude la plus basse.

5- Écrire une fonction qui prend en entrée le modèle météorologique et des couples d'indices en lattitude
et longitude et renvoie la température moyenne dans le volume d'atmosphère délimité par ces indices. Exemple
de couples d'indices : 3 et 10 en lattitude et 1 et 9 en longitude indiquent qu'il faut calculer la température sur les
blocs de coordonnées (i,j,k) avec 3 ≤ i ≤ 10, 1 ≤ j ≤ 9 et k non limité.
1- L'informatique au service de la santé - CORRECTION

enregistrement Date
entier jour;
entier mois;
entier annee;
finenregistrement

enum Type_evt {contamination, guerison, deces};

enregistrement EvtEpidemio
entier num_secu;
Date date;
Type_evt type;
finenregistrement

fonction avec retour entier nbDeces(EvtEpidemio[] t, Date d)

entier cpt,i;
debut
cpt <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
si((t[i].type = Type_evt.deces) et (egalDate(t[i].date,d)))
alors
cpt <- cpt + 1;
finsi
finpour
retourne cpt;
fin

// La fonction retourne null si aucun événement de contamination

// n'est présent dans le tableau
fonction avec retour EvtEpidemio contamineProche(EvtEpidemio[] t, Date d)
EvtEpidemio evt;
 entier i,j;
debut
evt <- null;
j <- 0;
tantque (t[j].type != Type_evt.contamination) faire
j <- j+1;
fintantque
si (j != t.longueur) alors
evt <- t[j];
pour (i allant de j+1 à t.longueur-1 pas 1) faire
si((t[i].type = Type_evt.contamination) et
(distDate(t[i].date,d) < distDate(evt.date,d))) alors
evt <- t[i];
finsi
finpour
finsi
retourne evt;
fin

2- L'informatique au service du ministère du travail - CORRECTION

enum Type_activite {fonctionnaire, salarie_du_prive, liberal};

enregistrement Activite
Type_activite type;
entier revenu;
finenregistrement

enregistrement Actif
chaine diplome;
Activite acti;
entier nb_annees;
finenregistrement

fonction avec retour entier nbFonctionnaire(Actif[] tab, entier n)

entier result,i;
debut
result <- 0;
pour (i allant de 0 à tab.longueur-1 pas 1) faire
si ((tab[i].acti.type = Type_activite.fonctionnaire) et
(tab[i].nb_annees >= n)) alors
result <- result + 1;
finsi
finpour
retourne result;
fin

fonction avec retour booleen plusDeFonctionnaires(Actif[] tab, chaine diplome)

entier nb_fonctionnaires, nb_non_fonctionnaires, i;
debut
nb_fonctionnaires <- 0;
nb_non_fonctionnaires <- 0;
pour (i allant de 0 à tab.longueur-1 pas 1) faire
si (tab[i].diplome = diplome) alors
si (tab[i].acti.type = Type_activite.fonctionnaire) alors
nb_fonctionnaires <- nb_fonctionnaires + 1;
sinon
 nb_non_fonctionnaires <- nb_non_fonctionnaires + 1;
finsi
finsi
finpour
retourne (nb_non_fonctionnaires <= nb_fonctionnaires);
fin

3- L'informatique au service des transports aériens - CORRECTION

enregistrement Vol
entier num;
Ville depart;
Ville arrivee;
Date d;
entier places;
finenregistrement

// Cette fonction ne modifie le nb de places que du premier vol portant

// le numero indiqué. Cette fonction est appelée en donnant 0 comme
// valeur au paramètre i.
fonction sans retour reserve(Vol[] t, entier num, entier i)
début
si(i < t.longueur) alors
si(t[i].num == num) alors
si (t[i].places > 0) alors
t[i].places <- t[i].places - 1;
finsi
sinon
reserve(t, num, i+1);
finsi
finsi
fin

fonction avec retour Vol prochain(Vol[] t, Ville v1, Ville v2, Date d)
Vol resultat;
int i, attente, temp;
début
resultat <- null;
attente <- -1;
pour(i allant de 0 à t.longueur-1 pas de 1) faire
si(t[i].depart == v1 ET t[i].arrivee == v2 ET t[i].places > 0) alors
temp <- distance(d,t[i].d);
si(attente == -1 OU (temp > 0 ET temp < attente)) alors
attente <- temp;
resultat <- t[i];
finsi
finsi
finpour
retourne resultat;
fin

4- L'informatique au service des traders - CORRECTION

enum Etat_Entreprise {Aplus,A,B,C};

enregistrement Entreprise
chaine nom;
 Etat_Entreprise etat;
reel prix_action;
entier nb_actions;
finenregistrement

enregistrement Paquet_Actions
Entreprise e;
reel prix_achat;
entier nb_actions;
chaine trader;
finenregistrement

fonction avec retour Paquet_Action trouveVente(Paquet_Actions[] t)

Paquet_Action pa;
reel benef,temp;
entier i;
booleen prems;
debut
benef <- 0;
pa <- null;
prems <- vrai;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si(t[i].etat == Etat_Entreprise.C) alors
temp <- t[i].nb_actions*t[i].e.prix_action -
t[i].nb_actions*t[i].prix_achat;
si(prems OU (temp > benef)) alors
prems <- false;
benef <- temp;
pa <- t[i];
finsi
finsi
finpour
retourne pa;
fin

fonction avec retour reel bonus(Paquet_Actions[] t, chaine trader)

reel valeur_achat = 0,valeur_courante = 0;
entier i;
debut
pour(i allant de 0 à t.longueur-1 pas de 1) faire
si(t[i].trader == trader) alors
valeur_achat <- t[i].prix_achat*t[i].nb_actions;
valeur_courante <- t[i].e.prix_action*t[i].nb_actions;
finsi
finpour
si(valeur_courante > valeur_achat) alors
retourne 0.2*(valeur_courante-valeur_achat);
sinon
retourne 0;
finsi
fin

5- L'informatique au service des rencontres - CORRECTION

enum Hobby {sport,jeu,cuisine,jardinage,theatre};

enregistrement Client
Hobby[] hobbies;
 entier id;
chaine mail;
finenregistrement

fonction avec retour booléen sameHobbies(Client c1, Client c2)

entier i,j;
booléen test;
début
si (c1.hobbies.longueur == c2.hobbies.longueur) alors
pour (i allant de 0 à c1.hobbies.longueur-1 pas de 1) faire
test <- faux;
pour (j allant de 0 à c2.hobbies.longueur-1 pas de 1) faire
si (c1.hobbies[i] == c2.hobbies[j]) alors
test <- vrai;
finsi
finpour
si (!test) alors
retourne faux;
finsi
finpour
retourne vrai;
sinon
retourne faux;
finsi
fin

fonction avec retour Client[] soulmates(Client c, Client[] t)

entier nb,i;
Client[] result;
début
nb <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (sameHobbies(t[i],c)) alors
nb = nb + 1;
finsi
finpour
redim result[nb];
nb <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (sameHobbies(t[i],c)) alors
result[nb] <- t[i];
nb++;
finsi
finpour
retourne result;
fin

6- Analyse de réseau social - CORRECTION

enregistrement Page
chaine nom;
Date creation;
entier visiteurs;
Page[] liens;
finenregistrement

Page p;
p.nom <- Toto";
p.creation <- creerDate(2010,6,13);
p.visiteurs <- 234;

fonction avec retour entier visitesMoy(Page[] t)

entier i,moy;
debut
moy= 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
moy <- moy + t[i].visiteurs;
finpour
retourne moy/t.longueur;
fin

fonction avec retour booleen proprioIdem(Page[] t)

entier cpt,i;
booléen b;
debut
b <- faux;
pour (cpt allant de 0 à t.longueur-1 pas de 1) faire
pour (i allant de cpt+1 à t.longueur-1 pas de 1) faire
si (t[i].nom == t[cpt].nom) alors
b <- vrai;
finsi
finpour
finpour
retourne b;
fin

fonction avec retour booleen lies(Page[] t, chaine nom1, chaine nom2)

entier i,j;
booléen b;
debut
b <- faux;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].nom == nom1) alors
pour (j allant de 0 à t[i].liens.longueur pas de 1) faire
si (t[i].liens[j].nom == nom2) alors
b <- vrai;
finsi
finpour
finsi
si (t[i].nom == nom2) alors
pour (j allant de 0 à t[i].liens.longueur-1 pas de 1) faire
si (t[i].liens[j].nom == nom1) alors
b <- vrai;
finsi
finpour
finsi
finpour
retourne b;
fin

7- Intentions de vote - CORRECTION

enum Candidat {Bayrou,Hollande,Joly,Lepage,Lepen,Melenchon,Morin,Nihous,Sarkozy,

Villepin};

enregistrement Categorie
 chaine nom;
entier nombre;
chaine revenu;
finenregistrement

enregistrement Vote
Categorie cat;
Candidat can;
reel pourcent;
finenregistrement

fonction avec retour Candidat prefere(Vote[] t, Categorie c)

entier i;
reel p;
Candidat ca;
début
p <- 0;
ca <- Bayrou; // valeur renvoyée si aucun vote de c n'est présent dans t
pour (i allant de 0 à t.longueur-1 pas 1) faire
si (t[i].cat = c) alors
si (t[i].pourcent > p) alors
p <- t[i].pourcent;
ca <- t[i].can;
finsi
finsi
finpour
retourne ca;
fin

fonction avec retour entier revenu(Candidat c, Vote[] t)

entier resultat,nb\_votants;
début
resultat <- 0;
nb\_votants <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
si (t[i].can = c) alors
nb\_votants <- nb\_votants + t[i].cat.nombre*t[i].pourcent;
resultat <- resultat + t[i].cat.nombre*t[i].pourcent*
t[i].cat.revenu);
finsi
finpour
retourne (resultat/nb\_votants);
fin

8- Jeu, set et match - CORRECTION

enregistrement Set
entier a,b;
finenregistrement

enregistrement Match
chaine tournoi, joueur1, joueur2;
Set[] sets;
finenregistrement

programme initialisation
Match m;
m.tournoi <- "Open d'Australie 2012";
 m.joueur1 <- "Rafael Nadal";
m.joueur2 <- "Roger Federer";
Set s1, s2, s3, s4;
s1.a <- 6; s1.b <- 7;
s2.a <- 6; s2.b <- 2;
s3.a <- 7; s3.b <- 6;
s4.a <- 6; s4.b <- 4;
m.sets <- {s1,s2,s3,s4};
finprogramme

fonction avec retour entier nbJeuxPerdus(Match[] t, chaine nom)

entier i,j,nb;
debut
nb <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].joueur1 = nom) alors
pour (j allant de 0 à t[i].sets.longueur-1 pas de 1) faire
nb <- nb+t[i].sets[j].b;
finpour
finsi
si (t[i].joueur2 = nom) alors
pour (j allant de 0 à t[i].sets.longueur-1 pas de 1) faire
nb <- nb+t[i].sets[j].a;
finpour
finsi
finpour
retourne nb;
fin

9- Traçabilité de la viande - CORRECTION

enum Viande {cheval,boeuf,canard,poulet,mouton,porc};

enum Site{élevage,abattoir,usineTransformation,usineConditionnement};

enregistrement Entreprise
chaine nom;
Pays pays;
Site site;
finenregistrement

enregistrement Lot
entier id;
Viande type;
réel poids;
Entreprise[] sites;
finenregistrement

fonction avec retour Lot[] trouveLotsParType(Viande type, Lot[] t)

entier i,j;
Lot[] résultat;
début
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].type = type) alors
j <- j+1;
finsi
finpour
redim résultat[j];
 j <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
si (t[i].type = type) alors
résultat[j] <- t[i];
j <- j+1;
finsi
finpour
retourne résultat;
fin

fonction avec retour réel passéPar(chaîne site, Lot[] t)

entier i,j;
booléen b;
réel t;
début
t <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
j <- 0;
b <- faux;
tantque (j < t[i].sites.longueur et non b) faire
si (t[i].sites[j].nom = site) alors
b <- vrai;
t <- t + t[i].poids;
écrire t[i].id;
sinon
j <- j+1;
finsi
fintantque
finpour
retourne t;
fin

10- Paradis fiscal - CORRECTION

enregistrement Opération
chaine compte;
entier somme;
Date d;
finenregistrement

enregistrement Banque
chaine id, pays;
booléen suspecte;
Opération[] opés;
finenregistrement

fonction avec retour entier opéInverse(Opération[] t, Opération o)

entier i,j;
debut
j <- -1;
i <- 0;
tantque (i<t.longueur && j=-1) faire
si (t[i].somme = -1*o.somme ET t[i].d = o.d) alors
j <- i;
finsi
i <- i+1;
finpour
retourne j;
fin

fonction avec retour chaine opéInverse2(Banque[] t, Opération o)

entier i,j;
chaine c;
debut
c <- "";
i <- 0;
tantque (i<t.longueur && c="") faire
si (t[i].suspecte) alors
j <- 0;
tantque (j<t[i].opés.longueur && c="") faire
si (t[i].opés[j].somme = -1*o.somme ET
t[i].opés[j].d = o.d) alors
c <- t[i].id;
finsi
j <- j+1;
fintantque
finsi
i <- i+1;
fintantque
retourne c;
fin

11- Écoutes téléphoniques - CORRECTION

enum Cryptage{haut,moyen,bas};

enregistrement Appel
Chaine appelant, appelé;
Date début;
int durée;
Chaine[] motsClés;
Cryptage niveau;
finenregistrement

fonction avec retour entier tempsPassé(Chaine n, Date d1, Date d2, Appel[] t)
entier i, total;
début
total <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si ((t[i].appelé = n OU t[i].appelant = n) ET
t[i].début>=d1 ET t[i].début<=d2) alors
total <- total+t[i].durée;
finsi
finpour
retourne total;
fin

fonction avec retour booléen suspect(Appel[] t, Chaine[] mots, Chaine n)

entier i,j,k;
booléen b;
début
b <- faux;
t <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
si (t[i].appelé = n OU t[i].appelant = n) alors
pour (j allant de 0 à mots.longueur-1 pas 1) faire
 pour (k allant de 0 à t[i].motsClés.longueur-1 pas 1) faire
si (t[i].mots-clés[k] = mots[j]) alors
b <- vrai;
finsi
finpour
finpour
finsi
finpour
retourne b;
fin

12- Coupe du monde de football - CORRECTION

enregistrement Match
chaine equipe1, equipe2;
entier buts1, buts2;
finenregistrement

fonction avec retour entier nbButsMarques(Match[] t, chaine eq)

entier i, buts;
debut
buts <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].equipe1 = eq) alors
buts <- buts + t[i].buts1;
finsi
si (t[i].equipe2 = eq) alors
buts <- buts + t[i].buts2;
finsi
finpour
retourne buts;
fin

fonction avec retour Match[] matchsNuls(Match[] t)

entier i,j;
Match[] resultat;
debut
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].buts1 = t[i].buts2) alors
j <- j+1;
finsi
finpour
redim resultat[j];
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].buts1 = t[i].buts2) alors
resultat[j] <- t[i];
j <- j+1;
finsi
finpour
retourne resultat;
fin

13- Épidémie - CORRECTION

enum NiveauEpidémique{détection, infections,transmissions,pandémie};

enregistrement Ville
Chaine nom;
entier population;
NiveauEpidémique niveau;
entier[] infectées;
entier[] mortes;
finenregistrement

fonction avec retour entier survivants(Ville v)

entier i, infectes, morts;
début
infectées <- 0;
mortes <- 0;
pour (i allant de 0 à v.infectées.longueur-1 pas de 1) faire
infectées <- infectées + v.infectées[i];
finpour
pour (i allant de 0 à v.mortes.longueur-1 pas de 1) faire
mortes <- mortes + v.mortes[i];
finpour
retourne infectées - mortes;
fin

fonction avec retour Chaine villeAEviter(Ville[] t)

entier i,j,indice,rapport;
début
rapport <- -1;
pour (i allant de 0 à t.longueur-1 pas 1) faire
mortes <- 0;
pour (j allant de 0 à t[i].mortes.longueur-1 pas de 1) faire
mortes <- mortes + t[i].mortes[j];
finpour
si (mortes/t[i].population > rapport) alors
indice <- i;
rapport <- mortes/t[i].population;
finsi
finpour
retourne t[indice].nom;
fin

14- Séismes - CORRECTION

enregistrement Séisme
Lieu endroit;
réel magnitude;
entier durée;
finenregistrement

enregistrement Lieu
chaine nom;
réel longitude, latitude;
finenregistrement

fonction avec retour entier nbSéisme(Séisme[] t, chaine lieu)

entier i, durée;
debut
durée <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
 si (t[i].endroit.nom = lieu) alors
durée <- durée + t[i].durée;
finsi
finpour
retourne durée;
fin

fonction avec retour Séisme[] grosSéisme(Séisme[] t)

entier i,j;
Séisme[] resultat;
debut
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].magnitude >= 8) alors
j <- j+1;
finsi
finpour
redim resultat[j];
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].magnitude >= 8) alors
resultat[j] <- t[i];
j <- j+1;
finsi
finpour
retourne resultat;
fin

15- Énergie électrique - CORRECTION

enum TypeProduction {charbon,gaz,nucléaire,hydraulique,eolien,solaire,biomasse,

geothermie};

enregistrement Producteur
chaine nom;
TypeProduction type;
entier production;
finenregistrement

enregistrement Region
chaine nom;
entier consommation;
Producteur[] prods;
finenregistrement

fonction avec retour réel partEolien(Region r)

entier i, eole, total;
début
eole <- 0;
total <- 0;
pour (i allant de 0 à r.prods.longueur-1 pas de 1) faire
total <- total + r.prods[i].production;
si (r.prods[i].type = TypeProduction.eolien) alors
eole <- eole + r.prods[i].production;
finsi
finpour
retourne eole/total;
fin
fonction avec retour Producteur[] eoliens(Region[] t)
entier i,j,cpt;
Producteur[] resultat;
début
cpt <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
pour (j allant de 0 à t[i].prods.longueur-1 pas de 1) faire
si (t[i].prods[j].type = TypeProduction.eolien) alors
cpt <- cpt + 1;
finsi
finpour
finpour
redim resultat[cpt];
cpt <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
pour (j allant de 0 à t[i].prods.longueur-1 pas de 1) faire
si (t[i].prods[j].type = TypeProduction.eolien) alors
resultat[cpt] <- t[i].prods[j];
cpt <- cpt + 1;
finsi
finpour
finpour
retourne resultat;
fin

16- Migration - CORRECTION

enum Statut {éco,demandeur,réfugié};

enregistrement Migrant
chaîne nom, pays, traversés[];
entier âge;
Statut st;
finenregistrement

fonction avec retour réel ageMoyen(Migrant[] t)

entier i, n, age;
debut
n <- 0;
age <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].st = Statut.éco) alors
age <- age + t[i].âge;
n <- n + 1;
finsi
finpour
retourne age/n;
fin

fonction avec retour Migrant[] majeurs(Migrant[] t)

entier i,j;
Migrant[] resultat;
debut
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].âge >= 18) alors
j <- j+1;
 finsi
finpour
redim resultat[j];
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].âge >= 18) alors
resultat[j] <- t[i];
j <- j+1;
finsi
finpour
retourne resultat;
fin

17- Assistants parlementaires - CORRECTION

enum Parti {FG, EELV, PS, LR, FN, SE};

enregistrement Assistant
chaine nom;
entier salaire;
booleen famille;
finenregistrement

enregistrement Depute
chaine nom;
Parti part;
Assistant[] assist;
finenregistrement

fonction avec retour booleen depasseDotation(Depute d)

entier i, total;
début
total <- 0;
pour (i allant de 0 à d.assist.longueur-1 pas de 1) faire
total <- total + d.assist[i].salaire;
finpour
retourne total>9561;
fin

fonction avec retour Depute[] eoliens(Depute[] t)

entier i,j,cpt;
Depute[] resultat;
début
cpt <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
pour (j allant de 0 à t[i].assist.longueur-1 pas de 1) faire
si (t[i].assist[j].famille) alors
cpt <- cpt + 1;
finsi
finpour
finpour
redim resultat[cpt];
cpt <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
pour (j allant de 0 à t[i].assist.longueur-1 pas de 1) faire
si (t[i].assist[j].famille) alors
resultat[cpt] <- t[i].prods[j];
cpt <- cpt + 1;
 finsi
finpour
finpour
retourne resultat;
fin

18- Trains - CORRECTION

enum TypeTrain { TER, Intercité, TGV };

enregistrement Train
chaîne départ, arrêts[];
entier numéro;
TypeTrain t;
finenregistrement

fonction avec retour booléen existe(Train[] t, Chaine g1, Chaine g2)

entier i, j;
booléen b;
début
b <- faux;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].départ = g1) alors
pour (j allant de 0 à t[i].arrêts.longueur-1 pas 1) faire
si (t[i].arrêts[j] = g2) alors
b <- vrai;
finsi
finpour
finsi
finpour
retourne b;
fin

fonction avec retour Train[] ter(Train[] t)

entier i,j;
Train[] resultat;
début
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].TypeTrain = TypeTrain.TER) alors
j <- j+1;
finsi
finpour
redim resultat[j];
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].TypeTrain = TypeTrain.TER) alors
resultat[j] <- t[i];
j <- j+1;
finsi
finpour
retourne resultat;
fin

19- ParcourSup - CORRECTION

enum Avis {OUI, OUI_MAIS, ATTENTE, REFUS};

enregistrement Demande
chaine formation;
Avis retour;
finenregistrement

enregistrement Bachelier
chaine nom, prenom, bac;
entier age;
Demande[] demandes;
finenregistrement

fonction avec retour booléen accepté(Bachelier b)

entier i;
booléen b;
début
b <- faux;
pour (i allant de 0 à b.demandes.longueur-1 pas de 1) faire
si (b.demandes[i].retour = OUI ou b.demandes[i].retour = OUI_MAIS)
alors
b <- vrai;
finsi
finpour
retourne b;
fin

fonction avec retour Bachelier[] refusés(Bachelier[] t)

entier i,j,cpt;
Bachelier[] resultat;
début
cpt <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
si (non accepté(t[i])) alors
cpt <- cpt + 1;
finsi
finpour
redim resultat[cpt];
cpt <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
si (non accepté(t[i])) alors
resultat[cpt] <- t[i];
cpt <- cpt + 1;
finsi
finpour
retourne resultat;
fin

fonction avec retour réel tauxPositifs(Bachelier[] t)

entier i,j,cpt;
réel taux;
début
taux <- 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
cpt <- 0;
pour (j allant de 0 à t[i].demandes.longueur-1 pas 1) faire
si (t[i].demandes[j].retour = OUI ou
t[i].demandes[j].retour = OUI_MAIS) alors
cpt <- cpt + 1;
finsi
 finpour
taux = taux + cpt/t[i].demandes.longueur;
finpour
retourne taux/t.longueur;
fin

20- Sécurité routière - CORRECTION

enum TypeRoute {Dep,Nat,Autoroute};

enregistrement Route
entier numéro, vitesseMax;
TypeRoute t;
finenregistrement

enregistrement Accident
Date d;
Route r;
entier morts, blessés;
finenregistrement

fonction avec retour entier nbMortels(Route r, Accident [] t)

entier i, n;
début
n <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].r = r) alors
n <- n+t[i].morts;
finsi
finpour
retourne n;
fin

fonction avec retour Accident[] quatreVingt(Accident[] t)

entier i,j;
Accident[] resultat;
début
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].r.vitesseMax = 80) alors
j <- j+1;
finsi
finpour
redim resultat[j];
j <- 0;
pour (i allant de 0 à t.longueur-1 pas de 1) faire
si (t[i].r.vitesseMax = 80) alors
resultat[j] <- t[i];
j <- j+1;
finsi
finpour
retourne resultat;
fin

21- Météorologie - CORRECTION

enregistrement Cube
 chaine nom;
réel temp, press, hygro;
finenregistrement

L'atmosphère est représentée par un tableau bidimensionnel de Cube

programme Initialisation
entier i,j, larg, long;
Cube[][] mod;
début
écrire "Donnez la largeur et la longueur du modèle";
lire larg;
lire long;
redim mod[larg][long];
pour (i allant de 0 à mod.longueur-1 pas 1) faire
pour (j allant de 0 à mod[i].longueur-1 pas 1) faire
mod.nom ← "zone\_"+i+"\_"+j;
mod.temp ← random()*40;
mod.press ← 1013.25;
mod.hygro ← 1.0;
finpour
finpour
fin

fonction avec retour chaine pressMax(Cube[][] t)

entier i,j;
reel pressMax;
chaine result;
début
result ← "";
pressMax ← 0;
pour (i allant de 0 à t.longueur-1 pas 1) faire
pour (j allant de 0 à t[i].longueur-1 pas 1) faire
si (t[i][j].press > pressMax) alors
pressMax ← t[i][j].press;
result ← t[i][j].nom;
finsi
finpour
finpour
retourne result;
fin

// On suppose que l'altitude est la troisième dimension du tableau et qu'elle croit

avec l'indice
fonction avec retour réel tempZone(Cube[][][] t, chaine zone)
entier i,j;
début
pour (i allant de 0 à t.longueur-1 pas 1) faire
pour (j allant de 0 à t[i].longueur-1 pas 1) faire
si (t[i][j][0].nom = zone) alors
return t[i][j][0].temp;
finsi
finpour
finpour
retourne 0;
fin

// On suppose que les indices en paramètre sont dans les limites du tableau
// et que t[0][0].longueur = t[i][j].longueur pour tout i et j valides
fonction avec retour réel tempVolume(Cube[][][] t, int xMin, int xMax, int yMin,
int yMax)
entier i,j,k;
réel temp;
début
temp ← 0;
pour (i allant de xMin à xMax pas 1) faire
pour (j allant de yMin à yMax pas 1) faire
pour (k allant de 0 à t[i][j].longueur-1 pas 1) faire
temp ← temp + t[i][j][k].temp;
finpour
finpour
finpour
retourne temp/((xMax-xMin+1)*(yMax-yMin+1)*t[0][0].longueur);
fin