Justifier les tableaux Numpy avec des fonctions vectorisées

Numpy fournit des moyens efficaces de justifier des tableaux à l'aide de fonctions vectorielles, offrant des performances et des codes améliorés par rapport aux boucles Python traditionnelles. Éléments non nuls à gauche, droite, haut ou vers le bas tout en maintenant sa forme.

Solution numpy

L'implémentation Numpy suivante effectue une justification efficace:

Import Numpy comme np Def Justify (a, invalid_val = 0, axe = 1, côté = 'gauche'): Si invalid_val est np.nan: masque = ~ np.isnan (a) autre: masque = a! = invalid_val Justified_mask = np.sort (masque, axe = axe) if (côté == 'up') | (côté == 'gauche'): Justified_mask = np.flip (Justifié_Mask, axe = axe) out = np.full (a.shape, invalid_val) Si axe == 1: out [justifié_mask] = a [masque] autre: out.t [justifié_mask.t] = a.t [mask.t] renvoie

Cette fonction justifie un tableau 2D le long de l'axe et du côté spécifié (gauche, droite, haut, vers le bas). It works by identifying non-zero elements using mask, sorting them using sort, flipping the mask if justifying upwards or leftwards, and finally overwriting the original array with the justified values.

import numpy as np

def justify(a, invalid_val=0, axis=1, side='left'):    
    if invalid_val is np.nan:
        mask = ~np.isnan(a)
    else:
        mask = a!=invalid_val
    justified_mask = np.sort(mask,axis=axis)
    if (side=='up') | (side=='left'):
        justified_mask = np.flip(justified_mask,axis=axis)
    out = np.full(a.shape, invalid_val) 
    if axis==1:
        out[justified_mask] = a[mask]
    else:
        out.T[justified_mask.T] = a.T[mask.T]
    return out

Here's a usage example that covers non-zero elements to the left:

a = np.array ([[1,0,2,0], [3,0,4,0], [5,0,6,0], [0,7,0,8]]) # Couverture à gauche couvert_left = Justify (a, axe = 1, côté = 'gauche') Imprimer ("Array original:") Imprimer (a) Imprimer ("\ ncovérire à gauche:") print (couvert_left)

output:

a = np.array([[1,0,2,0], 
              [3,0,4,0], 
              [5,0,6,0], 
              [0,7,0,8]])

# Cover left
covered_left = justify(a, axis=1, side='left')

print("Original Array:")
print(a)
print("\nCovered Left:")
print(covered_left)

justifiant un tableau générique n dimensionnel

Original Array:
[[1 0 2 0]
 [3 0 4 0]
 [5 0 6 0]
 [0 7 0 8]]

Covered Left:
[[1 2 0 0]
 [3 4 0 0]
 [5 6 0 0]
 [7 8 0 0]]

Defi Justify_nd (a, invalid_val, axe, côté): pushax = lambda a: np.moveaxis (a, axe, -1) Si invalid_val est np.nan: masque = ~ np.isnan (a) autre: masque = a! = invalid_val Justified_mask = np.sort (masque, axe = axe) Si côté == 'front': Justified_mask = np.flip (Justifié_Mask, axe = axe) out = np.full (a.shape, invalid_val) if (axe == - 1) ou (axe == a.ndim-1): out [justifié_mask] = a [masque] autre: pushax (out) [pushax (justifié_mask)] = pushax (a) [pushax (mask)]] renvoie

Cette fonction prend en charge des scénarios plus complexes en justifiant un tableau N dimensionnel le long d'un axe arbitraire et en «front» ou «end» du tableau.