Discussion :

[afizbawary]

Bonsoir à tous !

J'aurais besoin de votre aide sur cet exercice.

Donc premièrement, je demande à l'utilisateur d'introduire des valeurs dans le tableau. Jusque-là, y'a pas de soucis.
Je dois demander à l'utilisateur quelle valeur il souhaite supprimer.

Alors moi j'ai remplacé les positions où ces valeurs s'y retrouvent par les positions du tableau +1.

En gros, si l'utilisateur tape :
6 5 4 3 2 1 0 (0 arrête l'instruction)

Et puis l'utilisateur souhaite supprimer la valeur "5" du tableau.

Il est censé voir l'impression du tableau comme ceci :
6 4 3 2 1

Mais je voulais savoir s'il y avait pas un autre moyen plus optimal que celui-ci.

Nous n'avons le droit d'utiliser que des "if, for, while".

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
package ex6;
 
import java.util.Scanner;
 
public class Ex6 {
 
    public static void main(String[] args) {
 
        int valeurlue, i, j, k;
        int tab[] = new int[50];
 
        i = 0;
 
        Scanner lectureClavier = new Scanner(System.in);
 
        System.out.println("Introduisez des valeurs entières positives ou négatives !");
        System.out.println("Si une valeur nulle est introduite, arrêt prématuré !");
 
        valeurlue = lectureClavier.nextInt();
 
        while ((valeurlue != 0)&&(i<50))
        {
            tab[i] = valeurlue;
            i = i + 1;
 
            if (i<50)
            {
                valeurlue = lectureClavier.nextInt();
            }
        }
 
        System.out.println("Saisissez une valeur, toutes ses occurrences seront supprimées !");
        valeurlue = lectureClavier.nextInt();
 
        if (valeurlue != 0)
        {
            for (j=0 ; j<=i-1 ; j++)
            {
                while (tab[j] == valeurlue)
                {
                    for (k=j; k<=i-1 ; k++)
                    {
                        tab[k] = tab[k+1];
                    }
                    i = i-1;
                }
            }
        }
 
        if ((valeurlue == 0)||(compteur == i))
        {
            System.out.println("Le tableau ne comportait pas de valeurs similaires à celle entrée par l'utilisateur !");
        }
 
 
        System.out.println("Impression du tableau : ");
 
        for (j=0 ; j<=i-1 ; j++)
        {
            System.out.println(tab[j]);          
        }       
    }  
}

Merci à vous.

[joel.drigo]

Salut,

Dans la boucle

Code :

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

1
2
3
4
5
6
7
while (tab[j] == valeurlue) {
                    for (k=j; k<=i-1 ; k++)
                    {
                        tab[k] = tab[k+1];
                    }
                    i = i-1;
}

Quand tu détectes la valeur qu'on a demandé de supprimer, tu décales toute la suite, et tu le fais tant que la valeur courante correspond à la valeur à supprimer.

Si on veux supprimer par exemple 5, et qu'on a 10 5 successifts, et 20 valeurs après, on va décaler 10 fois 20 valeurs.

Alors qu'on pourrait lorsqu'on détecte la valeur à supprimer chercher le dernier élément suivant qui n'est pas la valeur à supprimer et décaler d'un coup. Avec notre exemple, ça fait un seul décalage de 10 positions d'un coup.
En gérant le cas particulier où on ne trouve pas de valeur différente et dans ce cas, il n'y a même aucun décalage : il suffit de modifier la borne de fin (ton i, qui au passage devrait s'appeler length, ou size, ou count, enfin un truc qui signifie que c'est la taille, surtout que i, c'est pas mal usité comme indice de boucle for, donc risque de confusion, pour ceux qui vont lire ton code.


On peut aussi gérer tout le traitement avec une approche différente, en utilisant un second tableau et deux indices de boucles : on fait avancer l'un de 1 en 1 et l'autre n'avance que quand la valeur dans le premier tableau n'est pas égale à la valeur à supprimer. A la fin, on remplace le premier tableau par le second.

Code pseudocode :

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
 
tab[] tableau
tablength // nombre d'élements dans tab
valeur // valeur à supprimer
 
tab[] temp // nouveau tableau
i indice dans le premier tableau
j <- 0 indice dans le second tableau
 
for( i <- 0; i<tablength; i <- i + 1 ) {
   if ( valeur != tab[i] ) {
        temp[j] <- tab[i]
        j <- j + 1
   }
}
tab <- temp
tablength <- j

[afizbawary]

Un grand merci à toi @joel.drigo !

Que de conseils précieux !

J'ai donc modifié le code avec ce que tu m'as conseillé :

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
package ex6bis;
 
import java.util.Scanner;
 
public class Ex6Bis {
 
    public static void main(String[] args) {
 
        int valeurlue, i, j, compteur;
        int tab[] = new int[50];
        int tabtemp[] = new int[50]; //Tableau temporaire
 
        j = 0;
        compteur = 0;
 
        Scanner lectureClavier = new Scanner(System.in);
 
        System.out.println("Introduisez des valeurs entières positives ou négatives !");
        System.out.println("Si une valeur nulle est introduite, arrêt prématuré !");
 
        valeurlue = lectureClavier.nextInt();
        while ((valeurlue != 0)&&(compteur<50))
        {
            tab[compteur] = valeurlue;
            compteur = compteur + 1;
 
            if (compteur<50)
            {
                valeurlue = lectureClavier.nextInt();
            }
        }
 
        System.out.println("Saisissez une valeur, toutes ses occurrences seront supprimées !");
        valeurlue = lectureClavier.nextInt();
        System.out.println("--");
 
        if (valeurlue != 0)
        {
            for (i=0 ; i<compteur ; i++)
            {
                if (valeurlue != tab[i])
                {
                    tabtemp[j] = tab[i];
                    j = j + 1;
                }
            }
 
        }       
 
        tab = tabtemp;
        compteur = j;
 
        for (i=0 ; i<compteur ; i++)
        {
            System.out.println(tab[i]); 
 
        }
    }  
}

Je n'étais pas au courant que l'on pouvait affecter un tableau à un autre tableau. Alors que c'est bête comme bonjour, il suffisait d'affecter les variables sans crochets comme tu me l'as montré.
Et c'est vrai qu'on utilise moins de boucles dans ce cas.

Si tu peux y rejeter un oeil

[joel.drigo]

Au lieu d'utiliser la taille en dur (la valeur 50), il est préférable d'utiliser la taille du tableau, comme ça si on change la taille du tableau, pas besoin de modifier le reste du code (et on ne risque pas d'oublier une valeur à changer).

Code :

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

1
2
3
4
5
6
7
8
9
10
while ((valeurlue != 0)&&(compteur<tab.length))
        {
            tab[compteur] = valeurlue;
            compteur = compteur + 1;
 
            if (compteur<tab.length)
            {
                valeurlue = lectureClavier.nextInt();
            }
}

et

Code :

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

1
2
int tab[] = new int[50];
int tabtemp[] = new int[tab.length]; //Tableau temporaire

On peut réduire le code de la boucle de saisie, mais c'est déjà d'un niveau un peu moins débutant peut-être :

Code :

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

1
2
3
for(compteur=0 ; compteur<tab.length && (valeurlue=lectureClavier.nextInt())!=0 ; compteur++) {
        	tab[compteur] = valeurlue;
}