Discussion :

[Arsene12]

Bonjour,

je travaille en python et j'ai une liste de tuples.

Code :

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

listeM = ((x1,y1),(x2,y2)...)

Je voudrais vérifier qu'il n'y ait pas de doublon dans les x et de doublon dans les y.

J'affiche les x et le y ainsi :

Code :

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

1
2
3
    for n in range(0,len(listeM)):
        print('mon X = '+ str(listeM[n][0]))
        print('mon Y = '+ str(listeM[n][1]))

Comment comparer le plus simplement les x entre eux et les y entre eux?
Dois-je par exemple insérer les x dans une nouvelle liste en vérifiant à chaque fois si la valeur ne s'y trouve pas déjà?
Auriez-vous une méthode à me proposer, svp?

Merci d'avance de votre aide.
Cordialement,
Arsène

[wiwaxia]

Bonjour,

... Comment comparer le plus simplement les x entre eux et les y entre eux? ...

En procédant à une double énumération, après avoir prévu des listes pour la consignation des résultats:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Nx:= 0; Ny:= 0;
 
FOR i:= 1 TO (N - 1) DO
  FOR j:= (i + 1) TO N DO
    IF (ListeM[i].x:= ListeM[j].x) THEN BEGIN
                                          Inc(Nx); ListeDx[Nx].u:= i; 
                                          ListeDx[Nx].v:= j 
                                        END
                                   ELSE IF (ListeM[i].y:= ListeM[j].y) THEN BEGIN  
                                                                              Inc(Ny); ListeDy[Ny].u:= i; 
                                                                              ListeDy[Ny].v:= j
                                                                            END

[Arsene12]

Merci, j'avais pensé moi aussi me servir des listes pour faire ce travail. Mais je travaille en python et non en java (ou C++). Donc mon code est le suivant :

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
    maListeD1[:] = []
    maListeD2[:] = []
 
    if leMoinsDeFaux1==1:
       print("UN SEUL VRAI SUR UNE LIGNE COMMUNE")    
       for x in range(0,len(listeM)):
           if listeM[x][0] in maListeD1:
              print("DOUBLON")
           else :
              maListeD1.append(listeM[x][0])
 
    if leMoinsDeFaux2==1:
       print("UN SEUL VRAI SUR UNE COLONNE COMMUNE")    
       for y in range(0,len(listeM)):
          if listeM[y][1] in maListeD2:
              print("DOUBLON")
          else :
              maListeD2.append(listeM[y][1])

J'ai auparavant défini mes listes :

Code :

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

1
2
3
listeM = []
maListeD1 = []
maListeD2 = []

et j'ai rempli listeM.

[Arsene12]

J'arrive à savoir s'il existe un doublon. Je voudrai maintenant le généraliser aux triplons, quadruplons, etc... Cela revient à connaitre le nombre de doublons, triplons, quadruplons,... présents dans une liste.

J'utilise pour cela un dictionnaire qui me donne le nombre d’occurrences de chaque entrée :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
    if leMoinsDeFaux1==leMoinsDeFaux:
       print("UN SEUL VRAI SUR UNE COLONNE COMMUNE")    
       for x in range(0,len(listeM)):
              maListeD1.append(listeM[x][0])
       maListeD1X = dict([(n, maListeD1.count(n)) for n in set(maListeD1)])
       print(maListeD1X)       
 
    if leMoinsDeFaux2==leMoinsDeFaux:
       print("UN SEUL VRAI SUR UNE LIGNE COMMUNE")    
       for y in range(0,len(listeM)):
              maListeD2.append(listeM[y][1])
       maListeD2Y = dict([(n, maListeD2.count(n)) for n in set(maListeD2)])
       print(maListeD2Y)

[wiwaxia]

Une solution consiste à travailler sur une liste de triplets, dont le troisième terme est initialisé à zéro - on suppose pour simplifier toutes les valeurs (x, y, u) du même type Entier.

Code :

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

TYPE ListeXY: ARRAY[1..N] OF RECORD  x, y, u: Entier  END;

On peut reprendre une comparaison terme à terme - pour (x), par exemple - sous réserve que la nouvelle valeur considérée n'ait jamais été rencontrée auparavant.

Cela se traduit par les instructions suivantes (c'est du Pascal, mais cela se lit comme du pseudo-code):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
FOR i:= 1 TO (N - 1) DO
  IF (Liste[i].u=0) THEN     // Valeur abordée pour la 1re fois
    BEGIN
      Liste[i].u:= 1;
      FOR j:= (i + 1) TO N DO 
        IF (Liste[i].x=Liste[j].x) THEN 
          BEGIN
            Inc(Liste[i].u); Liste[j].u:= Liste[i].u
          END
    END;
 
IF (Liste[N].u=0) THEN Liste[N].u:= 1;

On sait de cette manière combien de fois toute valeur de (x) intervient dans la liste ⁽¹⁾.

Un travail analogue peut être simultanément effectué sur les valeurs de (y) en ajoutant un terme supplémentaire, par une déclaration du type:

Code :

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

TYPE ListeXY: ARRAY[1..N] OF RECORD  x, y, u, v: Entier  END;

À ce stade, les rangs des valeurs rencontrées plusieurs fois n'ont pas été mémorisés; on les retrouve facilement à partir de la liste précédente, ou en insérant quelques instructions supplémentaires dans l'algorithme envisagé.

Il est facile de déterminer, à partir de la liste constituée, les valeurs maximales de (u), et (v), ainsi que le nombre total de valeurs différentes observées pour (x) et (y).

(1) PS: j'ai omis de mentionner l'ajustement nécessaire pour que toute valeur de (x) rencontrée (k) fois corresponde à u = k (jusqu'ici, c'est seulement le cas de la première et de la dernière):

Code :

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

1
2
3
4
5
 
FOR i:= 1 TO (N - 1) DO
  IF (Liste[i].u>2) THEN
    FOR j:= (i + 1) TO N DO 
      IF ((Liste[j].x=Liste[i].x) AND (Liste[j].u<Liste[i].u)) THEN Liste[j].u:= Liste[i].u

[Arsene12]

Je vois vaguement en quoi consiste cette solution. Comme je travaille en python, c'est aussi bien d'utiliser le dictionnaire. Les tuples représentent les coordonnées x et y de points. S'il y a des x ou des y égaux, cela veut dire que des points sont alignés, horizontalement ou verticalement. Si ces points sont situés dans une matrice, ils sont associés à une valeur, parfois booléenne. On peut ainsi comparer les rangées une à une pour savoir si elles sont identiques. Pour cela on constitue des listes. En résumé avec python, listes et dictionnaire permettent d'effectuer des comparaisons et de déterminer le nombre d’occurrences.