중복순열 유형 문제 - 가위바위보

문제

• 중복순열 문제이다.
• 선택 가능한 모든 경우의 수를 구해야한다.
• 입력 : 게임의 수(주어지지 않는 경우엔 3번의 게임을 디폴트값으로 한다)
• 출력 : 2차원 배열
• 주의사항 : 배열의 순서는 가중치 적용 정렬한다.
  중요도는 'rock', 'paper', 'scissors' 순이다.

[
      ["rock", "rock", "rock"],
      ["rock", "rock", "paper"],
      ["rock", "rock", "scissors"],
      ["rock", "paper", "rock"],
      // ...etc ...
    ]

풀이

const rockPaperScissors = function (num) {
  num = num || 3;

  const lookup = ['rock', 'paper', 'scissors'] // 배열의 순서로 가중치 적용됨
  let result = [];

  function generateCombinations(roundsLeft, currentCombination) {
    if (roundsLeft === 0) {
      result.push(currentCombination);
      return;
    }
    
    for (let i = 0; i < lookup.length; i++) {
      generateCombinations(roundsLeft - 1, [...currentCombination, lookup[i]]);
    }
  }
  
  generateCombinations(num, []);

  return result;
};

이해하기

나는 아직도 재귀를 모르나보다 🫠 그래서 이해가 될때까지 손으로 적어보고 이렇게 기록도 남기기로 했다.

g는 generateCombinations 함수를 지칭한다.

1. g(3, [])
    
    `i = 0`
    
    - g(2, [r]) : 즉시 호출
        
        `i = 0`
        
        - g(1, [r, r]): 즉시 호출
            
            i = 0
            
            - g(0, [r, r, r]) → return result [[r,r,r]]
            
            i = 1
            
            - g(0, [r, r, p]) → return result [[r,r,r], [r,r,p]]
            
            i = 2
            
            - g(0, [r, r, s]) → return result [[r,r,r], [r,r,p],[r,r,s]]
        
        `i = 1`
        
        - g(1, [r, p]): 즉시 호출
            
            i = 0
            
            - g(0, [r, p, r]) → return result [[r,p,r]]
            
            i = 1
            
            - g(0, [r, p, p]) → return result [[r,p,r], [r,p,p]]
            
            i = 2
            
            - g(0, [r, p, s]) → return result [[r,p,r], [r,p,p],[r,p,s]]
        
        `i = 2`
        
        - g(1, [r, s]): 즉시 호출
            
            i = 0
            
            - g(0, [r, s, r]) → return result [[r,s,r]]
            
            i = 1
            
            - g(0, [r, s, p]) → return result [[r,s,r], [r,s,p]]
            
            i = 2
            
            - g(0, [r, s, s]) → return result [[r,s,r], [r,s,p],[r,s,s]]

`i = 1`

- g(2, [p]) : 즉시 호출
    
    `i = 0`
    
    - g(1, [p, r]): 즉시 호출
        
        i = 0
        
        - g(0, [p, r, r]) → return result [[p,r,r]]
        
        i = 1
        
        - g(0, [p, r, p]) → return result [[p,r,r], [p,r,p]]
        
        i = 2
        
        - g(0, [p, r, s]) → return result [[p,r,r], [p,r,p],[p,r,s]
    
    `i = 1`
    
    - g(1, [p, p]): 즉시 호출
        
        i = 0
        
        - g(0, [p, p, r]) → return result [[p,p,r]]
        
        i = 1
        
        - g(0, [p, p, p]) → return result [[p,p,r], [p,p,p]]
        
        i = 2
        
        - g(0, [p, p, s]) → return result [[p,p,r], [p,p,p],[p,p,s]]
    
    `i = 2`
    
    - g(1, [p, s]): 즉시 호출
        
        i = 0
        
        - g(0, [p, s, r]) → return result [[p,s,r]]
        
        i = 1
        
        - g(0, [p, s, p]) → return result [[p,s,r], [p,s,p]]
        
        i = 2
        
        - g(0, [p, s, s]) → return result [[p,s,r], [ps,p],[p,s,s]]

`i = 2`

…