function solution(n) {
return String(n).split("").reverse().map(v=> Number(v));
}
๊ฐ์ฅ ๋จ์ํ๊ฒ ์๊ฐ๋์ ์ด๋ ๊ฒ ํ์๋๋ฐ,
์๋๋ฉด์์ ์ข์ ์ฝ๋๋ ์๋ ๊ฒ ๊ฐ๋ค.
<๋ฌธ์ >
์์ฐ์ n์ ๋ค์ง์ด ๊ฐ ์๋ฆฌ ์ซ์๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ํํ๋ก ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 12345์ด๋ฉด [5,4,3,2,1]์ ๋ฆฌํดํฉ๋๋ค.
<์ ํ ์กฐ๊ฑด>
n์ 10,000,000,000์ดํ์ธ ์์ฐ์์ ๋๋ค.
๋๋ ๋น์ฐํ 0์ด ์์ฐ์๊ฐ ์๋๋๊น ๊ณ ๋ ค ์ํ๋๋ฐ,
์ด์ฐ์ํ(?) ์์๋ 0์ด ํฌํจ๋๋ ๊ฒฝ์ฐ๋ ์๋ค๊ณ ํ๋ค.
๊ทธ์น๋ง ์ด์ฐ์ํ์ด ๋ ์์ธ์ ์ธ ๊ฒฝ์ฐ๋๊น 0์ด ํฌํจ๋๋ ๋ฒ์๋ผ๋ ๋ง์ด ์๋ค๋ฉด ์ผ๋ฐ ์ํ์ผ๋ก ์๊ฐํด์ผ๊ฒ ๋ค!
+ ํ
ํ์ดํ ํจ์์์ ์ธ์๋ ๋ฉ์๋๊ฐ ๋ฐ๋ ์ธ์๋ ๊ฐ์ ๋ ์๋ต์ด ๊ฐ๋ฅํ๊ฑฐ๋ ๊ฐ์ ๋งฅ๋ฝ
.map(v=> Number(v));
์ด ๋ถ๋ถ์ ์กฐ๊ธ ๋ ๊ฐ๋จํ๊ฒ ์์ฑํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
.map(Number);
// Number() ํจ์๋ฅผ ์ง์ ์ฝ๋ฐฑํจ์๋ก ์ ๋ฌ
// map() ๋ฉ์๋๋ ๋ฐฐ์ด์ ๊ฐ ์์์ ๋ํด Number() ํจ์๋ฅผ ํธ์ถํ๋ฉฐ ๊ฐ์ ๋์
//Number() ํจ์๊ฐ ์
๋ ฅ๊ฐ์ ๋ฐ์ ์ซ์๋ก ๋ณํํ๋ ํจ์์ด๊ธฐ ๋๋ฌธ์ map(v =>Number(v)) ์์ v๋ฅผ ์๋ต ๊ฐ๋ฅ
//ํ์ง๋ง map(v => Number(v+1)) ์ธ๊ฒฝ์ฐ์๋ map(Number(v+1))์ผ๋ก ํํํ ์ ์์ต๋๋ค
//---> map ๋ฉ์๋๋ ์ธ์๋ฅผ ์ฝ๋ฐฑ์ด ๋ค์ด๊ฐ์ผํ๋๋ฐ Number(v+1)์ ํจ์ ์คํ!
๋ฌดํผ,
๊ทธ๋๋ 0์ด ํฌํจ๋๋ ๊ฒฝ์ฐ์ ์ซ์์์ ์๋ฆฌ์๋ฅผ ์ป๋ ๋ฐฉ์์ ๋ค๋ฅด๊ฒ ์ฐพ์๋ณด์.
function solution(n) {
const result = [];
while(n > 0 ){
result.push(n % 10);
n = Math.floor(n / 10);
}
return result;
}
์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉ๋๋ ๋ฐฉ์.
10์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๋ฐฐ์ด์ ๋ฃ๋๋ค.
์๋ ์๋ฅผ 10์ผ๋ก ๋๋ ํ ์ฌํ ๋น ํด์ค๋ค.
์๋ ์๊ฐ ์์ด์ง ๋๊น์ง ๋ฐ๋ณตํ๋ค.
1์ ์๋ฆฌ ์ ๋ถํฐ ๋ค์ด๊ฐ๊ฒ ๋๋ค.
์์์ ์ ๋ค๋ฃจ๋ ๋ฐฉ์์์๋ ๊ณ ๋ คํ ๊ฒ์ด ๋ง๋ค.
parseInt(n / 10)์ ํ๋ฉด ์ ์๊ฐ ๋์ค์ง๋ง ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ฉด parseInt(n / 10)์ ๋ถ๋์์์ ์ค์ฐจ๋ฅผ ๋ฐ์ํฉ๋๋ค. ๊ทธ๋์ Math.floor(n / 10)์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ์์ ํฉ๋๋ค.
Math.floor ํจ์๋ ์ฃผ์ด์ง ์ซ์๋ฅผ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฎ์ ์ ์๋ก ๋ฐ์ฌ๋ฆผํฉ๋๋ค. ==> ์ ํํ ์ ์๊ฐ ์๋์ฌ๋ ์ฌ๋ฐ๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด์
์ ๋ฆฌ :
parseInt ์ด๋ฒ ๋ฌธ์ ์์๋ ์ ์์ ์ผ๋ก ์๋ํ์ง๋ง ๋ถ๋์์์ ์ค์ฐจ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ ์์ต๋๋ค. --> Math.floor๋ก ์ฌ์ฉํ๋ ๊ฒ์ด ์์ ์ถ๊ฐ ์ด์ :
parseInt๋ ๋ฌธ์์ด์ ์ซ์๋ก ๋ณํํ๋๋ก ์ค๊ณ๋ ํจ์
์ซ์๋ฅผ ์ ์๋ก ๋ฐ์ฌ๋ฆผํ๋๋ก ์ค๊ณ๋ ํจ์: Math.floor(), Math.ceil(), Math.round()
function solution(n) {
let len = Math.floor(Math.log10(n)) + 1;
let answer = new Array(len);
for (let i = 0; i < len; i++) {
answer[i] = n % 10;
n = Math.floor(n / 10);
}
return answer;
}
log ๋ฅผ ์ด์ฉํด ํ๋ณํ์ ํ์ง ์๊ณ ๊ตฌํ ์ ์๋ ํ์ด.
Array ์ ์ธ๋ฌธ์ ์ด์ฉํ ์ด์ -> push ๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ง์๋๋ก ๋๋ฆด ์ ์๊ธฐ ๋๋ฌธ์,
๋ฏธ๋ฆฌ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ ํด๋๊ณ for ๋ฌธ์ ์ด์ฉํด์ ์ฐจ๋ก๋ก ๋ฃ์ด์ค ๊ฒ.
๋ก๊ทธ ์๋ฆฌ
a ๋ฅผ x ๋ฒ ๊ณฑํ๋ฉด B ๊ฐ ๋๋ค.
log a B = x;
a ** x = B;