Discussion :

[Tuxico]

Bonjour à tous,

voila l'énoncé :

Code :

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

Recherchez des entiers n'apparaissant qu'une fois dans un tableau non-trié et non croissant et les récpuérer .

J'ai pensé à 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
25
26
27
28
29
30
31
32
33
34
35
program trirepetition;
 
var repet,i,l,current : integer;
    tab : array[1..5] of integer;
    tabNoRepet : array[1..5] of integer;
 
begin
 
i := 1;
l := 1;
repet := 0;
 
while(i<=5) do
begin
current := tab[l];
        if(current<>tab[i+1]) then
                begin
                i := i + 1;
                repet := 0;
                 if(i=6) then
                 begin
                 tabNoRepet[l] := tab[i];
                 l := l + 1;
                 end;
                end;
        if(current=tab[i+1]) then
                begin
                repet := 1;
                i := i + 1;
                l := l + 1;
                end;
 
end;
 
end.

seulement le problème est que j'obitens un value outOfrange a cause du i+1 quand celui-ci vaut 5 et je ne vois pas comment parcourir entierement le tableau sans utiliser cela :s cela doit etre tout bete mais bon d'avance merci

[Arnich]

prend i = 2 au depart et compare a tab i et non i+1

ensuite pourquoi une foi que tu c'est que cela se répète tu continu a parcouir le tableau?

[Trap D]

Tu peux faire cet exercice en 3 parcours de tableaux :
premier parcours, tu lis le tableaux à travailler en repérant la plus petite et la grande valeur (soient nmin et nmax les 2 valeurs).
tu crées un tableaux auxiliaire dont la numérotation des éléments va de nmin à nmax, tu initialises ce tableau à zéro;
deuxième parcours : tu parcours le premier tableau et tu incrémentes de 1 les cases correspondantes du tableau auxiliaire.
troisième parcours : tu lis le tableau auxiliaire et tu affiches les nombres dont les cases correpondantes sont à 1.

Cette méthode (tri par casiers) n'est évidemment valable que pour des entiers, mais c'était dans l'énoncé de l'exercice.

[Tuxico]

ah oui je n'y avais pas pensé merci a vous deux ^^

[Tuxico]

Si cela intéresse quelqu'un voila le code que j'ai réalisé

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
program tableaurepettest;
 
var
tab : array[1..5] of integer;
tabverify : array[1..5] of integer;
i,l : integer;
 
begin
 
tab[1] := 103;
tab[2] := 300;
tab[3] := 103;
tab[4] := 220;
tab[5] := 290;
 
i := 1;
l := 2;
 
        while(i<5) do
        begin
                while(tab[i]<>tab[l]) AND (l<=4) do
                begin
                l := l + 1;
                end;
 
                if(tab[i]=tab[l]) then
                begin
                tabverify[i] := 1;
                i := i + 1;
                end;
 
                if(l=5) AND (tab[i]<>tab[l]) then
                begin
                writeln(tab[i]);
                i := i + 1;
                end;
 
        end;
 
end.

[Bloon]

Tu peux faire cet exercice en 3 parcours de tableaux :
premier parcours, tu lis le tableaux à travailler en repérant la plus petite et la grande valeur (soient nmin et nmax les 2 valeurs).
tu crées un tableaux auxiliaire dont la numérotation des éléments va de nmin à nmax, tu initialises ce tableau à zéro;

Si nmin est très petit et nmax très grand, ne risques-tu pas d'occuper énormément de mémoire ?

Suggestion d'algo :

soit A le tableau à traiter, B un tableau trié des éléments rencontrés dans A et C le tableau trié des éléments apparaissant une seule fois dans A :

Code :

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

1
2
3
4
5
6
7
8
pour chaque élément de A
  si A[i] est dans B alors
    retirer A[i] de C
  sinon
    ajouter A[i] dans B
    ajouter A[i] dans C
fin pour
// C contient les éléments n'apparaissant qu'une seule fois dans A

Je pense que le fait de trier B et C doit accélérer le traitement

Bloon

[Trap D]

Si nmin est très petit et nmax très grand, ne risques-tu pas d'occuper énormément de mémoire

Tout à fait, c'est un tri très particulier, mais qui est très efficace lorsqu'on peut l'utiliser.