๊ทธ๋ฆฌ๋”” & ๊ตฌํ˜„ # 2

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))

 

๋ฐ˜์‘ํ˜•