
๊ฐ์ ์ฐจ์์ด์ง๋ง ๋ค๋ฅธ ๋ชจ์์ ๊ฐ์ง ๋ฐฐ์ด ๊ฐ์ ์ฐ์ฐ์์ ์ด๋ป๊ฒ ๋ธ๋ก๋์บ์คํ ์ด ์ ์ฉ๋๋์ง ์ดํด๋ณด์์ต๋๋ค.
2์ฐจ์ ๋ฐฐ์ด(ํ๋ ฌ) ๊ฐ์ ๋ง์ ์ฐ์ฐ์ ํด๋ด ์๋ค. ์์๋ก 3 x 3 ๋ฐฐ์ด(A)๊ณผ 1 x 3 ๋ฐฐ์ด(B) ์ฌ์ด์ ๋ง์ ์ฐ์ฐ, ๊ทธ๋ฆฌ๊ณ 3 x 3 ๋ฐฐ์ด(A)๊ณผ 2 x 3 ๋ฐฐ์ด(C) ์ฌ์ด์ ๋ง์ ์ฐ์ฐ์ ํํ๋ ์ฝ๋๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
A = [
[10, 10, 10],
[20, 20, 20],
[30, 30, 30]
]
B = [
[1, 2, 3]
]
C = [
[2, 2, 3],
[4, 5, 6],
]
A = np.array(A)
B = np.array(B)
C = np.array(C)
result = A + B
print(result)
>>>[[11 12 13]
[21 22 23]
[31 32 33]]
result = A + C
>>>ValueError: operands could not be broadcast together with shapes (3,3) (2,3)
์ ์ฝ๋์์ A + B๋ฅผ ํํ๋ ์ฐ์ฐ์ ๊ทธ๋ฆผ์ผ๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.

1 x 3 ๋ฐฐ์ด B๋ 3 x 3 ๋ฐฐ์ด A ๋ชจ์์ ๋ง์ถฐ 0์ฐจ์์ ๊ธฐ์ค์ผ๋ก ํ์ฅ(1->3)ํ์ฌ ์ฐ์ฐํฉ๋๋ค.

๊ทธ๋ฌ๋ 2 x 3 ๋ฐฐ์ด C๋ 3 x 3 ๋ฐฐ์ด A ๋ชจ์์ ๋ง์ถ์ง ๋ชปํ๋ค๊ณ ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค. ์ด๋ ๋ธ๋ก๋์บ์คํ
์ด ์ฐจ์์ ํฌ๊ธฐ๊ฐ 1์ผ ๋๋ง ์ ์ฉ์ด ๋๊ธฐ ๋๋ฌธ์
๋๋ค. ๋ฐ๋ผ์ B๋ 0์ฐจ์์ ํฌ๊ธฐ๊ฐ 1์ด์ฌ์ ๋ธ๋ก๋์บ์คํ
์ด ์ ์ฉ๋์ง๋ง, C๋ 0์ฐจ์์ ํฌ๊ธฐ๊ฐ 2์ด๋ฏ๋ก ๋ธ๋ก๋์บ์คํ
์ด ์ ์ฉ๋์ง ์์ต๋๋ค.

๋ ๋ค๋ฅธ ์์ 1 x 3 ๋ฐฐ์ด๊ณผ 3 x 1 ๋ฐฐ์ด์ ์ฐ์ฐ์ ์ดํด๋ด ์๋ค.
A = [
[1],
[2],
[3]
]
B = [
[1, 2, 3]
]
A = np.array(A)
B = np.array(B)
result = A + B
print(result)
>>>[[2 3 4]
[3 4 5]
[4 5 6]]

1 x 3 ๋ฐฐ์ด B๋ A์ 0์ฐจ์์ ํฌ๊ธฐ์ธ 3์ ๋ง์ถฐ, 3 x 1 ๋ฐฐ์ด A๋ B์ 1์ฐจ์์ ํฌ๊ธฐ 3์ ๋ง์ถฐ ํ์ฅํ๋ฉฐ ์ต์ข
3 x 3 ๋ฐฐ์ด๋ก ์ฐ์ฐ๋ฉ๋๋ค.

์ฆ, ์ฐ์ฐ์ ํ ๋ฐฐ์ด์์ ํฌ๊ธฐ๊ฐ 1์ธ ์ฐจ์์ด ์กด์ฌํ๋ค๋ฉด ๋ธ๋ก๋์บ์คํ
์ด ์ ์ฉ๋์ด ๋ค๋ฅธ ๋ฐฐ์ด์์ ํด๋น ์ฐจ์์ ํฌ๊ธฐ๋งํผ ํ์ฅํฉ๋๋ค.
์ฐจ์์ด ๋ค๋ฅธ ๋ฐฐ์ด๋ค ๊ฐ์ ์ฐ์ฐ์ ํ ๋ ๋ธ๋ก๋์บ์คํ ์ด ์ด๋ป๊ฒ ์ ์ฉ๋๋์ง ์ดํด์์ต๋๋ค.
๋ค๋ฅธ ์ฐจ์์ ๋ฐฐ์ด๋ค ๊ฐ์ ์ฐ์ฐ์ ํด๋ด ์๋ค. ์์๋ก 2 x 1 x 3 ๋ชจ์์ ๊ฐ์ง 3์ฐจ์ ๋ฐฐ์ด(A)๊ณผ 2 x 3 ๋ชจ์์ ๊ฐ์ง 2์ฐจ์ ๋ฐฐ์ด(B) ์ฌ์ด์ ๋ง์ ์ฐ์ฐ, ๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ด(A)๊ณผ 1 x 2 ๋ชจ์์ ๊ฐ์ง 2์ฐจ์์ ๋ฐฐ์ด(C) ์ฌ์ด์ ๋ง์ ์ฐ์ฐ์ ํ๋ ์ฝ๋๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
# 2 x 1 x 3 ๋ชจ์์ ๋ฐฐ์ด A
A = np.array(
[[[3, 2, 1]],
[[0, 1, 3]]]
)
# 2 x 3 ๋ชจ์์ ๋ฐฐ์ด B
B = np.array(
[[0, 2, 1],
[2, 2, 3]]
)
# 2 ๋ชจ์์ ๋ฐฐ์ด C
C = np.array([[1, 2]])
result = A + B
print(result)
>>>[[[3 4 2]
[5 4 4]]
[[0 3 4]
[2 3 6]]]
result = A + C
>>>ValueError: operands could not be broadcast together with shapes (2,1,3) (1,2)

a. 2 x 3 ๋ชจ์์ ๊ฐ์ง 2์ฐจ์ ๋ฐฐ์ด B๋ 0์ฐจ์์ ํฌ๊ธฐ๊ฐ 2, 1์ฐจ์์ ํฌ๊ธฐ๊ฐ 3์
๋๋ค. ๊ทธ๋ฌ๋ 2 x 1 x 3 ๋ชจ์์ ๊ฐ์ง 3์ฐจ์์ ๋ฐฐ์ด A์ ๋ง์ถฐ 3์ฐจ์์ผ๋ก ํ์ฅ๋๋ฉด 0์ฐจ์์๋ ๋ฐฐ์ด A์ 0์ฐจ์ ํฌ๊ธฐ์ธ 2๊ฐ ๋๊ณ , 1์ฐจ์์๋ ๊ธฐ์กด ๋ฐฐ์ด์ 0์ฐจ์ ํฌ๊ธฐ(2)๊ฐ, 2์ฐจ์์๋ ๊ธฐ์กด ๋ฐฐ์ด์ 1์ฐจ์ ํฌ๊ธฐ(3)๊ฐ ๋ฉ๋๋ค.

b. ๊ทธ๋ฆฌ๊ณ ์์ ์ค์ต์์ ํ์ธํ๋ ๊ฒ์ฒ๋ผ ๋ฐฐ์ด A์ 1์ฐจ์์ ํฌ๊ธฐ๊ฐ 1์ด๋ฏ๋ก ๋ฐฐ์ด B์ 1์ฐจ์์ ํฌ๊ธฐ์ ๋ง์ถฐ 2๋ก ํ์ฅ๋ฉ๋๋ค.

๊ทธ๋ฌ๋ A + C์ ๊ฒฝ์ฐ ๋ธ๋ก๋์บ์คํ
์ด ์ ์ฉ๋์ง ์๋๋ค๊ณ ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค. ์ด๋ ๋ธ๋ก๋์บ์คํ
์ด ์ ์ฉ๋ ๋ ๋ง์ง๋ง ์ฐจ์๋ถํฐ ๋ง์ถฐ์ง๊ธฐ ๋๋ฌธ์
๋๋ค. ์ฆ, ๋ฐฐ์ด A์ 2์ฐจ์์ ํฌ๊ธฐ์ธ 3๊ณผ C์ 1์ฐจ์์ ํฌ๊ธฐ์ธ 2๊ฐ ๋ง์ง ์์ ๋ฐ์ํ ๊ฒ์
๋๋ค.

๋ฐฐ์ด ๊ฐ ์ฐ์ฐ์์ ์๋ก ์ฐจ์์ด ๋ง์ง ์๋๋ผ๋ A + B์ ๊ฐ์ด ๋ค์์๋ถํฐ ์ฐจ์์ ์ง์ด ์ผ์นํ๋ฉด ๋ธ๋ก๋์บ์คํ
์ด ์ ์ฉ๋ฉ๋๋ค.
any()๋ฉ์๋๋ ์ฃผ์ด์ง ๋ฐฐ์ด์ True๊ฐ ํ๋๋ผ๋ ์์ผ๋ฉด True๋ฅผ ๋ฐํํ๊ณ , True๊ฐ ํ๋๋ ์๋ค๋ฉด False๋ฅผ ๋ฐํํฉ๋๋ค.
๋ค์์ ์์ ์ฝ๋์ ๋๋ค.
A = np.array([1, 2, 3, 4, 5, 4, 3, 2, 1])
print(A >= 4)
>>>[False False False True True True False False False]
print((A >= 4).any())
>>>True
๋ฐฐ์ด A์๋ 4 ์ด์์ ์๊ฐ 4, 5, 4๋ก ์ด 3๊ฐ๊ฐ ์กด์ฌํฉ๋๋ค. ๋ฐฐ์ด์ ๊ด๊ณ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ 4 ์ด์์ ์๋ True, 4 ๋ฏธ๋ง์ ์๋ False์ธ ๋ฐฐ์ด์ ์ป์ต๋๋ค. ๊ทธ ํ any()๋ฉ์๋๋ฅผ ํตํด์ ํ๋๋ผ๋ True๊ฐ ์๋์ง ๊ฒ์ฌํฉ๋๋ค. ์ A์์ ๊ด๊ณ ์ฐ์ฐ์ ํตํด ์ป์ ๋ฐฐ์ด์๋ 1๊ฐ ์ด์(3๊ฐ)์ True๊ฐ ์กด์ฌํ๋ฏ๋ก any()๋ฉ์๋์ ๊ฒฐ๊ณผ๋ True๋ก ๋์ต๋๋ค.
all()๋ฉ์๋๋ ์ฃผ์ด์ง ๋ฐฐ์ด์ ๋ชจ๋ ์์๊ฐ True๋ผ๋ฉด True๋ฅผ ๋ฐํํ๊ณ , ํ๋๋ผ๋ False๊ฐ ์๋ค๋ฉด False๋ฅผ ๋ฐํํฉ๋๋ค.
๋ค์์ ์์ ์ฝ๋์ ๋๋ค.
A = np.array([1, 2, 3, 4, 5, 4, 3, 2, 1])
print(A >= 4)
>>>[False False False True True True False False False]
print((A >= 4).all())
>>>False
any()๋ฅผ ์ฌ์ฉํ์ ๋์ ๋ค๋ฅด๊ฒ False๊ฐ ์ถ๋ ฅ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ์ฆ, any()๋ ๊ด๊ณ ์ฐ์ฐ์๋ก ์ฐ์ฐํ ๋ฐฐ์ด์ True๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ True๋ฅผ ๋ฐํํ์ต๋๋ค. ๊ทธ๋ฌ๋ all()๋ ๋ชจ๋ ์์๊ฐ True๊ฐ ์๋๊ณ False์ธ ์์๋ค๋ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ False๋ฅผ ๋ฐํํฉ๋๋ค.

๋ฌธ์ ํ์ด
์ฌ๋ผ์ด์ฑ์ ์ด์ฉํด ๊ฐ ๊ตฌ์ญ์ ์ ๊ทผํ ํ ๊ด๊ณ ์ฐ์ฐ์๋ฅผ ์ด์ฉํด ๊ฐ์ ๋ณ๊ฒฝํฉ๋๋ค.
ํ์ด ์ฝ๋
def solution(board, bombs):
board[0:5,0:5][board[0:5,0:5]==bombs[0]] = 0
board[0:5,5:10][board[0:5,5:10]==bombs[1]] = 0
board[5:10,0:5][board[5:10,0:5]==bombs[2]] = 0
board[5:10,5:10][board[5:10,5:10]==bombs[3]] = 0
answer = board
return answer

๋ฌธ์ ํ์ด
๋ฐ์ดํฐ์ ๋ฐ์ดํฐ ํํฐ์ ๋ฐฐ์ด์ ํํ๋ ๊ฐ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ ํํฐ๋ฅผ ๋ฐ์ดํฐ ๋ฐฐ์ด์ ๊ฐ์๋งํผ ๋ธ๋ก๋์บ์คํ
์ ํตํด ๋๋๊ณ np.matmul()์ ์ฌ์ฉํ์ฌ ํ๋ ฌ๊ณฑ ์ฐ์ฐ์ ์งํํฉ๋๋ค.
ํ์ด ์ฝ๋
def solution(data, data_filter):
answer = np.matmul(data, data_filter/len(data))#๋ธ๋ก๋์บ์คํ
์ฌ์ฉ
return answer

๋ฌธ์ ํ์ด
๊ฐ ์ ํ๋ณ๋ก ์ต์ข
์ ์ ๊ณ์ฐ์ ํ์ํ ์์๋ฅผ ํฌํจํ๋ ๋ฐฐ์ด์ ๊ฐ๊ฐ ์์ฑํ๋ค. ๊ทธ ํ if๋ฌธ์ ํตํด ๋ฒํธ๋ง๋ค ์ด๋ค ์ ํ์ ์ง์ํ๋์ง์ ๋ฐ๋ผ ์์์ ๋ง๋ ์์ ๋ฐฐ์ด๊ณผ data ๋ฐฐ์ด์ ์ฌ๋ผ์ด์ฑํ ๊ฐ์ np.dot์ ํตํด ์ต์ข
์ ์๋ฅผ ๊ณ์ฐํ๋ค.
๋ง์ง๋ง์ผ๋ก ์ต์ข
์ ์๊ฐ ๊ฐ ํฉ๊ฒฉ ๊ธฐ์ค ์ ์๋ณด๋ค ๋ฎ์ผ๋ฉด ์ ๋ต ๋ฐฐ์ด์ ์ถ๊ฐํ๋ค.
ํ์ด ์ฝ๋
def solution(data):
answer = []
test1 = np.array([0.3,0.3,0.4])
test2 = np.array([0.5,0.15,0.2,0.15])
test3 = np.array([0.3,0.4,0.3])
for student in data:
if student[1] == 0:
if np.dot(test1, student[2:5]) >= 0.8:
answer.append(int(student[0]))
elif student[1] == 1:
if np.dot(test2, student[5:9]) >= 0.75:
answer.append(int(student[0]))
elif student[1] == 2:
if np.dot(test3, student[6:9]) >= 0.75:
answer.append(int(student[0]))
return answer
๋~!