[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ๋ฌธ์์ด ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ
๋ฌธ์ ์ค๋ช
๋ฌธ์์ด s์ ๋ํ๋๋ ๋ฌธ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํด ์๋ก์ด ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
s๋ ์๋ฌธ ๋์๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ๋๋ฌธ์๋ ์๋ฌธ์๋ณด๋ค ์์ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
์ ํ์ฌํญ
str์ ๊ธธ์ด 1 ์ด์์ธ ๋ฌธ์์ด์
๋๋ค.
์ ์ถ๋ ฅ ์
s | return |
---|---|
"Zbcdefg" | "gfedcbZ" |
function solution(s) {
var answer = s
.split("")
.sort((a, b) => a - b)
.reverse()
.join("");
return answer;
}
๊ตฌํ ์ ๊ทผ
1. ํด๋น ๋ฌธ์์ด์ ๋๋์ด ๋ฐฐ์ด๋ก ๋ฐํํ๊ธฐ ์ํด split ๋ฉ์๋ ์ฌ์ฉ
2. sort ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ ์ธ์๋ฅผ ๋น๊ต ํ ์ค๋ฆ์ฐจ์์ผ๋ก ๋์ด
3.์ ์กฐ๊ฑด์์ ๋๋ฌธ์๊ฐ ๊ฐ์ฅ ์์ ๊ฐ์ผ๋ก ๋ฐํํ๊ธฐ ์ํด reverse ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ํด๋น ๋ฌธ์์ด์ ์ค๋ฆ์ฐจ์์ ์ญ์์ผ๋ก ๋ํ๋๋ค.
๋ฌธ์ ์
1. ํด๋น ํจ์์์ ์กฐ๊ฑด์ ์
์ถ๋ ฅ์ ํต๊ณผ๊ฐ ๋์ง๋ง ํ
์คํธ ์ผ์ด์ค์์ ํต๊ณผ๊ฐ ๋์ง ๋ชป ํ๋ ๋ฌธ์ ๊ฐ ์๊น.
2. ๋ฌธ์์ด์์ sort๋ ascii ์ฝ๋์ ์ ๋์ฝ๋ ํ๊ธฐ ๊ฐ์ผ๋ก ๋น๊ต๊ฐ ์ด๋ค์ง๋๋ฐ
sort ๋ฉ์๋์ ์ธ์๋ก ์ฃผ์ด์ง a - b ์ฐ์ฐ์ ์ซ์ ํ๋ง ๊ฐ๋ฅ.
a-b๋ก ์ฐ์ฐ ๋ ๊ฐ์ด 0์ ๊ธฐ์ค์ผ๋ก ์๊ฑฐ๋ ์ปค์ผ ์ฐจ์ ์ ๋ ฌ์ด ์ด๋ค์ง๋ค.
๊ทธ๋ฌ๋ ๋ฌธ์์ด์ ์ฐ์ฐ์ด ๋ถ๊ฐ๋ฅ ํ๋ฉฐ, ๋ฌธ์์ด์ ์ธ์์ (a-b)์ ์ฐ์ฐ์ผ๋ก ์ฐธ ๊ฑฐ์ง์ ๋๋ ์ ์๋ ๋น๊ต ์ฑ๋ฆฝ์์ฒด๊ฐ ๋ถ๊ฐ.
์ ๋์ฝ๋์ ์ซ์ ํ๊ธฐ ํฌ๊ธฐ๋ฅผ ํตํด ๋น๊ต๋ฅผ ํ๊ธฐ ๋๋ฌธ์ ๋น๊ต์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๊ฑฐ๋, localeCompare( )๋ฉ์๋๋ฅผ ํตํด ๋์ ๋น๊ต๋ฅผ ํด์ฃผ์ด์ผ ํ๋ค.
๊ทธ ์ด์ ๋ ์๋ ์์๋ฅผ ์ฐธ๊ณ ํ์.
sort ๊ธฐ๋ฅ ์์)
๊ทธ๋ ๊ธฐ์ ๋ฌธ์์ด ์์ฒด๋ฅผ ์ฐจ์ ์ ๋ ฌํ๊ณ ์ถ์ผ๋ฉด 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋ค.
ํฌ๊ธฐ๋ฅผ ๋น๊ตํ ๊ฐ์ ์กฐ๊ฑด์ ํตํด -1, 0, 1 ๊ฐ์ค ํ๋๋ก ๋ฐํ ํ ์ ๋ ฌ.
sort((a, b) => {
return a < b ? -1 : a > b ? 1 : 0;
})
sort((a, b) => {
return a > b ? -1 : a < b ? 1 : 0;
})
String.prototype.localeCompare() ๋ฉ์๋ ์ด์ฉ
localeCompare() ๋ฉ์๋๋ ์ฐธ์กฐ ๋ฌธ์์ด์ด ์ ๋ ฌ ์์ผ๋ก ์ง์ ๋ ๋ฌธ์์ด ์ ํน์ ๋ค์ ์ค๋์ง ๋๋ ๋์ผํ ๋ฌธ์์ด์ธ์ง ๋ํ๋ด๋ ์์น๋ฅผ ๋ฐํํฉ๋๋ค.
sort((a, b) => a.localeCompare(b))
sort((a, b) => b.localeCompare(a))
๊ทธ๋ฌ๋ ์์ ๋ ์์๋ ์ฐจ์ด๊ฐ ์กด์ฌํ๋๋ฐ, ์์ ์ฝ๋๋ฅผ ์ดํด๋ณด์๋ฉด
var str = "Zbcdefg";
var split = str.split("");
console.log(split.sort((a, b) => {
return a < b ? -1 : a > b ? 1 : 0;
}).join(""));
console.log(split.sort((a, b) => {
return a > b ? -1 : a < b ? 1 : 0;
}).join(""));
console.log(split.sort((a, b) => a.localeCompare(b)).join(""));
console.log(split.sort((a, b) => b.localeCompare(a)).join(""));
// ์์คํค ์ฝ๋ ์ซ์์ ๋น๊ต ๊ฐ์ ๋ฐ๋ผ ์ฐจ์ ์ ๋ ฌ ์ ์ฉ.
Zbcdefg
gfedcbZ
// ๋ฌธ์ ์ฌ์ ์์ ๊ทธ๋๋ก ์ฐจ์ ์ ๋ ฌ ์ ์ฉ.
bcdefgZ
Zgfedcb
sort() ๋ฉ์๋ ๊ธฐ๋ฅ ์์ฒด์ ๋ค์๊ธ ์ดํด๋ณผ ์ ์๋ ๊ณ๊ธฐ๊ฐ ๋์๊ณ gpt ๋์๊ณผ ๊ตฌ๊ธ ๊ฒ์์ ํตํด์ ๋ฌด์์ด ๋ฌธ์ ์ธ์ง sort ๋ฉ์๋์ ์ข ๋ ๋ค๊ฐ๊ฐ ์์์๋ค.
map์ ํตํด sort ๋ฉ์๋๋ฅผ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ๋ ์์๋๋ฐ ์ฐจํ ์ดํดํ๋๋ก ํด๋ณด์,,
#1
function solution(s) {
return s
.split("")
.sort()
.reverse()
.join("");
}
ํ์ด
1. ๋ฌธ์์ด sortํ ๋๋ localeCompare์ ์ด์ฉํ๊ฑฐ๋
2. sort([compareFunction]) ์ธ์ ๊ฐ์ผ๋ก ์๋ฌด๊ฒ๋ ์ ๋ฌํ์ง ์์ผ๋ฉด ์ป๊ณ ์ ํ๋ ์ ๋ ฌ์ด ๋ ๊ฒ์ด๋ค,,!
#2
function solution(s) {
return s.split("").sort((a,b) => a<b ? 1:-1).join("")
}
ํ์ด
์ฝ์์ ๊ฐ์์ ๋ง์
๋ฌธ์ ์ค๋ช
๋ ์ ์ left์ right๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. left๋ถํฐ right๊น์ง์ ๋ชจ๋ ์๋ค ์ค์์, ์ฝ์์ ๊ฐ์๊ฐ ์ง์์ธ ์๋ ๋ํ๊ณ , ์ฝ์์ ๊ฐ์๊ฐ ํ์์ธ ์๋ ๋บ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
1 โค left โค right โค 1,000
์ ์ถ๋ ฅ ์
left | right | result |
---|---|---|
13 | 17 | 43 |
24 | 27 | 52 |
function collect(num) {
let sum = 0;
for (let i = 1; i <= num; i++) {
if (num % i === 0) sum += 1;
}
return sum;
}
function solution(left, right) {
let answer = 0;
for (let i = left; i <= right; i++) {
collect(i) % 2 === 0 ? (answer += i) : (answer -= i);
}
return answer;
}
๊ตฌํ ์ ๊ทผ
1. collect ํจ์๋ฅผ ํตํด ํด๋น ์ธ์์ ๋์
๋๋ ๊ฐ์ ์ฝ์๊ฐ ๋ช๊ฐ์ธ์ง ๊ตฌํ๊ณ
2. solution ํจ์๋ฅผ ํตํด left์์ right์ ๋ฒ์๊น์ง ์ซ์๋ค์ ์ฝ์๊ฐ ์ง์ ๊ฐ์ด๋ฉด ๋ํ๊ณ ํ์ ๊ฐ์ด๋ฉด ๋นผ๋ ํจ์ ๊ธฐ๋ฅ์ ๊ตฌํ.
๋ฌธ์ ์
ํ๋์ ํจ์๋ง์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ คํ์ง ๋ง๊ณ ๋ค์ํ ํจ์๋ฅผ ํตํด ์ป๊ณ ์ ํ๋ ๊ฒฐ๊ณผ ๊ฐ์ ๋ฐํํ์.
์์ ์ฝ๋์์๋ ์ฝ์ ๊ฐ์๋ฅผ ํ์
ํ๋ ํจ์์
ํ์
ํ ๊ฐ์๋ฅผ ํ, ์ง ๊ตฌ๋ณํ์ฌ ํฉ์ฐํ๋ ํจ์๋ฅผ ๊ตฌํํด์ผ ํ๋ค.
#1
function solution(left, right) {
let answer = 0;
for (let i = left; i <= right; i++) {
let count = 0;
for (let j = 1; j <= i; j++) {
if (i % j === 0) count++; // ์ฝ์์ ๊ฐ์ ๋์ฐ
}
if (count % 2)
answer -= i; // ์ ์ฒด ์ฝ์์ ๊ฐ์๋ฅผ 2๋ก ๋๋ ๋๋จธ์ง๊ฐ ์กด์ฌํ๋ฉด ๋บ ๊ฐ์ ํ ๋น
else answer += i; // ์ ์ฒด ์ฝ์์ ๊ฐ์๋ฅผ 2๋ก ๋๋ ๋๋จธ์ง๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด ๋ํ ๊ฐ์ ํ ๋น
}
return answer;
}
ํ์ด
์ด์ค for๋ฌธ์ผ๋ก ๊ตฌํ ํด๋ณด๊ณ ์ถ์๋๋ฐ ๊ตฌํ ํ์ ๋ถ์ด ๊ณ์
์ ๊ฐ์ ธ์๋ดค๋ค.
1. answer์ for ๋ฌธ์ผ๋ก count์ ๊ฐ์ ๊ตฌํด ํ,์ง ๊ตฌ๋ณ ํ ์กฐ๊ฑด ํฉ์ฐ
2. count์ for ๋ฌธ์ผ๋ก ์ฝ์์ ๊ฐ์๊ฐ ๋ช๊ฐ์ธ์ง ๋์ฐ.
#2
function solution(left, right) {
var answer = 0;
for (let i = left; i <= right; i++) {
if (Number.isInteger(Math.sqrt(i))) {
answer -= i;
} else {
answer += i;
}
}
return answer;
}
ํ์ด
1. ์ ๊ณฑ๊ทผ์ด ์ ์๋ฉด ์ฝ์์ ๊ฐ์๊ฐ ํ์๋ค...
๋ฌธ์์ด ๋ค๋ฃจ๊ธฐ ๊ธฐ๋ณธ
๋ฌธ์ ์ค๋ช
๋ฌธ์์ด s์ ๊ธธ์ด๊ฐ 4 ํน์ 6์ด๊ณ , ์ซ์๋ก๋ง ๊ตฌ์ฑ๋ผ์๋์ง ํ์ธํด์ฃผ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด s๊ฐ "a234"์ด๋ฉด False๋ฅผ ๋ฆฌํดํ๊ณ "1234"๋ผ๋ฉด True๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
s | return |
---|---|
"a234" | false |
"1234" | true |
function solution(s) {
var answer = s
.split("")
.map((e) => e * 1)
.every((cur) => typeof cur === "number");
return answer;
}
console.log(solution("a234"));
๊ตฌํ ์ ๊ทผ
1. split ๋ฉ์๋๋ฅผ ํตํด ํด๋น ๋ฌธ์์ด์ ๋๋์ด ์ค ๋ค์
2. map ๋ฉ์๋ค ํตํด ๋ฐฐ์ด ์๋ฆฌ๋จผํธ๋ฅผ ๊ฐ๊ฐ *1 ์ฐ์ฐํ์ฌ ์ซ์ํ์ผ๋ก ํ ๋ณํ์ ํด์ฃผ์๋ค.
3. ๋ง์ง๋ง์ผ๋ก every ๋ฉ์๋๋ฅผ ํตํด ๊ฐ ์กฐ๊ฑด์ด ํต๊ณผ๊ฐ ๋๋์ง ํ๋ณํ๋ ํจ์๋ฅผ ๊ตฌํ
๋ฌธ์ ์
1. typeof์ ๋ฌธ์
cur = ['a','2','3','4'] ์ผ ๋
.every((cur) => typeof cur === Number);
// true
์ง๊ธ ์ฝ๋์ ๋ฌธ์ ์ ์ type of์์ ๋์ค๋ ๊ฒ์ด์๋ค.
๊ทธ๋ฌ๋ ๊ฐ์ ํ every ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๋ typeof์ ๊ฒฐ๊ณผ ๊ฐ์ด 'number'๋ฉด true๋ฅผ ๋ฐํํ๊ธฐ๋ฅผ ๋ฐ๋ฌ๋๋ฐ,,
cur = ['a','2','3','4']
์ผ ๋๋ true๊ฐ ๋์ค๋ ๊ฒ ์ด์๋ค.
console.log(cur)์ ํด๋ณด๋ NaN์ด ๋์ค๋ ๊ฒ.
NaN์ typeof ํ๋ฉด number๋ก ์ทจ๊ธ.
๋ฌธ์ ๊ฐ์
1. cur์ ์ธ์ ๊ฐ์ด ์ซ์๋ก ๋ณํ์ด ๊ฐ๋ฅํ์ง ์ฌ๋ถ๋ฅผ ํ์
ํ ์ ์๋ ํจ์ isNaN ๋ฉ์๋๋ฅผ
2. every ๋ฉ์๋๋ฅผ ํตํด ์ํํ์ฌ ์ฐธ ๊ฑฐ์ง ํ๋ณ.
#1
function alpha_string46(s) {
return s.length == 4 || s.length == 6 ? !isNaN(s) : false
}
ํ์ด
s์ ์ธ์๋ก ์ ๋ฌ ๋๋ ๋ฌธ์์ด์ด ์ซ์ํ ๋ณํ์ด ๊ฐ๋ฅํ์ง ์ผํญ์ฐ์ฐ์๋ก ํ๋ฒ์ ์ฌ๋ถ ํ์
.
๊ทธ๋ฌ๋ ์ง๊ธ ์ฝ๋์ ๋ฌธ์ ์ ์ผ๋ก๋ ์ธ์ ๊ฐ์ด ์ง์๋ก ์ค๊ฒ๋๋ฉด ํ ์คํธ ์ผ์ด์ค๋ฅผ ํต๊ณผํ์ง ๋ชป ํ๋ค.
s = "1e22"
๋์ ์ฝ๋์ฒ๋ผ split์ผ๋ก ํ๋์ฉ ์ชผ๊ฐ์ด ๊ตฌ๋ถํ๋ ๊ฒ๋ ๋ฐฉ๋ฒ์ด ๋ ๊ฒ ๊ฐ๋ค.
#2
function alpha_string46(s){
var regex = /^\d{6}$|^\d{4}$/;
return regex.test(s);
}
ํ์ด
์ ๊ท ํํ์ ๋ฉ์๋ test๋ฅผ ์ฌ์ฉํ์ฌ ํจ์๋ฅผ ๊ตฌํํ ๋ฐฉ์์ด๋ค.
์ ๊ท ํํ์์ ์์ง ์ ๋ค๋ฃฐ ์ค ๋ชฐ๋ผ ์ ๊ทผํ๊ธฐ๊ฐ ์ด๋ ค์ด ๊ฒ ๊ฐ๋ค..