Last Update: 2019-12-22
- Level 1 ์ฐ์ต๋ฌธ์ (1) ๋ฐ๋ก๊ฐ๊ธฐ
- Level 1 ์ฐ์ต๋ฌธ์ (2) ๋ฐ๋ก๊ฐ๊ธฐ
- Level 1 ์ฐ์ต๋ฌธ์ (3)
ํ๋ก๊ทธ๋๋จธ์ค์ Level1 ๋ฌธ์ ๋ค์ค ์ฐ์ต๋ฌธ์ ๋ผ๋ ์นดํ
๊ณ ๋ฆฌ์ ๋ฌธ์ ๋ค์ ๋ค๋ฅธ ๋ฌธ์ ๋ค์ ๋นํด ์ฌ์ด ํธ์ด๋ ์ฌ๋ฌ ๊ธ์ ๋๋ ์ฐ์ง ์๊ณ ์ด๋ฒ ๊ธ์ ์ญ ์ ์ด ๋ณผ ์๊ฐ์ด๋ค. ๋ชป ํผ๊ฑด ๋ฌผ๋ก ์์ ์.
์ ์ผ ์์ ์ ์ ๊ฑฐํ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
์ ์๋ฅผ ์ ์ฅํ ๋ฐฐ์ด, arr ์์ ๊ฐ์ฅ ์์ ์๋ฅผ ์ ๊ฑฐํ ๋ฐฐ์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ๋จ, ๋ฆฌํดํ๋ ค๋ ๋ฐฐ์ด์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ์ ๋ฐฐ์ด์ -1์ ์ฑ์ ๋ฆฌํดํ์ธ์. ์๋ฅผ๋ค์ด arr์ด [4,3,2,1]์ธ ๊ฒฝ์ฐ๋ [4,3,2]๋ฅผ ๋ฆฌํด ํ๊ณ , [10]๋ฉด [-1]์ ๋ฆฌํด ํฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- arr์ ๊ธธ์ด 1 ์ด์์ธ ๋ฐฐ์ด์ ๋๋ค.
- ์ธ๋ฑ์ค i, j์ ๋ํด i โ j์ด๋ฉด arr[i] โ arr[j] ์ ๋๋ค.
์ ์ถ๋ ฅ ์
| arr | return |
|---|---|
| [4,3,2,1] | [4,3,2] |
| [10 | [-1] |
ํ์ด
function solution(arr) {
if (arr.length <= 1) {
return [-1];
}
var min = Math.min(...arr);
var index = arr.indexOf(min);
arr.splice(index, 1);
return arr;
}
๋ฐฐ์ด์์ ๊ฐ์ฅ ์์ ๊ฐ์ ๊ตฌํ๋ค ๋ง๊ทธ๋๋ก ์ ๊ฑฐํด์ฃผ๋ฉด ๋๋ค. ๋ฑํ ์ด๋ ต์ง ์๋ค.
์ง์์ ํ์
๋ฌธ์ ๋ณด๊ธฐ
์ ์ num์ด ์ง์์ผ ๊ฒฝ์ฐ โEvenโ์ ๋ฐํํ๊ณ ํ์์ธ ๊ฒฝ์ฐ โOddโ๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- num์ int ๋ฒ์์ ์ ์์ ๋๋ค.
- 0์ ์ง์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| num | return |
|---|---|
| 3 | โOddโ |
| 4 | โEvenโ |
ํ์ด
function solution(num) {
return num % 2 === 0 ? "Even" : "Odd";
}
์ฝ๋ผ์ธ ์ถ์ธก
๋ฌธ์ ๋ณด๊ธฐ
1937๋ Collatz๋ ์ฌ๋์ ์ํด ์ ๊ธฐ๋ ์ด ์ถ์ธก์, ์ฃผ์ด์ง ์๊ฐ 1์ด ๋ ๋๊น์ง ๋ค์ ์์ ์ ๋ฐ๋ณตํ๋ฉด, ๋ชจ๋ ์๋ฅผ 1๋ก ๋ง๋ค ์ ์๋ค๋ ์ถ์ธก์ ๋๋ค. ์์ ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1-1. ์ ๋ ฅ๋ ์๊ฐ ์ง์๋ผ๋ฉด 2๋ก ๋๋๋๋ค.
1-2. ์ ๋ ฅ๋ ์๊ฐ ํ์๋ผ๋ฉด 3์ ๊ณฑํ๊ณ 1์ ๋ํฉ๋๋ค.
2. ๊ฒฐ๊ณผ๋ก ๋์จ ์์ ๊ฐ์ ์์ ์ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณตํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ์ ๋ ฅ๋ ์๊ฐ 6์ด๋ผ๋ฉด 6โ3โ10โ5โ16โ8โ4โ2โ1 ์ด ๋์ด ์ด 8๋ฒ ๋ง์ 1์ด ๋ฉ๋๋ค. ์ ์์ ์ ๋ช ๋ฒ์ด๋ ๋ฐ๋ณตํด์ผํ๋์ง ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ์ฃผ์ธ์. ๋จ, ์์ ์ 500๋ฒ์ ๋ฐ๋ณตํด๋ 1์ด ๋์ง ์๋๋ค๋ฉด โ1์ ๋ฐํํด ์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- ์
๋ ฅ๋ ์,
num์ 1 ์ด์ 8000000 ๋ฏธ๋ง์ธ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | result |
|---|---|
| 6 | 8 |
| 16 | 4 |
| 626331 | -1 |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ #1
๋ฌธ์ ์ ์ค๋ช ๊ณผ ๊ฐ์ต๋๋ค. - ์
์ถ๋ ฅ ์ #2
16 -> 8 -> 4 -> 2 -> 1 ์ด๋์ด ์ด 4๋ฒ๋ง์ 1์ด ๋ฉ๋๋ค. - ์
์ถ๋ ฅ ์ #3
626331์ 500๋ฒ์ ์๋ํด๋ 1์ด ๋์ง ๋ชปํ๋ฏ๋ก -1์ ๋ฆฌํดํด์ผํฉ๋๋ค.
ํ์ด
function solution(num) {
let cnt = 0;
while (true) {
// ์ซ์๊ฐ 1์ด๋๋ฉด ์ข
๋ฃ
if (num === 1) {
return cnt;
}
// ์์
์ 500๋ฒ ์ด์ ๋ฐ๋ณตํ์ผ๋ฉด ์ข
๋ฃ
if (cnt >= 500) {
return -1;
}
if (num % 2 === 0) {
num /= 2;
} else {
num = num * 3 + 1;
}
cnt++;
}
}
1์ด ๋์์ ๋์, 500๋ฒ ์ด์ ๋ฐ๋ณตํ์ ๊ฒฝ์ฐ๋ง ์์ธ์ฒ๋ฆฌ ํด์ฃผ๋ฉด ๊ฐ๋จํ๊ฒ ์ฃผ์ด์ง ๋ฌธ์ ๋๋ก ์์ ์ฐ๊ณ ํด๊ฒฐ ๊ฐ๋ฅ.
ํ๊ท ๊ตฌํ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
์ ์๋ฅผ ๋ด๊ณ ์๋ ๋ฐฐ์ด arr์ ํ๊ท ๊ฐ์ returnํ๋ ํจ์, solution์ ์์ฑํด๋ณด์ธ์.
์ ํ ์กฐ๊ฑด
- arr์ ๊ธธ์ด 1 ์ด์, 100 ์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค.
- arr์ ์์๋ -10,000 ์ด์ 10,000 ์ดํ์ธ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| arr | return |
|---|---|
| [1,2,3,4] | 2.5 |
| [5,5] | 5 |
ํ์ด
function solution(arr) {
return (
arr.reduce((acc, curr) => {
return acc + curr;
}) / arr.length
);
}
๋ฐฐ์ด ๊ฐ ์์์ ํฉ / ๋ฐฐ์ด์ ๊ธธ์ด. reduce ํจ์๋ ์ ๋ง ์ ์ฉํ๋ ์ ์์๋๋๋ก ํ์.
ํ์ค๋ ์
๋ฌธ์ ๋ณด๊ธฐ
์์ ์ ์ x๊ฐ ํ์ค๋ ์์ด๋ ค๋ฉด x์ ์๋ฆฟ์์ ํฉ์ผ๋ก x๊ฐ ๋๋์ด์ ธ์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 18์ ์๋ฆฟ์ ํฉ์ 1+8=9์ด๊ณ , 18์ 9๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 18์ ํ์ค๋ ์์ ๋๋ค. ์์ฐ์ x๋ฅผ ์ ๋ ฅ๋ฐ์ x๊ฐ ํ์ค๋ ์์ธ์ง ์๋์ง ๊ฒ์ฌํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
x๋ 1 ์ด์, 10000 ์ดํ์ธ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| arr | return |
|---|---|
| 10 | true |
| 12 | true |
| 11 | false |
| 13 | false |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ #1
10์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 1์ ๋๋ค. 10์ 1๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 10์ ํ์ค๋ ์์ ๋๋ค. - ์
์ถ๋ ฅ ์ #2
12์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 3์ ๋๋ค. 12๋ 3์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 12๋ ํ์ค๋ ์์ ๋๋ค. - ์
์ถ๋ ฅ ์ #3
11์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 2์ ๋๋ค. 11์ 2๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ผ๋ฏ๋ก 11๋ ํ์ค๋ ์๊ฐ ์๋๋๋ค. - ์
์ถ๋ ฅ ์ #4
13์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 4์ ๋๋ค. 13์ 4๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ผ๋ฏ๋ก 13์ ํ์ค๋ ์๊ฐ ์๋๋๋ค.
ํ์ด
function solution(x) {
var sum = 0;
var num = x;
while (num > 0) {
sum += num % 10;
num = parseInt(num / 10);
}
return x % sum === 0;
}
๊ฒฐ๋ก ์ ์ผ๋ก๋ x๋ฅผ ๊ฐ ์๋ฆฟ์์ ํฉ์ผ๋ก ๋๋ ๊ฐ์ด 0์ธ์ง๋ง ๊ตฌํ๋ฉด ๋๋ค. ๊ฐ ์๋ฆฟ์์ ํฉ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ Level 1 ์ฐ์ต๋ฌธ์ (2) - ์๋ฆฟ์ ๋ํ๊ธฐ๋ฅผ ์ฐธ๊ณ ํ๋ฉด ๋๋ค.
ํธ๋ํฐ ๋ฒํธ ๊ฐ๋ฆฌ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค ๋ชจ๋ฐ์ผ์ ๊ฐ์ธ์ ๋ณด ๋ณดํธ๋ฅผ ์ํด ๊ณ ์ง์๋ฅผ ๋ณด๋ผ ๋ ๊ณ ๊ฐ๋ค์ ์ ํ๋ฒํธ์ ์ผ๋ถ๋ฅผ ๊ฐ๋ฆฝ๋๋ค.
์ ํ๋ฒํธ๊ฐ ๋ฌธ์์ด phone_number๋ก ์ฃผ์ด์ก์ ๋, ์ ํ๋ฒํธ์ ๋ท 4์๋ฆฌ๋ฅผ ์ ์ธํ ๋๋จธ์ง ์ซ์๋ฅผ ์ ๋ถ *์ผ๋ก ๊ฐ๋ฆฐ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- s๋ ๊ธธ์ด 4 ์ด์, 20์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
์ ์ถ๋ ฅ ์
| phone_number | return |
|---|---|
| 01033334444 | *******4444 |
| 027778888 | *****8888 |
ํ์ด
function solution(phone_number) {
return "*".repeat(phone_number.length - 4) + phone_number.slice(-4);
}
๊ธฐ๋ณธ์ ์ถฉ์คํ๋ค๊ณ ์๊ฐํจ.
ํ๋ ฌ์ ๋ง์
๋ฌธ์ ๋ณด๊ธฐ
ํ๋ ฌ์ ๋ง์ ์ ํ๊ณผ ์ด์ ํฌ๊ธฐ๊ฐ ๊ฐ์ ๋ ํ๋ ฌ์ ๊ฐ์ ํ, ๊ฐ์ ์ด์ ๊ฐ์ ์๋ก ๋ํ ๊ฒฐ๊ณผ๊ฐ ๋ฉ๋๋ค. 2๊ฐ์ ํ๋ ฌ arr1๊ณผ arr2๋ฅผ ์ ๋ ฅ๋ฐ์, ํ๋ ฌ ๋ง์ ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- ํ๋ ฌ arr1, arr2์ ํ๊ณผ ์ด์ ๊ธธ์ด๋ 500์ ๋์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
| arr1 | arr2 | return |
|---|---|---|
| [[1,2],[2,3]] | [[3,4],[5,6]] | [[4,6],[7,9]] |
| [[1],[2]] | [[3],[4]] | [[4],[6]] |
ํ์ด
function solution(arr1, arr2) {
return arr1.map((arr, i) => {
return arr.map((value, j) => {
return value + arr2[i][j];
});
});
}
ํ๋ ฌ๋ฌธ์ ๋ ์ค๋ธ์ ํธ๋ ์ด์ค ๋ฐฐ์ด์ ๋ค๋ฃจ๋ ๋ฌธ์ ๋ก ์์ฃผ ์ถ์ ๋๋ ๊ฒ ๊ฐ๋ค. ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฌธ์ ์ด๊ธฐ๋ ํ ๋ฏ?
x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์
๋ฌธ์ ๋ณด๊ธฐ
ํจ์ solution์ ์ ์ x์ ์์ฐ์ n์ ์ ๋ ฅ ๋ฐ์, x๋ถํฐ ์์ํด x์ฉ ์ฆ๊ฐํ๋ ์ซ์๋ฅผ n๊ฐ ์ง๋๋ ๋ฆฌ์คํธ๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ๋ค์ ์ ํ ์กฐ๊ฑด์ ๋ณด๊ณ , ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- x๋ -10000000 ์ด์, 10000000 ์ดํ์ธ ์ ์์ ๋๋ค.
- n์ 1000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| x | n | answer |
|---|---|---|
| 2 | 5 | [2,4,6,8,10] |
| 4 | 3 | [4,8,12] |
| -4 | 2 | [-4, -8] |
ํ์ด
function solution(x, n) {
var answer = [];
for (let i = 0; i < n; i++) {
answer.push((i + 1) * x);
}
return answer;
}
x์ ๋ฐฐ์๋ก ์ด๋ฃจ์ด์ง ๊ธธ์ด n๋งํผ์ ๋ฐฐ์ด์ ๋ง๋ค๋ฉด ๋๋ค.
์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์
๋ฌธ์ ๋ณด๊ธฐ
๋ ์๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ ์์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ๋ณด์ธ์. ๋ฐฐ์ด์ ๋งจ ์์ ์ต๋๊ณต์ฝ์, ๊ทธ๋ค์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฃ์ด ๋ฐํํ๋ฉด ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ ์ 3, 12์ ์ต๋๊ณต์ฝ์๋ 3, ์ต์๊ณต๋ฐฐ์๋ 12์ด๋ฏ๋ก solution(3, 12)๋ [3, 12]๋ฅผ ๋ฐํํด์ผ ํฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- ๋ ์๋ 1์ด์ 1000000์ดํ์ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | m | return |
|---|---|---|
| 3 | 12 | [3, 12] |
| 2 | 5 | [1, 10] |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ #1
์์ ์ค๋ช ๊ณผ ๊ฐ์ต๋๋ค. - ์
์ถ๋ ฅ ์ #2
์์ฐ์ 2์ 5์ ์ต๋๊ณต์ฝ์๋ 1, ์ต์๊ณต๋ฐฐ์๋ 10์ด๋ฏ๋ก [1, 10]์ ๋ฆฌํดํด์ผ ํฉ๋๋ค.
ํ์ด
function solution(n, m) {
var answer = [];
answer[0] = gcd(n, m);
answer[1] = (n * m) / answer[0];
return answer;
}
function gcd(a, b) {
if (a < b) {
[a, b] = [b, a];
}
if (a % b === 0) {
return b;
}
return gcd(b, a % b);
}
์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ์ด์ฉํ ๋ฌธ์ ํ์ด๋ ์๋นํ ์์ฃผ ์ถ์ ๋๋ค๊ณ ํ๋ค. ์ด๋ฌํ ํ์ด๋ ์์ฃผ ์ ํ๊ฒ ๋ ํ
๋ ๊ผญ ์์๋ฌ์ผ๊ฒ ๋ค. ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ด๋ผ๋ ์๊ณ ๋ฆฌ์ฆ์ด ์๋๋ฐ ์ด ๋ฐฉ๋ฒ์ ์ด์ฉํด ํ์ด ๋ณด์๋ค.
- ์ต๋๊ณต์ฝ์
- ํฐ ์(n)๋ฅผ ์์ ์(m)๋ก ๋๋ ๋๋จธ์ง ๊ฐ์ด 0์ด ๋์ผ ํจ
- ๋๋ ๋๋จธ์ง ๊ฐ์ด 0์ด๋ผ๋ฉด m์ด ์ต๋๊ณต์ฝ์
- 0์ด ์๋๋ผ๋ฉด, ํฐ์๋ m, ์์์๋ n % m์ผ๋ก ๋ฐ๋ณต.
- ์ต์๊ณต๋ฐฐ์
- ๋ ์์ ๊ณฑ / ์ต๋๊ณต์ฝ์
level1์ ์ฐ์ต๋ฌธ์ ๋ค์ ํ์ด๋ณด์๋ค. ๋ชป ํผ๊ฒ๋ ์๊ณ ์ฝ๊ฒ ํผ ๊ฒ๋ ์๊ณ ์ฐพ์๋ณธ ๊ฒ๋ ์๊ณ ๋ค์ํ์๋ฏผ, ์ค์ ์ฝ๋ฉํ ์คํธ๋ฅผ ๋น๋์ด๋ณด๋ฉด ์ด ์ ๋ ์์ค์ ์์ฃผ ๊ธฐ์ด ๋จ๊ณ์ ๋ฌธ์ ๋ค์ด๋ผ๊ณ ํ ์ ์๋๋ฐ, ์ด๋ฐ ๋ฌธ์ ๋ค๋ ์ ๋ชปํธ๋ ๊ฑธ ๋๊ผ๋ค. ๋ฒผ๋ฝ์น๊ธฐ๊ฐ ์๋๋ผ ๊พธ์คํ ๊ณ์ ๊ด์ฌ์ ๊ฐ์ง๊ณ ํ์์๋ ๊ณต๋ถํ๋ ์ต๊ด์ ๋ค์ฌ์ผ๊ฒ ๋ค.