Wadifa InfoEmploi public au Maroc ع
🎁 Soyez parmi les premiers : testez Taqdia gratuitement Tester →

Modèle de concours d'accès en 1re année du cycle ingénieur d'État — INPT 2012 — Algorithmique et programmation en C

🏢 Institut National des Postes et Télécommunications (INPT) 👤 Élève ingénieur 🎯 Algorithmique et programmation en C 📅 16/07/2012 👁️ 16 vues

⬇️ Télécharger le PDF Adresse permanente : wadifa-info.com/fr/modele-concours/2630

En bref

Ce document est une ancienne épreuve écrite du concours de Élève ingénieur organisé par Institut National des Postes et Télécommunications (INPT) (2012), publiée sur Wadifa Info en consultation et téléchargement PDF gratuits, avec une correction proposée.

Organisme
Institut National des Postes et Télécommunications (INPT)
Grade
Élève ingénieur
Spécialité
Algorithmique et programmation en C
Année
2012
Pages
4
Langue des questions
français
Correction
correction proposée disponible sur cette page
Épreuve d'algorithmique et programmation en langage C du concours d'accès en 1re année de l'INPT (lundi 16 juillet 2012, 1 heure) : problème sur la validité des identificateurs dans un langage de programmation.
📝 Texte des questions (extrait automatiquement des pages scannées)

Ce texte est extrait automatiquement des images de l'épreuve et peut contenir des erreurs de lecture — les images ci-dessus font foi.

Royaume du Maroc .
Agence Nationale de Réglementation des Télécommunications
Institut National des Postes et Télécommunications
Concours d’accès en 1“ année de l’Institut
National des Postes et Télécommunications
Lundi 16 juillet 2012
Epreuve d’algorithmique et programmation
en Langage C
Recommandations aux candidats
| - L’appréciation des copies tient compte de la rigueur algorithmique, de
la présentation et de la clarté de la rédaction.
- Si, au cours de l'épreuve, un candidat repère ce qui lui semble être une
erreur d'énoncé, il le signale sur sa copie, propose une correction et
poursuit l'épreuve en conséquence.
- L'usage de calculatrices électroniques n'est pas autorisé.
Durée de l’épreuve: 1 heure
wadifa-info.com ‏نماذج المباريات من موقع وظيفة إنفو‎

| Problème: Validité des identificateurs d’un langage de programmation
Contexte du problème
Tout langage de programmation permet l’utilisation de chaînes de caractères
pour déclarer et identifier les constantes et les variables du programme.
Ces chaînes de caractères appelés identificateurs doivent respecter un
ensemble de règles particulières pour chaque langage.
Le problème suivant s'intéresse à la vérification de la validité d'identificateurs
d'un langage spécifique
Règles de validité des identificateurs du langage à étudier
Soit un langage de programmation qui définit, comme suit, les règles de validité
d'un identificateur:
- Un identificateur est une chaîne de caractères de longueur inférieure strictement à 80
- Un identificateur ne peut contenir que des caractères alphabétiques minuscules
(‘a’, …,’z') ou majuscules (‘A’, …,’Z’) ou des chiffres (‘0’, ‘1’, ... ‘9?).
- Un identificateur ne doit pas commencer par un chiffre (‘0’, 1”, …, ‘9?).
- Un identificateur ne doit pas être un des mots clés suivants : if, do, while , for.
Remarques
- Toutes les fonctions demandées seront écrites en langage C
- Les questions non traitées peuvent être admises pour aborder les questions
ultérieures
- Toute fonction peut être décomposée, si nécessaire, en plusieurs fonctions
- Seules les fonctions suivantes définies dans la bibliothèque du langage © peuvent être
appelées sans être définies :
- Fonctions déclarées dans le fichier string.h
int strlen (const char“) retourne la longueur de la chaine en paramètre
char* strepy (char*, const char*) : copie la 2ème chaîne dans la première
int stremp (const char*, const char*) compare les 2 chaînes en paramètres et
retourne 0 si elles sont identiques
- Fonction déclarée dans le fichier stdlib.h
void free (void*) : libère l’espace dynamique alloué |
- Dans ce problème, il n’est pas demandé d'écrire la fonction main
Rappel : Les valeurs décimales des codes ASCII des caractères chiffres, des
caractères alphabétiques majuscules ou miniscules sont indiqués ci-dessous :
Code ASCII] 48 | 49 | [57] [65 ]66| |90 | |97]98 | |122
‏ا ا ا‎

1- Vérification de la validité d’un identificateur
> Question 1 (5 points) : Ecrire une fonction de prototype int valide (char id! ]) qui
retourne 1 si son paramètre id est un identificateur valide ou retourne 0 (zéro) sinon.
(Un identificateur est valide s’il respecte les règles du langage à étudier citées plus haut)
Exemple :
Concours, INPT, Max10, Min0 sont des identificateurs valides.
3xy, hy*, if ne sont pas des identificateurs valides.
2- Suppression des identificateurs non valides dans un tableau
> Question 2 (8 points): Soit T un tableau de N (0<N) chaînes de caractères dont
les longueurs sont inférieures à 80
Ecrire une fonction de prototype : void supprimer(int N, char 1] ][80]) qui
supprime toutes les chaînes qui ne correspondent pas à des identificateurs valides. Ces
chaînes seront remplacées par des chaînes vides à la fin du tableau ( voir exemple)
Exemple
- Soit N= 5 et 1-) 10601117, “4val”, “variable”, “if”, “delta”}
Après l'appel de la fonction supprimer(5, T),T={'identifi”, “variable”, "6117, 7, 1
3- Suppression des identificateurs redondants dans une liste chaînée |
On suppose avoir déjà crée une liste chaînée d’identificateurs valides dans la :
mémoire dynamique. Cette liste chaînée est définie par le type liste déclaré ainsi :
typedef struct tliste
{ char identificateur[80]; // représente un identificateur
struct tliste “suiv; // représente l'adresse de l'élément suivant dans la liste
} liste;
> Question 3 (7 points): Ecrire une fonction de prototype :
void supprimer_redondants(liste *adrDebut) qui permet de supprimer tous les
identificateurs redondants dans une liste chaînée de type liste définie plus haut.
Le paramètre (adrDebut) de cette fonction représente l'adresse du premier
élément de cette liste, le dernier élément de cette liste a l'adresse NULL dans son
champ suiv
Dans le cas où n (n>1) identificateurs sont identiques dans la liste chaînée, on
ne laissera dans la liste que le premier et on supprimera les (n-1) autres (voir exemple)

| Exemple
-Représentation de la Liste chaînée avant la suppression des identificateurs redondants :
adrDebut
‎el ai‏ نايبب
‎-Représentation de la liste chaînée après l'appel de la fonction supprimer _redondants(adrDebut)
‎adrDebut
‎SARA ERINE ERA ‏ا ين‎ RENE FIN DE L’'EPREUVE KENEEAARARAAENEERERIERERANENEENERERXT
‎313
‏نماذج المباريات من موقع وظيفة إنفو ‎wadifa-info.com‏

Correction proposée

Il s'agit d'une correction proposée, rédigée par l'équipe wadifa-info pour vous aider à comprendre la méthode — ce n'est pas un corrigé officiel de l'administration organisatrice.

Ce modèle est l'épreuve d'algorithmique et programmation en langage C du concours d'accès en 1re année de l'INPT (Institut National des Postes et Télécommunications, ANRT), session du lundi 16 juillet 2012. Durée : 1 heure, calculatrice interdite. Un seul problème en trois questions (5 + 8 + 7 points) sur la validité des identificateurs d'un langage. Voici une correction proposée ; seules strlen, strcpy, strcmp et free sont utilisées, comme l'impose l'énoncé.

💡 Le jury note la rigueur : traitez les cas limites (chaîne vide, longueur 79/80, premier ou dernier élément de la liste) et libérez la mémoire des maillons supprimés.

Question 1 — Fonction valide (5 points)

On vérifie les quatre règles dans l'ordre : longueur entre 1 et 79 (strictement inférieure à 80 ; une chaîne vide n'identifie rien), premier caractère non chiffre, uniquement des lettres ou des chiffres, et pas un mot clé. Deux petites fonctions auxiliaires testent la nature d'un caractère à partir des codes ASCII rappelés (les lettres et les chiffres sont contigus dans la table).

int estLettre(char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); }
int estChiffre(char c) { return c >= '0' && c <= '9'; }

int valide(char id[])
{
    int i, n = strlen(id);
    if (n == 0 || n >= 80) return 0;          /* longueur dans [1, 79] */
    if (estChiffre(id[0])) return 0;          /* ne commence pas par un chiffre */
    for (i = 0; i < n; i++)
        if (!estLettre(id[i]) && !estChiffre(id[i])) return 0;
    if (strcmp(id, "if") == 0 || strcmp(id, "do") == 0 ||
        strcmp(id, "while") == 0 || strcmp(id, "for") == 0) return 0;
    return 1;
}

Contrôle sur l'exemple : Concours, INPT, Max10, Min0 → 1 ; 3xy (commence par un chiffre), hy* (caractère *), if (mot clé) → 0.

Question 2 — Fonction supprimer (8 points)

On compacte le tableau en un seul passage : l'indice k désigne la prochaine case à remplir. Chaque chaîne valide est recopiée en position k (l'ordre est conservé), puis les cases restantes reçoivent la chaîne vide (premier caractère '\0'). Complexité : N appels à valide.

void supprimer(int N, char T[][80])
{
    int i, k = 0;                      /* k : prochaine place libre */
    for (i = 0; i < N; i++)
        if (valide(T[i])) {
            if (k != i) strcpy(T[k], T[i]);
            k++;
        }
    for (; k < N; k++) T[k][0] = '\0'; /* chaines vides en fin de tableau */
}

Contrôle : {"identif1", "4val", "variable", "if", "delta"} devient {"identif1", "variable", "delta", "", ""}.

Question 3 — Fonction supprimer_redondants (7 points)

Pour chaque maillon p, on parcourt la suite de la liste avec deux pointeurs (prec, q) ; chaque maillon q portant le même identificateur que p est détaché (prec->suiv = q->suiv) puis libéré par free. Le premier exemplaire est toujours conservé, si bien que la tête de liste ne change jamais : le paramètre adrDebut (adresse du premier élément) suffit. Complexité O(n²) comparaisons.

void supprimer_redondants(liste *adrDebut)
{
    liste *p, *prec, *q;
    for (p = adrDebut; p != NULL; p = p->suiv) {
        prec = p;                      /* on parcourt la suite de la liste */
        q = p->suiv;
        while (q != NULL) {
            if (strcmp(q->identificateur, p->identificateur) == 0) {
                prec->suiv = q->suiv;  /* on detache q */
                free(q);
                q = prec->suiv;
            } else {
                prec = q;
                q = q->suiv;
            }
        }
    }
}

Contrôle : Valeur → nombre → nombre → total → Valeur → X10 → total devient Valeur → nombre → total → X10 → NULL.

Un nouveau sujet de concours chaque jour sur WhatsApp

Questions fréquentes sur ce sujet

Ce sujet est-il téléchargeable gratuitement ?
Oui. La totalité du sujet (4 pages) est consultable et téléchargeable gratuitement, sans inscription ni compte.
Le corrigé est-il inclus ?
Oui. Un corrigé proposé figure sur cette page, sous les pages du sujet : méthode de réponse et éléments attendus, rédigés par l'équipe Wadifa Info.
Quel organisme et quel grade concerne ce sujet ?
Ce sujet provient d'un concours organisé par Institut National des Postes et Télécommunications (INPT). Il concerne le grade : Élève ingénieur.
De quelle session s'agit-il et dans quelle langue ?
Session : 16/07/2012. Les questions sont en français.
Où trouver d'autres sujets du même concours ?
Tous nos sujets de la même famille sont regroupés sur la page les sujets de concours « Accès aux écoles et instituts supérieurs ». Les sujets y sont classés par session, du plus récent au plus ancien.

Organisme : Institut National des Postes et Télécommunications (INPT) · 16/07/2012 — Copie issue de : archive de modèles de concours — document archivé tel que reçu ; l'avis officiel du concours fait foi.

}
Utile ? Envoyez-le à quelqu'un qui cherche
WhatsApp Facebook Telegram

Citer cette page

Journaliste, blogueur, enseignant : copiez la référence ci-dessous et mettez un lien vers cette page.

Adresse permanente : https://www.wadifa-info.com/fr/modele-concours/2630/modele-de-concours-d-acces-en-1re-annee-du-cycle-ingenieur-d-etat-inpt-2012-algorithmiqu

📲
Installez Wadifa Info sur votre iPhone : appuyez sur le bouton Partager en bas de Safari, puis sur Sur l'écran d'accueil. Les nouveaux concours, sans passer par le navigateur.