๐๋ณธ ํฌ์คํ ์ '(์ด์ฝํ 2021) ์ด๊ฒ์ด ์ทจ์ ์ ์ํ ์ฝ๋ฉ ํ ์คํธ๋ค with ํ์ด์ฌ' ์ ํ๋ธ ๊ฐ์๋ฅผ ์๊ฐํ๊ณ ์ ๋ฆฌํ ๊ธ์ ๋๋ค.
๋จธ๋ฆฟ์์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ์์ค์ฝ๋๋ก ๋ฐ๊พธ๋ ๊ณผ์
์ผ๋ฐ์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์์์ 2์ฐจ์ ๊ณต๊ฐ์ ํ๋ ฌ(Matrix)
์ ์๋ฏธ๋ก ์ฌ์ฉ๋๋ค.
for i in range(5):
for j in range(5):
print('(',i,',',j,')', end=' ')
print()
์๋ฎฌ๋ ์ด์
๋ฐ ์์ ํ์ ๋ฌธ์ ์์๋ 2์ฐจ์ ๊ณต๊ฐ์์์ ๋ฐฉํฅ ๋ฒกํฐ
๊ฐ ์์ฃผ ํ์ฉ๋๋ค.
# ๋, ๋ถ, ์, ๋จ
dx = [0,-1,0,1]
dy = [1,0,-1,0]
# ํ์ฌ ์์น
x,y = 2,2
for i in range(4):
# ๋ค์ ์์น
nx = x + dx[i]
ny = y + dy[i]
print(nx, ny)
๋ฌธ์ ์ค๋ช
์ฌํ๊ฐ A๋ NXN ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ ์์ ์ ์์ต๋๋ค.
์ด ๊ณต๊ฐ์ 1X1 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ์ผ๋ก ๋๋์ด์ ธ ์์ต๋๋ค.
๊ฐ์ฅ ์ผ์ชฝ ์ ์ขํ๋ (1,1)์ด๋ฉฐ, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์ขํ๋ (N,N)์ ํด๋นํฉ๋๋ค.
์ฌํ๊ฐ A๋ ์,ํ,์ข,์ฐ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ ์ ์์ผ๋ฉฐ, ์์ ์ขํ๋ ํญ์ (1,1)์
๋๋ค.
์ฐ๋ฆฌ ์์๋ ์ฌํ๊ฐ A๊ฐ ์ด๋ํ ๊ณํ์ด ์ ํ ๊ณํ์๊ฐ ๋์ฌ ์์ต๋๋ค.
๊ณํ์์๋ ํ๋์ ์ค์ ๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์ฌ L,R,U,D ์ค ํ๋์ ๋ฌธ์๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์ ํ์์ต๋๋ค. ๊ฐ ๋ฌธ์์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
L: ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
R: ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
U: ์๋ก ํ ์นธ ์ด๋
D: ์๋๋ก ํ ์นธ ์ด๋
์ด๋ ์ฌํ๊ฐ A๊ฐ NXN ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ์์ง์์ ๋ฌด์๋ฉ๋๋ค.
# 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(move_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)
๋ฌธ์ ์ค๋ช
์ ์ N์ด ์ ๋ ฅ๋๋ฉด 00์ 00๋ถ 00์ด๋ถํฐ N์ 59๋ถ 59์ด๊น์ง์ ๋ชจ๋ ์๊ฐ ์ค์์ 3์ด ํ๋๋ผ๋ ํฌํจ๋๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์๋ฅผ ๋ค์ด 1์ ์ ๋ ฅํ์ ๋ ๋ค์์ 3์ด ํ๋๋ผ๋ ํฌํจ๋์ด ์์ผ๋ฏ๋ก ์ธ์ด์ผ ํ๋ ์๊ฐ์ ๋๋ค.
00์ 00๋ถ 03์ด
00์ 13๋ถ 30์ด
n = int(input())
# 1. 0์ ~ n์
# 2. 00๋ถ ~ 59๋ถ
# 3. 00์ด ~ 59์ด
cnt = 0
for i in range(n+1):
for j in range(60):
for k in range(60):
time = str(i) + str(j) + str(k)
if '3' in time:
cnt += 1
print(cnt)
๋ฌธ์ ์ค๋ช
ํ๋ณต ์๊ตญ์ ์์ค ์ ์์ ์ฒด์คํ๊ณผ ๊ฐ์ 8X8 ์ขํ ํ๋ฉด์
๋๋ค.
์์ค ์ ์์ ํน์ ํ ํ ์นธ์ ๋์ดํธ๊ฐ ์ ์์ต๋๋ค.
๋์ดํธ๋ ๋ง์ ํ๊ณ ์๊ธฐ ๋๋ฌธ์ ์ด๋ํ ๋๋ L์ ํํ๋ก๋ง ์ด๋ํ ์ ์์ผ๋ฉฐ ์ ์ ๋ฐ์ผ๋ก๋ ๋๊ฐ ์ ์์ต๋๋ค.
๋์ดํธ๋ ํน์ ์์น์์ ๋ค์๊ณผ ๊ฐ์ 2๊ฐ์ง ๊ฒฝ์ฐ๋ก ์ด๋ํ ์ ์์ต๋๋ค.
1. ์ํ์ผ๋ก ๋ ์นธ ์ด๋ํ ๋ค์ ์์ง์ผ๋ก ํ ์นธ ์ด๋ํ๊ธฐ
2. ์์ง์ผ๋ก ๋ ์นธ ์ด๋ํ ๋ค์ ์ํ์ผ๋ก ํ ์นธ ์ด๋ํ๊ธฐ
์์ค์ ์ ์์์ ํ ์์น๋ฅผ ํํํ ๋๋ 1๋ถํฐ 8๋ก ํํํ๋ฉฐ, ์ด ์์น๋ฅผ ํํํ ๋๋ a๋ถํฐ h๋ก ํํํฉ๋๋ค.
n = input()
x = ord(n[0]) - 96
y = int(n[1])
cnt = 0
steps = [(-2,1), (-2,-1), (2,1), (2,-1), (1,2), (1,-2), (-1,2), (-1,-2)]
for step in steps:
dx = x + step[0]
dy = y + step[1]
if (dx >= 1 and dx <= 8 and dy >= 1 and dy <= 8):
cnt += 1
print(cnt)
๋ฌธ์ ์ค๋ช
์ํ๋ฒณ ๋๋ฌธ์์ ์ซ์(0~9)๋ก๋ง ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ด ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋๋ค.
์ด๋ ๋ชจ๋ ์ํ๋ฒณ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ์ด์ด์ ์ถ๋ ฅํ ๋ค์, ๊ทธ ๋ค์ ๋ชจ๋ ์ซ์๋ฅผ ๋ํ ๊ฐ์ ์ด์ด์ ์ถ๋ ฅํฉ๋๋ค.
๋ฌธ์ ํด๊ฒฐ
1.์
๋ ฅ ๋ฐ์ ๋ฌธ์์ด์ ์ฒ์๋ถํฐ ์ํํ๋ฉด์ ์ํ๋ฒณ์ด๋ฉด (.isalpha()์ฌ์ฉ) ์ํ๋ฒณ ๋ฆฌ์คํธ์ ์ ์ฅ
2. ์ํ๋ฒณ์ด ์๋๋ผ๋ฉด ์ซ์๋ฅผ ๊ณ์ ๋ํด๋๊ฐ
3. ์ํ๋ฒณ์ ์ค๋ฆ์ฐจ์(sort() ์ฌ์ฉ) ํด์ฃผ๊ณ
4. ๋ค์ ๋ํ ์ซ์๋ฅผ ์ถ๊ฐํด์ค๋ค (.append() ์ฌ์ฉ)
5.'๊ตฌ๋ถ์'.join(๋ฆฌ์คํธ): ๋ฆฌ์คํธ์ ๊ฐ๊ณผ ๊ฐ ์ฌ์ด์ '๊ตฌ๋ถ์'์ ๋ค์ด์จ ๊ตฌ๋ถ์๋ฅผ ๋ฃ์ด์ ํ๋์ ๋ฌธ์์ด์ ๋ง๋ค์ด์ ๋ฐํ
.join() ๋ฅผ ์ฌ์ฉํ์ง ์์์ ๋:
.join() ๋ฅผ ์ฌ์ฉํ์ ๋:
def solution(s):
num = 0
answer = []
for i in s:
if i.isalpha():
answer.append(i)
else:
num += int(i)
answer.sort()
answer.append(str(num))
return ''.join(answer)
print(solution("K1KA5CB7"))