Last Update: 2019-12-22
- Level 1 ์ฐ์ต๋ฌธ์ (1) ๋ฐ๋ก๊ฐ๊ธฐ
- Level 1 ์ฐ์ต๋ฌธ์ (2)
- Level 1 ์ฐ์ต๋ฌธ์ (3) ๋ฐ๋ก๊ฐ๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค์ Level1 ๋ฌธ์ ๋ค์ค ์ฐ์ต๋ฌธ์ ๋ผ๋ ์นดํ
๊ณ ๋ฆฌ์ ๋ฌธ์ ๋ค์ ๋ค๋ฅธ ๋ฌธ์ ๋ค์ ๋นํด ์ฌ์ด ํธ์ด๋ ์ฌ๋ฌ ๊ธ์ ๋๋ ์ฐ์ง ์๊ณ ์ด๋ฒ ๊ธ์ ์ญ ์ ์ด ๋ณผ ์๊ฐ์ด๋ค. ๋ชป ํผ๊ฑด ๋ฌผ๋ก ์์ ์.
์๋ฐ์๋ฐ์๋ฐ์๋ฐ์๋ฐ์?
๋ฌธ์ ๋ณด๊ธฐ
๊ธธ์ด๊ฐ n์ด๊ณ , ์๋ฐ์๋ฐ์๋ฐ์โฆ์ ๊ฐ์ ํจํด์ ์ ์งํ๋ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์.
์๋ฅผ๋ค์ด n์ด 4์ด๋ฉด ์๋ฐ์๋ฐ์ ๋ฆฌํดํ๊ณ 3์ด๋ผ๋ฉด ์๋ฐ์๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- n์ ๊ธธ์ด 10,000์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | return |
|---|---|
| 3 | ์๋ฐ์ |
| 4 | ์๋ฐ์๋ฐ |
ํ์ด
function solution(n) {
var answer = "์๋ฐ".repeat(n);
answer = answer.substr(0, answer.length / 2);
return answer;
}
๋ฌธ์์ด์ ์ ์๋ก ๋ฐ๊พธ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
๋ฌธ์์ด s๋ฅผ ์ซ์๋ก ๋ณํํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํ์ธ์.
์ ํ ์กฐ๊ฑด
- s์ ๊ธธ์ด๋ 1 ์ด์ 5์ดํ์ ๋๋ค.
- s์ ๋งจ์์๋ ๋ถํธ(+, -)๊ฐ ์ฌ ์ ์์ต๋๋ค.
- s๋ ๋ถํธ์ ์ซ์๋ก๋ง ์ด๋ฃจ์ด์ ธ์์ต๋๋ค.
- s๋ 0์ผ๋ก ์์ํ์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
์๋ฅผ๋ค์ด str์ด 1234์ด๋ฉด 1234๋ฅผ ๋ฐํํ๊ณ , -1234์ด๋ฉด -1234๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค. str์ ๋ถํธ(+,-)์ ์ซ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์๊ณ , ์๋ชป๋ ๊ฐ์ด ์ ๋ ฅ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
ํ์ด
function solution(s) {
// return +s;
// return s / 1;
// return s * 1;
return parseInt(s);
}
์ฃผ์์น ์ฐ์ฐ๋ฅผ ํตํด ์ ์ํ์ ๋ฐ๊ฟ ์๋ ์๊ฒ ์ง๋ง, parseInt๋ก ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ๋ช ํํ ๊ฒ ๊ฐ์์ parseInt๋ฅผ ์ฌ์ฉํ๋ค.
์์ ์ํธ
๋ฌธ์ ๋ณด๊ธฐ
์ด๋ค ๋ฌธ์ฅ์ ๊ฐ ์ํ๋ฒณ์ ์ผ์ ํ ๊ฑฐ๋ฆฌ๋งํผ ๋ฐ์ด์ ๋ค๋ฅธ ์ํ๋ฒณ์ผ๋ก ๋ฐ๊พธ๋ ์ํธํ ๋ฐฉ์์ ์์ ์ํธ๋ผ๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด AB๋ 1๋งํผ ๋ฐ๋ฉด BC๊ฐ ๋๊ณ , 3๋งํผ ๋ฐ๋ฉด DE๊ฐ ๋ฉ๋๋ค. z๋ 1๋งํผ ๋ฐ๋ฉด a๊ฐ ๋ฉ๋๋ค. ๋ฌธ์์ด s์ ๊ฑฐ๋ฆฌ n์ ์ ๋ ฅ๋ฐ์ s๋ฅผ n๋งํผ ๋ฏผ ์ํธ๋ฌธ์ ๋ง๋๋ ํจ์, solution์ ์์ฑํด ๋ณด์ธ์.
์ ํ ์กฐ๊ฑด
- ๊ณต๋ฐฑ์ ์๋ฌด๋ฆฌ ๋ฐ์ด๋ ๊ณต๋ฐฑ์ ๋๋ค.
- s๋ ์ํ๋ฒณ ์๋ฌธ์, ๋๋ฌธ์, ๊ณต๋ฐฑ์ผ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- s์ ๊ธธ์ด๋ 8000์ดํ์ ๋๋ค.
- n์ 1 ์ด์, 25์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| s | n | result |
|---|---|---|
| โABโ | 1 | โBC" |
| "zโ | 1 | โa" |
| "a B zโ | 4 | โe F dโ |
ํ์ด
function solution(s, n) {
var answer = s
.split("")
.map((item) => {
if (item === " ") {
return item;
}
var charCode = item.charCodeAt();
var result = charCode + n;
if ((charCode <= 90 && result > 90) || (charCode >= 97 && result > 122)) {
result -= 26;
}
return String.fromCharCode(result);
})
.join("");
return answer;
}
charCode๋ฅผ n๋งํผ ์ฆ๊ฐ์ํค๋ฉด ๋๋ค. ๋ค๋ง z๋ a๋ก Z๋ A๋ก ๋์๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ if๋ฌธ์ ์ด์ฉํด ๋ณํ charCode์ ๊ฒฐ๊ณผ๊ฐ์ ๋น๊ตํด ์ํ๋ฑ ๊ฐ์์ธ 26๋งํผ ๋นผ์ฃผ๋ ๋ก์ง์ ์ถ๊ฐํด ์ฃผ์๋ค. charCode๋ฅผ ๋ค์ ๋ฌธ์๋ก ์นํํ๋ ํจ์๋ String์ ๋ฉ์๋์ธ fromCharCode์ด๋ค. ์ธ์๋๋๋ก ํด์ผ๊ฒ ๋ค.
์ฝ์์ ํฉ
๋ฌธ์ ๋ณด๊ธฐ
์ ์ n์ ์ ๋ ฅ๋ฐ์ n์ ์ฝ์๋ฅผ ๋ชจ๋ ๋ํ ๊ฐ์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- n์ 0 ์ด์ 3000์ดํ์ธ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | return |
|---|---|
| 12 | 28 |
| 5 | 6 |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ #1
12์ ์ฝ์๋ 1, 2, 3, 4, 6, 12์ ๋๋ค. ์ด๋ฅผ ๋ชจ๋ ๋ํ๋ฉด 28์ ๋๋ค. - ์
์ถ๋ ฅ ์ #2
5์ ์ฝ์๋ 1, 5์ ๋๋ค. ์ด๋ฅผ ๋ชจ๋ ๋ํ๋ฉด 6์ ๋๋ค.
ํ์ด
function solution(n) {
var answer = 0;
for (var i = 1; i <= n; i++) {
if (n % i === 0) {
answer += i;
}
}
return answer;
}
n์ 1๋ถํฐ ๋๋์ด ๋๋จธ์ง๊ฐ 0์ธ ์ = ์ฝ์๋ฅผ ์ฐพ์ ๋ํด์ค๋ค.
์ด์ํ ๋ฌธ์ ๋ง๋ค๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
๋ฌธ์์ด s๋ ํ ๊ฐ ์ด์์ ๋จ์ด๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด๋ ํ๋ ์ด์์ ๊ณต๋ฐฑ๋ฌธ์๋ก ๊ตฌ๋ถ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด์ ์ง์๋ฒ์งธ ์ํ๋ฒณ์ ๋๋ฌธ์๋ก, ํ์๋ฒ์งธ ์ํ๋ฒณ์ ์๋ฌธ์๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์.
์ ํ ์กฐ๊ฑด
- ๋ฌธ์์ด ์ ์ฒด์ ์ง/ํ์ ์ธ๋ฑ์ค๊ฐ ์๋๋ผ, ๋จ์ด(๊ณต๋ฐฑ์ ๊ธฐ์ค)๋ณ๋ก ์ง/ํ์ ์ธ๋ฑ์ค๋ฅผ ํ๋จํด์ผํฉ๋๋ค.
- ์ฒซ ๋ฒ์งธ ๊ธ์๋ 0๋ฒ์งธ ์ธ๋ฑ์ค๋ก ๋ณด์ ์ง์๋ฒ์งธ ์ํ๋ฒณ์ผ๋ก ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์
| s | return |
|---|---|
| โtry hello world" | "TrY HeLlO WoRlDโ |
์ ์ถ๋ ฅ ์ ์ค๋ช
โtry hello worldโ๋ ์ธ ๋จ์ด โtryโ, โhelloโ, โworldโ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด์ ์ง์๋ฒ์งธ ๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก, ํ์๋ฒ์งธ ๋ฌธ์๋ฅผ ์๋ฌธ์๋ก ๋ฐ๊พธ๋ฉด โTrYโ, โHeLlOโ, โWoRlDโ์ ๋๋ค. ๋ฐ๋ผ์ โTrY HeLlO WoRlDโ ๋ฅผ ๋ฆฌํดํฉ๋๋ค.
ํ์ด
function solution(s) {
return s
.split(" ")
.map((word) => {
return word
.split("")
.map((char, index) => {
return index % 2 === 0 ? char.toUpperCase() : char.toLowerCase();
})
.join("");
})
.join(" ");
}
์๋ฆฟ์ ๋ํ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
์์ฐ์ N์ด ์ฃผ์ด์ง๋ฉด, N์ ๊ฐ ์๋ฆฟ์์ ํฉ์ ๊ตฌํด์ return ํ๋ solution ํจ์๋ฅผ ๋ง๋ค์ด ์ฃผ์ธ์.
์๋ฅผ๋ค์ด N = 123์ด๋ฉด 1 + 2 + 3 = 6์ return ํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- N์ ๋ฒ์ : 100,000,000 ์ดํ์ ์์ฐ์
์ ์ถ๋ ฅ ์
| N | answer |
|---|---|
| 123 | 6 |
| 987 | 24 |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ #1
๋ฌธ์ ์ ์์์ ๊ฐ์ต๋๋ค. - ์
์ถ๋ ฅ ์ #2
9 + 8 + 7 = 24์ด๋ฏ๋ก 24๋ฅผ return ํ๋ฉด ๋ฉ๋๋ค.
ํ์ด
function solution(n) {
return ("" + n).split("").reduce((acc, curr) => {
return acc + parseInt(curr);
}, 0);
}
์ฒ์์ ์์ฒ๋ผ ๋ฌธ์๋ก ์นํํด์ ํ ๊ธ์์ฉ ๋ํด์ฃผ๋ ํ์ด๋ฅผ ํ๋๋ฐ ์๋์ ๊ฐ์ ๋ฐฉ๋ฒ๋ ์๋ค๊ณ ํด์ ์ ์ด๋๋ค. ๋ฌด์กฐ๊ฑด ๋ฌธ์๋ก ์ชผ๊ฐ์ ํธ๋ ๊ฒ๋ณด๋จ ์ํ์ ์ธ ์ ๊ทผ์ ํ๋ ๋ฐฉ๋ฒ์ ํญ์ ์๊ฐํด์ผ๊ฒ ๋ค.
function solution(n) {
var sum = 0;
while (n > 0) {
sum += n % 10;
n = parseInt(n / 10);
}
return sum;
}
์์ฐ์ ๋ค์ง์ด ๋ฐฐ์ด๋ก ๋ง๋ค๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
์์ฐ์ n์ ๋ค์ง์ด ๊ฐ ์๋ฆฌ ์ซ์๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ํํ๋ก ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 12345์ด๋ฉด [5,4,3,2,1]์ ๋ฆฌํดํฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- n์ 10,000,000,000์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | return |
|---|---|
| 12345 | [5,4,3,2,1] |
ํ์ด
function solution(n) {
return ("" + n)
.split("")
.reverse()
.map((item) => +item);
}
์ค๋ช ์ด ๋ฑํ ํ์์์๋งํผ ๊ฐ๋จํ๋ค. ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์๋ค๋ฉด, ๋ฐ๋ก ์ โ์๋ฆฟ์ ๋ํ๊ธฐโ๋ฌธ์ ์์ ์ฒ๋ผ 1์ ์๋ฆฌ์๋ฅผ ๊ตฌํด ์๋ก์ด ๋ฐฐ์ด์ pushํด์ฃผ๋ ๋ฐฉ๋ฒ ๋ํ ์์ ๊ฒ ๊ฐ๋ค.
์ ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
ํจ์ solution์ ์ ์ n์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ ฅ๋ฐ์ต๋๋ค. n์ ๊ฐ ์๋ฆฟ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํ ์๋ก์ด ์ ์๋ฅผ ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 118372๋ฉด 873211์ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- n์ 1์ด์ 8000000000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | return |
|---|---|
| 118372 | 873211 |
ํ์ด
function solution(n) {
return parseInt(
("" + n)
.split("")
.sort((a, b) => b - a)
.join(""),
);
}
๋ฌธ์์ด ์นํ > ๋ฐฐ์ด > ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ > ๋ฌธ์์ด ํฉ์น๊ธฐ > ์ ์ํ ์นํ
์ ์ ์ ๊ณฑ๊ทผ ํ๋ณ
๋ฌธ์ ๋ณด๊ธฐ
์์์ ์์ ์ ์ n์ ๋ํด, n์ด ์ด๋ค ์์ ์ ์ x์ ์ ๊ณฑ์ธ์ง ์๋์ง ํ๋จํ๋ ค ํฉ๋๋ค.
n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด๋ผ๋ฉด x+1์ ์ ๊ณฑ์ ๋ฆฌํดํ๊ณ , n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด ์๋๋ผ๋ฉด -1์ ๋ฆฌํดํ๋ ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ ์กฐ๊ฑด
- n์ 1์ด์, 50000000000000 ์ดํ์ธ ์์ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
| n | return |
|---|---|
| 121 | 144 |
| 3 | -1 |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์#1
121์ ์์ ์ ์ 11์ ์ ๊ณฑ์ด๋ฏ๋ก, (11+1)๋ฅผ ์ ๊ณฑํ 144๋ฅผ ๋ฆฌํดํฉ๋๋ค. - ์
์ถ๋ ฅ ์#2
3์ ์์ ์ ์์ ์ ๊ณฑ์ด ์๋๋ฏ๋ก, -1์ ๋ฆฌํดํฉ๋๋ค.
ํ์ด
function solution(n) {
var sqrt = Math.sqrt(n);
if (sqrt === parseInt(sqrt)) {
return (sqrt + 1) ** 2;
}
return -1;
}
์ฃผ์ด์ง ์์ ์ ๊ณฑ๊ทผ์ด ์์ ์ ์ x์ ๊ฐ์ผ๋ฉด ๋๊ธฐ ๋๋ฌธ์ ๊ฐ๋จํ๊ฒ ํด๊ฒฐ ๊ฐ๋ฅํ๋ค.
sqrt ** 2 === n ์ผ๋ก๋ ๋น๊ต๊ฐ ๊ฐ๋ฅํ๋ค.
๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ
๋ฌธ์ ๋ณด๊ธฐ
๋ฌธ์์ด๋ก ๊ตฌ์ฑ๋ ๋ฆฌ์คํธ strings์, ์ ์ n์ด ์ฃผ์ด์ก์ ๋, ๊ฐ ๋ฌธ์์ด์ ์ธ๋ฑ์ค n๋ฒ์งธ ๊ธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ ค ํฉ๋๋ค. ์๋ฅผ ๋ค์ด strings๊ฐ [โsunโ, โbedโ, โcarโ]์ด๊ณ n์ด 1์ด๋ฉด ๊ฐ ๋จ์ด์ ์ธ๋ฑ์ค 1์ ๋ฌธ์ โuโ, โeโ, โaโ๋ก strings๋ฅผ ์ ๋ ฌํฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- strings๋ ๊ธธ์ด 1 ์ด์, 50์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค.
- strings์ ์์๋ ์๋ฌธ์ ์ํ๋ฒณ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- strings์ ์์๋ ๊ธธ์ด 1 ์ด์, 100์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
- ๋ชจ๋ strings์ ์์์ ๊ธธ์ด๋ n๋ณด๋ค ํฝ๋๋ค.
- ์ธ๋ฑ์ค 1์ ๋ฌธ์๊ฐ ๊ฐ์ ๋ฌธ์์ด์ด ์ฌ๋ฟ ์ผ ๊ฒฝ์ฐ, ์ฌ์ ์์ผ๋ก ์์ ๋ฌธ์์ด์ด ์์ชฝ์ ์์นํฉ๋๋ค.
์ ์ถ๋ ฅ ์
| strings | n | return |
|---|---|---|
| [โsunโ, โbedโ, โcarโ] | 1 | [โcarโ, โbedโ, โsunโ] |
| [โabceโ, โabcdโ, โcdxโ] | 2 | [โabcdโ, โabceโ, โcdxโ] |
์ ์ถ๋ ฅ ์ ์ค๋ช
- ์
์ถ๋ ฅ ์ 1
โsunโ, โbedโ, โcarโ์ 1๋ฒ์งธ ์ธ๋ฑ์ค ๊ฐ์ ๊ฐ๊ฐ โuโ, โeโ, โaโ ์ ๋๋ค. ์ด๋ฅผ ๊ธฐ์ค์ผ๋ก strings๋ฅผ ์ ๋ ฌํ๋ฉด [โcarโ, โbedโ, โsunโ] ์ ๋๋ค. - ์
์ถ๋ ฅ ์ 2
โabceโ์ โabcdโ, โcdxโ์ 2๋ฒ์งธ ์ธ๋ฑ์ค ๊ฐ์ โcโ, โcโ, โxโ์ ๋๋ค. ๋ฐ๋ผ์ ์ ๋ ฌ ํ์๋ โcdxโ๊ฐ ๊ฐ์ฅ ๋ค์ ์์นํฉ๋๋ค. โabceโ์ โabcdโ๋ ์ฌ์ ์์ผ๋ก ์ ๋ ฌํ๋ฉด โabcdโ๊ฐ ์ฐ์ ํ๋ฏ๋ก, ๋ต์ [โabcdโ, โabceโ, โcdxโ] ์ ๋๋ค.
ํ์ด
function solution(strings, n) {
var answer = strings.sort((a, b) => {
if (a[n] === b[n]) {
return a.localeCompare(b);
}
return a[n].localeCompare(b[n]);
});
return answer;
}
์ธ๋ฑ์ค ๊ฐ์ผ๋ก ์ ๋ ฌํ๋ผ๋ ๋ง์ ์ฒ์์ ์ดํดํ์ง ๋ชปํ๋๋ฐ, ๋ป์ ์๊ณ ๋๋ ๊ฐ๋จํ๋ค. ์ ์ถ๋ ฅ ์ 1์ ๊ธฐ์ค์ผ๋ก ์ค๋ช ํ๋ฉด, u, e, a ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ฉด ์ํ๋ฒณ ์์๋๋ก a, e, u๊ฐ ๋๋ ๊ฐ ์ธ๋ฑ์ค ๊ฐ์ด a, e, u์ธ car, bed, sun ์์๊ฐ ๋๋ ๊ฒ์ด๋ค.
์ถ๊ฐ ์ ํ ์กฐ๊ฑด์ผ๋ก๋ ์ธ๋ฑ์ค ๊ฐ์ด ๊ฐ์ ๊ฒฝ์ฐ๋ ์ธ๋ฑ์ค ๊ฐ ์์๊ฐ ์๋ ์ฌ์ ์ ์ ๋ ฌ์ ํ๊ฒ ๋๋ฉด ๋๋ค.
localeCompare๋ ๋ฌธ์์ด์ ๋น๊ตํ๋ ํจ์์ด๋ค. ์ฌ์ ์์ผ๋ก ๋น๊ตํ๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ์ ์์ฃผ ์ ํฉํ ํจ์์ด๋ค.
"a".localeCompare("a"); // 0
"A".localeCompare("B"); // -1
"B".localeCompare("A"); // 1