les lignes non dominantes d'une matrices

salut,

je cherche à recupérer toute les lignes non dominantes d’une matrices. ( l’un des éléments de la ligne choisi soit supérieur). Par exemple j’ai une matrice suivante : arr = [[-1, 7], [ 3, 1], [ 2, -5], [ 7, 6], [0,1] ,[4,-1] ,[8,7] ,[-2,6] ,[4,6] ]. je cherche les lignes qui réponds aux conditions suivantes :

je suppose que la ligne (a, b) la ligne récupérée. il existe pas une lignes qui domine la ligne recupéré c à d : ∄ (a1,b1) / arr[a1]< arr[a] et arr[b1]< arr[b]. import numpy

def maxelement(arr):

no_of_rows = len(arr) 
no_of_column = len(arr[0]) 

for i in range(no_of_rows-1): 


    for j in range(no_of_column-2): 

        m=arr[i+1][j]
        n=arr[i+1][j+1]
        if arr[i+1][j] > m  or arr[i+1][j+2] >n   : 
            m = arr[i][j] 
            n = arr[i][j]  

    print(m,n) 

arr = [[3, 4, 1, 8], [1, 4, 9, 11], [76, 34, 21, 1], [2, 1, 4, 5]]

Ok, ici, tu compares quoi dans ton code ? i est l’indice d’une ligne que tu cherches à tester.

m = arr[i+1][j]

Puis arr[i+1][j] > m Donc déjà cette condition n’a pas de sens. Elle est forcément fausse.

Ensuite n = arr[i+1][j+1] Puis : arr[i+1][j+2] > n

Donc là, c’est assez tordu comme comportement. Si l’élément de la ligne suivante est supérieur à l’élément de la ligne suivante, mais celui d’après alors tu changes les la valeur des éléments suivant, mais ça n’a aucun intérêt pour la prochaine itération seulement pour la dernière car ensuite on écrase les valeurs de m et n à la prochaine itération.

Ton code affiche pour chaque ligne de la matrice:

• L’avant et l’avant dernier élément de la ligne suivante.
• Sauf, si l’avant avant dernier élément de la ligne suivante est plus petit que l’avant dernier élément de la ligne suivante, au quel cas on affiche deux fois l’avant avant dernier élément de la ligne courante.
• Si jamais on a moins de 3 éléments par ligne, alors on affiche jamais rien.

Bref, ton code est hyper tordu. Soit j’ai rien compris à la définition de ligne dominer soit tu t’es beaucoup embrouillé.

On va reprendre de zéro. En premier, tu va juste faire une fonction dominer qui te prend deux lignes en paramètre et qui retourne True si la première ligne domine la deuxième et False sinon.

merci pour la réponse par exemple j’ai une matrice (A ) tel que le nombre de ligne = 10 , le nombre de colonnes = 2 . A = [[-1, 7], [ 3, 1], [ 2, -5], [ 7, 6], [0,1] ,[4,-1] ,[8,7] ,[-2,6] ,[4,6] ]. je cherche les blocs ( un bloque est constitue d’un ligne et d’une colonne) où il ya pas un autre bloc où l’élément de la ligne est inférieur à la ligne des blocs recherchés et l’élément de la colonne est aussi inférieur à la ligne des blocs recherchés. dans l’exemple en dessus les combinaisons [ 2, -5] et [-2,6] son les solutions suitées. merci

Plus simplement : tu regardes une par une les colonnes de ta matrice et tu sélectionnes la ligne suivant le nombre le plus petit.

Donc naïvement :

Prendre en entrée une matrice
Définir un tableau vide resultats
Pour chaque colonne j (1 à 2)
    Définir recherche_index à 0
    Définir recherche_valeur à 0
    Analyser chaque ligne i (1 à 10)
        La valeur X vaut matrice[i][j]
        Si i vaut 0 (c'est la première ligne)
            Alors définir recherche_valeur à X et recherche_index à i
        Sinon Si la valeur X est inférieure à recherche_valeur
            Alors définir recherche_valeur à X et recherche_index à i
    Ajouter matrice[recherche_index] au tableau resultats
Retourner resultats

Salut,

Ou bien set(np.argmin(A, axis=0)) pour avoir l’ensemble des lignes qui satisfont le critère.

@adri1: L’ensemble des indices des lignes satisfaisant le critère. Mais du coup grâce à toi j’ai compris ce que l’OP veut.

Ben oui, les lignes elles-mêmes sont pas hashables de toute façon… Une fois qu’on a cet ensemble, on en fait ce qu’on veut.

merci ,

pour moi j’ai une liste arr = [[3,4], [4,1],[5,0],[7,1],[-1,0],[8,9],[2,-8]] . ( pour moi [3,4] est une ligne tel que 3 est le 1 premier élément de cette ligne et 4 est le 2 deuxième élément de la ligne [3,4]. l’objectif est de tester toutes les lignes :

si ([3,4]) ( 3 est inférieur au tous les premiers éléments de toutes autres lignes de la liste et 4 inférieur au tous les deuxièmes éléments de toutes autres lignes de la liste) cette condition est satisfaite je garde la ligne [3,4] dans la liste sinon je le surprime. ensuite je passe à la ligne prochaine ([4,1]) la meme chose jus’à la fin aprés j’affiche la liste arr. merci

Salut,

Et donc, qu’est ce qui ne te va pas, par exemple avec ma solution qui répond directement à ton problème ?

EDIT : et d’ailleurs, tu souhaites que les deux éléments soient les plus petits comme tu sembles le dire dans ton dernier message (cas A), ou bien seulement un seul suffit comme dans ton premier exemple (cas B, ce pourquoi je propose une solution) ? Autrement dit, dans [[3,4], [4,1],[5,0],[7,1],[-1,0],[8,9],[2,-8]] tu gardes rien du tout (cas A) ou bien [-1,0] et [2,-8] (cas B) ?

Typiquement,

import numpy as np
arr = np.array([[3,4], [4,1],[5,0],[7,1],[-1,0],[8,9],[2,-8]])
lines = list(set(np.argmin(arr, axis=0)))  # set to avoid dup if both min on same line
print(arr[lines])  # np.array([[-1, 0], [2, -8]])

Il me semble que, dans les exemples que tu donnes, toutes le lignes sont "non dominantes".

Peux-tu fournir un exemple de matrice qui aurait une ligne non dominante ?

De ce que je comprends, il suffit de chercher les lignes dont le premier élément est le plus petit, puis de voir si c’est pareil pour les autres éléments de ces lignes.

Typiquement, sur ton premier exemple :
arr = [[-1, 7], [ 3, 1], [ 2, -5], [ 7, 6], [0,1] ,[4,-1] ,[8,7] ,[-2,6] ,[4,6] ]
c’est [-2,6], mais 6 est plus grand que 1 dans [ 3, 1], donc on n’a pas de ligne non dominante.

Pour arr = [[3, 4, 1, 8], [1, 4, 9, 11], [76, 34, 21, 1], [2, 1, 4, 5]]
on examine [1, 4, 9, 11], mais 4 est plus grand que 1 dans [2, 1, 4, 5].

Pour arr = [[3,4], [4,1],[5,0],[7,1],[-1,0],[8,9],[2,-8]]
on examine [-1,0], mais 0 est plus grand que -8 dans [2,-8].