Discussion :

[pileus]

Exercice: Ecrire un programme qui lit un entier X et un tableau A du type int au clavier et élimine toutes les occurrences de X dans A en tassant les éléments restants. Le programme utilisera les pointeurs P1 et P2 pour parcourir le tableau

voilà ce que j'ai fait mais je ne sais pas pourquoi ça marche pas
merci pour votre aide

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
#include <stdio.h>
#include <conio.h>
int main()
{
    int t[50];
    int n;
    int *p1;
    int *p2;
    int q;
    int nb;
    printf("entrer la dimension du tableau");
    scanf("%d",&n);
    for(p1=t;p1<t+n;p1++){
                       printf("entrer l'element [%d]:    ",p1-t);
                       scanf("%d",p1);
                       }
                       printf("entrer l'élement à afficher");
                       scanf("%d",&q);
                       for(p1=t;p1<t+n;p1++){
                                             while(*p1=!q)
                                             *p2=*p1;
                                             nb++;
                                             }
                                             n=nb;
    for(p2=t;p2<t+n;p2++){
                          printf("%4d",*p2);
                          }
                          printf("\n");
                          getch();
}

[CGi]

Tu utilises le pointeur p2 sans qu'il soit initialisé !

Edit : Mets la balise code, pour afficher ton code correctement !

[Bktero]

Un "bonjour" pour démarrer, un sujet, ça n'a jamais fait de mal....

Bonsoir,

L'identation du code est horrible, j'espère que c'est la faute du copier coller !

L'exercice demande un entier X et un tableau A, pourquoi ne pas les avoir nommé ainsi ?

L'algo est..... tordu ! Pour avoir besoin d'un pointeur p1 et p2 pour parcourir le tableau t de son début à sa fin de manière linéraire ? Pourquoi ne pas faire :

Code :

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

1
2
3
4
 
for(n=0 ; n<sizeof(t)/sizeof([0]); n++)
{
    t[n]; // quelque chose avec le n-ieme élément....

Les pointeurs p1 et p2 sont utiles pour faire les suppressions et surtout le tassement.

Le tableau a une taille de 50. Et si l'utilisateur entre 75 ? Que va t-il se passer ?

Voici un code sans la suppression :

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
#include <stdio.h>
 
int main(void)
{
    int A[50] = {0};
    int X = 0;
    int dim = 50;
    int i = 0;
    int *p1 = A;
    int *p2 = A;
 
    printf("Entrer le nombre d'elements souhaites : ");
    scanf("%d", &dim);
 
    if(dim > 50)
    {
        dim = 50;
        printf("Troncature a 50\n");
    }
 
    printf("Valeur a eliminer ? = ");
    scanf("%d", &X);
 
    for(i=0; i<dim; i++)
    {
        printf("Entrer l'element [%d] : ", i);
        scanf("%d", &A[i]);
    }
 
 
    printf("Tableau avec suppression de '%d'\n", X);
    for(i=0; i<dim; i++)
    {
        printf("%d ", A[i]);
    }
 
    // for( ?? ) pour supprimer et tasser
 
    // noublions pas de sauvegarder la nouvelle taille :
    dim = 4;
 
 
    printf("Tableau apres suppression de '%d'\n", X);
    for(i=0; i<dim; i++)
    {
        printf("%d ", A[i]);
    }
 
    return dim;
}

C'est tentant quand l'énoncé dit "utiliser 2 pointeurs pour parcourir le tableau" de les utiliser tout le temps, mais il faut savoir rester calme, réfléchir un peu et écrire son algo en français, sur du papier, avant de vouloir le faire en C sur son éditeur préféré.

Prenez le temps de réfléchir un peu et tout ira mieux

[diogene]

Sur le principe du tassement du tableau et de l'utilisation des deux pointeurs :
- Un pointeur, disons p1, pointe sur la position où on va lire dans le tableau
- l'autre pointeur, p2, pointe sur la position où on va écrire dans le tableau

(0) Au départ, p1 et p2 sont placés au début du tableau.
(1) Si *p1 est à éliminer, alors on incrémente p1
(2) Si *p1 est à garder, alors on le copie à la position p2, on incrémente p1 et p2Et on fait cela jusqu'à ce que p1 ait parcouru tout le tableau.
Note : on peut retrouver le nombre d'éléments restant dans le tableau en faisant la différence entre p2 et l'adresse du début du tableau.

Pour illustrer, en notant '>' p1 et '<' p2 et la règle utilisée entre (), on veut éliminer x du tableau

      x   1   x   2   x   3   4   x
(0) <>x   1   x   2   x   3   4   x  
(1)  <x  >1   x   2   x   3   4   x   
(2)   1  <1  >x   2   x   3   4   x    
(1)   1  <1   x  >2   x   3   4   x   
(2)   1   2  <x   2  >x   3   4   x    
(1)   1   2  <x   2   x  >3   4   x    
(2)   1   2   3  <2   x   3  >4   x    
(2)   1   2   3   4  <x   3   4  >x    
(1)   1   2   3   4  <x   3   4   x >  
Résultat
      1   2   3   4   x   3   4   x    n=4

[Bktero]

Pas bête le coup d'écraser les éléments tant qu'on n'a pas trouvé d'élément à éliminer, on réduit la complexité

[orthomimi]

Bonjour

Je recherchais une manière élégante de supprimer des éléments d'un tableau et je suis tombé sur cet ancien post que je me suis permis de réouvrir.

Comme j'avais du mal à écrire l'astuce de Diogène en passant par deux pointeurs, j'ai mis au clair mes idées avec ce petit programme qui résume ce qu'il a écrit, mais en n'utilisant que le pointeur initial ( mais je le remercie pour son idée ).

Le but, ici, est d'éliminer d'un tableau d'int, ceux qui sont impairs , de remettre à zéro les autres et de réallouer la mémoire utile.

J'ai mis en PJ le programme sous Sublime Text.

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
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char const *argv[])
{
	int i=0,j=0,k=0,n=20,*tab=malloc(n*sizeof(*tab));
	if(tab==NULL)exit(-1);[/B]
 
	//  remplissage du tableau  //
 
	for(i=0;i<n;i++)tab[i]=i+1;
 
	//  impression tableau initial //
 
	for(i=0;i<n;i++)printf("%d\n",tab[i]);
 
	//
 
	puts("\n");
 
	//  élimination des éléments impairs du tableau  // 
 
	i=0;
	while(i<n)
	{
		while((*(tab+i))%2!=0)i++;
		tab[j]=*(tab+i);
		i++;
                j++;
	}
 
	// mise a 0 des éléments impairs restants
 
	for(k=j;k<n;k++)tab[k]=0;
 
	/// réallocation à j éléments ///
 
	tab=realloc(tab,j*sizeof(*tab));
	if(tab==NULL)exit(-1);
 
	/// résultat : reste les nbs pairs  ///
 
	for(k=0;k<n;k++)printf("%d\n",tab[k]);
 
	//  libération du pointeur //
 
	free(tab);
		return 0;
}

Merci pour cette belle astuce : et pour Diogène, j'utilise beaucoup realloc quand je ne connais pas la taille du tableau à créer, car j'ai découvert cela en lisant ses posts...et j'adore Glenn Gould !