Discussion :

[PIMPMAX]

Bonjour à tous,

Voici un algo. Il faut le corriger afin de permettre un tri décroissant des éléments du tableau:


Tableau nombres(5) en Numérique
Variable tmp en Numérique
Début
nombres(0) <-35
nombres(1) <-2
nombres(2) <-9
nombres(3) <-12
nombres(4) <-79
Pour i de 0 à 4 Faire
Pour j de i-1 à 5 Faire

Si nombres (i)> nombres (j) Faire
tmp <- nombres (i)
nombres (i) <- nombres (j)
nombres (j) <- tmp
Fin si
Fin Pour
Fin Pour
Pour i de 0 à 4 Faire
Afficher nombre (j) & "\n"
Fin Pour
Fin

[thewho]

Bonjour,

Voici un algo. Il faut le corriger afin de permettre un tri décroissant des éléments du tableau:

Et toi, gentiment, tu penses qu'on va faire ton travail à ta place.

Qu'as tu déjà fait ?
Où en es-tu de ta réflexion sur ce problème ?

Montre-nous cela, et sans doute quelqu'un t'aidera.

[PIMPMAX]

c'est pas long à résoudre pour un initié.

ça doit prendre à peine 3 minutes.
par contre pour un débutant comme moi c'est galère donc merci à ceux qui voudront bien m'aider.

c'est ça avoir de l'ouverture d'esprit, le partage !

[plegat]

merci à ceux qui voudront bien m'aider.

Sauf que "aider", c'est filer un coup de main à quelqu'un qui bosse pour qu'il finisse plus vite/facilement.
Faire faire ton boulot par quelqu'un d'autre, c'est pas demander de l'aide...

c'est ça avoir de l'ouverture d'esprit, le partage !

Je suis très ouvert d'esprit, mais ça m'étonnerait que tu me fasses trimer pour tes beaux yeux... surtout avant la fin du match... par contre je vais t'aider!

En attendant que le stade gagne son match, et vu que je suppose que tu sais lire et que tu n'es pas plus bête qu'un autre, tu prends une feuille de papier, et tu suis l'algorithme en notant les valeurs successives que prennent les variables. Tu regardes ensuite où ça a l'air de déconner, et tu corriges l'algorithme en conséquence. Et si tu n'arrives pas à corriger, tu nous explique ce que tu as vu comme boulette, et on te file un coup de main.

Bon, si le stade perd, je promets pas d'être toujours ouvert d'esprit, mais bon...

[PIMPMAX]

Bon alors merci pour ton ouverture d'esprit.
Me concernant je trouve ceci bizarre :
Pour j de i-1 à 5 puisque le tableau s'arrête à 4.

Ensuite ce que je comprend de ces lignes
Si nombres (i)> nombres (j) Faire
tmp <- nombres (i)
nombres (i) <- nombres (j)
nombres (j) <- tmp

C'est qu'au final les nombres de i deviennent ceux de j et inversement.
la variable tmp n'étant qu'un relai ?

Voilà en gros ce que je pige de ce charabia...
j'y ai passé toute la matinée...pas moyen que ma cervelle tourne dans le bon sens

[thewho]

Bonjour,

Puisque tu as à peu près compris ce qui se passe, et que tu as vu un problème, tu devrais pouvoir le corriger tout seul.

Pour cela, demande-toi quelles limites il faut mettre aux boucles (le pluriel ici t'indique de t'occuper également de la boucle sur i), sachant que :

- il ne faut jamais dépasser les limites du tableau

- comme il s'agit de déplacer les valeurs testées si elles répondent OUI à une condition (celle pointée par i est > à celle pointée par j), il est inutile que i et j puissent prendre la même valeur.

Tu devrais t'en sortir avec ça.

Ensuite ce que je comprend de ces lignes
Si nombres (i)> nombres (j) Faire
tmp <- nombres (i)
nombres (i) <- nombres (j)
nombres (j) <- tmp

C'est qu'au final les nombres de i deviennent ceux de j et inversement.
la variable tmp n'étant qu'un relai ?

C'est bien ça, on appelle ça swapper les valeurs (ne te fixe pas sur ce terme, il est bien possible qu'on t'en apprenne un autre).


Conseil au passage.
Même si on ne te le donne pas ainsi, prends l'habitude d'indenter le code, comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Tableau nombres(5) en Numérique
Variable tmp en Numérique
 
Début
  nombres(0) <-35
  nombres(1) <-2
  nombres(2) <-9
  nombres(3) <-12
  nombres(4) <-79
 
  Pour i de 0 à 4 Faire
    Pour j de i-1 à 5 Faire
      Si nombres (i)> nombres (j) Faire
        tmp <- nombres (i)
        nombres (i) <- nombres (j)
        nombres (j) <- tmp
      Fin si
    Fin Pour
  Fin Pour
 
  Pour i de 0 à 4 Faire
    Afficher nombre (j) & "\n"
  Fin Pour
Fin

Comme tu le vois, ça facilite beaucoup la lecture.

Et j'ajoute : pour les Fin Si our Fin Pour, etc..., prends l'habitude de préciser à quoi cela se rapporte, surtout quand il y a des imbrications, comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Tableau nombres(5) en Numérique
Variable tmp en Numérique

Début
  nombres(0) <-35
  nombres(1) <-2
  nombres(2) <-9
  nombres(3) <-12
  nombres(4) <-79
  
  Pour i de 0 à 4 Faire
    Pour j de i-1 à 5 Faire
      Si nombres (i)> nombres (j) Faire
        tmp <- nombres (i)
        nombres (i) <- nombres (j)
        nombres (j) <- tmp
      Fin si
    Fin Pour   // boucle j
  Fin Pour   // boucle i
  
  Pour i de 0 à 4 Faire
    Afficher nombre (j) & "\n"
  Fin Pour
Fin

Comme tu peux le voir, malgré mon conseil, je n'ai pas mis de commentaire pour le Fin Si : il n'y a pas d'imbrication, le code est court, et l'indentation rend parfaitement visible de quoi il s'agit.

Autant prendre de bonne habitudes tout de suite.

[plegat]

Me concernant je trouve ceci bizarre :
Pour j de i-1 à 5 puisque le tableau s'arrête à 4.

Y'a un peu de ça... mais tu n'en a que la moitié...
Etant donné que i va de 0 à 4 d'après l'algo... si j va de i-1 à 5... ça fait donc que pour i=0, on va avoir j qui aller de... -1... à 5... or, le tableau commence à 0... donc pour i=0, et j=-1, ça va planter! Donc il y a une correction à apporter sur la valeur mini de j. Ce n'est pas i-1, c'est ... autre chose!

Ensuite ce que je comprend de ces lignes
Si nombres (i)> nombres (j) Faire
tmp <- nombres (i)
nombres (i) <- nombres (j)
nombres (j) <- tmp

C'est qu'au final les nombres de i deviennent ceux de j et inversement.
la variable tmp n'étant qu'un relai ?

Yes!
C'est la méthode classique pour inverser deux éléments dans un tableau. La valeur a la position i devient celle qui était à la position j, et inversement. tmp est juste là pour ne pas perdre de valeur en cours de route (parce que si tu mets directement la valeur du rang j au rang i, tu écrases elle qui était au rang i...)

Voilà en gros ce que je pige de ce charabia...
j'y ai passé toute la matinée...pas moyen que ma cervelle tourne dans le bon sens

Je t'ai conseillé de suivre les valeurs numériques des variables...
C'est beaucoup plus facile de comprendre en faisant ça si tu ne piges pas l'algo dans sa globalité.

Exemple, première boucle.

nombre=tableau(35,2,9,12,79)
i=0
j=i-1=-1, ça, ça va planter, on va commencer les indices à 0 déjà, et les terminer à 4 vu que tu t'es aperçu que ça ne devrait jamais atteindre 5 (donc correction de l'algo, "Pour j de i à 4" au lieu de "Pour j de i-1 à 5")

Test nombre(i=0)>nombre(j=0)... euh... là tu t'aperçois que c'est bizarre comme test... en plus il sera toujours faux, donc ce qu'il y a dans la boucle ne sera jamais exécuté. Autant virer ce cas, on peut faire commencer j à la valeur suivant (donc correction de la correction précédente, "Pour j de i+1 à 4" au lieu de "Pour j de i à 4")

On refait le test... avec j=i+1 cette fois!
Test nombre(i=0)>nombre(j=1) soit Test 35>2... ça, c'est vrai, on exécute ce qu'il y a dans la boucle, qui en fait revient à inverse les valeurs 5 et 2 dans le tableau. On se retrouve avec nombre=tableau(2,35,9,12,79)

Et ainsi de suite.... jusqu'à ce que tu arrives au soucis suivant... par exemple pour i=4, si tu dois partir de j=i+1, ça va donner j=5, et ça va replanter...

Et en réfléchissant un peu, tu vas vite comprendre qu'en fait, le but du jeu, c'est de prendre chaque élément de ton tableau, à tour de rôle, en partant du premier et en allant vers le dernier, et de le comparer avec tous ceux qui sont situés après lui dans le tableau. A partir de là, tu peux sortir quelques règles élémentaires sur l'algorithme "corrigé":

• la boucle i doit aller de 0 à 3, et pas 4. Je ne peux pas comparer le 4ème élément avec les suivants, c'est le dernier!
• la boucle j doit aller de i+1 (l'élément qui suit celui au rang i, jusqu'à 4, le dernier)

Voilà quelques pistes. Vas-y progrssivement, n'aie pas peur de tester avec tes valeurs si ça marche ou pas, et corrige en conséquence.
Et teste également avec un autre tableau de valeurs que celui que tu as là. Ce n'est pas parce que ça marche avec certaines données, que ça va marcher avec toutes!

[PIMPMAX]

ok merci pour l'aide, je vais replonger dans l'exercice.

[pseudocode]

@thewho et plegat: vous etes dur avec lui...comprendre l'idée qui est derriere un algo faux, c'est quand meme pas evident . Il est pas pret de faire des jolies bulles

[plegat]

@thewho et plegat: vous etes dur avec lui...comprendre l'idée qui est derriere un algo faux, c'est quand meme pas evident .

Roh, ben non, dans son premier post il a marqué "Il faut le corriger afin de permettre un tri décroissant des éléments du tableau", donc il sait déjà ce que doit faire l'algo. C'est pour ça qu'on lui dit de dérouler l'algorithme et de voir où ça part en vrille...

Il est pas pret de faire des jolies bulles

Ah ça...
Mais il y a de super algos justes et pas faux plein Google pour les bulles!

[thewho]

Bonjour,

@thewho et plegat: vous etes dur avec lui...comprendre l'idée qui est derriere un algo faux, c'est quand meme pas evident . Il est pas pret de faire des jolies bulles

En quoi sommes-nous durs avec lui ?

On lui donne les pistes, avec des détails lui permettant de comprendre ce qu'il faut faire.

C'est en réfléchissant sur des problèmes qu'on apprend, pas en copiant la réponse d'un autre.

(C'est le but des exercices, n'est-ce pas ?)

[pseudocode]

Roh, ben non, dans son premier post il a marqué "Il faut le corriger afin de permettre un tri décroissant des éléments du tableau", donc il sait déjà ce que doit faire l'algo. C'est pour ça qu'on lui dit de dérouler l'algorithme et de voir où ça part en vrille...

Hum... si on me donnais un code buggué de qsort juste en me disant que ca trie un tableau, sans avoir entendu parlé du qsort... bah je serai pas pres de le corriger.

Autant je pourrais ecrire un algo a partir d'un idée, autant je suis incapable de percevoir l'idée derriere un algo... meme un algo juste.

Je dois etre mal equipé en cerveau .

[plegat]

Autant je pourrais ecrire un algo a partir d'un idée, autant je suis incapable de percevoir l'idée derriere un algo... meme un algo juste.

Ben c'est comme pour la littérature, comment peut-on prétendre maitriser l'écriture d'un bouquin si on ne sait pas lire?

L'algo, c'est pareil. Autant il faut savoir transposer une idée de traitement en algorithme, autant il faut savoir ce que fait un algorithme comme traitement. Ca permet de vérifier que tu as bien transposé ton idée.

Là, en prime, on ne lui demande pas ce que fait l'algo, on lui demande de le corriger pour qu'il fasse ce qu'il est sensé faire. Et ce n'est pas du quicksort, c'est quand même d'un niveau assez basique (même si le "basique" peut paraitre élevé quand on débute). Si on te donnait la méthode complète du quicksort, avec un algo buggué à côté, serais-tu capable de le corriger? Je pense que oui... Bon, là, ok, il n'a pas la méthode, mais il a déjà compris que la méthode était basée sur une inversion d'éléments. A lui en suite de vérifier si les inversion sont faites correctement (vérifier les bornes des boucles, voir si on inverse les éléments dans l'ordre qu'il faut, etc etc). Pour ça, il n'y a pas de secrets, on applique, on réfléchit, on teste... et normalement à la fin on trouve!

[PIMPMAX]

voila pour moi :

Tableau nombres(5) en Numérique
Variable tmp en Numérique

Début

nombres(0) <- 35
nombres(1) <- 2
nombres(2) <- 9
nombres(3) <- 12
nombres(4) <- 79

Pour i de 0 à 3 Faire

Pour j de i+1 à 4 Faire

Si nombres (i) > nombres (j) Faire
tmp <- nombres (i)
nombres (i) <- nombres (j)
nombres (j) <- tmp
Fin si

Fin Pour

Fin Pour

Pour i de 0 à 4 Faire
Afficher nombre (j) & "\n"
Fin Pour

Fin

test d'utilisation

nombres(0) <- 35
nombres(1) <- 2
nombres(2) <- 9
nombres(3) <- 12
nombres(4) <- 79

i prend 0
j prend 1

35 > 2 donc

nombres(0) <- 2
nombres(1) <- 35

j prend 2

35 > 9 donc

nombres(1) <- 9
nombres(2) <- 35

j prend 3

35 > 12 donc

nombres(2) <- 12
nombres(3) <- 35

j prend 4

35 < 79 donc on fait rien

on obtient

nombres(0) <- 2
nombres(1) <- 9
nombres(2) <- 12
nombres(3) <- 35
nombres(4) <- 79

i prend 1
j prend 2

9 < 12 donc on fait rien

j prend 3

9 < 35 donc on fait rien

i prend 2
j prend 3

12 < 35 donc on fait rien

[plegat]

Ok... même si il manque quelques étapes sur la fin (quelques couples i/j), l'idée est là.

Par contre, le résultat final du test d'utilisation, c'est quoi?

PS: en avance sur ta réponse, une dernière correction à apporter... l'algo doit trier le tableau "par ordre décroissant"... la condition du 'SI' de l'algo est donc à inverser.

[thewho]

Bonjour,

Eh bien, tu vois qu'en travaillant un peu, ça avance.

J'aurais présenté le code ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Tableau nombres(5) en Numérique
Variable tmp en Numérique
 
Début
  nombres(0) <- 35
  nombres(1) <- 2
  nombres(2) <- 9
  nombres(3) <- 12
  nombres(4) <- 79
 
  // tri du fichier
  Pour i de 0 à 3 Faire
    Pour j de i+1 à 4 Faire
      Si nombres (i) > nombres (j) Faire
        tmp <- nombres (i)
        nombres (i) <- nombres (j)
        nombres (j) <- tmp
      Fin si
    Fin Pour // boucle j
  Fin Pour // boucle i
 
  // affichage des données après tri
  Pour i de 0 à 4 Faire
    Afficher nombre (j) & "\n"
  Fin Pour
Fin

Tu as mis des lignes vides inutiles, car elles n'éclaircissent pas le code, et se contentent de l'étaler.

Pour l'indentation, si tu l'as faite et n'apparaît pas sur le forum, c'est qu'il faut en cadrer ton code par les balises [c ode] et [/c ode], en supprimant les espaces de "c ode", que je n'ai mis que pour invalider les balises.

Un ou deux petits commentaire rendent le code plus explicite pour les lecteurs.

En espérant t'avoir été utile, bonne continuation