Discussion :

[StabiloHB]

Bonjour à tous,

J'ai un array de taille n*3, j'ai réussi à le trier par la troisième colonne, maintenant je voudrais sortir dans une liste, pour chaque différent indice de la colonne 3 ici 1, 2, 3 et 4, le "parcours" en partant de 0 voici l'exemple pour mieux comprendre.

Code :

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

1
2
3
4
5
6
7
8
9
import numpy as np
 
x=[[0, 3, 3], [0, 7, 4], [0, 8, 1], [0, 10, 2], [1, 11, 3], [2, 12, 1], [3, 13, 3], [4, 14, 4], [5, 15, 2], [6, 16, 3], [7, 17, 4], [8, 9, 1],
   [9, 18, 1], [10, 20, 2], [11, 21, 3], [12, 21, 1], [13, 6, 3], [14, 21, 4], [15, 21, 2], [16, 1, 3], [17, 4, 4], [18, 19, 1], [19, 2, 1], [20, 5, 2]]
 
array = np.array(x)
 
columnIndex=2
sortedArray = array[array[:,columnIndex].argsort()]

ce qui me donne donc :

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
[[ 8  9  1]
 [18 19  1]
 [ 0  8  1]
 [12 21  1]
 [ 2 12  1]
 [ 9 18  1]
 [19  2  1]
 [15 21  2]
 [10 20  2]
 [20  5  2]
 [ 5 15  2]
 [ 0 10  2]
 [ 3 13  3]
 [11 21  3]
 [ 1 11  3]
 [13  6  3]
 [16  1  3]
 [ 6 16  3]
 [ 0  3  3]
 [ 7 17  4]
 [ 4 14  4]
 [14 21  4]
 [17  4  4]
 [ 0  7  4]]

Je devrais donc avoir autant de listes finales que j'ai d'indices différents dans la colonne 3 ici donc 4 listes finales. Je pense qu'une liste de listes finales serait plus simple d'ailleurs.
J'aimerais les faire ressemble à ça (pour l'exemple d'indice 1) :

Code :

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

[0,8,9,18,19,2,12,21]

il faut voir ça comme un chemin, le 1 commence toujours par 0 ensuite il fait 0 vers 8 après 8 vers 9 ect... on ne peut pas les trier par ordre croissant. J'ai vraiment du mal à imaginer un algo, de plus je connais assez peu numpy. Avez vous des idées pour me mettre sur la voie ?

Merci, en vous souhaitant une bonne journée,

Stabilo.

[lg_53]

Bonjour

Il faut préciser la notion de chemin. Comment s'ordonne les chiffres d'un même chemin ?

Autrement dit, sur l'exemple que vous donnez, et que je réduis (pour le point 1) :
Comment on passe de :

Code :

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

1
2
3
4
5
6
7
X=np.array([[ 8,  9 ],
 [18, 19],
 [ 0,  8],
 [12, 21],
 [ 2, 12],
 [ 9, 18],
 [19,  2]])

à

Code :

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

[0,8,9,18,19,2,12,21]

?


Alors vous ne l'expliquez pas clairement, mais comme je pense avoir deviner ce qui se cache derrière votre idée de chemin, voici une proposition :

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
import numpy as np
 
X=np.array([[ 8,  9 ],
 [18, 19],
 [ 0,  8],
 [12, 21],
 [ 2, 12],
 [ 9, 18],
 [19,  2]])
 
X1 = list(X[:,0])
X2 = list(X[:,1])
 
res = [0]
for _ in range(len(X)):
    res.append( X2[X1.index( res[-1] )] )
 
print(res)

[danielhagnoul]

J'en suis arrivé au code ci-dessous juste avant midi, mais je n'avais pas eu le temps de poster mon message.

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#! python3
# coding: utf-8
 
import numpy as np
 
x = [[0, 3, 3], [0, 7, 4], [0, 8, 1], [0, 10, 2], [1, 11, 3],
     [2, 12, 1], [3, 13, 3], [4, 14, 4], [5, 15, 2], [6, 16, 3],
     [7, 17, 4], [8, 9, 1], [9, 18, 1], [10, 20, 2], [11, 21, 3],
     [12, 21, 1], [13, 6, 3], [14, 21, 4], [15, 21, 2], [16, 1, 3],
     [17, 4, 4], [18, 19, 1], [19, 2, 1], [20, 5, 2]]
 
array = np.array(x)
 
# print(array)
 
index = array[:, 2].argsort()
 
array_index = array[index]
 
print(array_index)
 
unique, counts = np.unique(array_index[:, 2], return_counts=True)
dict_index = dict(zip(unique, counts))
 
print(dict_index)
 
n1 = 0
n2 = dict_index[1]
array_1 = np.array([(array_index[n1:n2, 0]), (array_index[n1:n2, 1])]).flatten()
 
n1 = n2
n2 += dict_index[2]
array_2 = np.array([(array_index[n1:n2, 0]), (array_index[n1:n2, 1])]).flatten()
 
n1 = n2
n2 += dict_index[3]
array_3 = np.array([(array_index[n1:n2, 0]), (array_index[n1:n2, 1])]).flatten()
 
n1 = n2
n2 += dict_index[4]
array_4 = np.array([(array_index[n1:n2, 0]), (array_index[n1:n2, 1])]).flatten()
 
print(array_1, np.sort(array_1))
print(array_2, np.sort(array_2))
print(array_3, np.sort(array_3))
print(array_4, np.sort(array_4))
 
"""
[[ 8  9  1]
 [18 19  1]
 [ 0  8  1]
 [12 21  1]
 [ 2 12  1]
 [ 9 18  1]
 [19  2  1]
 [15 21  2]
 [10 20  2]
 [20  5  2]
 [ 5 15  2]
 [ 0 10  2]
 [ 3 13  3]
 [11 21  3]
 [ 1 11  3]
 [13  6  3]
 [16  1  3]
 [ 6 16  3]
 [ 0  3  3]
 [ 7 17  4]
 [ 4 14  4]
 [14 21  4]
 [17  4  4]
 [ 0  7  4]]
{1: 7, 2: 5, 3: 7, 4: 5}
[ 8 18  0 12  2  9 19  9 19  8 21 12 18  2] [ 0  2  2  8  8  9  9 12 12 18 18 19 19 21]    
[15 10 20  5  0 21 20  5 15 10] [ 0  5  5 10 10 15 15 20 20 21]
[ 3 11  1 13 16  6  0 13 21 11  6  1 16  3] [ 0  1  1  3  3  6  6 11 11 13 13 16 16 21]    
[ 7  4 14 17  0 17 14 21  4  7] [ 0  4  4  7  7 14 14 17 17 21]
"""

[wiztricks]

Salut,

J'ai vraiment du mal à imaginer un algo, de plus je connais assez peu numpy. Avez vous des idées pour me mettre sur la voie ?

Ca serait plus facile sans numpy:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
D = [ [0, 3, 3], [0, 7, 4], [0, 8, 1], [0, 10, 2], [1, 11, 3], [2, 12, 1], [3, 13, 3], [4, 14, 4], [5, 15, 2], [6, 16, 3], [7, 17, 4], [8, 9, 1], [9, 18, 1], [10, 20, 2], [11, 21, 3], [12, 21, 1], [13, 6, 3], [14, 21, 4], [15, 21, 2], [16, 1, 3], [17, 4, 4], [18, 19, 1], [19, 2, 1], [20, 5, 2]]
 
P = {}
for x, y, k in D:
    P.setdefault(k, {}).update({ x: y })
 
for k in P:
    L = [0]
    while y := P[k].get(L[-1]):
        L.append(y)
    print (k, L)

après si c'est un exercice de style...

- W

[StabiloHB]

Tout d'abord je vous remercie tous les trois pour le temps que vous avez consacré à mon problème.

Il faut préciser la notion de chemin. Comment s'ordonne les chiffres d'un même chemin ?

Pour être plus précis, ma liste initiale est donc une liste de chemin de taille N, chaque "chemin" a trois arguments, un point de départ colonne 1 un point d'arrivé colonne 2 et un indice de véhicule en colonne 3.
Mon but étant de savoir quel chemin a parcouru chaque véhicule.

J'ai une contrainte supplémentaire qui est que chaque véhicule par de 0 donc le premier indice de toutes mes nouvelles listes de chemin commence forcément par 0.

mais comme je pense avoir deviner ce qui se cache derrière votre idée de chemin, voici une proposition :

Franchement c'est algo répond à mon problème, j'ai juste à lui donner la liste des chemins empruntés par chaque véhicule séparément et le tour est joué !

J'en suis arrivé au code ci-dessous juste avant midi, mais je n'avais pas eu le temps de poster mon message.

Alors je t'avoue c'est pas de mon niveau ahaha, j'ai eu du mal à le comprendre. Mais du coup dans l'output, il y a les bons points pour chaque véhicule mais ils sont triés par ordre croissant et non par passage. Mais c'est de ma faute j'ai mal expliqué ma problématique..

Ca serait plus facile sans numpy:

Je pense que je vais utiliser cet algo, il a l'avantage de pouvoir gérer N véhicules ainsi que N chemins automatiquement.
je l'ai juste un peu réadapté car je n'utilise pas python 3.8 du coup ":=" n'est pas dispo.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
D = [ [0, 3, 3], [0, 7, 4], [0, 8, 1], [0, 10, 2], [1, 11, 3], [2, 12, 1], [3, 13, 3], [4, 14, 4], [5, 15, 2], [6, 16, 3], [7, 17, 4], [8, 9, 1], [9, 18, 1], [10, 20, 2], [11, 21, 3], [12, 21, 1], [13, 6, 3], [14, 21, 4], [15, 21, 2], [16, 1, 3], [17, 4, 4], [18, 19, 1], [19, 2, 1], [20, 5, 2]]
 
P = {}
for x, y, k in D:
    P.setdefault(k, {}).update({ x: y })
 
print(D)
for k in P:
    L = [0]
    while len(L)!=len(P[k])+1:
        y=P[k].get(L[-1])
        L.append(y)
    print (k, L)

Merci encore à tous ! En vous souhaitant une excellente journée !

Stabilo.