6092๋ฒ : [๊ธฐ์ด-๋ฆฌ์คํธ] ์ด์ํ ์ถ์ ๋ฒํธ ๋ถ๋ฅด๊ธฐ1
์ ๋ณด ์ ์๋์ ์์
์ ์์ํ๊ธฐ ์ ์ ์ด์ํ ์ถ์์ ๋ถ๋ฅธ๋ค.
์ ์๋์ ์ถ์๋ถ๋ฅผ ๋ณด๊ณ ๋ฒํธ๋ฅผ ๋ถ๋ฅด๋๋ฐ, ํ์๋ค์ ์ผ๊ตด๊ณผ ์ด๋ฆ์ ๋นจ๋ฆฌ ์ตํ๊ธฐ ์ํด ๋ฒํธ๋ฅผ ๋ฌด์์(๋๋ค)์ผ๋ก ๋ถ๋ฅธ๋ค.
๊ทธ๋ฆฌ๊ณ ์ผ๊ตด๊ณผ ์ด๋ฆ์ด ์ ๊ธฐ์ต๋์ง ์๋ ํ์๋ค์ ๋ฒํธ๋ฅผ ์ฌ๋ฌ ๋ฒ ๋ถ๋ฌ ์ด๋ฆ๊ณผ ์ผ๊ตด์ ๋นจ๋ฆฌ ์ตํ๋ ค๊ณ ํ๋ ๊ฒ์ด๋ค.
์ถ์ ๋ฒํธ๋ฅผ n๋ฒ ๋ฌด์์๋ก ๋ถ๋ ์ ๋, ๊ฐ ๋ฒํธ(1 ~ 23)๊ฐ ๋ถ๋ฆฐ ํ์๋ฅผ ๊ฐ๊ฐ ์ถ๋ ฅํด๋ณด์.
n = int(input())
nums = list(map(int, input().split()))
d = []
for i in range(24):
d.append(0)
for i in range(n):
d[nums[i]] += 1
for i in range(1, 24):
print(d[i], end=" ")
6093๋ฒ : [๊ธฐ์ด-๋ฆฌ์คํธ] ์ด์ํ ์ถ์ ๋ฒํธ ๋ถ๋ฅด๊ธฐ2
์ ๋ณด ์ ์๋์ ์์ ์ ์์ํ๊ธฐ ์ ์ ์ด์ํ ์ถ์์ ๋ถ๋ฅธ๋ค.
ํ์๋ค์ ์ผ๊ตด๊ณผ ์ด๋ฆ์ ๋นจ๋ฆฌ ์ตํ๊ธฐ ์ํด ๋ฒํธ๋ฅผ ๋ฌด์์(๋๋ค)์ผ๋ก ๋ถ๋ฅด๋๋ฐ,
์์ผ์ด๋ ์ ์๋์ด ๋ถ๋ฅธ ๋ฒํธ๋ค์ ๊ธฐ์ตํ๊ณ ์๋ค๊ฐ ๊ฑฐ๊พธ๋ก ๋ถ๋ฌ๋ณด๋ ๊ฒ์ ํด๋ณด๊ณ ์ถ์ด์ก๋ค.
์ถ์ ๋ฒํธ๋ฅผ n๋ฒ ๋ฌด์์๋ก ๋ถ๋ ์ ๋, ๋ถ๋ฅธ ๋ฒํธ๋ฅผ ๊ฑฐ๊พธ๋ก ์ถ๋ ฅํด ๋ณด์.
n = int(input())
nums = list(map(int, input().split()))
# range(์์, ๋, ์ฆ๊ฐ) / ์์ ์๋ ํฌํจ, ๋ ์๋ ํฌํจํ์ง ์์. [์์, ๋)
for i in range(n-1, -1, -1):
print(nums[i], end=" ")
6094๋ฒ : [๊ธฐ์ด-๋ฆฌ์คํธ] ์ด์ํ ์ถ์ ๋ฒํธ ๋ถ๋ฅด๊ธฐ3
์ ๋ณด ์ ์๋์ ์ค๋๋ ์ด์ํ ์ถ์์ ๋ถ๋ฅธ๋ค.
์์ผ์ด๋ ์ค๋๋ ๋ค๋ฅธ ์๊ฐ์ ํด๋ณด์๋ค. ์ถ์ ๋ฒํธ๋ฅผ ๋ค ๋ถ๋ฅด์ง๋ ์์ ๊ฒ ๊ฐ์๋ฐ... ๊ฐ์ฅ ๋น ๋ฅธ ๋ฒํธ๊ฐ ๋ญ์์ง?
์ถ์ ๋ฒํธ๋ฅผ n๋ฒ ๋ฌด์์๋ก ๋ถ๋ ์ ๋, ๊ฐ์ฅ ๋น ๋ฅธ ๋ฒํธ๋ฅผ ์ถ๋ ฅํด ๋ณด์.
๋จ, ์ฒซ ๋ฒ์งธ ๋ฒํธ์ ๋ง์ง๋ง ๋ฒํธ๊ฐ ๋ช ๋ฒ์ธ์ง๋ ์๋ฌด๋ ๋ชจ๋ฅธ๋ค. ์์(-) ๋ฒํธ, 0๋ฒ ๋ฒํธ๋ ์์ ์ ์๋ค.
n = int(input())
nums = list(map(int, input().split()))
print(min(nums))
6095๋ฒ : [๊ธฐ์ด-๋ฆฌ์คํธ] ๋ฐ๋ํ์ ํฐ ๋ ๋๊ธฐ
๊ธฐ์์ฌ ์ํ์ ํ๋ ํ๊ต์์ ์ด๋ค ๊ธ์์ผ(์ ์ ๊ท๊ฐ์ผ)์๋ ๋ชจ๋ ์ง์ผ๋ก ๊ท๊ฐ๋ฅผ ํ๋ค.
์ค๋๋ง์ ์ง์ ๊ฐ ์์ผ์ด๋ ์๋ฒ์ง์ ํจ๊ป ๋๋ ๋งค์ฐ ํฐ ์ค๋ชฉ์ ๋ํด์ ์๊ฐํด ๋ณด๋ค๊ฐ
"๋ฐ๋ํ์ ๋์ ์ฌ๋ฆฐ ๊ฒ์ ํ๋ก๊ทธ๋๋ฐ ํ ์ ์์๊น?"ํ๊ณ ์๊ฐํ์๋ค.
๋ฐ๋ํ(19 * 19)์ n๊ฐ์ ํฐ ๋์ ๋๋๋ค๊ณ ํ ๋, n๊ฐ์ ํฐ ๋์ด ๋์ธ ์์น๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
- ์ ๋ ฅ : ๋ฐ๋ํ์ ์ฌ๋ ค ๋์ ํฐ ๋์ ๊ฐ์(n)๊ฐ ์ฒซ ์ค์ ์ ๋ ฅ๋๋ค. ๋์งธ ์ค ๋ถํฐ n+1 ๋ฒ์งธ ์ค๊น์ง ํฐ ๋์ ๋์ ์ขํ(x, y)๊ฐ n์ค ์ ๋ ฅ๋๋ค.
- ์ถ๋ ฅ : ํฐ ๋์ด ์ฌ๋ ค์ง ๋ฐ๋ํ์ ์ํฉ์ ์ถ๋ ฅํ๋ค. ํฐ ๋์ด ์๋ ์์น๋ 1, ์๋ ๊ณณ์ 0์ผ๋ก ์ถ๋ ฅํ๋ค.
d = [] # ์๋ฌด๊ฒ๋ ์๋ ๋น ๋ฆฌ์คํธ ๋ง๋ค๊ธฐ
for i in range(20):
d.append([]) # ๋ฆฌ์คํธ ์์ ๋ค๋ฅธ ๋ฆฌ์คํธ ์ถ๊ฐํ๊ธฐ
for j in range(20):
d[i].append(0) # ๋ฆฌ์คํธ ์์ ๋ค์ด์๋ ๋ฆฌ์คํธ ์์ 0 ๋ฃ๊ธฐ
# List Comprehensions ๋ฐฉ์์ผ๋ก ๋ชจ๋ 0์ด ์ฑ์์ง 2์ฐจ์ ๋ฆฌ์คํธ ๋ง๋ค๊ธฐ
# d = [[0 for j in range(20)] for i in range(20)]
n = int(input())
for i in range(n):
x, y = map(int, input().split())
d[x][y] = 1 # ์
๋ ฅ๋ x, y ์ขํ์ ํฐ ๋(1) ๋ฃ๊ธฐ
for i in range(1, 20):
for j in range(1, 20):
print(d[i][j], end=" ")
print() # New Line
6096๋ฒ : [๊ธฐ์ด-๋ฆฌ์คํธ] ๋ฐ๋์ ์ญ์ ๋ค์ง๊ธฐ
๋ถ๋ชจ๋์ ๊ธฐ๋ค๋ฆฌ๋ ์์ผ์ด๋ ๊ฒ์ /ํฐ ์ ๋ฐ๋์์ ๋ฐ๋ํ์ ๊ฝ ์ฑ์ ๊น์ ๋๊ณ ๋๋ค๊ฐ...
"์ญ(+)์ ๋ค์ง๊ธฐ๋ฅผ ํด๋ณผ๊น?"ํ๊ณ ์๊ฐํ๋ค.
์ญ์ ๋ค์ง๊ธฐ๋ ๊ทธ ์์น์ ์๋ ๋ชจ๋ ๊ฐ๋ก์ค ๋์ ์์ ๋ฐ๋(1->0, 0->1)๋ก ๋ฐ๊พผ ํ, ๋ค์ ๊ทธ ์์น์ ์๋ ๋ชจ๋ ์ธ๋ก์ค ๋์ ์์ ๋ฐ๋๋ก ๋ฐ๊พธ๋ ๊ฒ์ด๋ค. ์ด๋ค ์์น๋ฅผ ๊ณจ๋ผ ์ง์ ๋ค์ง๊ธฐ๋ฅผ ํ๋ฉด, ๊ทธ ์์น๋ฅผ ์ ์ธํ ๊ฐ๋ก์ค๊ณผ ์ธ๋ก์ค์ ์์ด ๋ชจ๋ ๋ฐ๋๋ก ๋ฐ๋๋ค.
๋ฐ๋ํ(19 * 19)์ ํฐ ๋(1) ๋๋ ๊ฒ์ ๋(0)์ด ๋ชจ๋ ๊ฝ ์ฑ์์ ธ ๋์ฌ์์ ๋,
n๊ฐ์ ์ขํ๋ฅผ ์
๋ ฅ๋ฐ์ ์ญ(+)์ ๋ค์ง๊ธฐํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
baduk = []
for i in range(19):
baduk.append([]) # ๋ฆฌ์คํธ์ ๋ฆฌ์คํธ ๋ฃ๊ธฐ
for j in range(19):
baduk[i].append(0) # ๋ฆฌ์คํธ ์ ๋ฆฌ์คํธ์ 0 ๋ฃ๊ธฐ
for i in range(19):
baduk[i] = list(map(int, input().split()))
n = int(input())
for i in range(n):
x, y = map(int, input().split())
for j in range(19):
# ์
๋ ฅํ x ์ขํ์ ์ผ์นํ๋ ๋ชจ๋ ๊ณณ์ ๋ค์ง๊ธฐ
if baduk[x-1][j] == 0:
baduk[x-1][j] = 1
else:
baduk[x-1][j] = 0
# ์
๋ ฅํ y ์ขํ์ ์ผ์นํ๋ ๋ชจ๋ ๊ณณ์ ๋ค์ง๊ธฐ
if baduk[j][y-1] == 0:
baduk[j][y-1] = 1
else:
baduk[j][y-1] = 0
for i in range(19):
for j in range(19):
print(baduk[i][j], end=" ")
print()
6097๋ฒ : [๊ธฐ์ด-๋ฆฌ์คํธ] ์คํ๊ณผ์ ๋ฝ๊ธฐ
๋ถ๋ชจ๋๊ณผ ํจ๊ป ๋๋ฌ๊ฐ ์์ผ์ด๋ ์คํ๊ณผ์(์คํ์ ๋
น์ฌ ๋ฌผ๊ณ ๊ธฐ ๋ฑ์ ๋ชจ์์ ๋ง๋ ๊ฒ) ๋ฝ๊ธฐ๋ฅผ ๋ณด๊ฒ ๋์๋ค.
๊ธธ์ด๊ฐ ๋ค๋ฅธ ๋ช ๊ฐ์ ๋ง๋๋ฅผ ๋ฐ๋ํ๊ณผ ๊ฐ์ ๊ฒฉ์ํ์ ๋๋๋ฐ, ๋ง๋์ ์๋ ์คํ๊ณผ์ ์ด๋ฆ ์๋์ ์๋ ๋ฒํธ๋ฅผ ๋ฝ์ผ๋ฉด ์คํ๊ณผ์๋ฅผ ๊ฐ์ ธ๊ฐ๋ ๊ฒ์์ด์๋ค. (์์ด, ๋ถ์ด, ์ฉ ๋ฑ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์ ํ์๋ค.)
๊ฒฉ์ํ์ ์ธ๋ก(h), ๊ฐ๋ก(w), ๋ง๋์ ๊ฐ์(n), ๊ฐ ๋ง๋์ ๊ธธ์ด(l),
๋ง๋๋ฅผ ๋๋ ๋ฐฉํฅ(d:๊ฐ๋ก๋ 0, ์ธ๋ก๋ 1)๊ณผ ๋ง๋๋ฅผ ๋๋ ๋ง๋์ ๊ฐ์ฅ ์ผ์ชฝ ๋๋ ์์ชฝ์ ์์น(x, y)๊ฐ ์ฃผ์ด์ง ๋,
๊ฒฉ์ํ์ ์ฑ์ด ๋ง๋์ ๋ชจ์์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
# ๊ฒฉ์ํ์ ์ธ๋ก h, ๊ฐ๋ก w
h, w = map(int, input().split())
# ๋์ ์ ์๋ ๋ง๋์ ๊ฐ์ n
n = int(input())
arr = []
for i in range(h):
arr.append([])
for j in range(w):
arr[i].append(0)
for i in range(n):
# ๊ฐ ๋ง๋์ ๊ธธ์ด l, ๋ฐฉํฅ d(๊ฐ๋ก 0, ์ธ๋ก 1), ์ขํ x/y(๊ฐ์ฅ ์ผ์ชฝ ์)
l, d, x, y = map(int, input().split())
for j in range(0, l):
if d == 0: # ๊ฐ๋ก
arr[x-1][y-1+j] = 1
else:
arr[x-1+j][y-1] = 1
for i in range(h):
for j in range(w):
print(arr[i][j], end=" ")
print()
6098๋ฒ : [๊ธฐ์ด-๋ฆฌ์คํธ] ์ฑ์คํ ๊ฐ๋ฏธ
์์ผ์ด๋ ์๋ช
๊ณผํ์ ๊ด์ฌ์ด ์๊ฒจ ์๊ฐ๋ฏธ๋ฅผ ์ฐ๊ตฌํ๊ณ ์์๋ค.
์๊ฐ๋ฏธ๋ฅผ ์ ์ฌํ ์ดํด๋ณด๋ ์ค ํน๋ณํ ์ฑ์คํด ๋ณด์ด๋ ๊ฐ๋ฏธ๊ฐ ์์๋๋ฐ, ๊ทธ ๊ฐ๋ฏธ๋ ๊ฐ๋ฏธ๊ตด์์ ๋์ ๋จน์ด๊น์ง ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ๋ก ์ด๋ํ๋ ๊ฒ์ด์๋ค. ๊ฐ๋ฏธ๋ ์ค๋ฅธ์ชฝ์ผ๋ก ์์ง์ด๋ค๊ฐ ๋ฒฝ์ ๋ง๋๋ฉด ์๋์ชฝ์ผ๋ก ์์ง์ฌ ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ๋ก ์์ง์๋ค. (์ค๋ฅธ์ชฝ์ ๊ธธ์ด ๋ํ๋๋ฉด ๋ค์ ์ค๋ฅธ์ชฝ์ผ๋ก ์์ง์ธ๋ค.)
์ด์ ํธ๊ธฐ์ฌ์ด ์๊ธด ์์ผ์ด๋ ๊ทธ ๊ฐ๋ฏธ๋ฅผ ๋ฏธ๋ก ์์์ ๋ฃ๊ณ ์ดํด๋ณด๊ธฐ ์์ํ์๋ค.
๋ฏธ๋ก ์์์ ๋ฃ์ ๊ฐ๋ฏธ๋ ๋จน์ด๋ฅผ ์ฐพ์๊ฑฐ๋, ๋ ์ด์ ์์ง์ผ ์ ์์ ๋๊น์ง ์ค๋ฅธ์ชฝ ๋๋ ์๋์ชฝ์ผ๋ก๋ง ์์ง์๋ค.
๋ฏธ๋ก ์์์ ๊ตฌ์กฐ๊ฐ 0(๊ฐ ์ ์๋ ๊ณณ), 1(๋ฒฝ ๋๋ ์ฅ์ ๋ฌผ)๋ก ์ฃผ์ด์ง๊ณ , ๋จน์ด๊ฐ 2๋ก ์ฃผ์ด์ง ๋, ์ฑ์คํ ๊ฐ๋ฏธ์ ์ด๋ ๊ฒฝ๋ก๋ฅผ ์์ํด๋ณด์.
๋จ, ๋งจ ์๋์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ๋์ฐฉํ ๊ฒฝ์ฐ, ๋ ์ด์ ์์ง์ผ ์ ์๋ ๊ฒฝ์ฐ, ๋จน์ด๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ์๋ ๋์ด์ ์ด๋ํ์ง ์๊ณ ๊ทธ ๊ณณ์ ๋จธ๋ฌด๋ฅธ๋ค๊ณ ๊ฐ์ ํ๋ค.
๋ฏธ๋ก ์์์ ํ
๋๋ฆฌ๋ ๋ชจ๋ ๋ฒฝ์ผ๋ก ๋์ด ์์ผ๋ฉฐ, ๊ฐ๋ฏธ์ง์ ๋ฐ๋์ (2, 2)์ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฏธ๋ (2, 2)์์ ์ถ๋ฐํ๋ค.
- ์ ๋ ฅ : 10*10 ํฌ๊ธฐ์ ๋ฏธ๋ก ์์์ ๊ตฌ์กฐ์ ๋จน์ด์ ์์น๊ฐ ์ ๋ ฅ๋๋ค.
- ์ถ๋ ฅ : ์ฑ์คํ ๊ฐ๋ฏธ๊ฐ ์ด๋ํ ๊ฒฝ๋ก๋ฅผ 9๋ก ํ์ํด ์ถ๋ ฅํ๋ค.
arr = []
for i in range(10):
arr.append(input().split())
x, y = 1, 1 # ์์ ์ง์
while arr[x][y] != "2": # ๋จน์ด๋ฅผ ์ฐพ์ ๋๊น์ง ๋ฐ๋ณต
arr[x][y] = "9" # ์ด๋ ๊ฒฝ๋ก๋ 9๋ก ํ์
if arr[x+1][y] == "1" and arr[x][y+1] == "1": # ๋์ด์ ์์ง์ผ ์ ์๋ ๊ฒฝ์ฐ
break
elif arr[x][y+1] == "1": # ์ค๋ฅธ์ชฝ์ด ๋งํ ๊ฒฝ์ฐ
x += 1 # x ์ขํ ํ ์นธ ์ด๋ (์๋๋ก)
else: # ์๋์ชฝ์ด ๋งํ ๊ฒฝ์ฐ
y += 1 # y ์ขํ ํ ์นธ ์ด๋ (์ค๋ฅธ์ชฝ์ผ๋ก)
arr[x][y] = "9" # ๋ง์ง๋ง ์ขํ(๋จน์ด๊ฐ ์๋ ๊ณณ) ์ฒ๋ฆฌ
for i in range(10):
for j in range(10):
print(arr[i][j], end=" ")
print()