ํฐ์คํ ๋ฆฌ ๋ทฐ
๋ฌธ์
์ ์๋์ ์ฌํด ์กธ์ ํ๋ ๋ฐ ํ์๋ค์๊ฒ ์กธ์ ์ ๋ฌผ์ ์ฃผ๋ ค๊ณ ํ๋ค.ํ์๋ค์๊ฒ ๊ฐ์ ์ํ๋ ์ํ์ ๊ณจ๋ผ ๊ทธ ์ํ์ ๊ฐ๊ฒฉ๊ณผ ๋ฐฐ์ก๋น๋ฅผ ์ ์ถํ๋ผ๊ณ ํ์๋ค. ์ ์๋์ด ๊ฐ์ง๊ณ ์๋ ์์ฐ์ ํ์ ๋์ด ์๋ค.ํ์ฌ ์์ฐ์ผ๋ก ์ต๋ ๋ช ๋ช ์ ํ์์๊ฒ ์ ๋ฌผ์ ์ฌ์ค ์ ์๋์ง ๊ตฌํ๊ณ ์ ํ๋ค.์ ์๋์ ์ํ ํ๋๋ฅผ 50% ํ ์ธํด์ ์ด ์ ์๋ ์ฟ ํฐ์ ๊ฐ์ง๊ณ ์๋ค. ๋ฐฐ์ก๋น๋ ํ ์ธ์ ํฌํจ๋์ง ์๋๋ค.(์ ์๋์ ์ต์ํ 1๊ฐ ์ด์์ ์ํ์ ์ด ์ ์๋ ์์ฐ์ ๊ฐ์ง๊ณ ์๋ค)
๋ฌธ์ ํ์ด
์์ฐ์ ๋ง๊ฒ ํ์๋ค์๊ฒ ์ ๋ฌผ์ ์ค ์ ์๋ ๊ฒฝ์ฐ์ ์๋ ์ด 4๊ฐ์ง์ด๋ค.2๋ช ์ ํ์์๊ฒ ์ด ์ ์๋ ์์ฐ, 3๋ช ์ ํ์์๊ฒ ์ด ์ ์๋ ์์ฐ, 4๋ช ์ ํ์์๊ฒ ์ด ์ ์๋ ์์ฐ, 5๋ช ์ ํ์์๊ฒ ์ด ์ ์๋ ์์ฐ์ผ๋ก ๋๋ ์ ์๋ค. ์ด๋ ์ ์๋์ ์ต์ํ 1๊ฐ ์ด์์ ์ ๋ฌผ์ ์ด ์ ์๋ ์์ฐ์ด ์๊ธฐ ๋๋ฌธ์ 1๋ช ์ ํ์์๊ฒ ์ด ์ ์๋ ์์ฐ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ๋ ํ์์์ ์ ์ธํ ์ ์๋ค.
5๋ช ์ ํ์ ์ค์์ r๋ช ์ ๋ฝ๋ ์กฐํฉ์ ์ด์ฉํด์ผ ํ๋ ๋ฌธ์ ์ด๋ค. ์ด๋ r = 2, 3, 4, 5(๋ช ) ์์ผ๋ก ์ฆ๊ฐํ๊ณ r์ด ์ฆ๊ฐํ ๋๋ง๋ค 4๋ฒ์ ๋ฐ๋ณต๋ฌธ์ ์ํํ๋ ๋ค์ ์ธ๋ฑ์ค ์์๋ฅผ ์ฐธ์กฐํ๊ธฐ ์ํด ๊ฐ ๋ฐ๋ณต๋ฌธ์ ์ธ๋ฑ์ค ์ด๊ธฐ๊ฐ์ ์ด์ ์ธ๋ฑ์ค์ ์ด๊ธฐ๊ฐ์ 1์ ๊ฐ์ฐํด์ค์ผ ํ๋ค.
์์ฐ ํ๋๋ฅผ ๋๊ธฐ์ง ์๊ณ ์์ฐ์ ์ ๋ถ ์๋นํ์ ๋์ ํ์ ์๊ฐ ์ต๋ ๊ฐ์ด ๋๊ธฐ ๋๋ฌธ์ ๊ฐ ๊ฒฝ์ฐ์ ์กฐํฉ๋ค์ ํฉ์ฐ ๊ฐ์ ์์ฐ๊ณผ ๋น๊ตํด์ฃผ์๋ค. ์ ์๋์ ํ ์ํ์ ๋ํด์๋ง 50%์ ํ ์ธํ ์ ์๋ ์ฟ ํฐ์ด ์๊ธฐ ๋๋ฌธ์ ์กฐํฉ ์ค ๋ง์ง๋ง ์กฐํฉ์ ์ํ์ ๊ดํด์๋ง 0.5๋ฅผ ๊ณฑํด์ฃผ๊ณ ๋ฐฐ์ก๋น์ ํด๋นํ๋ ์ธ๋ฑ์ค ์์๋ฅผ ๋ณ๋๋ก ํฉ์ฐํด์ฃผ์ด ํด๋น ์กฐ๊ฑด์ ๋ง์กฑ์์ผฐ๋ค.
์ฝ๋
function solution(stu, budget, arr) {
let answer = [];
let sumArr = [];
for(let i = 0; i < arr.length; i++) {
let sum = 0;
for(let j = 0; j < arr[i].length; j++) {
sum += arr[i][j];
}
sumArr.push(sum);
}
for(let i = 0; i < arr.length; i++) {
for(let j = i + 1; j < arr.length; j++) {
if(sumArr[i] + ((arr[j][0] * 0.5) + (arr[j][1])) === 28) {
answer.push([arr[i], arr[j]]);
}
for(let z = j + 1; z < arr.length; z++) {
if(sumArr[i] + sumArr[j] + ((arr[z][0] * 0.5) + (arr[z][1])) ===28) {
answer.push([arr[i], arr[j], arr[z]]);
}
for(let h = z + 1; h < arr.length; h++) {
if(sumArr[i] + sumArr[j] + sumArr[z] + ((arr[h][0] * 0.5) + (arr[h][1])) === 28) {
answer.push([[arr[i], arr[j], arr[z], arr[h]]]);
}
for(let s = h + 1; s < arr.length; s++) {
if(sumArr[i] + sumArr[j] + sumArr[z] + sumArr[h] + ((arr[s][0] * 0.5) + (arr[s][1])) === 28) {
answer.push([arr[i], arr[j], arr[z], arr[h], arr[h], arr[s]]);
}
}
}
}
}
}
return answer[0][0].length;
}
let stu = 5;
let budget = 28;
let arr = [[6,6], [2,2], [4,3], [4,5], [10, 3]]
console.log(solution(stu, budget, arr));
์ค๋ต
50%์ ํ ์ธ ์ฟ ํฐ์ ์ด๋ ์ํ์ ์ ์ฉํ๋์ ๋ฐ๋ผ ์ ๋ฌผ์ ๋ฐ์ ์ ์๋ ํ์์ ์๊ฐ ๋ฌ๋ผ์ง๊ธฐ ๋๋ฌธ์ ์ด๋ค ์ํ์ ํ ์ธ์ ์ ์ฉํ ์ง๋ฅผ ๊ฒฝ์ฐ์ ์ ๊ธฐ์ค์ผ๋ก ์ก๋๋ค๋ฉด ์กฐํ ๋ฐ ์ฐธ์กฐ์ ๋ฐ๋ณต์ ์ค์ผ ์ ์๋ค.(์ฌ์ค์ 2๋ช ์ ํ์์๊ฒ ์ ๋ฌผ์ ๋๋ ์ค ์ ์๋ ๊ฒฝ์ฐ์ 5๋ช ์ ํ์์๊ฒ ์ ๋ฌผ์ ๋๋ ์ค ์ ์๋ ๊ฒฝ์ฐ๋ ๊ฒ์ฌํด๋ณด์ง ์์๋ ์์ฐ ๋ด์์ ๋ง์กฑํ ๋งํ ๋ต์ ์ฐพ์๋ด๊ธฐ๊ฐ ์ด๋ ต๊ธฐ ๋๋ฌธ์ ๋ถํ์ํ ์ฐ์ฐ ๊ณผ์ ์ด๋ผ๊ณ ์๊ฐํ๋ค)
๋ํ ์์ ํ์ด์์๋ ์์ฐ์ ์ ๋ถ ์ฌ์ฉํ์์ ๋๊ฐ ์ ๋ฌผ์ ๋๋ ์ค ์ ์๋ ํ์์ ์๊ฐ ๊ฐ์ฅ ๋ง๋ค๊ณ ๊ฐ์ ํ์์ง๋ง(์ค์ ์ ๋ต ๋ํ ์์ฐ 28์ ๋ชจ๋ ์๋นํ์ ๋ ์ ๋ฌผ์ ์ฌ ์ค ์ ์๋ ์ต๋ ํ์ ์๋ฅผ ์ฐพ์ ์ ์์๋ค) ์์ฐ๋ณด๋ค ๋ฎ์ ๊ธ์ก์์ ์ต๋ ํ์ ์๊ฐ ๋์ฌ ์๋ ์๊ธฐ ๋๋ฌธ์ ํฉ์ฐ์ด ์์ฐ๊ณผ ๊ฐ๋ค๋ ์กฐ๊ฑด์์ ํตํด ๋ต์ ์ฐพ๋ ๊ฒ์ ์ ํฉํ์ง ์๋ค.
์ด๋ ์ ๋ฌผ์ ์ค ์ ์๋ ์ต๋ ํ์ ์๋ฅผ ๊ตฌํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ฅ ์์ ๊ฐ์ ํ ์ธ์จ์ ์ ์ฉ์ํค๊ณ ์ดํ ์ต๋ํ์ผ๋ก ๋จ๊ธด ๊ธ์ก์ ๊ฐ์ง๊ณ ๋จ์ ์ํ๋ค์ ๊ตฌ๋งคํ ์ ์๋๋ก ํด์ผ ํ๊ธฐ ๋๋ฌธ์ ์ํ ๋ฆฌ์คํธ๋ฅผ Array.sort()๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์์ผ ์ฃผ์๋ค.
์ฝ๋
function solution(m, product) {
let answer = 0;
let n = product.length;
product.sort((a, b) => a[0] + a[1] - (b[0] + b[1]));
for (let i = 0; i < n; i++) {
let money = m - (product[i][0] / 2 + product[i][1]);
let cnt = 1;
for (let j = 0; j < n; j++) {
if (j !== i && product[j][0] + product[j][1] > money) break;
if (j !== i && product[j][0] + product[j][1] <= money) {
money -= product[j][0] + product[j][1];
cnt++;
}
}
answer = Math.max(answer, cnt);
}
return answer;
}
let arr = [
[6, 6],
[2, 2],
[4, 3],
[4, 5],
[10, 3]
];
console.log(solution(28, arr));
'์๊ณ ๋ฆฌ์ฆ > ํ๊ทธ ๋ณ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํฌํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ]๋ ๋ฐฐ์ด ํฉ์น๊ธฐ (0) | 2021.07.02 |
---|---|
[์์ ํ์]k๋ฒ์งธ ํฐ ์ (0) | 2021.07.01 |
[์์ ํ์]๋ฉํ ๋ง (0) | 2021.06.03 |
๋ค์ง์ ์์ (0) | 2021.06.01 |
์๋ฆฟ์์ ํฉ (0) | 2021.05.31 |