์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | ||
6 | 7 | 8 | 9 | 10 | 11 | 12 |
13 | 14 | 15 | 16 | 17 | 18 | 19 |
20 | 21 | 22 | 23 | 24 | 25 | 26 |
27 | 28 | 29 | 30 |
- array.reduce()
- ES6 ๋ธ๋ผ์ฐ์ ์ง์ ํํฉ
- ์์ค๋ฆ~
- ์๋ฐ์คํฌ๋ฆฝํธ์ ํ์๋ฐฐ๊ฒฝ
- ํ๋ก๊ทธ๋๋จธ์ค
- ์๋ฆ๋๋ ์๊ณ ๋ฆฌ์ฆ
- ์๋ฐ์คํฌ๋ฆฝํธ์ ECMAScript
- !x.includes()
- ํ๋ ฌ...
- ๊ฐ์ฐ์ค์ ๊ณต์
- .split()
- async-await
- arr.push()
- ์ผํญ์ฐ์ฐ์
- ์๋ฐ์คํฌ๋ฆฝํธ
- for๋ฌธ
- ์๊ณ ๋ฆฌ์ฆ
- a && b
- ๊ตฌ๋ฌธ๊ณผ ์๋ฏธ
- .map()
- ํ๋ก๊ทธ๋๋จธ์ค ๊ณต์ ์ฐ์ฑ
- ์๋ฐ์คํฌ๋ฆฝํธ์ ํน์ง
- for๋ฐ๋ณต๋ฌธ
- Ajax๋?
- Promise.all()
- Math.min
- ๋ฐฐ์ด ์ต์๊ฐ
- JavaScript
- ํ๋ก๊ทธ๋๋ฐ์ด๋
- ์ด๋ ค์ด๋ฐใ ใ
- Today
- Total
Ming's develop story
๊ณผ์ผ ์ฅ์ - ํ๋ก๊ทธ๋๋จธ์ค ๋ณธ๋ฌธ
๋ฌธ์ ์ค๋ช
๊ณผ์ผ ์ฅ์๊ฐ ์ฌ๊ณผ ์์๋ฅผ ํฌ์ฅํ๊ณ ์์ต๋๋ค. ์ฌ๊ณผ๋ ์ํ์ ๋ฐ๋ผ 1์ ๋ถํฐ k์ ๊น์ง์ ์ ์๋ก ๋ถ๋ฅํ๋ฉฐ, k์ ์ด ์ต์ํ์ ์ฌ๊ณผ์ด๊ณ 1์ ์ด ์ตํํ์ ์ฌ๊ณผ์ ๋๋ค. ์ฌ๊ณผ ํ ์์์ ๊ฐ๊ฒฉ์ ๋ค์๊ณผ ๊ฐ์ด ๊ฒฐ์ ๋ฉ๋๋ค.ํ ์์์ ์ฌ๊ณผ๋ฅผ m๊ฐ์ฉ ๋ด์ ํฌ์ฅํฉ๋๋ค.์์์ ๋ด๊ธด ์ฌ๊ณผ ์ค ๊ฐ์ฅ ๋ฎ์ ์ ์๊ฐ p (1 โค p โค k)์ ์ธ ๊ฒฝ์ฐ, ์ฌ๊ณผ ํ ์์์ ๊ฐ๊ฒฉ์ p * m ์ ๋๋ค.๊ณผ์ผ ์ฅ์๊ฐ ๊ฐ๋ฅํ ๋ง์ ์ฌ๊ณผ๋ฅผ ํ์์ ๋, ์ป์ ์ ์๋ ์ต๋ ์ด์ต์ ๊ณ์ฐํ๊ณ ์ ํฉ๋๋ค.(์ฌ๊ณผ๋ ์์ ๋จ์๋ก๋ง ํ๋งคํ๋ฉฐ, ๋จ๋ ์ฌ๊ณผ๋ ๋ฒ๋ฆฝ๋๋ค)์๋ฅผ ๋ค์ด, k = 3, m = 4, ์ฌ๊ณผ 7๊ฐ์ ์ ์๊ฐ [1, 2, 3, 1, 2, 3, 1]์ด๋ผ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด [2, 3, 2, 3]์ผ๋ก ๊ตฌ์ฑ๋ ์ฌ๊ณผ ์์ 1๊ฐ๋ฅผ ๋ง๋ค์ด ํ๋งคํ์ฌ ์ต๋ ์ด์ต์ ์ป์ ์ ์์ต๋๋ค.(์ต์ ์ฌ๊ณผ ์ ์) x (ํ ์์์ ๋ด๊ธด ์ฌ๊ณผ ๊ฐ์) x (์์์ ๊ฐ์) = 2 x 4 x 1 = 8์ฌ๊ณผ์ ์ต๋ ์ ์ k, ํ ์์์ ๋ค์ด๊ฐ๋ ์ฌ๊ณผ์ ์ m, ์ฌ๊ณผ๋ค์ ์ ์ score๊ฐ ์ฃผ์ด์ก์ ๋, ๊ณผ์ผ ์ฅ์๊ฐ ์ป์ ์ ์๋ ์ต๋ ์ด์ต์ returnํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
ํ๋ก๊ทธ๋๋จธ์ค/๊ณผ์ผ ์ฅ์
์ ์ถ๋ ฅ ์
k | m | score | result |
3 | 4 | [1, 2, 3, 1, 2, 3, 1] | 8 |
4 | 3 | [4, 1, 2, 2, 4, 4, 4, 4, 1, 2, 4, 2] | 33 |
๋ด ํ์ด
function computeMaxProfit(k, m, score) {
const numBox = Math.floor(score.length / m);
const availableScores = score.sort((a, b) => b - a).slice(0, numBox * m);
const result = availableScores.reduce((acc, cur, index) => {
if ((index + 1) % m === 0) {
return (acc = acc + cur * m);
}
return acc;
}, 0);
return result;
}
๊ณ ๋ฏผ์ ํด๋ณด๋ ๊ฒฐ๊ตญ ์ต๋ ์ด์ต์ ๋ด๋ ค๋ฉด ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ํด์ ํ ๋ฐ์ค์ ๋ค์ด๊ฐ ์ฌ๊ณผ์ ๊ฐ์๊ฐ ์ ํด์ง๋ ๊ทธ๊ฒ์ผ๋ก ๋ช ๋ฐ์ค๋ฅผ ์ฑ์ธ ์ ์์์ง ์๋ฉด ๋์๋ค.
์ฐ์ score.length๋ฅผ ํ ๋ฐ์ค์ ๋ค์ด๊ฐ ์ฌ๊ณผ์ ๊ฐ์๋ก ๋๋ ๋ค ์์์ ์ ๋ฒ๋ ค numBox ๋ฅผ ์ ์ํ๋ค.
๊ทธ๋ฆฌ๊ณ score ๋ฐฐ์ด์์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ค ํ์ํ ์๋ง ๋นผ๊ณ ๋ฒ๋ ค์ฃผ๋ ์์ ์ ํ๋ค.
์ดํ reduce๋ฅผ ์ฌ์ฉํ๊ณ , ๊ฐ ๋ฐ์ค์์ ๋ง์ง๋ง์ ์์นํ ์ธ๋ฑ์ค ๊ฐ์ ์กฐ๊ฑด์ ์์นํ ๊ทธ ๋ฐ์ค์ ์ต์๊ฐ์ด๋ผ๋ฉด ๊ทธ ๊ฐ์ ํ ์์์ ๋ด๊ธด ์ฌ๊ณผ ๊ฐ์๋ฅผ ๊ณฑํ์ฌ์ฃผ๊ณ ๋ํด์ค์ผ๋ก์จ ๊ฒฐ๊ณผ ๊ฐ์ ๋์ถํด๋๋ค.
๋ค๋ฅธ ์ฌ๋์ ํ์ด
function solution(k, m, score) {
let answer = 0;
const sortedScore = score.slice().sort((a, b) => a - b).slice(score.length % m);
for (let i = 0; i < sortedScore.length; i += m) {
answer += sortedScore[i] * m;
}
return answer;
}
๊ฐ๊ฒฐํ๊ณ ๊น๋ํ๋ค.
์ฐ์ score.slice()๋ก ์๋ณธ ๋ฐฐ์ด์ ์ ์งํ ์ํ๋ก ๋ฐฐ์ด์ ๋ณต์ฌํ์๊ณ ๊ทธ๊ฒ์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ํ ๋ค ๋๋จธ์ง ๊ฐ๋ค์ slice ๋ก ์๋ผ๋ด์๋ค. ์ดํ ๋ฐ๋ณต๋ฌธ์ ํตํด ์์์ ์ต์๊ฐ๋ง ๋ฝ์์ ๋ํด์ฃผ๊ธฐ ์ํด i๋ฅผ m์ฉ ์ฆ๊ฐ์์ผฐ๋ค.
๋ด๊ฐ ์ ๊ทผํ ๋ฐฉ์๋ณด๋ค ๋ ๊ฐ์ง ์ธก๋ฉด์์ ๋ ์ข๋ค๋ผ๋ ์๊ฐ์ด ๋ค์๋ค.
์ฒซ ๋ฒ์งธ๋ก๋ score์ ๋ฐ๋ก sort๋ฅผ ์ฌ์ฉํ๋ฉด ํจ์์ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌ๋ ๋ฐฐ์ด์ ์๋ณธ ๋ฐฐ์ด๊ณผ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ฐธ์กฐํ๊ณ ์๊ธฐ ๋๋ฌธ์ ์๋ณธ ๋ฐฐ์ด ์์ฒด๊ฐ ๋ณ๊ฒฝ๋๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด ๋ณต์ฌ๋ฅผ ์ํด slice()๋ฅผ ์ฌ์ฉํ ์ ์ด์๋ค.
๋ ๋ฒ์งธ๋ก๋ reduce()๋ ๋ด๋ถ์ ์ผ๋ก ์ฝ๋ฐฑ ํจ์๋ฅผ ํธ์ถํด์ผ ํด์ ์ฝ๋ฐฑ ํจ์ ํธ์ถ ๋น์ฉ์ด ์ถ๊ฐ๋์ด ํจ์๋ฅผ ํธ์ถํ๋ ์ค๋ฒํค๋๊ฐ ๋ฐ๋ณต๋ฌธ๋ณด๋ค ํด ์ ์์ด์ ๊ฐ๋จํ ์ฐ์ฐ์ ์์ด์๋ for๋ฌธ์ด ๋ ๋น ๋ฅธ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
'D E V E L O P ๐ป > ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๊ณต์ ์ฐ์ฑ - ํ๋ก๊ทธ๋๋จธ์ค (0) | 2025.02.12 |
---|---|
๋ง์น ํ๊ธฐ - ํ๋ก๊ทธ๋๋จธ์ค (0) | 2025.02.10 |
์๊ณ ๋ฆฌ์ฆ - ์ง์ฌ๊ฐํ ๋ณ์ฐ๊ธฐ (0) | 2022.05.24 |
์๊ณ ๋ฆฌ์ฆ - ํธ๋ํฐ ๋ฒํธ ๊ฐ๋ฆฌ๊ธฐ (0) | 2022.05.24 |
์๊ณ ๋ฆฌ์ฆ - x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์ (0) | 2022.05.23 |