Jieunny์ ๋ธ๋ก๊ทธ
[JS] ํ๋ก๊ทธ๋๋จธ์ค - ํฐ์ผ๋ชฌ ๋ณธ๋ฌธ
๐ ๋ฌธ์
๋น์ ์ ํฐ์ผ๋ชฌ์ ์ก๊ธฐ ์ํ ์ค๋ ์ฌํ ๋์, ํ ๋ฐ์ฌ๋์ ์ฐ๊ตฌ์ค์ ๋์ฐฉํ์ต๋๋ค. ํ ๋ฐ์ฌ๋์ ๋น์ ์๊ฒ ์์ ์ ์ฐ๊ตฌ์ค์ ์๋ ์ด N ๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ ์ค์์ N/2๋ง๋ฆฌ๋ฅผ ๊ฐ์ ธ๊ฐ๋ ์ข๋ค๊ณ ํ์ต๋๋ค.
ํ ๋ฐ์ฌ๋ ์ฐ๊ตฌ์ค์ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ์ ๋ฐ๋ผ ๋ฒํธ๋ฅผ ๋ถ์ฌ ๊ตฌ๋ถํฉ๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ ๋ฒํธ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ์ฐ๊ตฌ์ค์ ์ด 4๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ด ์๊ณ , ๊ฐ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ ๋ฒํธ๊ฐ [3๋ฒ, 1๋ฒ, 2๋ฒ, 3๋ฒ]์ด๋ผ๋ฉด ์ด๋ 3๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ, 1๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ, 2๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ๊ฐ ์์์ ๋ํ๋
๋๋ค. ์ด๋, 4๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ ์ค 2๋ง๋ฆฌ๋ฅผ ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ด 6๊ฐ์ง๊ฐ ์์ต๋๋ค.
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ๋ ๋ฒ์งธ(1๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ์ธ ๋ฒ์งธ(2๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ๋ ๋ฒ์งธ(1๋ฒ), ์ธ ๋ฒ์งธ(2๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ๋ ๋ฒ์งธ(1๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ธ ๋ฒ์งธ(2๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
์ด๋, ์ฒซ ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ๊ณผ ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ ํ ์ข
๋ฅ(3๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ)์ ํฐ์ผ๋ชฌ๋ง ๊ฐ์ง ์ ์์ง๋ง, ๋ค๋ฅธ ๋ฐฉ๋ฒ๋ค์ ๋ชจ๋ ๋ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ง ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ ์์์์ ๊ฐ์ง ์ ์๋ ํฐ์ผ๋ชฌ ์ข
๋ฅ ์์ ์ต๋๊ฐ์ 2๊ฐ ๋ฉ๋๋ค.
๋น์ ์ ์ต๋ํ ๋ค์ํ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ง๊ธธ ์ํ๊ธฐ ๋๋ฌธ์, ์ต๋ํ ๋ง์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ํฌํจํด์ N/2๋ง๋ฆฌ๋ฅผ ์ ํํ๋ ค ํฉ๋๋ค. N๋ง๋ฆฌ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด nums๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, N/2๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ ์ค, ๊ฐ์ฅ ๋ง์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ ์ฐพ์, ๊ทธ๋์ ํฐ์ผ๋ชฌ ์ข
๋ฅ ๋ฒํธ์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
โ๏ธ ํ์ด
function solution(nums) {
var answer = 0;
let r = nums.length / 2;
let combinations = getCombinations(nums, r);
let notEqual = [];
let max = 0;
for(let i=0; i<combinations.length; i++){
let temp = [];
for(let j=0; j<combinations[i].length; j++){
if(temp.includes(combinations[i][j]) === false){
temp.push(combinations[i][j]);
}
}
notEqual.push(temp);
}
for(let i=0; i<notEqual.length; i++){
if(notEqual[i].length > max){
max = notEqual[i].length;
}
}
return max;
}
function getCombinations(n, r){
let result = [];
if(r === 1){
return n.map((el) => [el]);
}
n.forEach((fixed, idx, origin) => {
const rest = origin.slice(idx + 1);
const combinations = getCombinations(rest, r-1);
const attached = combinations.map((el) => [fixed, ...el]);
result.push(...attached);
});
return result;
}
โฐ ๋ช ํ ์คํธ์ผ์ด์ค์ ๋ต์ ๋์ค๋๋ฐ, ๋๋จธ์ง๋ ๋ฐํ์ ์๋ฌ ๋๋ค..๊ทธ๋์ ์ฐพ์ ๋ณด๋ ๋ชจ๋ ์กฐํฉ์ ๋ฐ์ง๋ ๋ฌธ์ ๊ฐ ์๋๋ผ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ์ ๊ทผํด์ผ ํ๋ ๋ฌธ์
๐จ ํฌ์ผ๋ชฌ์ด ์ด ๋ช ์ข ๋ฅ์ธ์ง, ๊ฐ์ ธ๊ฐ ์ ์๋ ํฌ์ผ๋ชฌ์ด ๋ช ๋ง๋ฆฌ์ธ์ง๋ง ๊ตฌํ๋ฉด ํด๊ฒฐ๋๋ ๋ฌธ์
function solution(nums) {
let kind;
let canBring;
let isContained = [];
let answer;
for(let pokemon of nums){
if(isContained.includes(pokemon) === false){
isContained.push(pokemon);
}
}
kind = isContained.length;
canBring = nums.length / 2;
answer = kind > canBring ? canBring : kind;
return answer;
}
โฐ ํฌ์ผ๋ชฌ ์ข ๋ฅ๊ฐ ๊ฐ์ ธ๊ฐ ์ ์๋ ์ ๋ณด๋ค ๋ง๋ค๋ฉด ๊ฐ์ ธ๊ฐ ์ ์๋ ๋งํผ๋ง ๋ค๋ฅธ ์ข ๋ฅ๋ฅผ ๊ฐ์ ธ๊ฐ๋ฉด ๋๊ณ
โฐ ํฌ์ผ๋ชฌ ์ข ๋ฅ๊ฐ ๊ฐ์ ธ๊ฐ ์ ์๋ ์ ๋ณด๋ค ์ ๋ค๋ฉด ๋ชจ๋ ์ข ๋ฅ๋ฅผ ๋ค ๊ฐ์ ธ๊ฐ๊ณ ์ค๋ณต์ผ๋ก ๊ฐ์ ธ๊ฐ ์ ์๋ค๋ ๋ป!
'Study > Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JS] ํ๋ก๊ทธ๋๋จธ์ค - ํฌ๊ธฐ๊ฐ ์์ ๋ถ๋ถ ๋ฌธ์์ด (0) | 2023.01.20 |
---|---|
[JS] ํ๋ก๊ทธ๋๋จธ์ค - ์ฝ๋ผ๋ฌธ์ (0) | 2023.01.20 |
[JS] ํ๋ก๊ทธ๋๋จธ์ค - 2016๋ (0) | 2023.01.19 |
[JS] ํ๋ก๊ทธ๋๋จธ์ค - ์ผ์ด์ฌ (์กฐํฉ ํ์ด๊ณผ์ ) (0) | 2023.01.18 |
[JS] ํ๋ก๊ทธ๋๋จธ์ค - ์ต์์ง์ฌ๊ฐํ (0) | 2023.01.17 |