# ๋ช ์์ ์ ๋น(1) # 138477 # lv1
# ๋ฌธ์ 1 (๋ช ์์ ์ ๋น)
"๋ช
์์ ์ ๋น"์ด๋ผ๋ TV ํ๋ก๊ทธ๋จ์์๋ ๋งค์ผ 1๋ช
์ ๊ฐ์๊ฐ ๋
ธ๋๋ฅผ ๋ถ๋ฅด๊ณ , ์์ฒญ์๋ค์ ๋ฌธ์ ํฌํ์๋ก ๊ฐ์์๊ฒ ์ ์๋ฅผ ๋ถ์ฌํฉ๋๋ค. ๋งค์ผ ์ถ์ฐํ ๊ฐ์์ ์ ์๊ฐ ์ง๊ธ๊น์ง ์ถ์ฐ ๊ฐ์๋ค์ ์ ์ ์ค ์์ k๋ฒ์งธ ์ด๋ด์ด๋ฉด ํด๋น ๊ฐ์์ ์ ์๋ฅผ ๋ช
์์ ์ ๋น์ด๋ผ๋ ๋ชฉ๋ก์ ์ฌ๋ ค ๊ธฐ๋
ํฉ๋๋ค. ์ฆ ํ๋ก๊ทธ๋จ ์์ ์ดํ ์ด๊ธฐ์ k์ผ๊น์ง๋ ๋ชจ๋ ์ถ์ฐ ๊ฐ์์ ์ ์๊ฐ ๋ช
์์ ์ ๋น์ ์ค๋ฅด๊ฒ ๋ฉ๋๋ค. k์ผ ๋ค์๋ถํฐ๋ ์ถ์ฐ ๊ฐ์์ ์ ์๊ฐ ๊ธฐ์กด์ ๋ช
์์ ์ ๋น ๋ชฉ๋ก์ k๋ฒ์งธ ์์์ ๊ฐ์ ์ ์๋ณด๋ค ๋ ๋์ผ๋ฉด, ์ถ์ฐ ๊ฐ์์ ์ ์๊ฐ ๋ช
์์ ์ ๋น์ ์ค๋ฅด๊ฒ ๋๊ณ ๊ธฐ์กด์ k๋ฒ์งธ ์์์ ์ ์๋ ๋ช
์์ ์ ๋น์์ ๋ด๋ ค์ค๊ฒ ๋ฉ๋๋ค.
์ด ํ๋ก๊ทธ๋จ์์๋ ๋งค์ผ "๋ช
์์ ์ ๋น"์ ์ตํ์ ์ ์๋ฅผ ๋ฐํํฉ๋๋ค. ์๋ฅผ ๋ค์ด, k = 3์ด๊ณ , 7์ผ ๋์ ์งํ๋ ๊ฐ์์ ์ ์๊ฐ [10, 100, 20, 150, 1, 100, 200]์ด๋ผ๋ฉด, ๋ช
์์ ์ ๋น์์ ๋ฐํ๋ ์ ์๋ ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด [10, 10, 10, 20, 20, 100, 100]์
๋๋ค.
๋ช ์์ ์ ๋น ๋ชฉ๋ก์ ์ ์์ ๊ฐ์ k , 1์ผ๋ถํฐ ๋ง์ง๋ง ๋ ๊น์ง ์ถ์ฐํ ๊ฐ์๋ค์ ์ ์์ธ score ๊ฐ ์ฃผ์ด์ก์ ๋, ๋งค์ผ ๋ฐํ๋ ๋ช ์์ ์ ๋น์ ์ตํ์ ์ ์๋ฅผ returnํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
# ์ ํ์ฌํญ
- 3 ≤ k ≤ 100
- 7 ≤ score์ ๊ธธ์ด ≤ 1,000
- 0 ≤ score[i] ≤ 2,000
# ํ์ด
def solution(k, score):
# ์์ด๋์ด
# -> score๋ฅผ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๊ณ , k๋ฒ์งธ์ ์๋ ์ ์๋ฅผ return ํ๋ค๋ฉด?
# -> ๋ช
์์ ์ ๋น list ๋ฅผ ์์ฑํ๊ณ , ์ ๋น์ ์ ์๋ฅผ ์ถ๊ฐํ๋ ๋ฐฉ์.
# -> ์ ๋น list์ ๋ํด์ง score๋ค ๊ฐ์ด๋ฐ ๋ง์ง๋ง k๋ฒ์งธ์ ์ ์๋ฅผ answer list์ append
answer = []
list1 = [] # ์ ๋น ๋ฆฌ์คํธ
for i in range(len(score)):
list1.append(score[i]) # i๋ฒ์งธ score๋ฅผ ๋ช
์์ ์ ๋น์ ๋ํจ.
list1.sort(reverse = True) # ๋ช
์์ ์ ๋น์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ.
if len(list1) < k:
# ๋ง์ฝ ๋ช
์์ ์ ๋น์ ๋ค์ด๊ฐ ์ ์์ ๊ฐ์๊ฐ k๋ณด๋ค ์์ผ๋ฉด,
answer.append(list1[-1])
else:
# ๋ช
์์ ์ ๋น์ ๋ค์ด๊ฐ ์ ์์ ๊ฐ์๊ฐ k๋ณด๋ค ํฌ๋ฉด,
answer.append(list1[k - 1])
return answer
# ๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ # 136798 # lv1
# ๋ฌธ์ 2 (๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ)
์ซ์๋๋ผ ๊ธฐ์ฌ๋จ์ ๊ฐ ๊ธฐ์ฌ์๊ฒ๋ 1๋ฒ๋ถํฐ number๊น์ง ๋ฒํธ๊ฐ ์ง์ ๋์ด ์์ต๋๋ค. ๊ธฐ์ฌ๋ค์ ๋ฌด๊ธฐ์ ์์ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํ๋ ค๊ณ ํฉ๋๋ค.
๊ฐ ๊ธฐ์ฌ๋ ์์ ์ ๊ธฐ์ฌ ๋ฒํธ์ ์ฝ์ ๊ฐ์์ ํด๋นํ๋ ๊ณต๊ฒฉ๋ ฅ์ ๊ฐ์ง ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํ๋ ค ํฉ๋๋ค. ๋จ, ์ด์๋๋ผ์์ ํ์ฝ์ ์ํด ๊ณต๊ฒฉ๋ ฅ์ ์ ํ์์น๋ฅผ ์ ํ๊ณ , ์ ํ์์น๋ณด๋ค ํฐ ๊ณต๊ฒฉ๋ ฅ์ ๊ฐ์ง ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํด์ผ ํ๋ ๊ธฐ์ฌ๋ ํ์ฝ๊ธฐ๊ด์์ ์ ํ ๊ณต๊ฒฉ๋ ฅ์ ๊ฐ์ง๋ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, 15๋ฒ์ผ๋ก ์ง์ ๋ ๊ธฐ์ฌ๋จ์์ 15์ ์ฝ์๊ฐ 1, 3, 5, 15๋ก 4๊ฐ ์ด๋ฏ๋ก, ๊ณต๊ฒฉ๋ ฅ์ด 4์ธ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํฉ๋๋ค. ๋ง์ฝ, ์ด์๋๋ผ์์ ํ์ฝ์ผ๋ก ์ ํด์ง ๊ณต๊ฒฉ๋ ฅ์ ์ ํ์์น๊ฐ 3์ด๊ณ ์ ํ์์น๋ฅผ ์ด๊ณผํ ๊ธฐ์ฌ๊ฐ ์ฌ์ฉํ ๋ฌด๊ธฐ์ ๊ณต๊ฒฉ๋ ฅ์ด 2๋ผ๋ฉด, 15๋ฒ์ผ๋ก ์ง์ ๋ ๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ์ ์์ ๊ณต๊ฒฉ๋ ฅ์ด 2์ธ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํฉ๋๋ค. ๋ฌด๊ธฐ๋ฅผ ๋ง๋ค ๋, ๋ฌด๊ธฐ์ ๊ณต๊ฒฉ๋ ฅ 1๋น 1kg์ ์ฒ ์ด ํ์ํฉ๋๋ค. ๊ทธ๋์ ๋ฌด๊ธฐ์ ์์ ๋ฌด๊ธฐ๋ฅผ ๋ชจ๋ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ฒ ์ ๋ฌด๊ฒ๋ฅผ ๋ฏธ๋ฆฌ ๊ณ์ฐํ๋ ค ํฉ๋๋ค.
๊ธฐ์ฌ๋จ์์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ number์ ์ด์๋๋ผ์ ํ์ฝ์ผ๋ก ์ ํด์ง ๊ณต๊ฒฉ๋ ฅ์ ์ ํ์์น๋ฅผ ๋ํ๋ด๋ ์ ์ limit์ ์ ํ์์น๋ฅผ ์ด๊ณผํ ๊ธฐ์ฌ๊ฐ ์ฌ์ฉํ ๋ฌด๊ธฐ์ ๊ณต๊ฒฉ๋ ฅ์ ๋ํ๋ด๋ ์ ์ power๊ฐ ์ฃผ์ด์ก์ ๋, ๋ฌด๊ธฐ์ ์ ์ฃผ์ธ์ด ๋ฌด๊ธฐ๋ฅผ ๋ชจ๋ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ฒ ์ ๋ฌด๊ฒ๋ฅผ returnํ๋ solution ํจ์๋ฅผ ์์ฑํ์์ค.
# ์ ํ์ฌํญ
- 1 ≤ number ≤ 100,000
- 2 ≤ limit ≤ 100
- 1 ≤ power ≤ limit
# ํ์ด
import math
def count_divisors(n):
# ์ฝ์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํจ์
count = 0
for i in range(1, int(math.sqrt(n)) + 1):
# ์ฝ์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๊ณ์ฐ์ ์ค์ด๊ณ ์ sqrt ๋ฉ์๋๋ฅผ ์ฌ์ฉ.
if n % i == 0:
# ๋ง์ฝ n % i ์ ๋๋จธ์ง๊ฐ 0์ด๋ฉด, ์ ๊ณฑ๊ทผ์ด ์๋ ๋,
count += 1
if i != n // i:
# ์ ๊ณฑ๊ทผ์ด ์๋ ๊ฒฝ์ฐ
count += 1
return count
def solution(number, limit, power):
# ๊ธฐ์ฌ์ ๋ฒํธ์ ํด๋น ๋ฒํธ์ ์ฝ์ ๊ฐ์๋ก ๊ณต๊ฒฉ๋ ฅ์ ๊ณ์ฐ
yaksu_list = [count_divisors(knight) for knight in range(1, number + 1)]
# ์ ํ ์์น๋ณด๋ค ํฐ ๊ณต๊ฒฉ๋ ฅ์ power๋ก ๋์ฒด
yaksu_list = [power if attack > limit else attack for attack in yaksu_list]
return sum(yaksu_list)