๐ŸŒ  ๋ฌธ์ œ

N์ง„์ˆ˜ ๊ฒŒ์ž„
ํŠœ๋ธŒ๊ฐ€ ํ™œ๋™ํ•˜๋Š” ์ฝ”๋”ฉ ๋™์•„๋ฆฌ์—์„œ๋Š” ์ „ํ†ต์ ์œผ๋กœ ํ•ด์˜ค๋Š” ๊ฒŒ์ž„์ด ์žˆ๋‹ค. ์ด ๊ฒŒ์ž„์€ ์—ฌ๋Ÿฌ ์‚ฌ๋žŒ์ด ๋‘ฅ๊ธ€๊ฒŒ ์•‰์•„์„œ ์ˆซ์ž๋ฅผ ํ•˜๋‚˜์”ฉ ์ฐจ๋ก€๋Œ€๋กœ ๋งํ•˜๋Š” ๊ฒŒ์ž„์ธ๋ฐ, ๊ทœ์น™์€ ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

์ˆซ์ž๋ฅผ 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ฐจ๋ก€๋Œ€๋กœ ๋งํ•œ๋‹ค. ์ฒซ ๋ฒˆ์งธ ์‚ฌ๋žŒ์€ 0, ๋‘ ๋ฒˆ์งธ ์‚ฌ๋žŒ์€ 1, … ์—ด ๋ฒˆ์งธ ์‚ฌ๋žŒ์€ 9๋ฅผ ๋งํ•œ๋‹ค.
10 ์ด์ƒ์˜ ์ˆซ์ž๋ถ€ํ„ฐ๋Š” ํ•œ ์ž๋ฆฌ์”ฉ ๋Š์–ด์„œ ๋งํ•œ๋‹ค. ์ฆ‰ ์—ดํ•œ ๋ฒˆ์งธ ์‚ฌ๋žŒ์€ 10์˜ ์ฒซ ์ž๋ฆฌ์ธ 1, ์—ด๋‘ ๋ฒˆ์งธ ์‚ฌ๋žŒ์€ ๋‘˜์งธ ์ž๋ฆฌ์ธ 0์„ ๋งํ•œ๋‹ค.
์ด๋ ‡๊ฒŒ ๊ฒŒ์ž„์„ ์ง„ํ–‰ํ•  ๊ฒฝ์šฐ,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0, 1, 1, 1, 2, 1, 3, 1, 4, …
์ˆœ์œผ๋กœ ์ˆซ์ž๋ฅผ ๋งํ•˜๋ฉด ๋œ๋‹ค.

ํ•œํŽธ ์ฝ”๋”ฉ ๋™์•„๋ฆฌ ์ผ์›๋“ค์€ ์ปดํ“จํ„ฐ๋ฅผ ๋‹ค๋ฃจ๋Š” ์‚ฌ๋žŒ๋‹ต๊ฒŒ ์ด์ง„์ˆ˜๋กœ ์ด ๊ฒŒ์ž„์„ ์ง„ํ–‰ํ•˜๊ธฐ๋„ ํ•˜๋Š”๋ฐ, ์ด ๊ฒฝ์šฐ์—๋Š”
0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, …
์ˆœ์œผ๋กœ ์ˆซ์ž๋ฅผ ๋งํ•˜๋ฉด ๋œ๋‹ค.

์ด์ง„์ˆ˜๋กœ ์ง„ํ–‰ํ•˜๋Š” ๊ฒŒ์ž„์— ์ต์ˆ™ํ•ด์ ธ ์งˆ๋ ค๊ฐ€๋˜ ์‚ฌ๋žŒ๋“ค์€ ์ข€ ๋” ๋‚œ์ด๋„๋ฅผ ๋†’์ด๊ธฐ ์œ„ํ•ด ์ด์ง„๋ฒ•์—์„œ ์‹ญ์œก์ง„๋ฒ•๊นŒ์ง€ ๋ชจ๋“  ์ง„๋ฒ•์œผ๋กœ ๊ฒŒ์ž„์„ ์ง„ํ–‰ํ•ด๋ณด๊ธฐ๋กœ ํ–ˆ๋‹ค. ์ˆซ์ž ๊ฒŒ์ž„์ด ์ต์ˆ™ํ•˜์ง€ ์•Š์€ ํŠœ๋ธŒ๋Š” ๊ฒŒ์ž„์— ์ ธ์„œ ๋ฒŒ์น™์„ ๋ฐ›๋Š” ๊ตด์š•์„ ํ”ผํ•˜๊ธฐ ์œ„ํ•ด, ์ž์‹ ์ด ๋งํ•ด์•ผ ํ•˜๋Š” ์ˆซ์ž๋ฅผ ์Šค๋งˆํŠธํฐ์— ๋ฏธ๋ฆฌ ์ถœ๋ ฅํ•ด์ฃผ๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค๋ ค๊ณ  ํ•œ๋‹ค. ํŠœ๋ธŒ์˜ ํ”„๋กœ๊ทธ๋žจ์„ ๊ตฌํ˜„ํ•˜๋ผ.

๐ŸŒ  ์ž…๋ ฅ ํ˜•์‹

  • ์ง„๋ฒ• n, ๋ฏธ๋ฆฌ ๊ตฌํ•  ์ˆซ์ž์˜ ๊ฐฏ์ˆ˜ t, ๊ฒŒ์ž„์— ์ฐธ๊ฐ€ํ•˜๋Š” ์ธ์› m, ํŠœ๋ธŒ์˜ ์ˆœ์„œ p ๊ฐ€ ์ฃผ์–ด์ง„๋‹ค.
    2 โ‰ฆ n โ‰ฆ 16
    0 ๏ผœ t โ‰ฆ 1000
    2 โ‰ฆ m โ‰ฆ 100
    1 โ‰ฆ p โ‰ฆ m

๐ŸŒ  ์ถœ๋ ฅ ํ˜•์‹

ํŠœ๋ธŒ๊ฐ€ ๋งํ•ด์•ผ ํ•˜๋Š” ์ˆซ์ž t๊ฐœ๋ฅผ ๊ณต๋ฐฑ ์—†์ด ์ฐจ๋ก€๋Œ€๋กœ ๋‚˜ํƒ€๋‚ธ ๋ฌธ์ž์—ด. ๋‹จ, 10~15๋Š” ๊ฐ๊ฐ ๋Œ€๋ฌธ์ž A~F๋กœ ์ถœ๋ ฅํ•œ๋‹ค.

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

n t m p result
2 4 2 1 "0111"
16 16 2 1 "02468ACE11111111"
16 16 2 2 "13579BDF01234567"

๐Ÿงž ํ’€์ด

/*
n = ์ง„๋ฒ•
t = ๋ฏธ๋ฆฌ ๊ตฌํ•  ์ˆซ์ž์˜ ๊ฐฏ์ˆ˜
m = ๊ฒŒ์ž„์— ์ฐธ๊ฐ€ํ•˜๋Š” ์ธ์›
p = ํŠœ๋ธŒ์˜ ์ˆœ์„œ
*/

/*
2, 4, 2, 1์ผ ๋•Œ,
0 1 1 1 0
1 0 1 0
*/

function solution(n, t, m, p) {
    let i = 0;
    let turn = 1;
    let answer = [];
    while (answer.length !== t) {
        let convertedValue = i.toString(n).toUpperCase().split("");
        for (let e of convertedValue) {
            if (answer.length == t) {
                break;
            }
            if (turn === p) {
                answer.push(e);
            }
            turn += 1;
            if (turn > m) {
                turn = 1;
            }
        }
        i ++;
    }
    return answer.join("");
}

๐Ÿ’ก ์•Œ๊ฒŒ ๋œ ์ 

  • N์ง„๋ฒ•์„ ํ‘œํ˜„ํ•˜๊ธฐ ์œ„ํ•œ ๋ฉ”์†Œ๋“œ - toString(N)
  • ํ•ด๋‹น ๋ฌธ์ž์—ด์„ ๋ชจ๋‘ ๋Œ€๋ฌธ์ž๋กœ ๋ฐ”๊พธ๋Š” ํ•จ์ˆ˜ - toUpperCase()
  • ๋ฐฐ์—ด์˜ ๊ฐ ์›์†Œ๋ฅผ ๋Œ๊ธฐ ์œ„ํ•œ ๋ฐ˜๋ณต๋ฌธ - for (let element of array)
  • ํ•ด๋‹น ๋กœ์ง์œผ๋กœ ๊ตฌํ˜„ํ–ˆ์„ ๋•Œ, n์ง„๋ฒ• ์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜๊ณ , ์ด๋ฅผ ํ•˜๋‚˜์”ฉ ์ชผ๊ฐœ์„œ ๋ฐ˜๋ณต๋ฌธ์„ ๋Œ ๋•Œ, ๋„๋Š” ์™€์ค‘์— answer array์˜ ์›์†Œ๊ฐ€ t๋งŒํผ ์ฐจ๋ฒ„๋ฆฌ๋Š” ๊ฒฝ์šฐ๊ฐ€ ์žˆ์Œ. ๋”ฐ๋ผ์„œ ์ด์ค‘ ๋ฐ˜๋ณต๋ฌธ ์•ˆ์—์„œ ๋ฐ˜๋ณต์„ ํ•  ๋•Œ๋„, t ๊ฐฏ์ˆ˜๋ฅผ ๋„๋‹ฌํ•˜๋ฉด break๋ฅผ ํ†ตํ•ด, ๋ฐ˜๋ณต๋ฌธ์„ ์ข…๋ฃŒํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•  ๊ฒƒ

 

๐ŸŒ  ๋ฌธ์ œ

๋“ฑ์ฐจ์ˆ˜์—ด ํ˜น์€ ๋“ฑ๋น„์ˆ˜์—ด common์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ๋งˆ์ง€๋ง‰ ์›์†Œ ๋‹ค์Œ์œผ๋กœ ์˜ฌ ์ˆซ์ž๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • 2 < common์˜ ๊ธธ์ด < 1,000
  • -1,000 < common์˜ ์›์†Œ < 2,000
  • common์˜ ์›์†Œ๋Š” ๋ชจ๋‘ ์ •์ˆ˜์ž…๋‹ˆ๋‹ค.
  • ๋“ฑ์ฐจ์ˆ˜์—ด ํ˜น์€ ๋“ฑ๋น„์ˆ˜์—ด์ด ์•„๋‹Œ ๊ฒฝ์šฐ๋Š” ์—†์Šต๋‹ˆ๋‹ค.
  • ๋“ฑ๋น„์ˆ˜์—ด์ธ ๊ฒฝ์šฐ ๊ณต๋น„๋Š” 0์ด ์•„๋‹Œ ์ •์ˆ˜์ž…๋‹ˆ๋‹ค.

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

common result
[1, 2, 3, 4] 5
[2, 4, 8] 16

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • [1, 2, 3, 4]๋Š” ๊ณต์ฐจ๊ฐ€ 1์ธ ๋“ฑ์ฐจ์ˆ˜์—ด์ด๋ฏ€๋กœ ๋‹ค์Œ์— ์˜ฌ ์ˆ˜๋Š” 5์ด๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • [2, 4, 8]์€ ๊ณต๋น„๊ฐ€ 2์ธ ๋“ฑ๋น„์ˆ˜์—ด์ด๋ฏ€๋กœ ๋‹ค์Œ์— ์˜ฌ ์ˆ˜๋Š” 16์ด๋‹ค.

๐Ÿงž ํ’€์ด

function solution(common) {
    let isWhat = '';
    // ๋“ฑ์ฐจ, ๋“ฑ๋น„ ํŒ๋‹จ
    if (common[1] - common[0] != common[2] - common[1]) {
        isWhat = '๋“ฑ๋น„';
    } else {
        isWhat = '๋“ฑ์ฐจ';
    }
    if (isWhat === '๋“ฑ๋น„') {
        return common[common.length-1] * common[1] / common[0]; 
    } else {
        return common[common.length-1] + common[1] - common[0];
    }
}

๐ŸŒ  ๋ฌธ์ œ

์—ฐ์†๋œ ์„ธ ๊ฐœ์˜ ์ •์ˆ˜๋ฅผ ๋”ํ•ด 12๊ฐ€ ๋˜๋Š” ๊ฒฝ์šฐ๋Š” 3, 4, 5์ž…๋‹ˆ๋‹ค. ๋‘ ์ •์ˆ˜ num๊ณผ total์ด ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค. ์—ฐ์†๋œ ์ˆ˜ num๊ฐœ๋ฅผ ๋”ํ•œ ๊ฐ’์ด total์ด ๋  ๋•Œ, ์ •์ˆ˜ ๋ฐฐ์—ด์„ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ๋‹ด์•„ returnํ•˜๋„๋ก solutionํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • 1 ≤ num ≤ 100
  • 0 ≤ total ≤ 1000
  • num๊ฐœ์˜ ์—ฐ์†๋œ ์ˆ˜๋ฅผ ๋”ํ•˜์—ฌ total์ด ๋  ์ˆ˜ ์—†๋Š” ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ์—†์Šต๋‹ˆ๋‹ค.

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

num total result
3 12 [3, 4, 5]
5 15 [1, 2, 3, 4, 5]
4 14 [2, 3, 4, 5]
5 5 [-1, 0, 1, 2, 3]

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • num = 3, total = 12์ธ ๊ฒฝ์šฐ [3, 4, 5]๋ฅผ returnํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • num = 5, total = 15์ธ ๊ฒฝ์šฐ [1, 2, 3, 4, 5]๋ฅผ returnํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #3

  • 4๊ฐœ์˜ ์—ฐ์†๋œ ์ˆ˜๋ฅผ ๋”ํ•ด 14๊ฐ€ ๋˜๋Š” ๊ฒฝ์šฐ๋Š” 2, 3, 4, 5์ž…๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #4

  • ์„ค๋ช… ์ƒ๋žต

๐Ÿงž ํ’€์ด

function solution(num, total) {
    let answer = [];
    if (num % 2 != 0) {
        let a = parseInt(total / num);
        for (let i = a - parseInt(num/2); i <= a + parseInt(num/2); i++) {
            answer.push(i);
        }   
    } else {
        let a = parseInt(total / num);
        for (let i = a - parseInt(num/2) + 1; i <= a + parseInt(num/2); i++) {
            answer.push(i);
        }
    }
    return answer;
}

๐ŸŒ  ๋ฌธ์ œ

๋จธ์“ฑ์ด๋Š” ํฐ ์ข…์ด๋ฅผ 1 x 1 ํฌ๊ธฐ๋กœ ์ž๋ฅด๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด 2 x 2 ํฌ๊ธฐ์˜ ์ข…์ด๋ฅผ 1 x 1 ํฌ๊ธฐ๋กœ ์ž๋ฅด๋ ค๋ฉด ์ตœ์†Œ ๊ฐ€์œ„์งˆ ์„ธ ๋ฒˆ์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

์ •์ˆ˜ M, N์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, M x N ํฌ๊ธฐ์˜ ์ข…์ด๋ฅผ ์ตœ์†Œ๋กœ ๊ฐ€์œ„์งˆ ํ•ด์•ผํ•˜๋Š” ํšŸ์ˆ˜๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • 0 < M, N < 100
  • ์ข…์ด๋ฅผ ๊ฒน์ณ์„œ ์ž๋ฅผ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

M N result
2 2 3
2 5 9
1 1 0

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • ๋ณธ๋ฌธ๊ณผ ๋™์ผํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • ๊ฐ€๋กœ 2 ์„ธ๋กœ 5์ธ ์ข…์ด๋Š” ๊ฐ€๋กœ๋กœ 1๋ฒˆ ์„ธ๋กœ๋กœ 8๋ฒˆ ์ด ๊ฐ€์œ„์งˆ 9๋ฒˆ์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #3

  • ์ด๋ฏธ 1 * 1 ํฌ๊ธฐ์ด๋ฏ€๋กœ 0์„ return ํ•ฉ๋‹ˆ๋‹ค.

๐Ÿงž ํ’€์ด

function solution(M, N) {
    return M * N - 1;
}
๋”๋ณด๊ธฐ

๐ŸŒ  ๋ฌธ์ œ

๋ฌธ์ž์—ด "hello"์—์„œ ๊ฐ ๋ฌธ์ž๋ฅผ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•œ ์นธ์”ฉ ๋ฐ€๊ณ  ๋งˆ์ง€๋ง‰ ๋ฌธ์ž๋Š” ๋งจ ์•ž์œผ๋กœ ์ด๋™์‹œํ‚ค๋ฉด "ohell"์ด ๋ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์„ ๋ฌธ์ž์—ด์„ ๋ฏผ๋‹ค๊ณ  ์ •์˜ํ•œ๋‹ค๋ฉด ๋ฌธ์ž์—ด A์™€ B๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, A๋ฅผ ๋ฐ€์–ด์„œ B๊ฐ€ ๋  ์ˆ˜ ์žˆ๋‹ค๋ฉด ๋ฐ€์–ด์•ผ ํ•˜๋Š” ์ตœ์†Œ ํšŸ์ˆ˜๋ฅผ returnํ•˜๊ณ  ๋ฐ€์–ด์„œ B๊ฐ€ ๋  ์ˆ˜ ์—†์œผ๋ฉด -1์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • 0 < A์˜ ๊ธธ์ด = B์˜ ๊ธธ์ด < 100
  • A, B๋Š” ์•ŒํŒŒ๋ฒณ ์†Œ๋ฌธ์ž๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์Šต๋‹ˆ๋‹ค.

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

A B result
"hello" "ohell" 1
"apple" "elppa" -1
"atat" "tata" 1
"abc" "abc" 0

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • "hello"๋ฅผ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•œ ์นธ ๋ฐ€๋ฉด "ohell"๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • "apple"์€ ๋ช‡ ๋ฒˆ์„ ๋ฐ€์–ด๋„ "elppa"๊ฐ€ ๋  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #3

  • "atat"๋Š” ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•œ ์นธ, ์„ธ ์นธ์„ ๋ฐ€๋ฉด "tata"๊ฐ€ ๋˜๋ฏ€๋กœ ์ตœ์†Œ ํšŸ์ˆ˜์ธ 1์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #4

  • "abc"๋Š” ๋ฐ€์ง€ ์•Š์•„๋„ "abc"์ด๋ฏ€๋กœ 0์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

๐Ÿงž ํ’€์ด

function solution(A, B) {
    let cnt_l = 0;
    let cnt_r = 0;
    
    let a = A.split("");
    let b = B.split("");    
    let c = A.split("");
    let d = B.split("");

    // while (a.join("") != b.join("")) {
    //     if (cnt_l === a.length) {
    //         return -1
    //     }
    //     a.push(a.shift());
    //     cnt_l += 1;
    // }
    while (c.join("") != d.join("")) {
        if (cnt_r === c.length) {
            return -1
        }
        c.unshift(c.pop());
        cnt_r += 1;
    }
    return cnt_r;
}

๐ŸŒ  ๋ฌธ์ œ

1๋ถ€ํ„ฐ 13๊นŒ์ง€์˜ ์ˆ˜์—์„œ, 1์€ 1, 10, 11, 12, 13 ์ด๋ ‡๊ฒŒ ์ด 6๋ฒˆ ๋“ฑ์žฅํ•ฉ๋‹ˆ๋‹ค. ์ •์ˆ˜ i, j, k๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, i๋ถ€ํ„ฐ j๊นŒ์ง€ k๊ฐ€ ๋ช‡ ๋ฒˆ ๋“ฑ์žฅํ•˜๋Š”์ง€ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • 1 ≤ i < j ≤ 100,000
  • 0 ≤ k ≤ 9

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

i j k result
1 13 1 6
10 50 5 5
3 10 2 0

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • ๋ณธ๋ฌธ๊ณผ ๋™์ผํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • 10๋ถ€ํ„ฐ 50๊นŒ์ง€ 5๋Š” 15, 25, 35, 45, 50 ์ด 5๋ฒˆ ๋“ฑ์žฅํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ 5๋ฅผ return ํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #3

  • 3๋ถ€ํ„ฐ 10๊นŒ์ง€ 2๋Š” ํ•œ ๋ฒˆ๋„ ๋“ฑ์žฅํ•˜์ง€ ์•Š์œผ๋ฏ€๋กœ 0์„ return ํ•ฉ๋‹ˆ๋‹ค.

๐Ÿงž ํ’€์ด

function solution(i, j, k) {
    let answer = 0;
    let array = [];
    for (let n = i; n <= j; n ++) {
        array.push(n.toString().split("").map(Number));
    }
    while (array.length != 0) {
        let tmp = array.shift();
        for (e in tmp) {
            if (tmp[e] === k) {
                answer += 1;
            }
        }
    }
    return answer;
}

๐ŸŒ  ๋ฌธ์ œ

๋ฌธ์ž์—ด before์™€ after๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, before์˜ ์ˆœ์„œ๋ฅผ ๋ฐ”๊พธ์–ด after๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์œผ๋ฉด 1์„, ๋งŒ๋“ค ์ˆ˜ ์—†์œผ๋ฉด 0์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • 0 < before์˜ ๊ธธ์ด == after์˜ ๊ธธ์ด < 1,000
  • before์™€ after๋Š” ๋ชจ๋‘ ์†Œ๋ฌธ์ž๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์Šต๋‹ˆ๋‹ค.

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

before after result
"olleh" "hello" 1
"allpe" "apple" 0

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • "olleh"์˜ ์ˆœ์„œ๋ฅผ ๋ฐ”๊พธ๋ฉด "hello"๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • "allpe"์˜ ์ˆœ์„œ๋ฅผ ๋ฐ”๊ฟ”๋„ "apple"์„ ๋งŒ๋“ค ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

๐Ÿงž ํ’€์ด

function solution(before, after) {
    let b = before.split("").sort();
    let a = after.split("").sort();
    
    if (b.length != a.length) {
        return 0;
    }
    
    while (b.length != 0 && a.length != 0) {
        let tmp_b = b.shift();
        let tmp_a = a.shift();
        if (tmp_b != tmp_a) {
            return 0;
        }
    }
    return 1;
}

๐ŸŒ  ๋ฌธ์ œ

์ด์ง„์ˆ˜๋ฅผ ์˜๋ฏธํ•˜๋Š” ๋‘ ๊ฐœ์˜ ๋ฌธ์ž์—ด bin1๊ณผ bin2๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ๋‘ ์ด์ง„์ˆ˜์˜ ํ•ฉ์„ returnํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • return ๊ฐ’์€ ์ด์ง„์ˆ˜๋ฅผ ์˜๋ฏธํ•˜๋Š” ๋ฌธ์ž์—ด์ž…๋‹ˆ๋‹ค.
  • 1 ≤ bin1, bin2์˜ ๊ธธ์ด ≤ 10
  • bin1๊ณผ bin2๋Š” 0๊ณผ 1๋กœ๋งŒ ์ด๋ฃจ์–ด์ ธ ์žˆ์Šต๋‹ˆ๋‹ค.
  • bin1๊ณผ bin2๋Š” "0"์„ ์ œ์™ธํ•˜๊ณ  0์œผ๋กœ ์‹œ์ž‘ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

bin1 bin2 result
"10" "11" "101"
"1001" "1111" "11000"

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • 10 + 11 = 101 ์ด๋ฏ€๋กœ "101" ์„ returnํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • 1001 + 1111 = 11000 ์ด๋ฏ€๋กœ "11000"์„ returnํ•ฉ๋‹ˆ๋‹ค.

๐Ÿงž ํ’€์ด

function solution(bin1, bin2) {
    let a = parseInt(bin1, 2);
    let b = parseInt(bin2, 2);
    let c = a + b;
    return c.toString(2);
}

๐ŸŒ  ๋ฌธ์ œ

ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์น˜ํ‚จ์€ ์น˜ํ‚จ์„ ์‹œ์ผœ๋จน์œผ๋ฉด ํ•œ ๋งˆ๋ฆฌ๋‹น ์ฟ ํฐ์„ ํ•œ ์žฅ ๋ฐœ๊ธ‰ํ•ฉ๋‹ˆ๋‹ค. ์ฟ ํฐ์„ ์—ด ์žฅ ๋ชจ์œผ๋ฉด ์น˜ํ‚จ์„ ํ•œ ๋งˆ๋ฆฌ ์„œ๋น„์Šค๋กœ ๋ฐ›์„ ์ˆ˜ ์žˆ๊ณ , ์„œ๋น„์Šค ์น˜ํ‚จ์—๋„ ์ฟ ํฐ์ด ๋ฐœ๊ธ‰๋ฉ๋‹ˆ๋‹ค. ์‹œ์ผœ๋จน์€ ์น˜ํ‚จ์˜ ์ˆ˜ chicken์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ ๋ฐ›์„ ์ˆ˜ ์žˆ๋Š” ์ตœ๋Œ€ ์„œ๋น„์Šค ์น˜ํ‚จ์˜ ์ˆ˜๋ฅผ returnํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

๐ŸŒ  ์ œํ•œ์‚ฌํ•ญ

  • chicken์€ ์ •์ˆ˜์ž…๋‹ˆ๋‹ค.
  • 0 ≤ chicken ≤ 1,000,000

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ

chicken result
100 11
1,081 120

๐ŸŒ  ์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • 100๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•˜๋ฉด ์ฟ ํฐ์ด 100์žฅ ๋ฐœ๊ธ‰๋˜๋ฏ€๋กœ ์„œ๋น„์Šค ์น˜ํ‚จ 10๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • 10๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•˜๋ฉด ์ฟ ํฐ์ด 10์žฅ ๋ฐœ๊ธ‰๋˜๋ฏ€๋กœ ์„œ๋น„์Šค ์น˜ํ‚จ 1๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ๋”ฐ๋ผ์„œ 10 + 1 = 11 ์„ returnํ•ฉ๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • 1081๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•˜๋ฉด ์ฟ ํฐ์ด 1081์žฅ ๋ฐœ๊ธ‰๋˜๋ฏ€๋กœ ์„œ๋น„์Šค ์น˜ํ‚จ 108๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ฟ ํฐ์ด 1์žฅ ๋‚จ์Šต๋‹ˆ๋‹ค.
  • 108๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•˜๋ฉด ์ฟ ํฐ์ด 108์žฅ ๋ฐœ๊ธ‰๋˜๋ฏ€๋กœ ์„œ๋น„์Šค ์น˜ํ‚จ 10๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ฟ ํฐ์ด 8์žฅ ๋‚จ์Šต๋‹ˆ๋‹ค.
  • 10๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•˜๋ฉด ์ฟ ํฐ์ด 10์žฅ ๋ฐœ๊ธ‰๋˜๋ฏ€๋กœ ์„œ๋น„์Šค ์น˜ํ‚จ 1๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • 1๋งˆ๋ฆฌ๋ฅผ ์ฃผ๋ฌธํ•˜๋ฉด ์ฟ ํฐ์ด 1์žฅ ๋ฐœ๊ธ‰๋ฉ๋‹ˆ๋‹ค.
  • ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ์ฟ ํฐ์ด ์ด 10์žฅ์ด๋ฏ€๋กœ ์„œ๋น„์Šค ์น˜ํ‚จ 1๋งˆ๋ฆฌ๋ฅผ ์ถ”๊ฐ€๋กœ ์ฃผ๋ฌธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ๋”ฐ๋ผ์„œ 108 + 10 + 1 + 1 = 120 ์„ returnํ•ฉ๋‹ˆ๋‹ค.

๐Ÿงž ํ’€์ด

function solution(chicken) {
    let service = parseInt(chicken / 10);
    let coupon = chicken % 10;
    coupon += service;
    while (parseInt(coupon / 10) >= 1) {
        let new_service = parseInt(coupon / 10);
        service += new_service;
        coupon = coupon % 10;
        coupon += new_service;
    }
    return service;
}

+ Recent posts