ํด๋น ๊ฒ์๋ฌผ์ longroadhome๋์ ํ๋ก๊ทธ๋๋จธ์ค LV.3 ์ผ๊ทผ ์ง์ JS ๊ฒ์๋ฌผ์ ์ฐธ๊ณ ํ์ฌ ์ ์๋์์์ ๋ฏธ๋ฆฌ ๋ฐํ๋๋ค.
๋ฌธ์ ์ค๋ช
ํ์ฌ์ Demi๋ ๊ฐ๋์ ์ผ๊ทผ์ ํ๋๋ฐ์, ์ผ๊ทผ์ ํ๋ฉด ์ผ๊ทผ ํผ๋ก๋๊ฐ ์์ ๋๋ค. ์ผ๊ทผ ํผ๋ก๋๋ ์ผ๊ทผ์ ์์ํ ์์ ์์ ๋จ์ ์ผ์ ์์ ๋์ ์ ๊ณฑํ์ฌ ๋ํ ๊ฐ์ ๋๋ค. Demi๋ N์๊ฐ ๋์ ์ผ๊ทผ ํผ๋ก๋๋ฅผ ์ต์ํํ๋๋ก ์ผํ ๊ฒ๋๋ค.Demi๊ฐ 1์๊ฐ ๋์ ์์ ๋ 1๋งํผ์ ์ฒ๋ฆฌํ ์ ์๋ค๊ณ ํ ๋, ํด๊ทผ๊น์ง ๋จ์ N ์๊ฐ๊ณผ ๊ฐ ์ผ์ ๋ํ ์์ ๋ works์ ๋ํด ์ผ๊ทผ ํผ๋ก๋๋ฅผ ์ต์ํํ ๊ฐ์ ๋ฆฌํดํ๋ ํจ์ solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์ฌํญ
works๋ ๊ธธ์ด 1 ์ด์, 20,000 ์ดํ์ธ ๋ฐฐ์ด์
๋๋ค.
works์ ์์๋ 50000 ์ดํ์ธ ์์ฐ์์
๋๋ค.
n์ 1,000,000 ์ดํ์ธ ์์ฐ์์
๋๋ค.
์ ์ถ๋ ฅ ์
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
n=4 ์ผ ๋, ๋จ์ ์ผ์ ์์ ๋์ด [4, 3, 3] ์ด๋ผ๋ฉด ์ผ๊ทผ ์ง์๋ฅผ ์ต์ํํ๊ธฐ ์ํด 4์๊ฐ๋์ ์ผ์ ํ ๊ฒฐ๊ณผ๋ [2, 2, 2]์ ๋๋ค. ์ด ๋ ์ผ๊ทผ ์ง์๋ 22 + 22 + 22 = 12 ์ ๋๋ค.
์ ์ถ๋ ฅ ์ #2
n=1์ผ ๋, ๋จ์ ์ผ์ ์์ ๋์ด [2,1,2]๋ผ๋ฉด ์ผ๊ทผ ์ง์๋ฅผ ์ต์ํํ๊ธฐ ์ํด 1์๊ฐ๋์ ์ผ์ ํ ๊ฒฐ๊ณผ๋ [1,1,2]์ ๋๋ค. ์ผ๊ทผ์ง์๋ 12 + 12 + 22 = 6์ ๋๋ค.
๋์ ํ์ด
function solution(n, works) {
// ํ ์ ์๋ ์ผ์ ์ด๋์ด works ๋ฐฐ์ด์ ๋ชจ๋ ๋น์ธ ์ ์๋ ๊ฒฝ์ฐ
if(works.reduce((a,b) => a+b,0) <= n) return 0
// ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
works.sort((a,b) => b-a)
// ์์ง ํ ์ ์๋ ์ผ์ด ๋จ์๊ฒฝ์ฐ
while(n) {
// 0๋ฒ์งธ ์ธ๋ฑ์ค๊ฐ ํด๋น ๋ฐ๋ณต์ ์ต๋๊ฐ
const max = works[0]
for(let i = 0 ; i < works.length ; i ++) {
// ํด๋น ์ธ๋ฑ์ค๋ ์ต๋๊ฐ๊ณผ ๊ฐ๋ค๋ฉด
if(works[i] === max) {
n--
works[i]--
}
if(!n) break
}
}
return works.reduce((a,b) => a+(b**2) ,0)
}
์ฐ์ฐ์ด ํ์ํ์ง ์์ ํด์ผํ ์ผ์ ์ดํฉ๋ณด๋ค ํ ์ ์๋์ผ์ด ๋ ๋ง๋ค๋ฉด [0,0,...] ์ด๋ฏ๋ก 0 ์ return
์ค๋ฆ์ฐจ์ ์ ๋ ฌ
n์ด ๋จ์๊ฒฝ์ฐ ๋ฐ๋ณต
3-1. ์ต๋๊ฐ์ ์ง์ ํ๋ฉฐ ์ต๋๊ฐ๊ณผ ๊ฐ์ ๋ฐฐ์ด ๋ด์์ ๊ฐ์ฅ ํฐ ์๋ฅผ ์ฐพ์ ํ ์ ์๋ ์ผ์ ์์ ํด๋น ์ธ๋ฑ์ค์ ์๋ฅผ 1์ฉ ๋บ
โป ํฐ ์์ ์ ๊ณฑ์ ํญ์ ์์ ์์ ์ ๊ณฑ๋ณด๋ค ํฌ๊ธฐ ๋๋ฌธ์ ํฐ ์๋ฅผ ๋ชจ๋ ์ฐพ์ ๋ฎ๊ฒ ํ์คํ ์ํค๋ ๊ณผ์
3-2. ํด๋น ์์ ์ผ๋ก ํ ์ ์๋ ์ผ์ด 0๊ฐ ๋จ์๋ค๋ฉด ๋ฐ๋ณต ์ค๋จ
๋จ์์๋ ์๋ฅผ ๋ชจ๋ ์ ๊ณฑํ์ฌ ๋ํ ํ ์ถ๋ ฅ