Discussion :

[sp2308]

Bonjour

Je souhaiterais optimiser mon code .
Un petit exemple :
J ai le tableau X[] {3,9,2}
Apres le tir j obtiens 2,3,9

Mon objectif est de faire la difference entre la position initale de 3 et sa nouvelle position,(0-1 = 1) idem avec les autres valeurs de mon tableau
Pour y parvenir, actuellement je cree un tableau initial, un tableau target qui me servira à trier et remplacer les valeurs et un tableau posi qui me servira à comparer les positions initiales et trier.
A l issue je boucle sur l index que je compare à la vealeur de Posi[index]....
C est lent et peut certainement etre optimisé par le tri d un tableau à 2 dimensions ? Qu en pensez vous ?
Merci pour votre aide, commentaires etc

stéphane

mon code :

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
 
int T = 30;
            Double[] X = { 44.3, 21.3, 31.4, 8.7, 12.8, 45.0, 88.1, 32.0, 53.2, 30.3, 95.8, 50.4, 71.6, 26.7, 3.8, 36, 46, 34.3, 77.2, 55.3, 64.2, 85.5, 18.6, 50.9, 93.6, 26.8, 59, 99.1, 57, 78.1 };
 
double[] target= new double [T];
            int[] posi= new int[T];
            for (int Idx = 0; Idx < T; Idx++)
            {
                target[Idx] = X[Idx];
                posi[Idx] = Idx;
            }
            //---Tri
            for (int k = 0; k < T; k++)
            {
                for (int i = k+1; i < T; i++)
                {
                    if (target[i] < target[k])
                    {
                        double tmp = target[k];
                        target[k] = target[i];
                        target[i] = tmp;
                        int tmp2 = posi[k];
                        posi[k] = posi[i];
                        posi[i] = tmp2;
                    }
                }  
            }
            int Diff;
            int D_t=0;
            for (int i = 0; i < T; i++)
            {
                Diff = posi[i] - i;
                Diff = Diff * Diff;
                D_t = D_t + Diff;
            }

[Pongten]

Avec du Linq peut-être ?

Un petit exemple pour voir si ça correspond bien à ce que tu attends :

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
Int32[] myArray = new Int32[]
            {
                4,
                8,
                2,
                3,
                16,
                12,
                10
            };
 
            var sortedItems = myArray.Select((v, i) => new { Index = i, Value = v }).OrderBy(item => item.Value);
 
            foreach(var item in sortedItems.Select((elem, i) => new {OldIndex = elem.Index, NewIndex = i, Value = elem.Value}))
            {
                Console.WriteLine("Value : {0}, OldIndex : {1}, NewIndex : {2}, Diff : {3}", item.Value, item.OldIndex, item.NewIndex, item.NewIndex - item.OldIndex);
            }
 
            Console.ReadKey();

[DonQuiche]

Bonjour. Il y a une variante de Array.Sort qui prend un tableau de clés et un tableau de valeurs. Si tu passes X pour les clés et, pour les valeurs, un tableau contenant les positions de départ (0, 1, 2, 3, 4...) tu obtiendras ton X trié et un tableau te donnant pour la position d'arrivée la position de départ.

sort({3, 9, 2}, {0, 1, 2}) -> {2, 3, 9}, {2, 0, 1}