Discussion :

[rimkm]

bonjour tout le monde j'ai un un probleme en pascal et j'arrive pas a le résoudre le voila:
écrire un programme intitulé Nb_Seq, qui à partir d'un tableau T de N entiers, affiche toutes les séquences strictement croissantes, de ce tableau, ainsi que leur nombre.
j'ai essayer de trouver une solution mais mon programme n'affiche pas le nombre de séquences.
j'espère que vous pouvez m'aider a trouver l'erreur de mon programme.

[droggo]

Qoa,

je vais te donner la solution relatif a la procédure affiche alors complète la reste du programme

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
 
procedure affichage(t:tab;n:integer);
var
i,nb:integer;
begin
nb:=0;
for i:=1 to n do
begin
if(t[i]>=0)then
begin
     write(t[i]:3);
     nb:=nb+1;
         end;
end;
writeln;
write(' il y a ',nb,' case(s) positif(s) dans ce tableau');
end;

Ça ne correspond pas du tout à la demande.

Pour rimkm : on ne fera pas ton travail à ta place, alors montre-nous où ce que tu as déjà fait, en indiquant ce qui te bloque

[Dr.Who]

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
 
fonction TestSiStrictementCroissant(Tab est un tableau) retour [vrai ou faux]
variable Max de type entier
variable Idx de type entier
variable Old du même type que les éléments de Tab
début
  Max = longueur Tab moins un
  Idx = zéro
  Ret = Tab[Idx] supérieur ou égal à zéro
  Old = Tab[Idx]
  tant que (Ret est égal à vrai) et (Idx est strictement inferieur à Max) faire 
  début
    incrémente Idx
    Ret = Tab[Idx] strictement supérieur à Old
    Old = Tab[Idx]
  fin
  TestSiStrictementCroissant = Ret
fin

[kingmoezhaj]

désole pour la solution d'hier qui étais fausse
si j'ai compris l'énoncé voila je propose cette solution

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
 
program sequence;
uses wincrt;
 
type
tab=array[1..100]of integer;
var
t:tab;
n:integer;
 
procedure remplir(var t:tab;n:integer);
var
i:integer;
begin
Randomize;
for i:=1 to n do
begin
t[i]:=Random(100);
end;
end;
 
procedure affichage(t:tab;n:integer);
var
i:integer;
begin
for i:=1 to n do
begin
write(t[i]:3);
end;
end;
 
procedure sequence(t:tab; n:integer);
var
nb,i,j,k:integer;
begin
nb:=0;
i:=1;
repeat
i:=i+1;
j:=i;
while(t[i]<t[i+1])and(i<=n)do
   i:=i+1;
if(j<>i)then
            begin
            nb:=nb+1;
            writeln;
            for k:=j to i do
             write(t[k]:3);
            writeln;
            end;
until(i>=n);
writeln('Le nombre des sequences est : ',nb);
end;
 
begin
repeat
write('la taille du tableau : ');
readln(n);
until(n>0);
 
remplir(t,n);
affichage(t,n);
writeln;
sequence(t,n);
end.

[Dr.Who]

plutôt :

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
const
  MaxTab = 100;
 
type
  TTab = array[0..MaxTab-1] of integer;
 
 
procedure remplir(var T: TTab);
var
  n : integer;
begin
  for n := 0 to MaxTab-1 do
    T[n] := Random(100);
end;
 
procedure affiche(T: TTab);
var
  n : integer;
begin
  write('(');
  for n := 0 to MaxTab-1 do
  begin
    write(T[n]:2);
    if n < MaxTab-1 then
      write(', ');
  end;
  writeln(')');
end;
 
procedure sequence(T: TTab; var Count: integer);
var n, OldValue, Oldn, c : integer;
begin
  Count    := 0;
  OldValue := T[0];
  n        := 1;
  while n < MaxTab do
  begin
    Oldn := n;
    c    := 0;
    while (T[n] > OldValue) and (n < MaxTab) do
    begin
      OldValue := T[n];
      inc(c);
      inc(n);
    end;
    if (n > Oldn) and (c > 1) then
      inc(Count)
    else
    begin
      OldValue := T[n];
      inc(n);
    end;
  end;
end;
 
procedure afficheSequences(T: TTab);
var n, m, OldValue, Oldn, Count, c : integer;
begin
  Count    := 0;
  OldValue := T[0];
  n        := 1;
  while n < MaxTab do
  begin
    Oldn := n;
    c    := 0;
    while (T[n] > OldValue) and (n < MaxTab) do
    begin
      OldValue := T[n];
      inc(c);
      inc(n);
    end;
    if (n > Oldn) and (c > 1) then
    begin
      inc(Count);
      write(Count:3,' [',Oldn,'..',n-1,'] = (');
      for m := oldn to n-1 do
      begin
        write(T[m]:2);
        if m < n-1 then
          write(', ');
      end;
      writeln(')');
    end
    else
    begin
      OldValue := T[n];
      inc(n);
    end;
  end;
end;
 
 
 
var
  T : TTab;
  C : integer;
begin
  Randomize;
 
  remplir(T);
  affiche(T);
  Writeln;
 
  Sequence(T, C);
  Writeln('Nombre de sequences trouvees : ', C);
  Writeln;
 
  AfficheSequences(T);
  Writeln;
 
  readln;
end.

[kingmoezhaj]

plutôt :

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
const
  MaxTab = 100;
 
type
  TTab = array[0..MaxTab-1] of integer;
 
 
procedure remplir(var T: TTab);
var
  n : integer;
begin
  for n := 0 to MaxTab-1 do
    T[n] := Random(100);
end;
 
procedure affiche(T: TTab);
var
  n : integer;
begin
  write('(');
  for n := 0 to MaxTab-1 do
  begin
    write(T[n]:2);
    if n < MaxTab-1 then
      write(', ');
  end;
  writeln(')');
end;
 
procedure sequence(T: TTab; var Count: integer);
var n, OldValue, Oldn, c : integer;
begin
  Count    := 0;
  OldValue := T[0];
  n        := 1;
  while n < MaxTab do
  begin
    Oldn := n;
    c    := 0;
    while (T[n] > OldValue) and (n < MaxTab) do
    begin
      OldValue := T[n];
      inc(c);
      inc(n);
    end;
    if (n > Oldn) and (c > 1) then
      inc(Count)
    else
    begin
      OldValue := T[n];
      inc(n);
    end;
  end;
end;
 
procedure afficheSequences(T: TTab);
var n, m, OldValue, Oldn, Count, c : integer;
begin
  Count    := 0;
  OldValue := T[0];
  n        := 1;
  while n < MaxTab do
  begin
    Oldn := n;
    c    := 0;
    while (T[n] > OldValue) and (n < MaxTab) do
    begin
      OldValue := T[n];
      inc(c);
      inc(n);
    end;
    if (n > Oldn) and (c > 1) then
    begin
      inc(Count);
      write(Count:3,' [',Oldn,'..',n-1,'] = (');
      for m := oldn to n-1 do
      begin
        write(T[m]:2);
        if m < n-1 then
          write(', ');
      end;
      writeln(')');
    end
    else
    begin
      OldValue := T[n];
      inc(n);
    end;
  end;
end;
 
 
 
var
  T : TTab;
  C : integer;
begin
  Randomize;
 
  remplir(T);
  affiche(T);
  Writeln;
 
  Sequence(T, C);
  Writeln('Nombre de sequences trouvees : ', C);
  Writeln;
 
  AfficheSequences(T);
  Writeln;
 
  readln;
end.

En tout cas je pense ma solution est juste
merci pour la correction de l'affichage;

[Dr.Who]

oui c'etait juste je pense, juste corrigé deux ou trois truc pour rendre plus clair et eviter les bugs.

attention de ne pas appeler Randomize dans une methode.
Randomize doit s'appeler au début du programme donc dans le bloc principal.

attention à l'indexation des tableaux, si dans TP c'est pas trés important, il est important de s'y habitué quand on passe ou FPK ou Delphi.
donc toujours penser à faire "array [0..Max-1] of" ... toujours indexer à zero.
d'ailleur un exemple dans une grille de sudoku il est plus simple d'effectuer les manipulation sur :
array[0..8, 0..8] ...

plutot que sur :
array[1..9, 1..9] ...

d'ailleur en delphi il n'est pas rare que le compilateur optimise les tableaux d'index <> 0 en les réindexant à zero.
c'est plus simple pour lui, question d'allocation et d'allignement et aussi de performance.

attention aussi aux melanges de while, de repeat et de for.
toujours essayer de ne travailler qu'avec l'un de ceux la.
while avec while
repeat avec repeat
et for avec for.
au maximum.

en fait, si on regarde l'assembleur généré, les imbrications de repeat avec while et for donne un gros bordel innommable de jump et de compteurs ... difficile à analyser.
si on essaye d'harmoniser les boucles, l'assembleur généré devient plus clair et plus explicite. plus facile à analyser, plus propre et donc forcement plus performant.

cela est valable aussi pour les imbrication de if qu'on peu souvent remplacer par des Case Of ... encore une fois, plus performant et propre selon les cas.

attention par contre au ecrasement d'identifiant.
tu declare des variables globales T et N au débuts qui sont en permanence ecrasées par les arguments T et N des méthodes.
de plus attention aux arguments inutiles comme N dans les méthodes qui se remplace par la taille du tableau (constante) et donc evite la monopolisation d'un registre supplementaire pour les arguments.

voila.

[kingmoezhaj]

Merci

[droggo]

Boe,

attention aussi aux melanges de while, de repeat et de for.
toujours essayer de ne travailler qu'avec l'un de ceux la.
while avec while
repeat avec repeat
et for avec for.
au maximum.

Je ne suis pas d'accord.

Chaque type de boucle correspond à un cas particulier, il faut utiliser celui qui correspond au cas traité, même si ça imbrique différents types de boucles.

Et il faut oublier le code généré par TP, les compilateurs plus récents font quand même mieux, bien que très en retrait par rapport aux compilateurs C ou C++.
D'ailleurs, même avec le code de TP, les processeurs récents sont bien plus performants pour une même série d'instruction (je ne parle pas de la fréquence, effet qui est évident, mais du nombre de cycles par instruction + le pipeline amélioré + la prédiction de branchement + ...).
Et de toute manière, sauf cas très critique pour le temps d'exécution (ce qui est globalement rare), la vitesse n'est pas le critère principal.