[PYTHON] 파이썬 : NumPy 배열 정당화하기

파이썬 : NumPy 배열 정당화하기

제가 파이썬에 조금 익숙해 져서 좋았습니다. 제가 게임의 2048 게임 데모를 만드는 데 사용할 4x4 매트릭스의 내용을 이동해야 할 때까지 파이썬이 매우 섹시하다고 말할 수있었습니다. 여기에 제가 가지고있는 게임이 있습니다. 이 기능

def cover_left(matrix):
        new=[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
        for i in range(4):
             count=0
             for j in range(4):
                if mat[i][j]!=0:
                    new[i][count]=mat[i][j]
                    count+=1
        return new

이 함수를 다음과 같이 호출하면이 함수가 수행합니다.

cover_left([
              [1,0,2,0], 
              [3,0,4,0], 
              [5,0,6,0], 
              [0,7,0,8]
          ])

왼쪽의 0을 덮어서 생성합니다.

[  [1, 2, 0, 0],
   [3, 4, 0, 0],
   [5, 6, 0, 0],
   [7, 8, 0, 0]]

제발 날 좀 더 빠르고 코드가 필요합니다 (나는 깊이 우선 탐색 알 고를 사용하고 있습니다) 그리고 더 중요한 것은 cover_up, cover_down의 구현을 믿는 이것의 numpy 방법을 도와 누군가가 필요합니다

`cover_left`.
`cover_up`
    [  [1, 7, 2, 8],
       [3, 0, 4, 0],
       [5, 0, 6, 0],
       [0, 0, 0, 0]]
`cover_down`
    [  [0, 0, 0, 0],
       [1, 0, 2, 0],
       [3, 0, 4, 0],
       [5, 7, 6, 8]]
`cover_right`
    [  [0, 0, 1, 2],
       [0, 0, 3, 4],
       [0, 0, 5, 6],
       [0, 0, 7, 8]]

미리 감사드립니다.

해결법

1. ==============================

   1.다음은이 다른 게시물에서 영감을 얻은 벡터화 된 접근 방식이며 네 가지 방향 모두에 대해 0이 아닌 코드를 일반화 한 것입니다.

   다음은이 다른 게시물에서 영감을 얻은 벡터화 된 접근 방식이며 네 가지 방향 모두에 대해 0이 아닌 코드를 일반화 한 것입니다.

   def justify(a, invalid_val=0, axis=1, side='left'):    
       """
       Justifies a 2D array
   
       Parameters
       ----------
       A : ndarray
           Input array to be justified
       axis : int
           Axis along which justification is to be made
       side : str
           Direction of justification. It could be 'left', 'right', 'up', 'down'
           It should be 'left' or 'right' for axis=1 and 'up' or 'down' for axis=0.
   
       """
   
       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
   

   샘플 실행 -

   In [473]: a # input array
   Out[473]: 
   array([[1, 0, 2, 0],
          [3, 0, 4, 0],
          [5, 0, 6, 0],
          [6, 7, 0, 8]])
   
   In [474]: justify(a, axis=0, side='up')
   Out[474]: 
   array([[1, 7, 2, 8],
          [3, 0, 4, 0],
          [5, 0, 6, 0],
          [6, 0, 0, 0]])
   
   In [475]: justify(a, axis=0, side='down')
   Out[475]: 
   array([[1, 0, 0, 0],
          [3, 0, 2, 0],
          [5, 0, 4, 0],
          [6, 7, 6, 8]])
   
   In [476]: justify(a, axis=1, side='left')
   Out[476]: 
   array([[1, 2, 0, 0],
          [3, 4, 0, 0],
          [5, 6, 0, 0],
          [6, 7, 8, 0]])
   
   In [477]: justify(a, axis=1, side='right')
   Out[477]: 
   array([[0, 0, 1, 2],
          [0, 0, 3, 4],
          [0, 0, 5, 6],
          [0, 6, 7, 8]])
   

2. ==============================

   2.이 모든 덕분에 내가 나중에 사용하는 것입니다

   이 모든 덕분에 내가 나중에 사용하는 것입니다

   def justify(a, direction):
       mask = a>0
       justified_mask = numpy.sort(mask,0) if direction == 'up' or direction =='down' else numpy.sort(mask, 1)
       if direction == 'up':
           justified_mask = justified_mask[::-1]
       if direction =='left':
           justified_mask = justified_mask[:,::-1]
       if direction =='right':
           justified_mask = justified_mask[::-1, :]    
       out = numpy.zeros_like(a) 
       out.T[justified_mask.T] = a.T[mask.T]
       return out
   

from https://stackoverflow.com/questions/44558215/python-justifying-numpy-array by cc-by-sa and MIT license