Recueil d'exercices : tableaux, chaînes et sous-programmes

Écrire un algorithme permettant de :

• Remplir un tableau T par n chaînes non vides et dont la taille maximale est 6 caractères, avec 2 ≤ n ≤ 15.
• Calculer et afficher la somme des nombres extraits des chaînes de chaque élément du tableau T.

Le nombre extrait de la chaîne contenue dans la case i de T est formé par la concaténation de tous les chiffres de la chaîne parcourue de gauche à droite.

Exemple : Si n = 5 et que le tableau T contient :

Alors la somme S = 23 + 15 + 30 + 0 + 21 = 89. Le programme affichera la valeur de S.

On se propose de crypter une phrase composée par des lettres majuscules et des espaces en utilisant le principe de cryptage suivant :

• L'espace ne sera pas crypté.
• Choisir aléatoirement deux entiers p et q avec 2 ≤ p ≤ 10 et 2 ≤ q ≤ 10.
• Chaque lettre d'ordre alphabétique i sera remplacée par la lettre d'ordre alphabétique j avec : j = (p*i + q) Mod 26 + 1

Exemple : Pour la phrase ph = "ON VA REUSSIR AU BAC", si p = 3 et q = 4, la phrase cryptée est "XU SH GTPJJEG HP QHN".

En effet, la lettre "O" est d'ordre alphabétique i = 15, elle sera remplacée par la lettre d'ordre alphabétique j = (3*15 + 4) Mod 26 = 24, qui est la lettre "X".

Écrire l'algorithme intitulé Codage qui permet de saisir une phrase, choisir p et q et afficher son code selon le principe décrit précédemment.

Écrire un algorithme qui permet de saisir un entier positif et d'afficher s'il est abondant ou déficient.

Exemple : 12 est abondant. En effet, les diviseurs de 12 sauf lui-même sont 1, 2, 3, 4 et 6. Comme 1 + 2 + 3 + 4 + 6 = 16 et 12 < 16, alors 12 est dit abondant.

Exemple : 10 est déficient. En effet, les diviseurs de 10 sauf lui-même sont 1, 2 et 5. Comme 1 + 2 + 5 = 8 et 10 > 8, alors 10 est dit déficient.

Exemple : la chaîne "Le lion lape le lait lentement" est un tautogramme.

Écrire un algorithme permettant de saisir une chaîne de caractères composée uniquement de lettres et d'espaces (on suppose que deux mots consécutifs sont séparés par un seul espace) puis afficher un message indiquant si cette chaîne est tautogramme ou non.

Exemples :

• 7 est un nombre premier factoriel car 7 est un nombre premier et il s'écrit sous la forme 3! + 1.
• 719 est un nombre premier factoriel car 719 est premier et il s'écrit sous la forme 6! - 1.

On se propose d'écrire un programme permettant de remplir un tableau T par N entiers positifs (avec 2 ≤ N ≤ 10) et d'afficher tous les nombres premiers factoriels.

Pour chacune des propositions suivantes, mettre V (vrai) si la réponse est correcte et F (faux) dans le cas contraire.

Procédure P(N : entier ; @T : tab)

Fonction F(x : entier ; y : réel ; ch : chaîne) : booléen

Soient les fonctions suivantes :

Fonction F1(a, b : entier) : entier
Début
    R ← 0
    Pour i de 1 à b faire
        R ← R + a
    Fin pour
    Retourner R
Fin

Fonction F2(a, b : entier) : entier
Début
    R ← 1
    Pour i de 1 à b faire
        R ← R * a
    Fin pour
    Retourner R
Fin

Fonction F3(a, b : entier) : entier
Début
    P ← 0
    Pour i de a à b faire
        P ← P + i
    Fin pour
    Retourner P
Fin

Fonction F4(a, b : entier) : entier
Début
    Répéter
        Si a > b alors a ← a - b
                 Sinon b ← b - a
        FinSi
    Jusqu'à a = b
    Retourner a
Fin

Fonction F5(a, b : entier) : entier
Début
    Répéter
        Si a > b alors a ← a mod b
                 Sinon b ← b mod a
        FinSi
    Jusqu'à a*b = 0
    Si a = 0 alors R ← b
             Sinon R ← a
    FinSi
    Retourner R
Fin

Valider chacune des propositions suivantes en mettant V si elle est correcte ou F si elle est fausse.

a. Pour calculer le produit de a par b, on peut faire appel à la fonction : F1, F2, F3, F4, F5

b. Pour calculer aᵇ, on peut faire appel à : F1, F2, F3, F4, F5

c. Pour calculer le PGCD des entiers a et b, on peut faire appel à : F1, F2, F3, F4, F5

d. Pour calculer la somme des entiers de l'intervalle [a, b], on peut faire appel à : F1, F2, F3, F4, F5

Dans le but de gérer les discussions dans un groupe fermé créé au sein d'un réseau social, on se propose de réaliser une application informatique permettant d'afficher à l'administrateur du groupe :

• La liste des adhérents qui ont envoyé un même commentaire donné.
• La liste des adhérents inactifs dans le groupe, sachant qu'un adhérant est qualifié inactif s'il n'a envoyé aucun commentaire.

Travail demandé : écrire un algorithme qui permet de :

• Remplir un tableau A par les noms d'utilisateurs de Na adhérents du groupe avec 5 < Na ≤ 50. Sachant qu'un nom d'utilisateur est unique et formé par une suite d'au minimum trois caractères commençant obligatoirement par une lettre majuscule.
• Remplir un tableau M par Nm commentaires émis par les adhérents de ce groupe avec 2 < Nm ≤ 100, en respectant le format général suivant : NumE#commentaire, où :
  • NumE est une donnée représentant l'indice de l'émetteur du commentaire dans le tableau A
  • Commentaire représente le texte envoyé par cet émetteur.
• Afficher :
  • Le nom d'utilisateur de chaque adhérent qui a envoyé un commentaire donné.
  • La liste des adhérents inactifs.

Exemple : Pour Na = 5, Nm = 7 et les tableaux A et M suivants :

Pour cet exemple, M[2] signifie :

• Indice dans le tableau A de l'émetteur du commentaire : 0
• Texte du commentaire : Mes salutations

Si le commentaire saisi est "Help", alors le programme devra afficher les deux résultats suivants :

Le commentaire Help est envoyé par Amir@, Mohamed
La liste des adhérents inactifs est : Hichem_2018
                                      Salah20

A. Valider chacune des propositions ci-dessous en mettant V si vrai ou F dans le cas contraire :

1. L'instruction qui permet d'affecter à une variable X une valeur aléatoire de l'intervalle [2, 10] est :

   • X ← 2 + aléa(0, 8)
   • X ← 2 + aléa(0, 9)
   • X ← aléa(2, 10)

2. Une structure de données tableau peut :

   • Contenir des éléments de types différents
   • Être déclarée avec une taille maximale variable
   • Avoir des indices de cases de type scalaire

3. Une fonction est :

   • Un sous-programme qui peut rendre un seul résultat
   • Un sous-programme qui doit rendre un seul résultat
   • Un cas particulier d'une procédure

B. Afin de réaliser les tâches décrites dans la première colonne du tableau suivant, un élève fournit les propositions ci-dessous. Remplir la colonne « correction » en apportant les corrections nécessaires pour que ces propositions soient les plus adéquates relativement au choix de la structure itérative.

Soit MAT et SCO, deux tableaux contenant respectivement les matricules (la matricule est une chaîne numérique de longueur 6) et les scores (un score est un entier de l'intervalle [20..120]) de N (4 ≤ N ≤ 18) employés qui ont participé à un concours sur dossier pour le passage d'un grade.

On se propose d'écrire l'algorithme d'un programme permettant d'afficher les matricules ayant réussi dans ce concours. Pour cela on procède de la manière suivante :

• On calcule la moyenne des scores moysc.
• Une matricule gagnante est celle ayant un score ≥ moysc.

Exemple : Pour N = 4 :

Le programme affichera :

La moysc dans ce concours est égale à 68.5
La liste des employés qui ont réussi dans ce concours est :
L'employé 112547 avec un score égal à 112.
L'employé 993258 avec un score égal à 99.

Algorithme du programme principal :

0) Début grade
1) N ← saisie_N
2) Remplirmat(MAT, N)
3) Remplirscore(SCO, N)
4) S ← calcul_moysc(SCO, N)
5) Affiche(MAT, SCO, N, moysc)
6) Fin grade

Travail demandé :

1. Compléter les déclarations nécessaires pour le programme principal.
2. Développer le module Remplirmat qui permet de remplir un tableau MAT par N matricules en respectant les contraintes décrites ci-dessus.
3. Développer le module Remplirscore qui permet de remplir un tableau SCO par N scores en respectant les contraintes décrites ci-dessus.
4. Développer le module calcul_moysc qui permet de calculer la moysc de ce concours.
5. Développer le module Affiche qui permet d'afficher la moyenne des scores ainsi que la liste des matricules gagnantes.

L'IMEI (International Mobile Equipment Identity) est un numéro composé de 15 chiffres. Ce numéro permet à un opérateur de réseau GSM d'identifier le mobile appelant et ainsi de l'autoriser ou non à se connecter.

Un numéro est dit un IMEI s'il vérifie la formule de LUHN décrite ci-dessous :

1. Calculer la somme S des chiffres du numéro en appliquant le principe suivant :
   • Doubler les valeurs des chiffres de rang impair.
   • Si le double est supérieur ou égal à 10, alors il sera remplacé par la somme de ses chiffres.
2. Si la somme est un multiple de 10, alors le nombre est en accord avec la formule LUHN et dans ce cas il est valide, sinon il est dit invalide.

Exemples :

• Le nombre 354365039281174 est un IMEI, car en appliquant la formule LUHN on obtient 60 qui est un multiple de 10.

  Étape 1 : 3 5*2 4 3*2 6 5*2 0 3*2 9 2*2 8 1*2 1 7*2 4
  Étape 2 : 3 10  4 6   6 10  0 6   9 4   8 2   1 14  4
  Étape 3 : 3 1+0 4 6   6 1+0 0 6   9 4   8 2   1 1+4 4
  Étape 5 : S = 3+1+4+6+6+1+0+6+9+4+8+2+1+5+4 = 60
  

• 100000000001111 n'est pas un IMEI car en appliquant la formule LUHN on obtient 7 qui n'est pas un multiple de 10.

Travail demandé : On se propose d'écrire une solution modulaire d'un programme qui permet de déterminer et d'afficher si un numéro de 15 chiffres (chaîne de caractères) donné est un IMEI ou non en appliquant la formule LUHN.

L'Association SCOUTS TUNISIENS (الكشافة التونسية) est une organisation de jeunesse. Elle procure aux jeunes des deux sexes une éducation globale et les prépare à entrer dans la vie sociale suivant la méthode scoute mondiale qui correspond avec la réalité tunisienne.

Cet organisme organise durant l'année plusieurs activités et évènements. Afin d'encourager le travail bénévole, on veut concevoir et produire un programme qui facilite et organise ces activités.

Donc l'agent chargé du planning annuel dans l'association :

• Saisit les évènements et les activités qui vont être réalisés durant l'année.
• Entre une date, le programme affiche les évènements et les activités pour cette date.

Écrire un programme Python qui permet de :

• Remplir un tableau par n évènements (3 ≤ n ≤ 30) où chaque évènement est saisi sous la forme suivante : nom événement-jour/mois. Un évènement est valide :
  • s'il contient les caractères "-" et "/",
  • 1 ≤ jour ≤ 31 et 1 ≤ mois ≤ 12,
  • Nom événement est une chaîne de lettres et peut contenir des espaces.
• Saisir une date sous la forme J/M et afficher tous les évènements de cette date.

Exemple : Si N = 5 :

Si la date saisie est 12/4, le programme affichera :

Les activités pour le 12/4 :
Compagne Nettoyage
Campagne vaccin

Soit la fonction suivante :

Fonction Anonyme(X, Y : Entier) : Entier
Début
    S ← 0
    Tant que Y ≠ 0 Faire
        Si Y Mod 2 ≠ 0 Alors S ← S + X Fin si
        X ← X * 2
        Y ← Y Div 2
    Fin Tant que
    Retourner S
Fin

1. Exécuter la fonction pour les valeurs suivantes de x et y :
   • a. x = 10 et y = 2
   • b. x = 6 et y = 6
2. Quel est le rôle de cette fonction ?

Soient les algorithmes suivants :

Début
    X ← 6
    y ← 5
    z ← 0
    Somcar(x, y, z)
    Ecrire(x, y, z)
Fin

Procédure Somcar(x1, x2, s : entier)
Début
    X1 ← x1 * x2
    X2 ← x2 * x2
    S ← x1 + x2
Fin

1. Trouver le résultat fourni par l'algorithme ci-dessus.
2. Que faut-il ajouter à la procédure Somcar pour avoir un résultat correct ?
3. Remplacer dans ce programme la procédure par une fonction.

1. Écrire l'algorithme d'un sous-programme qui permet de saisir un entier premier.
2. Écrire l'algorithme d'un sous-programme qui permet de saisir une chaîne de caractères majuscules.
3. Écrire l'algorithme d'un sous-programme qui permet de saisir une chaîne de caractères numérique.
4. Écrire l'algorithme d'un sous-programme qui permet de remplir un tableau par 10 entiers distincts deux à deux.
5. Écrire l'algorithme d'un sous-programme qui permet de remplir un tableau par 10 entiers distincts.
6. Écrire l'algorithme d'un sous-programme qui permet de remplir un tableau par 10 entiers triés dans l'ordre croissant.

Écrire un programme qui cherche et affiche les n premiers entiers naturels positifs impairs et palindromes (n étant un entier naturel tel que 5 < n < 20).

Exemple : 121 est un entier impair et palindrome.

PHRASE est une chaîne comportant un minimum de 5 caractères. On se propose d'écrire un programme qui saisit Phrase puis affiche sans répétition :

• les caractères de PHRASE qui sont des lettres (minuscules ou majuscules, accentués ou non)
• les autres caractères de PHRASE (chiffres, ponctuation, etc.)

Écrire un programme permettant de déterminer et d'afficher tous les nombres amis compris entre 1 et 1000.

On se propose d'écrire un programme permettant de remplir deux tableaux V1 et V2 respectivement par N et M entiers (avec N et M deux entiers de l'intervalle [2..20] et les éléments de V1 et V2 sont saisis dans un ordre strictement croissant), puis de fusionner les éléments de ces deux tableaux dans un tableau V3 en éliminant les redondances et en gardant l'ordre croissant des éléments. Enfin, le programme affichera les éléments du tableau V3.

Exemple : Si N = 5, M = 7 :

Alors le tableau V3 contiendra :

Par exemple, 3 et 5 sont jumeaux ainsi que 41 et 43.

Écrire un programme qui cherche et affiche tous les nombres premiers jumeaux consécutifs ≤ à 400.

Pour vérifier si un nombre est divisible par 13, il suffit de :

• Éliminer le chiffre des unités et ajouter son quadruple (4 fois) au nombre restant.
• Répéter cette transformation jusqu'à obtenir un résultat strictement inférieur à 52.
• Le nombre de départ est divisible par 13 si et seulement si le résultat final est 13, 26 ou 39.

Écrire un algorithme puis sa traduction en Python qui permet de :

• saisir un tableau de N entiers supérieurs à 20 dans un ordre croissant (3 ≤ N ≤ 20).
• déterminer les nombres du tableau qui sont divisibles par 13 en utilisant le principe ci-dessus et les afficher par ordre décroissant.

Exemple : pour N = 6, le tableau T peut contenir :

Le programme affichera :

1664
312
52

Explications :

• 312 est divisible par 13 car 31 + (4×2) = 39, qui est divisible par 13.
• 1664 est divisible par 13 car 166 + (4×4) = 182 et 18 + (4×2) = 26, qui est divisible par 13.
• 41503 n'est pas divisible par 13 car 4150 + (4×3) = 4162, puis 416 + (4×2) = 424, puis 42 + (4×4) = 58, puis 5 + (4×8) = 37, qui n'est pas divisible par 13.

Important :

1. Une solution modulaire au problème est exigée.
2. Enregistrer au fur et à mesure votre programme dans le dossier bac2022 se trouvant sur la racine C:\ en lui donnant comme nom votre nom.

Pour envoyer et recevoir des messages électroniques via Internet, chaque utilisateur doit avoir un compte de messagerie caractérisé par une adresse e-mail ayant la forme suivante :

Nom_utilisateur@domaine.suffixe

Dans une adresse e-mail valide, les conditions suivantes sont respectées :

1. Le nom d'utilisateur est formé par des caractères alphanumériques, commence obligatoirement par une lettre, et peut contenir les caractères spéciaux suivants : l'underscore _, le tiret -.
2. Le caractère @ doit figurer une seule fois juste après le nom d'utilisateur.
3. domaine et suffixe sont deux chaînes de lettres.

Travail demandé :

Écrire un programme Python qui permet de saisir une adresse e-mail qui remplit les conditions précédentes, puis de générer et d'afficher le mot de passe qui lui correspond en respectant la règle suivante.

Si la longueur du nom d'utilisateur est paire, on ajoute au nom d'utilisateur :

• une lettre aléatoire du nom du domaine,
• la dernière lettre du suffixe,
• la longueur du domaine.

Si la longueur du nom d'utilisateur est impaire, on ajoute au nom d'utilisateur :

• la première lettre du nom du domaine,
• la première lettre du suffixe,
• la longueur du domaine multipliée par la longueur du suffixe.

Exemple : si l'utilisateur saisit Anas_Fehri@Gmail.com, le programme affichera :

Le mot de passe correspondant est : Anas_Fehriam5

où Anas_Fehri est le nom d'utilisateur, a une lettre aléatoire du domaine (Gmail), m la dernière lettre du suffixe (com), et 5 la longueur du domaine.

Dans le cadre d'une campagne publicitaire, une société commerciale a décidé d'organiser chaque semaine un jeu de chance pour ses clients.

Le principe du jeu consiste à calculer le nombre de chance à partir du numéro de téléphone du client donné et d'afficher le message "Félicitations, vous avez gagné." dans le cas où ce nombre est premier, ou "Désolé, vous n'avez pas gagné." dans le cas contraire.

Sachant que :

• Le numéro de téléphone devrait commencer par 2, 4, 5 ou 9.
• Le nombre de chance est la somme de chaque chiffre du numéro de téléphone multiplié par son indice (l'indice du premier chiffre est 0).
• Un nombre premier est un nombre divisible uniquement par 1 et par lui-même.

Exemple : pour le numéro 29234560, le programme affiche "Désolé, vous n'avez pas gagné." car le nombre de chance vaut 99, qui n'est pas premier :

99 = 2*0 + 9*1 + 2*2 + 3*3 + 4*4 + 5*5 + 6*6 + 0*7

Algorithme de la fonction Chance à exploiter :

Fonction Chance (Ch : Chaine) : Chaine
DEBUT
    Si NON (Estnum(Ch) ET long(Ch) = 8 ET Ch[0] ∈ ["2","4","5","9"]) Alors
        msg ← "Vérifier le numéro de téléphone !"
    Sinon
        msg ← "Désolé, vous n'avez pas gagné."
        s ← 0
        Pour i de 0 à long(Ch) - 1 Faire
            s ← s + valeur(Ch[i]) * i
        Fin Pour
        Si premier(s) Alors
            msg ← "Félicitation, vous avez gagné."
        FinSi
    FinSi
    Retourner msg
FIN

Travail demandé :

1. Concevoir une interface graphique (un label avec le nom de la société, un label demandant la saisie du numéro, une zone de saisie, un bouton Jouer, un label pour afficher un message) et l'enregistrer sous le nom Interface_Jeu.
2. Implémenter en Python la fonction Chance dans un programme nommé Jeu0.
3. Développer une fonction Premier permettant de vérifier si un nombre passé en paramètre est premier ou non, puis l'enregistrer sous le nom Jeu1.
4. Dans le programme Jeu1, ajouter les instructions permettant :
   • d'appeler l'interface graphique Interface_Jeu en exploitant l'annexe ci-dessous,
   • d'implémenter un module Play qui s'exécute à la suite d'un clic sur le bouton Jouer, permettant de récupérer le numéro de téléphone saisi puis d'exploiter la fonction Chance afin d'afficher le message retourné via un label de l'interface.

Annexe (intégration PyQt5) :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
app = QApplication([])
windows = loadUi("Nom_Interface.ui")
windows.show()
windows.Nom_Bouton.clicked.connect(Nom_Module)
app.exec_()

Important :

1. Une solution modulaire au problème est exigée.
2. Enregistrer au fur et à mesure votre programme dans le dossier bac2022 se trouvant sur la racine C:\.

Le ministère de l'éducation organise une olympiade d'informatique à l'échelle nationale.

Pour générer un code pour chaque participant, on se propose d'écrire un programme intitulé Olympiade qui permet de :

• Remplir deux tableaux TN et TG respectivement par les noms et les gouvernorats d'origine des N participants avec 5 ≤ N ≤ 26. Un nom ne doit pas dépasser 15 lettres et celui du gouvernorat 10 lettres au maximum.
• Générer dans un troisième tableau TC un code pour chaque participant. Ce code est formé de 5 caractères :
  • les trois premiers caractères représentent les trois premières lettres du gouvernorat du participant,
  • les deux derniers caractères forment un nombre de 2 chiffres représentant le rang du participant par rapport aux autres participants du même gouvernorat.
• Afficher pour chaque participant son nom et son code.

Exemple : pour N = 9 et les tableaux suivants :

Après génération, le tableau TC :

Affichage attendu :

Rahma     Jen01
Ayoub     Mon01
Aya       Béj01
Ali       Jen02
Mohamed   Tat01
Bilel     Jen03
Meriem    Mon02
Sana      Sfa01
Anis      Sfa02

Important :

1. Une solution modulaire au problème est exigée.
2. Enregistrer au fur et à mesure votre programme dans le dossier bac2022.

Pour générer automatiquement des mots de passe pour les utilisateurs d'une application informatique, on suit les étapes suivantes :

1. On remplit un tableau T par les noms de N utilisateurs (avec 1 ≤ N ≤ 9), sachant qu'un nom d'utilisateur est formé de 20 lettres majuscules au maximum.
2. On génère un tableau TM contenant les mots de passe des N utilisateurs. Un mot de passe est généré en apportant les modifications suivantes au nom de l'utilisateur :
   • Remplacer toutes les occurrences de la lettre "A" par le caractère "@".
   • Remplacer toutes les occurrences de la lettre "O" par le caractère zéro "0".
   • Ajouter à la fin de la chaîne obtenue précédemment le nombre de voyelles contenues dans le nom de l'utilisateur. La chaîne résultante représente le mot de passe.

Exemple :

Écrire un programme Python permettant de remplir T et de générer automatiquement les mots de passe comme présenté ci-dessus, puis d'afficher les mots de passe pour chaque utilisateur.

Écrire un programme permettant de :

• Remplir un tableau T1 par les noms de N élèves (5 ≤ N ≤ 20). Le nom ne doit exister qu'une seule fois dans T1 et ne doit pas être une chaîne vide.
• Remplir un tableau T2 par les moyennes des élèves : à l'élève T1[i] correspond la moyenne T2[i]. Les moyennes doivent être comprises entre 0 et 20.
• Calculer le rang de chaque élève dans un tableau T3.
• Trier les trois tableaux par ordre croissant suivant le rang.
• Afficher le nom, la moyenne et le rang de chaque élève.

On se propose d'écrire un programme permettant de remplir deux tableaux V1 et V2 respectivement par N et M entiers (avec N et M deux entiers de l'intervalle [2..20], les éléments de V1 et V2 étant saisis dans un ordre strictement croissant), puis de fusionner les éléments de ces deux tableaux dans un tableau V3 en éliminant les redondances et en gardant l'ordre croissant des éléments. Enfin, le programme affichera les éléments du tableau V3.

Exemple : si N = 5, M = 7 et :

Alors V3 contiendra :

Soit un tableau T1 contenant n lettres majuscules (de A à Z), n étant un entier compris entre 5 et 20.

On désire trier en ordre croissant les éléments de T1 et les ranger dans un tableau T2 en utilisant le principe suivant :

1. Chercher la lettre qui a le plus petit code ASCII dans T1.
2. a) Ranger cette lettre dans T2. b) Remplacer cette lettre par "*" dans T1.
3. Répéter n fois les étapes 1 et 2.

Écrire un programme qui permet de :

• Saisir les éléments de T1.
• Trier les éléments de T1 et les ranger dans T2.
• Afficher les éléments de T2.

On se propose de ranger dans un tableau V les numéros des cartes d'identité nationale des N élèves d'un lycée. Deux élèves ne peuvent pas avoir un même numéro de carte d'identité nationale. Un numéro de carte d'identité est composé obligatoirement de huit chiffres.

Écrire un programme qui permet de saisir les numéros de cartes d'identité des N élèves du lycée, puis de les trier par ordre croissant et de les afficher.

On se propose de saisir N termes informatiques dans un tableau, avec 1 < N < 35, de trier ce tableau selon l'ordre alphabétique croissant, d'insérer un nouveau terme dans sa bonne place (sans fausser l'ordre du tableau) et d'afficher le tableau résultat.

Exemple : N = 5

T après lecture et avant le tri :

T après le tri :

MOT : 'BUS'

T après l'insertion du mot 'BUS' (résultat à afficher) :

Soient les algorithmes ci-dessous, correspondant à un programme principal Exercice et à une fonction Inconnue appelée par celui-ci :

Algorithme Exercice
Début
    Lire(A)
    Si Inconnue(A) alors
        Ecrire(A, "Vérifie la propriété.")
    Sinon
        Ecrire(A, "ne vérifie pas la propriété.")
Fin

Fonction Inconnue (C : ............) : ............
Répéter
    L ← estnum(C[0])
    C ← effacer(C, 0, 1)
Jusqu'à (C = "") ou (non L)
Retourner L = vrai
Fin

Questions :

1. À partir des algorithmes donnés ci-dessus, remplir la 2ème colonne du tableau suivant par un exemple de chaque élément cité dans la 1ère colonne.

2. Compléter l'entête de la fonction Inconnue par les types appropriés.

3. Compléter le tableau de déclaration ci-dessous par les types des objets locaux de la fonction Inconnue.

4. Parmi les variables A, C, L, réécrire dans le tableau ci-dessous celles qui ne sont pas visibles par le programme principal.

5. Donner le résultat affiché par le programme Exercice pour chacune des valeurs de la variable A suivantes :

   • A = "523"
   • A = "-523"
   • A = "5.23"
   • A = "A5B8"

6. En déduire le rôle de la fonction Inconnue.

Une translation d'ordre n appliquée à une chaîne de caractères ch consiste à déplacer les n derniers caractères de la chaîne vers son début.

Exemples :

• Pour ch = "bonjour" et n = 1, on déplace le dernier caractère vers le début, ce qui donne après translation ch = "rbonjou".
• Pour ch = "bonjour" et n = 4, on déplace les 4 derniers caractères vers le début, ce qui donne après translation ch = "jourbon".

Questions :

1. Pour ch = "bac_2022" :

   • n = 6 → ?
   • n = 8 → ?

2. On propose l'algorithme du programme principal suivant :

Algorithme Deplacer
Début
    Saisie(n, ch)
    Ecrire(translation(n, ch))
Fin

• Écrire l'algorithme du module saisie qui permet de lire une chaîne non vide de 10 caractères au maximum et de lire l'ordre de translation n (n est un entier compris entre 1 et la longueur de la chaîne ch).
• Écrire l'algorithme du module translation.

Une société d'import/export, qui importe et assure le transport des marchandises à partir des quais du port, souhaite connaître le nombre de camions qu'elle doit louer pour décharger un bateau plein de conteneurs.

Sachant que :

• Un camion ne peut porter que deux conteneurs au maximum.
• Un camion ne peut porter que 10 tonnes au maximum.
• Un conteneur a un poids maximum de 10 tonnes et 1 tonne au minimum.

On désire remplir un tableau T de N réels distincts compris entre 1 et 10 représentant les poids des conteneurs (3 < N ≤ 20), puis afficher le couple de poids (ou le poids) transporté(s) par chaque camion ainsi que le nombre de camions.

Exemple : soit N = 8 et T contenant les poids :

Après tri décroissant de T :

On vérifie ensuite si un camion peut porter deux conteneurs selon le principe suivant :

• T[0] + T[7] = 9.82 + 2.5 = 12.32 > 10 ⇒ camion n°1 : un seul conteneur de 9.82 tonnes.
• T[1] + T[7] = 8.71 + 2.5 = 11.21 > 10 ⇒ camion n°2 : un seul conteneur de 8.71 tonnes.
• T[2] + T[7] = 7.15 + 2.5 = 9.65 ≤ 10 ⇒ camion n°3 : deux conteneurs de (7.15, 2.5) tonnes.
• T[3] + T[6] = 6.18 + 3.0 = 9.18 ≤ 10 ⇒ camion n°4 : deux conteneurs de (6.18, 3.0) tonnes.
• T[4] + T[5] = 5.30 + 3.2 = 8.5 ≤ 10 ⇒ camion n°5 : deux conteneurs de (5.30, 3.2) tonnes.

On vous demande d'élaborer :

1. un algorithme du programme principal solution à ce problème, en le décomposant en modules,
2. l'algorithme de chaque module.

1. Concevoir une interface graphique comme le modèle ci-dessous et l'enregistrer sous le nom Interface_Rigolo. L'interface comporte :
   • Un label contenant le titre Nombre Rigolo.
   • Un label demandant la saisie de N.
   • Une zone de saisie permettant la saisie d'un nombre.
   • Un bouton Vérifier permettant d'appeler la fonction Message.
   • Un bouton Rétablir permettant de vider le champ de saisie et le label de messages.
   • Un label pour afficher les différents messages.
2. Implémenter l'algorithme de la fonction Message en Python puis enregistrer le programme sous le nom Rigolo0.
3. Développer dans ce programme le module Somme_Chiffres permettant de calculer la somme des chiffres d'un nombre et le module Som_Chif_Facteurs permettant de calculer la somme des chiffres des facteurs premiers d'un nombre, et l'enregistrer sous le nom Rigolo1.
4. Dans le fichier Python Rigolo1, apporter les modifications nécessaires pour intégrer cette interface graphique en exploitant l'annexe ci-dessous.

Annexe :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
app = QApplication([])
fen = loadUi("Nom_Interface.ui")
fen.show()
fen.Nom_Bouton.clicked.connect(Nom_Module)
app.exec_()

1. Implémenter l'algorithme RECHERCHER en Python puis enregistrer le programme sous le nom cherche0.

2. Transformer ce programme en un module nommé CHERCHE, puis l'appeler et l'enregistrer sous le nom cherche1.

3. Développer dans ce programme :

   • Le module verif_1 permettant de retourner True si le mot est non vide formé uniquement de caractères alphabétiques et contenant au maximum 15 caractères, False sinon.
   • Le module verif_2 permettant de retourner True si le texte non vide formé uniquement de caractères alphabétiques et d'espaces et contenant au maximum 200 caractères, False sinon.

   NB : le texte ne commence pas par un espace, ne se termine pas par un espace et les mots du texte sont séparés par un seul espace.

4. Concevoir une interface graphique comme le modèle ci-dessus et l'enregistrer sous le nom Interface_recherche.

5. Apporter les modifications nécessaires pour intégrer cette interface graphique en exploitant l'annexe ci-dessous. NB : Programmer le bouton Rétablir.

Annexe :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
a = QApplication([])
f = loadUi("Nom_Interface.ui")
f.show()
f.Nom_Bouton1.clicked.connect(Nom_Module)
f.Nom_Bouton2.clicked.connect(Nom_Module)
app.exec_()

a. Concevoir une interface graphique et l'enregistrer sous le nom Suite.ui. b. Traduire en python l'algorithme de la fonction aff_palin qui permet de vérifier si l'entier n est supérieur ou égal à 10 et de retourner le résultat de la fonction suite_palin ou un message d'erreur. c. Développer la fonction palindrome qui permet de vérifier si n est un nombre palindrome ou non. d. Développer le module suite_palin qui permet de retourner la suite palindromique ou le message « pas de suite palindromique » après le calcul de 11 termes. e. Développer le module clr() qui permet, en cliquant sur Actualiser, d'effacer la saisie et l'affichage. f. Faire le traitement nécessaire et afficher le résultat sur l'interface.

Annexe :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
app = QApplication([])
windows = loadUi("Nom_Interface.ui")
windows.show()
windows.Nom_Bouton.clicked.connect(Nom_Module)
app.exec_()

1. Concevoir une interface graphique comme illustré et l'enregistrer sous le nom Interface_cryptage.
2. Implémenter en Python la fonction cryptage dans un programme et l'enregistrer sous le nom Prog_Cryptage.
3. Développer la fonction valide qui permet de vérifier si le message M est non vide et formé uniquement par des lettres et des espaces.
4. Développer la fonction nbMot qui permet de déterminer le nombre de mots dans le message M à crypter, en prenant en considération la possibilité d'existence des espaces superflus.
5. Dans le programme Prog_Cryptage, ajouter les instructions permettant :
   • D'appeler l'interface graphique intitulée Interface_cryptage en exploitant l'annexe ci-dessous.
   • D'implémenter un module affiche, qui s'exécute à la suite d'un clic sur le bouton Crypter, permettant de récupérer le message saisi puis d'exploiter les 3 fonctions cryptage, valide et nbMot afin d'afficher le message retourné via un label de l'interface Interface_cryptage.

Si le message saisi est invalide, on va afficher dans le label "Vérifier votre message !".

Annexe :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
app = QApplication([])
windows = loadUi("Nom_Interface.ui")
windows.show()
windows.Nom_Bouton.clicked.connect(Nom_Module)
app.exec_()

1. Concevoir une interface graphique comme illustré et l'enregistrer sous le nom Interface_oblong.
2. Implémenter en python la fonction affichage dans un programme et l'enregistrer sous le nom oblong_1.
3. Développer la fonction oblong permettant de vérifier si un nombre, passé en paramètre, est propre ou non, puis l'enregistrer dans votre dossier de travail sous le nom oblong_2.
4. Dans le programme oblong_2, ajouter les instructions permettant :
   • D'appeler l'interface intitulée Interface_oblong en exploitant l'annexe ci-dessous.
   • D'implémenter un module Verif, qui s'exécute à la suite d'un clic sur le bouton Vérifier, permettant de récupérer le nombre saisi puis exploiter la fonction affichage afin d'afficher le message retourné via un label de l'interface Interface_oblong.

Annexe :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
app = QApplication([])
windows = loadUi("Nom_Interface.ui")
windows.show()
windows.Nom_Bouton.clicked.connect(Nom_Module)
app.exec_()

1. Concevoir une interface graphique comme illustrée, puis l'enregistrer dans votre dossier de travail sous le nom fort.ui.
2. Développer en python une fonction intitulée somme, qui permet de vérifier si un nombre est fort ou non, et l'enregistrer sous le nom fort.py.
3. Dans le programme fort.py, ajouter les instructions suivantes permettant de :
   • D'appeler l'interface graphique fort.ui en exploitant l'annexe ci-dessous.
   • D'implémenter un module afficher, qui s'exécute à la suite d'un clic sur le bouton verifier, permettant de récupérer le nombre saisi, puis d'exploiter la fonction traiter, afin d'afficher le message retourné via le label « msg » de la fonction traiter.

Annexe :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
app = QApplication([])
fen = loadUi("nom_interface.ui")
fen.nom_bouton.clicked.connect(nom_module)
fen.show()
app.exec()

1. Concevoir une interface graphique comme illustrée et l'enregistrer sous le nom InterfaceSuperPairplus.
2. Créer un programme Python et l'enregistrer sous le nom NbrSuperPairplus.
3. Développer dans le programme NbrSuperPairplus une fonction SuperPairplus(N) qui permet de vérifier si un entier N est super-pairplus ou non.
4. Dans le programme NbrSuperPairplus :
   • Ajouter les instructions permettant d'appeler l'interface graphique intitulée InterfaceSuperPairplus en exploitant l'annexe ci-après.
   • Développer un module Play, qui s'exécute suite à un clic sur le bouton Vérifier, permettant de récupérer l'entier N saisi, puis d'exploiter la fonction SuperPairplus afin d'afficher le message adéquat via le label dédié.

Annexe :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# ...
app = QApplication([])
windows = loadUi("Nom_Interface.ui")
windows.show()
windows.Nom_Bouton.clicked.connect(Nom_Module)
app.exec_()

À partir des trois exercices ci-dessus, entraînez-vous à :

1. Tracer l'exécution de la fonction inconnu avec d'autres couples (a, b) (essayez par exemple (7, 13) et vérifiez que vous obtenez bien 7 × 13 = 91).
2. Écrire la version Pascal de la procédure sublime et tester avec les premiers nombres sublimes.
3. Implémenter en Python la fonction générer et tester sur la chaîne "PYTHON" afin de retrouver "80*8272*78".