์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- ์ด๋ ธํ ์ด์
- fontstyle
- swagger
- ์ฑ์ฉํ์ ํ
- tcp
- Kotlin
- di
- 2024-08-21
- OOP
- datepicker
- http method
- menutab
- ๊ธฐ์ด100์
- AndroidStudio
- ์ฝ๋์
- Dialog
- IOC
- uri
- 2024-08-20
- url
- Android Studio
- ํ๋ IT&E
- OpenAPI
- Factory Method Pattern
- ๊ฐ์ฒด์งํฅํ๋ก๊ทธ๋๋ฐ
- Python
- udp
- reflection
- FACTORY
- URN
dingdong coding
[ 6092 - 6098 ] ๋ฆฌ์คํธ ๋ณธ๋ฌธ
# ๊ฐ๋ ๋ณต๊ธฐ์ฉ
[ 6092 ] ์ด์ํ ์ถ์ ๋ฒํธ ๋ถ๋ฅด๊ธฐ1
๋ฌธ์ ์ ๋ณด ์ ์๋์ ์์
์ ์์ํ๊ธฐ ์ ์ ์ด์ํ ์ถ์์ ๋ถ๋ฅธ๋ค. ์ ์๋์ ์ถ์๋ถ๋ฅผ ๋ณด๊ณ ๋ฒํธ๋ฅผ ๋ถ๋ฅด๋๋ฐ, ํ์๋ค์ ์ผ๊ตด๊ณผ ์ด๋ฆ์ ๋นจ๋ฆฌ ์ตํ๊ธฐ ์ํด ๋ฒํธ๋ฅผ ๋ฌด์์(๋๋ค)์ผ๋ก ๋ถ๋ฅธ๋ค. ๊ทธ๋ฆฌ๊ณ ์ผ๊ตด๊ณผ ์ด๋ฆ์ด ์ ๊ธฐ์ต๋์ง ์๋ ํ์๋ค์ ๋ฒํธ๋ฅผ ์ฌ๋ฌ ๋ฒ ๋ถ๋ฌ ์ด๋ฆ๊ณผ ์ผ๊ตด์ ๋นจ๋ฆฌ ์ตํ๋ ค๊ณ ํ๋ ๊ฒ์ด๋ค.
์ถ์ ๋ฒํธ๋ฅผ n๋ฒ ๋ฌด์์๋ก ๋ถ๋ ์ ๋, ๊ฐ ๋ฒํธ(1 ~ 23)๊ฐ ๋ถ๋ฆฐ ํ์๋ฅผ ๊ฐ๊ฐ ์ถ๋ ฅํด๋ณด์.
์
๋ ฅ ์ฒซ ๋ฒ์งธ ์ค์ ์ถ์ ๋ฒํธ๋ฅผ ๋ถ๋ฅธ ํ์์ธ ์ ์ n์ด ์
๋ ฅ๋๋ค. (1 ~ 10000) ๋ ๋ฒ์งธ ์ค์๋ ๋ฌด์์๋ก ๋ถ๋ฅธ n๊ฐ์ ๋ฒํธ(1 ~ 23)๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์์๋๋ก ์
๋ ฅ๋๋ค.
์ถ๋ ฅ 1๋ฒ๋ถํฐ ๋ฒํธ๊ฐ ๋ถ๋ฆฐ ํ์๋ฅผ ์์๋๋ก ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ํ ์ค๋ก ์ถ๋ ฅํ๋ค.
n = int(input())
a = input().split() # a[0] ~ a[n-1] ๊น์ง ๊ฐ ์ ์ฅ
d = []
for i in range(24): # d[0] ~ d[23] 0์ผ๋ก ์ด๊ธฐํ
d.append(0)
for i in range(n): # 0 ~ n-1 ๊น์ง a[0] ~ a[n-1]
d[int(a[i])] += 1 # int(a[i]) = ํ์ ์ถ์๋ฒํธ count +1
for i in range(1, 24): # 1 ~ 23
print(d[i], end=' ')
๋ฆฌ์คํธ
d = [ ] #์ด๋ค ๋ฐ์ดํฐ ๋ชฉ๋ก(list) ์ ์์๋๋ก ์ ์ฅํ๊ธฐ ์ํด ์๋ฌด๊ฒ๋ ์๋ ๋ฆฌ์คํธ ๋ณ์ ๋ง๋ค๊ธฐ
d.append(๊ฐ) #d ๋ฆฌ์คํธ์ ๋ง์ง๋ง์ ์ํ๋ ๊ฐ์ ์ถ๊ฐ(append)ํด ๋ฃ์
d[a[i]] += 1 #2์ค ๋ฆฌ์คํธ ์ฐธ์กฐ : ๋ง์ฝ a[i]์ ๊ฐ์ด 1์ด์๋ค๋ฉด? d[1] += 1 ์ด ์คํ๋๋ ๊ฒ์ด๋ค. 1๋ฒ ์นด์ดํธ 1๊ฐ ์ฆ๊ฐ
์ด๋ค ๊ฐ์ ๊ธฐ๋กํ๋ค๊ฐ ๋ค์ ์ฌ์ฉํ ํ์๊ฐ ์์ ๋, ํ์ํ ๋ณ์(variable)๋ฅผ ๋ง๋ค์ด ์ฌ์ฉํ๋ ๊ฒ์ฒ๋ผ, ์ฌ๋ฌ ๊ฐ์ ๊ฐ์ ํ๋๋ก ๋ฌถ์ด ๋ชฉ๋ก์ผ๋ก ๊ธฐ๋กํ๋ค๊ฐ ๋ค์ ์ฌ์ฉํ ํ์๊ฐ ์์ ๋, ๋ฆฌ์คํธ(list)๋ฅผ ๋ง๋ค์ด ์ฌ์ฉํ ์ ์๋ค. ๋ฆฌ์คํธ๋ ๋ณ์๋ค์ ๋ชจ์ ๋์ ๋ณ์๋ผ๊ณ ์๊ฐํ ์๋ ์๊ณ , ์ฐธ์กฐ๋ฒํธ๋ฅผ ์ด์ฉํด ๊ฐ๋จํ๊ณ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ ์ ์๋ค.
[ 6093 ] ์ด์ํ ์ถ์ ๋ฒํธ ๋ถ๋ฅด๊ธฐ2
๋ฌธ์ ์ ๋ณด ์ ์๋์ ์์
์ ์์ํ๊ธฐ ์ ์ ์ด์ํ ์ถ์์ ๋ถ๋ฅธ๋ค. ํ์๋ค์ ์ผ๊ตด๊ณผ ์ด๋ฆ์ ๋นจ๋ฆฌ ์ตํ๊ธฐ ์ํด ๋ฒํธ๋ฅผ ๋ฌด์์(๋๋ค)์ผ๋ก ๋ถ๋ฅด๋๋ฐ, ์์ผ์ด๋ ์ ์๋์ด ๋ถ๋ฅธ ๋ฒํธ๋ค์ ๊ธฐ์ตํ๊ณ ์๋ค๊ฐ ๊ฑฐ๊พธ๋ก ๋ถ๋ฌ๋ณด๋ ๊ฒ์ ํด๋ณด๊ณ ์ถ์ด์ก๋ค.
์ถ์ ๋ฒํธ๋ฅผ n๋ฒ ๋ฌด์์๋ก ๋ถ๋ ์ ๋, ๋ถ๋ฅธ ๋ฒํธ๋ฅผ ๊ฑฐ๊พธ๋ก ์ถ๋ ฅํด ๋ณด์.
์
๋ ฅ ๋ฒํธ๋ฅผ ๋ถ๋ฅธ ํ์(n, 1 ~ 10000)๊ฐ ์ฒซ ์ค์ ์
๋ ฅ๋๋ค. n๊ฐ์ ๋๋ค ๋ฒํธ(k, 1 ~ 23)๊ฐ ๋ ๋ฒ์งธ ์ค์ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์์๋๋ก ์
๋ ฅ๋๋ค.
์ถ๋ ฅ ์ถ์์ ๋ถ๋ฅธ ๋ฒํธ ์์๋ฅผ ๋ฐ๊พธ์ด ๊ณต๋ฐฑ์ ๋๊ณ ์ถ๋ ฅํ๋ค.
n = int(input())
a = input().split() # a[0] ~ a[n-1] ๊น์ง ๊ฐ ์ ์ฅ
for i in range(n):
a[i] = int(a[i])
for i in range(n-1, -1, -1):
print(a[i], end=' ')
range(์์, ๋, ์ฆ๊ฐ) #์์ ์๋ ํฌํจ, ๋ ์๋ ํฌํจํ์ง ์์. [์์, ๋)
range(n-1, -1, -1) #n-1, n-2, ..., 3, 2, 1, 0
[ 6094 ] ์ด์ํ ์ถ์ ๋ฒํธ ๋ถ๋ฅด๊ธฐ3
๋ฌธ์ ์ ๋ณด ์ ์๋์ ์ค๋๋ ์ด์ํ ์ถ์์ ๋ถ๋ฅธ๋ค. ์์ผ์ด๋ ์ค๋๋ ๋ค๋ฅธ ์๊ฐ์ ํด๋ณด์๋ค. ์ถ์ ๋ฒํธ๋ฅผ ๋ค ๋ถ๋ฅด์ง๋ ์์ ๊ฒ ๊ฐ์๋ฐ... ๊ฐ์ฅ ๋น ๋ฅธ ๋ฒํธ๊ฐ ๋ญ์์ง? ์ถ์ ๋ฒํธ๋ฅผ n๋ฒ ๋ฌด์์๋ก ๋ถ๋ ์ ๋, ๊ฐ์ฅ ๋น ๋ฅธ ๋ฒํธ๋ฅผ ์ถ๋ ฅํด ๋ณด์.
๋จ, ์ฒซ ๋ฒ์งธ ๋ฒํธ์ ๋ง์ง๋ง ๋ฒํธ๊ฐ ๋ช ๋ฒ์ธ์ง๋ ์๋ฌด๋ ๋ชจ๋ฅธ๋ค. ์์(-) ๋ฒํธ, 0๋ฒ ๋ฒํธ๋ ์์ ์ ์๋ค.
์
๋ ฅ ๋ฒํธ๋ฅผ ๋ถ๋ฅธ ํ์(n, 1 ~ 10000)๊ฐ ์ฒซ ์ค์ ์
๋ ฅ๋๋ค. n๊ฐ์ ๋๋ค ๋ฒํธ(k)๊ฐ ๋ ๋ฒ์งธ ์ค์ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์์๋๋ก ์
๋ ฅ๋๋ค.
์ถ๋ ฅ ์ถ์์ ๋ถ๋ฅธ ๋ฒํธ ์ค์ ๊ฐ์ฅ ๋น ๋ฅธ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค.
n = int(input())
a = list(map(int, input().split()))
result = a[0]
for i in range(n): # 0 ~ n-1
if a[i] < result:
result = a[i]
print(result)
[ 6095 ] ๋ฐ๋ํ์ ํฐ ๋ ๋๊ธฐ
๋ฌธ์ ๊ธฐ์์ฌ ์ํ์ ํ๋ ํ๊ต์์ ์ด๋ค ๊ธ์์ผ(์ ์ ๊ท๊ฐ์ผ)์๋ ๋ชจ๋ ์ง์ผ๋ก ๊ท๊ฐ๋ฅผ ํ๋ค. ์ค๋๋ง์ ์ง์ ๊ฐ ์์ผ์ด๋ ์๋ฒ์ง์ ํจ๊ป ๋๋ ๋งค์ฐ ํฐ ์ค๋ชฉ์ ๋ํด์ ์๊ฐํด ๋ณด๋ค๊ฐ "๋ฐ๋ํ์ ๋์ ์ฌ๋ฆฐ ๊ฒ์ ํ๋ก๊ทธ๋๋ฐ ํ ์ ์์๊น?"ํ๊ณ ์๊ฐํ์๋ค. ๋ฐ๋ํ(19 * 19)์ n๊ฐ์ ํฐ ๋์ ๋๋๋ค๊ณ ํ ๋, n๊ฐ์ ํฐ ๋์ด ๋์ธ ์์น๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์
๋ ฅ ๋ฐ๋ํ์ ์ฌ๋ ค ๋์ ํฐ ๋์ ๊ฐ์(n)๊ฐ ์ฒซ ์ค์ ์
๋ ฅ๋๋ค. ๋์งธ ์ค ๋ถํฐ n+1 ๋ฒ์งธ ์ค๊น์ง ํ ๋์ ๋์ ์ขํ(x, y)๊ฐ n์ค ์
๋ ฅ๋๋ค. n์ 10์ดํ์ ์์ฐ์์ด๊ณ x, y ์ขํ๋ 1 ~ 19 ๊น์ง์ด๋ฉฐ, ๋๊ฐ์ ์ขํ๋ ์
๋ ฅ๋์ง ์๋๋ค.
์ถ๋ ฅ ํฐ ๋์ด ์ฌ๋ ค์ง ๋ฐ๋ํ์ ์ํฉ์ ์ถ๋ ฅํ๋ค. ํฐ ๋์ด ์๋ ์์น๋ 1, ์๋ ๊ณณ์ 0์ผ๋ก ์ถ๋ ฅํ๋ค.
# ํ์ด 1
n = int(input())
d = [[0 for j in range(20)] for i in range(20)]
for i in range(n):
x, y = map(int, input().split())
d[x][y] = 1
for i in range(1, 20):
for j in range(1, 20):
print(d[i][j], end=' ')
print()
# ํ์ด2
d = []
for i in range(20):
d.append([])
for j in range(20):
d[i].append(0)
n = int(input())
for i in range(n):
x, y = input().split()
d[int(x)][int(y)] = 1
for i in range(1,20):
for j in range(1,20):
print(d[i][j], end=' ')
print()
๊ฐ๋ก๋ฒํธ, ์ธ๋ก๋ฒํธ๋ฅผ ์ฌ์ฉํด 2์ฐจ์ ํํ์ ๋ฐ์ดํฐ์ฒ๋ผ ์ฝ๊ฒ ๊ธฐ๋กํ๊ณ ์ฌ์ฉํ ์ ์๋ค.
๋ฆฌ์คํธ์ด๋ฆ[๋ฒํธ][๋ฒํธ] ํ์์ผ๋ก ์ ์ฅ๋์ด์๋ ๊ฐ์ ์ฝ๊ณ ์ธ ์ ์๊ณ , ๋ ํ์ฅํ n์ฐจ์์ ๋ฆฌ์คํธ๋ ๋ง๋ค ์ ์๋ค.
List Comprehensions
ex) d = [[0 for j in range(20)] for i in range(20)]
[ 6096 ] ๋ฐ๋์ ์ญ์ ๋ค์ง๊ธฐ
๋ฌธ์ ๋ถ๋ชจ๋์ ๊ธฐ๋ค๋ฆฌ๋ ์์ผ์ด๋ ๊ฒ์ /ํฐ ์ ๋ฐ๋์์ ๋ฐ๋ํ์ ๊ฝ ์ฑ์ ๊น์ ๋๊ณ ๋๋ค๊ฐ... "์ญ(+)์ ๋ค์ง๊ธฐ๋ฅผ ํด๋ณผ๊น?"ํ๊ณ ์๊ฐํ๋ค. ์ญ์ ๋ค์ง๊ธฐ๋ ๊ทธ ์์น์ ์๋ ๋ชจ๋ ๊ฐ๋ก์ค ๋์ ์์ ๋ฐ๋(1->0, 0->1)๋ก ๋ฐ๊พผ ํ, ๋ค์ ๊ทธ ์์น์ ์๋ ๋ชจ๋ ์ธ๋ก์ค ๋์ ์์ ๋ฐ๋๋ก ๋ฐ๊พธ๋ ๊ฒ์ด๋ค. ์ด๋ค ์์น๋ฅผ ๊ณจ๋ผ ์ง์ ๋ค์ง๊ธฐ๋ฅผ ํ๋ฉด, ๊ทธ ์์น๋ฅผ ์ ์ธํ ๊ฐ๋ก์ค๊ณผ ์ธ๋ก์ค์ ์์ด ๋ชจ๋ ๋ฐ๋๋ก ๋ฐ๋๋ค. ๋ฐ๋ํ(19 * 19)์ ํฐ ๋(1) ๋๋ ๊ฒ์ ๋(0)์ด ๋ชจ๋ ๊ฝ ์ฑ์์ ธ ๋์ฌ์์ ๋,
n๊ฐ์ ์ขํ๋ฅผ ์
๋ ฅ๋ฐ์ ์ญ(+)์ ๋ค์ง๊ธฐํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์
๋ ฅ ๋ฐ๋์์ด ๊น๋ ค ์๋ ์ํฉ์ด 19 * 19 ํฌ๊ธฐ์ ์ ์๊ฐ์ผ๋ก ์
๋ ฅ๋๋ค. ์ญ์ ๋ค์ง๊ธฐ ํ์(n)๊ฐ ์
๋ ฅ๋๋ค.
์ญ์ ๋ค์ง๊ธฐ ์ขํ๊ฐ ํ์(n) ๋งํผ ์
๋ ฅ๋๋ค. ๋จ, n์ 10์ดํ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ ์ญ์ ๋ค์ง๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
d = [[0 for j in range(20)] for i in range(20)]
for i in range(19):
a = input().split()
for j in range(19):
d[i+1][j+1] = int(a[j])
n = int(input())
for i in range(n):
x, y = map(int, input().split())
for j in range(1, 20):
if d[j][y] == 0:
d[j][y] = 1
else:
d[j][y] = 0
if d[x][j] == 0:
d[x][j] = 1
else:
d[x][j] = 0
for i in range(1, 20):
for j in range(1, 20):
print(d[i][j], end=' ')
print()
[ 6097 ] ์คํ๊ณผ์ ๋ฝ๊ธฐ
๋ฌธ์ ๋ถ๋ชจ๋๊ณผ ํจ๊ป ๋๋ฌ๊ฐ ์์ผ์ด๋ ์คํ๊ณผ์(์คํ์ ๋ น์ฌ ๋ฌผ๊ณ ๊ธฐ ๋ฑ์ ๋ชจ์์ ๋ง๋ ๊ฒ) ๋ฝ๊ธฐ๋ฅผ ๋ณด๊ฒ ๋์๋ค. ๊ธธ์ด๊ฐ ๋ค๋ฅธ ๋ช ๊ฐ์ ๋ง๋๋ฅผ ๋ฐ๋ํ๊ณผ ๊ฐ์ ๊ฒฉ์ํ์ ๋๋๋ฐ, ๋ง๋์ ์๋ ์คํ๊ณผ์ ์ด๋ฆ ์๋์ ์๋ ๋ฒํธ๋ฅผ ๋ฝ์ผ๋ฉด ์คํ๊ณผ์๋ฅผ ๊ฐ์ ธ๊ฐ๋ ๊ฒ์์ด์๋ค. (์์ด, ๋ถ์ด, ์ฉ ๋ฑ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์ ํ์๋ค.)
๊ฒฉ์ํ์ ์ธ๋ก(h), ๊ฐ๋ก(w), ๋ง๋์ ๊ฐ์(n), ๊ฐ ๋ง๋์ ๊ธธ์ด(l), ๋ง๋๋ฅผ ๋๋ ๋ฐฉํฅ(d:๊ฐ๋ก๋ 0, ์ธ๋ก๋ 1)๊ณผ ๋ง๋๋ฅผ ๋๋ ๋ง๋์ ๊ฐ์ฅ ์ผ์ชฝ ๋๋ ์์ชฝ์ ์์น(x, y)๊ฐ ์ฃผ์ด์ง ๋, ๊ฒฉ์ํ์ ์ฑ์ด ๋ง๋์ ๋ชจ์์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
์
๋ ฅ ์ฒซ ์ค์ ๊ฒฉ์ํ์ ์ธ๋ก(h), ๊ฐ๋ก(w) ๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๊ณ , ๋ ๋ฒ์งธ ์ค์ ๋์ ์ ์๋ ๋ง๋์ ๊ฐ์(n)
์ธ ๋ฒ์งธ ์ค๋ถํฐ ๊ฐ ๋ง๋์ ๊ธธ์ด(l), ๋ฐฉํฅ(d), ์ขํ(x, y)๊ฐ ์
๋ ฅ๋๋ค.
1 <= w, h <= 100
1 <= n <= 10
d = 0 or 1
1 <= x <= 100-h
1 <= y <= 100-w
์ถ๋ ฅ ๋ชจ๋ ๋ง๋๋ฅผ ๋์ ๊ฒฉ์ํ์ ์ํ๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง๋์ ์ํด ๊ฐ๋ ค์ง ๊ฒฝ์ฐ 1, ์๋ ๊ฒฝ์ฐ 0์ผ๋ก ์ถ๋ ฅํ๋ค. ๋จ, ๊ฐ ์ซ์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ถ๋ ฅํ๋ค.
# ํ์ด 1
h, w = map(int, input().split())
n = int(input())
a = [[0 for j in range(w)] for i in range(h)]
for i in range(n):
l, d, x, y = map(int, input().split())
for j in range(l):
if d == 0:
a[x-1][y-1] = 1
y += 1
else:
a[x-1][y-1] = 1
x += 1
for i in range(h):
for j in range(w):
print(a[i][j], end=' ')
print()
# ํ์ด2
h, w = map(int, input().split())
n = int(input())
board = [[0] * w for _ in range(h)]
for i in range(n):
l, d, x, y = map(int, input().split())
if (d == 0):
for j in range(l):
board[x - 1][y - 1 + j] = 1
else:
for j in range(l):
board[x - 1 + j][y - 1] = 1
for i in range(h):
for j in range(w):
print(board[i][j], end=' ')
print()
[ 6098 ] ์ฑ์คํ ๊ฐ๋ฏธ
๋ฌธ์ ์์ผ์ด๋ ์๋ช
๊ณผํ์ ๊ด์ฌ์ด ์๊ฒจ ์๊ฐ๋ฏธ๋ฅผ ์ฐ๊ตฌํ๊ณ ์์๋ค. ์๊ฐ๋ฏธ๋ฅผ ์ ์ฌํ ์ดํด๋ณด๋ ์ค ํน๋ณํ ์ฑ์คํด ๋ณด์ด๋ ๊ฐ๋ฏธ๊ฐ ์์๋๋ฐ, ๊ทธ ๊ฐ๋ฏธ๋ ๊ฐ๋ฏธ๊ตด์์ ๋์ ๋จน์ด๊น์ง ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ๋ก ์ด๋ํ๋ ๊ฒ์ด์๋ค. ๊ฐ๋ฏธ๋ ์ค๋ฅธ์ชฝ์ผ๋ก ์์ง์ด๋ค๊ฐ ๋ฒฝ์ ๋ง๋๋ฉด ์๋์ชฝ์ผ๋ก ์์ง์ฌ ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ๋ก ์์ง์๋ค. (์ค๋ฅธ์ชฝ์ ๊ธธ์ด ๋ํ๋๋ฉด ๋ค์ ์ค๋ฅธ์ชฝ์ผ๋ก ์์ง์ธ๋ค.)
์ด์ ํธ๊ธฐ์ฌ์ด ์๊ธด ์์ผ์ด๋ ๊ทธ ๊ฐ๋ฏธ๋ฅผ ๋ฏธ๋ก ์์์ ๋ฃ๊ณ ์ดํด๋ณด๊ธฐ ์์ํ์๋ค. ๋ฏธ๋ก ์์์ ๋ฃ์ ๊ฐ๋ฏธ๋ ๋จน์ด๋ฅผ ์ฐพ์๊ฑฐ๋, ๋ ์ด์ ์์ง์ผ ์ ์์ ๋๊น์ง ์ค๋ฅธ์ชฝ ๋๋ ์๋์ชฝ์ผ๋ก๋ง ์์ง์๋ค.
๋ฏธ๋ก ์์์ ๊ตฌ์กฐ๊ฐ 0(๊ฐ ์ ์๋ ๊ณณ), 1(๋ฒฝ ๋๋ ์ฅ์ ๋ฌผ)๋ก ์ฃผ์ด์ง๊ณ , ๋จน์ด๊ฐ 2๋ก ์ฃผ์ด์ง ๋, ์ฑ์คํ ๊ฐ๋ฏธ์ ์ด๋ ๊ฒฝ๋ก๋ฅผ ์์ํด๋ณด์.
๋จ, ๋งจ ์๋์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ๋์ฐฉํ ๊ฒฝ์ฐ, ๋ ์ด์ ์์ง์ผ ์ ์๋ ๊ฒฝ์ฐ, ๋จน์ด๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ์๋
๋์ด์ ์ด๋ํ์ง ์๊ณ ๊ทธ ๊ณณ์ ๋จธ๋ฌด๋ฅธ๋ค๊ณ ๊ฐ์ ํ๋ค.
๋ฏธ๋ก ์์์ ํ
๋๋ฆฌ๋ ๋ชจ๋ ๋ฒฝ์ผ๋ก ๋์ด ์์ผ๋ฉฐ, ๊ฐ๋ฏธ์ง์ ๋ฐ๋์ (2, 2)์ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฏธ๋ (2, 2)์์ ์ถ๋ฐํ๋ค.
์
๋ ฅ 10*10 ํฌ๊ธฐ์ ๋ฏธ๋ก ์์์ ๊ตฌ์กฐ์ ๋จน์ด์ ์์น๊ฐ ์
๋ ฅ๋๋ค.
์ถ๋ ฅ ์ฑ์คํ ๊ฐ๋ฏธ๊ฐ ์ด๋ํ ๊ฒฝ๋ก๋ฅผ 9๋ก ํ์ํด ์ถ๋ ฅํ๋ค.
d = [[0 for j in range(10)] for i in range(10)]
for i in range(10):
a = input().split()
for j in range(10):
d[i][j] = int(a[j])
x, y = 1, 1
while True:
if (d[x][y] == 0):
d[x][y] = 9
elif (d[x][y] == 2):
d[x][y] = 9
break
if ((d[x][y + 1] == 1 and d[x + 1][y] == 1)):
break
if (d[x][y + 1] != 1):
y = y + 1
elif (d[x + 1][y] != 1):
x = x + 1
for i in range(10):
for j in range(10):
print(d[i][j], end=' ')
print()
'๐ตCoding Test > CodeUp' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ์ฝ๋์ ] Greedy (0) | 2022.02.13 |
---|---|
[ 6077 - 6091 ] ์ข ํฉ (0) | 2022.01.18 |
[ 6065 - 6076 ] ์ ํ์คํ๊ตฌ์กฐ, ๋ฐ๋ณต์คํ๊ตฌ์กฐ (0) | 2022.01.18 |
[ 6048 - 6064 ] ๋น๊ต์ฐ์ฐ, ๋ ผ๋ฆฌ์ฐ์ฐ, ๋นํธ๋จ์๋ ผ๋ฆฌ์ฐ์ฐ, 3ํญ์ฐ์ฐ (0) | 2022.01.17 |
[ 6032 - 6041, 6043 - 6047 ] ์ฐ์ ์ฐ์ฐ, ๋นํธ์ํํธ์ฐ์ฐ (0) | 2022.01.14 |