Bonjour ,

une stratégie possible est de parcourir toute la matrice élément par élément et de comparer chaque élément à la plus petite valeur trouvée (initialisée à la valeur du 1° élément de la matrice par exemple) et chaque fois qu'on trouve un élément plus petit , on conserve sa valeur ainsi que sa position (ligne et colonne)
Connais-t'on la taille de la matrice ?

Cordialement

Non on a pas preciser la taille
Cest la premiere fois que jfais algorithme donc cest un peu difficile de comprendre

Oui c'est un tableau de dimension 2 deL lignes et de C colonnes a valeurs entieres

ha oui d'accord.
Bon alors fais comme fm_31 t'a suggéré.
deux boucles Pour I allant de 1 à L et Pour J allant de 1 à C pour parcourir les termes de la matrice puis à chaque item tu testes si l'élément de la matrice est plus petit ou plus grand que le plus petit et le plus grand obtenus jusqu'à alors. Si oui tu remplaces la valeur max ou min par la nouvelle valeur (et tu stockes le I et J dans des variables).
A la fin tu affiche les max et min et les I et J correspondant.

Lance toi, les algorithmes pour progresser il faut se battre un peu avec.
tu veux écrire ça dans un langage particulier ou bien en langage naturel ?

Oui ca m'aide beaucoup merci
Jvais essayer de le faire
Cest en langage naturel

Tu peux faire l'algorithme en  "langage naturel"  mais tu peux aussi l'écrire en algobox  par exemple , ce qui a l'avantage de pouvoir le tester directement . Pour cela , j'utilise le logiciel  Prolab   (gratuit et en ligne , rien à télécharger)

Bonjour,

nota : ne pas en faire plus que ce qui est demandé
on cherche le minimum seul
pas le minimum et le maximum
(même s'il n'est pas vraiment plus compliqué d'obtenir ici les deux )


Algobox ... hum
ce langage ne permet pas de définir des matrices, seulement des listes (à une seule dimension)

1ère solution : on se fiche que ce soit une matrice ou pas ; c'est 4 nombres dans 4 variables qu'on peut tout aussi bien appeler A,B,C,D
seul le concepteur sait que A et B sont la 1ère ligne et C et D la seconde
le programme (Algobox) n'a aucun moyen de le savoir (donc adieu les boucles et les indices "pour I de ...")
pour aider le concepteur à s'y retrouver (vu que c'est lui qui fait tout le boulot sur les indices !!) il peut appeler ces variables M00, M01, M10 et M11 vu que le nom d'une variable c'est ce qu'on veut ...


deuxième solution : pour définir une matrice il faut utiliser une astuce "classique" mais qu'on risque fort d'être incapable d'imaginer en débutant !
on remplace cette matrice (à deux dimensions, de L lignes et C colonnes) par une liste à une seule dimension = C*L
on range successivement tous les éléments de la 1ère ligne, puis tous les éléments de la seconde ligne etc
le rang d'un élément [I, J] ligne I colonne J dans cette liste est donc C*I + J
(I de 0 à L-1 et J de 0 à C-1, il y a C éléments par ligne)
ainsi les rangs de cette matrice 2x3 sont

0  1  2
3  4  5

non, c'est pas 4 nombres dans 4 variables c'est une matrice avec C colonnes et L lignes

certes, mais je rebondissais sur Algobox : ça n'existe pas une matrice dans Algobox, il n'y au mieux que des Listes.

et que si on laisse tomber cette histoire d'Algobox alors comme je l'ai dit à la fin

Une matrice possédant L lignes et de C colonnes   a pour dimension L C

Donc si L C = 2 alors L = 1 et C = 2 ou L = 2 et C = 1 !!!

on va laisser Cita avec le flou de son énoncé qui ne rime à rien alors ...

non, visiblement dans son esprit, une matrice à 2 dimensions n'est pas une matrice 2 x 2 mais une matrice lignes x colonnes avec L lignes et C colonnes.

2 dimensions ici veut dire plane c.a.d a_ij et pas a _ijk ou plus

Donc demandons au posteur de revoir la définition de la dimension d'une matrice pour que nous soyons tous d'accord (au moins sur ce point)

dans son post de 12:23 elle est claire

OK, j'ai compris.

je retire ce que j'ai dit à propos du cas particulier d'une matrice 2x2
Le reste est à garder :
- à propos de Algobox et de la représentation "linéaire" d'une matrice sous forme d'une Liste
- la différence entre "programme" et "algorithme" et sur la façon d'écrire l'élément d'une matrice en "langage naturel"
- et sur le fait qu'on ne demande que le min, et pas le min et le max simultanément, sans complication.

Oui, je ne sais pas s'il connait " la représentation "linéaire" d'une matrice sous forme d'une Liste "

Pour info, on se sert d'une variable de type liste.
- Pour affecter une valeur à l'élément du tableau correspondant à la ligne li et à la colonne col, il suffit de remplir le champ Rang du terme de la liste par : li*(nombre de colonnes)+col. On obtient alors une ligne de la forme :
montableau[li*(nombre de colonnes)+col] PREND_LA_VALEUR...
- Pour réutiliser la valeur d'un élément du tableau dans un calcul, on utilise la syntaxe :
montableau[li*(nombre de colonnes)+col].

salut

soit une matrice d'ordre n ... et qui contient donc   éléments

alors la transformation transforme la matrice A en une liste (on numérote simplement les éléments par ligne et colonne)

la réciproque est évidente ... et c'est elle qui nous intéresse bien sur ...

Généralisé comme dit précédemment à une matrice pas forcément carrée ...
et de plus la réciproque est ici bien inutile.
(on ne traite que la transformation (i;j) ---> k et la transformation inverse ne sert pas)

ben non il nous faut la réciproque  puisque si on ne veut pas s'emmerder à rentrer une matrice ou que ce n'est pas possible on rentre une liste et il nous faut retourner l'élément correspondant de la matrice (ses indices)

rentrer dans une liste les éléments a_i,j d'une matrice par ligne et colonne donne la transformation (i, j) --> (i - 1)n + j = k naturellement : l'élément de rang k de la liste correspondant à l'élément a_i, j de la matrice

et ce qu'on veut au final c'est i, et j connaissant k

bof.

pour i de 0 à C-1
pour j de O0 à L-1
entrer l'élément M_ij c'est à dire M[c*i+j] dans une traduction machine en Liste

je rappelle : ne pas confondre algorithme (des M_ij) et programme (un bidouillage avec des listes parce que la machine ne sait pas traiter des matrices)
bidouillage inutile si la machine sait (par exemple en C et autres dans lesquels on sait traiter des listes de listes et pas seulement des listes de nombres)

puis
pour i de 0 à C-1
pour j de 0 à L-1
comparer l'élément M_ij c'est à dire M[c*i+j] dans une traduction machine en Liste (idem)
mémoriser i et j si celui ci est plus petit que le candidat actuel

(ou variante de calculs si les éléments sont numérotés de 1 à C au lieu de 0 à C-1)