Suite arithmétique – Bac pratique – Section informatique – 2010

Bac Info 09-12-25

23 0

Sujet (Algo et programmation - Bac 2009)

Ecrire an programme Python qui permet de :
- remplir un fichier nommé "Nornbre.dat" par n chiffres aléatoires non nuls (avec 2 < n< 50).- déterminer et afficher le plus petit nombre (pn) et le plus grand nombre formé par tous les chiffres de ce fichier.- vérifier si les écarts entre tous les chiffres symétriques de (gn) forment des termes successifs d'une suite arithmétique, dans l'affirmative, afficher sa raison (r).Deux chiffres Ci et Cj dc gn sont dits symétriques si leurs positions respectives i et j dans gn vérifient : k +1, avec k le nombre de chiffres de gn, pour tout i allant de 1. k div 2.

Solution Algorithmique

Dans cet algorithme, On va utiliser trois fonctions et deux procédures :

- la fonction saisie()

- la procédure remplir_fichier_nombres()

- la procédure extraction_nombre()

- la fonction min_nombre()

- la fonction max_nombre()

- la procédure verif_suite_arithmetique()

Algorithme du programme Principal

Algorithme suite_aritmetique 
Debut 
     n <- saisie()                     # Saisie du nombre de chiffres
     remplir_fichier_nombres(n)       # Remplir le fichier avec n chiffres aléatoires
     extraction_nombre(t, n)          # Charger ces chiffres dans le tableau t
     Ecrire(max_nombre(t, n))          # Afficher le premier maximum (non utilisé ensuite)
     pn <- min_nombre(t, n)            # Calcul du plus petit nombre
     Ecrire('Le plus petit nombre= ' + str(pn))
     gn <- max_nombre(t, n)            # Calcul du plus grand nombre
     Ecrire('Le plus grand nombre= ' + gn)
     # Vérification si les chiffres du plus grand nombre forment une suite arithmétique
     Si verif_suite_arithmetique(t, n) alors
        ecrire('Les chiffres de ' + gn + ' forme une suite arithmetique') 
     Sinon
        Ecrire('Les chiffres de ' + gn + ' ne forme pas une suite arithmetique')
     Finsi
Fin

Algorithme suite_aritmetique

Debut

n <- saisie() # Saisie du nombre de chiffres

remplir_fichier_nombres(n) # Remplir le fichier avec n chiffres aléatoires

extraction_nombre(t, n) # Charger ces chiffres dans le tableau t

Ecrire(max_nombre(t, n)) # Afficher le premier maximum (non utilisé ensuite)

pn <- min_nombre(t, n) # Calcul du plus petit nombre

Ecrire('Le plus petit nombre= ' + str(pn))

gn <- max_nombre(t, n) # Calcul du plus grand nombre

Ecrire('Le plus grand nombre= ' + gn)

# Vérification si les chiffres du plus grand nombre forment une suite arithmétique

Si verif_suite_arithmetique(t, n) alors

ecrire('Les chiffres de ' + gn + ' forme une suite arithmetique')

Sinon

Ecrire('Les chiffres de ' + gn + ' ne forme pas une suite arithmetique')

Finsi

Fin

Déclaration des objets

Objet	Type / Nature
n	entier
t	tableau des entiers
gn	entier
pn	entier

La fonction saisir

La fonction saisie() permet à l’utilisateur de saisir un entier n et de contrôler que cet entier appartient bien à l’intervalle strict : 100

Fonction saisie(): entier    
    Ecrire('donner n tel que 2<n<=50: ')
    lire (n)
    # Tant que la valeur n'est pas dans l’intervalle demandé, on redemande
    Tant que (n <= 2) ou (n > 50) faire
        Ecrire('donner n tel que 2<n<=50: ') 
        lire (n)
    Fin tant que
    retourner n
fin

Fonction saisie(): entier

Ecrire('donner n tel que 2<n<=50: ')

lire (n)

# Tant que la valeur n'est pas dans l’intervalle demandé, on redemande

Tant que (n <= 2) ou (n > 50) faire

Ecrire('donner n tel que 2<n<=50: ')

lire (n)

Fin tant que

retourner n

fin

Déclaration des objets

Objet	Type / Nature
n	entier

La procédure remplir_fichier_nombres

La procédure génère automatiquement n chiffres aléatoires compris entre 0 et 9, puis les enregistre dans un fichier texte nommé Nombres.dat, un chiffre par ligne.

Elle :

- crée ou remplace le fichier Nombres.dat.

- produit n chiffres choisis au hasard.

- les écrit dans le fichier, chacun sur une nouvelle ligne.

- ferme le fichier à la fin.

Procédure remplir_fichier_nombres(n:entier):   
    Ouvrir("Nombre.dat", f , "w") # Fichier texte pour les statistiques
    Pour i de 0 à n-1 faire
        chiffre <- Alea(0, 9)   # Génère un chiffre aléatoire
        Ecrire(f , Convch(chiffre) + '\n')     # Écriture du chiffre dans le fichier
    Finpour
    Fermer(f)   
Fin

Procédure remplir_fichier_nombres(n:entier):

Ouvrir("Nombre.dat", f , "w") # Fichier texte pour les statistiques

Pour i de 0 à n-1 faire

chiffre <- Alea(0, 9) # Génère un chiffre aléatoire

Ecrire(f , Convch(chiffre) + '\n') # Écriture du chiffre dans le fichier

Finpour

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier du Nombre.dat
i	entier
chiffre	entier

La procédure extraction_nombre

La fonction extraction_nombre a pour rôle de :

- lire les n chiffres stockés dans le fichier nombres.dat

- convertir chaque chiffre lu en entier

- placer ces valeurs dans le tableau t, dans l’ordre où elles apparaissent dans le fichier.

Procédure extraction_nombre(t:tableau ; n:entier)
    Ouvrir(f,"nombres.dat", "r")   # Lecture du fichier contenant les chiffres
    Lire_lignes (f , chiffres)     # Lire toutes les lignes
    i <- 0
    Pour chiffre dans chiffres faire
        t[i] <- Valeur(chiffre)       # Conversion en entier et stockage dans t
        i <- i+1
    Fin pour
Fin

Procédure extraction_nombre(t:tableau ; n:entier)

Ouvrir(f,"nombres.dat", "r") # Lecture du fichier contenant les chiffres

Lire_lignes (f , chiffres) # Lire toutes les lignes

i <- 0

Pour chiffre dans chiffres faire

t[i] <- Valeur(chiffre) # Conversion en entier et stockage dans t

i <- i+1

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
f	fichier du Nombre.dat

La procédure min_nombre

La procédure min_nombre a pour rôle de former le plus petit nombre possible à partir des n chiffres contenus dans le tableau t.

Pour cela, elle :

- trie les chiffres du tableau t dans l’ordre croissant en utilisant un tri par sélection.

- construit un nombre en concaténant les chiffres triés du plus petit au plus grand.

- retourne ce nombre sous forme d’une chaîne de caractères.

Procedure min_nombre (t:tableau;n:entier):    
    # Tri par sélection en ordre croissant
    Pour i de 0 à n - 2 faire
        min_indice <- i
        Pour j de i + 1 à n-1 faire
            Si t[min_indice] > t[j]:   # Chercher le plus petit élément
                min_indice <- j
            Finsi
        Finpour
        # Échange des éléments
        Si min_indice != i alors
            temp <- t[i]
            t[i] <- t[min_indice]
            t[min_indice] <- temp
        Finsi
    Finpour 
    # Construction du nombre en concaténant les chiffres triés
    nombre <- ''
    Pour i de 0 à n-1 faire
        nombre = nombre + Conch (t[i])
    Finpour
    retourner nombre
Fin

Procedure min_nombre (t:tableau;n:entier):

# Tri par sélection en ordre croissant

Pour i de 0 à n - 2 faire

min_indice <- i

Pour j de i + 1 à n-1 faire

Si t[min_indice] > t[j]: # Chercher le plus petit élément

min_indice <- j

Finsi

Finpour

# Échange des éléments

Si min_indice != i alors

temp <- t[i]

t[i] <- t[min_indice]

t[min_indice] <- temp

Finsi

Finpour

# Construction du nombre en concaténant les chiffres triés

nombre <- ''

Pour i de 0 à n-1 faire

nombre = nombre + Conch (t[i])

Finpour

retourner nombre

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
min_indice	entier
nombre	chaîne

La procédure max_nombre

La procédure max_nombre a pour rôle de former le plus grand nombre possible à partir des n chiffres contenus dans le tableau t.

Pour cela, elle :

- trie les chiffres du tableau t dans l’ordre déccroissant en utilisant un tri par sélection.

- construit un nombre en concaténant les chiffres triés du plus grand au plus petit.

- retourne ce nombre sous forme d’une chaîne de caractères.

Procedure max_nombre (t:tableau;n:entier):    
    # Tri par sélection en ordre decroissant
    Pour i de 0 à n - 2 faire
        max_indice <- i
        Pour j de i + 1 à n-1 faire
            Si t[max_indice] < t[j]:   # Chercher le plus petit élément
                min_indice <- j
            Finsi
        Finpour
        # Échange des éléments
        Si max_indice != i alors
            temp <- t[i]
            t[i] <- t[max_indice]
            t[max_indice] <- temp
        Finsi
    Finpour 
    # Construction du nombre en concaténant les chiffres triés
    nombre <- ''
    Pour i de 0 à n-1 faire
        nombre = nombre + Conch (t[i])
    Finpour
    retourner nombre
Fin

Procedure max_nombre (t:tableau;n:entier):

# Tri par sélection en ordre decroissant

Pour i de 0 à n - 2 faire

max_indice <- i

Pour j de i + 1 à n-1 faire

Si t[max_indice] < t[j]: # Chercher le plus petit élément

min_indice <- j

Finsi

Finpour

# Échange des éléments

Si max_indice != i alors

temp <- t[i]

t[i] <- t[max_indice]

t[max_indice] <- temp

Finsi

Finpour

# Construction du nombre en concaténant les chiffres triés

nombre <- ''

Pour i de 0 à n-1 faire

nombre = nombre + Conch (t[i])

Finpour

retourner nombre

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
max_indice	entier
nombre	chaîne

La fonction verif_suite_arithmetique

La fonction verif_suite_arithmetique a pour rôle de vérifier si les chiffres du tableau t forment une suite arithmétique lorsqu’on les compare par paires symétriques (c’est-à-dire le premier avec le dernier, le deuxième avec l’avant-dernier, etc.).

Plus précisément, elle :

- calcule les premières différences entre les paires de chiffres symétriques :

𝑡[0]−𝑡[𝑛−1]

t[1]−t[n−2]

- compare ces différences pour obtenir une première relation.

- parcourt toutes les autres paires symétriques :

t[i]−t[n−i−1]

t[i+1]−t[n−i−2]

- vérifie si la même relation entre les différences est toujours respectée et retourne Vrai si toutes les paires respectent la même différence (donc forment une suite arithmétique), Faux sinon.

Fonction verif_suite_arithmetique(t:tableau; n:entier):booleen
    # Calcul des deux premières différences
    u0 <- t[0] - t[n - 1]
    Ecrire(u0))
    u1 <- t[1] - t[n - 2]
    Ecrire(u1)
    
    r <- u0 - u1   # Première valeur du "raisonnement"
    i <- 2

    # Vérifications successives pour toutes les paires symétriques
    Tant que (r = u0 - u1) et (i < n div 2) faire
        u0 <- t[i] - t[n - i - 1]
        u1 <- t[i + 1] - t[n - i - 2]
        Ecrire(u0)
        Ecrire(u1)
        i = i + 1
    Fin tant que
    # Retourne vrai si toutes les différences respectent la même relation
    retourner (r = u0 - u1)
Fin

Fonction verif_suite_arithmetique(t:tableau; n:entier):booleen

# Calcul des deux premières différences

u0 <- t[0] - t[n - 1]

Ecrire(u0))

u1 <- t[1] - t[n - 2]

Ecrire(u1)

r <- u0 - u1 # Première valeur du "raisonnement"

i <- 2

# Vérifications successives pour toutes les paires symétriques

Tant que (r = u0 - u1) et (i < n div 2) faire

u0 <- t[i] - t[n - i - 1]

u1 <- t[i + 1] - t[n - i - 2]

Ecrire(u0)

Ecrire(u1)

i = i + 1

Fin tant que

# Retourne vrai si toutes les différences respectent la même relation

retourner (r = u0 - u1)

Fin

Déclaration des objets

Objet	Type / Nature
u0	entier
u1	entier
i	entier
r	entier

Solution en Python

from numpy import *
import random

# Tableau pouvant contenir jusqu'à 50 chiffres
t = array([int()] * 50)   # Stockera les chiffres lus dans le fichier


# Fonction pour saisir un entier n vérifiant 2 < n ≤ 50
def saisie():
    n = int(input('donner n telque 2<n<=50: '))
    # Répéter tant que la valeur n’est pas dans l’intervalle demandé
    while (n <= 2) or (n > 50):
        n = int(input('donner n telque 2<n<=50: '))
    return n    


# Procédure pour remplir un fichier avec n chiffres aléatoires entre 0 et 9
def remplir_fichier_nombres(n):    
    f = open("Nombres.dat", "w")    # Ouverture du fichier en écriture    
    for i in range(n):
        chiffre = random.randint(0, 9)   # Génère un chiffre aléatoire
        f.write(str(chiffre) + '\n')     # Écriture du chiffre dans le fichier
    f.close()                            # Fermeture du fichier


# Extraction des n chiffres du fichier vers le tableau t
def extraction_nombre(t, n):
    f = open("nombres.dat", "r")   # Lecture du fichier contenant les chiffres
    chiffres = f.readlines()       # Lire toutes les lignes
    i = 0
    for chiffre in chiffres:
        t[i] = int(chiffre)        # Conversion en entier et stockage dans t
        i += 1


# Fonction pour générer le plus petit nombre possible en triant les chiffres
def min_nombre(t, n):
    # Tri par sélection en ordre croissant
    for i in range(n - 1):
        min_indice = i
        for j in range(i + 1, n):
            if t[min_indice] > t[j]:   # Chercher le plus petit élément
                min_indice = j
        # Échange des éléments
        if min_indice != i:
            temp = t[i]
            t[i] = t[min_indice]
            t[min_indice] = temp
    
    # Construction du nombre en concaténant les chiffres triés
    nombre = ''
    for i in range(n):
        nombre += str(t[i])
    return nombre


# Fonction pour générer le plus grand nombre possible en triant les chiffres
def max_nombre(t, n):
    # Tri par sélection en ordre décroissant
    for i in range(n - 1):
        max_indice = i
        for j in range(i + 1, n):
            if t[max_indice] < t[j]:   # Chercher le plus grand élément
                max_indice = j
        # Échange des éléments
        if max_indice != i:
            temp = t[i]
            t[i] = t[max_indice]
            t[max_indice] = temp

    # Construction du nombre trié décroissant
    nombre = ''
    for i in range(n):
        nombre += str(t[i])
    return nombre


# Vérifie si les paires de chiffres (t[i], t[n-i-1]) forment une suite arithmétique
def verif_suite_arithmetique(t, n):
    # Calcul des deux premières différences
    u0 = t[0] - t[n - 1]
    print(str(u0))
    u1 = t[1] - t[n - 2]
    print(str(u1))
    
    r = u0 - u1   # Première valeur du "raisonnement"
    i = 2

    # Vérifications successives pour toutes les paires symétriques
    while (r == u0 - u1) and (i < n // 2):
        u0 = t[i] - t[n - i - 1]
        u1 = t[i + 1] - t[n - i - 2]
        print(str(u0))
        print(str(u1))
        i += 1

    # Retourne vrai si toutes les différences respectent la même relation
    return r == u0 - u1


# ============================
#        PROGRAMME PRINCIPAL
# ============================

n = saisie()                     # Saisie du nombre de chiffres
remplir_fichier_nombres(n)       # Remplir le fichier avec n chiffres aléatoires
extraction_nombre(t, n)          # Charger ces chiffres dans le tableau t

print(max_nombre(t, n))          # Afficher le premier maximum (non utilisé ensuite)

pn = min_nombre(t, n)            # Calcul du plus petit nombre
print('Le plus petit nombre= ' + str(pn))

gn = max_nombre(t, n)            # Calcul du plus grand nombre
print('Le plus grand nombre= ' + str(gn))

# Vérification si les chiffres du plus grand nombre forment une suite arithmétique
if verif_suite_arithmetique(t, n):
    print('Les chiffres de ' + str(gn) + ' forme une suite arithmetique') 
else:
    print('Les chiffres de ' + str(gn) + ' ne forme pas une suite arithmetique')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

from numpy import *

import random

# Tableau pouvant contenir jusqu'à 50 chiffres

t = array([int()] * 50) # Stockera les chiffres lus dans le fichier

# Fonction pour saisir un entier n vérifiant 2 < n ≤ 50

def saisie():

n = int(input('donner n telque 2<n<=50: '))

# Répéter tant que la valeur n’est pas dans l’intervalle demandé

while (n <= 2) or (n > 50):

n = int(input('donner n telque 2<n<=50: '))

return n

# Procédure pour remplir un fichier avec n chiffres aléatoires entre 0 et 9

def remplir_fichier_nombres(n):

f = open("Nombres.dat", "w") # Ouverture du fichier en écriture

for i in range(n):

chiffre = random.randint(0, 9) # Génère un chiffre aléatoire

f.write(str(chiffre) + '\n') # Écriture du chiffre dans le fichier

f.close() # Fermeture du fichier

# Extraction des n chiffres du fichier vers le tableau t

def extraction_nombre(t, n):

f = open("nombres.dat", "r") # Lecture du fichier contenant les chiffres

chiffres = f.readlines() # Lire toutes les lignes

i = 0

for chiffre in chiffres:

t[i] = int(chiffre) # Conversion en entier et stockage dans t

i += 1

# Fonction pour générer le plus petit nombre possible en triant les chiffres

def min_nombre(t, n):

# Tri par sélection en ordre croissant

for i in range(n - 1):

min_indice = i

for j in range(i + 1, n):

if t[min_indice] > t[j]: # Chercher le plus petit élément

min_indice = j

# Échange des éléments

if min_indice != i:

temp = t[i]

t[i] = t[min_indice]

t[min_indice] = temp

# Construction du nombre en concaténant les chiffres triés

nombre = ''

for i in range(n):

nombre += str(t[i])

return nombre

# Fonction pour générer le plus grand nombre possible en triant les chiffres

def max_nombre(t, n):

# Tri par sélection en ordre décroissant

for i in range(n - 1):

max_indice = i

for j in range(i + 1, n):

if t[max_indice] < t[j]: # Chercher le plus grand élément

max_indice = j

# Échange des éléments

if max_indice != i:

temp = t[i]

t[i] = t[max_indice]

t[max_indice] = temp

# Construction du nombre trié décroissant

nombre = ''

for i in range(n):

nombre += str(t[i])

return nombre

# Vérifie si les paires de chiffres (t[i], t[n-i-1]) forment une suite arithmétique

def verif_suite_arithmetique(t, n):

# Calcul des deux premières différences

u0 = t[0] - t[n - 1]

print(str(u0))

u1 = t[1] - t[n - 2]

print(str(u1))

r = u0 - u1 # Première valeur du "raisonnement"

i = 2

# Vérifications successives pour toutes les paires symétriques

while (r == u0 - u1) and (i < n // 2):

u0 = t[i] - t[n - i - 1]

u1 = t[i + 1] - t[n - i - 2]

print(str(u0))

print(str(u1))

i += 1

# Retourne vrai si toutes les différences respectent la même relation

return r == u0 - u1

# ============================

# PROGRAMME PRINCIPAL

# ============================

n = saisie() # Saisie du nombre de chiffres

remplir_fichier_nombres(n) # Remplir le fichier avec n chiffres aléatoires

extraction_nombre(t, n) # Charger ces chiffres dans le tableau t

print(max_nombre(t, n)) # Afficher le premier maximum (non utilisé ensuite)

pn = min_nombre(t, n) # Calcul du plus petit nombre

print('Le plus petit nombre= ' + str(pn))

gn = max_nombre(t, n) # Calcul du plus grand nombre

print('Le plus grand nombre= ' + str(gn))

# Vérification si les chiffres du plus grand nombre forment une suite arithmétique

if verif_suite_arithmetique(t, n):

print('Les chiffres de ' + str(gn) + ' forme une suite arithmetique')

else:

print('Les chiffres de ' + str(gn) + ' ne forme pas une suite arithmetique')

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Suite arithmétique – Bac pratique – Section informatique – 2010

Bac Info 09-12-25

Calcul approché d’une intégrale – Bac théorique – Section informatique – 2009

Bac Info 09-12-25

Chemins Matrice – Bac théorique – Section informatique – 2009

Bac Info 08-12-25

Facteurs premiers – Bac pratique – Section informatique – 2009

Bac Info 05-12-25

Suite – Bac pratique – Section informatique- 2009

Bac Info 05-12-25

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 10431vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 9926vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 8909vues

Allumer une LED par la carte ESP32

ESP32 8575vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino UNO 8481vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 28 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino UNO 17 commentaires

Présentation du module capteur de lumière à LDR

Composants 14 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Présentation du buzzer

Composants 6 commentaires

Suite arithmétique – Bac pratique – Section informatique – 2010

Sujet (Algo et programmation - Bac 2009)

Solution Algorithmique

Algorithme du programme Principal

La fonction saisir

La procédure remplir_fichier_nombres

La procédure extraction_nombre

La procédure min_nombre

La procédure max_nombre

La fonction verif_suite_arithmetique

Solution en Python

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles