Suite Robinson – Bac pratique – Section informatique – 2012
Sujet (Algo et programmation - Bac 2012)
La suite de Robinson est définie par :
- Uo = 0
- Un se construit en concaténant le nombre d'apparitions de chacun des chiffres constituant le terme Un-1 du chiffre lui-même, selon l'ordre décroissant des chiffres, pour tout n > 0.
Exemple :
Pour n = 5, U5 = 1113122110
En effet :
U0=0
U1 = 10 car il y a une apparition (1) du chiffre 0 dans U0
U2 = 1110 car il y a une apparition (1) du chiffre 1 et une apparition (1) du chiffre 0 dans U1
U3 = 3110 car il y a trois apparitions (3) du chiffre 1 et une apparition (1) du chiffre 0 dans U2
U4 = 132110 car il y a une apparition (1) du chiffre 3, deux apparitions (2) du chiffre 1 et une apparition (1) du chiffre 0 dans U3
U5 = 1113122110 car il y a une apparition (1) du chiffre 3, une apparition (1) du chiffre 2, trois apparitions (3) du chiffre 1 et une apparition (1) du chiffre 0 dans U4.
Travail a faire :
Ecrire un programme Python et l'enregistrer sous le nom Robinson, permettant de remplir et d'afficher un fichier texte nomme "Robinson.txt" contenant les k premiers termes de la suite de Robinson (avec 2 < k < 15) sachant que chaque terme de la suite occupera une ligne dans le fichier "Robinson.txt".
Solution Algorithmique
Dans cet algorithme, On va utiliser deux fonctions et une procédure:
- la fonction saisie()
- la fonction concatiner_suite()
- la procédure remplir_fichier_robinson()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 |
Algorithme Robinson Debut # Saisie du nombre de termes k (2 < k < 15) k <- saisie(2, 15) # Génération et remplissage du fichier avec les k premiers termes remplir_fichier_robinson(k) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| k | entier |
La fonction saisie
Cette fonction permet de saisir un entier n compris strictement entre deux bornes inf et sup.
Plus précisément :
Elle demande à l’utilisateur de saisir une valeur entière n.
Elle vérifie que n appartient à l’intervalle ]inf , sup[.
Tant que la valeur saisie est inférieure ou égale à inf ou supérieure ou égale à sup, la saisie est redemandée.
Lorsque la valeur est correcte, la fonction la retourne.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction saisie(inf:entier ; sup:entier):entier # Première saisie de l'entier Ecrire('donner n tel que ' , inf , '< n < ' , sup , ': ') Lire(n) # Tant que n n'est pas dans l'intervalle demandé, # on redemande la saisie Tant que (n <= inf) ou (n >= sup) faire Ecrire('donner n tel que ' , inf , '< n < ' , sup , ': ') Lire(n) Fin tant que # Retourne la valeur correcte saisie retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | chaîne |
La fonction concatiner_suite
La fonction concatiner_suite(u) a pour rôle de générer le terme suivant de la suite de Robinson à partir d’un terme précédent u.
Plus précisément, elle fait les opérations suivantes :
- Parcourt chaque chiffre du terme précédent u.
- Compte le nombre d’apparitions consécutives de chaque chiffre.
- Pour chaque groupe de chiffres identiques, elle concatène dans une nouvelle chaîne : (nombre d’apparitions) + (chiffre).
- Retourne cette nouvelle chaîne, qui correspond au terme suivant de la suite.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Fonction concatiner_suite(u:chaine): chaine chiffre <- u[0] # Initialise le premier chiffre à comparer cp <- 0 # Compteur du nombre d'apparitions du chiffre courant u1 <- '' # Chaîne qui contiendra le terme suivant # Parcours de chaque caractère du terme précédent Pour i de 0 à long(u)-1 faire Si chiffre = u[i] alors cp <- cp + 1 # Incrémentation si le chiffre est le même Sinon # Si le chiffre change, on ajoute le compteur et le chiffre courant u1 <- u1 + Convch(cp) + chiffre chiffre <- u[i] # Mise à jour du chiffre courant cp <- 1 # Réinitialisation du compteur # Ajout du dernier groupe de chiffres u1 <- u1 + Convch(cp) + chiffre retourner u1 # Retourne le terme suivant Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| chiffre | chaîne |
| cp | entier |
| u1 | chaîne |
La procédure remplir_fichier_robinson
La procédure remplir_fichier_circul(p, q) a pour rôle est de déterminer et enregistrer tous les nombres premiers circulaires compris entre deux entiers p et q.
Plus précisément, cette procédure :
- affiche un message indiquant le début du remplissage
- ouvre le fichier Circul.dat en mode écriture
- parcourt tous les entiers de p à q (bornes incluses)
- teste pour chaque entier s’il est premier circulaire à l’aide de la fonction test_circulaire()
- affiche chaque nombre premier circulaire trouvé
- écrit chaque nombre premier circulaire dans le fichier, un nombre par ligne
- ferme le fichier après la fin du traitement
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
Procédure remplir_fichier_robinson(n:entier) Ecrire('*** Fichier Robinson.txt ***') # Ouverture du fichier en mode écriture Ouvrir( f , "Robinson.txt", "w") u0 <- '0' # Terme initial U0 Ecrire('u0= 0') # Affichage du terme initial Ecrire (f , 'u0= 0' + '\n') # Écriture du terme initial dans le fichier # Génération et écriture des termes U1 à Un Pour i de 1 à n faire u1 <- concatiner_suite(u0) # Calcul du terme suivant Ecrire ('u' + i + '= ' + u1) # Affichage à l'écran Ecrire(f ,'u' + Conch(i) + '= ' + u1 + '\n') # Écriture dans le fichier u0 <- u1 # Mise à jour pour le prochain terme # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| i | entier |
| u0 | chaîne |
| u1 | chaîne |
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 |
# -------------------------------------------------- # Fonction qui permet de saisir un entier n # compris strictement entre inf et sup # -------------------------------------------------- def saisie(inf, sup): # Demande à l'utilisateur de saisir un entier n n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Tant que n n'appartient pas à l'intervalle ]inf , sup[ # on redemande la saisie while (n <= inf) or (n >= sup): n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Retourne la valeur correcte saisie return n # -------------------------------------------------- # Fonction qui génère le terme suivant de la suite de Robinson # à partir du terme précédent 'u' # -------------------------------------------------- def concatiner_suite(u): chiffre = u[0] # Initialise le premier chiffre à comparer cp = 0 # Compteur du nombre d'apparitions du chiffre courant u1 = '' # Chaîne qui contiendra le terme suivant # Parcours de chaque caractère du terme précédent for i in range(len(u)): if chiffre == u[i]: cp = cp + 1 # Incrémentation si le chiffre est le même else: # Si le chiffre change, on ajoute le compteur et le chiffre courant u1 = u1 + str(cp) + chiffre chiffre = u[i] # Mise à jour du chiffre courant cp = 1 # Réinitialisation du compteur # Ajout du dernier groupe de chiffres u1 = u1 + str(cp) + chiffre return u1 # Retourne le terme suivant # -------------------------------------------------- # Fonction qui remplit le fichier "Robinson.txt" # avec les k premiers termes de la suite de Robinson # -------------------------------------------------- def remplir_fichier_robinson(n): print('*** Fichier Robinson.txt ***') # Ouverture du fichier en mode écriture f = open("Robinson.txt", "w") u0 = '0' # Terme initial U0 print('u0= 0') # Affichage du terme initial f.write('u0= 0' + '\n') # Écriture du terme initial dans le fichier # Génération et écriture des termes U1 à Un for i in range(1, n + 1): u1 = concatiner_suite(u0) # Calcul du terme suivant print('u' + str(i) + '= ' + u1) # Affichage à l'écran f.write('u' + str(i) + '= ' + u1 + '\n') # Écriture dans le fichier u0 = u1 # Mise à jour pour le prochain terme # Fermeture du fichier f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- # Saisie du nombre de termes k (2 < k < 15) k = saisie(2, 15) # Génération et remplissage du fichier avec les k premiers termes remplir_fichier_robinson(k) |
Exécution du programme
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
