ํ๋ก๊ทธ๋๋จธ์ค 1๋จ๊ณ : ๋ช ์์ ์ ๋น (1)
์ฝ๋ฉํ ์คํธ ์ฐ์ต > ์ฐ์ต๋ฌธ์ > ๋ช ์์ ์ ๋น (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
๐ฉ ๋ฌธ์ ํ์ด
function solution(k, score) {
let last = []; // ์ตํ ์ ์ ๋ชฉ๋ก
let answer = [];
if(k<score.length){
for(i=0; i<k; i++){
answer.push(score[i]); // ๋ค์๋ ์ ์ ์ ๋ฃ์ด์ฃผ๊ธฐ
answer.sort((a,b) => {return a-b}); // ์ ๋ ฌ
last.push(answer[0]); // ์ตํ์ ์ ์ ๋ฃ์ด์ฃผ๊ธฐ
}
for(i=k; i<score.length; i++){
answer.push(score[i]); // ๋ค์๋ ์ ์ ์ ๋ฃ์ด์ฃผ๊ธฐ
answer.sort((a,b) => {return a-b}); // ์ ๋ ฌ
answer.shift(); // ๊ฐ์ฅ ์์ ์ ์ ๊ฑฐ(ํ๋ฝ)
last.push(answer[0]); // ์ตํ์ ์ ์ ๋ฃ์ด์ฃผ๊ธฐ
}
} else {
for(i=0; i<score.length; i++){
answer.push(score[i]); // ๋ค์๋ ์ ์ ์ ๋ฃ์ด์ฃผ๊ธฐ
answer.sort((a,b) => {return a-b}); // ์ ๋ ฌ
last.push(answer[0]); // ์ตํ์ ์ ์ ๋ฃ์ด์ฃผ๊ธฐ
}
}
return last;
}
for๋ฌธ์ ์ฐ๋ฐ! ํ ์คํธ ์ผ์ด์ค๋ ํต๊ณผ์ธ๋ฐ ์๊พธ ์คํจํด์ ๋ณด๋๊น, k๊ฐ score๋ณด๋ค ํด ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ์ง ์์๋๋ผ๊ณ ์. ๊ทธ๋์ if๋ฌธ์ผ๋ก ๊ฒฝ์ฐ์ ์๋ฅผ ๋ง๋ค์ด ๋๋ ค๋ฐ์ผ๋๊น ๋ฐ๋ก ํต๊ณผํ๋๋ฐ... ์ด๋๋ ๋๋ ์ถ๊ณ ์ง์ ๋ถํ๋ค์.
๐ฉ ๋ค๋ฅธ ํ์ด
function solution(k, score) {
const stack = []
return score.reduce((a,c) => {
if(stack.length < k) {
stack.push(c)
stack.sort((a,b) => a - b)
}
else {
stack.push(c)
stack.sort((a,b) => a - b)
stack.shift()
}
a.push(stack[0])
return a
},[])
}
stack ๋ฐฐ์ด ์์์ ๊ฐ์๊ฐ k๋ณด๋ค ์์ ๊ฒฝ์ฐ, ์ ์๋ฅผ pushํด ์ฃผ๊ณ , ์์์ ๊ฐ์๊ฐ k๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ,
๊ฐ์ฅ ๋ฎ์ ์ ์๋ฅผ ๋นผ์ฃผ๋ ๋ฐฉ๋ฒ์
๋๋ค.
๊ทธ๊ฒ๊น์ง๋ง ์๊ฒ ๋ค์... reduce()์ ๋ ๋ฉ์ด์ง๋ ๊ธฐ๋ถ์ด์์...
'Programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค 1๋จ๊ณ : 2016๋ (2) | 2022.12.12 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค 1๋จ๊ณ : ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฐ์ ๊ธ์ (5) | 2022.12.08 |
ํ๋ก๊ทธ๋๋จธ์ค 1๋จ๊ณ : ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์ (5) | 2022.12.07 |
ํ๋ก๊ทธ๋๋จธ์ค 1๋จ๊ณ : ํธ๋ ํ์ดํธ ๋ํ (4) | 2022.12.07 |
ํ๋ก๊ทธ๋๋จธ์ค 1๋จ๊ณ : ์ซ์ ๋ฌธ์์ด๊ณผ ์๋จ์ด (3) | 2022.12.05 |
๋๊ธ