https://school.programmers.co.kr/learn/courses/30/lessons/181916
๋ฌธ์
๋ฌธ์ ์ค๋ช
1๋ถํฐ 6๊น์ง ์ซ์๊ฐ ์ ํ ์ฃผ์ฌ์๊ฐ ๋ค ๊ฐ ์์ต๋๋ค. ๋ค ์ฃผ์ฌ์๋ฅผ ๊ตด๋ ธ์ ๋ ๋์จ ์ซ์์ ๋ฐ๋ผ ๋ค์๊ณผ ๊ฐ์ ์ ์๋ฅผ ์ป์ต๋๋ค.
๋ค ์ฃผ์ฌ์์์ ๋์จ ์ซ์๊ฐ ๋ชจ๋ p๋ก ๊ฐ๋ค๋ฉด 1111 × p์ ์ ์ป์ต๋๋ค.
์ธ ์ฃผ์ฌ์์์ ๋์จ ์ซ์๊ฐ p๋ก ๊ฐ๊ณ ๋๋จธ์ง ๋ค๋ฅธ ์ฃผ์ฌ์์์ ๋์จ ์ซ์๊ฐ q(p ≠ q)๋ผ๋ฉด (10 × p + q)2 ์ ์ ์ป์ต๋๋ค.
์ฃผ์ฌ์๊ฐ ๋ ๊ฐ์ฉ ๊ฐ์ ๊ฐ์ด ๋์ค๊ณ , ๋์จ ์ซ์๋ฅผ ๊ฐ๊ฐ p, q(p ≠ q)๋ผ๊ณ ํ๋ค๋ฉด (p + q) × |p - q|์ ์ ์ป์ต๋๋ค.
์ด๋ ๋ ์ฃผ์ฌ์์์ ๋์จ ์ซ์๊ฐ p๋ก ๊ฐ๊ณ ๋๋จธ์ง ๋ ์ฃผ์ฌ์์์ ๋์จ ์ซ์๊ฐ ๊ฐ๊ฐ p์ ๋ค๋ฅธ q, r(q ≠ r)์ด๋ผ๋ฉด q × r์ ์ ์ป์ต๋๋ค.
๋ค ์ฃผ์ฌ์์ ์ ํ ์ซ์๊ฐ ๋ชจ๋ ๋ค๋ฅด๋ค๋ฉด ๋์จ ์ซ์ ์ค ๊ฐ์ฅ ์์ ์ซ์ ๋งํผ์ ์ ์๋ฅผ ์ป์ต๋๋ค.
๋ค ์ฃผ์ฌ์๋ฅผ ๊ตด๋ ธ์ ๋ ๋์จ ์ซ์๊ฐ ์ ์ ๋งค๊ฐ๋ณ์ a, b, c, d๋ก ์ฃผ์ด์ง ๋, ์ป๋ ์ ์๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ ์ฌํญ
- a, b, c, d๋ 1 ์ด์ 6 ์ดํ์ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
a | b | c | d | result |
2 | 2 | 2 | 2 | 2222 |
4 | 1 | 4 | 4 | 1681 |
6 | 3 | 3 | 6 | 27 |
2 | 5 | 2 | 6 | 30 |
6 | 4 | 2 | 5 | 2 |
์์ค ์ฝ๋
# 1
def solution(a, b, c, d):
answer = 0
origin = [a,b,c,d]
dice = list(set([a,b,c,d]))
# ๋ชจ๋ ๊ฐ์ ๊ฒฝ์ฐ
if len(dice) == 1:
answer = dice[0] * 1111
# 3๊ฐ๊ฐ ๊ฐ๊ฑฐ๋ 2๊ฐ์ฉ ๊ฐ์ ๊ฒฝ์ฐ
elif len(dice) == 2:
# 3๊ฐ๊ฐ ๊ฐ์ ๊ฒฝ์ฐ
if max([origin.count(num) for num in dice]) == 3:
p = max(origin, key=origin.count)
q = min(origin, key=origin.count)
answer = (10 * p + q)**2
# 2๊ฐ์ฉ ๊ฐ์ ๊ฒฝ์ฐ
else:
answer = ((dice[0] + dice[1]) * abs(dice[0] - dice[1]))
# 2๊ฐ๊ฐ ๊ฐ๊ณ ๋๋จธ์ง๋ ๋ค๋ฅธ ๊ฒฝ์ฐ
elif len(dice) == 3:
for num in dice:
if origin.count(num) == 2:
dice.remove(num)
answer = dice[0]*dice[1]
# ๋ชจ๋ ๋ค๋ฅธ ๊ฒฝ์ฐ
else:
answer = min(dice)
return answer
ํ์ด # 1
- a, b, c, d๊ฐ ๋ชจ๋ ์กด์ฌํ๋ ๋ฆฌ์คํธ = origin / ์ค๋ณต์ ์ ๊ฑฐํ ๋ฆฌ์คํธ = dice
- dice์ ์์๊ฐ 1๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ a, b, c, d๊ฐ ๋ชจ๋ ๊ฐ๋ค๋ ์๋ฏธ
- dice์ ์์๊ฐ 2๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ๋ 3๊ฐ๊ฐ ๊ฐ๊ฑฐ๋ 2๊ฐ๊ฐ ๊ฐ์ ๊ฒฝ์ฐ
- dice์ ์์๊ฐ origin์ 3๊ฐ ์์ผ๋ฉด origin.count ๊ธฐ์ค์ผ๋ก ์ต๋๊ฐ=p / ์ต์๊ฐ=q
- ์์ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด 2๊ฐ์ฉ ๊ฐ์ ๊ฒฝ์ฐ
- dice์ ์์๊ฐ 3๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ๋ 2๊ฐ๋ ๊ฐ๊ณ ๋๋จธ์ง๋ ๋ค๋ฅธ ๊ฒฝ์ฐ
- ๊ฐ์ 2๊ฐ์ ์์๋ฅผ ๋บด๊ณ ๋๋จธ์ง์ ๊ณฑ
- ์์ ๊ฒฝ์ฐ์ ํฌํจ๋์ง ์์ผ๋ฉด a, b, c, d๊ฐ ๋ชจ๋ ๋ค๋ฅธ ๊ฒฝ์ฐ
# 2
def solution(a, b, c, d):
answer = 0
dice = [a,b,c,d]
cnt = [dice.count(num) for num in dice]
# ๋ชจ๋ ๊ฐ์ ๊ฒฝ์ฐ
if max(cnt) == 4:
answer = a * 1111
# 3๊ฐ๊ฐ ๊ฐ๊ณ ๋๋จธ์ง 1๊ฐ๊ฐ ๋ค๋ฅธ ๊ฒฝ์ฐ
elif max(cnt) == 3:
answer = (10 * dice[cnt.index(3)] + dice[cnt.index(1)])**2
# 2๊ฐ๊ฐ ๊ฐ์ ๊ฒฝ์ฐ
elif max(cnt) == 2:
# 2๊ฐ๊ฐ ๊ฐ๊ณ ๋๋จธ์ง 2๊ฐ๋ ๋ค๋ฅธ ๊ฒฝ์ฐ
if min(cnt) == 1:
answer = 1
answer = eval('*'.join([str(dice[i]) for i, c in enumerate(cnt) if c == 1]))
# 2๊ฐ์ฉ ๊ฐ์ ๊ฒฝ์ฐ
else:
answer = (max(dice) + min(dice)) * abs(max(dice) - min(dice))
# ๋ชจ๋ ๋ค๋ฅธ ๊ฒฝ์ฐ
else:
answer = min(dice)
return answer
ํ์ด #2
- ์ฃผ์ฌ์์์ ๋์จ ์ซ์ ๋ฆฌ์คํธ = dice / ๊ฐ ์ซ์์ ๊ฐฏ์ ๋ฆฌ์คํธ = cnt
- ๊ฐฏ์์ ์ต๋๊ฐ์ด 4์ธ ๊ฒฝ์ฐ๋ ๋ชจ๋ ๊ฐ๋ค๋ ์๋ฏธ
- ๊ฐฏ์์ ์ต๋๊ฐ์ด 3์ธ ๊ฒฝ์ฐ๋ 3๊ฐ๊ฐ ๊ฐ๊ณ ๋๋จธ์ง 1๊ฐ๊ฐ ๋ค๋ฅด๋ค๋ ์๋ฏธ
- ๊ฐฏ์์ ์ต๋๊ฐ์ด 2์ธ ๊ฒฝ์ฐ์๋ 2๊ฐ์ง ์ํฉ ์กด์ฌ
- 2๊ฐ๊ฐ ๊ฐ๊ณ ๋๋จธ์ง 2๊ฐ๊ฐ ๋ค๋ฅธ ๊ฒฝ์ฐ์๋ cnt๊ฐ 1์ธ ๊ฐ๋ค์ ๊ณฑ
- 2๊ฐ์ฉ ๊ฐ์ ๊ฒฝ์ฐ์๋ dice์ ์ต๋๊ฐ ์ต์๊ฐ์ผ๋ก ๊ฐ ์ซ์๋ฅผ ๊ตฌ๋ถ
- ์์ ๊ฒฝ์ฐ์ ํฌํจ๋์ง ์์ผ๋ฉด a, b, c, d๊ฐ ๋ชจ๋ ๋ค๋ฅธ ๊ฒฝ์ฐ
๋จธ๋ฆฌ ์ธ๋งค๋ค๊ฐ ์ฒซ ๋ฒ์งธ ํ์ด๋ ๊ฒจ์ฐ ์๊ฐํ๋๋ฐ ๋ ๋ฒ์งธ ํ์ด ๋๋ฌด ์ ๋ฐํ๋ค. ํธ์ ๋ถ ๋๋ฌด ๋๋จํด์..๊ฐ์ ์ซ์์ ๊ฐฏ์๋ฅผ ์ด๋ป๊ฒ ๊ตฌ๋ถํ๋์ง ์๊ฐํ๊ธฐ๊ฐ ์ด๋ ค์ ๋ ๋ฌธ์ ์๋ค.๐ฒ๐ฒ
'์ฝ๋ฉ ๋ฌธ์ ํ์ด ๐ป > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.0 ๊ฒน์น๋ ์ ๋ถ์ ๊ธธ์ด (1) | 2023.12.05 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.0 ํน์ดํ ์ ๋ ฌ (1) | 2023.12.05 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.0 ์ ์๋ฅผ ๋์ ํ์ผ๋ก ๋ฐฐ์นํ๊ธฐ (0) | 2023.12.05 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.0 2์ ์์ญ (1) | 2023.11.24 |
[ํ๋ก๊ทธ๋๋จธ์ค / ํ์ด์ฌ] Lv.0 ์กฐ๊ฑด ๋ฌธ์์ด (1) | 2023.11.18 |