[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ๋ฌธ์์ด ๋ด 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 |
function solution(s){
var answer = true
var p = [] , y = [];
let splits = s.toLowerCase().split('')
for(let i=0; i<splits.length; i++){
if(splits[i] ==='p') p.push('p');
if(splits[i] ==='y') y.push('y');
}
if(p.length !== y.length ) answer = false;
return answer
}
์ ๊ทผ ๋ฐฉ๋ฒ
1. ๋ฌธ์์ด์ ๊ฐ๋ณ๋ก ์๋ผ์ฃผ์ด ๋ฐฐ์ด๋ก ๋ฐํํ ๊ฒ
2. ํด๋น ๋ฐฐ์ด์ ๋น๊ต ๋ฐ๋ณตํ์ฌ P์ y์ ๊ฐ๋ง์ ์ถ์ถ ํ ๊ฒ.
3. ์ถ์ถ๋ ๊ฐ์ ๋น ๋ฐฐ์ด์ ๋ฃ์ ๊ฒ
4. ์ถ์ถ๋ ๋ฐฐ์ด๋ค์ ๊ธธ์ด๋ฅผ ๋น๊ตํ ๊ฒ
function solution(s){
var answer = true
var p, y =[];
let splits = s.toLowerCase().split('')
for(let i=0; i<splits.length; i++){
if(i ==='p') p.psuh('p')
if(i ==='y') y.push('y')
if(p.length === y.length ) answer
}
return p
}
๊ทธ๋ ๊ฒ ๋ฌธ์ ์ ๊ทผ์ ํด์ ํด๋น ํ์ด๊น์ง ์๊ฐํ ์ ์์์ง๋ง ํด๋น ์ฝ๋์ ๋ฌธ์ ๊ฐ ๋ฌด์์ธ์ง ๋ชจ๋ฅด๊ฒ ์ด์ gpt์๊ฒ ๋ฌผ์ด๋ดค๋ค.
ํด๋น ๋ฌธ์ ์ ์์ ๊ธฐ๋ณธ ๊ฐ๋
๊ณผ๋ ๊ฐ์ ๋ฌธ์ ๋ฅผ ์ค์ ํ ์ ์ ์ฐพ์๋ณด์๋ค.
1. ๋ณ์ ์ ์ธ์์ ์ด๋ฆ์ ํ๋ฒ์ ์ ์ธํ ์ ์์ง๋ง, ๋ณ์ ๋ณ ์ด๊ธฐ๊ฐ์ ๊ฐ๋ณ๋ก ํ ๋น ํด์ผํ๋ ๋ฌธ์ .
let p, y = ""
let p = "", y = ""
์์ ๊ฐ์ ์์ผ๋ก ์์ ํ์ด์ผ ํ๋ค. ๊ทธ๋ ์ง์์ผ๋ฉด y๋ ๋น ๋ฌธ์์ด์ด ํ์ฑ๋์ง๋ง p์ ํ ๋น ๋ ๊ฐ์ undefined๋ก ํ ๋น๋๊ธฐ ๋๋ฌธ์ ์๋ฌด๋ฐ ์์ด ํ์ฑ๋์ง ์๋๋ค.
if(i === 'p')
if(splits[i] === 'p')
์์ ๊ฐ์ด ์์ ์ด ๋์ด์ผ splits์ ํด๋น ์ธ๋ฑ์ค์ ์กด์ฌํ๋ ๊ฐ๊ณผ ๋น๊ตํ ์ ์๋ ๊ฒ.
๋ค์์๋ ์ง๊ธ๊ณผ ๊ฐ์ ์ค์๋ฅผ ๋ฐ๋ณตํ์ง ๋ง์.
๋ค๋ฅธ ์ฌ๋ ํ์ด
ํ์ด #.1
function numPY(s){
//ํจ์๋ฅผ ์์ฑํ์ธ์
return s.toUpperCase().split("P").length === s.toUpperCase().split("Y").length;
}
split( )๋ฉ์๋์ ํด๋น ๋ฌธ์์ด๋ง ์ ์ฉํ์ฌ ์ถ์ถ์ด ๊ฐ๋ฅํ ์ฌ์ค์ ์๊ฒ๋๋ค.
ํ์ด #.2
function solution(s){
return [...s.toLowerCase()].reduce((acc, cur) => {
if(cur ==='p') return acc + 1;
else if(cur ==='y') return acc - 1;
return acc;
}, 0) ? false : true;
}
[...]์คํ๋ ๋ ๋ฌธ๋ฒ์ ์ ์ฉํด ํด๋น ๋ฌธ์์ด์ ์์๋ฅผ ์์งํ๊ณ ๋๊ดํธ([ ])๋ก ๊ฐ์ธ ๋ฐฐ์ด๋ก ๋ง๋ ๊ฒ์ด ์ธ์ ๊น์๋ค.
์คํ๋ ๋ ๋ฌธ๋ฒ์ for..of์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๋ด๋ถ์์ ์ดํฐ๋ ์ดํฐ(iterator, ๋ฐ๋ณต์)๋ฅผ ์ฌ์ฉํด ์์๋ฅผ ์์งํฉ๋๋ค.
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ์ ์ ์ ๊ณฑ๊ทผ ํ๋ณ
๋ฌธ์ ์ค๋ช
์์์ ์์ ์ ์ n์ ๋ํด, n์ด ์ด๋ค ์์ ์ ์ x์ ์ ๊ณฑ์ธ์ง ์๋์ง ํ๋จํ๋ ค ํฉ๋๋ค.
n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด๋ผ๋ฉด x+1์ ์ ๊ณฑ์ ๋ฆฌํดํ๊ณ , n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด ์๋๋ผ๋ฉด -1์ ๋ฆฌํดํ๋ ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ์ฌํญ
n์ 1์ด์, 50000000000000 ์ดํ์ธ ์์ ์ ์์
๋๋ค.
์ ์ถ๋ ฅ ์
n | return |
---|---|
121 | 144 |
3 | -1 |
function solution(n) {
var answer = Math.sqrt(n)
if(!Number.isInteger(answer)) return -1
return Math.pow(answer+1,2)
}
์ ๊ทผ ๋ฐฉ๋ฒ
1. ํด๋น ์์ ์ ๊ณฑ๊ทผ์ด ๋ฌด์์ธ์ง ํ๋ณํ๋ Math.sqrt๋ฅผ ํตํด ์ ๊ณฑ์ด ๋๋ ์๋ฅผ ๊ตฌํ๊ณ
2. ์ ์์ธ์ง ์๋์ง ํ๋ณํ๊ธฐ ์ํด Number.inInteger ๋ฉ์๋๋ฅผ ์ฌ์ฉ
3. ๋ง์ง๋ง ํด๋น ์ ๊ณฑ๊ทผ+1์ ์ ๊ณฑ ์๊น์ง ๊ตฌํด์ฃผ๋ ํจ์๋ฅผ ๊ตฌํ.
๋ค๋ฅธ ์ฌ๋ ํ์ด
์ง๊ธ์ ์ฝ๋๋ฅผ ๊ฐ์ ํ ์ ์๋ ๋ฐฉ๋ฒ์ด ๋ฌด์์ผ๊น ๋ฌผ์ด๋ณด๊ฒ ๋๋ค.
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1: ์ ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ
๋ฌธ์ ์ค๋ช
ํจ์ solution์ ์ ์ n์ ๋งค๊ฐ๋ณ์๋ก ์
๋ ฅ๋ฐ์ต๋๋ค. n์ ๊ฐ ์๋ฆฟ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํ ์๋ก์ด ์ ์๋ฅผ ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 118372๋ฉด 873211์ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ์ฌํญ
n์ 1์ด์ 8000000000 ์ดํ์ธ ์์ฐ์์
๋๋ค.
์ ์ถ๋ ฅ ์
n | return |
---|---|
118372 | 873211 |
function solution(n) {
var answer = n.toString().split('').sort((a,b) => b - a).join('')
return parseInt(answer);
}
์ ๊ทผ ๋ฐฉ๋ฒ
1. ๋ฐ์์จ ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํ ํ split ๋ฉ์๋๋ฅผ ํตํด ๋ฐฐ์ด๋ก ๋ฐํ
2. sort ๋ฉ์๋๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
3. join ๋ฉ์๋๋ก ('')๋ฅผ ์์ค ๋ณํฉ๋ ๋ฌธ์์ด ๋ฐํ
4. return ๊ฐ์ pareseInt๋ฅผ ํตํด ์ซ์๋ก ํ๋ณํ ํด์ฃผ์๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด
์ด ์ญ์ ์ฝ๋ ๊ฐ์ ๋ฐฉ๋ฒ์ด ์์๊น ํด์ ๋ฌผ์ด๋ณด์๋ค.
์ต๊ณ ์ ์นญ์ฐฌ์ด ์๋๊ฐ..ใ ใ ๊พธ์คํ ๊ณ์ํด์ ํ๋ค๋ณด๋ฉด ๋์ฑ ์ค๋ ฅ์ ์์ ์ ์์ ๊ฒ์ด๋ผ ๋ฏฟ๊ณ ์ง๊ธ์ ๋ต๋ณ์ ๊ณ๊ธฐ๋ก ๋์ฑ ์ฑ์ฅํ ๊ฐ๋ฐ์๊ฐ ๋๋๋ก ๋ ธ๋ ฅํด์ผ๊ฒ ๋ค!