Entiers ZIGZAG – Bac Pratique 2015 [ Algorithme + Python ]

Algo et Python 05-09-24

190 0

Sujet bac informatique pratique 2015 (Bac scientifique)

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 »

Solution Algorithmique

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

Algorithme enitiers_zigzag
Debut
     n<-saisie_taille()
     Ecrire('remplissage du tableau t')
     remplir(t,n)
     afficher_entiers_zigzag(t,n)
Fin

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.

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

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

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

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.

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

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.

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

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

Solution en Python

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)

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

Solution en Python et Designer QT

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

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 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.

2- Créer le script Python pour l'application

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)