2020. 11. 25. 16:02ใ๐ ์ฝ๋ฉ ํ ์คํธ/Python
<๊ตฌํ: ์๋ฎฌ๋ ์ด์ ๊ณผ ์์ ํ์>
๊ตฌํ(Implementation)
- ๊ตฌํ์ด๋, ๋จธ๋ฆฟ์์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ์์ค์ฝ๋๋ก ๋ฐ๊พธ๋ ๊ณผ์ ์ ๋๋ค.
- ํ๋ก๊ทธ๋๋ฐ์์์ ์ขํ๊ณ๋ ์ผ๋ฐ์ ์ธ ๋์ํ์์์ ์ขํ๊ณ์ ๋ค๋ฅธ ์๋ฏธ๋ฅผ ๊ฐ์ง ๋๊ฐ ๋ง์ต๋๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์์์ 2์ฐจ์ ๊ณต๊ฐ์ ํ๋ ฌ(Matrix)์ ์๋ฏธ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
- ์์ ํ์ ๋ฌธ์ ์์๋ 2์ฐจ์ ๊ณต๊ฐ์์์ ๋ฐฉํฅ ๋ฒกํฐ๊ฐ ์์ฃผ ํ์ฉ๋ฉ๋๋ค.
<๋ฌธ์ > ์๊ฐ: ๋ฌธ์ ์ค๋ช
- ์ ์ N์ด ์ ๋ ฅ๋๋ฉด 00์ 00๋ถ 00์ด๋ถํฐ N์ 59๋ถ 59์ด๊น์ง์ ๋ชจ๋ ์๊ฐ ์ค์์ 3์ด ํ๋๋ผ๋ ํฌํจ๋๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด 1์ ์ ๋ ฅํ์ ๋ ๋ค์์ 3์ด ํ๋๋ผ๋ ํฌํค๋์ด ์์ผ๋ฏ๋ก ์ธ์ด์ผ ํ๋ ์๊ฐ์ ๋๋ค.
- 00์ 00๋ถ 03์ด
- 00์ 13๋ถ 30์ด
- ๋ฐ๋ฉด์ ๋ค์์ 3์ด ํ๋๋ ํฌํจ๋์ด ์์ง ์์ผ๋ฏ๋ก ์ธ๋ฉด ์ ๋๋ ์๊ฐ์ ๋๋ค.
- 00์ 02๋ถ 55์ด
- 01์ 27๋ถ 45์ด
<๋ฌธ์ > ์๊ฐ: ๋ฌธ์ ์กฐ๊ฑด
<๋ฌธ์ > ์๊ฐ: ๋ฌธ์ ํด๊ฒฐ ์์ด๋์ด
- ์ด ๋ฌธ์ ๋ ๊ฐ๋ฅํ ๋ชจ๋ ์๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ํ๋์ฉ ๋ชจ๋ ์ธ์ ํ ์ ์๋ ๋ฌธ์ ์ ๋๋ค.
- ํ๋ฃจ๋ 86,400์ด์ด๋ฏ๋ก, 00์ 00๋ถ 00์ด๋ถํฐ 23์ 59๋ถ 59์ด๊น์ง์ ๋ชจ๋ ๊ฒฝ์ฐ๋ 86,400๊ฐ์ง ์ ๋๋ค.
- 24 * 60 * 60 = 86,400
- ๋ฐ๋ผ์ ๋จ์ํ ์๊ฐ์ 1์ฉ ์ฆ๊ฐ์ํค๋ฉด์ 3์ด ํ๋๋ผ๋ ํฌํจ๋์ด ์๋์ง๋ฅผ ํ์ธํ๋ฉด ๋ฉ๋๋ค.
- ์ด๋ฌํ ์ ํ์ ์์ ํ์(Brute Forcing) ๋ฌธ์ ์ ํ์ด๋ผ๊ณ ๋ถ๋ฆฝ๋๋ค.
- ๊ฐ๋ฅํ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ชจ๋ ๊ฒ์ฌํด๋ณด๋ ํ์ ๋ฐฉ๋ฒ์ ์๋ฏธํฉ๋๋ค.
<๋ฌธ์ > ์๊ฐ: ๋ต์ ์์ (Python)
# H ์
๋ ฅ ๋ฐ๊ธฐ
h = int(input())
count = 0
for i in range(h + 1):
for j in range(60):
for k in range(60):
# ๋งค ์๊ฐ ์์ '3'์ด ํฌํจ๋์ด ์๋ค๋ฉด ์นด์ดํธ ์ฆ๊ฐ
if '3' in str(i) + str(j) + str(k):
count += 1
print(count)
<๋ฌธ์ > ์ํ์ข์ฐ: ๋ฌธ์ ์ค๋ช
- ์ฌํ๊ฐ A๋ N x N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ ์์ ์ ์์ต๋๋ค. ์ด ๊ณต๊ฐ์ 1 x 1 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ์ผ๋ก ๋๋์ด์ ธ ์์ต๋๋ค. ๊ฐ์ฅ ์ผ์ชฝ ์ ์ขํ๋ (1, 1)์ด๋ฉฐ, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์ขํ๋ (N, N)์ ํด๋นํฉ๋๋ค. ์ฌํ๊ฐ A๋ ์, ํ, ์ข, ์ฐ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ ์ ์์ผ๋ฉฐ, ์์ ์ขํ๋ ํญ์ (1, 1)์ ๋๋ค. ์ฐ๋ฆฌ ์์๋ ์ฌํ๊ฐ A๊ฐ ์ด๋ํ ๊ณํ์ด ์ ํ ๊ณํ์๊ฐ ๋์ฌ ์์ต๋๋ค.
- ๊ณํ์์๋ ํ๋์ ์ค์ ๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์ฌ L, R, U, D์ค ํ๋์ ๋ฌธ์๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์ ํ ์์ต๋๋ค. ๊ฐ ๋ฌธ์์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- L: ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
- R: ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
- U ์๋ก ํ ์นธ ์ด๋
- D: ์๋๋ก ํ ์นธ ์ด๋
- ์ด๋ ์ฌํ๊ฐ A๊ฐ N x N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ์์ง์์ ๋ฌด์๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด (1, 1)์ ์์น์์ L ํน์ U๋ฅผ ๋ง๋๋ฉด ๋ฌด์๋ฉ๋๋ค. ๋ค์์ N = 5์ธ ์ง๋์ ๊ณํ์์ ๋๋ค.
<๋ฌธ์ > ์ํ์ข์ฐ: ๋ฌธ์ ์กฐ๊ฑด
<๋ฌธ์ > ์ํ์ข์ฐ: ๋ฌธ์ ํด๊ฒฐ ์์ด๋์ด
- ์ด ๋ฌธ์ ๋ ์๊ตฌ์ฌํญ๋๋ก ์ถฉ์คํ ๊ตฌํํ๋ฉด ๋๋ ๋ฌธ์ ์ ๋๋ค.
- ์ผ๋ จ์ ๋ช ๋ น์ ๋ฐ๋ผ์ ๊ฐ์ฒด๋ฅผ ์ฐจ๋ก๋๋ก ์ด๋์ํจ๋ค๋ ์ ์์ ์๋ฎฌ๋ ์ด์ (Simulation) ์ ํ์ผ๋ก๋ ๋ถ๋ฅ๋๋ฉฐ ๊ตฌํ์ด ์ค์ํ ๋ํ์ ์ธ ๋ฌธ์ ์ ํ์ ๋๋ค.
<๋ฌธ์ > ์ํ์ข์ฐ: ๋ต์ ์์ (Python)
# N ์
๋ ฅ ๋ฐ๊ธฐ
n = int(input())
x, y = 1, 1
plans = input().split()
# L, R, U, D ์ ๋ฐ๋ฅธ ์ด๋ ๋ฐฉํฅ
dx = [0, 0, -1, 1]
dy = [-1, -1, 0, 0]
move_types = ['L', 'R', 'U', 'D']
# ์ด๋ ๊ณํ์ ํ๋์ฉ ํ์ธํ๊ธฐ
for plan in plans:
# ์ด๋ ํ ์ขํ ๊ตฌํ๊ธฐ
for i in range(len(voe_types)):
if plan == move_types[i]:
nx = x + dx[i]
ny = y + dy[i]
# ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ ๋ฌด์
if nx < 1 or ny < 1 or nx > n or ny > n:
continue
# ์ด๋ ์ํ
x, y = nx, ny
print(x, y)
<๋ฌธ์ > ๋ฌธ์์ด ์ฌ์ ๋ ฌ: ๋ฌธ์ ์ค๋ช
- ์ํ๋ฒณ ๋๋ฌธ์์ ์ซ์(0 ~ 9)๋ก๋ง ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ด ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋๋ค. ์ด๋ ๋ชจ๋ ์ํ๋ฒณ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ์ด์ด์ ์ถ๋ ฅํ ๋ค์, ๊ทธ ๋ค์ ๋ชจ๋ ์ซ์๋ฅผ ๋ํ ๊ฐ์ ์ด์ด์ ์ถ๋ ฅํฉ๋๋ค.
<๋ฌธ์ > ๋ฌธ์์ด ์ฌ์ ๋ ฌ: ๋ฌธ์ ์กฐ๊ฑด
<๋ฌธ์ > ๋ฌธ์์ด ์ฌ์ ๋ ฌ: ๋ฌธ์ ํด๊ฒฐ ์์ด๋์ด
- ๋ฌธ์์ด์ด ์ ๋ ฅ๋์์ ๋ ๋ฌธ์๋ฅผ ํ๋์ฉ ํ์ธํฉ๋๋ค.
<๋ฌธ์ > ๋ฌธ์์ด ์ฌ์ ๋ ฌ: ๋ต์ ์์ (Python)
data = input()
result = []
value = 0
# ๋ฌธ์๋ฅผ ํ๋์ฉ ํ์ธํ๋ฉฐ
for x in data:
# ์ํ๋ฒณ์ธ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ์ฝ์
if x.isalpha():
result.append(x)
# ์ซ์๋ ๋ฐ๋ก ๋ํ๊ธฐ
else:
value += int(x)
# ์ํ๋ฒณ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
result.sort()
# ์ซ์๊ฐ ํ๋๋ผ๋ ์กด์ฌํ๋ ๊ฒฝ์ฐ ๊ฐ์ฅ ๋ค์ ์ฝ์
if value != 0:
result.append(str(value))
# ์ต์ข
๊ฒฐ๊ณผ ์ถ๋ ฅ(๋ฆฌ์คํธ๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ์ฌ ์ถ๋ ฅ)
print(''.join(result))
'๐ ์ฝ๋ฉ ํ ์คํธ > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๐ง ๋ฆฌ์คํธ(๋ฐฐ์ด) ๊ฐ๋ ์ ๋ฆฌ & ์ฐ์ต๋ฌธ์ ํ์ด (with Python) (0) | 2025.07.01 |
---|---|
Python์ main์ด ์๋ ์ด์ (0) | 2025.03.24 |
๊ทธ๋ฆฌ๋ & ๊ตฌํ # 1 (0) | 2020.11.25 |
ํ์ด์ฌ ๋ฌธ๋ฒ #4 (0) | 2020.11.19 |
ํ์ด์ฌ ๋ฌธ๋ฒ #3 (0) | 2020.11.19 |