[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ๊ฐ์ด๋ฐ ๊ธ์ ๊ฐ์ ธ์ค๊ธฐ
๋ฌธ์ ์ค๋ช
๋จ์ด s์ ๊ฐ์ด๋ฐ ๊ธ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ๋ง๋ค์ด ๋ณด์ธ์. ๋จ์ด์ ๊ธธ์ด๊ฐ ์ง์๋ผ๋ฉด ๊ฐ์ด๋ฐ ๋๊ธ์๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
s | return |
---|---|
"abcde" | "c" |
"qwer" | "w,e" |
function solution(s) {
var sampleValue = Math.floor(s.length / 2);
var answer = "";
// ๋จ์ด s์ ๊ฐ์ด๋ฐ ๊ธ์๋ฅผ ๋ฐํํ๋ ํจ์,
// ๋จ์ด์ ๊ธธ์ด๊ฐ ์ง์๋ผ๋ฉด ๊ฐ์ด๋ฐ ๋๊ธ์๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค.
if (s.length % 2 != 1) answer = s.slice(sampleValue - 1, sampleValue + 1);
else answer = s.slice(sampleValue, sampleValue + 1);
return answer;
}
๊ตฌํ ์ ๊ทผ
1. ๊ฐ์ด๋ฐ ๊ธ์๋ฅผ ๋ฐํํ๊ธฐ ์ํด ํด๋น ๋ฌธ์์ด์ ๊ฐ์ด๋ฐ ๊ฐ์ ์ ์ ์๊ฒ sampleValue ๋ณ์์ Math.floor ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์์ด s์ ๊ธธ์ด๋ฅผ 2๋ก ๋๋ ๊ฐ์ ์ฃผ์๋ค.
2. if์กฐ๊ฑด์ ํตํด ์ง์, ํ์ ํ๋ณ ํ answer์๋ค slice ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ํด๋น ๋ฌธ์์ด์ ์ถ์ถํ ์ ์๊ฒ ํจ์๋ฅผ ๊ตฌํํจ.
๋ฌธ์ ์
๋ฌด์ธ๊ฐ ์ข ๋ ์ฝ๋๋ฅผ ๊น๋ํ๊ฒ ๋ง๋ค ์ ์์๊น ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ๋ณด์๋๋ฐ ์ธ์ ๊น์๋ ๊ฒ์,
๋ฌธ์์ด์ ํน์ ๊ธ์์ ์ ๊ทผํ๊ณ ์ถ์ ๋, ๋ฌธ์์ด์ [์ธ๋ฑ์ค]๋ฅผ ๋ฃ๊ฑฐ๋, (์ธ๋ฑ์ค) ๊ฐ์ ๋ฃ์ผ๋ฉด ์ํ๋ ๊ธ์๋ฅผ ์ถ์ถํ ์ ๊ฐ ์์๋ค.
(์๋ ์ถ์ฒ: ์๋ฐ์คํฌ๋ฆฝํธ ์ธํฌ)
#1
function solution(s) {
const mid = Math.floor(s.length/2);
return s.length %2 === 1 ? s[mid] : s[mid-1]+s[mid];
}
ํ์ด
1. floor ๋ฐฉ์์ ๋์ ๊ฐ์ด ์ค๊ฐ ๊ฐ์ ๊ตฌํ๊ธฐ ์ํ ๋ฐฉ์์ธ ๊ฒ ๊ฐ์๊ณ
2. ์ผํญ์ฐ์ฐ์์ ์กฐ๊ฑด์ ํตํด์ ํด๋นํ๋ ํน์ ๊ธ์๋ฅผ ์ป๊ธฐ ์ํด [ ]์์ ๋๋ ๋ณ์๋ฅผ ํ ๋นํ์ฌ ํจ์๋ฅผ ๊ตฌํํ ๊ฒ์ด ๋ด๊ฐ ์๊ฐํ์ ๋ ๊ฐ์ฅ ๊น๋ํ ๊ฒ ๊ฐ์๋ค.
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ์๋ฐ์๋ฐ์๋ฐ์๋ฐ์๋ฐ์?
๋ฌธ์ ์ค๋ช
๊ธธ์ด๊ฐ n์ด๊ณ , "์๋ฐ์๋ฐ์๋ฐ์...."์ ๊ฐ์ ํจํด์ ์ ์งํ๋ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ๋ค์ด n์ด 4์ด๋ฉด "์๋ฐ์๋ฐ"์ ๋ฆฌํดํ๊ณ 3์ด๋ผ๋ฉด "์๋ฐ์"๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
n | return |
---|---|
3 | "์๋ฐ์" |
4 | "์๋ฐ์๋ฐ" |
function solution(n) {
var repeat = "์๋ฐ";
var answer = repeat.repeat(n).slice(0, n);
return answer;
}
๊ตฌํ ์ ๊ทผ
1. ํด๋น ๋ฌธ์์ด์ด ๋ฐ๋ณต์ ํด์ผํ๋ ๊ทธ๋งํผ ๋ฐ๋ณตํ ์ ์๊ฒ repeat ๋ฉ์๋๋ฅผ ์ฌ์ฉํจ.
2. answer์๋ค ํด๋น ๋ฌธ์์ด ๋งํผ ์๋ผ์ค๋ค๋ฉด ์ํ๋ ๊ธธ์ด๋งํผ์ ๋ฐ๋ณต๋ ๋ฌธ์์ด์ด ๋ฐํ ๋จ.
ํ์ต
substring() ๋ฉ์๋๋ string ๊ฐ์ฒด์ ์์ ์ธ๋ฑ์ค๋ก ๋ถํฐ ์ข
๋ฃ ์ธ๋ฑ์ค ์ ๊น์ง ๋ฌธ์์ด์ ๋ถ๋ถ ๋ฌธ์์ด์ ๋ฐํํฉ๋๋ค.
slice() ๋ฉ์๋๋ ๋ฌธ์์ด์ ์ผ๋ถ๋ฅผ ์ถ์ถํ๋ฉด์ ์๋ก์ด ๋ฌธ์์ด์ ๋ฐํํฉ๋๋ค.
๊ฐ์ ๋งฅ๋ฝ์ด์ง๋ง substring ๋ฉ์๋๋ ์ด์ ๊ฐ์ ๊ธฐ๋ฅ์ผ๋ก์จ ์ฌ์ฉํ ์ ์์์ ์ธ์งํ๊ณ ์์.
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ๋ด์
๋ฌธ์ ์ค๋ช
๊ธธ์ด๊ฐ ๊ฐ์ ๋ 1์ฐจ์ ์ ์ ๋ฐฐ์ด a, b๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. a์ b์ ๋ด์ ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ด๋, a์ b์ ๋ด์ ์ a[0]b[0] + a[1]b[1] + ... + a[n-1]*b[n-1] ์ ๋๋ค. (n์ a, b์ ๊ธธ์ด)
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
a | b | result |
---|---|---|
[1,2,3,4] | [-3,-1,0,2] | 3 |
[-1,0,1] | [1,0,-1] | -2 |
function solution(a, b) {
var answer = [];
for (let i = 0; i < a.length; i++) {
answer.push(a[i] * b[i]);
}
return answer.reduce((a, c) => a + c, 0);
}
๊ตฌํ ์ ๊ทผ
1. ๊ฐ ์ธ์๋ณ ๋ฐฐ์ด์ ์ํํ๋ฉฐ ๊ฐ์ ์ง๋ผ๋ฆฌ ๊ณฑ์ ํด์ค์ผ ํ๊ธฐ์ for์ ํตํด ์ธ๋ฑ์ค ๋ณ๋ก ๊ณฑ์ ํ์.
2. ๊ณฑํ ๊ฐ์ answer์ push
3. push๋ ๋ฐฐ์ด์ reduce ํจ์๋ฅผ ํตํด ๋ชจ๋ ๋ํด ์ฃผ์๋ค.
๋ฌธ์ ์
1. ๊ตณ์ด reduce๋ฅผ ์ฌ์ฉํ์ง ์์๋ ๊ฐ๋ฅํ ์ํ์๋ค.
for๋ฅผ ์ฌ์ฉํ๋์ง reduce๋ง ์ฌ์ฉํ๋์ง ๊ฐ๋ฅํ ํจ์์๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด๋ฅผ ๋ณด๋ฉด์ ์ด๋ค ๋ฌธ์ ์๋์ง ์ดํด๋ณด์.
#1
function solution(a, b) {
var sum = 0;
for(var i=0; i<a.length; i++){
sum += a[i]*b[i];
}
return sum;
}
ํ์ด
1. sum์๋ค ๋ํ ๊ฐ์ ๋ฐ๋ก ํ ๋นํ๋ฉฐ ๋ฐฐ์ด๋ค์ ์ธ๋ฑ์ค ์๋ฆฌ๋จผํธ๋ฅผ ๊ณฑํ ๊ฐ์ ์ฌํ ๋น ํ๋ฉด reduce๋ฅผ ์ฌ์ฉํ์ง ์์๋ ๋ํ ๊ฐ์ ๋ฐํํ ์๊ฐ ์์๋ค.
์ฆ, ๊ตณ์ด ํจ์๋ฅผ ๋ ์ ์ฉํ ํ์๊ฐ ์์๋ค.
#2
function solution(a, b) {
return a.reduce((acc, _, i) => acc += a[i] * b[i], 0);
}
ํ์ด
1. reduce๋ง ์ฌ์ฉํ๋ค๋ฉด ์์ ๊ฐ์ด cur(ํ์ฌ ๊ฐ)์ ์ ์ธํ๊ณ i(์ธ๋ฑ์ค) ๋ง ์ํํ์ฌ ๋ํ ๊ฐ์ ๋ฐํํ ์ ์์์ ๊ฒ์ด๋ค.
function solution(a, b) {
var answer = a.reduce((a, _, i) => (a += a[i] * b[i]), 0);
return answer;
}
๋ฌธ์ ์
์์ ํจ์๋ฅผ ๊ธฐ๋ฅํ๋ฉด NaN์ด ๋์ค๊ฒ ๋๋๋ฐ ์๊ทธ๋ฐ์ง ์ดํดํ ์๊ฐ ์์์ด์ gpt์๊ฒ ๋ฌผ์ด ๋ณด์๋ค.
์ ๋ฌ ๋์ด์ผ ํ๋ ๋ณ์๋ ๋ฎ์ด์์ด์ง์ง ์๊ฒ ์ด๋ฆ์ ์ ์์ฑํด์ผ ํ ๊ฒ.