y_flm's Blog

function solution(array) {
    let count = {};
    let maxValue = 0;
    let maxKeys = [];
    
    for(let num of array) {
        count[num] = (count[num] + 1) || 1;
    }
    
    for (let key in count) {
         if (count[key] > maxValue) {
             maxValue = count[key];
             maxKeys = [key];
         } else if (count[key] === maxValue) {
             maxKeys.push(key);
         }
    }

  return maxKeys.length > 1 ? -1 : Number(maxKeys[0]);

}

나는 객체를 이용해서 문제를 풀었다.

먼저 배열을 순회하며 각 요소와 요소에 대한 카운트 값을 count 객체에 넣어준다.

count 객체에 대해 만약 count[key] 값이 maxValue보다 크면 maxValue에 count[key] 값을 넣어준다.

그리고 maxKeys에 해당 키를 넣어준다.

하지만 count[key]와 maxValue가 똑같다면 maxKeys에 해당 키를 푸쉬해준다.

둘의 다른 점은 push할 때는 [1, 2] 이런식으로 마지막 요소 다음에 하나씩 추가되는 것이고,

maxKeys = [key]는 maxKeys에 [key]를 덮어씌우는 것이다.

그러므로 기존에 [1, 2]가 있었더라도 maxKeys=[3]을 해버리면 maxKeys는 [3]만 들어있게 된다.

따라서 maxKeys의 길이가 1 이상이면 같은 값이 여러 개인 것이므로 -1을 리턴해주고 아니라면 maxKeys[0]을 리턴한다.

function solution(code) {
    let result = [];
    let mode = 0;
    
    [...code].forEach((val, i) => {
        if(val !== '1') {
            if(mode) {
                if(i % 2 !== 0) result.push(val);
            } else {
                if(i % 2 === 0) result.push(val);
            }
        } else {
            mode = !mode;
        }
    })
    
    return result.length ? result.join('') : 'EMPTY';
}

먼저 forEach로 code를 순회한다.

만약 현재 값 val이 1이 아닐 경우에는 mode의 값에 따라 result에 val을 넣어주면 된다.

0이면 false, 0이 아니면 true이므로 이런 성질을 이용해서 mode 값을 비교해줬다.

따라서 mode는 0부터 시작하니 false로 시작하게 되는 것이고 false면 홀수 인덱스, true면 짝수 인덱스 요소를 넣어준다.

만약 val이 1이면 mode를 반전시켜주면 된다.

마지막으로 반복문을 통해 처리한 result의 길이를 기준으로 값을 리턴해주면 된다.

result가 비어있지 않으면 문자열로 반환해주고 비어있으면 EMPTY를 반환해주면 된다.

function solution(polynomial) {
    let xResult = 0;
    let sum = 0;
    
    polynomial.split(' + ').forEach((val) => {
        if(val.includes('x')) {
            let num = val.replace('x', '');
            xResult += (num === '' ? 1 : Number(num));
        } else {
            sum += Number(val);
        }
    })
    
       if(xResult === 0) {
        return `${sum}`;
    }
    
    if(xResult === 1) {
        return sum === 0 ? 'x' : `x + ${sum}`;
    }
    
    return sum === 0 ? `${xResult}x` : `${xResult}x + ${sum}`;
}

먼저 polynomial을 +를 기준으로 배열로 나누어주고, forEach로 값을 순회한다.

만약 해당 값에 x가 포함된다면, x는 replace를 통해 비어준 후 xResult에 값을 더해준다.

여기서 만약 num이 비어있으면 생략된 숫자 1이므로 1을 더해주고 아니면 숫자로 변환한 num 값을 더해준다.

만약 값에 x가 포함되지 않는다면 그냥 자연수이므로 sum에 해당 값을 더해준다.

이렇게 계산된 값을 가지고 올바르게 리턴해주기만 하면 된다.

만약 xResult가 0이면 자연수뿐이므로 sum만 리턴해주고,

만약 xResult가 1이고 sum이 0이면, 1은 생략해야하니까 x만 리턴해주고 sum이 0이 아니면 x + sum을 리턴해준다.

만약 xReulst가 0도 1도 아니라면, sum이 0일 때는 xReulstx만 리턴해주고, 0이 아니면 xResultx + sum을 리턴해주면 된다.

function solution(spell, dic) {
     const sortedSpell = spell.sort().join('');
    
    for (let word of dic) {
        const sortedWord = word.split('').sort().join('');
        
        if (sortedSpell === sortedWord) {
            return 1;
        }
    }
    
    return 2;
}

찾기 쉽도록 spell과 dic의 각 단어들을 정렬해준다.

그럼 반복문을 통해 정렬된 단어와 정렬된 spell이 같으면 1, 아니면 2를 반환하게 된다.

function gcd(a, b) {
  while (b !== 0) {
    let temp = b;
    b = a % b;
    a = temp;
  }
  return a;
}

function lcm(a, b) {
  return Math.abs(a * b) / gcd(a, b);
}

function solution(numer1, denom1, numer2, denom2) {
    let commonDenom = lcm(denom1, denom2);
    
    numer1 *= Math.floor(commonDenom / denom1);
    numer2 *= Math.floor(commonDenom / denom2);
    let sumNumer = numer1 + numer2;
    
    let commonGcd = gcd(sumNumer, commonDenom);
    sumNumer /= commonGcd;
    commonDenom /= commonGcd;

    return [sumNumer, commonDenom];
}

분수를 더하려면 공통 분모를 만들어줘야하고, 그러기 위해서는 최소공배수를 구해주면 된다.

기약분수를 만들기 위해서 최대공약수도 필요하므로 최대공약수와 최소공배수를 구하는 함수를 만들어준다.

그 후 분모의 최소공배수를 commonDenom에 저장해주고, 각 분자에 분자 * 공통 분모 / 기존 분모 값을 해준다.

그렇게해서 계산된 분자 1, 2를 더해서 sumNumer에 저장해준다.

그 다음 기약분수를 만들어주기 위해 최대공약수를 구해서  commonGcd에 넣어주고,

더해진 분자와 공통 분모를 각각 최대공약수로 나눠준다.

마지막으로 계산된 분자와 분모를 리턴 값에 맞게 반환해주면 끝!

function solution(a, b) {
    let min = Math.min(a, b);
    let numerator = a;
    let denominator = b;
    
    for(let i = 2; i <= min; i++) {
        if(numerator % i === 0 && denominator % i === 0) {
            numerator = Math.floor(numerator / i);
            denominator = Math.floor(denominator / i);
        }
    }
    
    while(denominator !== 1) {
        if(denominator % 2 === 0) {
            denominator = Math.floor(denominator / 2);
        } else if(denominator % 5 === 0) {
            denominator = Math.floor(denominator / 5);
        } else {
            return 2;
        }
    }
    
    return 1;
}

먼저 기약분수로 변환하기 위해 두 수 중 더 작은 수를 찾아 min 변수에 넣어주고,

for문에서는 2부터 min까지의 수를 통해 각각 나눠지는 숫자일 때 분자와 분모를 나눠준다.

그 다음 기약분수는 만들어졌으니 while문을 통해 분모의 소인수가 2, 5뿐인지 판별해준다.

조건은 분모가 1이되면 멈추도록 해주고 분모를 각각 2와 5로 나누었을 때 나머지가 0이 되는 경우에만

분모와 2 또는 5로 나눈 몫을 분모에 저장해준다.

여기서 2와 5로 나누어지지 않는다면 무한 소수이므로 2를 리턴해주고,

정상적으로 while문이 종료되면 유한소수일테니 1을 리턴해준다.

function solution(babbling) {
    let words = ['aya', 'ye', 'woo', 'ma'];
    let count = 0;

    for(let i = 0; i < babbling.length; i++) {
        let word = babbling[i];
        
        for(let j = 0; j < words.length; j++) {            
            if(word.includes(words[j])) {
                word = word.replace(words[j], ' ');
                
                if(word.trim().length === 0) {
                    count++;
                    break;
                }
            }
        }
    }
    
    return count;
}

먼저 문제에서 제시된 단어들을 배열로 선언해준다.

먼저 babbling의 첫단어를 word에 넣어주고,

만약 word에 제시된 단어가 포함된다면 replace를 통해 해당 단어를 빈 공간으로 바꿔준다.

여기서 그냥 여백이 아닌 빈 공간을 넣어주는 이유는 word가 wyeoo인 경우,

먼저 ye가 없어지면서 woo라는 단어로 바뀌게 되는데 그렇게 되면 연속된 문자가 아니라 포함되는 문자로 없애게 되므로

문제가 원하는대로 작동하지 않기 때문에 일부러 빈공간을 넣어주는 것이다.

이렇게 단어를 없애주다가 word에 여백을 없애준 후의 길이가 0이라면 조건이 충족하므로 count를 증가시켜준다.

그 후 반복문이 끝나고 count를 반환해주면 정답이다.

function 최대공약수(x, y) {
    while (y !== 0) {
        let temp = y;
        y = x % y;
        x = temp;
    }
    return x;
}

function 최소공배수(x, y) {
    for(let i = 1; ; i++) {
        let check = true;
        
        if((y * i) % x !== 0) {
            check = false;
        }
        
        if(check) {
            return y * i;
        }
    }
}

function solution(n, m) {
    return [최대공약수(n, m), 최소공배수(n, m)];
}

단순히 두 수의 최대공약수와 최소공배수를 구하는 문제이므로

최대공약수를 반환하는 함수와 최소공배수를 반환하는 함수를 따로 만들어주었다.

근데 공식을 보면 두 수의 곱을 최대공약수로 나눠주면 최소공배수라고 한다 ㅎㅎ .. 

 그럼 아래와 같이 바꿀 수 있다.

function 최대공약수(x, y) {
    while (y !== 0) {
        let temp = y;
        y = x % y;
        x = temp;
    }
    return x;
}

function solution(n, m) {
    return [최대공약수(n, m), (n * m) / 최대공약수(n, m)];
}