Nombres de Keith – Examen théorique informatique [Bac scientifique 2025]
Sujet bac informatique théorique (Bac scientifique 2025)
Un nombre entier nb de k chiffrres est dit nombre de Keith s'il peut apparaltre dans une suite de nombres générés à partir de ses propres chiffres.Voiei les &tapes pour determiner si un nombre nb a k chiffres est un nombre de Keith ou non :
1- Déterminer les k premiers tonics de la suite : les k premiers termes de la suite sont les k chiffres du nombre nb en conainencant de gauche a droite.
2- Calculer le terme suivant de la suite : le terme suivant est la somme des k derniers ferules.
3- Répéter l'étape n°2 jusqu' a ce que le dernier terme calculé soit supérieur ou égal à nb
4- Verifier l'apparition du nombre nb : Si le nombre nb est un terme de la suite, alors it est un nombre de Keith sinon it n'est pas un nombre de Keith.
Exemnles
Pour nb = 14, on a done k =2 puisque 14 est un nombre forme de 2 ehiffres
1- Les 2 premiers termes de la suite sont sueeessivement : 1 et 4 (les k ehiffres de nb).
2- Le calcul du terme suivant de la suite : 5 = (1+4).
3- Le calcul des termes suivants : 9 — (4+5), puis 14 = (5+9). Arrest du calcul puisque le terme 14 est superieur ou egal a nb.
4- Verifier si 14 apparait dans la suite : puisque le terme 14 est egal a nb, done 14 est un nombre de Keith.
Pour nb = 189, on a done k --3 puisque 189 est un notnbre forme de 3 chiffres
1- Les 3 premiers termes de la suite sent successivement 1, 8 et 9 (les k chiffres de nb).
2- Le calcul du terme suivant de la suite : 18 = (1+8+9).
3- Le calcul des terries suivants : 35 = (8+9+18), puis 62 = (9+18+35). puis 115 = (18+35+62), puis 212 = (35+62+115). Arra du calcul puisque le terme 212 est supérieur ou égal à nb.
4- Verifier si 189 apparait dans la suite : puisque le terme 212 est strietement superieur a nb, done 189 n'appaxait pas dans la suite et par consequent 189 West pas un nombre de Keith.
Pour nb = 153 7, on a done k = 4 puisque 1537 est un nombre forme de 4 chiffres
1- Les 4 premiers termes de la suite sont successivement : 1, 5, 3 et 7 (les k chiffres de nb).
2- Le calcul du terme suivant de la suite : 16 = (1+5+3+7).
3- Le calcul des termes suivants : 31 = (5+3+7+16), puis 57 = (3+7+16+31), puis 111 = (7+16+31+57), puis 215 = (16+31+57+111), puis 414 = (31+57+111+215), puis 797 = (57+111+215+414), puis 1537 = (111+215+414+797). Arrêt du calcul puisque le terme 1537 est supérieur ou égal a
4- Vérifier si 1537 apparaît dans la suite puisque le terme 1537 est egal a nb, done le terme 1537 est un nombre de Keith.
On se propose d'écrire un algorithme d'un programme qui permet de :
- remplir un tableau T1 par N1 entiers sachant que chaque element du tableau doit etre un
entier compose de 2 chiffres au minimum et de 5 chiffres au maximum.
- générer un deuxieme tableau T2 contenant les elements de T1 qui sant des nombres de Keith.
- afficher les elements de T2 regroupes selon leurs nombres de chiffres conformement a l'exemple suivant
Exemple :
Pour N1 = 12 et le tableau T1 suivant :
Le tableau T2 généré sera donc :
Le programme affiche les lignes suivantes
14, 61, 47 nombre(s) de Keith de 2 chiffres.
Aucun nombre de Keith de 3 chiffres.
1537, 4788 : nombre(s) de Keith de 4 chiffres.
31331, 55604, 34285 : nombre(s) de Keith de 5 chiffres.
Travail demande
1- Ecrire un algorithme du programme principal, solution a ce problème, en le décomposant en
2- Ecrire un algorithme pour chaque module envisage.
N.B. : Le candidat est appelé a dresser les tableaux de déclaration des objets et des nouveaux types nécessaires.
Solution Algorithmique
Dans cet algorithme, On va utiliser deux fonctions et quatre procédures:
- la fonction saisie_entier()
- la procédure remplir_tableau()
- la fonction test_keith()
- la procéduer generer()
- la procédure nbr_keith()
- la procédure afficher()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Algorithme nombres_keith Debut taille_t2 <- 0 Ecrire('*** Saisie taille du tableau T1 ***') n <- saisie_entier(5, 20) Ecrire('*** Remplir le tableau T1 ***') remplir_tableau(t1, n) # Génération des nombres de Keith generer(t1, t2, n) Ecrire('*** Le contenu du tableau T2 ***') afficher(t2, taille_t2) Ecrire('*** Le nombres de Keith selon les nombres de chiffres ***') Pour i de 2 à 5 faire nbr_keith(t2, taille_t2, i) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| taille_t2 | entier |
| n | entier |
| t1 | tableau des entiers |
| t2 | tableau des entiers |
La fonction saisie_taille
Cette fonction permet de saisir un entier, en s’assurant que la valeur entrée par l’utilisateur est comprise entre deux bornes (binf et bsup).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
fonction saisie_entier(binf:entier;bsup:entier):entier Début # Demande à l'utilisateur de saisir un entier entre binf et bsup Ecrire('donner n tq ' , binf , '<=n<=' , bsup , ': ') Lire(n) # Tant que la valeur saisie n'est pas valide, on redemande Tant que Non (binf <= n <= bsup) faire Ecrire('donner n tq ' , binf , '<=n<=' , bsup , ': ') Lire(n) Fin tant que # Retourne l'entier valide retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_tableau
Cette procédure permet de remplir un tableau t avec n entiers saisis par l’utilisateur, en garantissant que chaque valeur est comprise entre 10 et 99999.
|
1 2 3 4 5 6 7 |
Procedure remplir_tableau(t:tableau, n:entier) Début Pour i de 0 à n-1 faire # Chaque valeur doit être comprise entre 10 et 99999 t[i] <- saisie_entier(10, 99999) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction test_keith
Cette fonction permet de tester si un nombre nb est un nombre de Keith. Elle retourne Vrai si nb est un nombre de Keith, et Faux sinon.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
fonction test_keith(nb:entier, t:tableau):booleen Début # Conversion du nombre en chaîne de caractères ch <- Convch(nb) # Remplissage du tableau t avec les chiffres du nombre Pour i de 0 à long(ch)-1 faire t[i] <- Valeur(ch[i]) Fin pour n = len(ch) somme = 0 # Calcul des sommes successives jusqu'à dépasser ou atteindre nb Tant que somme < nb faire somme <- 0 # Calcul de la somme des n derniers termes Pour i de 0 à n-1 faire somme <- somme + t[i] Fin pour # Décalage du tableau vers la gauche Pour i de 0 à n-2 faire t[i] <- t[i+1] Fin pour # Ajout de la nouvelle somme à la fin t[n-1] <- somme Fin tant que # Retourne Vrai si nb est un nombre de Keith, sinon Faux retourner somme = nb Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
| n | entier |
| somme | entier |
| i | entier |
La procédure generer
Cette procédure permet de générer un tableau t2 contenant uniquement les nombres de Keith extraits du tableau t1.
|
1 2 3 4 5 6 7 8 9 10 11 |
procedure generer(t1:tableau, t2:tableau, n:entier) Début # Parcours du tableau t1 Pour i de 0 à n-1 # Si le nombre est un nombre de Keith Si test_keith(t1[i], t) alors t2[taille_t2] <- t1[i] taille_t2 <- taille_t2 + 1 Fin si Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| taille_t2 | entier (variable globale) |
La procédure nbr_keith
Cette procédure permet d’afficher les nombres de Keith d’un tableau donné ayant un nombre précis de chiffres, ainsi que leur nombre total.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
Procedure nbr_keith(t:tableau, n:entier, nbr_chiffres:entier) Début cp <- 0 liste <- '' Pour i de 0 à n-1 faire # Vérifie le nombre de chiffres Si len(str(t[i])) = nbr_chiffres alors cp <- cp + 1 liste <- liste + Convch(t[i]) + ',' Fin si Fin pour # Affichage du résultat Si cp = 0 alors Ecrire('Aucun nombre de Keith de', nbr_chiffres, 'chiffres.') Sinon Ecrire(Sous_chaine(liste , 0 , long(liste)-1), ': nombre(s) de Keith de', nbr_chiffres, 'chiffres.') Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| cp | entier |
| liste | chaîne |
| i | entier |
La procédure afficher
Cette procédure permet d’afficher les n premiers éléments d’un tableau t sur une seule ligne, séparés par des espaces.
|
1 2 3 4 5 6 |
procedure afficher(t:tableau,n:entier Début Pour i de 0 à n-1 faire Ecrire(t[i]) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
Solution en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 |
from numpy import * # -------------------------------------------------- # Déclaration des tableaux # t : tableau de travail utilisé dans le test de Keith # t1 : tableau contenant les nombres saisis par l'utilisateur # t2 : tableau contenant uniquement les nombres de Keith # -------------------------------------------------- t = array([int()] * 50) t1 = array([int()] * 50) t2 = array([int()] * 50) # -------------------------------------------------- # Fonction de saisie sécurisée d’un entier # binf : borne inférieure # bsup : borne supérieure # -------------------------------------------------- def saisie_entier(binf, bsup): # Demande à l'utilisateur de saisir un entier entre binf et bsup n = int(input('donner n tq ' + str(binf) + '<=n<=' + str(bsup) + ': ')) # Tant que la valeur saisie n'est pas valide, on redemande while not (binf <= n <= bsup): n = int(input('donner n tq ' + str(binf) + '<=n<=' + str(bsup) + ': ')) # Retourne l'entier valide return n # -------------------------------------------------- # Remplissage d’un tableau t avec n entiers # -------------------------------------------------- def remplir_tableau(t, n): for i in range(n): # Chaque valeur doit être comprise entre 10 et 99999 t[i] = saisie_entier(10, 99999) # -------------------------------------------------- # Fonction qui teste si un nombre est un nombre de Keith # nb : nombre à tester # t : tableau auxiliaire # -------------------------------------------------- def test_keith(nb, t): # Conversion du nombre en chaîne de caractères ch = str(nb) # Remplissage du tableau t avec les chiffres du nombre for i in range(len(ch)): t[i] = int(ch[i]) n = len(ch) somme = 0 # Calcul des sommes successives jusqu'à dépasser ou atteindre nb while somme < nb: somme = 0 # Calcul de la somme des n derniers termes for i in range(n): somme = somme + t[i] # Décalage du tableau vers la gauche for i in range(n - 1): t[i] = t[i + 1] # Ajout de la nouvelle somme à la fin t[n - 1] = somme # Retourne True si nb est un nombre de Keith, sinon False return somme == nb # -------------------------------------------------- # Génération du tableau t2 contenant les nombres de Keith # -------------------------------------------------- def generer(t1, t2, n): global taille_t2 # Parcours du tableau t1 for i in range(n): # Si le nombre est un nombre de Keith if test_keith(t1[i], t): t2[taille_t2] = t1[i] taille_t2 = taille_t2 + 1 # -------------------------------------------------- # Affiche les nombres de Keith selon le nombre de chiffres # -------------------------------------------------- def nbr_keith(t, n, nbr_chiffres): cp = 0 liste = '' for i in range(n): # Vérifie le nombre de chiffres if len(str(t[i])) == nbr_chiffres: cp = cp + 1 liste = liste + str(t[i]) + ',' # Affichage du résultat if cp == 0: print('Aucun nombre de Keith de', nbr_chiffres, 'chiffres.') else: print(liste[0:len(liste)-1], ': nombre(s) de Keith de', nbr_chiffres, 'chiffres.') # -------------------------------------------------- # Affichage du contenu d’un tableau # -------------------------------------------------- def afficher(t, n): for i in range(n): print(t[i], end=" ") print() # -------------------------------------------------- # Programme principal # -------------------------------------------------- taille_t2 = 0 print('*** Saisie taille du tableau T1 ***') n = saisie_entier(5, 20) print('*** Remplir le tableau T1 ***') remplir_tableau(t1, n) # Génération des nombres de Keith generer(t1, t2, n) print('*** Le contenu du tableau T2 ***') afficher(t2, taille_t2) print('*** Le nombres de Keith selon les nombres de chiffres ***') for i in range(2, 6): nbr_keith(t2, taille_t2, i) |
Exécution du programme:
Solution en Python et Designer QT
1- Créer l'interface graphique avec Qt Designer
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets:
QLineEdit nommé 'ch' pour entrer les éléments du tableau T1
QLabel nommé 'msg' pour afficher des messages d'erreur.
QPushButton nommé 'remplirT1_bt' pour mettre les entiers saisis dans le tableau T1
QPushButton nommé 'remplirT2_bt' pour mettre les nombres de Keith dans le tableau T2
QLabel nommé 'tab1_label' pour contenir les entiers du tableau T1
QLabel nommé 'tab2_label' pour contenir les entiers du tableau T2
QPushButton nommé 'afficher_bt' pour rechercher et afficher les nombres de Keith selon leurs nombres de chiffres.
QLabel nommé 'resulat_label' pour contenir les nombres de Keith selon leurs nombres de chiffres.
Enregistrez le fichier avec l'extension .ui, par exemple tabtab-5.ui.
2- Créer le script Python pour l'application
Voici un exemple de script Python qui utilise l'interface graphique générée par Qt Designer.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 |
# ======================= # Importation des modules # ======================= # Chargement d’une interface graphique créée avec Qt Designer from PyQt5.uic import loadUi # Modules PyQt5 pour la gestion de l’interface graphique from PyQt5 import QtCore, QtGui from PyQt5.QtWidgets import * from PyQt5 import QtCore, QtGui, QtWidgets # Importation du type tableau depuis numpy from numpy import array # ======================= # Déclaration des tableaux # ======================= # Tableaux de taille maximale 50 t = array([int()] * 50) # tableau auxiliaire (utilisé pour le test Keith) t1 = array([int()] * 50) # tableau principal (saisi par l’utilisateur) t2 = array([int()] * 50) # tableau des nombres de Keith # Variables globales n = 0 # taille réelle du tableau t1 taille_t2 = 0 # taille réelle du tableau t2 # ======================= # Initialisation de l’application graphique # ======================= app = QApplication([]) windows = loadUi("tabtab-2.ui") # Chargement du fichier .ui # ================================================== # Fonction qui supprime les espaces inutiles d’une chaîne # ================================================== def supprimer_espaces(ch): # Supprimer les espaces au début de la chaîne while ch[0] == ' ': ch = ch[1:len(ch)] # Supprimer les espaces à la fin de la chaîne while ch[len(ch) - 1] == ' ': ch = ch[0:len(ch) - 1] # Remplacer les doubles espaces par un seul espace while ch.find(' ') > 0: ch = ch.replace(" ", " ") return ch # ================================================== # Procédure qui remplit le tableau t1 à partir d’une chaîne # ================================================== def createTab(): # Lecture de la chaîne saisie par l’utilisateur ch = windows.ch.text() # Effacer les messages précédents windows.msg.clear() windows.resultat_label.clear() global n # variable globale pour la taille du tableau # Vérifier si la chaîne est vide if ch == "": windows.msg.setText("Veuillez remplir le tableau") else: windows.msg.clear() ch = supprimer_espaces(ch) i = 0 j = 0 ch1 = '' # Parcours de la chaîne caractère par caractère while ((i < len(ch)) and (('0' <= ch[i] <= '9') or (ch[i] == '-') or ch[i] == ' ')): # Construction d’un nombre if ('0' <= ch[i] <= '9') or (ch[i] == '-'): ch1 = ch1 + ch[i] # Fin d’un nombre if (ch[i] == ' ') or (i == len(ch) - 1): t1[j] = int(ch1) ch1 = '' j = j + 1 i = i + 1 # Vérifier si la chaîne contient uniquement des entiers if i < len(ch): windows.msg.setText("La chaine doit contenir des entiers") else: # Vérifier la taille du tableau if 5 <= j <= 20: n = j tab = '' # Affichage du tableau t1 for k in range(j): tab = tab + 't1[' + str(k) + '] = ' + str(t1[k]) + '\n' windows.tab1_label.setText(tab) else: windows.msg.setText("La taille du tableau doit être entre 5 et 20") # ================================================== # Fonction qui teste si un nombre est un nombre de Keith # ================================================== def test_keith(nb, t): # Conversion du nombre en chaîne ch = str(nb) # Stockage des chiffres du nombre dans le tableau t for i in range(len(ch)): t[i] = int(ch[i]) n = len(ch) somme = 0 # Calcul des sommes successives while somme < nb: somme = 0 # Somme des n derniers termes for i in range(n): somme = somme + t[i] # Décalage des valeurs dans le tableau for i in range(n - 1): t[i] = t[i + 1] # Ajout de la nouvelle somme t[n - 1] = somme # Retourne True si nb est un nombre de Keith return somme == nb # ================================================== # Procédure qui génère le tableau t2 des nombres de Keith # ================================================== def generer(): global n global taille_t2 # Parcours du tableau t1 for i in range(n): if test_keith(t1[i], t): t2[taille_t2] = t1[i] taille_t2 = taille_t2 + 1 tab = '' for i in range(taille_t2): tab = tab + 't2[' + str(i) + '] = ' + str(t2[i]) + '\n' # Affichage du tableau t2 windows.tab2_label.setText(tab) # ================================================== # Fonction qui affiche les nombres de Keith selon le nombre de chiffres # ================================================== def nbr_keith(t, n, nbr_chiffres): cp = 0 liste = '' for i in range(n): if len(str(t[i])) == nbr_chiffres: cp = cp + 1 liste = liste + str(t[i]) + ',' if cp == 0: return 'Aucun nombre de Keith de ' + str(nbr_chiffres) + ' chiffres.\n' else: return liste[0:len(liste) - 1] + ' : nombre(s) de Keith de ' + str(nbr_chiffres) + ' chiffres.\n' # ================================================== # Procédure d’affichage final # ================================================== def afficher_nbr_keith(): global taille_t2 liste = '' # Affichage pour les nombres de 2 à 5 chiffres for i in range(2, 6): liste = liste + nbr_keith(t2, taille_t2, i) windows.resultat_label.setText(liste) # ======================= # Connexion des boutons # ======================= windows.remplirT1_bt.clicked.connect(createTab) windows.remplirT2_bt.clicked.connect(generer) windows.afficher_bt.clicked.connect(afficher_nbr_keith) # ======================= # Lancement de l’application # ======================= windows.show() app.exec_() |
Exécution du programme
1) Remplissage du tableau T1
2) Remplissage du tableau T2
3) Affichage des nombres de Keith selon leurs nombres de chiffres
Vous pouvez voir aussi :
1) des exercices sur les chaînes des caractères
2) des exercices sur les tableaux
3) des sujets Bac pratique
4) des sujets Bac théorique
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
