Trier numpy array

Version imprimable

Trier numpy array

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:

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:

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:

[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.

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:

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:

[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:

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)

:salut:

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

Code:

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]
"""

Salut,

Citation:

Envoyé par StabiloHB

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:

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

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

Citation:

Envoyé par lg_53

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.

Citation:

Envoyé par lg_53

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é !

Citation:

Envoyé par danielhagnoul

:salut:

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..

Citation:

Envoyé par wiztricks

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:

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.