스킬트리

해당 문제 링크

  • 처음엔 각 스킬을 키로, 인덱스를 값으로 갖는 객체를 만들어 풀려 했으나 스킬트리 내 스킬들 인덱스 비교가 어려워서 다른 방법을 찾다가 정규식으로 처리하는 방법을 찾음
1
2
3
4
5
6
7
function solution(skill, skill_trees) {
    let regex = new RegExp(`[^${skill}]`, 'g'); // 정규식으로 skill에 해당하지 않는(^) 글자를 찾게끔하기
    let isPossible = skill_trees.map(eachTree => eachTree.replace(regex, '')) // replace를 통해 스킬이 아닌것들을 죄다 빈 문자열로 변환
                                .filter(each => skill.substring(0, each.length) === each) 
                                // 정규식으로 필터링된 각 스킬트리를 substring으로 원래 스킬을 필터링된 문자열의 길이만큼 잘라내고 그 값이 스킬트리와 같은지 비교
    return isPossible.length; // isPossible 배열 내에는 배울 수 있는 스킬만 남을 것이므로 배열의 길이를 리턴
}

괄호 변환

해당 문제 링크

1
2
3
4
5
6
7
8
9
10
1. 입력이 빈 문자열인 경우, 빈 문자열을 반환합니다. 
2. 문자열 w를 두 "균형잡힌 괄호 문자열" u, v로 분리합니다. 단, u는 "균형잡힌 괄호 문자열"로 더 이상 분리할 수 없어야 하며, v는 빈 문자열이 될 수 있습니다. 
3. 문자열 u가 "올바른 괄호 문자열" 이라면 문자열 v에 대해 1단계부터 다시 수행합니다. 
  3-1. 수행한 결과 문자열을 u에 이어 붙인 후 반환합니다. 
4. 문자열 u가 "올바른 괄호 문자열"이 아니라면 아래 과정을 수행합니다. 
  4-1. 빈 문자열에 첫 번째 문자로 '('를 붙입니다. 
  4-2. 문자열 v에 대해 1단계부터 재귀적으로 수행한 결과 문자열을 이어 붙입니다. 
  4-3. ')'를 다시 붙입니다. 
  4-4. u의 첫 번째와 마지막 문자를 제거하고, 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙입니다. 
  4-5. 생성된 문자열을 반환합니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function solution(p) {
    if (p === '') return p; // 1. 입력이 빈 문자열인 경우, 빈 문자열을 반환합니다. 

    let left = 0, right = 0, pIndex = 0; // 레벨 1의 올바른 괄호처럼 left와 right를 나누기
    let isBalanced = true; // "균형잡힌 괄호 문자열"의 flag 변수

    do {
        if (p[pIndex] === '(') left++; 
        else right++;
        
        if(right > left) 
            isBalanced = false;
        pIndex++;
    } while (left !== right)
    
    let u = p.substr(0, pIndex);
    let v = p.substr(pIndex);

    if(isBalanced) {
        return u + solution(v);
    } else {
        u = u.substr(1, u.length - 2).replace(/[\(]|[\)]/g, a => a === ')' ? '(' : ')');
        v = `(${solution(v)})`;
            return v +u;
    }
}
  • 재귀적으로 구현하는 법에 대해서 완벽하게 이해하지 못해서 다른 사람 풀이를 참고함
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    function solution(p) {
      if (p.length < 1) return ""; // 1번

      let balance = 0; // 재귀적으로 호출될 때마다 0으로 초기화됨
      let pivot = 0; 
      do { 
          balance += p[pivot++] === "(" ? 1 : -1  // 좌측 괄호라면 1을 아니라면 -1을 더함  
      } while (balance !== 0); // 0이라면 "균형잡힌 괄호 문자열"

      const u = p.slice(0, pivot); // balance가 0이 아니라면 문자열 w를 두 "균형잡힌 괄호 문자열" u, v로 분리
      const v = solution(p.slice(pivot, p.length)); // v는 1부터 다시 수행해야 하므로 재귀적으로 함수를 호출 (u로 나눠진 부분 다음부터)

      if (u[0] === "(" && u[u.length - 1] == ")")  // 첫 괄호와 마지막 괄호를 검사해 "올바른 괄호 문자열"인지 확인
        return u + v; 
      else 
        return "(" + v + ")" + reverse(u); 
    }

    function reverse(str) {
      return str.slice(1, str.length - 1) // u의 첫 번째와 마지막 문자를 제거
                .split("")
                .map((c) => (c === "(" ? ")" : "(")) // 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙임
                .join(""); // 다시 문자열로 join하여 리턴
    }

    소수 찾기(레벨2)

    해당 문제 링크
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    function solution(numbers) {
       let answer = 0;
       let primeNums = [];

       let splitedNumbers = numbers.split('')

       const isPrime = num => {
           let count = 0;
           for(let i = 1; i <= num; i++) {
               if (num % i === 0) {
                   count++;
               }
               if (count >= 3) {
                   break;
               }
           }
           if (count === 2 && !primeNums.includes(num)) {
               primeNums.push(num);
           }
       }

       const createNumbers = (arr, str) => {
           if (arr.length > 0) {
               for (let i = 0; i < arr.length; i++) {
                   const temp = [...arr];
                   temp.splice(i, 1);
                   createNumbers(temp, str + arr[i])
               }
           }

           if (str.length > 0) {
               isPrime(+str);
           }
       }

       createNumbers(splitedNumbers, '');

       answer = primeNums.length;
       return answer;
    }