Last Update: 2019-12-17
- Level 1 ์ฐ์ต๋ฌธ์ (1)
- Level 1 ์ฐ์ต๋ฌธ์ (2) ๋ฐ๋ก๊ฐ๊ธฐ
- Level 1 ์ฐ์ต๋ฌธ์ (3) ๋ฐ๋ก๊ฐ๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค์ Level1 ๋ฌธ์ ๋ค์ค ์ฐ์ต๋ฌธ์ ๋ผ๋ ์นดํ
๊ณ ๋ฆฌ์ ๋ฌธ์ ๋ค์ ๋ค๋ฅธ ๋ฌธ์ ๋ค์ ๋นํด ์ฌ์ด ํธ์ด๋ ์ฌ๋ฌ ๊ธ์ ๋๋ ์ฐ์ง ์๊ณ ์ด๋ฒ ๊ธ์ ์ญ ์ ์ด ๋ณผ ์๊ฐ์ด๋ค. ๋ชป ํผ๊ฑด ๋ฌผ๋ก ์์ ์.
2016๋
๋ฌธ์ ๋ณด๊ธฐ
2016๋
1์ 1์ผ์ ๊ธ์์ผ์
๋๋ค. 2016๋
a์ b์ผ์ ๋ฌด์จ ์์ผ์ผ๊น์? ๋ ์ a ,b๋ฅผ ์
๋ ฅ๋ฐ์ 2016๋
a์ b์ผ์ด ๋ฌด์จ ์์ผ์ธ์ง ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์์ผ์ ์ด๋ฆ์ ์ผ์์ผ๋ถํฐ ํ ์์ผ๊น์ง ๊ฐ๊ฐ SUN, MON, TUE, WED, THU, FRI, SAT
์ ๋๋ค. ์๋ฅผ ๋ค์ด a=5, b=24๋ผ๋ฉด 5์ 24์ผ์ ํ์์ผ์ด๋ฏ๋ก ๋ฌธ์์ด โTUEโ๋ฅผ ๋ฐํํ์ธ์.
์ ํ ์กฐ๊ฑด
- 2016๋ ์ ์ค๋ ์ ๋๋ค.
- 2016๋ a์ b์ผ์ ์ค์ ๋ก ์๋ ๋ ์ ๋๋ค. (13์ 26์ผ์ด๋ 2์ 45์ผ๊ฐ์ ๋ ์ง๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค)
์ ์ถ๋ ฅ ์
| a | b | result |
|---|---|---|
| 5 | 24 | TUE |
ํ์ด
function solution(a, b) {
var answer = "";
var days = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
answer = days[new Date(2016, a - 1, b).getDay()];
return answer;
}
์ ํ ์กฐ๊ฑด์ ์ค๋ ์ด๋ผ๋ ์กฐ๊ฑด๋๋ฌธ์ ํผ๋์ค๋ฌ์ธ ๋ป ํ์ผ๋, ๊ทธ๋ฅ ๊ตฌํ๋ฉด ๋จ.
๊ฐ์ด๋ฐ ๊ธ์ ๊ฐ์ ธ์ค๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
๋จ์ด s์ ๊ฐ์ด๋ฐ ๊ธ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ๋ง๋ค์ด ๋ณด์ธ์. ๋จ์ด์ ๊ธธ์ด๊ฐ ์ง์๋ผ๋ฉด ๊ฐ์ด๋ฐ ๋๊ธ์๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค.
์ ํ์ฌํญ
- s๋ ๊ธธ์ด๊ฐ 1 ์ด์, 100์ดํ์ธ ์คํธ๋ง์ ๋๋ค.
์ ์ถ๋ ฅ ์
| s | return |
|---|---|
| abcde | c |
| qwer | we |
ํ์ด
function solution(s) {
var answer = "";
var length = s.length;
answer = s.substr(Math.ceil(length / 2) - 1, length % 2 === 0 ? 2 : 1);
return answer;
}
๊ฐ์ ์ซ์๋ ์ซ์ด
๋ฌธ์ ๋ณด๊ธฐ
๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค. ๋จ, ์ ๊ฑฐ๋ ํ ๋จ์ ์๋ค์ ๋ฐํํ ๋๋ ๋ฐฐ์ด arr์ ์์๋ค์ ์์๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด,
- arr = [1, 1, 3, 3, 0, 1, 1] ์ด๋ฉด [1, 3, 0, 1] ์ return ํฉ๋๋ค.
- arr = [4, 4, 4, 3, 3] ์ด๋ฉด [4, 3] ์ return ํฉ๋๋ค.
๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ์ ๊ฑฐํ๊ณ ๋จ์ ์๋ค์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ์ฌํญ
- ๋ฐฐ์ด arr์ ํฌ๊ธฐ : 1,000,000 ์ดํ์ ์์ฐ์
- ๋ฐฐ์ด arr์ ์์์ ํฌ๊ธฐ : 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ 9๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์
์ ์ถ๋ ฅ ์
| arr | answer |
|---|---|
| [1,1,3,3,0,1,1] | [1,3,0,1] |
| [4,4,4,3,3] | [4,3] |
ํ์ด
function solution(arr) {
var answer = arr.filter((item, index) => {
return item !== arr[index + 1];
});
return answer;
}
์ฐ์๋ ์ซ์๋ง ์ ๊ฑฐํ๋ฉด ๋๋ฏ๋ก, ๋ค์ ์์๋ง ๋น๊ตํด๋๊ฐ๋ฉด ๋จ
๋๋์ด ๋จ์ด์ง๋ ์ซ์ ๋ฐฐ์ด
๋ฌธ์ ๋ณด๊ธฐ
array์ ๊ฐ element ์ค divisor๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ฐฐ์ด์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
divisor๋ก ๋๋์ด ๋จ์ด์ง๋ element๊ฐ ํ๋๋ ์๋ค๋ฉด ๋ฐฐ์ด์ -1์ ๋ด์ ๋ฐํํ์ธ์.
์ ํ์ฌํญ
- arr์ ์์ฐ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ ๋๋ค.
- ์ ์ i, j์ ๋ํด i โ j ์ด๋ฉด arr[i] โ arr[j] ์ ๋๋ค.
- divisor๋ ์์ฐ์์ ๋๋ค.
- array๋ ๊ธธ์ด 1 ์ด์์ธ ๋ฐฐ์ด์ ๋๋ค.
์ ์ถ๋ ฅ ์
| arr | divisor | return |
|---|---|---|
| [5, 9, 7, 10] | 5 | [5, 10] |
| [2, 36, 1, 3] | 1 | [1, 2, 3, 36] |
| [3, 2, 6] | 10 | [-1] |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์#1
arr์ ์์ ์ค 5๋ก ๋๋์ด ๋จ์ด์ง๋ ์์๋ 5์ 10์ ๋๋ค. ๋ฐ๋ผ์ [5, 10]์ ๋ฆฌํดํฉ๋๋ค. - ์
์ถ๋ ฅ ์#2
arr์ ๋ชจ๋ ์์๋ 1์ผ๋ก ๋๋์ด ๋จ์ด์ง๋๋ค. ์์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด [1, 2, 3, 36]์ ๋ฆฌํดํฉ๋๋ค. - ์
์ถ๋ ฅ ์#3
3, 2, 6์ 10์ผ๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ต๋๋ค. ๋๋์ด ๋จ์ด์ง๋ ์์๊ฐ ์์ผ๋ฏ๋ก [-1]์ ๋ฆฌํดํฉ๋๋ค.
ํ์ด
function solution(arr, divisor) {
var divisorArray = arr.filter((item) => item % divisor === 0);
if (divisorArray.length > 0) {
return divisorArray.sort((a, b) => a - b);
}
return [-1];
}
์ซ์์ ๋ ฌ์ด ํฌ๊ธฐ๋๋ก ์ด๋ฃจ์ด์ง์ง ์๋๋ค๋ ๊ฒ๋ง ์ ์ํ๋ฉด ์ด๋ ต์ง ์๊ฒ ํ ์ ์์.
๋ ์ ์ ์ฌ์ด์ ํฉ
๋ฌธ์ ๋ณด๊ธฐ
๋ ์ ์ a, b๊ฐ ์ฃผ์ด์ก์ ๋ a์ b ์ฌ์ด์ ์ํ ๋ชจ๋ ์ ์์ ํฉ์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด a = 3, b = 5์ธ ๊ฒฝ์ฐ, 3 + 4 + 5 = 12์ด๋ฏ๋ก 12๋ฅผ ๋ฆฌํดํฉ๋๋ค.
์ ํ์ฌํญ
- a์ b๊ฐ ๊ฐ์ ๊ฒฝ์ฐ๋ ๋ ์ค ์๋ฌด ์๋ ๋ฆฌํดํ์ธ์.
- a์ b๋ -10,000,000 ์ด์ 10,000,000 ์ดํ์ธ ์ ์์ ๋๋ค.
- a์ b์ ๋์๊ด๊ณ๋ ์ ํด์ ธ์์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
| a | b | return |
|---|---|---|
| 3 | 5 | 12 |
| 3 | 3 | 3 |
| 5 | 3 | 12 |
ํ์ด
function solution(a, b) {
var start = a > b ? b : a;
var end = a > b ? a : b;
return ((start + end) * (end - start + 1)) / 2;
}
์ฒ์์๋ reduce ํจ์๋ฅผ ์ด์ฉํด ๋ฐ๋ณตํ๋ ค ํ์ผ๋, ์ ํ์กฐ๊ฑด์ ๋ณด๋ฉด -์ฒ๋ง ~ ์ฒ๋ง ๊น์ง์ ํฐ ์์ด๊ธฐ ๋๋ฌธ์ ๊ต์ฅํ ๋นํจ์จ์ ์ด๋ผ๊ณ ์๊ฐํ๋ฉฐ ๋ชปํ๊ณ ์์๋ค. ์ฐพ์๋ณด๋ ๊ฐ์ฐ์ค๊ฐ ๋ฑ์ฐจ์์ด์ ํฉ์ ๊ตฌํ ์์ด ์๋ค๊ณ ํ๋ค. ๋ ์์ ํฉ๊ณผ ๋์์ ์ฐจ + 1 ์ ๊ณฑํ ๋ค 2๋ก ๋๋๋ฉด ๋๋ค๊ณ ํ๋ค.
๋ฌธ์์ด ๋ด p์ y์ ๊ฐ์
๋ฌธ์ ๋ณด๊ธฐ
๋๋ฌธ์์ ์๋ฌธ์๊ฐ ์์ฌ์๋ ๋ฌธ์์ด s๊ฐ ์ฃผ์ด์ง๋๋ค. s์ โpโ์ ๊ฐ์์ โyโ์ ๊ฐ์๋ฅผ ๋น๊ตํด ๊ฐ์ผ๋ฉด True, ๋ค๋ฅด๋ฉด False๋ฅผ return ํ๋ solution๋ฅผ ์์ฑํ์ธ์. โpโ, โyโ ๋ชจ๋ ํ๋๋ ์๋ ๊ฒฝ์ฐ๋ ํญ์ True๋ฅผ ๋ฆฌํดํฉ๋๋ค. ๋จ, ๊ฐ์๋ฅผ ๋น๊ตํ ๋ ๋๋ฌธ์์ ์๋ฌธ์๋ ๊ตฌ๋ณํ์ง ์์ต๋๋ค.
์๋ฅผ ๋ค์ด s๊ฐ pPoooyY๋ฉด true๋ฅผ returnํ๊ณ Pyy๋ผ๋ฉด false๋ฅผ returnํฉ๋๋ค.
์ ํ์ฌํญ
- ๋ฌธ์์ด s์ ๊ธธ์ด : 50 ์ดํ์ ์์ฐ์
- ๋ฌธ์์ด s๋ ์ํ๋ฒณ์ผ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
| s | answer |
|---|---|
| pPoooyY | true |
| Pyy | false |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ #1
โpโ์ ๊ฐ์ 2๊ฐ, โyโ์ ๊ฐ์ 2๊ฐ๋ก ๊ฐ์ผ๋ฏ๋ก true๋ฅผ return ํฉ๋๋ค. - ์
์ถ๋ ฅ ์ #2
โpโ์ ๊ฐ์ 1๊ฐ, โyโ์ ๊ฐ์ 2๊ฐ๋ก ๋ค๋ฅด๋ฏ๋ก false๋ฅผ return ํฉ๋๋ค.
ํ์ด
function solution(s) {
var stringArr = s.split("");
var p = stringArr.filter((item) => ["p", "P"].includes(item));
var y = stringArr.filter((item) => ["y", "Y"].includes(item));
return p.length === y.length;
}
์ฒ์์ ์์ฒ๋ผ ํ์์ผ๋, ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ๋ณด๋ ํจ์ฌ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ด ์์ด ๊ทธ ๋ต๋ณ๋ ์ ๋๋ค. ์ ๊ท์์ ํ์คํ ์์๋์๋ก ๊ฐ๋ฐํ ๋ ๋์์ด ๋ง์ด ๋ ๊ฒ ๊ฐ๋ค.
function solution(s) {
var p = s.match(/p/gi) || [];
var y = s.match(/y/gi) || [];
return p.length === y.length;
}
match ํจ์๋ ๊ฐ์ด ์์๊ฒฝ์ฐ null์ ๋ฐํํ๊ธฐ ๋๋ฌธ์ ๋น ๋ฐฐ์ด์ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ถ๊ฐํด๋์์.
๋ฌธ์์ด ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
๋ฌธ์์ด s์ ๋ํ๋๋ ๋ฌธ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํด ์๋ก์ด ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
s๋ ์๋ฌธ ๋์๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ๋๋ฌธ์๋ ์๋ฌธ์๋ณด๋ค ์์ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
์ ํ์ฌํญ
- str์ ๊ธธ์ด 1 ์ด์์ธ ๋ฌธ์์ด์ ๋๋ค.
์ ์ถ๋ ฅ ์
| s | return |
|---|---|
| Zbcdefg | gfedcbZ |
ํ์ด
function solution(s) {
return s.split("").sort().reverse().join("");
}
๋ฌธ์ sort์์๋ ๋๋ฌธ์ -> ์๋ฌธ์์์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ด๋ ์ด๋ฅผ ๋ค์ง์ด์ฃผ๋ฉด ๋๊ฒ ๋ค.
๋ฌธ์์ด ๋ค๋ฃจ๊ธฐ ๊ธฐ๋ณธ
๋ฌธ์ ๋ณด๊ธฐ
๋ฌธ์์ด s์ ๊ธธ์ด๊ฐ 4 ํน์ 6์ด๊ณ , ์ซ์๋ก๋ง ๊ตฌ์ฑ๋ผ์๋์ง ํ์ธํด์ฃผ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด s๊ฐ a234์ด๋ฉด False๋ฅผ ๋ฆฌํดํ๊ณ 1234๋ผ๋ฉด True๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ์ฌํญ
s๋ ๊ธธ์ด 1 ์ด์, ๊ธธ์ด 8 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
์ ์ถ๋ ฅ ์
| s | return |
|---|---|
| โa234โ | false |
| โ1234โ | true |
ํ์ด
function solution(s) {
return [4, 6].includes((parseInt(s) + "").length);
}
์์ฒ๋ผ ํ๋ฉด, ๋ฌธ์๊ฐ ๊ปด์๋ ๊ฒฝ์ฐ paserInt์์ NaN์ด ๋์ฌ๊ฒ์ด๊ณ NaN์ ๋ฌธ์์ด๋ก ์นํํ๊ณ ๊ธธ์ด๋ฅผ ๊ตฌํด๋ 3์ด๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๋ ํด๊ฒฐ๋๋ค. ํ์ง๋ง ์กฐ๊ธ ๋ ๋ช
ํํ๊ฒ ์ฒ๋ฆฌ๋ฅผ ํ๋ ค๋ฉด parseInt ์ ์ isNaN ํจ์๋ ์ ๊ท์์ ์ด์ฉํด ์ซ์์ธ์ง ์ฌ๋ถ๋ฅผ ์ฒดํฌํ๋ ๋ฐฉ๋ฒ๋ ์๊ฒ ๋ค.
์์ธ์์ ๊น์๋ฐฉ ์ฐพ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
Stringํ ๋ฐฐ์ด seoul์ element์ค Kim์ ์์น x๋ฅผ ์ฐพ์, ๊น์๋ฐฉ์ x์ ์๋ค๋ String์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํ์ธ์. seoul์ Kim์ ์ค์ง ํ ๋ฒ๋ง ๋ํ๋๋ฉฐ ์๋ชป๋ ๊ฐ์ด ์ ๋ ฅ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
์ ํ์ฌํญ
- seoul์ ๊ธธ์ด 1 ์ด์, 1000 ์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค.
- seoul์ ์์๋ ๊ธธ์ด 1 ์ด์, 20 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
- Kim์ ๋ฐ๋์ seoul ์์ ํฌํจ๋์ด ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
| seoul | return |
|---|---|
| [โJaneโ, โKimโ] | โ๊น์๋ฐฉ์ 1์ ์๋คโ |
ํ์ด
function solution(seoul) {
return `๊น์๋ฐฉ์ ${seoul.indexOf("Kim")}์ ์๋ค`;
}
์์์ฐพ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
1๋ถํฐ ์ ๋ ฅ๋ฐ์ ์ซ์ n ์ฌ์ด์ ์๋ ์์์ ๊ฐ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ๋ง๋ค์ด ๋ณด์ธ์.
์์๋ 1๊ณผ ์๊ธฐ ์์ ์ผ๋ก๋ง ๋๋์ด์ง๋ ์๋ฅผ ์๋ฏธํฉ๋๋ค.
(1์ ์์๊ฐ ์๋๋๋ค.)
์ ํ์ฌํญ
- n์ 2์ด์ 1000000์ดํ์ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | result |
|---|---|
| 10 | 4 |
| 5 | 3 |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ #1
1๋ถํฐ 10 ์ฌ์ด์ ์์๋ [2,3,5,7] 4๊ฐ๊ฐ ์กด์ฌํ๋ฏ๋ก 4๋ฅผ ๋ฐํ - ์
์ถ๋ ฅ ์ #2
1๋ถํฐ 5 ์ฌ์ด์ ์์๋ [2,3,5] 3๊ฐ๊ฐ ์กด์ฌํ๋ฏ๋ก 3๋ฅผ ๋ฐํ
ํ์ด
function solution(n) {
// true์ธ ๊ฐ์ ์์๋ผ๊ณ ๊ฐ์ , 0๋ฒ index๋ฅผ ์ ์ 0์ด๋ผ๊ณ ์๊ฐํ๊ณ ํ๊ธฐ ์ํด n + 1๊ฐ ๋งํผ ๋ฐฐ์ด ์์ฑ
let arr = Array(n + 1).fill(true);
// ์ด๋ฏธ ์์๋ผ๊ณ ๊ฐ์ ํ์ผ๋ ์ ๊ณฑ๋ถํฐ ๋ก์ง์ ์์ํจ
for (let i = 2; i ** 2 <= n; i++) {
if (arr[i]) {
// ํด๋น ์์ ๋ฐฐ์๋ ๋ชจ๋ ์์๊ฐ ์๋์ผ๋ก false ์ฒ๋ฆฌ
for (let j = i ** 2; j <= n; j += i) {
arr[j] = false;
}
}
}
// 0๊ณผ 1์ ์ ์ธ
arr = arr.slice(2).filter((item) => item);
return arr.length;
}
ํด๋น ๋ฌธ์ ๋ ๋ฌด์ํ๊ฒ ์ผ์ผํ ๊ณ์ฐํ์ฌ ํ๋ ค๊ณ ํ์ผ๋ ํ ์คํธ๋ ํต๊ณผํด๋ ์ฑ์ ์์ ์คํจ๊ฐ ๋๋ค. ์ผ์ผํ ๊ณ์ฐ์ ํ๋ค๋ณด๋ ์์ฐ์ค๋ ์ฑ๋ฅ๋ถ๋ถ์์ ํ๋ฝ์ด ๋๋๋ฐ, ์ธํฐ๋ท์ ์ฐพ์๋ณด๋ ์์๋ฅผ ๊ตฌํ๋ ์ ์ค์์ ์๋ผํ ์คํ ๋ค์ค์ ์ฒด๋ผ๋ ์์ ๋ฐ๊ฒฌํ๊ณ , ๊ทธ ์์ ์ ์ฉํ๊ณ ํ ์ ์์๋ค. ์๋ผํ ์คํ ๋ค์ค์ ์ฒด๋ ์๊ธฐ ์์ ์ ์ ์ธํ ๋ฐฐ์์ ๊ฐ์ ์ ์ธํด ๋๊ฐ๋ค๋ ์ ์ด ํต์ฌ์ด๋ค.
level 1 ๋ฌธ์ ๋ค ์ค์์ ๊ฐ์ฅ ์ด๋ ค์ด ํธ์ ์ํ์ง ์์๋์ถ๋ค.