Partage

zArray1D

Réponses

<< 1 2 3 4 5

9 février 2010 à 0:02:13

Citation : Monsieur_JaKy

candide > Je ne vois pas trop où est le problème, car j est toujours inférieur ou égal à i.

Si ton tableau commence par 42 éléments non nuls (et donc qui ne seront pas déplacés à la fin du programme), tu vas recopier chacun de ces éléments sur lui-même ce qui est absurde.

GurneyH

9 février 2010 à 3:56:06

Citation : Pouet

@ GurneyH : Ca met combien de temps pour avoir le résultat ton truc ? je l'ai laissé tourner 30 minutes en vain
Niveau mémoire ça pompe bien par contre 16 Go de mémoire virtuelle + 2 Go de mémoire 'normale'

Aïe, Aîe... :honte:

Mon code est un excellent candidat pour le bêtisier 2010.

J'ai eu la chance de ne jamais tomber sur un nombre trop grand. En plus pour ceux qui ont des entiers 64 bits, c'est moyen. :'(

Stocker l'arbre dans un tableau c'est nul ici... A l'arrivée j'ai le même problème que la méthode linéaire(occupation mémoire), mais en moins efficace, et plus buggé...

J'ai fais très fort, là... Collector :-°

Pour revenir à l'exercice 6(il mieux celui là! )

J'ai essayé la version de mob et de Pouet.
Celle de mob est vraiment efficace. Pouet, ta fonction est en O(N^2), et ne retourne pas la bonne valeur.

Dans le même genre, j'ai ça.

/* -------------------------------------------------------------------------- */
int partition(int *t, int lft, int rgt)
{
    int pvt = t[lft];
    int iPvt = lft;
    int i;
    for (i = lft + 1; i <= rgt; ++i)
        if (t[i] < pvt)
        {
            t[iPvt] = t[i];
            t[i] = t[++iPvt];
        }

    t[iPvt] = pvt;

    return iPvt;
}



int select(int *t, int p, int r, int i)
{
    if (p == r)
        return t[p];
    else
    {
        int q = partition(t, p, r);
        int k = q - p + 1;
        if(i == k)
            return t[k];
        else if(i < k)
            return select(t, p, q - 1, i);
        else
            return select(t, q + 1, r, i - k);
    }
}



int kEmeEltSelect(int *t, int n, int k)
{
    return select(t, 0, n - 1, k);
}

Un peu moins bien que mob... Reste à essayer la version en O(N) dans le pire des cas. Il me reste également à essayer d'avoir une solution correcte pour le 7. :-°

)

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

9 février 2010 à 19:27:34

Citation : GurneyH

Pouet, ta fonction est en O(N^2), et ne retourne pas la bonne valeur.

Ah ... pour le dernier code que j'ai posé ?
Si c'est celui-là je suis pas trop d'accord pour le O(N^2) (c'est le qsort sans appel récursif :-°

). Après pour les mauvaises valeurs, tu peux me faire voir avec quoi tu testes stp ?

Arthurus

9 février 2010 à 20:02:54

@Pouet : Il marche pas ton tri !! (ou bien j'ai pas su l'utiliser alors)

#include <stdio.h>
#include <stdlib.h>

#define taille(tab) sizeof(tab)/sizeof(int)

void swap(int * tab, int x, int y) {
	int tmp = tab[x];
	tab[x] = tab[y];
	tab[y] = tmp;
}

void tri(int * tab, int * gauche, int * droite, int * pivot) {
	do {
		while (*gauche < *droite && tab[*droite] > tab[*pivot])
			(*droite)--;
		
		while (*gauche < *droite && tab[*gauche] <= tab[*pivot])
			(*gauche)++;
		
		if (*gauche < *droite)
			swap(tab, *gauche, *droite);
		else
			break;
	} while (1);
}

void affiche(int *tab,int t) 
{
	int i;
	for(i=0;i<t;i++)
		printf("%d ",tab[i]);
	printf("\n");
}

int main () 
{
	int tab[] = {2,2,4,6,4,1,8};
	int g=0,d=taille(tab)-1,p=2;
	affiche(tab,taille(tab));
	tri(tab,&g,&d,&p);
	affiche(tab,taille(tab));
	return 0;
}

arthurus@Arthurus-Laptop:~/sdz$ ./toto 
2 2 4 6 4 1 8 
2 2 4 1 4 6 8

Lithrein

9 février 2010 à 20:15:53

Citation : Arthurus

@Pouet : Il marche pas ton tri !! (ou bien j'ai pas su l'utiliser alors)

Citation : Pouet_forever

Le but n'est pas de trier le tableau, mais uniquement de chercher la bonne valeur

Arthurus

9 février 2010 à 20:21:21

Je l'avais pas vu (et puis pourquoi l'appeler tri ?! moi j'ai vu tri, j voulais tester

)

Pouet_forever

9 février 2010 à 20:39:54

Comme ça

En général je suis pas très inspiré sur les noms de variables/fonctions donc je met ce qui me passe par la tête :lol:

simpsonmaniac

9 février 2010 à 20:57:34

J'ai trouvé une solution pour le triangle de Pascal (je ne sais pas si c'est valable parce que j'utilise un tableau à deux dimensions pour stocker les lignes)

void print_r(int *tableau, int tailleTableau)
{
    int i;
    for(i=0; i<tailleTableau; i++){
        printf("%d ", tableau[i]);
    }
    putchar('\n');
}

void pascal(unsigned int numrows)
{
    int i;
    int j;
    int jlimit;
    int row1[] = {1};
    int row2[] = {1,1};
    int *rows[numrows];
    rows[0] = row1;
    if(numrows >= 2){
        rows[1] = row2;
    }
    for(i=2, jlimit = 3; i<numrows; i++, jlimit++){
        rows[i] = (int*)calloc(jlimit, sizeof(int));
        if(!rows[i]){
            perror("Malloc failed ");
        }
        rows[i][0] = 1;
        rows[i][jlimit-1] = 1;
        for(j=1; j<jlimit-1; j++){
            rows[i][j] = rows[i-1][j] + rows[i-1][j-1];
        }
    }
    for(i=0; i<numrows; i++){
        print_r(rows[i], i+1);
        if(i >= 2){
            free(rows[i]);
        }
    }
}

EDIT : Nouvelle solution pour pascal:

void print_row(int *tableau, int tailleTableau)
{
    int i;
    for(i=0; i<tailleTableau; i++){
        printf("%d ", tableau[i]);
    }
    putchar('\n');
}

void pascal(size_t sz)
{
    unsigned int i;
    unsigned int j;
    int *tab = NULL;
    for(i=1; i<=sz; ++i){
        tab = (int *)realloc(tab, i*sizeof(int));
        tab[0] = 1;
        tab[i-1] = 1;
        for(j=(i >= 2) ? i-2 : i-1; j > 0; j--){
            tab[j] = tab[j-1]+tab[j];
        }
        print_row(tab, i);
    }
}

Pouet_forever

10 février 2010 à 0:05:55

Bon j'ai trouvé mes erreurs (oui yen avait plusieurs :-°

). J'ai fait des tests avec vos codes et je suis à peu près au même niveau que le mi-qsort. En fait ça dépend du choix du pivot

Sur certains tableaux il sera plus performants et sur d'autres ce sera mon code

#define SWAP(tab, x, y) { int tmp = tab[x]; tab[x] = tab[y]; tab[y] = tmp; }

void tri(int * tab, int * gauche, int * droite, int * pivot) {
	do {
		while (*gauche < *droite && tab[*droite] > tab[*pivot])
			(*droite)--;
		SWAP(tab, *gauche, *droite);
		*pivot = *droite;
		
		while (*gauche < *droite && tab[*gauche] <= tab[*pivot])
			(*gauche)++;
		SWAP(tab, *gauche, *droite);
		*pivot = *gauche;
		
	} while (*gauche < *droite);
}

int kEmeElt(int * tab, int sz, int k) {
	int pivot = 0;
	int debut = 0;
	int fin = sz - 1;
	int gauche = debut;
	int droite = fin;
	
	if (sz < 0 || k < 0 || k >= sz)
		return 0;
	
	do {
		tri(tab, &gauche, &droite, &pivot);
		
		if (k == pivot)
			break;
		else if (k < pivot)
			fin = pivot - 1;
		else
			debut = pivot + 1;
		
		gauche = debut;
		droite = fin;
		pivot = gauche;
	} while (1);
	
	return tab[pivot];
}

Pour le 'tri' j'ai repris ce que j'avais fait dans un autre topic :-°

ce que j'avais fait là ne fonctionne pas correctement

GurneyH

10 février 2010 à 4:02:18

Citation : Simpsonmaniac

J'ai trouvé une solution pour le triangle de Pascal (je ne sais pas si c'est valable parce que j'utilise un tableau à deux dimensions pour stocker les lignes)

Disons qu'un des buts de cet exercice était de vous faire recourir à un petite astuce, qui consiste à utiliser 2 tableaux à une dimension et à échanger les pointeurs.

Voir aussi que pour construire la ligne courante, tu n'as besoin que de la ligne précédente, c'est inutile d'avoir une grille[N][N], même si tu n'alloue que la mémoire nécessaire pour chaque ligne.

@Pouet: pour la complexité en O(N ^ 2), je parlais bien de ce code, , avant correction.

Maintenant, effectivement les performances de ton code et de celui de mob sont très proche.

Concernant la solution linéaire même dans le pire des cas, il semble que l'intérêt soit surtout théorique, donc j'en reste là.

Pour l'exercice sur le mode, avec une grande plage de valeurs, et un tableau de très grande taille, il va être dur de faire mieux qu'une table de hashage...

Mais sans prise de tête qsort + parcours linéaire, ça reste plutôt efficace.

Zeste de Savoir, le site qui en a dans le citron !

Adroneus

10 février 2010 à 11:16:27

voici ma solution pour le triangle de pascal :

void     print_table(int *Grid, int Sz)
{
 int     iter;
 int     j;
 int     i;

 iter = 0;
 i = 0;
 j = 1;
 while ( iter < Sz )
	{
		i++;
		printf("%d\t", Grid[iter]);
		if ( i == j )
			{
			    i = 1;
			    putchar('\n');
			    if ( j == 1)
                    j += 2;
                else
                    j++;
			}
		iter++;
	}
}
void     pascal_stock(u_int n)
{
 int     i;
 int     j;
 int     iter;
 int     *pasc;
 int     nboccur;

 nboccur = (((n * n) / 2) + (n / 2));
 pasc = malloc(nboccur * sizeof(int));
 i = 0;
 j = 1;
 iter = 1;
 while ( i < nboccur )
	{
	    if ( j < 3 )
            pasc[i] = 0;
        else
            pasc[i] = pasc[i - j] + pasc[i - j + 1];
	 	if ( iter == j )
			{
				iter = 1;
				pasc[i] = 1;
				i++;
				pasc[i] = 1;
				j++;
			}
		iter++;
		i++;
	}
 pasc[i] = 1;
 if ( n != 0 )
    print_table(pasc, nboccur);
}

Edit : ouh la il a quoi le zCode? il aime pas mes indentations?

Edit : Voila, bon c'est une solution naive, j'ai observé l disposition du tableau et j'ai fais l'algo qui me paraissait le plus naturel... après c'est certainement pas le plus simple

GurneyH

10 février 2010 à 11:35:44

Citation : Adronéus

voici ma solution pour le triangle de pascal :

Effectivement ton code est compliqué...

Pour ton problème d'indentation, il faut que tu configures ton éditeur de texte pour remplacer les tabulations par des espaces.

Sinon, en général, c'est bien de tester le retour de malloc . free c'est pas mal non plus...

Pour le tracé simple du triangle :

Pour une ligne lin, et une colonne col.

tab[lin][0] = 1, tab[lin][col] = 1;
tab[lin][col] = tab[lin - 1][col - 1] + tab[lin - 1][col]

C'est pas plus compliqué.

Zeste de Savoir, le site qui en a dans le citron !

Adroneus

10 février 2010 à 11:43:08

Voui, je le ferai tout a l'heure, pas trop le temps la

merci, j'éditerai.

Mais la solution que t'as montré c'est pour un tableau bidimensionnel non?

GurneyH

10 février 2010 à 11:56:38

Citation : Adroneus

Mais la solution que t'as montré c'est pour un tableau bidimensionnel non?

C'est une solution qui utilise 2 tableaux, ou 1...

#include <stdio.h>

void afficherLigne(int *t, int n)
{
    int i;

    for(i = 0; i <= n; ++i)
        printf("%3d ", t[i]);
    puts("");
}



void trianglePascal(int n)
{
    int tab[100] = {0};
    int lin, col;

    for(lin = 0; lin < n; lin++)
    {
        tab[0] = 1;
        for(col = lin; col >= 1; col--)
            tab[col] = tab[col] + tab[col - 1];

        afficherLigne(tab, lin);
    }
}


int main(void)
{
    trianglePascal(10);

    return 0;
}

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

10 février 2010 à 19:40:55

Citation : GurneyH

Mais sans prise de tête qsort + parcours linéaire, ça reste plutôt efficace.

Et beaucoup moins couteux en mémoire :lol:

Bon comme personne n'a l'air de vouloir faire la méthode que tu dis je l'ai faite

#include <stdio.h>
#include <stdlib.h>

#define SWAP_PTR(p1, p2) { int * tmp = p1; p1 = p2; p2 = tmp; }

void affiche_ligne(int * tab, int n) {
	int i;
	for (i = 0; i < n; i++) {
		printf("%d ", tab[i]);
	}
	puts("");
}

void trianglePascal(int n) {
	int tab_0[100] = { 1 };
	int tab_1[100] = { 1 };
	int * tab_p = tab_0;
	int * tmp_p = tab_1;
	int i, j;
	
	for (i = 1; i <= n; i++) {
		for (j = 1; j < i; j++)
			tmp_p[j] = tab_p[j-1] + tab_p[j];
		
		affiche_ligne(tmp_p, j);
		SWAP_PTR(tab_p, tmp_p)
	}
}

int main (void) {
	trianglePascal(10);
	
	return EXIT_SUCCESS;
}

GurneyH

11 février 2010 à 3:55:36

Citation : Pouet_forever

Bon comme personne n'a l'air de vouloir faire la méthode que tu dis je l'ai faite

Merci.

Zeste de Savoir, le site qui en a dans le citron !

mob

11 février 2010 à 16:45:42

Citation : GurneyH

Maintenant, effectivement les performances de ton code et de celui de mob sont très proche.

C'est normal étant donné que c'est le même algorithme. La seule différence c'est le choix du pivot : je choisis toujours l'élément au milieu du tableau et Pouet_forever choisit toujours le premier élément comme pivot.

Je n'ai pas testé mon code sur un tableau déjà trié avec k le dernier élément du tableau, mais il me semble que c'est le pire cas pour celui de Pouet_forever. (O(n²))

darkipod

12 février 2010 à 9:14:41

bonjour,
j'ai refait (c'est un bien grand mot) les premiers exos versus pointeurs !
En fait je crois pas avoir atteint le but recherché quand je vois certains codes.
(que je ne comprends toujours pas !

)
exemple celui d'andoneus:

#include <stdio.h>


int       indexMin(int *, int);
int       indexMax(int *, int);
void      afficherEltCommuns(int *, int *, int, int);
void      xchang(int *, int, int);
void      triCroissant(int *, int);
void      triDecroissant(int *, int);
int       indexNul(int *, int);
void      zeroADroite(int *, int);

typedef unsigned int u_int;

int     indexMin(int *grid, int SizeGrid)
{
 int     iter;
 int     posit;

 iter = -1;
 posit = 0;
 while ( ++iter < SizeGrid )
	if ( *(grid + iter) < *(grid + posit) )
		posit = iter;
 return (posit);
}

int indexMax(int *grid, int SizeGrid)
{
 int     iter;
 int     posit;

 iter = -1;
 posit = 0;
 while ( ++iter < SizeGrid )
 	{
		if ( *(grid + iter) >= *(grid + posit) )
			posit = iter;
	}
 return (posit);
}

void    afficherEltCommuns(int *grid1, int *grid2, int Sz1, int Sz2)
{
 int     i;
 int     j;

 i = -1;
 while ( ++i < Sz1 )
	{
		j = 0;
		while ( (j < Sz2) && ((*(grid1 + i)) != (*(grid2 + j))) )
			j++;
		if ( (*(grid1 + i)) == (*(grid2 + j)) && (j != Sz2 ))
			printf("%d\n", *(grid1 + i));
	}
}

void      xchang(int *Grid, int pos1, int pos2)
{
 int     temp;

 temp = *(Grid + pos1);
 *(Grid + pos1) = *(Grid + pos2);
 *(Grid + pos2) = temp;
}

void      triCroissant(int *Grid, int SzGrid)
{
 int     min;
 int     iter;

 iter = -1;
 while ( ++iter < SzGrid )
	{
		min = indexMin(Grid + iter, SzGrid - iter);
		xchang(Grid + iter, min, 0);
	}
}

void     triDecroissant(int *Grid, int SzGrid)
{
 int     min;
 int     iter;

 iter = -1;
 while ( ++iter < SzGrid )
	{
		min = indexMax(Grid + iter, SzGrid - iter);
		xchang(Grid + iter, min, 0);
	}
}

int       indexNul(int *Grid, int SzGrid)
{
 int     iter;

 iter = -1;
 while ( ++iter < SzGrid )
	{
		if ( Grid[iter] == 0 )
			return (iter);
	}
 return (-1);
}

void      zeroADroite(int *Grid, int SzGrid)
{
 int     index;

 while ( SzGrid >= 0 )
	{
		index = indexNul(Grid, SzGrid);
		if ( index != -1 )
			{
				while ( index < SzGrid - 1 )
					{
						xchang(Grid, index, index + 1);
						index++;
					}
			}
		SzGrid--;
	}
}

voici mon code pour faire avancer le shimiliblick :lol:

#include <stdio.h>
#include <stdlib.h>

#define TAILLE(a) (sizeof(a)/sizeof *(a))
#define echange(a,b) int c;c=a;a=b;b=c



int indexMin(int tableau[], int tailleTableau);
int indexMax(int tableau[], int tailleTableau);
void afficherEltCommuns(int t1[], int t2[],int tailleTableau1,int tailleTableau2);
void affiche(int tableau[], int tailleTableau);
void triCroissant(int tableau[], int tailleTableau);
void triDecroissant(int tableau[], int tailleTableau);
void zeroADroite(int tableau[], int tailleTableau);





int main(void)
{
    int tableau[] = {1, 0, 4, 0, 0, -7};
    int tableau1[] = {0, 1, -1, 3, 8};
    int tableau2[] = {10, 1, 11, 7, 98, 8, 7, 8};
    int tableau3[] = {0,1,10,11,10};
    int tableau4[] = {10,1,11,7,98,8,7,10};

    printf("n de l'index du chiffre le plus petit : %d\n",indexMin(tableau,TAILLE(tableau)));//exo1
    printf("n de l'index du chiffre le plus grand : %d\n",indexMax(tableau,TAILLE(tableau)));//exo2
    afficherEltCommuns(tableau1, tableau2,TAILLE(tableau1),TAILLE(tableau2));//exo3
    afficherEltCommuns(tableau3, tableau4,TAILLE(tableau3),TAILLE(tableau4));//exo3


    printf("\ntableau a trier :");//exo 4
    affiche (tableau1,TAILLE(tableau1));
    triCroissant(tableau1,TAILLE(tableau1));
    printf("\ndans l'ordre croissant :");
    affiche (tableau1,TAILLE(tableau1));
    triDecroissant(tableau1,TAILLE(tableau1));
    printf("\ndans l'ordre decroissant :");
    affiche (tableau1,TAILLE(tableau1));

    printf("\n\n exo ZERO a droite :");
    affiche (tableau,TAILLE(tableau));
    zeroADroite(tableau,TAILLE(tableau));
    affiche (tableau,TAILLE(tableau));


    return 0;
}

int indexMin(int tableau[], int tailleTableau)
{
    int resultat=0;
    int i;

    for (i=1;i<tailleTableau;i++)
    {
        if (*(tableau+resultat)>*(tableau+i))
        {
            resultat = i ;
        }
    }
    return resultat;
}

int indexMax(int tableau[], int tailleTableau)
{
    int resultat=0;
    int i;
    for (i=1;i<tailleTableau;i++)
    {
        if (*(tableau+resultat)<*(tableau+i))
        {
            resultat = i;
        }
    }
    return resultat;
}

void afficherEltCommuns(int t1[], int t2[],int tailleTableau1,int tailleTableau2)
{
    int i, j;
    int flag[100]={0};
    printf("les elements identiques des deux tableaux sont : ");
    for (i=0;i<tailleTableau1;i++)
    {
        for (j=0;j<tailleTableau2;j++)
        {
            if ((*(t1+i) == *(t2+j)) && (*(flag+j)!=1))
            {
                *(flag+j)=1;
                break;//
            }
        }
        if (*(flag+j)==1)
        {
            printf(" %d ",*(t2+j));
        }
    }


    printf("\n");
}

void affiche(int tableau[], int tailleTableau)
{
    int *end=tableau + tailleTableau;
    printf("\n");
    for (;tableau != end;tableau++)
    {
        printf (" %d ",*tableau);
    }
}

void triCroissant(int tableau[], int tailleTableau)
{
    /*
        1.On recherche l'index de la valeur maxi
        2.On insère l'élément max à la bonne position dans le tableau
        3.On répète les 2 premières opérations sur le reste du tableau tant que le tableau n'est pas entièrement trié
    */
    int index,i;
    for (i=0;i<tailleTableau;i++)
    {
        index =indexMax(tableau, tailleTableau-i);
        echange(*(tableau+index),*(tableau+tailleTableau-i-1));
    }
}

void triDecroissant(int tableau[], int tailleTableau)
{
    /*
        1.On recherche l'index de la valeur mini
        2.On insère l'élément max à la bonne position dans le tableau
        3.On répète les 2 premières opérations sur le reste du tableau tant que le tableau n'est pas entièrement trié
    */
    int index,i;
    for (i=0;i<tailleTableau;i++)
    {
        index =indexMin(tableau, tailleTableau-i);
        echange(tableau[index],tableau[tailleTableau-i-1]);
    }
}

void zeroADroite(int tableau[], int tailleTableau)
{
    int i,j,k;
    i=0;
    k=0;//compteur de boucle secondaire
    while ((i<tailleTableau)&&(k<tailleTableau))//pas trouve autre chose pour eviter une boucle infinie i+k tour maximum
    {
        if (tableau[i]==0)
        {
            //alors on decale vers la droite
            for (j=i;j<(tailleTableau-1);j++)
            {
                *(tableau+j)=*(tableau+j+1);
            }
            k++;
            *(tableau+tailleTableau-1)=0;
        }
        else
        {
            i++;
        }
    }
}

j'ai uniquement compris que :
- tableau[i] est equivalant à *(tableau+i)
- tableau est un pointeur qui pointe sur le premier element:tableau[0]
- tableau++ permet d'acceder à l'element suivant tableau[1] etc...
ce qui me fait penser qu'on gere un peu comme une liste simple chainée ?
quel est intérêt de se compliquer l'existence ? :euh:

GurneyH

12 février 2010 à 9:25:57

Salut

*(tableau+i) et tableau[i]

sont strictement identique, et comme tu le dis, se compliquer l'existence ne sert à rien.
Seulement certains, utilisent cette notation, et c'est toujours bien de ne pas être largué lorqu'on la rencontre.

Sinon, ce n'était pas ce qui était demandé... Un exemple pour une simple boucle

void affiche(int tableau[], tailleTableau)
{
    int i;
    for(i = 0; i < tailletableau; i++)
        printf("%d ", tableau[i]);

    puts("");

}

Là même avec pointeur

void affiche(int tableau[], tailleTableau)
{
    int *fin = tableau + tailleTableau;
    for(;tableau < fin; tableau++)
        printf("%d ", *tableau);

    puts("");

}

Zeste de Savoir, le site qui en a dans le citron !

darkipod

12 février 2010 à 11:12:21

Merci pour ces precisions Gurney,
j'ai cependant du mal à passer ce cap....je l'ai fais pour une seule fonction,
j'attends la correction du mois pour comprendre le reste :-°

Pouet_forever

12 février 2010 à 18:02:03

@mob : J'avais pas vu que tu avais fait ça :-°

j'avais juste vu les fonctions avec qsort :euh:

Le mieux serait de prendre un nombre aléatoire

mob

12 février 2010 à 23:08:19

Pouet_forever: Je sais j'ai juste indiqué ça pour expliquer le fait qu'il n'y ai pas beaucoup de différences dans les performances.

Le mieux en fait serait de prendre la médiane du tableau, mais ça induit d'autres calculs qui peuvent être plus ou moins coûteux. (Enfin il me semble)

E.Honda

6 mai 2011 à 11:28:18

Voici le code de l'exercice afficher les communs :

fonction:

void afficherEltCommuns(int tableau1[], int tableau2[], int tailleTableau1, int tailleTableau2)
{
    int commun=0,i,j;

    for( i = 0; i < tailleTableau1; i++ )
    {
        for( j = 0; j < tailleTableau2; j++ )
        {

            if (tableau1[i] == tableau2[j] )
            {
                commun=tableau1[i];
                printf(" %d ",commun);
            }
        }
    }


}

main:

int main(int argc, char*argv[] )
{
    int tableau1[5]={3,69,48,7,5}, tableau2[6]={5,3,7,42,78,9};
    afficherEltCommuns( tableau1, tableau2, 5, 6);
    return EXIT_SUCCESS;
}

Steins;Gates too too roo

GurneyH

6 mai 2011 à 13:38:50

Bonjour

C'est un peu plus compliqué que ça,(l'énoncé est je l'avoue peu clair). :-°

Si tu 2 tableaux t1 et t2 avec

t1 = [0, 10, 2, 3, 10];
t2 = [10, 5]
l'élément commun est 10, 1 seule fois.

L'idée est de pouvoir réaliser des paires entre les 2 tableaux.

Zeste de Savoir, le site qui en a dans le citron !

E.Honda

6 mai 2011 à 19:38:55

Ah d'accord, merci pour l'info !

Maintenant c'est plus difficile pourtant je vois pas où je doit intervenir.
Le problème ce que ma fonction affiche tout les communs car il parcourt le tableau, je me demande comment faire pour dire " quand tu vois une paire sauvegarde une des valeur et continu de parcourir le tableau..." .
Mais je m'adresse pas au bon endroit désolé encore !

Cordialement,
Moustiko.

Steins;Gates too too roo

GurneyH

6 mai 2011 à 19:48:47

Si, c'est bien le bon endroit.

Une solution possible, est de mettre une valeur signifiant "utiliser" dans tes tableaux, pour chaque paire trouvée.

Ensuite, lorsque tu itères et que tu rencontres ce marqueur, tu passes à l'index suivant, tout simplement.

Zeste de Savoir, le site qui en a dans le citron !

E.Honda

7 mai 2011 à 16:10:31

Bonjour,

Euh j'ai du mal à interpréter ce que tu dis.

Ce que j'ai compris:

je doit inscrire une valeur dans un tableau que j’utiliserais comme marqueur pour chaque paire trouvé ???

Cordialement,
Moustiko.

Steins;Gates too too roo

GurneyH

7 mai 2011 à 17:21:07

Non, tu as bien interprété, tu peux utiliser un tableau supplémentaire.

Sinon
lien vers la correction.

Je pense que c'est le plus simple.

Zeste de Savoir, le site qui en a dans le citron !

<< 1 2 3 4 5

zArray1D

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.

× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.

zArray1D

Réponses

zArray1D

Supprimer

Modérer

Signaler le message aux modérateurs