Take a Number And Sum Its Digits Raised To The Consecutive Powers And ….¡Eureka!! ( 6 kyu )

문제

The number 89 is the first integer with more than one digit that fulfills the property partially introduced in the title of this kata. What’s the use of saying “Eureka”? Because this sum gives the same number.

In effect: 89 = 8^1 + 9^2

The next number in having this property is 135.

See this property again: 135 = 1^1 + 3^2 + 5^3

We need a function to collect these numbers, that may receive two integers a, b that defines the range [a, b] (inclusive) and outputs a list of the sorted numbers in the range that fulfills the property described above.

Let’s see some cases:

sumDigPow(1, 10) == [1, 2, 3, 4, 5, 6, 7, 8, 9]

sumDigPow(1, 100) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

첫번째와 두번째 인자 사이에 해당 값이 각자릿수의 제곱합과 같은 수를 찾아 리턴하는 문제

풀이

function sumDigPow(a, b) {
  let result = [], arr, sum = 0;
  for ( let i = a; i <= b; i++ ) {
    arr = i.toString().split('').map(Number);
    sum = 0;
    for ( let j = 0; j < arr.length; j++ ) {
      sum += Math.pow(arr[j], j+1);
    }
    if ( i === sum ) {
      result.push(i);
    }
  }
  return result;
}

포문 두개로 구성해서 그냥 노가다 식으로 짰는데, 통과는 되었지만 좋은 코드는 아닌 것 같다.

다른 사람의 풀이

function sumDigPow(a, b) {
  var ans = [];
  while(a <= b){
    if(a.toString().split('').reduce((x,y,i)=>x + +y ** (i + 1),0) == a)
      ans.push(a);
    a++;
  }
  return ans;
}

접근은 같지만 조금더 간결하게 코드를 작성하는 방법

언제봐도 리듀스는 너무 어려움

리듀스 세번째 인자는 인덱스.. 메모..

Find the missing letter ( 6 kyu )

문제

Find the missing letter

Write a method that takes an array of consecutive (increasing) letters as input and that returns the missing letter in the array.

You will always get an valid array. And it will be always exactly one letter be missing. The length of the array will always be at least 2.
The array will always contain letters in only one case.

Example:

['a','b','c','d','f'] -> 'e'
['O','Q','R','S'] -> 'P'

연속된 알파벳 중 빠진 단어를 리턴하는 문제

풀이

function findMissingLetter(array) {
  let code = array[0].charCodeAt(0);
  for ( let i = 1; i < array.length; i++ ) {
    if ( code+1 === array[i].charCodeAt(0) ) {
      code = code+1
    } else {
      return String.fromCharCode(code+1);
    }
  }
}

가장 앞의 알파벳의 아스키코드를 code에 담고 포문을 돌려 다음 알파벳인지 비교하는 방법

만약 비어있다면 해당 알파벳을 리턴

다른 사람의 풀이

풀이 방법이 다 똑같음

Maximum subarray sum ( 5 kyu )

문제

The maximum sum subarray problem consists in finding the maximum sum of a contiguous subsequence in an array or list of integers:

maxSequence([-2, 1, -3, 4, -1, 2, 1, -5, 4])
// should be 6: [4, -1, 2, 1]

Easy case is when the list is made up of only positive numbers and the maximum sum is the sum of the whole array. If the list is made up of only negative numbers, return 0 instead.

Empty list is considered to have zero greatest sum. Note that the empty list or array is also a valid sublist/subarray.

배열에서 연속된 원소의 합이 최대일 때를 구하는 문제

풀이

var maxSequence = function(arr){
  let max = 0, sum = 0, j;
  for ( let i = 0; i < arr.length; i++ ) {
    sum = 0;
    j = i;
    while ( sum <= max ) {
      sum += arr[j]
      if ( sum > max ) {
        max = sum;
      }
      j++;
    }
  }
  return max
}

for, while로 a에 b의 원소들이 없을때까지 반복해서 리턴

다른 사람의 풀이

var maxSequence = function(arr){
  var min = 0, ans = 0, i, sum = 0;
  for (i = 0; i < arr.length; ++i) {
    sum += arr[i];
    min = Math.min(sum, min);
    ans = Math.max(ans, sum - min);
  }
  return ans;
}

포문 하나로 해결.

이게 더 좋은 코드

Build Tower ( 6 kyu )

문제

Build Tower by the following given argument:
number of floors (integer and always greater than 0).

for example, a tower of 3 floors looks like below

[
  '  *  ', 
  ' *** ', 
  '*****'
]

주어진 숫자만큼의 별탑을 쌓는 문제

풀이

function towerBuilder(nFloors) {
  let result = [];
  for ( let i = 1; i <= nFloors; i++ ) {
    result.push(' '.repeat(nFloors-i) + '*'.repeat(i*2-1) + ' '.repeat(nFloors-i))
  }
  return result
}

repeat메소드로 쉽게 해결

다른 사람의 풀이

function towerBuilder(n) {
  return Array.from({length: n}, function(v, k) {
    const spaces = ' '.repeat(n - k - 1);
    return spaces + '*'.repeat(k + k + 1) + spaces;
  });
}

Array.from 대체 무엇

Delete occurrences of an element if it occurs more than n times( 6 kyu )

문제

Given a list lst and a number N, create a new list that contains each number of lst at most N times without reordering. For example if N = 2, and the input is [1,2,3,1,2,1,2,3], you take [1,2,3,1,2], drop the next [1,2] since this would lead to 1 and 2 being in the result 3 times, and then take 3, which leads to [1,2,3,1,2,3].

Example

deleteNth ([1,1,1,1],2) // return [1,1]
deleteNth ([20,37,20,21],1) // return [20,37,21]

주어진 배열에서 같은 원소가 최대 n번만 나오게 한뒤 리턴하는 문제

풀이

function deleteNth(arr,n){
  let obj = {}, result = [];
  for ( let i = 0; i < arr.length; i++ ) {
    if ( !obj[arr[i]] ) {
      obj[arr[i]] = 1;
      result.push(arr[i]);
    } else if ( obj[arr[i]] === n ) {
      continue;
    } else {
      obj[arr[i]]++;
      result.push(arr[i]);
    }
  }
  return result;
}

obj에 조건을 달아 새로운 배열 result에 담아 리턴하는 방법.

다른 사람의 풀이

function deleteNth(arr,x) {
  var cache = {};
  return arr.filter(function(n) {
    cache[n] = (cache[n]||0) + 1;
    return cache[n] <= x;
  });
}

필터로 이렇게 접근하는 방법 좋은것 같고,

if문 대신에 파이프 ||로 처리한 방법도 굿

Find the divisors! ( 6 kyu )

문제

Create a function named divisors/Divisors that takes an integer and returns an array with all of the integer’s divisors(except for 1 and the number itself). If the number is prime return the string ‘(integer) is prime’ (null in C#) (use Either String a in Haskell and Result, String> in Rust).

Example:

divisors(12); // should return [2,3,4,6]
divisors(25); // should return [5]
divisors(13); // should return "13 is prime"

You can assume that you will only get positive integers as inputs.

약수 찾기

풀이

function divisors(integer) {
  let result = [];
  for ( let i = 2; i < integer; i++ ) {
    if ( Number.isInteger(integer/i) ) {
      result.push(i)
    }
  }
  return result.length !== 0 ? result : `${integer} is prime`;
};

설명할게 없다.

다른 좋은방법이 있을것 같은 문제

다른 사람의 풀이

없네..

Array.diff ( 6 kyu )

문제

Your goal in this kata is to implement an difference function, which subtracts one list from another.

It should remove all values from list a, which are present in list b.

array_diff([1,2],[1]) == [2]

If a value is present in b, all of its occurrences must be removed from the other:

array_diff([1,2,2,2,3],[2]) == [1,3]

b의 원소를 a에서 지워서 리턴하는 문제

풀이

function array_diff(a, b) {
  for ( let i = 0; i < b.length; i++ ) {
    while ( a.indexOf(b[i]) !== -1 ) {
      a = a.slice(0, a.indexOf(b[i])).concat(a.slice(a.indexOf(b[i])+1, a.length));
    }
  }
  return a;
}

for, while로 a에 b의 원소들이 없을때까지 반복해서 리턴

다른 사람의 풀이

function array_diff(a, b) {
  return a.filter(function(x) { return b.indexOf(x) == -1; });
}

고수..

Are they the "same"? ( 6 kyu )

문제

Given two arrays a and b write a function comp(a, b) (compSame(a, b) in Clojure) that checks whether the two arrays have the “same” elements, with the same multiplicities. “Same” means, here, that the elements in b are the elements in a squared, regardless of the order.

Examples

Valid arrays

a = [121, 144, 19, 161, 19, 144, 19, 11]  
b = [121, 14641, 20736, 361, 25921, 361, 20736, 361]

comp(a, b) returns true because in b 121 is the square of 11, 14641 is the square of 121, 20736 the square of 144, 361 the square of 19, 25921 the square of 161, and so on. It gets obvious if we write b’s elements in terms of squares:

a = [121, 144, 19, 161, 19, 144, 19, 11] 
b = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19]

array1 배열의 인자들을 제곱한 값이 array2에 있는지 비교하는 문제

풀이

function comp(array1, array2){
  if ( !array1 || !array2 ) return false;
  array1 = array1.map(a => { return a*a }).sort((a,b) => { return b-a });
  array2 = array2.sort((a,b) => { return b-a });
  for ( let i = 0; i < array1.length; i++ ) {
    if ( array1[i] !== array2[i] ) {
      return false;
    }
  }
  return true;
}

완전 별로인 풀이같다.

예외처리를 두개나 걸고 소트로 그냥 비교하는 방법

[1,2,3] === [1,2,3] 은 false인걸 처음알았다.. 역시난 허접

다른 사람의 풀이

function comp(array1, array2) {
  if(array1 == null || array2 == null) return false;
  array1.sort((a, b) => a - b); array2.sort((a, b) => a - b);
  return array1.map(v => v * v).every((v, i) => v == array2[i]);
}

예외처리 하나 걸고 소트로 비교