[๋ฌธ์ ๋งํฌ] ๐
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
ํ์ด
๊ฐ ์ํฌ์์ ํจํด ์ ์
- ๊ฐ ์ํฌ์๋ ๋ฌธ์ ๋ฅผ ์ฐ๋ ์ผ์ ํ ํจํด์ ๊ฐ์ง๊ณ ์๋ค.
- ์ฒซ ๋ฒ์งธ ์ํฌ์๋ [1, 2, 3, 4, 5], ๋ ๋ฒ์งธ๋ [2, 1, 2, 3, 2, 4, 2, 5], ์ธ ๋ฒ์งธ๋ [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]๋ผ๋ ํจํด์ ๋ฐ๋ณตํ๋ฉฐ ๋ต์ ์ฐ๋๋ค.
์ ๋ต๊ณผ ๋น๊ตํ์ฌ ๋งํ ๊ฐ์ ๊ณ์ฐ
- ์ฃผ์ด์ง answers ๋ฆฌ์คํธ์ ๊ฐ ์ํฌ์์ ํจํด์ ๋ฐ๋ณต ๋น๊ตํ์ฌ ๋งํ ๊ฐ์๋ฅผ ์ผ๋ค.
- j ๋ณ์๋ฅผ ์ฌ์ฉํด ๊ฐ ์ํฌ์ ํจํด์ ์ธ๋ฑ์ค๋ฅผ ๋ง์ถฐ ๊ฐ๋ฉฐ ๋น๊ตํ๊ณ , j๊ฐ ํจํด ๊ธธ์ด์ ๋๋ฌํ๋ฉด ๋ค์ 0์ผ๋ก ์ด๊ธฐํํ์ฌ ํจํด์ ๋ฐ๋ณตํ๋ค.
๋ชจ๋ ์ํฌ์์ ์ ์ ๋น๊ต
- ๊ฐ ์ํฌ์๊ฐ ๋งํ ์ ์๋ฅผ cnt ๋ฆฌ์คํธ์ ์ ์ฅํ๋ค.
- cnt์์ ๊ฐ์ฅ ๋์ ์ ์๋ฅผ ์ฐพ๊ณ , ์ด๋ฅผ ํตํด ํด๋น ์ ์๋ฅผ ๋ฐ์ ์ํฌ์์ ๋ฒํธ๋ฅผ answer ๋ฆฌ์คํธ์ ์ถ๊ฐํ๋ค.
๊ฐ์ฅ ๋ง์ ๋ฌธ์ ๋ฅผ ๋งํ ์ํฌ์ ๋ฐํ
- answer ๋ฆฌ์คํธ์๋ ์ต๊ณ ์ ์๋ฅผ ๋ฐ์ ์ํฌ์์ ๋ฒํธ๊ฐ ๋ค์ด๊ฐ๋ฉฐ, ์ค๋ฆ์ฐจ์์ผ๋ก ๋ฐํํ๋ค.
Solution
def correct(student_answer, answers): # ์ ๋ต ๊ณ์ฐ ํจ์
cnt, j = 0, 0
for i in range(len(answers)):
if answers[i] == student_answer[j]:
cnt += 1
j += 1 # ๋ค์ ๋ฌธ์ ๋ก
if j >= len(student_answer):
j = 0
return cnt
def solution(answers):
answer = []
one = correct([1, 2, 3, 4, 5], answers) # 1๋ฒ ์ํฌ์
two = correct([2, 1, 2, 3, 2, 4, 2, 5], answers) # 2๋ฒ ์ํฌ์
three = correct([3, 3, 1, 1, 2, 2, 4, 4, 5, 5], answers) # 3๋ฒ ์ํฌ์
cnt = [one, two, three] # ์ ๋ต ๊ฐ์ ์ ์ฅ
max_cnt = max(cnt) # ์ ๋ต ๊ฐ์ ์ค ์ต๋๊ฐ ์ ์ฅ
for i in range(3):
if max_cnt == cnt[i]: # ์ต๋ ์ ๋ต ์์ ๊ฐ์ผ๋ฉด
answer.append(i + 1) # ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ๋ค.
return answer
๊ฐ์ ํ ์
- correct() ํจ์์์ ์ธ๋ฑ์ค ๊ด๋ฆฌ๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ๋ง๋ค๊ธฐ ์ํด enumerate()์ ๋ชจ๋๋ฌ ์ฐ์ฐ %๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
- solution() ํจ์์์ for ๋ฃจํ ์์ด ๋ฆฌ์คํธ ์ปดํ๋ฆฌํจ์ ์ผ๋ก ์ต๊ณ ์ ์๋ฅผ ์ป์ ํ์์ ์ฐพ์ ๋ฐํํ ์ ์๋ค.
๊ฐ์ ๋ ์ฝ๋
def correct(student_answer, answers):
return sum(1 for i, ans in enumerate(answers) if ans == student_answer[i % len(student_answer)])
def solution(answers):
patterns = [
[1, 2, 3, 4, 5],
[2, 1, 2, 3, 2, 4, 2, 5],
[3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
]
scores = [correct(pattern, answers) for pattern in patterns]
max_score = max(scores)
return [i + 1 for i, score in enumerate(scores) if score == max_score]
๐ฉ๐ป ํ๊ณ
์ด ๋ฌธ์ ๋ Level 1 ์ธ๋ฐ๋ ์๋นํ ๊ธด ์ฝ๋๋ฅผ ์์ฑํด์ผ ํ๋ค. ๋ด ํ์ด๋ง ๊ทธ๋ฐ ์ค ์์๋๋ฐ ๋ค๋ฅธ ์ฌ๋๋ค๋ ๋ง๋ง์น ์๊ฒ ๊ธธ์ด์ ๋ง๊ฒ ํ์๊ตฌ๋ ์ถ์๋ค.
์์ธ๋ก ์๋ฌ๊ฐ ๋ ๊ณณ์ max ๊ฐ์ ์ฐพ์ ๋์๋ค. ๋ค์์ ์ด๊ธฐ์ ์์ฑํ๋ ์ฝ๋์ด๋ค.
max_answer = 0
for i in range(len(cnt)):
if cnt[i] >= max_answer:
max_answer = cnt[i]
answer.append(i + 1)
- ์ฝ๋์์๋ `if cnt[i] >= max_answer` ์กฐ๊ฑด์ ์ฌ์ฉํด ์ต๊ณ ์ ์๋ฅผ ๊ฐฑ์ ํ๋ฉด์ ๋ฐ๋ก `answer` ๋ฐฐ์ด์ ์ ์๊ฐ ๊ฐ์ ์ฌ๋๋ ์ถ๊ฐํ๊ณ ์๋ค.
- ํ์ง๋ง, ์ด๋ ๊ฒ ํ๋ฉด ์ต๊ณ ์ ์๋ฅผ ๊ฐฑ์ ํ ๋ ์ด์ ์ ์ถ๊ฐ๋ ์ฌ๋๋ค์ `answer` ๋ฐฐ์ด์์ ์ ๊ฑฐํ์ง ์์ผ๋ฉด์, ์ต์ข ์ ์ผ๋ก ๊ฐ์ฅ ๋์ ์ ์๋ฅผ ๋ฐ์ ์ฌ๋๋ค์ด ์๋, ๊ทธ ์ด์ ์ ๊ณ ๋ ค๋ ์ฌ๋๋ค๊น์ง ํฌํจํ ์ ์๋ค.
์ด ๋ถ๋ถ๊น์ง ๋ฏธ์ฒ ๊ณ ๋ คํ์ง ๋ชปํ์ด์ ์์ฌ์ ๋ค. ๋คํํ๋ ๋ฐ๋ก ์์ ํด์ 2ํธ๋ง์ ์ฑ๊ณตํ๋ค. ์์งํ ์ฝ๋๊ฐ ๋๋ฌด ๊ธธ์ด์ ธ์ ์ ์ถ์ด ์ ๋ ์ค ์์๋ค. ์ฐ์ต๋ฌธ์ ๋ง๊ณ ๋ ์๋ฃ ๊ตฌ์กฐ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ ์ด๋ฐ์์ผ๋ก ํ์ด๋ ์ซ์ง ๋ง์.
๊ฐ์ ๋ ์ฝ๋๋ ๋ค์ ๋ณด๋ฉฐ ๋ ํจ์จ์ ์ธ ์ฝ๋๋ก ์์ฑํ๋๋ก ํ์.
'๐งฉ Algorithm > [Programmers] Level 1' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Programmers] L1. ํธ๋ ํ์ดํธ ๋ํ (Python) (0) | 2024.11.11 |
|---|---|
| [Programmers] L1. ์ฝ๋ผ ๋ฌธ์ (Python) (0) | 2024.11.07 |
| [Programmers] L1. ๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ (Python) (1) | 2024.11.06 |
| [Programmers] L1. ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฐ์ ๊ธ์ (Python) (0) | 2024.11.06 |
| [Programmers] L1. ์ผ์ด์ฌ (Python) (0) | 2024.11.06 |