Problème Matrice – Bac théorique – Section informatique – 2023

Bac Info 21-01-26

168 0

Sujet (Algo et programmation - Bac 2023)

Soit M une matrice de NL x NC entiers (avec 3 ≤ NL ≤ 15 et 3 ≤ NC ≤ 15) dont les éléments d’une même colonne sont distincts.

On se propose de déterminer la valeur minimale des maximums des colonnes de la matrice M appelée MiniMax. Pour ce faire on détermine le maximum de chaque colonne puis on détermine la valeur minimale des maximums obtenus.

Travail demandé :

1- Ecrire un algorithme d’une fonction Max_Colonne(NL, j, M) qui, pour une colonne j de la matrice M, permet de retourner le numéro de la ligne de son maximum.

2- Ecrire un algorithme d’une procédure nommée Recherche_Minimax qui permet de déterminer et d’afficher les positions de MiniMax dans la matrice M en utilisant le module Max_Colonne et en appliquant le procédé suivant :

- Remplir un tableau d’enregistrements T par les positions des maximums des colonnes de la matrice M. Chaque enregistrement du tableau T correspond au maximum d’une colonne et il est formé des deux champs suivants :

C : Le numéro de la colonne de la matrice M où se trouve la valeur maximale

L : Le numéro de la ligne de la matrice M où se trouve la valeur maximale

- Chercher et afficher la valeur du MiniMax.

- Afficher à partir du tableau T, la(les) position(s) du MiniMax. Exemple :

Pour NL = 5 , NC = 6 et la matrice M suivante :

La procédure Recherche_Minimax affiche :

MiniMax = 300

Les positions sont : (2,0) (3,4)

En effet, MiniMax est égale à 300 et se trouve dans la colonne numéro 2, la ligne numéro 0 et la colonne numéro 3, la ligne numéro 4 dans la matrice M.

Solution Algorithmique

Dans cet algorithme, On va utiliser quatre fonctions et cinq procédures :

- la fonction saisie()

- la fonction test_distinct()

- la procédure remplir_matrice()

- la procédure afficher_matrice()

- la fonction max_colonne()

- la fonction determiner_minimax()

- la procédure recherche_elt_minimax()

- la procédure recherche_minimax()

- la procédure afficher_tableau()

Algorithme du programme Principal

Algorithme matrice
Debut 
      nl <- saisie(3, 15) # nombre de lignes à saisir
      nc <- saisie(3, 15) # nombre de colonnes à saisir
      remplir_matrice(m, nl, nc) # remplissage de la matrice
      afficher_matrice(m, nl, nc) # affichage de la matrice
      recherche_minimax(m, t, nl, nc) # recherche et affichage du MiniMax
Fin

Algorithme matrice

Debut

nl <- saisie(3, 15) # nombre de lignes à saisir

nc <- saisie(3, 15) # nombre de colonnes à saisir

remplir_matrice(m, nl, nc) # remplissage de la matrice

afficher_matrice(m, nl, nc) # affichage de la matrice

recherche_minimax(m, t, nl, nc) # recherche et affichage du MiniMax

Fin

Déclaration des objets

Objet	Type / Nature
nl	entier
nc	entier
m	matrice
t	tableau des enregistrements

La fonction saisie

Cette fonction permet de saisir et retourner un entier compris entre binf et bsup en contrôlant la validité de la saisie.

Fonction saisie(binf:entier,bsup:entier):entier
    # Demande à l'utilisateur de saisir un entier n dans l'intervalle [binf, bsup]
    Ecrire('donner un entier dans [',binf,' , ',bsup),'] : ') 
    Lire(n) 
    # Vérification de la validité de la saisie
    Tant que Non (binf <= n <= bsup) faire
        Ecrire('donner un entier dans [',binf,' , ',bsup,'] : ') 
        Lire(n) 
    Fin tant que
    # Retourne la valeur valide saisie par l'utilisateur
    retourner n  
 Fin

Fonction saisie(binf:entier,bsup:entier):entier

# Demande à l'utilisateur de saisir un entier n dans l'intervalle [binf, bsup]

Ecrire('donner un entier dans [',binf,' , ',bsup),'] : ')

Lire(n)

# Vérification de la validité de la saisie

Tant que Non (binf <= n <= bsup) faire

Ecrire('donner un entier dans [',binf,' , ',bsup,'] : ')

Lire(n)

Fin tant que

# Retourne la valeur valide saisie par l'utilisateur

retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction test_distinct

Le rôle de la fonction test_distinct est de vérifier si la valeur située à la position m[i][j] est distincte des valeurs déjà présentes dans la colonne j (jusqu’à la ligne i-1).

Fonction test_distinct(m:matrice, i:entier, j:entier):booleen
    k <- 0
    # Vérifie que la valeur m[i][j] est différente des précédentes dans la colonne j
    Tant que (k < i-2) et (m[k][j] != m[k+1][j]) faire
         k <- k + 1
    Fin tant que
    retourner m[k][j] != m[k+1][j]
Fin

Fonction test_distinct(m:matrice, i:entier, j:entier):booleen

k <- 0

# Vérifie que la valeur m[i][j] est différente des précédentes dans la colonne j

Tant que (k < i-2) et (m[k][j] != m[k+1][j]) faire

k <- k + 1

Fin tant que

retourner m[k][j] != m[k+1][j]

Fin

Déclaration des objets

Objet	Type / Nature
k	entier

La procédure remplir_matrice

Le rôle de la procédure remplir_matrice est de remplir une matrice m de dimensions nl × nc par des entiers, en garantissant que les valeurs de chaque colonne sont distinctes.

Procédure remplir_matrice(m:matrice, nl:entier, nc:entier)
    Ecrire('remplir la matrice M')
    Pour j de 0 à nc-1 faire # pour chaque colonne
       Ecrire('donner un entier: ')  
       Lire(m[0][j])  # saisir la première valeur
       Pour i de 1 à nl-1 faire # pour les lignes suivantes
          Ecrire('donner un entier distinct: ') 
          Lire(m[i][j])
          # Tant que la valeur n'est pas distincte, redemander
          Tant que Non(test_distinct(m, i, j)) faire
              Ecrire('donner un entier distinct: ') 
              Lire(m[i][j])
          Fin tant que
       Fin pour
    Fin pour
Fin

Procédure remplir_matrice(m:matrice, nl:entier, nc:entier)

Ecrire('remplir la matrice M')

Pour j de 0 à nc-1 faire # pour chaque colonne

Ecrire('donner un entier: ')

Lire(m[0][j]) # saisir la première valeur

Pour i de 1 à nl-1 faire # pour les lignes suivantes

Ecrire('donner un entier distinct: ')

Lire(m[i][j])

# Tant que la valeur n'est pas distincte, redemander

Tant que Non(test_distinct(m, i, j)) faire

Ecrire('donner un entier distinct: ')

Lire(m[i][j])

Fin tant que

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
j	entier
i	entier

La procédure afficher_matrice

Le rôle de la procédure afficher_matrice est d'afficher le contenu d’une matrice m de dimensions nl × nc sous forme tabulaire.

Procédure afficher_matrice(m:matrice, nl:entier, nc:entier)
     Ecrire('Le contenu de la matrice M')
     Pour i de 0 à n-1 faire
        Pour j de 0 à nc-1 faire
            Ecrire(m[i][j], ' ')
        Fin pour
        Ecrire()
     Fin pour 
Fin

Procédure afficher_matrice(m:matrice, nl:entier, nc:entier)

Ecrire('Le contenu de la matrice M')

Pour i de 0 à n-1 faire

Pour j de 0 à nc-1 faire

Ecrire(m[i][j], ' ')

Fin pour

Ecrire()

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
j	entier
i	entier

La fonction max_colonne

Le rôle de la fonction max_colonne est de déterminer et retourner l’indice de la ligne contenant la valeur maximale dans une colonne donnée de la matrice.

Fonction max_colonne(nl:entier, j:entier, m:matrice):entier
    max_ligne <- 0
    Pour i de 1 à nl-1 faire
      Si m[max_ligne][j] < m[i][j] alors
         max_ligne <- i # mise à jour de l'indice de la ligne maximale
      Fin si
    Fin pour
    retourner max_ligne
Fin

Fonction max_colonne(nl:entier, j:entier, m:matrice):entier

max_ligne <- 0

Pour i de 1 à nl-1 faire

Si m[max_ligne][j] < m[i][j] alors

max_ligne <- i # mise à jour de l'indice de la ligne maximale

Fin si

Fin pour

retourner max_ligne

Fin

Déclaration des objets

Objet	Type / Nature
max_ligne	entier
i	entier
j	entier

La fonction determiner_minimax

Le rôle de la fonction determiner_minimax est de rechercher et retourner le MiniMax d’une matrice, c’est-à-dire le minimum parmi les maxima de chaque colonne.

Fonction determiner_minimax(m:matrice, t:tableau, taille:entier):entier
    minimax <- m[t[0]['l']][t[0]['c']] # initialisation avec le premier maximum
    Pour i de 1 à nc-1 faire
      Si minimax > m[t[i]['l']][t[i]['c']] alors
         minimax <- m[t[i]['l']][t[i]['c']] # mise à jour du MiniMax
      Fin Si
    Fin pour
    return minimax 
Fin

Fonction determiner_minimax(m:matrice, t:tableau, taille:entier):entier

minimax <- m[t[0]['l']][t[0]['c']] # initialisation avec le premier maximum

Pour i de 1 à nc-1 faire

Si minimax > m[t[i]['l']][t[i]['c']] alors

minimax <- m[t[i]['l']][t[i]['c']] # mise à jour du MiniMax

Fin Si

Fin pour

return minimax

Fin

Déclaration des objets

Objet	Type / Nature
minimax	entier
i	entier

La procédure recherche_elt_minimax

Cette procédure recherche et affiche les coordonnées des éléments de la matrice dont la valeur est égale au MiniMax.

Fonction recherche_elt_minimax(m:matrice, minimax:matrice, t:tableau, taille:entier)
    Ecrire('Les positions sont : ', end=' ')
    Pour i de 0 à taille-1 faire
        Si m[t[i]['l']][t[i]['c']] = minimax alors
            Ecrire('(', t[i]['c'], ',', t[i]['l'], ')')
        Fin si
    Fin pour 
Fin

Fonction recherche_elt_minimax(m:matrice, minimax:matrice, t:tableau, taille:entier)

Ecrire('Les positions sont : ', end=' ')

Pour i de 0 à taille-1 faire

Si m[t[i]['l']][t[i]['c']] = minimax alors

Ecrire('(', t[i]['c'], ',', t[i]['l'], ')')

Fin si

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La procédure afficher_tableau

Le rôle de la procédure afficher_tableau est d'afficher le tableau t contenant les positions (coordonnées) sous forme ordonnée.

Procedure afficher_tableau(t:tableau, n:entier)
    Ecrire('Le tableau T')
    Pour i de 0 à n-1 faire
        Ecrire ('(', t[i]['c'], ',', t[i]['l'], ')')
    Fin pour 
Fin

Procedure afficher_tableau(t:tableau, n:entier)

Ecrire('Le tableau T')

Pour i de 0 à n-1 faire

Ecrire ('(', t[i]['c'], ',', t[i]['l'], ')')

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La procédure recherche_minimax

Cette procédure recherche les éléments maximaux de chaque colonne d’une matrice, détermine le MiniMax et affiche sa valeur ainsi que ses positions.

Procedure recherche_minimax(m:matrice, t:tableau, nl:entier, nc:entier)
    taille <- 0
    Pour j de 0 à nc-1 faire
        # Trouve l'indice de la ligne contenant le maximum de la colonne j
        max_ligne <- max_colonne(nl, j, m)
        # Crée un enregistrement pour stocker la position du maximum
        position <- dict(c=int(), l=int())
        position['c'] <- j
        position['l'] <- max_ligne
        t[taille] <- position
        taille <- taille + 1
    
    # Affichage des positions des maxima
    afficher_tableau(t, taille)
    
    # Détermination du MiniMax
    minimax <- determiner_minimax(m, t, taille)
    print('MiniMax= ', minimax)
    
    # Recherche et affichage des positions du MiniMax
    recherche_elt_minimax(m, minimax, t, taille) 
Fin

Procedure recherche_minimax(m:matrice, t:tableau, nl:entier, nc:entier)

taille <- 0

Pour j de 0 à nc-1 faire

# Trouve l'indice de la ligne contenant le maximum de la colonne j

max_ligne <- max_colonne(nl, j, m)

# Crée un enregistrement pour stocker la position du maximum

position <- dict(c=int(), l=int())

position['c'] <- j

position['l'] <- max_ligne

t[taille] <- position

taille <- taille + 1

# Affichage des positions des maxima

afficher_tableau(t, taille)

# Détermination du MiniMax

minimax <- determiner_minimax(m, t, taille)

print('MiniMax= ', minimax)

# Recherche et affichage des positions du MiniMax

recherche_elt_minimax(m, minimax, t, taille)

Fin

Déclaration des objets

Objet	Type / Nature
taille	entier
j	entier
max_ligne	entier
position	enregistrement
minimax	entier

Solution en Python

from numpy import *

# --------------------------------------------------
# Définition des dimensions maximales de la matrice
# --------------------------------------------------
lignes = 50  # nombre maximal de lignes
colonnes = 50  # nombre maximal de colonnes

# Création d'une matrice M de taille 50x50 initialisée à 0
m = array([[int()] * colonnes] * lignes)

# Création d'un tableau t de 50 dictionnaires pour stocker des positions
t  = array([{}]*50)


# --------------------------------------------------
# Fonction de saisie sécurisée d'un entier
# --------------------------------------------------
def saisie(binf, bsup):
    # Demande à l'utilisateur de saisir un entier n dans l'intervalle [binf, bsup]
    n = int(input('donner un entier dans ['+str(binf)+' , '+str(bsup)+'] : '))

    # Vérification de la validité de la saisie
    while not (binf <= n <= bsup):
        n = int(input('donner un entier dans ['+str(binf)+' , '+str(bsup)+'] : '))
    
    # Retourne la valeur valide saisie par l'utilisateur
    return n


# --------------------------------------------------
# Fonction qui teste si l'entier à ajouter est distinct dans la colonne
# --------------------------------------------------
def test_distinct(m, i, j):
    k = 0
    # Vérifie que la valeur m[i][j] est différente des précédentes dans la colonne j
    while (k < i-2) and (m[k][j] != m[k+1][j]):
        k = k + 1
    return m[k][j] != m[k+1][j]


# --------------------------------------------------
# Procédure pour remplir la matrice avec des entiers distincts par colonne
# --------------------------------------------------
def remplir_matrice(m, nl, nc):
    print('remplir la matrice M')
    for j in range(nc):  # pour chaque colonne
        m[0][j] = int(input('donner un entier: '))  # saisir la première valeur
        for i in range(1, nl):  # pour les lignes suivantes
            m[i][j] = int(input('donner un entier distinct: '))
            # Tant que la valeur n'est pas distincte, redemander
            while not(test_distinct(m, i, j)):
                m[i][j] = int(input('donner un entier distinct: '))


# --------------------------------------------------
# Procédure pour afficher la matrice
# --------------------------------------------------
def afficher_matrice(m, nl, nc):
    print('Le contenu de la matrice M')
    for i in range(nl):
        for j in range(nc):
            print(m[i][j], end=' ')
        print()


# --------------------------------------------------
# Fonction qui retourne l'indice de la ligne contenant
# le maximum dans une colonne donnée
# --------------------------------------------------
def max_colonne(nl, j, m):
    max_ligne = 0
    for i in range(1, nl):
        if m[max_ligne][j] < m[i][j]:
            max_ligne = i  # mise à jour de l'indice de la ligne maximale
    return max_ligne


# --------------------------------------------------
# Fonction pour déterminer le MiniMax
# Le MiniMax est le minimum des maxima de chaque colonne
# --------------------------------------------------
def determiner_minimax(m, t, taille):
    minimax = m[t[0]['l']][t[0]['c']]  # initialisation avec le premier maximum
    for i in range(1, nc):
        if minimax > m[t[i]['l']][t[i]['c']]:
            minimax = m[t[i]['l']][t[i]['c']]  # mise à jour du MiniMax
    return minimax        


# --------------------------------------------------
# Procédure qui recherche et affiche les positions du MiniMax
# --------------------------------------------------
def recherche_elt_minimax(m, minimax, t, taille):
    print('Les positions sont : ', end=' ')
    for i in range(taille):
        if m[t[i]['l']][t[i]['c']] == minimax:
            print('(', t[i]['c'], ',', t[i]['l'], ')', end=' ')


# --------------------------------------------------
# Procédure pour afficher le tableau des positions
# --------------------------------------------------
def afficher_tableau(t, n):
    print('Le tableau T')
    for i in range(n):
        print('(', t[i]['c'], ',', t[i]['l'], ')', end='  ')
    print()
    

# --------------------------------------------------
# Procédure principale pour rechercher le MiniMax
# --------------------------------------------------
def recherche_minimax(m, t, nl, nc):
    taille = 0
    for j in range(nc):
        # Trouve l'indice de la ligne contenant le maximum de la colonne j
        max_ligne = max_colonne(nl, j, m)
        # Crée un dictionnaire pour stocker la position du maximum
        position = dict(c=int(), l=int())
        position['c'] = j
        position['l'] = max_ligne
        t[taille] = position
        taille += 1
    
    # Affichage des positions des maxima
    afficher_tableau(t, taille)
    
    # Détermination du MiniMax
    minimax = determiner_minimax(m, t, taille)
    print('MiniMax= ', minimax)
    
    # Recherche et affichage des positions du MiniMax
    recherche_elt_minimax(m, minimax, t, taille)





# --------------------------------------------------
# Programme principal
# --------------------------------------------------
nl = saisie(3, 15)  # nombre de lignes à saisir
nc = saisie(3, 15)  # nombre de colonnes à saisir
remplir_matrice(m, nl, nc)  # remplissage de la matrice
afficher_matrice(m, nl, nc)  # affichage de la matrice
recherche_minimax(m, t, nl, nc)  # recherche et affichage du MiniMax

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

138

139

140

141

142

143

144

145

146

147

from numpy import *

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

# Définition des dimensions maximales de la matrice

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

lignes = 50 # nombre maximal de lignes

colonnes = 50 # nombre maximal de colonnes

# Création d'une matrice M de taille 50x50 initialisée à 0

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

# Création d'un tableau t de 50 dictionnaires pour stocker des positions

t = array([{}]*50)

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

# Fonction de saisie sécurisée d'un entier

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

def saisie(binf, bsup):

# Demande à l'utilisateur de saisir un entier n dans l'intervalle [binf, bsup]

n = int(input('donner un entier dans ['+str(binf)+' , '+str(bsup)+'] : '))

# Vérification de la validité de la saisie

while not (binf <= n <= bsup):

n = int(input('donner un entier dans ['+str(binf)+' , '+str(bsup)+'] : '))

# Retourne la valeur valide saisie par l'utilisateur

return n

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

# Fonction qui teste si l'entier à ajouter est distinct dans la colonne

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

def test_distinct(m, i, j):

k = 0

# Vérifie que la valeur m[i][j] est différente des précédentes dans la colonne j

while (k < i-2) and (m[k][j] != m[k+1][j]):

k = k + 1

return m[k][j] != m[k+1][j]

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

# Procédure pour remplir la matrice avec des entiers distincts par colonne

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

def remplir_matrice(m, nl, nc):

print('remplir la matrice M')

for j in range(nc): # pour chaque colonne

m[0][j] = int(input('donner un entier: ')) # saisir la première valeur

for i in range(1, nl): # pour les lignes suivantes

m[i][j] = int(input('donner un entier distinct: '))

# Tant que la valeur n'est pas distincte, redemander

while not(test_distinct(m, i, j)):

m[i][j] = int(input('donner un entier distinct: '))

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

# Procédure pour afficher la matrice

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

def afficher_matrice(m, nl, nc):

print('Le contenu de la matrice M')

for i in range(nl):

for j in range(nc):

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

print()

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

# Fonction qui retourne l'indice de la ligne contenant

# le maximum dans une colonne donnée

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

def max_colonne(nl, j, m):

max_ligne = 0

for i in range(1, nl):

if m[max_ligne][j] < m[i][j]:

max_ligne = i # mise à jour de l'indice de la ligne maximale

return max_ligne

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

# Fonction pour déterminer le MiniMax

# Le MiniMax est le minimum des maxima de chaque colonne

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

def determiner_minimax(m, t, taille):

minimax = m[t[0]['l']][t[0]['c']] # initialisation avec le premier maximum

for i in range(1, nc):

if minimax > m[t[i]['l']][t[i]['c']]:

minimax = m[t[i]['l']][t[i]['c']] # mise à jour du MiniMax

return minimax

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

# Procédure qui recherche et affiche les positions du MiniMax

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

def recherche_elt_minimax(m, minimax, t, taille):

print('Les positions sont : ', end=' ')

for i in range(taille):

if m[t[i]['l']][t[i]['c']] == minimax:

print('(', t[i]['c'], ',', t[i]['l'], ')', end=' ')

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

# Procédure pour afficher le tableau des positions

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

def afficher_tableau(t, n):

print('Le tableau T')

for i in range(n):

print('(', t[i]['c'], ',', t[i]['l'], ')', end=' ')

print()

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

# Procédure principale pour rechercher le MiniMax

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

def recherche_minimax(m, t, nl, nc):

taille = 0

for j in range(nc):

# Trouve l'indice de la ligne contenant le maximum de la colonne j

max_ligne = max_colonne(nl, j, m)

# Crée un dictionnaire pour stocker la position du maximum

position = dict(c=int(), l=int())

position['c'] = j

position['l'] = max_ligne

t[taille] = position

taille += 1

# Affichage des positions des maxima

afficher_tableau(t, taille)

# Détermination du MiniMax

minimax = determiner_minimax(m, t, taille)

print('MiniMax= ', minimax)

# Recherche et affichage des positions du MiniMax

recherche_elt_minimax(m, minimax, t, taille)

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

# Programme principal

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

nl = saisie(3, 15) # nombre de lignes à saisir

nc = saisie(3, 15) # nombre de colonnes à saisir

remplir_matrice(m, nl, nc) # remplissage de la matrice

afficher_matrice(m, nl, nc) # affichage de la matrice

recherche_minimax(m, t, nl, nc) # recherche et affichage du MiniMax

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

Distributeur de pièces intelligent basé sur Micro:bit

Micro:bit 07-03-26

Balance numérique avec ESP8266 NodeMCU et module HX711

ESP8266 05-03-26

Balance électronique avec Arduino UNO et module HX711

Arduino 03-03-26

Balance électronique avec la carte ESP32 et module HX711

ESP32 02-03-26

Horloge réveil avec ESP8266 NodeMCU et le module RTC DS1302

ESP8266 26-02-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11597vues

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

Arduino 11241vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9820vues

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

Arduino 9421vues

Allumer une LED par la carte ESP32

ESP32 9403vues

Construction des robots

Tutoriels plus commentés

Premiers pas avec Micro:bit et MakeCode

Micro:bit 31 commentaires

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

Arduino 30 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

Problème Matrice – Bac théorique – Section informatique – 2023

Sujet (Algo et programmation - Bac 2023)

Travail demandé :

Solution Algorithmique

Algorithme du programme Principal

La fonction saisie

La fonction test_distinct

La procédure remplir_matrice

La procédure afficher_matrice

La fonction max_colonne

La fonction determiner_minimax

La procédure recherche_elt_minimax

La procédure afficher_tableau

La procédure recherche_minimax

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