Matrice – Bac pratique – Section informatique – 2010

Bac Info 10-12-25

181 0

Sujet (Algo et programmation - Bac 2010)

On se propose de stocker les ooordormées x et y de n points du plan (avec 3 <= n <= 10) dans un tableau T à deux dimensions. Ces points sont nommés At B, C, D, E ... . Les noms des points constituent les indices des colonnes. Les coordonnées de ces points sont rangées dans le tableau de la manière suivante : - la ligne l contiendra les abscisses - la ligne 2 contiendra les ordonnées Exemple : Pour n = 4, si on donne aux quatre points A B, C, D les coordonnées. suivantes. : A(-2, 3) ; 8(3, -2) ; C(3,3)} e D(5, -2). alors le tableau T sera rempli comme suit :

On se propose par la suite d'utiliser ce tableau pour calculer les distances entre Le différents points et les ranger dans une matrice carrée M d'ordre n où les indices des lignes et des colonnes sont les noms des n points.

On rappelle que la distance d entre deux points de coordonnées respectives {x1, y1) et (x2, y2 ) est donnée par la formule suivante :

Pour le tableau T de l'exemple .on obtient la matrice M suivante :

Travail demandé :

Ecrire un programme Python qui permet de :

- saisir un entier n tel que 3<=n<=10.

- remplir un tableau T par les coordonnées de n points

- en tenant compte des particularités constatées précédemment, calculer les distances entre les différents points et les ranger dans la matrice M.

- afficher le contenu de la matrice M.

- saisir le nom d'un des points du tableau T, puis d'afficher le nom du point qui lui est le plus proche. Dans le- cas où. il y en a plusieurs, afficher le premier rencontré.

exemple :

Pour la matrice M de l'exemple précédant, si le point saisi est "C" alors, le programme affichera : Le premier point le plus proche de C est : A

Solution Algorithmique

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

- la fonction saisie()

- la procédure remplir_matrice_T()

- la procédure afficher_matrice_T()

- la fonction calcul_distance()

- la procédure remplir_matrice_M()

- la procédure afficher_matrice_M()

- la procédure saisie_point()

- la procédure point_plus_proche()

Algorithme du programme Principal

Algorithme matrice_points 
Debut 
     n <- saisie() # Saisie du nombre de points
     remplir_matrice_T(t, n) # Saisie des coordonnées
     afficher_matrice_T(t, n) # Affichage de T
     remplir_matrice_M(m, n) # Calcul des distances
     afficher_matrice_M(m, n) # Affichage de M
     point <- saisie_point(n) # Choix du point
     Ecrire('Le premier point le plus proche de ' + point + ' est: ' + point_plus_proche(point, m, n))
Fin

Algorithme matrice_points

Debut

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

remplir_matrice_T(t, n) # Saisie des coordonnées

afficher_matrice_T(t, n) # Affichage de T

remplir_matrice_M(m, n) # Calcul des distances

afficher_matrice_M(m, n) # Affichage de M

point <- saisie_point(n) # Choix du point

Ecrire('Le premier point le plus proche de ' + point + ' est: ' + point_plus_proche(point, m, n))

Fin

Déclaration des objets

Objet	Type / Nature
n	entier
t	matrice
m	matrice
point	caractère

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 3<=n<=10: ')
    lire (n)
    # Tant que la valeur n'est pas dans l’intervalle demandé, on redemande
    Tant que (n < 3) ou (n > 10) faire
        Ecrire('donner n tel que 3<=n<=10: ') 
        lire (n)
    Fin tant que
    retourner n
fin

Fonction saisie(): entier

Ecrire('donner n tel que 3<=n<=10: ')

lire (n)

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

Tant que (n < 3) ou (n > 10) faire

Ecrire('donner n tel que 3<=n<=10: ')

lire (n)

Fin tant que

retourner n

fin

Déclaration des objets

Objet	Type / Nature
n	entier

La procédure remplir_matrice_T

Cette fonction a pour rôle de remplir la matrice t avec les coordonnées de n points, saisis par l’utilisateur.

La matrice t est organisée comme suit :

- t[0][i] contient l’abscisse du point numéro i

- t[1][i] contient son ordonnée

Les points sont nommés automatiquement A, B, C, ... grâce au code ASCII (A = 65).

Ainsi, pour chaque point (A, B, C, …), le programme demande : son abscisse, son ordonnée et stocke ces valeurs dans la matrice.

Procédure remplir_matrice_T(t:matrice;n:entier):   
    code_ASCII <- 65   # 65 correspond à 'A'
    Pour i de 0 à n-1 faire
        # Saisie de l'abscisse du point A, B, C, ...
        Ecrire('donner Abscisse du point ' + chr(code_ASCII + i) + ': ')
        lire(t[0][i])
        # Saisie de l'ordonnée
        Ecrire('donner Ordonnee du point ' + chr(code_ASCII + i) + ': ')
        lire(t[1][i])
    Fin pour   
Fin

Procédure remplir_matrice_T(t:matrice;n:entier):

code_ASCII <- 65 # 65 correspond à 'A'

Pour i de 0 à n-1 faire

# Saisie de l'abscisse du point A, B, C, ...

Ecrire('donner Abscisse du point ' + chr(code_ASCII + i) + ': ')

lire(t[0][i])

# Saisie de l'ordonnée

Ecrire('donner Ordonnee du point ' + chr(code_ASCII + i) + ': ')

lire(t[1][i])

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
code_ASCII	entier
i	entier

La procédure afficher_matrice_T

Cette procédure sert à afficher la matrice T, qui contient les coordonnées des points.

Il montre successivement :

- les noms des points (A, B, C, …)

- la ligne des abscisses (t[0][i])

- la ligne des ordonnées (t[1][i])

L’affichage se fait sous forme d’un tableau lisible.

Procédure afficher_matrice_T(t:matrice ; n:entier)
    Ecrire('****** Matrice T ******')
    code_ASCII <- 65

    # Affichage des noms des points
    Pour i de 0 à n-1 faire
        Ecrire(chr(code_ASCII + i), end='  ')
    Fin pour
    Ecrire() # retour a la ligne

    # Affichage des abscisses
    Pour i de 0 à n-1 faire 
       Ecrire(t[0][i])
    Fin pour
    Ecrire() # retour a la ligne

    # Affichage des ordonnées
    Pour i de 0 à n-1 faire
        Ecrire(t[1][i])
    Finpour
    Ecrire() # retou a la ligne
Fin

Procédure afficher_matrice_T(t:matrice ; n:entier)

Ecrire('****** Matrice T ******')

code_ASCII <- 65

# Affichage des noms des points

Pour i de 0 à n-1 faire

Ecrire(chr(code_ASCII + i), end=' ')

Fin pour

Ecrire() # retour a la ligne

# Affichage des abscisses

Pour i de 0 à n-1 faire

Ecrire(t[0][i])

Fin pour

Ecrire() # retour a la ligne

# Affichage des ordonnées

Pour i de 0 à n-1 faire

Ecrire(t[1][i])

Finpour

Ecrire() # retou a la ligne

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
code_ASCII	entier

La fonction calcul_distance

Cette fonction calcule et renvoie la distance euclidienne entre deux points du plan.

Les points ont pour coordonnées : point 1 : (x1, y1) et point 2 : (x2, y2)

Fonction calcul_distance (x1:entier, x2:entier, y1:entier, y2:entier):reel    
    retourner RacineCarre((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
Fin

Fonction calcul_distance (x1:entier, x2:entier, y1:entier, y2:entier):reel

retourner RacineCarre((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))

Fin

La procédure remplir_matrice_M

Cette procédure sert à afficher la matrice M, qui contient les distances entre tous les points.

1- Elle affiche les noms des points (A, B, C, …) sur la première ligne.

2- Pour chaque point (ligne) : elle affiche d’abord son nom (A, B, C, …), puis toutes les distances entre ce point et les autres (m[i][j]).

Procédure remplir_matrice_M(m:matrice; n:entier)
    Pour i de 0 à n-1 faire
        Pour j de 0 à n-1 faire
            # Distance entre le point i et le point j formatée sur 1 chiffre après la virgule
            m[i][j] <- calcul_distance(t[0][i], t[0][j], t[1][i], t[1][j])
        Finpour
    Finpour 
Fin

Procédure remplir_matrice_M(m:matrice; n:entier)

Pour i de 0 à n-1 faire

Pour j de 0 à n-1 faire

# Distance entre le point i et le point j formatée sur 1 chiffre après la virgule

m[i][j] <- calcul_distance(t[0][i], t[0][j], t[1][i], t[1][j])

Finpour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
j	entier

La procédure afficher_matrice_M

Cette procédure sert à afficher la matrice M, qui contient les distances entre tous les points.

1- Elle affiche les noms des points (A, B, C, …) sur la première ligne.

2- Pour chaque point (ligne) : elle affiche d’abord son nom (A, B, C, …), puis toutes les distances entre ce point et les autres (m[i][j]).

Procédure afficher_matrice_M(m:matrice; n:entier)
    Ecrire('****** Matrice M ******')
    code_ASCII <- 65

    # Première ligne : noms des points
    Ecrire('    ')
    Pour i de 0 à n-1 faire
        Ecrire(chr(code_ASCII + i)) # afficher les points A , B, C ,...
    Fin pour
    Ecrire() # retour a la ligne

    # Lignes suivantes : index + valeurs
    Pour i de 0 à n-1 faire
        Ecrire(chr(code_ASCII + i)) # afficher les points A , B, C ,...
        Pour j de 0 à n-1 faire
            Ecrire(m[i][j])
        Finpour
        Ecrire() # retour a la ligne
    Finpour 
Fin

Procédure afficher_matrice_M(m:matrice; n:entier)

Ecrire('****** Matrice M ******')

code_ASCII <- 65

# Première ligne : noms des points

Ecrire(' ')

Pour i de 0 à n-1 faire

Ecrire(chr(code_ASCII + i)) # afficher les points A , B, C ,...

Fin pour

Ecrire() # retour a la ligne

# Lignes suivantes : index + valeurs

Pour i de 0 à n-1 faire

Ecrire(chr(code_ASCII + i)) # afficher les points A , B, C ,...

Pour j de 0 à n-1 faire

Ecrire(m[i][j])

Finpour

Ecrire() # retour a la ligne

Finpour

Fin

Déclaration des objets

Objet	Type / Nature
code_ASCII	entier
i	entier
j	entier

La fonction saisie_point

Ce programme sert à saisir un point valide, c’est-à-dire une lettre représentant un point parmi : A, B, C, …

Fonction saisie_point(n:entier): caractere    
    Ecrire('donner le nom du point entre A et ' + chr(65 + n) + ' : ')
    lire(point)
    # Vérification de validité : doit être une lettre entre A et A+n
    Tant que (ord(point) < 65) ou (ord(point) > 65 + n) faire
        Ecrire('donner le nom du point entre A et ' + chr(65 + n) + ' : ') 
        lire(point)
    Fin tantque
    retourner point  
fin

Fonction saisie_point(n:entier): caractere

Ecrire('donner le nom du point entre A et ' + chr(65 + n) + ' : ')

lire(point)

# Vérification de validité : doit être une lettre entre A et A+n

Tant que (ord(point) < 65) ou (ord(point) > 65 + n) faire

Ecrire('donner le nom du point entre A et ' + chr(65 + n) + ' : ')

lire(point)

Fin tantque

retourner point

fin

Déclaration des objets

Objet	Type / Nature
point	caractère

La fonction point_plus_proche

Cette fonction recherche et retourne le nom du point le plus proche d’un point donné, en comparant les distances contenues dans la matrice M.

Fonction point_plus_proche(point:caractere, m:matrice, n:entier): caractere    
    indice_proche <- 0
    # Avancer jusqu'à trouver une distance différente de 0 (éviter A → A = 0)
    Tant que m[indice_proche][ord(point) - 65] == 0 faire
        indice_proche <- indice_proche + 1
    Fin tant que 
    # Recherche de la distance strictement minimale
    Pour i de 1 à n-1 faire
        Si (m[i][ord(point) - 65] != 0) et (m[i][ord(point) - 65] < m[indice_proche][ord(point) - 65]) alors
            indice_proche <- i
        Finsi
    Finpour
    # Retourne le nom du point correspondant
    retourner chr(indice_proche + 65)  
Fin

Fonction point_plus_proche(point:caractere, m:matrice, n:entier): caractere

indice_proche <- 0

# Avancer jusqu'à trouver une distance différente de 0 (éviter A → A = 0)

Tant que m[indice_proche][ord(point) - 65] == 0 faire

indice_proche <- indice_proche + 1

Fin tant que

# Recherche de la distance strictement minimale

Pour i de 1 à n-1 faire

Si (m[i][ord(point) - 65] != 0) et (m[i][ord(point) - 65] < m[indice_proche][ord(point) - 65]) alors

indice_proche <- i

Finsi

Finpour

# Retourne le nom du point correspondant

retourner chr(indice_proche + 65)

Fin

Déclaration des objets

Objet	Type / Nature
indice_proche	entier
i	entier

Solution en Python

from numpy import *

lignes = 50
colonnes = 50

# Matrice T : contient les coordonnées des points (t[0] = abscisses, t[1] = ordonnées)
t = array([[int()] * colonnes] * lignes)

# Matrice M : contiendra les distances entre tous les points
m = array([[float()] * colonnes] * lignes)


# ===================================
#  Fonction pour saisir un entier n
# ===================================
def saisie():
    n = int(input('donner n telque 3<=n<=10: '))
    # Tant que n n’est pas dans l’intervalle demandé, on redemande
    while (n < 3) or (n > 10):
        n = int(input('donner n telque 3<=n<=10: '))
    return n    


# =========================================
#  Remplir la matrice T avec les coordonnées
# =========================================
def remplir_matrice_T(t, n):
    code_ASCII = 65   # 65 correspond à 'A'
    for i in range(n):
        # Saisie de l'abscisse du point A, B, C, ...
        t[0][i] = int(input('donner Abscisse du point ' + chr(code_ASCII + i) + ': '))
        # Saisie de l'ordonnée
        t[1][i] = int(input('donner Ordonnee du point ' + chr(code_ASCII + i) + ': '))


# =========================================
#  Affichage de la matrice T
# =========================================
def afficher_matrice_T(t, n):
    print('****** Matrice T ******')
    code_ASCII = 65

    # Affichage des noms des points
    for i in range(n):
        print(chr(code_ASCII + i), end='  ')
    print()

    # Affichage des abscisses
    for i in range(n):
        print(t[0][i], end='  ')
    print()

    # Affichage des ordonnées
    for i in range(n):
        print(t[1][i], end='  ')
    print()


# =========================================
#  Calcul de la distance entre deux points
# =========================================
def calcul_distance(x1, x2, y1, y2):
    # Distance euclidienne : √((x2 − x1)² + (y2 − y1)²)
    return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))


# =========================================
#  Construction de la matrice des distances M
# =========================================
def remplir_matrice_M(m, n):
    for i in range(n):
        for j in range(n):
            # Distance entre le point i et le point j formatée sur 1 chiffre après la virgule
            m[i][j] = "{:.1f}".format(calcul_distance(t[0][i], t[0][j], t[1][i], t[1][j]))


# =========================================
#  Affichage de la matrice M
# =========================================
def afficher_matrice_M(m, n):
    print('****** Matrice M ******')
    code_ASCII = 65

    # Première ligne : noms des points
    print(end='    ')
    for i in range(n):
        print(chr(code_ASCII + i), end='    ')
    print()

    # Lignes suivantes : index + valeurs
    for i in range(n):
        print(chr(code_ASCII + i), end='  ')
        for j in range(n):
            print(m[i][j], end='  ')
        print()


# =========================================
#  Saisie d’un point dont on cherche le voisin le plus proche
# =========================================
def saisie_point(n):
    point = input('donner le nom du point entre A et ' + chr(65 + n) + ' : ')
    # Vérification de validité : doit être une lettre entre A et A+n
    while (ord(point) < 65) or (ord(point) > 65 + n):
        point = input('donner le nom du point entre A et ' + chr(65 + n) + ' : ')
    return point    


# =========================================
#  Trouver le point le plus proche d’un point donné
# =========================================
def point_plus_proche(point, m, n):
    indice_proche = 0
    # Avancer jusqu'à trouver une distance différente de 0 (éviter A → A = 0)
    while m[indice_proche][ord(point) - 65] == 0:
        indice_proche += 1

    # Recherche de la distance strictement minimale
    for i in range(1, n):
        if (m[i][ord(point) - 65] != 0) and (m[i][ord(point) - 65] < m[indice_proche][ord(point) - 65]):
            indice_proche = i

    # Retourne le nom du point correspondant
    return chr(indice_proche + 65)


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

n = saisie()                        # Saisie du nombre de points
remplir_matrice_T(t, n)             # Saisie des coordonnées
afficher_matrice_T(t, n)            # Affichage de T
remplir_matrice_M(m, n)             # Calcul des distances
afficher_matrice_M(m, n)            # Affichage de M
point = saisie_point(n)             # Choix du point
print('Le premier point le plus proche de ' + point + ' est: ' + point_plus_proche(point, m, 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

125

126

127

128

129

130

131

132

133

134

135

136

137

from numpy import *

lignes = 50

colonnes = 50

# Matrice T : contient les coordonnées des points (t[0] = abscisses, t[1] = ordonnées)

t = array([[int()] * colonnes] * lignes)

# Matrice M : contiendra les distances entre tous les points

m = array([[float()] * colonnes] * lignes)

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

# Fonction pour saisir un entier n

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

def saisie():

n = int(input('donner n telque 3<=n<=10: '))

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

while (n < 3) or (n > 10):

n = int(input('donner n telque 3<=n<=10: '))

return n

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

# Remplir la matrice T avec les coordonnées

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

def remplir_matrice_T(t, n):

code_ASCII = 65 # 65 correspond à 'A'

for i in range(n):

# Saisie de l'abscisse du point A, B, C, ...

t[0][i] = int(input('donner Abscisse du point ' + chr(code_ASCII + i) + ': '))

# Saisie de l'ordonnée

t[1][i] = int(input('donner Ordonnee du point ' + chr(code_ASCII + i) + ': '))

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

# Affichage de la matrice T

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

def afficher_matrice_T(t, n):

print('****** Matrice T ******')

code_ASCII = 65

# Affichage des noms des points

for i in range(n):

print(chr(code_ASCII + i), end=' ')

print()

# Affichage des abscisses

for i in range(n):

print(t[0][i], end=' ')

print()

# Affichage des ordonnées

for i in range(n):

print(t[1][i], end=' ')

print()

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

# Calcul de la distance entre deux points

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

def calcul_distance(x1, x2, y1, y2):

# Distance euclidienne : √((x2 − x1)² + (y2 − y1)²)

return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))

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

# Construction de la matrice des distances M

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

def remplir_matrice_M(m, n):

for i in range(n):

for j in range(n):

# Distance entre le point i et le point j formatée sur 1 chiffre après la virgule

m[i][j] = "{:.1f}".format(calcul_distance(t[0][i], t[0][j], t[1][i], t[1][j]))

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

# Affichage de la matrice M

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

def afficher_matrice_M(m, n):

print('****** Matrice M ******')

code_ASCII = 65

# Première ligne : noms des points

print(end=' ')

for i in range(n):

print(chr(code_ASCII + i), end=' ')

print()

# Lignes suivantes : index + valeurs

for i in range(n):

print(chr(code_ASCII + i), end=' ')

for j in range(n):

print(m[i][j], end=' ')

print()

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

# Saisie d’un point dont on cherche le voisin le plus proche

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

def saisie_point(n):

point = input('donner le nom du point entre A et ' + chr(65 + n) + ' : ')

# Vérification de validité : doit être une lettre entre A et A+n

while (ord(point) < 65) or (ord(point) > 65 + n):

point = input('donner le nom du point entre A et ' + chr(65 + n) + ' : ')

return point

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

# Trouver le point le plus proche d’un point donné

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

def point_plus_proche(point, m, n):

indice_proche = 0

# Avancer jusqu'à trouver une distance différente de 0 (éviter A → A = 0)

while m[indice_proche][ord(point) - 65] == 0:

indice_proche += 1

# Recherche de la distance strictement minimale

for i in range(1, n):

if (m[i][ord(point) - 65] != 0) and (m[i][ord(point) - 65] < m[indice_proche][ord(point) - 65]):

indice_proche = i

# Retourne le nom du point correspondant

return chr(indice_proche + 65)

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

# PROGRAMME PRINCIPAL

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

n = saisie() # Saisie du nombre de points

remplir_matrice_T(t, n) # Saisie des coordonnées

afficher_matrice_T(t, n) # Affichage de T

remplir_matrice_M(m, n) # Calcul des distances

afficher_matrice_M(m, n) # Affichage de M

point = saisie_point(n) # Choix du point

print('Le premier point le plus proche de ' + point + ' est: ' + point_plus_proche(point, m, 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

Sujet Matrice – Bac théorique – Section informatique – 2025

Bac Info 29-01-26

Nombre de Keith – Bac théorique – Section informatique – 2025

Bac Info 29-01-26

Pistolet de FURY – Bac théorique – Section informatique – 2025

Bac Info 27-01-26

Segmenter Matrice – Bac théorique – Section informatique – 2025

Bac SC 27-01-26

Suite Padovan – Bac théorique – Section informatique – 2025

Bac Info 27-01-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11129vues

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

Arduino 10691vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9430vues

Allumer une LED par la carte ESP32

ESP32 9045vues

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

Arduino 9038vues

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 28 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 24 commentaires

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

Composants 20 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Matrice – Bac pratique – Section informatique – 2010

Sujet (Algo et programmation - Bac 2010)

Solution Algorithmique

Algorithme du programme Principal

La fonction saisir

La procédure remplir_matrice_T

La procédure afficher_matrice_T

La fonction calcul_distance

La procédure remplir_matrice_M

La procédure afficher_matrice_M

La fonction saisie_point

La fonction point_plus_proche

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