Discussion :

[Cluster]

Bonjour à tous !

Voilà tout est expliqué dans le titre, je n'arrive pas à trouver la solution pour faire une permutation de nombres de gauche à droite dans un vecteur a dimension variable.
Le code ci-dessous, je demande d'encoder une dimension (j'ai encodé 4) pour définir le vecteur et puis je fais une permutation de ces 4 nombres vers la droite. Mais comment adapter cette permutation automatiquement selon qu'un utilisateur choisit une autre dimension de vecteur ?

D'avance un grand merci à tous ceux qui prendront la peine de me lire ^^

_________________________________________________________________

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
program vecteur3;
 
var v : array [1..100] of integer;
 
tmp,k,dim : integer;
 
 
 
Begin
 
     writeln ('Entrez un nombre entre 1 et 100 pour la dimension du vecteur');
 
     readln (dim);
 
     while  (dim < 1) or (dim > 100) do
 
          Begin
 
               writeln ('Entrez un nombre compris entre 1 et 100 SVP !');
 
               readln (dim);
 
          End;
 
     writeln ('Encodez les valeurs dans le vecteur !');
 
     for k := 1 to dim do
 
          Begin
 
              readln (v[k]);
 
          End;
 
     writeln;
 
     writeln ('Permutation');
 
     readln;
 
     k := 1;
 
     tmp := v[k];
 
     v[k] := v[k+1];
 
     v[k+1] := tmp;
 
     tmp := v[k];
 
     v[k] := v[k+2];
 
     v[k+2] := tmp;
 
     tmp := v[k];
 
     v[k] := v[k+3];
 
     v[k+3] := tmp;
 
     for k := 1 to dim do
 
          Begin
 
               writeln (v[k]);
 
          End;
 
     readln
 
 
 
End.

[Alcatîz]

Bonjour et bienvenue !

Le mieux à faire est de commencer ton exercice sur papier.

Attention, dans ton algorithme, k garde toujours la valeur 1. Tu dois le retravailler.
Ton algo revient en fait à permuter successivement tous les éléments avec le 1er élément de la liste.
Pour le [k]ième élément, cela s'écrit :

Code :

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

1
2
3
tmp := v[1];
v[1] := v[k];
v[k] := tmp;

Cette opération doit être répétée du 2ème au dernier élément du vecteur. Il faut donc inclure la permutation ci-dessus dans une boucle et faire varier k de 2 à Dim.

Si le vecteur de départ est 1234, le résultat sera 4123.

[Cluster]

Grand merci Alcatiz

Je vais retravailler ça !
C'est vrai que je n'ai pas pris la peine de le faire sur papier comme on nous l'apprend à l'école en LDA.
Je vous posterai ma résolution une fois l'exercice terminé.

Bonne journée

[Cluster]

Me revoilà

Je poste ci-dessous le corrigé de la permutation de nombres dans un vecteur à dimension variable.

Encore un tout grand merci à Alcatîz sans quoi je me serais encore tiré les cheveaux

Si vous voyez encore dans mon code quelque chose de non accadémique, n'hésitez pas à me le faire savoir, je suis toutjours au stade du débutant

Vous me verrez probablement encore souvent puisque je viens de commencer ma 1ère en informatique !

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
program Project1;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
var v : array [1..100] of integer;
 
tmp,dim,k : integer;
 
begin
 
      writeln ('Choisissez une dimension d''un vecteur comprise entre 1 et 100');
 
      readln (dim);
 
      while (dim<0) or (dim>100) do
 
          Begin
 
                writeln ('Compris entre 1 et 100 SVP !');
 
                readln (dim);
 
          End;
 
      writeln;
 
      writeln ('Vous avez choisi une dimension de vecteur de ', dim);
 
      writeln ('Appuyez sur "Enter"');
 
      readln;
 
      writeln ('Maintenant remplissez le vecteur avec des nombres');
 
      writeln;
 
      for k := 1 to dim do
 
            Begin
 
                  readln (v[k]);
 
            End;
 
      writeln;
 
      writeln ('Maintenan nous procedons a la permutation interne');
 
      writeln ('Appuyez sur "Enter"');
 
      readln;
 
      k := 1;
 
      for k := 2 to dim do
 
            Begin
 
                  tmp := v[1];
 
                  v[1] := v[k];
 
                  v[k] := tmp;
 
            End;
 
      writeln ('Le resultat de la permutation va s''afficher');
 
      writeln ('Appuyez sur "Enter"');
 
      readln;
 
      for k := 1 to dim do
 
            Begin
 
                  writeln (v[k]);
 
            End;
 
      readln;
 
end.

[Alcatîz]

La première ligne de cet extrait est inutile :

Code :

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

1
2
3
k := 1;
 
      for k := 2 to dim do

Ensuite, l'utilisateur doit entrer au minimum 2 comme taille de vecteur. Permuter un seul élément n'a pas de sens.

Au sujet de la lecture de la dimension du vecteur, tu utilises une boucle while..do. Mais une boucle repeat..until aurait été préférable car le test de la condition de terminaison se fait à la fin et non au début :

Code :

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

1
2
3
4
repeat
  writeln ('Compris entre 2 et 100 SVP !');
  readln(dim) ;
until (dim >= 2) and (dim <= 100);

Ainsi, tu n'as pas besoin d'avoir réalisé une première lecture avant d'entrer dans la boucle.

[Cluster]

J'en prends bonne note, cette ligne est de trop et ne sert strictement à rien et effectivement il est inutile de laisser la possibilité à l'utilisateur de choisir une dimension de 1 dans ce cas ci

Code :

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

k := 1;

En ce qui concerne la boucle repeat je t'avoue que je ne la connais pas encore mais j'en comprends tout à fait le sens. Le premier

Code :

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

readln(dim) ;

est alors inclut dans la boucle repeat, ce qui est plus logique c'est vrai

Je posterai donc le corrigé tout à l'heure avec une autre question qui me
turlupine.


Sur ce bonne nuit et encore merci pour tes conseils avisés Alcatîz

[Cluster]

Voici les modifications effectuées

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
program Project1;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
var v : array [2..100] of integer;
 
tmp,dim,k : integer;
 
begin
 
      repeat
 
            Begin
 
                  writeln ('Choisissez la taille du vecteur compris entre 2 et 100');
 
                  readln (dim);
 
            End;
 
      until (dim>=2) and (dim<=100);
 
      writeln;
 
      writeln ('Vous avez choisi une dimension de vecteur de ', dim);
 
      writeln ('Appuyez sur "Enter"');
 
      readln;
 
      writeln ('Maintenant remplissez le vecteur avec des nombres');
 
      writeln;
 
      for k := 1 to dim do
 
            Begin
 
                  readln (v[k]);
 
            End;
 
      writeln;
 
      writeln ('Maintenan nous procedons a la permutation interne');
 
      writeln ('Appuyez sur "Enter"');
 
      readln;
 
      for k := 2 to dim do
 
            Begin
 
                  tmp := v[1];
 
                  v[1] := v[k];
 
                  v[k] := tmp;
 
            End;
 
      writeln ('Le resultat de la permutation va s''afficher');
 
      writeln ('Appuyez sur "Enter"');
 
      readln;
 
      for k := 1 to dim do
 
            Begin
 
                  writeln (v[k]);
 
            End;
 
      readln;
 
end.

J'ai encore une question pour un second exercice
dont le but est de faire une permutation d'un vecteur a dimension variable

Exemple du vecteur au début : 6734

Permutation du vecteur en sortie : 4376


J'ai la formule pour un vecteur de dimension 4

Code :

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

1
2
3
4
5
6
7
8
9
10
11
tmp := v[1];
 
v[1] := v[4];
 
v[4] := tmp;
 
tmp := v[2];
 
v[2] := v[v3];
 
v[3] := tmp;

Mais je n'arrive toujours pas trouver la formule pour une dimension variable dans une boucle for
Il faudrait que j'arrive à incrémenter et décrémenter les permutations au fur et à mesure, je continue à chercher de mon côté

Bonne soirée