Un entier est dit zigzag lorsque ses chiffres croissent et décroissent ou inversement d’une façon alternative.
Exemples :
13254 est dit zigzag car i < 3 qui est > 2 qui est <5 qui est > 4.
8781 est dit zigzag car 8 est >7 qui est < 8 qui est > 1
Le nombre 8761 est dit non zizag car 8 > 7 qui est aussi > 6 .
Ecrire un programme Python qui permet de remplir un tableau t par n (5≤n≤25) entiers positifs composés d’au minimum 3 chiffres et d’afficher les nombres ZigZag du tableau T.
Exemple : Pour N=6 et le tableau T suivant :
121 | 5412 | 9674 | 4789 | 3624 | 8521 |
Le programme affiche : « les entiers ZIZAG sont : 121 9674 3624 »
1- Initialisation :
Créer un tableau T
de taille n
, où n
est un nombre entier entre 5 et 25.
Chaque élément de T
est un entier positif comportant au moins 3 chiffres.
2- Remplissage du tableau T
:
Saisir les n
entiers positifs dans le tableau T
. Chaque entier doit avoir au moins 3 chiffres.
3- Détection des nombres ZigZag :
Parcourir chaque nombre du tableau et vérifier si ses chiffres forment un motif alterné de croissance et décroissance (ou vice versa). Autrement dit, il faut que pour chaque chiffre du nombre :
a) Si le chiffre précédent est plus petit, alors le chiffre suivant doit être plus grand.
b) Si le chiffre précédent est plus grand, alors le chiffre suivant doit être plus petit.
Algorithme détaillé pour vérifier si un nombre est ZigZag :
Pour chaque entier du tableau T
:
1. Convertir l'entier en une liste de chiffres.
2. Si la liste contient moins de 3 chiffres, ce n’est pas un ZigZag.
3. Parcourir la liste des chiffres deux à deux, vérifier l’alternance :
a) Si à l’indice i
, le chiffre est plus grand que celui à l’indice i-1
, alors le chiffre à l’indice i+1
doit être plus petit que celui à l’indice i
.
b) Si à l’indice i
, le chiffre est plus petit que celui à l’indice i-1
, alors le chiffre à l’indice i+1
doit être plus grand que celui à l’indice i
.
Si l'alternance est respectée pour tous les chiffres, le nombre est ZigZag.
4- Affichage des résultats :
Après avoir parcouru tous les nombres dans T
, afficher uniquement les nombres qui respectent la propriété de ZigZag.
.Dans cet algorithme, On va utiliser 2 fonctions et 2 procédures :
Algorithme du programme principal
1 2 3 4 5 6 7 |
Algorithme enitiers_zigzag Debut n<-saisie_taille() Ecrire('remplissage du tableau t') remplir(t,n) afficher_entiers_zigzag(t,n) Fin |
Déclaration des objets
Objet | Type / Nature |
---|---|
n | entier |
t | tableau des 30 entiers |
La fonction saisie_taille
Cette fonction retourne un entier n entre 5 et 25 saisi par l'utilisateur.
1 2 3 4 5 6 7 8 9 10 |
foncttion saisie_taille():entier Début Ecrire('donner un entier entre 5 et 10') lire (n) Tant que n<5 ou n>10 faire Ecrire('donner un entier entre 5 et 10') lire (n) Fin tant que retourner n Fin |
Déclaration des objets
Objet | Type / Nature |
n | entier |
La procédure remplir
Cette procédure remplit le tableau t des entiers >=100
1 2 3 4 5 6 7 8 9 10 11 |
Procédure remplir(@t:Tab,n:entier) Début Pour i de 0 à n-1 faire Ecrire("donner elt N° "+str(i)+" >99") lire(t[i]) Tant que (t[i])<100) faire Ecrire("donner elt N° "+str(i)+" >99") lire(t[i]) Fin tant que Fin pour Fin |
Déclaration des objets
Objet | Type / Nature |
i | entier |
La fonction test_zig_zag
Cette fonction teste si un entier est zigzag ou non.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Fonction test_zig_zag(n:entier):booleen Début ch<-Convch(n) i<-0 test<-Vrai zigzag<-(ch[0]>ch[1]) Tant que (test) et (i<long(ch)-2) faire i<-i+1 Si (zigzag != (ch[i]>ch[i+1])) alors zigzag<- not(zigzag) test<-True Sinon test<-Faux Fin tant que retourner test Fin |
Déclaration des objets
Objet | Type / Nature |
---|---|
i | entier |
test | booléen |
zigzag | booléen |
ch | chaîne des caractères |
La procédure afficher_entiers_zigzag
Cette procédure identifie et affiche les entiers zizag.
1 2 3 4 5 6 7 8 9 |
Procédure afficher_mots_zizag(t:Tab,n:entier) Début Ecrire('les entiers zigzag sont:')) Pour i de 0 à n-1 faire Si test_entiers_zizag(t[i]) alors Ecrire(t[i]) # afficher les mots zigzag sont Fin si Fin pour Fin |
Déclaration des objets
Objet | Type / Nature |
---|---|
i | entier |
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 |
from numpy import array t=array([int()]*30) #declaration du tableau des entiers def saisie_taille() : n=int(input("donner un entier entre 5 et 25: ")) while(n<5) or (n>25) : n=int(input("donner un entier entre 5 et 25: ")) return n def remplir(t,n): for i in range (n) : t[i]=int(input("donner elt N° "+str(i)+" >99: ")) while (t[i]<=99): t[i]=int(input("donner elt N° "+str(i)+" >99: ")) def test_zig_zag(n) : ch=str(n) i=0 test=True zigzag=(ch[0]>ch[1]) while (test) and (i<len(ch)-2): i=i+1 if (zigzag != (ch[i]>ch[i+1])): zigzag= not(zigzag) test=True else: test=False return test def afficher_entiers_zigzag(t,n): print('les entiers zigzag sont:') for i in range (n) : if test_zig_zag(t[i]): print(str(t[i])) #programme principal n=saisie_taille() print('remplissage du tableau t') remplir(t,n) afficher_entiers_zigzag(t,n) |
Exécution du programme
Pour remplir un tableau des chaînes à partir d'une chaîne de caractères en Python, vous pouvez suivre les étapes suivantes :
1- Découper la chaîne de caractères en sous-chaînes contenant les mots.
3- Ajouter chaque sous-chaîne au tableau.
Pour créer une application en Python pour identifier et afficher les entiers zizag
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets:
QLineEdit
nommé 'ch' pour entrer des entiers .
QPushButton
nommé 'remplir_bt' pour exécuter le module createTab afin de remplir le tableau à partir de la chaine 'ch'.
QPushButton
nommé 'bt_recherche' pour exécuter le module afficher_entiers_zizgag.
QLabel
nommé 'msg' pour afficher des messages d'erreur.
QLabel
nommé 'tab_label' pour afficher les éléments du tableau T.
QLabel
nommé 'resultat' pour afficher les entiers zigzag.
Enregistrez le fichier avec l'extension .ui
, par exemple tabtab-2.ui
.
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 |
from numpy import array t=array([int()]*30) #declaration du tableau des entiers def saisie_taille() : n=int(input("donner un entier entre 5 et 25: ")) while(n<5) or (n>25) : n=int(input("donner un entier entre 5 et 25: ")) return n def remplir(t,n): for i in range (n) : t[i]=int(input("donner elt N° "+str(i)+" >99: ")) while (t[i]<=99): t[i]=int(input("donner elt N° "+str(i)+" >99: ")) def test_zig_zag(n) : ch=str(n) i=0 test=True zigzag=(ch[0]>ch[1]) while (test) and (i<len(ch)-2): i=i+1 if (zigzag != (ch[i]>ch[i+1])): zigzag= not(zigzag) test=True else: test=False return test def afficher_entiers_zigzag(t,n): print('les entiers zigzag sont:') for i in range (n) : if test_zig_zag(t[i]): print(str(t[i])) #programme principal n=saisie_taille() print('remplissage du tableau t') remplir(t,n) afficher_entiers_zigzag(t,n) |
Exécution du programme
Vous pouvez voir aussi :
La robotique éducative joue un rôle important dans l'éducation des enfants et des jeunes en les aidant à acquérir des compétences en science et technologie.
Dans ce cadre notre site web représente une excellente ressource pour les parents, les enseignants et les enfants qui souhaitent découvrir la robotique.
Zaouiet Kontech-Jemmel-Monastir-Tunisie
+216 92 886 231
medaliprof@gmail.com
Site robotique réalisé par Mohamed Ali-Prof Info