[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ์์ ๋ํ๊ธฐ
๋ฌธ์ ์ค๋ช
์ด๋ค ์ ์๋ค์ด ์์ต๋๋ค. ์ด ์ ์๋ค์ ์ ๋๊ฐ์ ์ฐจ๋ก๋๋ก ๋ด์ ์ ์ ๋ฐฐ์ด absolutes์ ์ด ์ ์๋ค์ ๋ถํธ๋ฅผ ์ฐจ๋ก๋๋ก ๋ด์ ๋ถ๋ฆฌ์ธ ๋ฐฐ์ด signs๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ค์ ์ ์๋ค์ ํฉ์ ๊ตฌํ์ฌ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
absolutes | signs | result |
---|---|---|
[4,7,12] | [true,false,true] | 9 |
[1,2,3] | [false,false,true] | 0 |
function solution(absolutes, signs) {
var answer = absolutes;
//signs[i] ๊ฐ ์ฐธ์ด๋ฉด absolutes[i] ์ ์ค์ ์ ์๊ฐ ์์์์, ๊ทธ๋ ์ง ์์ผ๋ฉด ์์์์ ์๋ฏธํฉ๋๋ค.
for (let i = 0; i < signs.length; i++) {
if (signs[i] != true) absolutes[i] *= -1;
}
return answer.reduce((a, c) => a + c);
}
๊ตฌํ ์ ๊ทผ
1. answer ์๋ค absolutes ๋ฐฐ์ด์ ์ด๊ธฐํ
2. for ๋ฐ๋ณต์ ํตํด sign[i] false๋ฉด -1์ ๊ณฑํ ๊ฐ์ ์ฌ ํ ๋น
3. answer์ reduce ๋ฉ์๋๋ก ๋ชจ๋ ๋ํ ๊ฐ์ ๋ฐํ.
๋ฌธ์ ์
๋ง์ง๋ง return์ผ๋ก ๋ฉ์๋๋ฅผ ์ ์ฉํ์ฌ ๋ฐํํ๋ ์ต๊ด์ ๊ณ ์ณ๋ณด์.
๋ชจ๋ ๋ฆฌํด ๊ฐ์ด ๋ฉ์๋๋ฅผ ์ ์ฉํด์ ๋ฐํ๋๋ค๋ ๋ณด์ฅ์ด ์๊ธฐ ๋๋ฌธ์,,
#1
function solution(absolutes, signs) {
return absolutes.reduce((acc, val, i) => acc + (val * (signs[i] ? 1 : -1)), 0);
}
ํ์ด
1. reduce ๋ฉ์๋ ํจ์ ์ ์ฉ์ acc(๋์ฐ๊ฐ)+cur/val(ํ์ฌ๊ฐ)์ ๊ณฑํด์ฃผ๋ ์ฐ์ฐ ์ ์ฉ
2. ์ฐ์ฐ์ sign[i]? ์ผํญ ์กฐ๊ฑด์ ํตํด truthy๋ฉด 1์ ๊ณฑํ๊ณ falsy๋ฉด -1์ ๊ณฑํ๊ฒ ํจ.
3. ์ด๊ธฐ ๊ฐ 0์ ์ ์ฉํ์ฌ acc๊ฐ์ ๋ฐฐ์ด๋ก ๊ณ์ฐ๋์ง ์๊ฒ ์ ์ฉ.
#2
function solution(absolutes, signs) {
let answer = 0;
for (let i = 0; i < absolutes.length; i++) {
signs[i] ? answer += absolutes[i] : answer -= absolutes[i]
}
return answer;
}
ํ์ด
1. answer๋ฅผ 0์ผ๋ก ์ด๊ธฐํ
2. for ๋ฐ๋ณต๊ณผ ์ผํญ์ฐ์ฐ์๋ฅผ ํตํด signs[i]
์ธ๋ฑ์ค ๊ฐ์ด truthy๋ฉด answer์๋ค absolutes[i]๋ฅผ ๋ํ ๊ฐ์ ์ฌํ ๋น.
falsy๋ฉด absolutes[i] ๋บ ๊ฐ์ ์ฌํ ๋น.
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ์ ์ผ ์์ ์ ์ ๊ฑฐํ๊ธฐ
๋ฌธ์ ์ค๋ช
์ ์๋ฅผ ์ ์ฅํ ๋ฐฐ์ด, arr ์์ ๊ฐ์ฅ ์์ ์๋ฅผ ์ ๊ฑฐํ ๋ฐฐ์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ๋จ, ๋ฆฌํดํ๋ ค๋ ๋ฐฐ์ด์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ์ ๋ฐฐ์ด์ -1์ ์ฑ์ ๋ฆฌํดํ์ธ์. ์๋ฅผ๋ค์ด arr์ด [4,3,2,1]์ธ ๊ฒฝ์ฐ๋ [4,3,2]๋ฅผ ๋ฆฌํด ํ๊ณ , [10]๋ฉด [-1]์ ๋ฆฌํด ํฉ๋๋ค.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
absolutes | result |
---|---|
[4,3,2,1] | [4,3,2] |
[10] | [-1] |
function solution(arr) {
var answer = arr.sort((a, b) => b - a).slice(0, -1);
if (answer.length <= 1) answer.push(-1);
return answer;
}
๊ตฌํ ์ ๊ทผ
1. sort ๋ฉ์๋๋ฅผ ์ ์ฉํ์ฌ ์ต์ ๊ฐ์ด ์ ์ผ ๋ค๋ก ์ฌ ์์๊ฒ ์ ๋ ฌ
2. slice ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๊ฐ์ฅ ๋ง์ง๋ง ์ธ๋ฑ์ค ๊ฐ์ ์ถ์ถํ ๋ค ์ถ์ถ๋ ๋ฐฐ์ด ๋ฐํ.
3. if ์กฐ๊ฑด์ ํตํด answer์ ๊ธธ์ด๊ฐ 1์ดํ๊ฐ ๋๋ฉด -1์ ๋ฐฐ์ด๋ก ๋ฐํ.
๋ฌธ์ ์
์ด ๊ณผ์ ์์ sort๋ฅผ ์ด์ฉํ๊ฒ ๋๋ฉด ํ
์คํธ ์ผ์ด์ค๋ฅผ ํต๊ณผํ์ง ๋ชป ํจ.
๊ทธ ์ด์ ๋ฅผ ์ฐพ์๋ณด๋ ๋ฐํ ๋ return์ด ์ ๋ ฌ๋์ด ๋์ค๋ ๊ฒ์ด ์๋ ์ต์ ๊ฐ๋ง ์ถ์ถํ์ฌ ๋ฐฐ์ด ๊ทธ๋๋ก ๋ฐํํ๋ ์๊ตฌ์ฌํญ์ด์๋ค.
์ต์ ๊ฐ์ ๊ตฌํ ์ ์์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ๋ฌด์ ์์๊น ๊ณ ๋ฏผํ๋ค Math.min ๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ ํจ์๋ฅผ ๊ตฌํํ๋ฉด ๋ ๊ฒ ๊ฐ์๋ค.
๊ฐ์ ๋ ๋ฐฉ๋ฒ.
function solution(arr) {
var minValue = Math.min(...arr);
var answer = arr.filter((e) => e !== minValue);
if (answer.length === 0) answer.push(-1);
return answer;
}
๊ตฌํ ์ ๊ทผ
1. Math.min ๋ฉ์๋์ ์คํ๋ ๋ ๋ฌธ๋ฒ์ ํตํด min ์ธ์์ arr ๋ฐฐ์ด์ ์ ๋ฌ.
2. filter ๋ฉ์๋๋ฅผ ํตํด ํ
์คํธ๋ฅผ ํต๊ณผํ ๋ฐฐ์ด ๋ฐํ
3. if ์กฐ๊ฑด์์ answer๊ธธ์ด๊ฐ 0์ด๋ฉด -1 ๋ฐฐ์ด์ ํ ๋นํ์ฌ ๋ฐํ.
#1
function solution(arr) {
arr.splice(arr.indexOf(Math.min(...arr)),1);
if(arr.length<1)return[-1];
return arr;
}
ํ์ด
1.splice ๋ฉ์๋ ์์ splice ๋ฉ์๋์ start ๊ฐ์ผ๋ก ์ต๊ณ ๊ฐ์ผ๋ก ์ํด์๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์ start๋ฅผ ๊ธฐ์คํ๊ณ , ์ญ์ ํ ์์๋ฅผ 1๋ก ํ๋ฒ์ ์ค์ ํด๋ธ ๊ฒ์ ์ ์ ์์๋ค.
2. ๋ค์ if ์กฐ๊ฑด์ ํตํด ๋ฐฐ์ด์ [-1]์ ๋ฐํํ ์ ์๋๋ก ์ค์ ํ์๋ค.
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ์๋ ์ซ์ ๋ํ๊ธฐ
๋ฌธ์ ์ค๋ช
0๋ถํฐ 9๊น์ง์ ์ซ์ ์ค ์ผ๋ถ๊ฐ ๋ค์ด์๋ ์ ์ ๋ฐฐ์ด numbers๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. numbers์์ ์ฐพ์ ์ ์๋ 0๋ถํฐ 9๊น์ง์ ์ซ์๋ฅผ ๋ชจ๋ ์ฐพ์ ๋ํ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
numbers | result |
---|---|
[1,2,3,4,6,7,8,0] | 14 |
[5,8,4,0,6,7,9] | 6 |
function solution(numbers) {
var answer = [];
var setArr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (let i = 0; i <= setArr.length; i++) {
if (setArr.indexOf([i]) != numbers.indexOf([i])) answer.push(setArr[i]);
}
return answer;
๊ตฌํ ์ ๊ทผ
1. ๋น๊ตํ ๋๋จธ์ง ๊ฐ์ ๋ด์ ๋น ๋ฐฐ์ด answer์ ๋ชจ๋ ๋ฐฐ์ด์ ๊ฐ์ง setArr๋ฅผ ์ ์ธ
2. ํด๋น ๋ฐฐ์ด์ ์ํํ์ฌ ๋น๊ตํ๋ ๋ฐฐ์ด๊ณผ ์ํํ๋ ๋ฐฐ์ด ์์์ ์กด์ฌํ์ง ์๋ ๊ฐ ์ถ์ถํ๊ธฐ ์ํด
์ฒ์์ filter ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ์ ๊ทผํ๋ ค ํ๋๋ฐ ์ํ๋ ๊ฐ์ด ๋์ค์ง ์์ indexOf ๋ฉ์๋๋ฅผ ์ฌ์ฉ.
๊ทธ๋ฌ๋ ๋ ํจ์์์ ๊ณ์ํด์ ์ธ๋ฑ์ค๋ฅผ ๋น๊ตํ ๊ฐ๋ง ๋ฐํ๋์ด ์์๋ฅผ ๋น๊ตํ๊ธฐ ์ํด์ ์ด๋ค ๋ฉ์๋๊ฐ ํ์ํ์ง gpt์๊ฒ ๋ฌผ์ด๋ดค๋ค,,
gpt๋ ๋ฐฐ์ด์ ์์๋ฅผ ๋น๊ตํ๊ธฐ ์ใ ฃํด์๋ includes( )๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค๊ณ ํ๋ค.
MDN์์๋ includes() ๋ฉ์๋๋ ๋ฐฐ์ด์ด ํน์ ์์๋ฅผ ํฌํจํ๊ณ ์๋์ง ํ๋ณํฉ๋๋ค.
๋ผ๊ณ ๋์ ์์๋ค,,
์ข ๋ ์ฐพ์๋ณด๊ณ ๋ฌธ์ ๋ฅผ ํด๊ฒฐ ํ ๋ฅ๋ ฅ์ ๊ธธ๋ฌ์ผ ๋๊ฒ ๋ค..
ํ์ง๋ง ์ด๋ ๊ฒ๋ง ๋๋ด๊ธฐ์ ๋๋ฌด ์์ฌ์ ๊ธฐ์กด์ ์ ์ฉํ๊ณ ์ถ์๋ filter ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ includes ๋ฉ์๋์ ํจ๊ป ์ ์ฉํ๋ฉด ๋ฌธ์ ๊ฐ ํด๊ฒฐ๋ ๊ฒ ๊ฐ์์ ์ ์ฉ ํด๋ณด์๋ค.
๊ทธ๋ ๊ฒ ๊ฐ์ ํ๊ฒ ๋ ์ฝ๋!
function solution(numbers) {
var setArr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
var answer = setArr.filter((e, i) => !numbers.includes(setArr[i]));
// filter์ e๋ ์๋ฆฌ๋จผํธ ์ด๋ฏ๋ก number.includes์์ number ๋ฐฐ์ด์ ํฌํจ๋์ง ์๋ ์ธ๋ฑ์ค ์์น ๋ฅผ ๋ฐํ.
return answer.reduce((a, c) => a + c);
}
filter() ๋ฉ์๋๋ ์ฃผ์ด์ง ํจ์์ ํ ์คํธ๋ฅผ ํต๊ณผํ๋ ๋ชจ๋ ์์๋ฅผ ๋ชจ์ ์๋ก์ด ๋ฐฐ์ด๋ก ๋ฐํํฉ๋๋ค.
์ ์ฉ ๋ฐฉ์์
arr.filter(callback(element[, index[, array]])[, thisArg])
Copy to Clipboard
์ฒซ ๋ฒ์งธ ์ธ์๋ก ๋ฐฐ์ด์ element๋ฅผ ์ํํ์ฌ ๋๊ณ , ๋ ๋ฒ์งธ ์ธ์๋ก index๋ฅผ ๋์์ ๊ฐ์ ๋น๊ตํ๋ ๊ตฌ๋ฌธ์ด๋ค.
function solution(numbers) {
var setArr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
var answer = setArr.filter((e) => !numbers.includes(setArr[e]));
// filter์ e๋ ์๋ฆฌ๋จผํธ ์ด๋ฏ๋ก number.includes์์ number ๋ฐฐ์ด์ ํฌํจ๋์ง ์๋ ์ธ๋ฑ์ค ์์น ๋ฅผ ๋ฐํ.
// [4, 8]
return answer.reduce((a, c) => a + c);
}
์ฒ์ filter๋ฅผ ์ ์ฉํ์ฌ ์ํํ ๋ ์ธ์์ e๊ฐ๋ง ์ ์ฉ๋์ด ๋ฐํ๋ ๊ฐ์ด ๊ณ์ํด์ [4,8]์ด๊ธธ๋ ์์ง ์ถ์๋๋ฐ, ํด๋น element๊ฐ ์ํ ์ธ๋ฑ์ค์ ์๋ฆฌ ๊ฐ์ ์๋ ค์ฃผ๋ ๊ฒ์ด์๋ค.
๊ทธ๋ ๊ฒ ๊ฐ์ ๋ ์ฝ๋์์๋
var answer = setArr.filter((e,i) => !numbers.includes(setArr[i]));
// [5, 9]
์ธ๋ฑ์ค๋ฅผ ์ํํ์ฌ ํด๋น ์ธ๋ฑ์ค์ ์ํด์๋ element๊ฐ์ ๋ฐํํ๊ฒ ๋๋
์ํ๋ [5,9] ๊ฒฐ๊ณผ ๊ฐ์ ์ป๊ฒ ๋์๋ค.
#1
function solution(numbers) {
return 45 - numbers.reduce((cur, acc) => cur + acc, 0);
}
ํ์ด
1. ๋น๊ต ๋์์ธ ์ ์ฒด ๋ฐฐ์ด์ ์ดํฉ์์ ๋น๊ตํด์ผ ๋ ๋ฐฐ์ด์ ์ดํฉ์ ๋นผ๊ฒ๋๋ฉด ์ํ๋ ๋๋จธ์ง ๊ฐ์ ์ป๊ฒ ๋๋ ๊ฒ์ด์๋ค,, (์ฒ์ฌ์ธ๊ฐ..)
#2
function solution(numbers) {
let answer = 0;
for(let i = 0; i <= 9; i++) {
if(!numbers.includes(i)) answer += i;
}
return answer;
}
ํ์ด
1. gpt์์ ์๋ ค์ค ๊ฒ ์ฒ๋ผ ๋๋ถ๋ถ์ ์ฌ๋๋ค์
ํน์ ์์ ๊ฐ์ ๋น๊ตํ๊ธฐ ์ํด includes( ) ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์ ์ ์์๋ค.