[Numpy exercise 100] 71번 ~ 80번 문제풀이

1번 ~ 30번 문제풀이

[Numpy exercise 100] 1번 ~ 30번 문제풀이

31번 ~ 60번 문제풀이

[Numpy exercise 100] 31번 ~ 60번 문제풀이

61번 ~ 70번 문제풀이

[Numpy exercise 100] 61번 ~ 70번 문제풀이

https://github.com/rougier/numpy-100

GitHub - rougier/numpy-100: 100 numpy exercises (with solutions)

---

71. Consider an array of dimension (5,5,3), how to mulitply it by an array with dimensions (5,5)? (★★★)

• 차원 배열(5,5,3)을 고려한다면, 차원 배열(5,5)에 의해 어떻게 그것을 곱할 것인가?
• 임시적으로 B의 shape을 3차원으로 바꿔서 그것을 곱함

A = np.ones((5,5,3))
B = 2*np.ones((5,5)) # (5,5) 1배열에 2를 곱해줌
print(A*B[:,:,None])

>>>
[[[2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]]

 [[2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]]

 [[2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]]

 [[2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]]

 [[2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]
  [2. 2. 2.]]]

# 배열B와 임시로 3차원으로 바꾼 배열B

print(B)
print(B[:,:,None])

>>>
[[2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]
 [2. 2. 2. 2. 2.]]
 
 [[[2.]
  [2.]
  [2.]
  [2.]
  [2.]]

 [[2.]
  [2.]
  [2.]
  [2.]
  [2.]]

 [[2.]
  [2.]
  [2.]
  [2.]
  [2.]]

 [[2.]
  [2.]
  [2.]
  [2.]
  [2.]]

 [[2.]
  [2.]
  [2.]
  [2.]
  [2.]]]

 

72. How to swap two rows of an array? (★★★)

• 배열의 두 행을 바꾸는 방법
• 행 인덱스를 이용해 행 교체

A = np.arange(25).reshape(5,5)
print(A)
A[[0,1]] = A[[1,0]]
print(A)

>>>
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]
 
[[ 5  6  7  8  9]
 [ 0  1  2  3  4]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]

 

73. Consider a set of 10 triplets describing 10 triangles (with shared vertices), find the set of unique line segments composing all the triangles (★★★)

• 10개의 삼각형을 설명하는 10개의 세쌍둥이 집합을 생각해보고, 모든 삼각형을 구성하는 고유 선분 집합을 찾는다.
• 문제 뜻을 이해하지 못함...
• np.roll : array를 굴리는 함수, shift 파라미터에 따라 인덱스를 설정하여 가장 앞 원소를 뒤로 보내거나 밀수 있음
  • 공식 문서 : https://numpy.org/doc/stable/reference/generated/numpy.roll.html
• repeat : 지정한숫자 (여기선 -1)가 나오기 전까지 무한 반복
  • 관련문서 : https://rfriend.tistory.com/459

[Python] itertools를 활용한 리스트 원소를 n번 반복하여 새로운 리스트 만들기

faces = np.random.randint(0,100,(10,3))
F = np.roll(faces.repeat(2,axis=1),-1,axis=1)
F = F.reshape(len(F)*3,2)
F = np.sort(F,axis=1)
G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )
G = np.unique(G)
print(G)

>>>
[( 0,  6) ( 0, 13) ( 6, 13) ( 7, 31) ( 7, 60) (14, 46) (14, 51) (19, 33)
 (19, 60) (20, 68) (20, 91) (22, 48) (22, 76) (29, 41) (29, 51) (31, 35)
 (31, 36) (31, 60) (33, 60) (35, 36) (39, 44) (39, 53) (41, 51) (44, 53)
 (46, 51) (48, 76) (50, 60) (50, 87) (60, 87) (68, 91)]

 

74. Given a sorted array C that corresponds to a bincount, how to produce an array A such that np.bincount(A) == C? (★★★)

• bincount에 해당하는 정렬 된 배열 C가 주어지면 np.bincount (A) = = C와 같은 배열 A를 생성하는 방법은 무엇입니까?
• np.repeat()메서드를 통해 A가 C랑 같아질때 까지 순차적으로 반복

C = np.bincount([1,1,2,3,4,4,6])
A = np.repeat(np.arange(len(C)), C)
print(A)

>>>
[1 1 2 3 4 4 6]

 

75. How to compute averages using a sliding window over an array? (★★★)

• 어레이에서 슬라이딩 윈도우를 사용하여 평균을 계산하는 방법은 무엇입니까?
• np.cumsum : 주어진 축을 따라 요소의 누적 합계 반환
  • https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html

numpy.cumsum — NumPy v1.21 Manual

def moving_average(a, n=3) :
    ret = np.cumsum(a, dtype=float)
    ret[n:] = ret[n:] - ret[:-n]
    return ret[n - 1:] / n
Z = np.arange(20)
print(moving_average(Z, n=3))

>>>
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17. 18.]

 

76. Consider a one-dimensional array Z, build a two-dimensional array whose first row is (Z[0],Z[1],Z[2]) and each subsequent row is shifted by 1 (last row should be (Z[-3],Z[-2],Z[-1]) (★★★)

• 1차원 배열 Z를 고려하여 첫 번째 행이 (Z[0],Z[1],Z[2]인 2차원 배열을 만들고 각 후속 행이 1씩 이동한다고 가정하십시오(마지막 행은 (Z[-3],Z[-2]),Z[-1]이어야 함).

from numpy.lib import stride_tricks

def rolling(a, window):
    shape = (a.size - window + 1, window)
    strides = (a.strides[0], a.strides[0])
    return stride_tricks.as_strided(a, shape=shape, strides=strides)
print(np.arange(10))
Z = rolling(np.arange(10), 3)
print(Z)

>>>
[0 1 2 3 4 5 6 7 8 9]
[[0 1 2]
 [1 2 3]
 [2 3 4]
 [3 4 5]
 [4 5 6]
 [5 6 7]
 [6 7 8]
 [7 8 9]]

 

77. How to negate a boolean, or to change the sign of a float inplace? (★★★)

• 부울을 부정하는 방법 또는 플로트 내부(부등) 기호를 변경하는 방법?
• 0과 1을 가진 array일때, logical_not()을 통해 반전시킬 수 있음
• 부호를 가진 array일때, negative()를 통해 부호를 반전시킬 수 있음

Z = np.random.randint(0,2,100)
print(Z)
print(np.logical_not(Z, out=Z))

>>>
# Z
[0 0 0 1 0 1 1 0 0 0 1 1 0 0 1 0 1 0 1 0 0 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 1
 1 0 1 1 1 0 0 1 1 0 1 1 1 1 1 0 1 0 0 0 0 1 0 0 1 1 0 0 0 1 0 0 0 1 1 1 1
 0 0 0 0 0 0 1 1 1 0 1 0 1 1 0 0 1 0 1 1 1 1 1 0 1 0]
 
 # np.logical_not 적용
[1 1 1 0 1 0 0 1 1 1 0 0 1 1 0 1 0 1 0 1 1 0 1 0 0 0 1 0 1 0 1 0 1 0 1 0 0
 0 1 0 0 0 1 1 0 0 1 0 0 0 0 0 1 0 1 1 1 1 0 1 1 0 0 1 1 1 0 1 1 1 0 0 0 0
 1 1 1 1 1 1 0 0 0 1 0 1 0 0 1 1 0 1 0 0 0 0 0 1 0 1]

Z = np.random.uniform(-1.0, 1.0, 30)
print(Z)
print(np.negative(Z, out=Z))

>>>
# Z
[ 0.80605726 -0.69816069 -0.1418693  -0.19194465  0.02354716  0.37920456
  0.21426436  0.63498652 -0.9326904  -0.01600721 -0.8734207   0.48281752
  0.00138393 -0.9786371  -0.6471253  -0.1070193  -0.89682613 -0.40210602
  0.22607657 -0.89140524  0.17531545  0.30002505  0.54486943 -0.48191416
 -0.66962649  0.39678452 -0.9176542  -0.2843332   0.32364294 -0.26163182]
 
 # np.negative()
 [-0.80605726  0.69816069  0.1418693   0.19194465 -0.02354716 -0.37920456
 -0.21426436 -0.63498652  0.9326904   0.01600721  0.8734207  -0.48281752
 -0.00138393  0.9786371   0.6471253   0.1070193   0.89682613  0.40210602
 -0.22607657  0.89140524 -0.17531545 -0.30002505 -0.54486943  0.48191416
  0.66962649 -0.39678452  0.9176542   0.2843332  -0.32364294  0.26163182]

 

78. Consider 2 sets of points P0,P1 describing lines (2d) and a point p, how to compute distance from p to each line i (P0[i],P1[i])? (★★★)

• 선(2d)과 점 p를 설명하는 점 P0,P1의 두 집합을 고려하며, p에서 각 선 i까지의 거리를 계산하는 방법(P0[i]),P1[i]?

def distance(P0, P1, p):
    T = P1 - P0
    L = (T**2).sum(axis=1)
    U = -((P0[:,0]-p[...,0])*T[:,0] + (P0[:,1]-p[...,1])*T[:,1]) / L
    U = U.reshape(len(U),1)
    D = P0 + U*T - p
    return np.sqrt((D**2).sum(axis=1))

P0 = np.random.uniform(-10,10,(10,2))
P1 = np.random.uniform(-10,10,(10,2))
p  = np.random.uniform(-10,10,( 1,2))
print(distance(P0, P1, p))

>>>
[ 1.58107655 13.76901584  4.63900327 14.08876824 19.20680104  8.36019799
  4.3356211   6.93239949  7.76393259  3.56538043]

 

79. Consider 2 sets of points P0,P1 describing lines (2d) and a set of points P, how to compute distance from each point j (P[j]) to each line i (P0[i],P1[i])? (★★★)

• 각 점 j(P[j])에서 각 선 i(P0[i])까지의 거리를 계산하는 방법, 선 (2d)과 점 P 집합을 설명하는 점 P0,P1을 고려한다.P1[i]?
• 이전 문제에서 정의한 함수 사용

P0 = np.random.uniform(-10, 10, (10,2))
P1 = np.random.uniform(-10,10,(10,2))
p = np.random.uniform(-10, 10, (10,2))
print(np.array([distance(P0,P1,p_i) for p_i in p]))

>>>
[[ 7.09996379  2.28628349  3.02667085  0.69680191 12.3405457   4.06039467
   1.69448862  1.15986278  7.76941756  7.00244358]
 [ 2.94171083  0.26736355  5.38250641  3.18764396 11.64424454  0.11719234
   5.01504534  2.55756628  3.32371878 11.00719431]
 [ 1.50853171  2.52011389  3.12011483  5.83670139  8.69723612  0.5191053
   3.3715126   4.50923556  2.69978361 10.09159488]
 [11.92175056  2.04549699  3.49998832  0.0187256   9.80647589 11.46733622
   5.5973582   4.64292861 14.04571887  0.47531408]
 [ 0.83917391  4.44605451  3.29479166  7.91593527  7.28675863  1.05926087
   4.19848028  6.86001551  0.53115203 11.48979973]
 [ 9.9750869   4.9257392   3.22555117  2.08995924 14.43136693  5.71457733
   1.05608949  4.12876992 10.30327618  5.59839973]
 [ 8.20698726  6.84628412  8.31190591  3.4098309  17.73190392  1.17985325
   6.1721835   3.43884914  7.20614792 10.3515742 ]
 [ 6.18103504  5.96612087  9.61179526  2.28484644 17.5265817   0.9582315
   7.92792991  1.6608396   4.99521156 12.41632178]
 [ 4.25330825  3.27542496  1.50386528  5.97996405  6.45459123  5.34913118
   1.60340477  2.72468215  6.54101367  5.15630905]
 [10.31772615  6.92213565  5.72127372  3.86182483 16.85719736  4.24233171
   3.22177502  5.02165964  9.87488891  7.27713738]]

 

80. Consider an arbitrary array, write a function that extract a subpart with a fixed shape and centered on a given element (pad with a fill value when necessary) (★★★)

• 임의의 배열을 고려하여, 고정된 모양과 특정 요소의 중심에 있는 하위 파트를 추출하는 함수를 작성합니다(필요할 때 'fill' 값을 가진 패드).

Z = np.random.randint(0,10,(10,10))
shape = (5,5)
fill  = 0
position = (1,1)

R = np.ones(shape, dtype=Z.dtype)*fill
P  = np.array(list(position)).astype(int)
Rs = np.array(list(R.shape)).astype(int)
Zs = np.array(list(Z.shape)).astype(int)

R_start = np.zeros((len(shape),)).astype(int)
R_stop  = np.array(list(shape)).astype(int)
Z_start = (P-Rs//2)
Z_stop  = (P+Rs//2)+Rs%2

R_start = (R_start - np.minimum(Z_start,0)).tolist()
Z_start = (np.maximum(Z_start,0)).tolist()
R_stop = np.maximum(R_start, (R_stop - np.maximum(Z_stop-Zs,0))).tolist()
Z_stop = (np.minimum(Z_stop,Zs)).tolist()

r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]
z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]
R[r] = Z[z]
print(Z)
print(R)

>>>
[[6 2 7 8 1 0 4 3 1 0]
 [3 7 2 0 7 8 9 9 5 4]
 [9 1 5 0 1 8 8 0 2 8]
 [1 4 4 7 1 8 7 5 9 8]
 [0 2 1 8 1 5 9 4 9 7]
 [3 8 1 2 8 7 1 2 9 2]
 [4 9 8 6 1 6 9 2 9 4]
 [1 0 2 6 0 5 4 9 8 6]
 [2 4 4 3 9 4 8 9 4 5]
 [3 3 8 1 0 2 0 5 4 3]]
 
[[0 0 0 0 0]
 [0 6 2 7 8]
 [0 3 7 2 0]
 [0 9 1 5 0]
 [0 1 4 4 7]]