id: 33-1644-revision-bac-pratique-25-sujets slug: 33-1644-revision-bac-pratique-25-sujets titre: "Révision Bac Pratique 2023 — 25 sujets PyQt5/Python" chapitre: 0 chapitre_titre: "Révisions et examens blancs" lecon: 1 niveau: 4eme-sci ordre: 90 prerequis: [] duree_estimee_min: 900 mots_cles:

• bac pratique
• pyqt5
• interface graphique
• sujets
• revision
• python
• tableaux
• sous-programmes langages:
• python objectifs:
• Concevoir une interface graphique PyQt et la relier à un programme Python
• Implémenter une procédure de remplissage aléatoire et d'affichage d'un tableau
• Calculer le chiffre de chance d'un nombre par sommations répétées de ses chiffres
• Déterminer si un client est gagnant en fonction d'une condition arithmétique status: published source_pdf: 33_1644.pdf source_pages:
• 4
• 5
• 6 kind: cours

Recueil de 25 sujets de bac pratique couvrant interfaces graphiques PyQt5, manipulations de chaînes, tableaux et sous-programmes. Chaque sujet propose un énoncé complet avec contraintes, exemples, et corrigé Python détaillé. Comptez environ 30-45 min par sujet pour le résoudre dans des conditions d'examen.

Sujet n°1 — Chariot gratuit-payant

Présentation du problème

Dans le cadre du 100ᵉ anniversaire, une entreprise commerciale décide, à la caisse, d'offrir aux clients leurs achats. Pour cela, et suite aux règlements de l'offre, le caissier demande au client son numéro de téléphone N (contenant 8 chiffres), dont le premier doit être l'un des chiffres de la liste suivante : 2, 3, 4, 5 et 9.

On se propose d'afficher si le client ayant le numéro de téléphone N est gagnant ou non.

Exemples

Exemple 1 — Client gagnant

Pour le numéro de téléphone et le tableau T suivants :

• N = 55 405 103
• T :

Le programme affiche : « Le client ayant le numéro de téléphone 55 405 103 a gagné un chariot gratuit ».

En effet, le CC du client a été obtenu en additionnant les chiffres de son numéro de téléphone jusqu'à obtenir un seul chiffre :

• 5 + 5 + 4 + 0 + 5 + 1 + 0 + 3 = 23
• 2 + 3 = 5

Le carré du chiffre 5 (soit 5² = 25) figure dans le tableau T → c'est un client gagnant.

Exemple 2 — Client perdant

• N = 99 678 987
• T :

Le programme affiche : « Le client ayant le numéro de téléphone 99 678 987 doit payer les achats du chariot ».

En effet, le calcul du CC donne :

• 9 + 9 + 6 + 7 + 8 + 9 + 8 + 5 = 55
• 5 + 5 = 10
• 1 + 0 = 1

Le carré du chiffre 1 (soit 1² = 1) ne figure pas dans le tableau T → c'est un client perdant.

Procédure REMP_AFFICHE à exploiter

Cette procédure permet de remplir aléatoirement le tableau T, de type TAB, par 8 entiers dans l'intervalle [1, 99] et de les afficher sur la console.

Procédure REMP_AFFICHE (@ T : TAB)
Début
    Pour i de 0 à 7 faire
        T[i] ← Aléa(1, 99)
        Ecrire(T[i], " | ")
    Fin Pour
Fin

Interface graphique à concevoir

L'interface graphique InterCHARIOT doit contenir les éléments suivants :

• Un label contenant le texte : « Chariot gratuit-payant »
• Un label demandant la saisie : « Introduire le numéro de téléphone du client satisfaisant les conditions : »
• Une zone de saisie permettant la saisie du numéro.
• Un bouton intitulé « Valider » (ou Vérifier).
• Un bouton intitulé « Effacer » (permettant d'effacer la zone de saisie et le label d'affichage).
• Un label pour afficher le message adéquat.

Travail demandé

1. Concevoir une interface graphique comme illustrée ci-dessus et l'enregistrer, dans votre dossier de travail, sous le nom InterCHARIOT.
2. Créer un programme Python et l'enregistrer, dans votre dossier de travail, sous le nom PgmeCHAR.
3. Implémenter la procédure REMP_AFFICHE et l'appeler dans le programme principal.
4. Développer dans le programme PgmeCHAR, une fonction GainPerd(N) qui permet de vérifier si le numéro de téléphone du client N est gagnant ou non.
5. Dans le programme PgmeCHAR :
   • Ajouter les instructions permettant d'appeler l'interface graphique InterCHARIOT en exploitant l'annexe ci-dessous.
   • Développer un module Play, qui s'exécute suite à un clic sur le bouton « Valider », permettant de récupérer l'entier N saisi satisfaisant les conditions décrites précédemment, puis d'exploiter la fonction GainPerd afin d'afficher le message adéquat via le label dédié à l'affichage de l'interface InterCHARIOT.

Annexe — squelette PyQt

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_()

Exemples d'exécution attendus

• Saisie 96123M45 (caractère non numérique) → « Désolé ! vérifier le numéro de téléphone du client !! »
• Saisie 85741963 (ne commence pas par 2, 3, 4, 5 ou 9) → « Désolé ! vérifier le numéro de téléphone du client !! »
• Saisie 23358930 avec un tableau contenant le carré du CC → « Le client ayant le numéro de téléphone 23358930 a gagné un chariot gratuit »
• Saisie 23358930 avec un tableau ne contenant pas le carré du CC → « Le client ayant le numéro de téléphone 23358930 doit payer les achats du chariot »

Grille d'évaluation

Pistes de résolution

from random import randint

T = [0] * 8

def REMP_AFFICHE():
    for i in range(8):
        T[i] = randint(1, 99)
        print(T[i], " | ", end="")

def ChiffreChance(N):
    s = N
    while s >= 10:
        somme = 0
        while s != 0:
            somme += s % 10
            s //= 10
        s = somme
    return s

def GainPerd(N):
    # Vérification du format
    ch = str(N)
    if len(ch) != 8 or ch[0] not in "23459":
        return "Désolé ! vérifier le numéro de téléphone du client !!"
    cc = ChiffreChance(N)
    if cc**2 in T:
        return f"Le client ayant le numéro de téléphone {N} a gagné un chariot gratuit"
    else:
        return f"Le client ayant le numéro de téléphone {N} doit payer les achats du chariot"

def Play():
    saisie = windows.zoneSaisie.text()
    try:
        N = int(saisie)
        msg = GainPerd(N)
    except ValueError:
        msg = "Désolé ! vérifier le numéro de téléphone du client !!"
    windows.labelMessage.setText(msg)

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

REMP_AFFICHE()

app = QApplication([])
windows = loadUi("InterCHARIOT.ui")
windows.show()
windows.btnValider.clicked.connect(Play)
windows.btnEffacer.clicked.connect(Effacer)
app.exec_()

Sujet pratique n°4 — Cryptographie par apparition dans le mot

Énoncé

On veut crypter un mot saisi MS non vide, composé uniquement par des lettres majuscules, et afficher le mot crypté MC.

La méthode de cryptage est la suivante :

• Pour chaque lettre, déterminer son nombre d'occurrence (apparition) n dans le mot MS.
• Déterminer K qui est égal à 2*n si n est impair et sera égal à (n DIV 2) si n est pair.
• Remplacer chaque lettre par la Kᵉ lettre qui la suit dans l'intervalle de l'alphabet ['A'..'Z']. Pour les dernières lettres, on revient dès le début, par exemple si K=3, on remplacera 'A' par 'D', 'B' par 'E', 'C' par 'F' … 'Y' par 'B' et 'Z' par 'C'.

Exemple

Pour le mot MS = "ZEBRE" :

Le programme affiche MC : "BFDTF".

Interface graphique

L'interface contient :

• Un label : "Cryptographie par apparition dans le mot"
• Un label : "Introduire un mot non vide et composé uniquement par des lettres majuscules :"
• Une zone de saisie pour le mot.
• Un bouton "Crypter"
• Un bouton "Effacer" (efface la zone de saisie et le label d'affichage)
• Un label pour afficher le message adéquat.

Travail demandé

1. Concevoir l'interface graphique et l'enregistrer sous le nom "InterCRYPTE_AM".
2. Créer un programme Python et l'enregistrer sous le nom "PgmeCRYPTE_AM".
3. Développer dans PgmeCRYPTE_AM une fonction Crypter(MS) qui permet de crypter le mot MS selon le principe décrit.
4. Dans le programme PgmeCRYPTE_AM :
   • Ajouter les instructions permettant d'appeler l'interface "InterCRYPTE_AM" en exploitant l'annexe.
   • Développer un module "Play", qui s'exécute suite à un clic sur "Crypter", permettant de récupérer le mot MS saisi (en vérifiant les conditions décrites), puis d'exploiter la fonction Crypter afin d'afficher le message adéquat via le label dédié de "InterCRYPTE_AM".

NB : L'affichage du message doit être conforme aux exemples d'exécution :

• Saisie "Zebre" → Désolé ! vérifier le mot à crypter !!
• Saisie "ZEBRE" → Le mot crypté sera : BFDTF
• Saisie "PROGRAMMATION" → Le mot crypté sera : RSPISBNNBVKPP

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_()

Grille d'évaluation

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

def Crypter(MS):
    MC = ""
    for c in MS:
        n = MS.count(c)
        if n % 2 == 1:
            K = 2 * n
        else:
            K = n // 2
        # décalage de K positions dans [A..Z] avec retour au début
        nouveau = chr((ord(c) - ord('A') + K) % 26 + ord('A'))
        MC += nouveau
    return MC

def Play():
    MS = windows.lineEdit.text()
    if MS == "" or not MS.isalpha() or not MS.isupper():
        windows.label_res.setText("Désolé ! vérifier le mot à crypter !!")
    else:
        windows.label_res.setText("Le mot crypté sera : " + Crypter(MS))

app = QApplication([])
windows = loadUi("InterCRYPTE_AM.ui")
windows.show()
windows.pb_Crypter.clicked.connect(Play)
app.exec_()

Sujet pratique n°5 — Les mots frères-cousins

Énoncé

On autorise deux règles de transformation des mots :

• Règle 1 : si toute consonne dans MotA est remplacée par une consonne dans MotB et toute voyelle dans MotA est remplacée par une voyelle dans MotB, on dira que MotA est frère de MotB.
• Règle 2 : si toute consonne dans MotA est remplacée par une voyelle dans MotB et toute voyelle dans MotA est remplacée par une consonne dans MotB, on dira que MotA est cousin de MotB.

NB :

• Les deux mots ne doivent pas être vides et ne contiennent que des lettres alphabétiques minuscules.
• La longueur du MotA est égale à celle du MotB.

Exemples

❶ MotA = "chlore" est frère de MotB = "frwihu" car chaque consonne est remplacée par une consonne et chaque voyelle par une voyelle (c→f, h→r, l→w, o→i, r→h, e→u).

❷ MotA = "bon" est cousin de MotB = "ali" car chaque consonne devient voyelle et chaque voyelle devient consonne (b→a, o→l, n→i).

❸ MotA = "moez" et MotB = "sara" sont ni frères ni cousins.

Interface graphique

L'interface contient :

• Un label : "Les mots frères-cousins"
• Un label : "Introduire MotA, un mot non vide contenant que des lettres alphabétiques minuscules :"
• Une zone de saisie pour MotA.
• Un label : "Introduire MotB, un mot non vide contenant que des lettres alphabétiques minuscules :"
• Une zone de saisie pour MotB.
• Un bouton "Vérifier"
• Un bouton "Effacer"
• Un label pour afficher le message adéquat.

Travail demandé

1. Concevoir l'interface graphique et l'enregistrer sous le nom "InterFRCO".
2. Créer un programme Python enregistré sous "PgmeFRCO".
3. Développer dans PgmeFRCO deux fonctions Freres(MotA, MotB) et Cousins(MotA, MotB) qui permettent de vérifier respectivement si les deux mots sont frères ou cousins.
4. Dans PgmeFRCO :
   • Ajouter les instructions permettant d'appeler l'interface "InterFRCO" en exploitant l'annexe.
   • Développer un module "Play" déclenché par le clic sur "Vérifier", qui récupère les deux mots, exploite Freres et Cousins, et affiche le message adéquat.

Exemples d'exécution :

• salah / mohamed → Désolé ! vérifier la saisie des mots !!
• SALAH / RaMZI → Désolé ! vérifier la saisie des mots !!
• kamel / riheb → kamel est frère de riheb
• ali / bon → Le mot ali est cousin de bon
• sara / moez → Les deux mots ni frères ni cousins

Grille d'évaluation

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

VOYELLES = "aeiouy"

def est_voyelle(c):
    return c in VOYELLES

def Freres(MotA, MotB):
    if len(MotA) != len(MotB):
        return False
    for i in range(len(MotA)):
        if est_voyelle(MotA[i]) != est_voyelle(MotB[i]):
            return False
    return True

def Cousins(MotA, MotB):
    if len(MotA) != len(MotB):
        return False
    for i in range(len(MotA)):
        if est_voyelle(MotA[i]) == est_voyelle(MotB[i]):
            return False
    return True

def valide(mot):
    return mot != "" and mot.isalpha() and mot.islower()

def Play():
    A = windows.le_A.text()
    B = windows.le_B.text()
    if not (valide(A) and valide(B) and len(A) == len(B)):
        windows.label_res.setText("Désolé ! vérifier la saisie des mots !!")
    elif Freres(A, B):
        windows.label_res.setText(A + " est frère de " + B)
    elif Cousins(A, B):
        windows.label_res.setText("Le mot " + A + " est cousin de " + B)
    else:
        windows.label_res.setText("Les deux mots ni frères ni cousins")

app = QApplication([])
windows = loadUi("InterFRCO.ui")
windows.show()
windows.pb_Verifier.clicked.connect(Play)
app.exec_()

Sujet pratique n°6 — Une chaîne presque palindrome

Énoncé

Une chaîne presque palindrome est une chaîne non vide de nombre pair de caractères, pour laquelle les caractères correspondants de même rang à partir de la droite et de gauche sont de même famille deux à deux.

Deux caractères sont de même famille s'ils sont les deux consonnes, les deux voyelles, les deux chiffres ou bien les deux symboles.

Exemples

❶ ch = "Tothem" est presque palindrome car :

• 1ᵉʳ caractère "T" et 6ᵉ caractère "m" sont les deux consonnes,
• 2ᵉ caractère "o" et 5ᵉ caractère "e" sont les deux voyelles,
• 3ᵉ caractère "t" et 4ᵉ caractère "h" sont les deux consonnes.

❷ ch = "B2#Ay!3B" est presque palindrome car :

• B / B → consonnes,
• 2 / 3 → chiffres,
• # / ! → symboles,
• A / y → voyelles.

❸ ch = "2#AC!3" n'est pas presque palindrome car le 3ᵉ caractère "A" est voyelle et le 4ᵉ caractère "C" est consonne (familles différentes).

Interface graphique

L'interface contient :

• Un label : "Chaine presque palindrome"
• Un label : "Introduire une chaine non vide de nombre pair de caractères :"
• Une zone de saisie pour la chaîne.
• Un bouton "Vérifier"
• Un bouton "Effacer"
• Un label pour afficher le message adéquat.

Travail demandé

1. Concevoir l'interface et l'enregistrer sous "InterPP".
2. Créer un programme Python enregistré sous "PgmePP".
3. Développer dans PgmePP une fonction Est_PP(ch) qui vérifie si la chaîne ch est presque palindrome.
4. Dans PgmePP :
   • Ajouter les instructions permettant d'appeler l'interface "InterPP".
   • Développer le module "Play" déclenché par "Vérifier" : récupère la chaîne ch, exploite Est_PP, et affiche le message adéquat.

Exemples d'exécution :

• Sar → Désolé ! vérifier la saisie de l chaine !!
• ELLE → ELLE une chaine n'est pas presque palindrome (car palindrome strict)
• Tothem → La chaine Tothem est presque palindrome
• B2#Ay!3B → La chaine B2#Ay!3B est presque palindrome
• 2#AC!3 → 2#AC!3 une chaine n'est pas presque palindrome

Grille d'évaluation

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

VOYELLES = "aeiouyAEIOUY"

def famille(c):
    if c.isdigit():
        return "chiffre"
    if c.isalpha():
        if c in VOYELLES:
            return "voyelle"
        return "consonne"
    return "symbole"

def Est_PP(ch):
    n = len(ch)
    if n == 0 or n % 2 != 0:
        return False
    # ne doit pas être palindrome
    if ch == ch[::-1]:
        return False
    for i in range(n // 2):
        if famille(ch[i]) != famille(ch[n - 1 - i]):
            return False
    return True

def Play():
    ch = windows.le_ch.text()
    if ch == "" or len(ch) % 2 != 0:
        windows.label_res.setText("Désolé ! vérifier la saisie de l chaine !!")
    elif Est_PP(ch):
        windows.label_res.setText("La chaine " + ch + " est presque palindrome")
    else:
        windows.label_res.setText(ch + " une chaine n'est pas presque palindrome")

app = QApplication([])
windows = loadUi("InterPP.ui")
windows.show()
windows.pb_Verifier.clicked.connect(Play)
app.exec_()

Sujet pratique n°7 — Le nombre pointu

Énoncé

Soit N un entier naturel strictement supérieur à 1. On dit que N est pointu si :

• N admet au plus un seul facteur premier, OU
• en notant p et q les deux plus grands facteurs premiers de N, avec p > q, l'inégalité p ≥ 2 * q est vérifiée.

Exemples

❶ N = 25 est un nombre pointu car il n'a qu'un seul facteur premier (25 = 5×5).

❷ N = 147 est un nombre pointu car 147 = 3×7×7, les deux plus grands facteurs premiers sont 7 et 3 (p = 7, q = 3), et 7 ≥ 2×3.

❸ N = 105 n'est pas pointu car 105 = 3×5×7, les deux plus grands facteurs premiers sont 7 et 5, et 7 < 2×5.

Interface graphique

L'interface contient :

• Un label : "Nombre pointu"
• Un label : "Introduire un entier > 1 :"
• Une zone de saisie pour le nombre.
• Un bouton "Vérifier"
• Un bouton "Effacer"
• Un label pour afficher le message adéquat.

Travail demandé

1. Concevoir l'interface et l'enregistrer sous "InterPointu".
2. Créer un programme Python enregistré sous "NbrPointu".
3. Développer dans NbrPointu une fonction Pointu(N) qui vérifie si l'entier N est pointu ou non.
4. Dans NbrPointu :
   • Ajouter les instructions permettant d'appeler l'interface "InterPointu".
   • Développer le module "Play" déclenché par "Vérifier" : récupère N, exploite Pointu, et affiche le message adéquat.

Exemples d'exécution :

• Blabla → Désolé ! vérifier la saisie du nombre !!
• 1 → Désolé ! vérifier la saisie du nombre !!
• 91 → Le nombre 91 n'est pas pointu (91 = 7×13, p=13, q=7, 13 < 14)
• 88 → 88 est un nombre pointu (88 = 2³×11, p=11, q=2, 11 ≥ 4)
• 75 → Le nombre 75 n'est pas pointu (75 = 3×5×5, p=5, q=3, 5 < 6)
• 44 → 44 est un nombre pointu (44 = 2²×11, p=11, q=2)

Grille d'évaluation

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

def facteurs_premiers(N):
    """Renvoie la liste (avec multiplicité) des facteurs premiers de N."""
    facteurs = []
    d = 2
    while N > 1:
        while N % d == 0:
            facteurs.append(d)
            N //= d
        d += 1
    return facteurs

def Pointu(N):
    facteurs = facteurs_premiers(N)
    # facteurs premiers distincts
    distincts = sorted(set(facteurs))
    if len(distincts) <= 1:
        return True
    p = distincts[-1]      # plus grand
    q = distincts[-2]      # deuxième plus grand
    return p >= 2 * q

def Play():
    s = windows.le_N.text()
    if not s.isdigit() or int(s) <= 1:
        windows.label_res.setText("Désolé ! vérifier la saisie du nombre !!")
    else:
        N = int(s)
        if Pointu(N):
            windows.label_res.setText(str(N) + " est un nombre pointu")
        else:
            windows.label_res.setText("Le nombre " + str(N) + " n'est pas pointu")

app = QApplication([])
windows = loadUi("InterPointu.ui")
windows.show()
windows.pb_Verifier.clicked.connect(Play)
app.exec_()

Sujet pratique n°8 — Le nombre spécial

Durée : 1 heure

Exemples

• Le nombre 4879 est spécial car : 4*7 + 8*9 = 28 + 72 = 100 = 10²
• Le nombre 3256 n'est pas spécial car : 5² < 3*5 + 2*6 = 27 < 6²

Interface graphique demandée

Pour vérifier si un entier naturel de quatre chiffres N est un nombre spécial ou non, on se propose de concevoir une interface graphique contenant les éléments suivants :

• Un label contenant le texte : "Nombre spécial"
• Un label demandant la saisie du nombre : "Introduire un entier de quatre chiffres non nuls :"
• Une zone de saisie permettant la saisie du nombre
• Un bouton intitulé "Vérifier"
• Un bouton intitulé "Effacer" (permettant d'effacer la zone de saisie et le label d'affichage)
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir une interface graphique comme illustrée ci-dessus et l'enregistrer, dans votre dossier de travail, sous le nom "InterSPEC".
2. Créer un programme Python et l'enregistrer, dans votre dossier de travail, sous le nom "PgmeSPEC".
3. Développer dans le programme "PgmeSPEC", une fonction Special(N) qui permet de vérifier si l'entier N saisi est spécial ou non.
4. Dans le programme "PgmeSPEC" :
   • Ajouter les instructions permettant d'appeler l'interface graphique intitulée "InterSPEC" 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 Special afin d'afficher le message adéquat via le label dédié à l'affichage de l'interface "InterSPEC".

Exemples d'exécution attendus

Annexe — Modèle d'appel d'interface 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_()

Grille d'évaluation

Sujet pratique n°9 — Le nombre totalement impair

Durée : 1 heure (DC2 – Salem Moallem)

Numérotation des positions :

Exemples

• N = 347 est un nombre totalement impair, car ses chiffres impairs sont 7 et 3 occupent respectivement les positions 1 et 3 qui sont impaires.
• N = 6745 est un nombre totalement impair, car ses chiffres impairs sont 5 et 7 occupent respectivement les positions 1 et 3 qui sont impaires.
• N = 213 n'est pas un nombre totalement impair, car ses chiffres impairs sont 3 et 1 occupent respectivement les positions 1 et 2 alors que cette dernière (position 2 pour le chiffre 1) n'est pas impaire.
• N = 5329 n'est pas un nombre totalement impair, car ses chiffres impairs sont 9, 3 et 5 occupent respectivement les positions 1, 3 et 4 alors que le dernier chiffre 5 occupe une position paire.

Interface graphique demandée

Pour vérifier si un entier naturel N strictement positif est un nombre totalement impair ou non, on se propose de concevoir une interface graphique contenant les éléments suivants :

• Un label contenant le texte : "Nombre totalement impair"
• Un label demandant la saisie du nombre : "Introduire un entier >0 :"
• Une zone de saisie permettant la saisie du nombre
• Un bouton intitulé "Vérifier"
• Un bouton intitulé "Effacer" (permettant d'effacer la zone de saisie et le label d'affichage)
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir une interface graphique comme illustrée ci-dessus et l'enregistrer, dans votre dossier de travail, sous le nom "InterTOTIMP".
2. Créer un programme Python et l'enregistrer, dans votre dossier de travail, sous le nom "PgmeTOTIMP".
3. Développer dans le programme "PgmeTOTIMP", une fonction Tot_impair(N) qui permet de vérifier si l'entier N saisi est totalement impair ou non.
4. Dans le programme "PgmeTOTIMP" :
   • Ajouter les instructions permettant d'appeler l'interface graphique intitulée "InterTOTIMP" 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 Tot_impair afin d'afficher le message adéquat via le label dédié à l'affichage de l'interface "InterTOTIMP".

Exemples d'exécution attendus

Annexe — Modèle d'appel d'interface 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_()

Grille d'évaluation

Sujet pratique n°10 — Le nombre doublement palindrome

Durée : 1 h 30 min

Rappels

Exemple de conversion : 57 = 28×2 + 1, puis on continue : 57₁₀ = 111001₂.

Exemples

N = 313 est un nombre doublement palindrome car :

1. il est palindrome avec sa représentation décimale (313),
2. et palindrome avec sa représentation binaire (313 en binaire est égal à 100111001).

N = 22 n'est pas un nombre doublement palindrome car :

1. il est palindrome avec sa représentation décimale (22),
2. mais n'est pas palindrome avec sa représentation binaire (22 en binaire est égal à 10110).

Interface graphique demandée

Pour vérifier si un entier naturel N (N ≥ 1) palindrome est un nombre doublement palindrome ou non, on se propose de concevoir une interface graphique contenant les éléments suivants :

• Un label contenant le texte : "Nombre doublement palindrome"
• Un label demandant la saisie du nombre : "Introduire un entier >=1 et palindrome :"
• Une zone de saisie permettant la saisie du nombre
• Un bouton intitulé "Vérifier"
• Un bouton intitulé "Effacer" (permettant d'effacer la zone de saisie et le label d'affichage)
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir une interface graphique comme illustrée ci-dessus et l'enregistrer, dans votre dossier de travail, sous le nom "InterDP".
2. Créer un programme Python et l'enregistrer, dans votre dossier de travail, sous le nom "NbrDP".
3. Développer dans le programme "NbrDP", une fonction DP(N) qui permet de vérifier si l'entier N saisi est doublement palindrome ou non.
4. Dans le programme "NbrDP" :
   • Ajouter les instructions permettant d'appeler l'interface graphique intitulée "InterDP" en exploitant l'annexe.
   • 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 DP afin d'afficher le message adéquat via le label dédié à l'affichage de l'interface "InterDP".

Exemples d'exécution attendus

Sujet pratique n°11 — Le nombre de Smith

Durée : 1 heure

Exemples

• N = 636 est un nombre de Smith car : ses facteurs sont 2*2*3*53. La somme des chiffres de 636 est 15 (6+3+6) et celle des chiffres des facteurs est également 15 (2+2+3+5+3).
• N = 27 est un nombre de Smith car : ses facteurs sont 3*3*3. La somme des chiffres de 27 est 9 (2+7) et celle des chiffres des facteurs est également 9 (3+3+3).
• N = 25 n'est pas un nombre de Smith car : ses facteurs sont 5*5. La somme des chiffres de 25 est 7 (2+5) et celle des chiffres des facteurs est 10 (5+5).
• N = 56 n'est pas un nombre de Smith car : ses facteurs sont 2*2*2*7. La somme des chiffres de 56 est 11 (5+6) et celle des chiffres des facteurs est 13 (2+2+2+7).

Interface graphique demandée

Pour vérifier si un entier naturel N (N > 1) est un nombre de Smith ou non, on se propose de concevoir une interface graphique contenant les éléments suivants :

• Un label contenant le texte : "Nombre de Smith"
• Un label demandant la saisie du nombre : "Introduire un entier > 1 :"
• Une zone de saisie permettant la saisie du nombre
• Un bouton intitulé "Vérifier"
• Un bouton intitulé "Effacer" (permettant d'effacer la zone de saisie et le label d'affichage)
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir une interface graphique comme illustrée ci-dessus et l'enregistrer, dans votre dossier de travail, sous le nom "InterSmith".
2. Créer un programme Python et l'enregistrer, dans votre dossier de travail, sous le nom "NbrSmith".
3. Développer dans le programme "NbrSmith", une fonction Smith(N) qui permet de vérifier si l'entier N saisi est Smith ou non.
4. Dans le programme "NbrSmith" :
   • Ajouter les instructions permettant d'appeler l'interface graphique intitulée "InterSmith" en exploitant l'annexe.
   • 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 Smith afin d'afficher le message adéquat via le label dédié à l'affichage de l'interface "InterSmith".

Exemples d'exécution attendus

Annexe — Modèle d'appel d'interface 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_()

Grille d'évaluation

Sujet pratique n°12 — Nombres SECTIONNABLE UNITAIRES

Exemples illustratifs

• 3 est un nombre sectionnable unitaire car 3 = 1 + 2.
• 10 est un nombre sectionnable unitaire car 10 = 1 + 2 + 3 + 4.
• 16 n'est pas un nombre sectionnable unitaire :
  • 16 > 1 + 2 + 3 + 4 + 5 (= 15)
  • 16 < 1 + 2 + 3 + 4 + 5 + 6 (= 21)
• 21 est un nombre sectionnable unitaire car 21 = 1 + 2 + 3 + 4 + 5 + 6.
• 136 est un nombre sectionnable unitaire car 136 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16.

Travail demandé

Écrire un programme en Python qui permet de :

• Remplir un tableau T par m entiers naturels supérieurs ou égaux à 3, avec 4 ≤ m ≤ 20.
• Déterminer et afficher, à partir du tableau T :
  • Les entiers sectionnable unitaires (sans redondance) selon la description précédente, s'ils existent.
  • Sinon, le message : "Aucun nombre Sectionnable unitaire dans le tableau".

Exemples

Exemple 1 — Soit m = 7 et le tableau T suivant :

Le programme affiche : les nombres sectionnable unitaires sont : 10, 15, 136

Exemple 2 — Soit m = 4 et le tableau T suivant :

Le programme affiche : Aucun nombre sectionnable unitaire dans le tableau

Sujet pratique n°13 — Nombres ÉTRANCHES

Exemples illustratifs

• 2016 est un nombre ÉTRANCHE :
  • 20 est divisible par 2
  • 201 est divisible par 3
  • 2016 est divisible par 4
• 201920 n'est pas un nombre ÉTRANCHE :
  • 20 est divisible par 2
  • 201 est divisible par 3
  • 2019 n'est pas divisible par 4 → on arrête la vérification.
• 705 est un nombre ÉTRANCHE : 70 divisible par 2, 705 divisible par 3.
• 72 est un nombre ÉTRANCHE : 72 divisible par 2.
• 2041 n'est pas ÉTRANCHE : 20 ÷ 2 ✓, 204 ÷ 3 ✓, mais 2041 n'est pas divisible par 4.

Travail demandé

Écrire un programme en Python qui permet de :

• Remplir un tableau T par m entiers naturels de deux chiffres ou plus, avec 4 ≤ m ≤ 20.
• Déterminer et afficher, à partir du tableau T :
  • Les entiers ÉTRANCHES, s'ils existent.
  • Sinon, le message : "Aucun nombre ETRANCHE dans le tableau".

Exemples

Exemple 1 — m = 7 :

Le programme affiche : les nombres ETRANCHES sont : 102, 72, 705, 705204, 1024

Exemple 2 — m = 4 :

Le programme affiche : Aucun nombre ETRANCHE dans le tableau

Sujet pratique n°14 — Nombres doublement palindromes

Fonction Palindrome fournie

L'algorithme suivant est celui d'une fonction permettant de vérifier si un entier X est palindrome ou non.

Fonction Palindrome (X : entier) : booléen
Début
    ch ← convch(X)
    i ← 0
    Tant que i < Long(ch) Div 2 ET ch[i] = ch[Long(ch) - 1 - i] Faire
        i ← i + 1
    Fin Tant que
    Retourner i = Long(ch) Div 2
Fin

TDOL :

Définitions

Travail demandé

Utiliser la fonction Palindrome ci-dessus, pour écrire un programme en Python permettant de :

• Saisir un tableau T de N entiers strictement positifs palindromes (5 ≤ N ≤ 20).
• Afficher, s'ils existent, les nombres doublement palindromes.

Exemple

Pour N = 8 et le tableau T suivant :

Le programme affiche :

Les nombres doublement palindromes sont :
33 = 100001
717 = 1011001101
99 = 1100011

Sujet pratique n°15 — Concours d'une commune

Énoncé

Une commune organise sur un week-end un concours de course / marche / randonnée par équipes. Pour gérer les résultats, les organisateurs ont créé deux tableaux :

• TN (Tableau des Noms) : noms des équipes.
• TT (Tableau des Temps) : temps total (en secondes) pris par chaque équipe pour réaliser les épreuves.

À un nom inscrit à l'indice i de TN correspond le temps inscrit à l'indice i de TT.

Exemple avec 4 équipes :

Les deux équipes La clef des champs et Les schtroumpfs sont en tête avec 7045 s, suivies de Les bisounours (7357 s), puis Vert de gris (9283 s).

Travail demandé

Réaliser un programme en Python intitulé 'COMPETITION' qui permet de :

• Remplir simultanément les deux tableaux TN et TT par respectivement N noms d'équipes (avec 3 ≤ N ≤ 20) et leurs temps totaux.

• Afficher le classement final en commençant par l'équipe qui a réalisé le plus petit temps. Les équipes ayant un même temps auront le même rang dans le classement.

Exemple d'affichage attendu

Le classement est :
Rang n°1 : L'équipe La clef des champs a pris 1 H : 57 Min : 25 Sec pour réaliser toutes les épreuves
           L'équipe Les schtroumpfs    a pris 1 H : 57 Min : 25 Sec pour réaliser toutes les épreuves
Rang n°3 : L'équipe Les bisounours     a pris 2 H :  3 Min : 37 Sec pour réaliser toutes les épreuves
Rang n°4 : L'équipe Vert de gris       a pris 2 H : 34 Min : 43 Sec pour réaliser toutes les épreuves

Sujet pratique n°16 — Nombres CRO-DEC et DEC-CRO

Définitions

Exemples

Nombres CRO-DEC :

• 283 : CRO-DEC car 2 < 8 et 8 > 3.
• 35741 : CRO-DEC car 3 < 5 < 7 > 4 > 1.

Nombres DEC-CRO :

• 724 : DEC-CRO car 7 > 2 < 4.
• 85169 : DEC-CRO car 8 > 5 > 1 < 6 < 9.

Nombres ni CRO-DEC ni DEC-CRO :

• 289 : pas CRO-DEC (2 < 8 mais 8 < 9), pas DEC-CRO (2 < 8).
• 35541 : pas CRO-DEC (le chiffre du milieu 5 n'est pas strictement supérieur au précédent), pas DEC-CRO (3 < 5).
• 35749 : pas CRO-DEC (le dernier chiffre 9 n'est pas strictement inférieur au précédent), pas DEC-CRO (3 < 5).

Interface graphique demandée

L'interface InterCRODEC doit contenir :

• Un label : "CRO-DEC *** DEC-CRO"
• Un label : "Introduire un entier >= 100 et dont le nombre de ses chiffres est impair : "
• Une zone de saisie pour le nombre.
• Un bouton "Vérifier".
• Un bouton "Effacer" (efface la saisie et le label d'affichage).
• Un label pour le message résultat.

Travail demandé

1. Concevoir l'interface graphique ci-dessus et l'enregistrer sous le nom "InterCRODEC".
2. Créer un programme Python sous le nom "NbrCRODEC".
3. Développer dans NbrCRODEC deux fonctions CRODEC(N) et DECRO(N) qui vérifient respectivement si un entier N :
   • est un nombre CRO-DEC,
   • est un nombre DEC-CRO.
4. Développer un module Play qui s'exécute suite au clic sur le bouton "Vérifier", qui récupère l'entier N saisi, exploite les deux fonctions, et affiche le message adéquat via le label dédié de l'interface.

Exemples d'exécution

Sujet pratique n°17 — Le mot emprisonné

Définition

Exemples

❶ MotA = "CHAT" est prisonnier dans MotB = "ATTACHANT" :

• La 1ʳᵉ lettre "C" existe dans MotB.
• La 2ᵉ lettre "H" existe après la 1ʳᵉ position de "C" dans MotB (dans la sous-chaîne "HANT").
• La 3ᵉ lettre "A" existe après la 1ʳᵉ position de "H" (dans "ANT").
• La 4ᵉ lettre "T" existe après la 1ʳᵉ position de "A" (dans "NT").

❷ MotA = "LIGNE" n'est PAS prisonnier dans MotB = "SIGNALER" :

• "L" existe dans MotB.
• Mais "I" existe dans MotB et pas après la 1ʳᵉ position de "L" (qui pointe vers "ER") → on arrête.

❸ MotA = "TIGE" est prisonnier dans MotB = "DISTINGUE" :

• "T" existe dans MotB.
• "I" existe après la position de "T" (dans "INGUE").
• "G" existe après la position de "I" (dans "NGUE").
• "E" existe après la position de "G" (dans "UE").

❹ MotA = "CAGE" n'est PAS prisonnier dans MotB = "AVANTAGEUX" :

• La 1ʳᵉ lettre "C" n'existe pas dans MotB → on arrête.

Interface graphique demandée

L'interface InterEMPRIS doit contenir :

• Un label : "Emprisonnement d'un mot".
• Un label : "Introduire MotA, un mot non vide contenant que des lettres majuscules : "
• Une zone de saisie pour MotA.
• Un label : "Introduire MotB, un mot alphabétique majuscule dont sa longueur est supérieure ou égale à MotA : "
• Une zone de saisie pour MotB.
• Un bouton "Vérifier".
• Un bouton "Effacer".
• Un label pour le message résultat.

Travail demandé

1. Concevoir l'interface graphique et l'enregistrer sous le nom "InterEMPRIS".
2. Créer un programme Python sous le nom "MotEmpris".
3. Développer dans MotEmpris une fonction Emprisonnier(MotA, MotB) qui vérifie si MotA est prisonnier dans MotB.
4. Dans le programme MotEmpris :
   • Ajouter les instructions permettant d'appeler l'interface "InterEMPRIS" (en exploitant l'annexe ci-dessous).
   • Développer un module Play qui s'exécute suite au clic sur "Vérifier", récupère MotA et MotB, exploite la fonction Emprisonnier et affiche le message adéquat.

Exemples d'exécution

Annexe — Appel d'une interface 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_()

Sujet pratique n°18 — Les nombres homogènes

Définition

Exemples

❶ A = 60 et B = 90 sont homogènes : leurs facteurs premiers sont mutuellement 2, 3 et 5.

• 60 = 2² × 3 × 5
• 90 = 2 × 3² × 5

❷ A = 63 et B = 84 ne sont pas homogènes :

• 63 = 3² × 7 → facteurs distincts : {3, 7}
• 84 = 2² × 3 × 7 → facteurs distincts : {2, 3, 7}

❸ A = 48 et B = 72 sont homogènes : facteurs premiers communs 2 et 3.

• 48 = 2⁴ × 3
• 72 = 2³ × 3²

❹ A = 50 et B = 70 ne sont pas homogènes :

• 50 = 2 × 5² → facteurs distincts : {2, 5}
• 70 = 2 × 5 × 7 → facteurs distincts : {2, 5, 7}

Interface graphique demandée

L'interface doit contenir :

• Un label : "Les nombres homogènes".
• Un label : "Introduire le premier nombre > 1 : "
• Une zone de saisie pour le premier nombre.
• Un label : "Introduire le second nombre > 1 et différent de premier nombre : "
• Une zone de saisie pour le second nombre.
• Un bouton "Vérifier".
• Un bouton "Effacer" (efface saisies et message).
• Un label pour le message résultat.

Sujet pratique n°19 — Nombres homogènes

Lycée Béja Nord — DC3 (4ème M2) — Durée : 1 heure

Énoncé

Deux entiers naturels A et B ( A ≠ B et A, B > 1 ) sont dits homogènes si l'un des deux entiers contient tous les diviseurs premiers de l'autre.

Exemples :

• ❶ A = 50 et B = 20 sont homogènes car les diviseurs premiers de 50 sont {2, 5} et les diviseurs premiers de 20 sont {2, 5}.
• ❷ A = 22 et B = 88 sont homogènes car les diviseurs premiers de 22 sont {2, 11} et les diviseurs premiers de 88 sont {2, 11}.
• ❸ A = 72 et B = 48 sont homogènes car les diviseurs premiers de 72 sont {2, 3} et ceux de 48 sont {2, 3}.
• ➍ A = 25 et B = 62 ne sont pas homogènes car les diviseurs premiers de 25 sont {5} et ceux de 62 sont {2, 31}.
• ❺ A = 11 et B = 88 ne sont pas homogènes car les diviseurs premiers de 11 sont {11} et ceux de 88 sont {2, 11}.

Pour vérifier si deux entiers A et B sont homogènes ou non, on se propose de concevoir une interface graphique contenant :

• Un label contenant le texte : "Nombres homogènes"
• Deux labels demandant la saisie des deux nombres
• Deux zones de saisie pour les nombres A et B
• Un bouton "Vérifier"
• Un bouton "Effacer" (permettant d'effacer les zones de saisie et le label d'affichage)
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir une interface graphique comme illustrée ci-dessus et l'enregistrer, dans votre dossier de travail, sous le nom "InterHOMO".
2. Créer un programme Python et l'enregistrer, dans votre dossier de travail, sous le nom "PgmeHOMO".
3. Développer dans le programme "PgmeHOMO", une fonction Homogene(A, B) qui permet de vérifier si les deux entiers A et B saisis sont homogènes ou non.
4. Dans le programme "PgmeHOMO" :
   • Ajouter les instructions permettant d'appeler l'interface graphique intitulée "InterHOMO" 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 Homogene afin d'afficher le message adéquat via le label dédié à l'affichage de l'interface "InterHOMO".

Exemples d'exécution attendus

Annexe — Squelette 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_()

Sujet pratique n°20 — Le plus petit multiple binaire d'un nombre décimal

Lycée Béja Nord — DC3 (4ème M2) — Durée : 1 heure

Énoncé

Pour se divertir pendant son temps libre, deux enfants s'amusent à inventer des codes. Le premier enfant propose, à son ami, de coder un entier naturel N par son plus petit multiple non nul contenant uniquement des zéros et des uns.

N.B. :

• L'entier N doit être dans l'intervalle [1, 88].
• ** N** n'est pas un multiple de 9.
• *** N** ne contient pas le chiffre 9.

Exemples :

• ❶ Le plus petit multiple de 2 satisfaisant la condition est 10. Donc le nombre 2 est codé en 10.
• ❷ Le plus petit multiple de 3 dont ses chiffres sont uniquement des zéros et (ou) des uns est 111. (3 × 37 = 111).
• ❸ Le plus petit multiple de 4 dont ses chiffres sont uniquement des zéros et (ou) des uns est 100. (4 × 25 = 100).
• ➍ Le plus petit multiple de 5 dont ses chiffres sont uniquement des zéros et (ou) des uns est 10. (5 × 2 = 10).
• ❺ Le plus petit multiple de 6 dont ses chiffres sont uniquement des zéros et (ou) des uns est 1110. (6 × 185 = 1110).
• ❻ Le plus petit multiple de 58 dont ses chiffres sont uniquement des zéros et (ou) des uns est 11011010. (58 × 189845 = 11011010).

L'interface graphique doit contenir :

• Un label : "Plus Petit Multiple Binaire"
• Un label : "Introduire un entier satisfaisant les 3 conditions :"
• Une zone de saisie pour le nombre
• Un bouton "Vérifier"
• Un bouton "Effacer"
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir l'interface graphique et l'enregistrer sous "InterPPMB".
2. Créer le programme Python "PgmePPMB".
3. Développer dans "PgmePPMB" une fonction PPMB(N) qui retourne le plus petit multiple binaire de l'entier N.
4. Dans le programme "PgmePPMB" :
   • Ajouter les instructions appelant l'interface "InterPPMB" (voir annexe).
   • Développer un module "Play", déclenché par le clic sur "Vérifier", qui récupère N, vérifie les 3 conditions et exploite PPMB pour afficher le message adéquat.

Exemples d'exécution attendus

Annexe — Squelette 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_()

Sujet pratique n°21 — Le nombre multipotent

Lycée Béja Nord — DC3 (4ème SC & M) — Durée : 1 heure

Énoncé

Exemples :

• ❶ Le nombre 30 est multipotent car le produit de ses diviseurs (1 × 2 × 3 × 5 × 6 × 10 × 15 × 30 = 810 000) est égal à 30⁴ = 810 000.
• ❷ Le nombre 6 est multipotent car le produit de ses diviseurs (1 × 2 × 3 × 6 = 36) est égal à 6² = 36.
• ❸ Le nombre 9 n'est pas multipotent car le produit de ses diviseurs (1 × 3 × 9 = 27) n'est pas égal à une puissance de 9 : en effet 9¹ < 27 < 9².
• ➍ Le nombre 10 est multipotent car (1 × 2 × 5 × 10 = 100) = 10².
• ❺ Le nombre 16 n'est pas multipotent car (1 × 2 × 4 × 8 × 16 = 1024) n'est pas égal à une puissance de 16 : 16² < 1024 < 16³.
• ❻ Le nombre 84 est multipotent car le produit de ses diviseurs (1 × 2 × 3 × 4 × 6 × 7 × 12 × 14 × 21 × 28 × 42 × 84 = 351 298 031 616) est égal à 84⁶.

L'interface graphique contient :

• Un label : "Nombre multipotent"
• Un label : "Introduire un entier >= 1 :"
• Une zone de saisie
• Un bouton "Vérifier"
• Un bouton "Effacer"
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir l'interface graphique et l'enregistrer sous "InterMULT".
2. Créer le programme Python "PgmeMULT".
3. Développer dans "PgmeMULT" une fonction Multipotent(N) qui vérifie si l'entier N saisi est multipotent ou non.
4. Dans le programme "PgmeMULT" :
   • Ajouter les instructions appelant l'interface "InterMULT" (voir annexe).
   • Développer un module "Play", déclenché par le clic sur "Vérifier", qui récupère N et exploite Multipotent pour afficher le message adéquat.

Exemples d'exécution attendus

Sujet pratique n°22 — Le nombre lisse (Bac Pratique 2022)

Lycée Béja Nord — Bac Pratique 2022 (4ème SC & M) — Durée : 1 heure

Énoncé

Exemples :

• N = 60, les diviseurs de 60 sont : 1, 2, 3, 4, 5, 6, 10, 12, 15, 30 et 60. Son plus grand diviseur premier est 5 et puisque 5 ≤ √60 ≈ 7,746, donc 60 est un nombre lisse.
• N = 49, les diviseurs de 49 sont : 1, 7 et 49. Son plus grand diviseur premier est 7 et puisque 7 ≤ √49 = 7, donc 49 est un nombre lisse.
• N = 22, les diviseurs de 22 sont : 1, 2, 11 et 22. Son plus grand diviseur premier est 11 et puisque 11 > √22 ≈ 4,690, donc 22 n'est pas un nombre lisse.

Pour vérifier si un entier naturel N (N > 1) est lisse ou non, on conçoit une interface graphique contenant :

• Un label : "Nombre lisse"
• Un label : "Introduire un entier >1 :"
• Une zone de saisie
• Un bouton "Vérifier"
• Un bouton "Effacer" (Annuler dans la maquette)
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir l'interface graphique et l'enregistrer sous "InterfaceLisse".
2. Créer le programme Python "NbrLisse".
3. Développer dans "NbrLisse" une fonction Lisse(N) qui vérifie si l'entier N est lisse ou non.
4. Dans le programme "NbrLisse" :
   • Ajouter les instructions appelant l'interface "InterfaceLisse" (voir annexe).
   • Développer un module "Play", déclenché par le clic sur "Vérifier", qui récupère N et exploite Lisse pour afficher le message adéquat.

Exemples d'exécution attendus

Sujet pratique n°23 — Le nombre semi-premier (Bac Pratique 2022)

Lycée Béja Nord — Bac Pratique 2022 (4ème SC & M) — Durée : 1 heure

Énoncé

Exemples :

• 6 est un nombre semi-premier car 6 = 2 × 3 avec 2 et 3 deux nombres premiers.
• 25 est un nombre semi-premier car 25 = 5 × 5 avec 5 nombre premier.
• 831 est un nombre semi-premier car 831 = 3 × 277 avec 3 et 277 deux nombres premiers.
• 8 n'est pas un nombre semi-premier, car 8 = 2 × 4 et 4 n'est pas un nombre premier.

Pour vérifier si un entier naturel N (N > 2) est un nombre semi-premier ou non, on conçoit une interface graphique contenant :

• Un label : "Nombre semi-premier"
• Un label : "Introduire un entier > 2 :"
• Une zone de saisie
• Un bouton "Vérifier"
• Un bouton "Effacer" (Annuler dans la maquette)
• Un label pour afficher le message adéquat

Travail demandé

1. Concevoir l'interface graphique et l'enregistrer sous "InterfaceSemiPremier".
2. Créer le programme Python "NbrSemiPremier".
3. Développer dans "NbrSemiPremier" une fonction SemiPremier(N) qui vérifie si N est semi-premier ou non.
4. Dans le programme "NbrSemiPremier" :
   • Ajouter les instructions appelant l'interface "InterfaceSemiPremier" (voir annexe).
   • Développer un module "Play", déclenché par le clic sur "Vérifier", qui récupère N et exploite SemiPremier pour afficher le message adéquat.

Exemples d'exécution attendus

Sujet n°23 — Le nombre hautement abondant

Bac Pratique AR 2022 — Durée : 1 heure

Énoncé

Un nombre N est dit hautement abondant si la somme de ses diviseurs (lui-même inclus) est strictement supérieure à la somme des diviseurs de n'importe quel nombre plus petit que lui (le nombre inclus).

Exemples

• 8 est hautement abondant car la somme de ses diviseurs, qui est égale à 15 (1+2+4+8=15), est strictement supérieure à la somme des diviseurs de tout entier plus petit que lui.
• 5 n'est pas hautement abondant car la somme de ses diviseurs, qui est égale à 6 (1+5=6), est inférieure à 7 qui est la somme des diviseurs de 4 (1+2+4=7).

Algorithme fourni

Voici l'algorithme de la fonction SOMDIV qui calcule la somme des diviseurs d'un entier naturel non nul :

Fonction SOMDIV (n : Entier) : Entier
DEBUT
    S ← n
    Pour i de 1 à n DIV 2 faire
        Si n MOD i = 0 alors
            S ← S + i
        Fin Si
    Fin Pour
    Retourner S
FIN

Problème

On décide d'afficher tous les nombres hautement abondants compris entre deux bornes p et q saisies avec 3 < p < q < 50, en faisant appel à la fonction SOMDIV.

L'interface graphique à concevoir contient :

• Un label contenant le texte : "Nombres hautement abondants"
• Un label demandant la saisie de la borne inférieure : "Introduire un entier p > 3 :"
• Une zone de saisie pour la borne inférieure
• Un label demandant la saisie de la borne supérieure : "Introduire un entier q tel que p < q < 50 :"
• Une zone de saisie pour la borne supérieure
• Un bouton intitulé "Vérifier"
• Un bouton intitulé "Effacer" (effacer la zone de saisie et le label d'affichage)
• Un label pour afficher le message adéquat

Exemples d'exécution attendus

Travail demandé

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_()

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

def SOMDIV(n):
    S = n
    for i in range(1, n // 2 + 1):
        if n % i == 0:
            S += i
    return S

def NbresHA(p, q):
    res = ""
    for n in range(p, q + 1):
        somN = SOMDIV(n)
        hautement = True
        for k in range(1, n):
            if SOMDIV(k) >= somN:
                hautement = False
                break
        if hautement:
            res += str(n) + ","
    return res[:-1]  # supprimer la dernière virgule

def Play():
    try:
        p = int(fen.a.text())
        q = int(fen.b.text())
    except:
        fen.res.setText("Veuillez introduire les deux bornes satisfaisantes les conditions !!")
        return
    if not (3 < p < q < 50):
        fen.res.setText("Veuillez introduire les deux bornes satisfaisantes les conditions !!")
    else:
        fen.res.setText(NbresHA(p, q))

def Efface():
    fen.a.clear()
    fen.b.clear()
    fen.res.clear()

app = QApplication([])
fen = loadUi("InterHA.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(Efface)
app.exec_()

Sujet n°24 — Jeu de chance

Prototype 2022 — Durée : 1 heure

Énoncé

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 le message "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, avec l'indice du premier chiffre égal à 0.
• Un nombre premier est un nombre qui est divisible par 1 et par lui-même.

Exemple

Donner le numéro : 29234560

Le programme affiche : Désolé, vous n'avez pas gagné.

En effet, le nombre de chance est égal à 99 qui n'est pas un nombre premier.

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

Algorithme fourni

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

Interface graphique

L'interface comporte :

• Un label contenant le nom de la société.
• Un label demandant la saisie du numéro de téléphone.
• Une zone de saisie pour le numéro de téléphone.
• Un bouton nommé "Jouer".
• Un label pour afficher un message.

Travail demandé

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

def Premier(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def Chance(Ch):
    if not (Ch.isnumeric() and len(Ch) == 8 and Ch[0] in ["2","4","5","9"]):
        msg = "Vérifier le numéro de téléphone !"
    else:
        msg = "Désolé, vous n'avez pas gagné."
        s = 0
        for i in range(len(Ch)):
            s += int(Ch[i]) * i
        if Premier(s):
            msg = "Félicitation, vous avez gagné."
    return msg

def Play():
    num = fen.a.text()
    fen.res.setText(Chance(num))

def Efface():
    fen.a.clear()
    fen.res.clear()

app = QApplication([])
fen = loadUi("Interface_Jeu.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(Efface)
app.exec_()

Sujet n°25 — Salle de sport

Bac Pratique 2019 — Durée : 1 heure

Énoncé

Un gérant d'une salle de sport veut récompenser les adhérents fidèles en leur offrant un bonus sous forme d'heures d'entraînement gratuites, calculé à partir de leurs numéros d'abonnement.

Le bonus est calculé en fonction de l'ancienneté de l'adhérent, exprimée en nombre de mois par rapport à la date du jour. Une heure supplémentaire est offerte pour chaque mois d'ancienneté, sachant que le bonus ne sera pris en considération que si l'ancienneté dépasse 5 ans.

Un numéro d'abonnement est formé de 10 chiffres répartis comme suit :

• Les 4 premiers chiffres représentent l'année d'adhésion qui doit être comprise entre 2000 et 2022.
• Les 2 suivants représentent le mois d'adhésion dont la valeur doit être comprise entre 1 et 12.
• Les 4 derniers chiffres représentent le numéro d'adhésion qu'on suppose distinct pour tous les adhérents.

Exemple

Pour le numéro d'abonnement 2016020110, l'année d'adhésion est 2016, le mois d'adhésion est 02 (Février) et son numéro d'adhésion est 0110. Le bonus accordé à cet adhérent est de 86 heures. En effet, son ancienneté est égale à six ans et deux mois par rapport à la date d'aujourd'hui (02/05/2023), en nombre de mois elle est égale à 86 (12×7 + 2).

Algorithme fourni

Fonction Fidelite (Ch : chaine) : Chaine
DEBUT
    Si NON Valide(ch) Alors
        msg ← "Vérifier le numéro d'abonnement"
    SinonSi Anciennete(ch) < 60 alors
        msg ← "L'ancienneté de l'adhérent est inférieure à 5 ans"
    Sinon
        msg ← "L'adhérent à un bonus de " + convch(Anciennete(ch)) + " heures"
    Fin Si
    Retourner msg
FIN

Interface graphique

L'interface comporte :

• Un label contenant le titre "Salle de sport".
• Un label demandant la saisie d'un numéro d'adhésion.
• Une zone de saisie pour le numéro d'adhésion.
• Un bouton nommé "Calculer".
• Un label pour afficher un message.

Travail demandé

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

# Date du jour : 02/05/2023
JOUR_MOIS = 5
JOUR_ANNEE = 2023

def Valide(ch):
    if not (ch.isnumeric() and len(ch) == 10):
        return False
    annee = int(ch[0:4])
    mois = int(ch[4:6])
    return (2000 <= annee <= 2022) and (1 <= mois <= 12)

def Anciennete(ch):
    annee = int(ch[0:4])
    mois = int(ch[4:6])
    return (JOUR_ANNEE - annee) * 12 + (JOUR_MOIS - mois)

def Fidelite(ch):
    if not Valide(ch):
        msg = "Vérifier le numéro d'abonnement"
    elif Anciennete(ch) < 60:
        msg = "L'ancienneté de l'adhérent est inférieure à 5 ans"
    else:
        msg = "L'adhérent à un bonus de " + str(Anciennete(ch)) + " heures"
    return msg

def Bonus():
    num = fen.a.text()
    fen.res.setText(Fidelite(num))

def Efface():
    fen.a.clear()
    fen.res.clear()

app = QApplication([])
fen = loadUi("Interface_adhesion.ui")
fen.show()
fen.b1.clicked.connect(Bonus)
fen.b2.clicked.connect(Efface)
app.exec_()

Annexes — Codes Python complets de sujets antérieurs

Cette section regroupe les codes Python complets fournis comme annexes de correction pour plusieurs sujets précédents.

Sujet n°01 — Chariot gratuit (gestion d'un tableau aléatoire)

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
from random import randint
from numpy import array
T = array([int()]*8)

def REMP_AFFICHE(T):
    for i in range(7):
        T[i] = randint(1, 99)
        print(T[i], end=" | ")
    print()
#******************************************
def GainPerd(N):
    s = Somme(N)
    while len(str(s)) != 1:
        s = Somme(str(s))
    return Existence(s*s, T)
#******************************************
def Somme(x):
    som = 0
    for i in range(len(x)):
        som += int(x[i])
    return som
#******************************************
def Existence(nb, T):
    i = -1
    while i < 8 and T[i] != nb:
        i += 1
    return i < 8
#******************************************
def Play():
    N = fen.a.text()
    if not ( N.isdecimal() and ( len(N) == 8 ) and (N[0] in {"2","3","4","5","9"}) ):
        fen.res.setText("Désolé ! vérifier le numéro de téléphone du client !!")
    elif GainPerd(N):
        fen.res.setText("Le client ayant le numéro de téléphone " + N + " \n a gagné un chariot gratuit")
    else:
        fen.res.setText("Le client ayant le numéro de téléphone " + N + " \n doit payer les achats du chariot")
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
REMP_AFFICHE(T)
app = QApplication([])
fen = loadUi("InterCHARIOT.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n°02 — Cryptage avec clé alphabétique

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
from random import randint

def Generer():
    ch = ""
    for i in range(26):
        n = randint(65, 90)
        while ch.find(chr(n)) != -1 or n == i:
            n = randint(65, 90)
        ch += chr(n)
    return ch
#******************************************
def Crypter(m, c):
    ch = ""
    for i in range(len(m)):
        if "A" <= m[i] <= "Z":
            ch += c[ord(m[i]) - 65]
        else:
            ch += m[i]
    return ch
#******************************************
def Majuscule_Espace(ch):
    i = 0
    while i < len(ch) and ("A" <= ch[i] <= "Z" or ch[i] == " "):
        i += 1
    return i == len(ch)
#******************************************
def Play():
    m = fen.a.text()
    if not ( 1 <= len(m) <= 100 and Majuscule_Espace(m) ):
        fen.res.setText("Désolé ! vérifier le message à crypter !!")
    else:
        cle = Generer()
        MC = Crypter(m, cle)
        fen.cle.setText("la clé générée est: " + cle)
        fen.res.setText("Le message crypté sera: " + MC)
#******************************************
def efface():
    fen.a.clear()
    fen.cle.clear()
    fen.res.clear()
#******************************************
app = QApplication([])
fen = loadUi("InterCRYPTE_AC.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n°03 — Cryptage par occurrences successives

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def Crypter(ch):
    ch_crypte = ""
    nb = 1
    for i in range(len(ch) - 1):
        if ch[i] == ch[i+1]:
            nb += 1
        else:
            ch_crypte += str(nb) + ch[i]
            nb = 1
    ch_crypte += str(nb) + ch[len(ch)-1]
    return ch_crypte
#******************************************
def Alphabetique(ch):
    i = 0
    while i < len(ch) and ("A" <= ch[i].upper() <= "Z"):
        i += 1
    return i == len(ch)
#******************************************
def Play():
    CH = fen.a.text()
    if not ( 1 <= len(CH) <= 50 and Alphabetique(CH) ):
        fen.res.setText("Désolé ! vérifier la chaîne à crypter !!")
    else:
        CHC = Crypter(CH)
        fen.res.setText("La chaîne cryptée sera: " + CHC)
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app = QApplication([])
fen = loadUi("InterCRYPTE_OS.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n°04 — Cryptage à base de l'occurrence d'un caractère

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def occurrence(c, ch):
    nb = 0
    for i in range(len(ch)):
        if ch[i] == c:
            nb += 1
    return nb
#******************************************
def Crypter(ch):
    m = ""
    for i in range(len(ch)):
        n = occurrence(ch[i], ch)
        if n % 2 == 0:
            k = n // 2
        else:
            k = 2 * n
        m += chr( ( ord(ch[i]) - ord("A") + k ) % 26 + ord("A") )
    return m
#******************************************
def Majuscule(ch):
    i = 0
    while i < len(ch) and ("A" <= ch[i] <= "Z"):
        i += 1
    return i == len(ch)
#******************************************
def Play():
    MS = fen.a.text()
    if not ( 1 <= len(MS) and Majuscule(MS) ):
        fen.res.setText("Désolé ! vérifier le mot à crypter !!")
    else:
        fen.res.setText("Le mot crypté sera: " + Crypter(MS))
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app = QApplication([])
fen = loadUi("InterCRYPTE_AM.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n°05 — Mots frères et cousins

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def Freres(A, B):
    voyelle = "aeiuoy"
    i = 0
    while i < len(A) and ( (voyelle.find(A[i]) == -1 and voyelle.find(B[i]) == -1) or (voyelle.find(A[i]) != -1 and voyelle.find(B[i]) != -1) ):
        i += 1
    return i == len(A)
#******************************************
def Cousins(A, B):
    voyelle = "aeiuoy"
    i = 0
    while i < len(A) and ( (voyelle.find(A[i]) == -1 and voyelle.find(B[i]) != -1) or (voyelle.find(A[i]) != -1 and voyelle.find(B[i]) == -1) ):
        i += 1
    return i == len(A)
#******************************************
def AlphaMinus(ch):
    i = 0
    while i < len(ch) and "a" <= ch[i] <= "z":
        i += 1
    return i == len(ch)
#******************************************
def Play():
    MotA = fen.cha.text()
    MotB = fen.chb.text()
    if ( MotA == "" ) or ( not AlphaMinus(MotA) ) or ( len(MotB) != len(MotA) ) or ( not AlphaMinus(MotB) ):
        fen.res.setText("Désolé ! vérifier la saisie des mots !!")
    elif Freres(MotA, MotB):
        fen.res.setText(MotA + " est frère de " + MotB)
    elif Cousins(MotA, MotB):
        fen.res.setText("Le mot " + MotA + " est cousin de " + MotB)
    else:
        fen.res.setText("Les deux mots ni frères ni cousins")
#******************************************
def efface():
    fen.cha.clear()
    fen.chb.clear()
    fen.res.clear()
#******************************************
app = QApplication([])
fen = loadUi("InterFRCO.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 06 — Chaîne presque palindrome

Ce programme vérifie si une chaîne est « presque palindrome » : chaque caractère à la position i et son symétrique à la position len(ch)-1-i doivent être de même nature (deux voyelles, deux consonnes, deux chiffres ou deux symboles), sans pour autant être identiques (sauf au centre).

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def palindrome(ch):
    i=0
    while i<len(ch)//2  and ch[i].upper()==ch[len(ch)-1-i].upper():
        i+=1
    return i==len(ch)//2
#******************************************
def Est_Voyelles(a,b):
    voyelle="AEIOUY"
    if voyelle.find(a.upper()) !=-1 and voyelle.find(b.upper()) !=-1:
        return True
    else:
        return False
#******************************************
def Est_Consonnes(a,b):
    voyelle="AEIOUY"
    if "A" <= a.upper() <= "Z" and  "A" <= b.upper() <= "Z" :
        if voyelle.find(a.upper()) ==-1 and voyelle.find(b.upper()) ==-1:
            return True
        else:
            return False
#******************************************
def Est_Chiffres(a,b):
    chiffre="0123456789"
    if chiffre.find(a) !=-1 and chiffre.find(b) !=-1:
        return True
    else:
        return False
#******************************************
def Est_Symboles(a,b):
    if not "A" <= a.upper() <= "Z" and not "0" <= a <= "9"  and not "A" <= b.upper() <= "Z" and not "0" <= b <= "9":
        return True
    else:
        return False
#******************************************
def Est_PP(ch):
    verife=not palindrome(ch)
    i=0
    while i< len(ch)//2 and verife:
        if Est_Voyelles(ch[i],ch[len(ch)-1-i]) or Est_Consonnes(ch[i],ch[len(ch)-1-i]) or Est_Chiffres(ch[i],ch[len(ch)-1-i]) or Est_Symboles(ch[i],ch[len(ch)-1-i]):
            i+=1
        else:
            verife=False
    return verife
#******************************************
def Play():
    ch=fen.a.text()
    if  not (len(ch)!=0 and len(ch) % 2 ==0):
        fen.res.setText("Désolé ! vérifier la saisie de 1 chaine !!")
    elif Est_PP(ch):
        fen.res.setText("La chaine "+ch+" est presque palindrome")
    else:
        fen.res.setText(ch+" une chaine n'est pas presque palindrome")
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app=QApplication([])
fen=loadUi("InterPP.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 07 — Nombre pointu (version 1)

Un nombre est pointu si sa décomposition en facteurs premiers distincts s'écrit sous la forme p × q × ... avec p ≥ 2 × q (le plus grand facteur premier vaut au moins le double du suivant).

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def Valide(ch):
    #Récupération de deux plus grands facteurs différents telsque p>=2*q
    ch=ch[1:]                       #éliminer le premier "*"
    q=int(ch[:ch.find("*")])        #récupérer le premier facteur
    ch=ch[ch.find("*")+1:]          #ch devient sans le premier facteur
    p=int(ch[:ch.find("*")])        #récupérer le second facteur
    ch=ch[ch.find("*")+1:]          #ch devient sans le premier et le second facteur
    while ch.find("*") !=-1:        # tantqu'il ya encore "*"
        q=p                         #l'avant plus grand facteur (q) prend la valeur de dernier facteur (p)
        p=int(ch[:ch.find("*")])    # le dernier facteur (p) prend le nouveau facteur
        ch=ch[ch.find("*")+1:]      #la chaine sans ce dernier facteur
    return p >= 2*q
#******************************************
def Pointu(N):
    ch="*"
    i=2
    nb=0
    while  N !=1:
        if N % i ==0 :
            if ch.find("*"+str(i)+"*") ==-1:
                ch+=str(i)+"*"      #concaténer dans ch les facteurs distincts
                nb+=1
            N//=i
        else:
            i+=1
    return nb==1 or Valide(ch)
#******************************************
def Play():
    ch=fen.a.text()
    if  not ( ch.isdecimal()  and  ( int(ch) >1 )  ):
        fen.res.setText("Désolé ! vérifier la saisie du nombre !!")
    elif Pointu(int(ch)):
        fen.res.setText(ch +" est un nombre pointu")
    else:
        fen.res.setText("Le nombre "+ ch +" n'est pas pointu")
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app=QApplication([])
fen=loadUi("InterPointu.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 08 — Nombre pointu (version 2, parcours inverse)

Variante du sujet n°07 : on récupère les deux plus grands facteurs en parcourant la chaîne depuis la fin.

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def Valide(ch):
    #Récupération de deux plus grands facteurs différents à partir de la fin de ch
    ch=ch[:len(ch)-1]   #éliminer l'étoile de la fin
    nb=0                # désigne le nombre des étoiles à partir de la fin
    i=len(ch)-1         # initialisation du compteur au dernier caractère de ch
    ch1=""              # initialisation de ch1 qui va contenir les deux plus grands facteurs différents séparés
    while not (i==-1 or nb==2): # On arrête le parcours lorsqu'on atteint l'avant début de ch ou bien le deuxième "*"
        if ch[i]=="*":
            nb+=1                   #on incrémente le nb lorsqu'on trouve "*"
        ch1=ch[i]+ch1               #concaténer dans ch1 à l'envers du parcours pourqu'on puisse trouver les 2 plus grands facteurs distincts
        i-=1                        # décrémenter le compteur i
    ch1=ch1[1:]                     #éliminer le premier "*" de ch1 pourqu'elle contient p et q séparés par un seul "*"
    return (i==-1 and nb<2)  or int(ch1[:ch1.find("*")])*2 <= int(ch1[ch1.find("*")+1:])
#******************************************
def Pointu(N):
    ch="*"
    i=2
    while  N !=1:
        if N % i ==0 :
            if ch.find("*"+str(i)+"*") ==-1:
                ch+=str(i)+"*"      #concaténer dans ch les facteurs distincts
            N//=i
        else:
            i+=1
    return Valide(ch)
#******************************************
def Play():
    ch=fen.a.text()
    if  not ( ch.isdecimal()  and  ( int(ch) >1 )  ):
        fen.res.setText("Désolé ! vérifier la saisie du nombre !!")
    elif Pointu(int(ch)):
        fen.res.setText(ch +" est un nombre pointu")
    else:
        fen.res.setText("Le nombre "+ ch +" n'est pas pointu")
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app=QApplication([])
fen=loadUi("InterPointu.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 08 (bis) — Nombre spécial

Un nombre N à 4 chiffres (sans le chiffre 0) est dit spécial s'il existe un entier i tel que i × i = S, où S est calculé à partir des chiffres de N par : S = (millier × dizaine) + (centaine × unité).

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def Special(N):
    s= (N //1000) * (N//10%10) + (N //100%10) * (N%10)
    i=1
    while  i*i< s:
        i+=1
    return i*i==s
#******************************************
def Play():
    N=fen.a.text()
    if  not ( N.isdecimal()  and  ( 1111 <= int(N) <= 9999) and N.find("0") ==-1  ):
        fen.res.setText("Désolé ! vérifier la saisie du nombre !!")
    elif Special(int(N)):
        fen.res.setText(N +" est un nombre spécial")
    else:
        fen.res.setText("Le nombre "+ N +" n'est pas spécial")
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app=QApplication([])
fen=loadUi("InterSPEC.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 09 — Nombre totalement impair

Un nombre est totalement impair si tous ses chiffres de rang impair sont impairs (en partant du chiffre des unités avec le rang 1, puis dizaines = rang 2, etc.).

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def Tot_impair(N):
    p=1
    i=len(N)-1
    verife=True
    while  i>-1 and  verife:
        if int(N[i]) % 2 == 1 and p % 2 ==0:
            verife=False
        p+=1
        i-=1
    return verife
#******************************************
def Play():
    N=fen.a.text()
    if  not ( N.isdecimal()  and  ( int(N) >0) ):
        fen.res.setText("Désolé ! vérifier la saisie du nombre !!")
    elif Tot_impair(N):
        fen.res.setText(N +" est un nombre totalement impair")
    else:
        fen.res.setText("Le nombre "+ N +" n'est pas totalement impair")
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app=QApplication([])
fen=loadUi("InterTOTIMP.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 10 — Nombre doublement palindrome

Un nombre N est doublement palindrome s'il est palindrome en base 10 ET si sa représentation binaire l'est aussi.

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def Palindrome(N):
    i = 0
    while i < len(N) // 2 and N[i] == N[len(N)-1-i] :
        i = i + 1
    return i==len(N)// 2

def Binaire(N):
    ch=""
    N=int(N)
    while N !=0:
        ch=str(N %2)+ch
        N=N // 2
    return ch
#******************************************
def play():
    N=fen.a.text()
    if not N.isdecimal()  or int(N)==0 or not Palindrome(N):
        fen.c.setText("Désolé! Introduire un nombre valide !!!")
    elif Palindrome(Binaire(N)):
        fen.c.setText("Le nombre "+N+" est doublement palindrome")
    else:
        fen.c.setText(N+"  n'est pas un nombre doublement palindrome")
#******************************************
def efface():
    fen.a.clear()
    fen.c.setText("")
#******************************************
app=QApplication([])
fen=loadUi("InterDP.ui")
fen.show()
fen.b.clicked.connect(play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 11 — Nombre de Smith

Un nombre N est un nombre de Smith si la somme de ses chiffres est égale à la somme des chiffres de tous ses facteurs premiers (comptés avec multiplicité).

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************
def SommeChiffres(n):
    ch=str(n)
    som=0
    for i in range(len(ch)):
        som+=int(ch[i])
    return som
#******************************************
def Smith(N):
    m=SommeChiffres(N)
    i=2
    s=0
    while  N !=1:
        if N % i ==0:
            s+=SommeChiffres(i)
            N//=i
        else:
            i+=1
    return s==m
#******************************************
def Play():
    ch=fen.a.text()
    if  not ( ch.isdecimal()  and  ( int(ch) >1 )  ):
        fen.res.setText("Désolé ! vérifier la saisie du nombre !!")
    elif Smith(int(ch)):
        fen.res.setText(ch +" est un nombre de Smith")
    else:
        fen.res.setText("Le nombre "+ ch +" n'est pas Smith")
#******************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#******************************************
app=QApplication([])
fen=loadUi("InterSmith.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 12 — Nombres sectionnables unitaires dans un tableau

Un nombre x est dit sectionnable unitaire s'il existe un entier i tel que 1 + 2 + ... + i ≥ x et que S == x exactement (la somme cumulée des entiers consécutifs depuis 1 atteint x pile).

from numpy import array
#******************************************************************
def saisie():
    global m
    m=0
    while not  (4 <= m <= 20):
        m=int(input("m="))
#******************************************************************
def remplir(t,m):
    for i in range(m):
        while not (t[i]>=3):
            t[i]=int(input("t["+str(i)+"]="))
#******************************************************************
def afficher(t,m):
    ch=","
    for i in range(m):
        if sectionnable(t[i]) and (ch.find(","+str(t[i])+",") ==-1):
            ch+=str(t[i])+","
    if ch != ",":
        print("Les nombres sectionnable unitaires sont:",ch[1:len(ch)-1])
    else:
        print("Aucun nombre sectionnable unitaire dans le tableau")
#******************************************************************
def sectionnable(x):
    s=1
    i=1
    while  not ( s >= x ):
        i+=1
        s+=i
    return  s==x
#******************************************************************

#----------------------PP---------------------
#********************************************
saisie()
t=array([int()]*m)
remplir(t,m)
afficher(t,m)

Sujet n° 13 — Nombres étranches dans un tableau

Un nombre x (à au moins 2 chiffres) est dit étranche si chaque préfixe x[:i+1] est divisible par sa propre longueur i+1.

from numpy import array
#******************************************************************
def saisie():
    global m
    m=0
    while not  (4 <= m <= 20):
        m=int(input("m="))
#******************************************************************
def remplir(t,m):
    for i in range(m):
        while not (t[i]>=10):
            t[i]=int(input("t["+str(i)+"]="))
#******************************************************************
def afficher(t,m):
    ch=""
    for i in range(m):
        if etranche(t[i]):
            ch+=str(t[i])+","
    if ch != "":
        print("Les nombres ETRANCHES sont:",ch[:len(ch)-1])
    else:
        print("Aucun nombre ETRANCHE dans le tableau")
#******************************************************************
def etranche(x):
    ch=str(x)
    i=1
    while not ( ( i==len(ch) ) or ( int(ch[:i+1]) % len(ch[:i+1]) !=0  )  ):
        i+=1
    return  i == len(ch)
#******************************************************************

#----------------------PP---------------------
#********************************************
saisie()
t=array([int()]*m)
remplir(t,m)
afficher(t,m)

Sujet n° 15 — Classement d'équipes par temps d'épreuves

Programme complet de gestion : saisie de N noms d'équipes (uniques, alphabétiques avec espaces non extrêmes) et de leurs temps en secondes, puis tri croissant des temps et affichage du classement avec rangs ex-aequo et conversion en H:Min:Sec.

from numpy import array
#******************************************************************
def saisie():
    global N
    N=0
    while not (3 <= N <= 20):
        N=int(input("N="))
#******************************************************************
def remplir(TN,TT,N):
    for i in range(N):

        TN[i]=input("TN["+str(i)+"]=")
        while TN[i] =="" or not Alphabetique_Espace(TN[i]) or not Distinct(TN[i],TN,i)  :
            TN[i]=input("TN["+str(i)+"]=")

        TT[i]=int(input("TT["+str(i)+"]="))
        while TT[i] <= 0 :
            TT[i]=int(input("TT["+str(i)+"]="))
#******************************************************************
def Alphabetique_Espace(ch):
    #on vérifie que l'espace n'existe ni au debut ni à la fin de ch ainsi que l'inexistence de double espace aussi
    verife= ("A"<= ch[0].upper() <= "Z") and  ("A"<= ch[len(ch)-1].upper() <= "Z") and (ch.find("  ")==-1)
    i=1
    while i<len(ch)-1 and verife:
        if ("A"<= ch[i].upper() <= "Z") or ch[i]==" ":
            i+=1
        else:
            verife=False
    return verife
#******************************************************************
def Distinct(ch, TN,p):
    i=0
    while TN[i] != ch:
        i+=1
    return i==p
#******************************************************************
def afficher(TN,TT,N):
    Trier(TN,TT,N)
    print(TN)
    print(TT)
    print("Le classement est:")
    print("Rang n°1:")
    print("\t L'équipe",TN[0]," a pris ", Temps(TT[0])," pour réaliser toutes les épreuves")

    for i in range(1,N):
        if TT[i] !=TT[i-1]:
            print("Rang n°",i+1,":")
        print("\t L'équipe",TN[i]," a pris ", Temps(TT[i])," pour réaliser toutes les épreuves")
#******************************************************************
def Trier(TN,TT,N):
    for i in range(N-1):
        IndMin=i
        for j in range(i+1,N):
            if TT[j] < TT[IndMin]:
                IndMin=j
        if IndMin != i:
            TN[i],TN[IndMin]=TN[IndMin],TN[i]
            TT[i],TT[IndMin]=TT[IndMin],TT[i]
#******************************************************************
def Temps(M):
     return str(M // 3600) + " H :" + str(M % 3600  // 60) + " Min :" + str(M % 60) + " Sec"
#******************************************************************

#----------------------PP---------------------
#********************************************
saisie()
TN=array([str]*N)
TT=array([int()]*N)
remplir(TN, TT, N)
afficher(TN, TT, N)

Sujet n° 16 — Nombres CRO-DEC et DEC-CRO

Un nombre est dit CRO-DEC (croissant-décroissant) si ses chiffres croissent jusqu'au milieu puis décroissent. Inversement, un nombre DEC-CRO voit ses chiffres décroître jusqu'au milieu puis croître.

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************************************************
def CRODEC(n):
    i=len(n)//2 -1
    while i>= 0 and n[i] < n[i+1] and  n[len(n)-i-1] < n[len(n)-i-2]:
        i-=1
    return i==-1
#-----------------------------------------------------------------------------
def DECRO(n):
    i=len(n)//2 -1
    while i>= 0  and n[i] > n[i+1] and  n[len(n)-i-1] > n[len(n)-i-2]:
        i-=1
    return i==-1
#-----------------------------------------------------------------------------
def play():
    n=window.a.text()
    if not n.isdecimal()  or len(n) % 2 ==0 or int(n) <100 :
        window.c.setText("Veuiller introduire un nombre >= 100 dont le nombre de ses chiffres est impair")
    elif CRODEC(n):
        window.c.setText(n+" est un nombre CRO-DEC")
    elif DECRO(n):
        window.c.setText(n+" est un nombre DEC-CRO")
    else:
        window.c.setText(n+" ni  CRO-DEC   ni  DEC-CRO")
#******************************************************************************
app=QApplication([])
window=loadUi("InterCRODEC.ui")
window.show()
window.b.clicked.connect(play)
app.exec_()

Sujet n° 17 — Mot emprisonné

Un mot A est dit emprisonné dans un mot B si toutes les lettres de A apparaissent dans B, dans l'ordre, en parcourant B de gauche à droite (les lettres de A peuvent être espacées par d'autres lettres dans B).

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#*****************************************
def Emprisonnier(A,B):
    i=0
    while i< len(A) and B.find(A[i])!=-1:
        B=B[B.find(A[i])+1:]
        i+=1
    return i==len(A)
#*****************************************
def AlphaMajus(ch):
    i=0
    while i < len(ch) and "A" <= ch[i] <= "Z":
        i+=1
    return i==len(ch)
#*****************************************
def Play():
    MotA=fen.cha.text()
    MotB=fen.chb.text()
    if  (MotA=="") or ( not AlphaMajus(MotA) ) or ( len(MotB) < len(MotA) ) or ( not AlphaMajus(MotB) ):
        fen.res.setText("Désolé ! vérifier la saisie des mots !!")
    elif Emprisonnier(MotA, MotB):
        fen.res.setText(MotA +" est prisonnié dans le mot "+MotB)
    else:
        fen.res.setText("Le mot "+MotA+" n'est pas prisonnié dans le mot "+MotB)
#*****************************************
def efface():
    fen.cha.clear()
    fen.chb.clear()
    fen.res.clear()
#*****************************************
app=QApplication([])
fen=loadUi("InterEMPRIS.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujets n° 18 — Nombres homogènes

Deux entiers naturels A et B (supérieurs à 1) sont dits homogènes s'ils possèdent les mêmes facteurs premiers distincts.

Par exemple : 12 = 2² × 3 et 18 = 2 × 3² sont homogènes car ils ont tous deux comme facteurs premiers distincts {2, 3}.

Première solution (avec décomposition puis extraction des facteurs distincts)

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#*****************************************
def Distinct(ch):
    x=""
    while ch.find("*") !=-1:
        if x.find(ch[:ch.find("*")]) ==-1:
            x+=ch[:ch.find("*")]+"*"
        ch=ch[ch.find("*")+1:]
    return x
#*****************************************
def FacteursPremiers(N):
    ch=""
    i=2
    while N != 1:
        if N % i == 0:
            ch+=str(i)+"*"
            N=N//i
        else:
            i+=1
    return ch
#*****************************************
def Homogene(A,B):
    return Distinct(FacteursPremiers(A)) == Distinct(FacteursPremiers(B))
#*****************************************
def Play():
    cha=fen.a.text()
    chb=fen.b.text()
    if  not ( cha.isdecimal()  and  chb.isdecimal() and ( int(cha) > 1 ) and ( int(chb) > 1 ) and ( int(cha) != int(chb) )  ):
        fen.res.setText("Désolé ! vérifier la saisie des nombres !!")
    elif Homogene(int(cha), int(chb)):
        fen.res.setText(cha +" et "+chb+" sont homogènes")
    else:
        fen.res.setText("Les deux nombres "+ cha +" et "+chb+" ne sont pas homogènes")
#*****************************************
def efface():
    fen.a.clear()
    fen.b.clear()
    fen.res.clear()
#*****************************************
app=QApplication([])
fen=loadUi("InterHOMO.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Deuxième solution (extraction directe des facteurs distincts)

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#*****************************************
def FacteursDistincts(N):
    chD="*"     # chaine qui va contenir les facteurs distincts
    i=2
    while N != 1:
        if N % i == 0:  # si i est un facteur premier
            N=N//i
            if chD.find("*"+str(i)+"*") ==-1:   # si i n'existe pas dans la chaine qui contient les facteurs distincts
                chD+=str(i)+"*"                  # on lui ajoute à chD
        else:
            i+=1
    return chD
#*****************************************
def Homogene(A,B):
    return FacteursDistincts(A)==FacteursDistincts(B)
#*****************************************
def Play():
    cha=fen.a.text()
    chb=fen.b.text()
    if  not ( cha.isdecimal()  and  chb.isdecimal() and ( int(cha) > 1 ) and ( int(chb) > 1 ) and ( int(cha) != int(chb) )  ):
        fen.res.setText("Désolé ! vérifier la saisie des nombres !!")
    elif Homogene(int(cha), int(chb)):
        fen.res.setText(cha +" et "+chb+" sont homogènes")
    else:
        fen.res.setText("Les deux nombres "+ cha +" et "+chb+" ne sont pas homogènes")
#*****************************************
def efface():
    fen.a.clear()
    fen.b.clear()
    fen.res.clear()
#*****************************************
app=QApplication([])
fen=loadUi("InterHOMO.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 19 — Plus petit multiple binaire (PPMB)

Le PPMB d'un entier n est le plus petit multiple de n dont l'écriture décimale ne contient que des 0 et des 1.

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#*****************************************
def est_binaire(n):
    ch=str(n)
    k=0
    while k < len(ch) and ch[k] in {"0","1"}:
        k+=1
    return k==len(ch)
#*****************************************
def ppmb(n):
    j=1
    while not est_binaire(j*n):
        j+=1
    return j*n
#*****************************************
def Play():
    ch=fen.a.text()
    if  not ( ch.isdecimal()  and  ( 1 <= int(ch) <= 88) and  (int(ch)% 9 !=0) and ch.find("9") ==-1):
        fen.res.setText("Désolé ! vérifier la saisie du nombre !!")
    else:
        fen.res.setText(ch +" * "+str(ppmb(int(ch))// int(ch))+" = "+str(ppmb(int(ch))))
#*****************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#*****************************************
app=QApplication([])
fen=loadUi("InterPPMB.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 20 — Nombres multipotents

Un entier N est dit multipotent si le produit de tous ses diviseurs (au sens large, de 2 à N) peut s'écrire comme une puissance entière de N.

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#*****************************************
def ProduitDiv(N):
    prod=1
    for i in range(2,N+1):
        if N % i ==0:
            prod*=i
    return prod
#*****************************************
def Puissance(a,b):
    p=1
    for i in range(b):
        p*=a
    return p
#*****************************************
def Multipotent(N):
    p=ProduitDiv(N)
    i=1
    while  Puissance(N,i) < p:
        i+=1
    return Puissance(N,i)==p
#*****************************************
def Play():
    ch=fen.a.text()
    if  not ( ch.isdecimal()  and  ( int(ch) >=1 ) ):
        fen.res.setText("Désolé ! vérifier la saisie du nombre !!")
    elif Multipotent(int(ch)):
        fen.res.setText(ch +" est un nombre multipotent")
    else:
        fen.res.setText("Le nombre "+ ch +" n'est pas multipotent")
#*****************************************
def efface():
    fen.a.clear()
    fen.res.clear()
#*****************************************
app=QApplication([])
fen=loadUi("InterMULT.ui")
fen.show()
fen.b1.clicked.connect(Play)
fen.b2.clicked.connect(efface)
app.exec_()

Sujet n° 21 — Nombres lisses

Un entier N est dit lisse (ou smooth) si tous ses facteurs premiers sont inférieurs ou égaux à √N.

Première solution

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************************************************
from math import sqrt
def Lisse(N):
    i=N//2
    verife=False
    while not (verife or  i < 1):
        if N % i ==0 and premier(i):
            verife=True
        else:
            i-=1
    return verife and i <=int(sqrt(N))
#****************************************************
def premier (m):
    nb=0
    for i in range(1, m+1):
        if m % i==0:
            nb+=1
    return nb==2

#******************************************************************************
def play():
    N=fen.a.text()
    if not N.isdecimal() or  int(N) <= 1 :
        fen.c.setText("Veuillez introduire un nombre > 1")
    elif Lisse(int(N)):
        fen.c.setText(N+"  est un nombre lisse")
    else:
        fen.c.setText(N+"  n'est pas un nombre lisse")

#******************************************************************************
app=QApplication([])
fen=loadUi("InterfaceLisse.ui")
fen.show()
fen.b.clicked.connect(play)
app.exec_()

Deuxième solution (optimisée)

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************************************************
from math import sqrt
def Lisse(N):
    i=N//2
    while not (i==1 or  (N % i ==0 and premier(i))):
        i-=1
    return 1 < i <=int(sqrt(N))
#****************************************************
def premier (m):
    if m<=1: return False
    d=2
    while d*d <=m:
        if m % d ==0:
            return False
        else:
            d+=1
    return True
#******************************************************************************
def play():
    N=fen.a.text()
    if not N.isdecimal() or  int(N) <= 1 :
        fen.c.setText("Veuillez introduire un nombre > 1")
    elif Lisse(int(N)):
        fen.c.setText(N+"  est un nombre lisse")
    else:
        fen.c.setText(N+"  n'est pas un nombre lisse")

#******************************************************************************
app=QApplication([])
fen=loadUi("InterfaceLisse.ui")
fen.show()
fen.b.clicked.connect(play)
app.exec_()

Sujet n° 22 — Nombres semi-premiers

Un entier N est dit semi-premier s'il peut s'écrire comme produit de deux nombres premiers (éventuellement égaux). Par exemple : 15 = 3 × 5, 49 = 7 × 7.

Première solution

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************************************************
def SemiPremier(N):
    i=2
    verife=False
    while not (verife or  i*i > N):
        if N % i ==0 and premier(i) and premier(N // i):
            verife=True
        else:
            i+=1
    return verife
#************************************************************
def premier (m):
    nb=0
    for i in range(1, m+1):
        if m % i==0:
            nb+=1
    return nb==2

#******************************************************************************
def play():
    N=fen.nombre.text()
    if not N.isdecimal() or  int(N) <= 2 :
        fen.lab_res.setText("Veuillez introduire un nombre > 2")
    elif SemiPremier(int(N)):
        fen.lab_res.setText(N+"  est semi premier")
    else:
        fen.lab_res.setText(N+"  n'est pas semi premier")

#******************************************************************************
app=QApplication([])
fen=loadUi("InterfaceSemiPremier.ui")
fen.show()
fen.Btverife.clicked.connect(play)
app.exec_()

Deuxième solution (par décomposition)

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************************************************
def SemiPremier(N):
    i=2
    nb=0
    while N !=1 and nb <=2:
        if N % i ==0 :
            nb+=1
            N//=i
        else:
            i+=1
    return nb==2

#******************************************************************************
def play():
    N=fen.nombre.text()
    if not N.isdecimal() or  int(N) <= 2 :
        fen.lab_res.setText("Veuillez introduire un nombre > 2")
    elif SemiPremier(int(N)):
        fen.lab_res.setText(N+"  est semi premier")
    else:
        fen.lab_res.setText(N+"  n'est pas semi premier")

#******************************************************************************
app=QApplication([])
fen=loadUi("InterfaceSemiPremier.ui")
fen.show()
fen.Btverife.clicked.connect(play)
app.exec_()

Sujet n° 23 — Nombres hautement abondants

Un entier N est hautement abondant si la somme de ses diviseurs est strictement supérieure à la somme des diviseurs de tout entier plus petit que lui.

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#******************************************************************************
def HautementAbondant(N):
    verife=True
    s=SOMDIV(N)
    for i in range(1,N):
        if s<= SOMDIV(i):
            verife=False
    return verife
#******************************************************************************
def SOMDIV (m):
    s=m
    for i in range(1, (m //2)+1):
        if m % i==0:
            s+=i
    return s
#******************************************************************************
def NbresHA(p,q):
    msg=""
    for i in range(int(p), int(q)+1):
        if HautementAbondant(i):
            msg+=str(i)+","
    return msg[:len(msg)-1]
#******************************************************************************
def play():
    p=fen.p.text()
    q=fen.q.text()
    if not ( p.isdecimal() and int(p)>3 and q.isdecimal() and int(p) < int(q) < 50) :
        fen.c.setText("Veuillez introduire les deux bornes satisfaisantes les conditions !!")
    else :
        fen.c.setText(NbresHA(int(p),int(q)))

#******************************************************************************
app=QApplication([])
fen=loadUi("InterHA.ui")
fen.show()
fen.b.clicked.connect(play)
app.exec_()

Sujet n° 24 — Jeu du numéro de téléphone chanceux

Le joueur saisit un numéro de téléphone à 8 chiffres dont le premier chiffre appartient à {"2","4","5","9"}. On calcule la somme pondérée S = Σ Ch[i] × i (pour i allant de 0 à 7). Si S est un nombre premier, le joueur gagne.

Fonction Chance (version isolée)

def Chance (Ch) :
    if  not (Ch.isdecimal() and len ( Ch ) == 8 and Ch[0] in ["2","4","5","9"] ) :
        msg = "Vérifier le numéro de téléphone !"
    else :
        msg = "Désolé, vous n'avez pas gagné."
        s = 0
        for  i in range (len ( Ch )) :
            s = s + int ( Ch [i] ) * i
        if Premier (s) :
           msg = "Félicitation, vous avez gagné."
    return msg
#-------------------------------------------------

Programme principal complet

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication,QMessageBox,QTableWidget,QTableWidgetItem
#----------------------------------------------------------------
def Premier (m):
    nb=0
    for i in range(1, m+1):
        if m % i==0:
            nb+=1
    return nb==2
#----------------------------------------------------------------
def Chance (Ch) :
    if  not (Ch.isdecimal() and len ( Ch ) == 8 and Ch[0] in ["2","4","5","9"] ) :
        msg = "Vérifier le numéro de téléphone !"
    else :
        msg = "Désolé, vous n'avez pas gagné."
        s = 0
        for  i in range (len ( Ch )) :
            s = s + int ( Ch [i] ) * i
        if Premier (s) :
           msg = "Félicitation, vous avez gagné."
    return msg
#----------------------------------------------------------------
def  Play() :
    form.res.setText(Chance(form.a.text()))
#----------------------------------------------------------------
app = QApplication([])
form = loadUi ("Interface_Jeu.ui")
form.show()
form.b.clicked.connect (Play)
app.exec_()

Solution complète du sujet n°25 (suite)

Fonction Fidelite

Cette fonction reçoit en paramètre la chaîne saisie (numéro d'abonnement) et retourne un message selon la validité et l'ancienneté de l'adhérent.

def Fidelite(ch):
    if not Valide(ch):
        msg= "Verifier le numéro d'abonnement"
    elif Anciennete (ch) < 60:
        msg ="L'ancienneté de l'adhérent est inferieur à 5 ans"
    else:
        msg = "L'adhérent à un bonus de " + str(Anciennete (ch)) +" heures"

    return msg
#--------------------------------------------------

Programme principal complet (PyQt5)

Voici le code complet intégrant l'interface graphique Interface_adhesion.ui et toutes les fonctions nécessaires :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication,QMessageBox,QTableWidget,QTableWidgetItem
#--------------------------------------------------------------
def Fidelite(ch):
    if not Valide(ch):
        msg= "Verifier le numéro d'abonnement"
    elif Anciennete (ch) < 60:
        msg ="L'ancienneté de l'adhérent est inferieur à 5 ans"
    else:
        msg = "L'adhérent à un bonus de " + str(Anciennete (ch)) +" heures"

    return msg
#--------------------------------------------------------------
# Vérifier si un numéro d'abonnement est valide
def Valide(ch):
    if ch.isdecimal() and len(ch)==10 and  2000 <= int(ch[:4]) <= 2023 and  1<= int(ch[4:6]) <= 12:
        return True
    else:
        return False
#--------------------------------------------------
# Calcul  de nombre de mois d'ancienneté
def Anciennete(ch):
    a=int(ch[:4])
    m=int(ch[4:6])
    mm=5
    aa=2023
    an = aa-a;
    if (mm < m) and (an!=0):
        an = an-1
    if m <= mm :
        nb = an*12+(mm-m)
    else :
        nb = an*12+(12-(m-mm))
    return nb
#--------------------------------------------------------------
def Bonus():
    form.res.setText(Fidelite(form.a.text()))
#--------------------------------------------------------------
app = QApplication([])
form = loadUi ("Interface_adhesion.ui")
form.show()
form.b.clicked.connect (Bonus)
app.exec_()

Analyse détaillée du code

Fonction Valide(ch)

Elle vérifie quatre conditions pour qu'un numéro d'abonnement soit considéré comme valide :

Fonction Anciennete(ch)

Elle calcule le nombre de mois d'ancienneté entre la date d'adhésion (extraite du numéro) et la date de référence (mai 2023, soit mm=5 et aa=2023).

• a : année d'adhésion (4 premiers caractères du numéro)
• m : mois d'adhésion (caractères en positions 4 et 5)
• an : différence brute en années
• Ajustement de an si le mois d'adhésion est postérieur au mois courant
• Calcul final de nb (nombre total de mois) selon la position relative des mois

Procédure événementielle Bonus()

Elle est déclenchée lors du clic sur le bouton b de l'interface :

1. Récupère le texte saisi dans la zone a via form.a.text()
2. Appelle Fidelite(...) sur cette chaîne
3. Affiche le résultat dans la zone res via setText(...)

Conclusion du document

Ce recueil de sujets a couvert l'ensemble des compétences attendues en 4ème année Sciences de l'Informatique pour la partie développement d'applications avec interface graphique en Python (PyQt5) :

• Conception et chargement d'interfaces .ui avec loadUi
• Manipulation des widgets : QLineEdit, QPushButton, QLabel, QTableWidget, QMessageBox
• Programmation événementielle avec clicked.connect
• Validation de saisies utilisateur (chaînes, entiers, formats spécifiques)
• Manipulation de chaînes de caractères et de tableaux
• Structuration du code en fonctions et procédures réutilisables