๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

ํ”„์—” ๊ณต๋ถ€/๐Ÿซง ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ณต๋ถ€

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค level.1] ์ž์—ฐ์ˆ˜ ๋’ค์ง‘์–ด ๋ฐฐ์—ด๋กœ ๋งŒ๋“ค๊ธฐ

728x90
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;

 

 

728x90
๋ฐ˜์‘ํ˜•