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
