๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/17681
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก์ Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
๋ค์ค๋ ํ์ ํ๋ก๋๊ฐ ๋น์๊ธ์ ์จ๊ฒจ๋๋ ์ฅ์๋ฅผ ์๋ ค์ค ๋น๋ฐ์ง๋๋ฅผ ์์ ๋ฃ์๋ค. ๊ทธ๋ฐ๋ฐ ์ด ๋น๋ฐ์ง๋๋ ์ซ์๋ก ์ํธํ๋์ด ์์ด ์์น๋ฅผ ํ์ธํ๊ธฐ ์ํด์๋ ์ํธ๋ฅผ ํด๋ ํด์ผ ํ๋ค. ๋คํํ ์ง๋ ์ํธ๋ฅผ ํด๋ ํ ๋ฐฉ๋ฒ์ ์ ์ด๋์ ๋ฉ๋ชจ๋ ํจ๊ป ๋ฐ๊ฒฌํ๋ค.
- ์ง๋๋ ํ ๋ณ์ ๊ธธ์ด๊ฐ n์ธ ์ ์ฌ๊ฐํ ๋ฐฐ์ด ํํ๋ก, ๊ฐ ์นธ์ "๊ณต๋ฐฑ"(" ") ๋๋ "๋ฒฝ"("#") ๋ ์ข ๋ฅ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
- ์ ์ฒด ์ง๋๋ ๋ ์ฅ์ ์ง๋๋ฅผ ๊ฒน์ณ์ ์ป์ ์ ์๋ค. ๊ฐ๊ฐ "์ง๋ 1"๊ณผ "์ง๋ 2"๋ผ๊ณ ํ์. ์ง๋ 1 ๋๋ ์ง๋ 2 ์ค ์ด๋ ํ๋๋ผ๋ ๋ฒฝ์ธ ๋ถ๋ถ์ ์ ์ฒด ์ง๋์์๋ ๋ฒฝ์ด๋ค. ์ง๋ 1๊ณผ ์ง๋ 2์์ ๋ชจ๋ ๊ณต๋ฐฑ์ธ ๋ถ๋ถ์ ์ ์ฒด ์ง๋์์๋ ๊ณต๋ฐฑ์ด๋ค.
- "์ง๋ 1"๊ณผ "์ง๋ 2"๋ ๊ฐ๊ฐ ์ ์ ๋ฐฐ์ด๋ก ์ํธํ๋์ด ์๋ค.
- ์ํธํ๋ ๋ฐฐ์ด์ ์ง๋์ ๊ฐ ๊ฐ๋ก์ค์์ ๋ฒฝ ๋ถ๋ถ์ 1, ๊ณต๋ฐฑ ๋ถ๋ถ์ 0์ผ๋ก ๋ถํธํํ์ ๋ ์ป์ด์ง๋ ์ด์ง์์ ํด๋นํ๋ ๊ฐ์ ๋ฐฐ์ด์ด๋ค.

๋ค์ค๊ฐ ํ๋ก๋์ ๋น์๊ธ์ ์์ ๋ฃ์ ์ ์๋๋ก, ๋น๋ฐ์ง๋์ ์ํธ๋ฅผ ํด๋ ํ๋ ์์ ์ ๋์์ค ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์ ๋ ฅ ํ์
์ ๋ ฅ์ผ๋ก ์ง๋์ ํ ๋ณ ํฌ๊ธฐ n ๊ณผ 2๊ฐ์ ์ ์ ๋ฐฐ์ด arr1, arr2๊ฐ ๋ค์ด์จ๋ค.
- 1 โฆ n โฆ 16
- arr1, arr2๋ ๊ธธ์ด n์ธ ์ ์ ๋ฐฐ์ด๋ก ์ฃผ์ด์ง๋ค.
- ์ ์ ๋ฐฐ์ด์ ๊ฐ ์์ x๋ฅผ ์ด์ง์๋ก ๋ณํํ์ ๋์ ๊ธธ์ด๋ n ์ดํ์ด๋ค. ์ฆ, 0 โฆ x โฆ 2n - 1์ ๋ง์กฑํ๋ค.
์ถ๋ ฅ ํ์
์๋์ ๋น๋ฐ์ง๋๋ฅผ ํด๋ ํ์ฌ '#', ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด ๋ฐฐ์ด๋ก ์ถ๋ ฅํ๋ผ.
์ ์ถ๋ ฅ ์์

ํ์ด
์ด ๋ฌธ์ ๋ ์ญ์ง์๋ฅผ ์ด์ง์๋ก ๋ณํํด์, ๋นํธ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ํ๋ฉด ๋๋ค.
1. ๊ฐ ๋ฐฐ์ด์ ์ซ์๋ฅผ ์ด์ง์๋ก ๋ณํํ๊ณ
2. ๋ณํํ ์ด์ง์๋ผ๋ฆฌ ๋นํธ ์ฐ์ฐ์ | ๋ฅผ ์ฌ์ฉํด ๋ ๋ค 0์ธ ๊ฒฝ์ฐ๋ง 0์ด ๋๋๋ก ๋ง๋ ๋ค.
์ด ๋ | ์ฐ์ฐ์๋ (OR) ์ฐ์ฐ์๋ก, '1100' | '1010' => '1110' ์ผ๋ก ๊ณ์ฐ๋๋ค.
๊ฐ์ด ์๋ฉด ์ข์ & ์ฐ์ฐ์๋ (AND) ์ฐ์ฐ์๋ก, '1100' & '1010' => 1000' ์ผ๋ก ๊ณ์ฐ๋๋ค.
์ฆ, |๋ ๋ ์ค ํ๋๋ง 1์ด๋๋ผ๋ 1๋ก ๊ณ์ฐ๋๊ณ ,
&๋ ๋ ๋ค 1์ด์ด์ผ๋ง 1๋ก ๊ณ์ฐ๋๋ค.
3. ๋นํธ ์ฐ์ฐ์๋ก ๋ณํ๋ ์๊ฐ 1->'#', 0-> ' ' ์ผ๋ก ๋ณํํด์ค๋ค.
์ ๋ต ์ฝ๋
์ ์์๋๋ก ๊ตฌํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค.
# ์ต์ข
๊ฒฐ๊ณผ๋ฅผ ๋ง๋๋ ๋ฉ์ธ ํจ์
def solution(n, arr1, arr2):
# arr1๊ณผ arr2๋ฅผ ๋นํธ OR ์ฐ์ฐ ํ ์ด์ง ๋ฌธ์์ด ๋ฆฌ์คํธ๋ก ๋ณํ
result = binary_num(arr1, arr2, n)
answer = []
# ๊ฐ ์ด์ง ๋ฌธ์์ด์ '#' ๋๋ ' '๋ก ๋ณํ
for i in range(len(result)):
ans = ''
for j in range(len(result[i])):
if result[i][j] == '1': # '1'์ด๋ฉด ๋ฒฝ์ด๋ฏ๋ก '#'
ans += "#"
else: # '0'์ด๋ฉด ๊ณต๋ฐฑ
ans += " "
answer.append(ans) # ์์ฑ๋ ๋ฌธ์์ด์ ๋ฆฌ์คํธ์ ์ถ๊ฐ
return answer
# ๋ ๋ฆฌ์คํธ์ ๊ฐ ์์๋ฅผ ๋นํธ OR ์ฐ์ฐํ ํ, n์๋ฆฌ ์ด์ง ๋ฌธ์์ด๋ก ๋ณํํ๋ ํจ์
def binary_num(arr1, arr2, n):
result = []
for a, b in zip(arr1, arr2): # arr1๊ณผ arr2์์ ๊ฐ์ ์ธ๋ฑ์ค๋ผ๋ฆฌ ์ง์ง์ด ๋ฐ๋ณต
binary = bin(a | b)[2:].zfill(n) # ๋นํธ OR ํ, ์์ '0b' ์ ๊ฑฐํ๊ณ n์๋ฆฟ์๋ก ์ฑ์
result.append(binary) # ๋ณํ๋ ์ด์ง ๋ฌธ์์ด์ ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ์ถ๊ฐ
return result
์ด ๋ ์๋กญ๊ฒ ์๊ฒ๋ ํจ์๋ .zfill()์ด๋ค. ์ด ํจ์๋ n์๋ฆฌ์์ ๋น ๊ณณ์ ์ฑ์์ฃผ๋ ํจ์์ด๋ค.
bin ํจ์๋ฅผ ์ ์ฌ์ฉํ๋ ๊ฒ๊ณผ .zfill()๊ณผ ๊ฐ์ด ์๋ฆฟ์๋ฅผ ๊ณ ๋ คํ๋ ๊ฒ์ด ์ค์ํ ํต์ฌ์ด์๋ ๊ฒ ๊ฐ๋ค.
'๐ ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [python] ๋ฆฌ์คํธ์์ ์ฌ๋ผ์ด์ฑ ํ ๋ฆฌ์คํธ ํํ๊ฐ ์๋ ์์๋ค๋ง ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ (0) | 2025.08.21 |
|---|---|
| [ํ๋ก๊ทธ๋๋จธ์ค] : ์์ด ๋๋ง์๊ธฐ (1) | 2025.07.17 |
| [ํ๋ก๊ทธ๋๋จธ์ค] : ์ฐ์ ๋ถ๋ถ ์์ด ํฉ์ ๊ฐ์ (3) | 2025.07.14 |
| [ํ๋ก๊ทธ๋๋จธ์ค] : ๋ฉ๋ฆฌ๋ฐ๊ธฐ (0) | 2025.07.13 |
| [DP] ํ์ด์ฌ์ผ๋ก Dynamic Programming ์ ๋ณตํ๊ธฐ (0) | 2025.07.13 |