์ฝ๋ฉ ํ ์คํธ์์ ๊ตฌํ์ ๋จธ๋ฆฟ์์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ์์ค์ฝ๋๋ก ๋ฐ๊พธ๋ ๊ณผ์ ์ ์๋ฏธํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ๊ตฌํ ์ ํ์ ๋ฌธ์ ๋ ํ์ด๋ฅผ ๋ ์ฌ๋ฆฌ๋ ๊ฒ์ ์ฝ์ง๋ง ์์ค์ฝ๋๋ก ์ฎ๊ธฐ๊ธฐ ์ด๋ ค์ด ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
์ด๊ฒ์ด ์ทจ์ ์ ์ํ ์ฝ๋ฉํ ์คํธ๋ค์์๋ ์์ ํ์๊ณผ ์๋ฎฌ๋ ์ด์ ์ ๋ชจ๋ ๊ตฌํ ์ ํ์ผ๋ก ๋ฌถ์ด์ ๋ค๋ฃจ๊ณ ์๋ค.
์์ ํ์์ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ฃผ์ ์์ด ๋ค ๊ณ์ฐ ํ๋ ๋ฐฉ๋ฒ์ ์๋ฏธํ๊ณ , ์๋ฎฌ๋ ์ด์ ์ ๋ฌธ์ ์์ ์ ์ํ ์๊ณ ๋ฆฌ์ฆ์ ํ ๋จ๊ณ์ฉ ์ฐจ๋ก๋๋ก ์ง์ ์ํํด์ผ ํ๋ ์ ํ์ ์๋ฏธํ๋ค.
์๋ฃํ
C/C++๊ณผ ์๋ฐ์์๋ ๊ธฐ๋ณธ int
์๋ฃํ์ ํํ ๋ฒ์๊ฐ -2,147,483,648 ~ 2,147,438,647์ด๋ค. ๋ฐ๋ผ์ ๋ ํฐ ์๋ฅผ ํํํ๊ธฐ ์ํด์๋ long long
์๋ฃํ์ด๋ BigInteger
ํด๋์ค๋ฅผ ์ด์ฉํด์ผ ํ๋ค. ํ์ง๋ง ํ์ด์ฌ์์๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ์๋ฃํ์ ์ง์ ํ ํ์๊ฐ ์๊ณ , ๋งค์ฐ ํฐ ์์ ์ฐ์ฐ ๋ํ ๊ธฐ๋ณธ์ผ๋ก ์ง์ํ๊ธฐ ๋๋ฌธ์ ํฌ๊ฒ ๊ณ ๋ฏผํ ํ์๊ฐ ์๋ค.
๋ฆฌ์คํธ์ ํฌ๊ธฐ
๋์ฒด๋ก ์ฝ๋ฉ ํ
์คํธ์์๋ 128 ~ 512MB๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ํํ๋ค. ํ์ด์ฌ์ ๊ตฌํ์์ ๋ณต์กํจ์ด ์ ์ ๋์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋์ด ๋ง์ ๊ฒฝ์ฐ์๋ ๊ผญ ๋ฉ๋ชจ๋ฆฌ ์ ํ์ ๊ณ ๋ คํด์ผ ํ๋ค.
๋ค์ ์งํ ๋ฐฉํฅ์ ๋ํ ์ ๋ณด๋ฅผ ์
๋ ฅ ๋ฐ์์ ์ด๋ํ ํ, ๋์ฐฉ ์ขํ๋ฅผ ์ถ๋ ฅํ๋ ๋ฌธ์ ๋ค. ์
๋ ฅ์ด string
์๋ฃํ์ผ๋ก ์ฃผ์ด์ง๊ธฐ ๋๋ฌธ์ dictionary
์๋ฃํ์ ์ฌ์ฉํ์ฌ ์ ์ ํํ๋ก ๋ณํํด์ฃผ์๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
import sys
input = sys.stdin.readline
n = int(input())
order = input().split()
x, y = 1, 1
# ์์น ์ ๋ณด ์ ์ ํํ๋ก ๋ณํ
dir = {
"U": 0,
"D": 1,
"L": 2,
"R": 3,
}
# ์ด๋ ๋ฐฉํฅ ์ค์
dxs, dys = [-1, 1, 0, 0], [0, 0, -1, 1]
# ๊ณต๊ฐ ๋ด์ ์ขํ์ธ์ง ์ฒดํฌ
def in_range(x, y):
return 0 < x < n and 0 < y < n
for val in order:
idx = dir[val]
nx, ny = x + dxs[idx], y + dys[idx]
if in_range(nx, ny):
x, y = nx, ny
print(x, y)
00์ 00๋ถ 00์ด๋ถํฐ ์ ๋ ฅ ๋ฐ์ N์ 59๋ถ 59์ด๊น์ง์ ๋ชจ๋ ์๊ฐ ์ค 3์ด ํ๋๋ผ๋ ํฌํจ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
n = int(input())
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)
๋ชจ๋ ์๊ฐ์ ๊ฒฝ์ฐ์ ์๋ฅผ ํ๋์ฉ ์ธ์ด๋ 86,400๊ฐ์ง๋ฐ์ ์กด์ฌํ์ง ์๋๋ค. ์ฆ, ํ์ด์ฌ์ ๋ฌธ์์ด ์ฐ์ฐ์ ์ฌ์ฉํด๋ ์๊ฐ ์ ํ 2์ด ์์ ๋ฌธ์ ๋ฅผ ํ ์ ์๊ธฐ ๋๋ฌธ์ ์์ ํ์์ ๋ฐฉ๋ฒ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
์ ๋ ฅ ๋ฐ์ ์์น ์ ๋ณด๋ฅผ ์ ์ ํํ๋ก ๋ณํํ๋ ๊ฒ ์ค์ํ๋ค. a ~ h๋ฅผ 1 ~ 8์ด๋ผ๊ณ ์๊ฐํ๊ณ ๋ฌธ์ ๋ฅผ ์ ๊ทผํ๋ฉด ์ฝ๊ฒ ํด๊ฒฐํ ์ ์๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
val = input()
# ์ด ์์น ์ ์ ํํ๋ก ๋ณํ
dir = {
"a" : 1,
"b" : 2,
"c" : 3,
"d" : 4,
"e" : 5,
"f" : 6,
"g" : 7,
"h" : 8,
}
x, y = int(val[1]), int(dir[val[0]])
cnt = 0
# ์ด๋ ๊ฐ๋ฅํ ์์น์ธ์ง ์ฒดํฌ
def in_range(x, y):
return 1 <= x < 9 and 1 <= y < 9
# ๋์ดํธ์ ์ด๋ ๊ฐ๋ฅ ๋ฐฉํฅ
dxs, dys = [2, 2, -2, -2, 1, -1, 1, -1], [1, -1, 1, -1, 2, 2, -2, -2]
for dx, dy in zip(dxs, dys):
nx, ny = x + dx, y + dy
if in_range(nx, ny):
cnt += 1
print(cnt)
์์ ์ฝ๋
val = input()
x, y = int(val[1]), int(ord(val[0])) - int(ord('a')) + 1
steps = [(-2, -1), (-1, -2), (1, -2), (2, -1), (2, 1), (1, 2), (-1, 2), (-2, 1)]
def in_range(x, y):
return 1 <= x < 9 and 1 <= y < 9
cnt = 0
for step in steps:
nx, ny = x + step[0], y + step[1]
if in_range(nx, ny):
cnt += 1
printc(cnt)
์ด ์ ๋ณด๋ฅผ ์ ์๋ก ๋ณํํ๊ธฐ ์ํด dictionary
์๋ฃํ์ ์ฌ์ฉํ ๊ฒ๊ณผ ๋ค๋ฅด๊ฒ ์์ ์ฝ๋์์๋ ์์คํค์ฝ๋ ๋ณํ ํจ์ ord()
๋ฅผ ์ฌ์ฉํ๋ค. ์ฝ๋๋ฅผ ๋ณด๋ค ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์ ์๊ธฐ ๋๋ฌธ์ ์ฌ์ฉ์ ์ต์ํด์ง๋๋ก ํ์.
๋ํ, dxs
, dys
๋ฅผ ์ฌ์ฉํ ๊ฒ์ด ์๋๋ผ steps
๋ฐฐ์ด์ ๋์ดํธ์ ์ด๋ ๊ฐ๋ฅ ์์น๋ฅผ ๋ชจ๋ ์ ์ฅํ๊ณ ๋ฐ๋ณต๋ฌธ์ ํตํด ์ ๊ทผํ๋ค. ํฐ ์ฐจ์ด๋ ์์ง๋ง ์ํฉ์ ๋ฐ๋ผ ์ ์ ํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋๋ก ํ์.
dx, dy๋ฅผ ์ฌ์ฉํ์ฌ ์ขํํ๋ฉด์์ ํ์ ์ ํ๊ณ , ๋ฐฉ๋ฌธํ ์ ์ด ์๋ ์ฅ์๋ผ๋ฉด 1์, ๋ฐฉ๋ฌธํ ์ ์ด ์๋ ์ฅ์๋ผ๋ฉด 0์ ํ ๋นํ์ฌ ๊ตฌ๋ถํ๋ค.
์์ ์ฝ๋
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
a, b, d = map(int, input().split())
game = [list(map(int, input().split())) for _ in range(n)]
temp = [([0] * m) for _ in range(n)]
temp[b][a] = 1
dxs, dys = [0, 1, 0, -1], [-1, 0, 1, 0]
def turn_left():
global d
d -= 1
if d == -1:
d = 3
cnt = 1
turn = 0
while True:
turn_left()
nx, ny = a + dxs[d], b + dys[d]
if game[ny][nx] == 0 and temp[ny][nx] == 0:
temp[ny][nx] = 1
a, b = nx, ny
cnt += 1
turn = 0
continue
else:
turn += 1
if turn == 4:
nx, ny = a - dxs[d], b - dys[d]
if game[ny][nx] == 0:
a, b = nx, ny
else:
break
turn = 0
print(cnt)
๋ค ๋ฐฉํฅ์ ๋ชจ๋ ํ์ธํ ๊ฒฝ์ฐ, ์๋ ๊ณณ์ผ๋ก ๋์๊ฐ๋ ๋ก์ง์ ๊ตฌํํ์ง ๋ชปํ๋ค. turn
๋ณ์๋ฅผ ์์ฑํ๊ณ ๊ฐ ์ ์๋ ๊ณณ์ ๋ง๋ ๋๋ง๋ค 1์ ๋ํด์ค๋ค. turn
์ด 4๊ฐ ๋๋ค๋ฉด ๋ชจ๋ ๋ฐฉํฅ์ ํ์ธํ๋ค๋ ์๋ฏธ์ด๋ฏ๋ก ์ด ๋ ์๋ ๊ณณ์ผ๋ก ๋์๊ฐ๋ฉด ๋๋ค.
์ถ๊ฐ๋ก, ์์ ์ฝ๋์์๋ temp
๋ฐฐ์ด์ ์๋ก ์์ฑํด์ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ํ์ธํ๋ค. ์ด ๋ ๋ฐฉ๋ฌธํ ์ฅ์๋ผ๋ฉด 2๋ฅผ ํ ๋นํ์ฌ ๊ธฐ์กด์ ๋ฐฐ์ด ๋ด์์๋ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ๊ตฌ๋ถํ ์ ์๋ค๊ณ ํ๋จํ๋ค. ์ํฉ์ ๋ง๊ฒ ์ ์ ํ ์ฌ์ฉํ๋๋ก ํ์.
์
๋ ฅ๊ฐ์ ๋ฌธ์์ด๋ก ๋ฐ์ ๋ค ์ข์ฐ์ธก ๋ฌธ์์ด์ int
์๋ฃํ์ผ๋ก ๋ณํํด์ ๋น๊ตํด์ฃผ๋ฉด ๋๋ค.
n = input()
m = len(n) // 2
if sum(map(int, n[:m])) == sum(map(int, n[m::])):
print("LUCKY")
else:
print("READY")
๋ชซ ์ฐ์ฐ์ //
๋ฅผ ํ์ฉํ์ฌ ์ค๊ฐ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์๊ณ , map()
ํจ์๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์์ด๋ก ๋ฐ์ ์
๋ ฅ๊ฐ์ ์ ์ ์๋ฃํ์ผ๋ก ๋ณํํด์ฃผ์๋ค.
์ ๋ ฅ๊ฐ์ด ๋ฌธ์์ธ์ง ์ซ์์ธ์ง ์ฌ๋ถ์ ๋ฐ๋ผ ๊ตฌ๋ถํ๊ณ ํ์ํ ์ฐ์ฐ์ ์ฒ๋ฆฌํด์ค ๋ค ๋ค์ ํฉ์ณ์ค๋ค.
n = input()
_str = ""
_int = 0
for i in n:
if i.isalpha():
_str += i
else:
_int += int(i)
print("".join(sorted(_str)) + str(_int))
๋น ๋ฌธ์์ด _str
๊ณผ _int
๋ฅผ ์์ฑํ๋ค. ๊ทธ๋ฆฌ๊ณ isalpha()
๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ ์
๋ ฅ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ์ํ๋ฒณ์ธ์ง ์๋์ง ํ๋ณํ๋ค. ์ํ๋ฒณ์ด๋ผ๋ฉด _str
๋ฌธ์์ด์ ๋ํด์ฃผ์๊ณ , ์ํ๋ฒณ์ด ์๋๋ผ๋ฉด int
์๋ฃํ์ผ๋ก ๋ณํํ์ฌ _int
์ ๋ํด์ฃผ์๋ค.
๋ง์ง๋ง์ผ๋ก _str
๋ฌธ์์ด์ sorted()
๋ฉ์๋๋ก ์ ๋ ฌํ ๋ค join()
๋ฉ์๋๋ก ๋ฌธ์์ดํ ์์ผ์ _int
์ ํจ๊ป ์ถ๋ ฅํ๋ค.
์ด์ค ๋ฐ๋ณต๋ฌธ์ ํ์ฉํ์ฌ step
์ ์ค์ ํ ํ์๊ฐ ์๋ค. ์ด ๋, step
์ ์ต๋ ๋ฌธ์์ด s
์ ์ ๋ฐ์ ๋์ง ์๋๋ค. ์ ๋ฐ์ ๋๊ฒ ๋๋ฉด ์ค๋ณต๋ ๋ฌธ์์ด ์กฐํฉ์ด ๋์ฌ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฆฌ๊ณ step
์ ๊ฒฐ์ ํ๋ ๋ฐ๋ณต๋ฌธ์ด ์ข
๋ฃ๋ ๋๋ง๋ค ์์ฑ๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๋น๊ตํ์ฌ ๋ ์งง์ ๊ฒ์ผ๋ก ๊ฐฑ์ ํด์ค๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
s = input()
n = len(s) // 2
result = 1e9
if len(s) == 1:
result = 1
for i in range(1, n+1):
temp = ""
cnt = 1
for j in range(0, len(s), i):
if s[j:j+i] == s[j+i:j+2*i]:
cnt += 1
continue
else:
temp += str(cnt) + s[j:j+i] if cnt >= 2 else s[j:j+i]
cnt = 1
result = min(result, len(temp))
print(result)
์ฒ์์ temp
๋ฅผ ๋ฐฐ์ด๋ก ์ค์ ํ์ฌ ๊ฐ์ append()
ํด์ฃผ์๋ค. ๊ทธ๋ฌ๋๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๊ตฌํ ๋ "".join()
๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผ ํ๋ ์๊ณ ๊ฐ ์๊ฒจ๋ฒ๋ ค์ temp
๋ฅผ ๋น ๋ฌธ์์ด๋ก ์ค์ ํ๋ค.
ํด๋น ์ฝ๋๋ฅผ ํ๋ก๊ทธ๋๋จธ์ค์์ ์คํ์์ผฐ์ ๋, 5๋ฒ ํ
์คํธ์ผ์ด์ค์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค. ์๊ณ ๋ดค๋๋ ์ฒ์ ์
๋ ฅ ๋ฐ์ ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ 1์ผ ๋ ๋ฐ์ํ๋ ์ค๋ฅ์๋ค. ๊ทธ๋์ len(s) == 1
์ผ ๊ฒฝ์ฐ 1์ ์ถ๋ ฅํ ์ ์๋๋ก ์ฝ๋๋ฅผ ์์ ํด์ฃผ์๋ค.
--
๐๐ปโโ๏ธ ๋ ๋๋น, ์ด๊ฒ์ด ์ทจ์ ์ ์ํ ์ฝ๋ฉํ ์คํธ๋ค