Discussion :

[saraHij]

j'ai 2 tableau tab1[6]={0,2,5,1,4,3} et tab2[6]={0,5,3,2,1,4} , je dois prendre la partie {5,1,4} du tab1 extraire l'ordre de ces element {3eme, 1er,2eme} {3,1,2} , faire la méme chose pour les elemnts {3,2,1} du tab2 est avoir l'ordre correspondant qui est :{3,2,1} , puis echanger la partie l'order du {5,1,4} par selon l'ordre qu'on a extrait du tab2 : {3,2,1} : echanger {5,1,4} d'ordre {3,1,2} par l'ordre {3,2,1} ===> {5,4,1} and get tab1[6] ={0,2,5,4,1,3} , et la méme chose pour tab2. actuelement j'ai pu faire la fonction qui extrait l'ordre des 3 element et celle qui fait l'échange des elements , mais ça marche que pour les 3 elements du tableau pas le tableau tous entier :

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
 
#include <stdio.h>
#define swap(a, b) {(a)^=(b); (b)^=(a); (a)^=(b);}
 
void getOrder(int tab[], int n, int pos[]) {
    for (int i = 0; i < n; i++) {
        int count = 0;
        for (int j = 0; j < n; j++)
            count += (tab[j] < tab[i]);
        pos[i] = count;
    }
}
 
 
void exchange(int *A,int *I,int n){
 
	 int i, j, k;
	    for(i = 0; i < n ; i++){
		if(i != I[i]){
		    j = i;
		    while(i != (k = I[j])){
		        swap(A[j], A[k]);
		        I[j] = j;
		        j = k;
		    }
		    I[j] = j;
		}
	    }
 
}
 
 
int main() {
    int tab[3] = { 5, 1, 4 };
 
    int tab2[3] = { 3, 2, 1 };
 
    int pos1[3];
    int pos2[3];
    int n = sizeof(tab) / sizeof(tab[0]);
 
    getOrder(tab, n, pos1);
    for (int i = 0; i < n; i++)
        printf("%d ", pos1[i]);
    printf("\n");
 
    getOrder(tab2, n, pos2);
    for (int i = 0; i < n; i++)
        printf("%d ", pos2[i]);
    printf("\n");
 
    exchange(tab,pos2,n);
 
   for (int i = 0; i < n; i++){
        printf("%d ", tab[i]);
 
	}
 
 
 
    return 0;
}

[Matt_Houston]

À propos de la forme :

• Tu présentes ton sujet de manière assez indigeste. Relis-toi : c'est non seulement une marque de respect envers tes interlocuteurs, mais cela concoure aussi à réorganiser les idées dans ton esprit et mieux appréhender le problème.
• Soigne la mise en page de ton code source : constance et cohérence dans l'indentation et le nommage des variables, utilisation du mot-clef const et des types adéquats (size_t pour les tailles et l'adressage) lorsque c'est nécessaire.
• Modularise ton code, même pour de simples tests. Par exemple l'affichage de tableau que tu répètes trois fois ci-avant peut déjà être confié à des fonctions utilitaires :
  

  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
  void idump(FILE *out, const int *buf, size_t num) {
      fprintf(out, "[ ");
      while (num-- > 0)
          fprintf(out, "%d ", *buf++);
      fprintf(out, "]");
  }
   
  void idumpln(FILE *out, const int *buf, size_t num) {
      idump(out, buf, num);
      fprintf(out, "\n");
  }
   
  #define idumplna(out, array) idumpln((out), (array), sizeof (array) / sizeof (array)[0])
   
  ..
   
  int t[] = { 5, -2 .. 18 };
   
  ..
   
  idumplna(stdout, t);

À propos du fond :

• le Xor-swap et autres tricks du style, c'est le mal. Que crois-tu qu'il se passe lorsque tu exécutes swap(tab[0], tab[0]) ? Le seul vrai value swap, c'est celui-ci : #define swap(type, a, b) { const type t = a; a = b; b = t; } .
• Un seul niveau de boucle suffit pour la fonction exchange (qui devrait plutôt être baptisée reorder, IMHO), la solution est vraiment beaucoup plus simple. Repose ton algo au clair sur papier pour bien comprendre.

[saraHij]

Merci pour vos remarques , mais je tiens a vous informer que l'algorithme demandé n'est pas un simple remplacement , j'ai besoin de passer par ces étapes

[Sve@r]

Bonjour

la solution est vraiment beaucoup plus simple. Repose ton algo au clair sur papier pour bien comprendre.

Sans déconner, t'as vraiment compris ce qu'il veut faire ? Hier je suis resté 10mn à lire et à relire son... "truc" sans rien paner.

Exemple "j'ai 2 tableau tab1[6]={0,2,5,1,4,3} et tab2[6]={0,5,3,2,1,4} , je dois prendre la partie {5,1,4} du tab1 extraire l'ordre de ces element {3eme, 1er,2eme} {3,1,2}". Bon, déjà "5" c'est bien le 3° item de tab1, mais "1" n'est pas le 1er, c'est le 4° !!! Et "4" ce n'est pas le 2° mais le 5°
Ou alors à partir de {5, 1, 4} tu récupères les items [5], [1] et [4] pour arriver à {3, 1, 2}. Alors effectivement tab1[5] vaut bien 3 et tab1[1] vaut 2 (à un moment il écrit {3, 2, 1}) mais tab1[4] ne vaut ni 1 ni 2 mais 4.

A partir de là, j'ai un peu abandonné l'espoir de comprendre...

[saraHij]

Bon le probleme est compliqué et je pense que je l'est mal presenter , sans entrer dans les détails voila le prb ,

supposons que j'ai 2 tableaux :tab1[]={0,2,5,1,4,3} et tab2[]={0,5,3,4,2,1}

je souhaite réordonner une partie du tab1 qui est {5,1,4} selon la position des elements (position et non les elements) correspondant du tab2 {3,4,2}

dans cet exemple : {5,1,4} correspond à {3,1,2} (3th,1st,2nd) et {3,4,2} correspond à { 3,2,1}

donc si on change l'ordre {3,1,2} de {5,1,4} par {3,2,1} ça donne ==> {5,4,1}


c'est une partie d'un travail ,ou j'aurai besoin de garder les positions , j'espere que c'etait un peu plus claire , vos propositions sont les bienvenus !!

[Bousk]

dans cet exemple : {5,1,4} correspond à {3,1,2} (3th,1st,2nd) et {3,4,2} correspond à { 3,2,1}

Avec quelles règles et substances trouve-t-on ces correspondances ?

[saraHij]

{5,1,4} correspond à {3,1,2} , c'est en ordre croissant ,

1 le plus petit correspond à 1 ,

4 le deuxieme ==> 2

5 le troisieme , ==> 3

ce qui donne {3,1,2}

(du plus petit au plus grand)

[Bousk]

Admettons. Sauf que ta règle ne fonctionne pas dans ton 2nd cas

{3,4,2} correspond à { 3,2,1}

Parce que, dans mon monde en tous cas, 4 > 3 > 2.

[Sve@r]

Pfouh j'ai enfin compris.
Le sous-tableau {5, 1, 4} de tab1 est rangé dans l'ordre "3° plus petit", "1er plus petit" et "2° plus petit" donc {3, 1, 2}.
Et le sous-tableau {3, 4, 2} de tab2 est rangé dans l'ordre "2° plus petit", "3° plus petit" et "1er plus petit" donc {2, 3, 1}
Ensuite tu fais en sorte que ton sous-tableau de tab1 soit rangé comme l'est celui de tab2 {2, 3, 1} donc en ayant le 2° plus petit, 3° plus petit et 1er plus petit soit {4, 5, 1}.

J'ai toutefois une autre question: quels sont les paramètres qui te font choisir {5, 1, 4} dans {0, 2, 5, 1, 4, 3} ? C'est fixe ? Variable ? Toujours 3 éléments ? Toujours pris à partir de l'item [2] ?

Sinon première remarque: le rangement initial {3, 1, 2} on s'en bat totalement le steak car mis à part nous fatiguer le cerveau il sert totalement à rien. Tu as {5, 1, 4} et tu veux juste le ranger dans l'ordre {2, 3, 1}.

Perso je verrais une fonction qui retourne un tableau trié (donc {1, 4, 5}) et ensuite, suffirait de récupérer l'item[2], l'item[3] et l'item[1]...

[saraHij]

pour les paramètres qui te font choisir {5, 1, 4} dans {0, 2, 5, 1, 4, 3} , je dois choisir intervalle moi même , depuis une position1 à une post2 , dans cet exemple je prend du 2 jusqu'à 4 ,

J'ai besoin de garder le rangement initial {3, 1, 2} parceque le méme algorithme sera appliqué pour tab2 ( extraire une partie et la réordoner selon les positions correspondant du tab1 {3, 1, 2} )

maintenant je cherche une solution plus optimale du probleme !!

[Sve@r]

maintenant je cherche une solution plus optimale du probleme !!

"plus optimale" pfff... tu cherches surtout une solution tout court !!!

Code c :

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
#include <stdio.h>
void swap(int *x, int *y) {
	int t;
	t=(*x);
	(*x)=(*y);
	(*y)=t;
}
 
void affiche(int t[], size_t n) {
	int i;
	int *pt;
 
	for (i=0, pt=t; i < n; i++, pt++)
		printf("%d ", *pt);
	fputc('\n', stdout);
}
 
// Rang d'une valeur dans un tableau
int rang(int x, int t[], size_t n) {
	int i;
	int r;
	int *p;
 
	r=0;
	for (i=0, p=t; i < n; i++, p++)
		if (*p < x) r++;
	return r;
}
 
// Position d'une valeur dans un tableau ayant un certain rang
int pos(int r, int t[], size_t n) {
	int i;
	int *p;
 
	for (i=0, p=t; i < n; i++, p++)
		if (rang(*p, t, n) == r) return i;
}
 
// Rangement de t1 selon les rangs de t2
void range(int t1[], int t2[], size_t n) {
	int i;
 
	for (i=0; i < n; i++)
		swap(&t1[i], &t1[pos(rang(t2[i], t2, n), t1, n)]);
}

Si j'applique cet algo sur {5, 1, 4} rangé comme {3, 4, 2} (donc 2°, 3°, 1er) ça donne {4, 5, 1} (donc là aussi 2°, 3°, 1er)

Code c :

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

1
2
3
4
5
6
7
8
int main() {
	int t1[]={5, 1, 4};
	int t2[]={3, 4, 2};
 
	affiche(t1, 3);
	range(t1, t2, 3);
	affiche(t1, 3);
}

Et si je l'applique sur {3, 4, 2} rangé comme {5, 1, 4} (donc 3°, 1er et 2°) ça donne {4, 2, 3} (donc là aussi 3°, 1er et 2°)

Code c :

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

1
2
3
4
5
6
7
8
int main() {
	int t1[]={3, 4, 2};
	int t2[]={5, 1, 4};
 
	affiche(t1, 3);
	range(t1, t2, 3);
	affiche(t1, 3);
}

[saraHij]

Merci beaucoup !!!