Problème suite de Fibonacci – Bac théorique – Section informatique – 2026

Bac Info 11-06-26

3 0

Sujet (Algo et programmation - Bac 2026)

En se basant sur le triangle de Pascal, on peut calculer les termes de la suite de Fibonacci et les termes de la suite diatomique de Stern en appliquant le procédé suivant:

- Les termes de la suite de Fibonacci sont déterminés en calculant la somme des valeurs situées sur chaque diagonale ascendante du triangle de Pascal (diagonale partant du bord gauche et montant vers la droite comme illustré par la figure Fig1 ci-après).

- Les termes de la suite diatomique de Stern sont déterminés en comptant le nombre de valeurs impaires situées sur chaque diagonale ascendante du triangle de Pascal (diagonale partant du bord gauche et montant vers la droite comme illustré par la figure Fig2 ci-après).

Exemples:

- Les 9 termes de la suite de Fibonacci de F1 à F9 sont: 1, 1, 2, 3, 5, 8, 13, 21 et 34. Ces termes sont déterminés à partir du triangle de Pascal en utilisant le procédé décrit précédemment, comme l'illustre la figure Fig1 ci-après.

- Les 9 termes de la suite diatomique de Stern de S1 à S9 sont: 1, 1, 2, 1, 3, 2, 3, 1 et 4. Ces termes sont déterminés à partir du triangle de Pascal en utilisant le procédé décrit précédemment, comme l'illustre la figure Fig2 ci-après.

Travail demandé :

1) Ecrire un algorithme d'une procédure TrianglePascal(M, N) qui permet de remplir une matrice M par les N premières lignes du triangle de Pascal en utilisant le procédé suivant:

- Les lignes sont remplies jusqu'à la diagonale principale.

- Pour chaque ligne :

Le premier élément et le dernier élément sont égaux à 1,

Les autres éléments sont déterminés en appliquant la formule suivante : M[ligne, colonne] = M[ligne - 1, colonne] + M[ligne - 1, colonne - 1]

NB: M est de type Mat et N est un entier supérieur ou égal à 5 déjà saisi dans le programme appelant.

2) Ecrire un algorithme d'une procédure Remplir(M, N, TFS) qui permet de remplir un tableau TFS, de type Tab, par N enregistrements où chaque enregistrement est composé des deux champs suivants :

- Fib: le terme de rang i de la suite de Fibonacci (i = [1..N]).

- Ste le terme de rang i de la suite diatomique de Stern (i e [1..N]).

Le calcul des termes de la suite de Fibonacci et les termes de la suite diatomique de Stern se fait à partir de la matrice M, déjà remplie par les N premières lignes du triangle de Pascal et en utilisant le procédé décrit précédemment.

Exemple : Pour N = 9, le tableau TFS est:

3) Une société de télécommunication organise un jeu promotionnel destiné à ses abonnés fidèles.

Chaque abonné est identifié par un matricule, qui est une chaine de caractères composée de 4 chiffres. Les matricules sont stockés dans un fichier texte nommé "Fidele.txt", à raison d'un matricule par ligne.

Ecrire un algorithme d'un programme qui permet de:

- Saisir un entier N (avec 5 ≤ N ≤ 100).

- Remplir une matrice M par les N premières lignes du triangle de Pascal en faisant appel à la procédure TrianglePascal.

- Remplir un tableau TFS par N enregistrements en faisant appel à la procédure Remplir.. Créer et remplir un fichier texte nommé "Gagnants.txt" par les gagnants et les super gagnants, sachant qu':

- un abonné est déclaré "Gagnant" si la somme des chiffres de son matricule est un terme de la suite de Fibonacci figurant dans le tableau TFS ou un terme de la suite diatomique de Stern figurant dans le tableau TFS.

- un abonné est déclaré "Super gagnant" si la somme des chiffres de son matricule est à la fois un terme de la suite de Fibonacci et un terme de la suite diatomique de Stern figurants dans le tableau TFS, non obligatoirement dans la même case.

NB:

Chaque ligne du fichier "Gagnants.txt" doit contenir le matricule du gagnant, suivi d'un espace, puis du commentaire "Gagnant" ou "Super gagnant" selon le cas. Le fichier "Fidele.txt" est enregistré sur la racine du disque D.

Le fichier "Gagnants.txt" est à créer sur la racine du disque D.

Exemple: À partir du tableau TFS de la question 2) et du fichier texte "Fidele.txt", dont le contenu est présenté dans la première colonne du tableau suivant, on obtient le fichier texte "Gagnants.txt", dont le contenu figure dans la deuxième colonne du même tableau :

En effet :

Pour le matricule 2001, la somme de ses chiffres est égale à 3, qui est à la fois un terme de la suite de Fibonacci figurant dans le tableau TFS à la case d'indice 4 et un terme de la suite diatomique de Stern figurant dans le tableau TFS à la case d'indice 5. Par conséquent il est déclaré "Super gagnant".

Pour le matricule 0130, la somme de ses chiffres est égale à 4 qui est seulement un terme de la suite diatomique de Stern figurant dans le tableau TFS à la case d'indice 9, donc il est déclaré "Gagnant".

Pour le matricule 3110, la somme de ses chiffres est égale à 5. Le nombre 5 est un terme de la suite de Fibonacci figurant dans le tableau TFS à la case d'indice 5. Cependant, bien qu'il appartienne mathématiquement à la suite diatomique de Stern, il ne figure pas dans le tableau TFS pour cette suite. Par conséquent, ce matricule est déclaré "Gagnant", mais non "Super gagnant".

Solution Algorithmique

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

- la fonction saisie_n()

- la fonction sommefacteurs()

- la fonction somme_chiffres()

- la fonction test_nombre_fort()

- la procédure NbrFort()

Algorithme du programme Principal

Algorithme nbr_fort
Debut 
     # Création du fichier des abonnés fidèles
     remplir_fidele()
     # Saisie du nombre de lignes du triangle de Pascal
     n = saisie_n()
     # Détermination des gagnants et création du fichier résultat
     remplir_gagnants()
Fin

Algorithme nbr_fort

Debut

# Création du fichier des abonnés fidèles

remplir_fidele()

# Saisie du nombre de lignes du triangle de Pascal

n = saisie_n()

# Détermination des gagnants et création du fichier résultat

remplir_gagnants()

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction saisie_n

Cette fonction permet de saisir et retourner un entier entre 5 et 100 en contrôlant la validité de la saisie.

Fonction saisie_n():entier
    Ecrire('saisir 5<=n<=100: ')
    Lire(n)
    # Tant que la valeur saisie n’est pas valide, on redemande
    Tant que Non (5<=n<=100) faire
        Ecrire('saisir 5<=n<=100: ') 
        Lire(n)
    Fin tant que
    retourner n 
Fin

Fonction saisie_n():entier

Ecrire('saisir 5<=n<=100: ')

Lire(n)

# Tant que la valeur saisie n’est pas valide, on redemande

Tant que Non (5<=n<=100) faire

Ecrire('saisir 5<=n<=100: ')

Lire(n)

Fin tant que

retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La procédure trianglepascal

Cette procédure permet de construire et d'afficher le triangle de Pascal jusqu'à la nᵉ ligne en remplissant une matrice selon la règle où les éléments des bords valent 1 et chaque élément intérieur est égal à la somme des deux éléments situés au-dessus de lui.

Procédure trianglepascal(m:matrice, n:entier)
    # Remplissage du triangle
    Pour i de 1 à n faire
        Pour j de 0 à i-1 faire
            # Premier et dernier élément de chaque ligne
            Si (j = 0) ou (j =i-1) alors
                m[i][j] <- 1                  
            # Calcul des éléments internes
            Sinon
                m[i][j] <- m[i-1][j] + m[i-1][j-1]
            Fin si
        Fin pour
    Fin pour
    # Affichage du triangle
    Pour i de 1 à n faire
        Pour j de 0 à i-1:
            Ecrire(m[i][j])
        Fin pour
        Ecrire()
    Fin pour
Fin

Procédure trianglepascal(m:matrice, n:entier)

# Remplissage du triangle

Pour i de 1 à n faire

Pour j de 0 à i-1 faire

# Premier et dernier élément de chaque ligne

Si (j = 0) ou (j =i-1) alors

m[i][j] <- 1

# Calcul des éléments internes

Sinon

m[i][j] <- m[i-1][j] + m[i-1][j-1]

Fin si

Fin pour

# Affichage du triangle

Pour i de 1 à n faire

Pour j de 0 à i-1:

Ecrire(m[i][j])

Fin pour

Ecrire()

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
j	entier

La procédure remplir

Cette procédure parcourt les lignes du triangle de Pascal, calcule pour chacune une somme particulière et le nombre de valeurs impaires correspondantes, enregistre ces résultats dans le tableau tfs, puis affiche son contenu.

Procédure remplir(m:matrice,n:entier,tfs:tab)
    Pour i de 1 à n+1 faire
        somme <- 0
        nbr_impaires <- 0
        # Parcours de la moitié de la ligne
        Pour j de 0 à (i div 2 + 1) faire
            # Calcul de la somme
            somme <- somme + m[i-j][j]
            # Comptage des nombres impairs
            Si m[i-j][j] mod 2 != 0 alors
                nbr_impaires <- nbr_impaires + 1
            Fin si
        # Création d'un nouvel enregistrement
        enregistrement = Enregistrement(
            Fib:entier,
            Ste=entier
        )
        # Stockage des résultats
        enregistrement['Fib'] <- somme
        enregistrement['Ste'] <- nbr_impaires
        # Insertion dans le tableau
        tfs[i] <- enregistrement
    # Affichage du contenu du tableau
    Pour i de 1 à n+1 faire
        Ecrire(tfs[i]['Fib'], ',', tfs[i]['Ste'])
    Finpour
 Fin

Procédure remplir(m:matrice,n:entier,tfs:tab)

Pour i de 1 à n+1 faire

somme <- 0

nbr_impaires <- 0

# Parcours de la moitié de la ligne

Pour j de 0 à (i div 2 + 1) faire

# Calcul de la somme

somme <- somme + m[i-j][j]

# Comptage des nombres impairs

Si m[i-j][j] mod 2 != 0 alors

nbr_impaires <- nbr_impaires + 1

Fin si

# Création d'un nouvel enregistrement

enregistrement = Enregistrement(

Fib:entier,

Ste=entier

)

# Stockage des résultats

enregistrement['Fib'] <- somme

enregistrement['Ste'] <- nbr_impaires

# Insertion dans le tableau

tfs[i] <- enregistrement

# Affichage du contenu du tableau

Pour i de 1 à n+1 faire

Ecrire(tfs[i]['Fib'], ',', tfs[i]['Ste'])

Finpour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
j	entier
somme	entier
nbr_impaires	entier

La procédure remplir_fidele

Cette procédure crée le fichier Fidele.txt, y enregistre les matricules des abonnés fidèles saisis par l'utilisateur, à raison d'un matricule par ligne, puis ferme le fichier.

Procédure remplir_fidele()
    Ecrire("Remplir le fichier Fidèle")
    # Ouverture du fichier en écriture
    Ouvrir("Fidele.txt" , f , "w")
    # Saisie du nombre d'abonnés
    Ecrire("donner le nombre des abonnés fideles :")
    Lire(n)
    # Saisie des matricules
    Pour i de 0 à n-1 faire
        Ecrire("donner une matricule formée de 4 chiffres :")
        Lire(matricule)
        Ecrire(f, matricule + '\n')
    Fin pour
    # Fermeture du fichier
    Fermer(f)    
Fin

Procédure remplir_fidele()

Ecrire("Remplir le fichier Fidèle")

# Ouverture du fichier en écriture

Ouvrir("Fidele.txt" , f , "w")

# Saisie du nombre d'abonnés

Ecrire("donner le nombre des abonnés fideles :")

Lire(n)

# Saisie des matricules

Pour i de 0 à n-1 faire

Ecrire("donner une matricule formée de 4 chiffres :")

Lire(matricule)

Ecrire(f, matricule + '\n')

Fin pour

# Fermeture du fichier

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier texte
n	entier
i	entier
matricule	chaîne des caractères

La fonction somme_chiffres

Cette fonction calcule et retourne la somme des chiffres d’un nombre donné sous forme de chaîne de caractères.

Fonction somme_chiffres(ch:chaine):entier
    s <- 0
    Pour i de 0 à long(ch)-1 faire
        s <- s+Valeur(ch[i])
    Fin pour
    retourner s    
Fin

Fonction somme_chiffres(ch:chaine):entier

s <- 0

Pour i de 0 à long(ch)-1 faire

s <- s+Valeur(ch[i])

Fin pour

retourner s

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
s	entier

La procédure remplir_fidele

Cette procédure crée le fichier Fidele.txt, y enregistre les matricules des abonnés fidèles saisis par l'utilisateur, à raison d'un matricule par ligne, puis ferme le fichier.

Procédure remplir_fidele()
    Ecrire("Remplir le fichier Fidèle")
    # Ouverture du fichier en écriture
    Ouvrir("Fidele.txt" , f , "w")
    # Saisie du nombre d'abonnés
    Ecrire("donner le nombre des abonnés fideles :")
    Lire(n)
    # Saisie des matricules
    Pour i de 0 à n-1 faire
        Ecrire("donner une matricule formée de 4 chiffres :")
        Lire(matricule)
        Ecrire(f, matricule + '\n')
    Fin pour
    # Fermeture du fichier
    Fermer(f)    
Fin

Procédure remplir_fidele()

Ecrire("Remplir le fichier Fidèle")

# Ouverture du fichier en écriture

Ouvrir("Fidele.txt" , f , "w")

# Saisie du nombre d'abonnés

Ecrire("donner le nombre des abonnés fideles :")

Lire(n)

# Saisie des matricules

Pour i de 0 à n-1 faire

Ecrire("donner une matricule formée de 4 chiffres :")

Lire(matricule)

Ecrire(f, matricule + '\n')

Fin pour

# Fermeture du fichier

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier texte
n	entier
i	entier
matricule	chaîne des caractères

Solution en Python

# Importation des fonctions load et dump du module pickle
# dump : permet d'enregistrer des données dans un fichier binaire
# load : permet de lire des données depuis un fichier binaire
from pickle import load, dump

# Création d'un dictionnaire représentant un enregistrement
# contenant un nombre n et sa base b
enregistrement = dict(
        n=int(),
        b=int()
        )

# -------------------------------------------------------
# Fonction de saisie d'un entier strictement supérieur à 10
# -------------------------------------------------------
def saisie_n():
    n = int(input('saisir n > 10: '))
    while n <= 10:
        n = int(input('saisir n > 10: '))
    return n

# -------------------------------------------------------
# Fonction qui calcule la somme des facteurs premiers
# distincts d'un entier k
# -------------------------------------------------------
def sommefacteurs(k):
    s = 0       # Somme des facteurs
    i = 2       # Premier diviseur à tester
    j = 0       # Dernier facteur ajouté

    while i <= k // 2:
        if k % i == 0:
            # Ajouter le facteur seulement s'il n'a pas été ajouté
            if i != j:
                s = s + i
                j = i
            # Supprimer ce facteur de k
            k = k // i
        else:
            # Passer au diviseur suivant
            i = i + 1
    return s

# -------------------------------------------------------
# Fonction qui calcule la somme des chiffres d'un nombre
# représenté sous forme de chaîne en base 16 maximum
# -------------------------------------------------------
def somme_chiffres(ch):
    s = 0

    for i in range(len(ch)):
        # Si le caractère est un chiffre de 0 à 9
        if '0' <= ch[i] <= '9':
            s = s + int(ch[i])

        # Si le caractère est une lettre de A à F
        elif 'A' <= ch[i] <= 'F':
            s = s + (ord(ch[i]) - 55)

    return s

# -------------------------------------------------------
# Fonction qui convertit un nombre décimal en base b
# puis vérifie si la somme de ses chiffres est égale à b
# -------------------------------------------------------
def test_nombre_fort(n, b):

    # Ensemble des symboles utilisés pour les bases jusqu'à 16
    chiffres = "0123456789ABCDEF"

    resultat = ""

    # Conversion du nombre n en base b
    while n > 0:
        reste = n % b
        resultat = chiffres[reste] + resultat
        n = n // b

    # Vérifier si la somme des chiffres obtenus est égale à la base
    return somme_chiffres(resultat) == b

# -------------------------------------------------------
# Recherche des nombres forts entre 10 et n
# et enregistrement dans un fichier binaire
# -------------------------------------------------------
def NbrFort(n):

    # Ouverture du fichier en écriture binaire
    f = open("NF.dat", "wb")

    # Parcours des entiers de 10 à n
    for i in range(10, n + 1):

        # Calcul de la somme des facteurs premiers distincts
        b = sommefacteurs(i)

        # La base doit être comprise entre 2 et 16
        if 2 <= b <= 16:

            # Vérification si le nombre est un nombre fort
            if test_nombre_fort(i, b):

                # Affichage du nombre et de sa base
                print(i, ' ', b)

                # Remplissage de l'enregistrement
                enregistrement['n'] = i
                enregistrement['b'] = b

                # Sauvegarde dans le fichier
                dump(enregistrement, f)

    # Fermeture du fichier
    f.close()

# -------------------------------------------------------
# Programme principal
# -------------------------------------------------------

# Saisie de la borne supérieure
n = saisie_n()

# Recherche et enregistrement des nombres forts
NbrFort(n)

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

# Importation des fonctions load et dump du module pickle

# dump : permet d'enregistrer des données dans un fichier binaire

# load : permet de lire des données depuis un fichier binaire

from pickle import load, dump

# Création d'un dictionnaire représentant un enregistrement

# contenant un nombre n et sa base b

enregistrement = dict(

n=int(),

b=int()

)

# -------------------------------------------------------

# Fonction de saisie d'un entier strictement supérieur à 10

# -------------------------------------------------------

def saisie_n():

n = int(input('saisir n > 10: '))

while n <= 10:

n = int(input('saisir n > 10: '))

return n

# -------------------------------------------------------

# Fonction qui calcule la somme des facteurs premiers

# distincts d'un entier k

# -------------------------------------------------------

def sommefacteurs(k):

s = 0 # Somme des facteurs

i = 2 # Premier diviseur à tester

j = 0 # Dernier facteur ajouté

while i <= k // 2:

if k % i == 0:

# Ajouter le facteur seulement s'il n'a pas été ajouté

if i != j:

s = s + i

j = i

# Supprimer ce facteur de k

k = k // i

else:

# Passer au diviseur suivant

i = i + 1

return s

# -------------------------------------------------------

# Fonction qui calcule la somme des chiffres d'un nombre

# représenté sous forme de chaîne en base 16 maximum

# -------------------------------------------------------

def somme_chiffres(ch):

s = 0

for i in range(len(ch)):

# Si le caractère est un chiffre de 0 à 9

if '0' <= ch[i] <= '9':

s = s + int(ch[i])

# Si le caractère est une lettre de A à F

elif 'A' <= ch[i] <= 'F':

s = s + (ord(ch[i]) - 55)

return s

# -------------------------------------------------------

# Fonction qui convertit un nombre décimal en base b

# puis vérifie si la somme de ses chiffres est égale à b

# -------------------------------------------------------

def test_nombre_fort(n, b):

# Ensemble des symboles utilisés pour les bases jusqu'à 16

chiffres = "0123456789ABCDEF"

resultat = ""

# Conversion du nombre n en base b

while n > 0:

reste = n % b

resultat = chiffres[reste] + resultat

n = n // b

# Vérifier si la somme des chiffres obtenus est égale à la base

return somme_chiffres(resultat) == b

# -------------------------------------------------------

# Recherche des nombres forts entre 10 et n

# et enregistrement dans un fichier binaire

# -------------------------------------------------------

def NbrFort(n):

# Ouverture du fichier en écriture binaire

f = open("NF.dat", "wb")

# Parcours des entiers de 10 à n

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

# Calcul de la somme des facteurs premiers distincts

b = sommefacteurs(i)

# La base doit être comprise entre 2 et 16

if 2 <= b <= 16:

# Vérification si le nombre est un nombre fort

if test_nombre_fort(i, b):

# Affichage du nombre et de sa base

print(i, ' ', b)

# Remplissage de l'enregistrement

enregistrement['n'] = i

enregistrement['b'] = b

# Sauvegarde dans le fichier

dump(enregistrement, f)

# Fermeture du fichier

f.close()

# -------------------------------------------------------

# Programme principal

# -------------------------------------------------------

# Saisie de la borne supérieure

n = saisie_n()

# Recherche et enregistrement des nombres forts

NbrFort(n)

Exécution du programme

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

Problème suite de Fibonacci – Bac théorique – Section informatique – 2026

Bac Info 11-06-26

Nombre Fort – Bac théorique – Section informatique – 2026

Bac Info 09-06-26

Appréciation des clients – Bac théorique – Section informatique – 2026

Bac Info 09-06-26

Matrice – Bac pratique – Section informatique – 2026

Bac Info 08-06-26

Projet Arduino : Construction d’une poubelle intelligente

Arduino 04-06-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 13128vues

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

Arduino 12521vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 10653vues

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

Arduino 10206vues

Allumer une LED par la carte ESP32

ESP32 10038vues

Construction des robots

Tutoriels plus commentés

Construire un GPS commandé par Arduino

Arduino 86 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 52 commentaires

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

Arduino 32 commentaires

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

Composants 22 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Problème suite de Fibonacci – Bac théorique – Section informatique – 2026

Sujet (Algo et programmation - Bac 2026)

Solution Algorithmique

Algorithme du programme Principal

La fonction saisie_n

La procédure trianglepascal

La procédure remplir

La procédure remplir_fidele

La fonction somme_chiffres

La procédure remplir_fidele

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