Time Limit Exceeded

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
    if(nums.length === 1 || nums.length === k){
        return nums;
    }

    if(nums.length > k){
        for(let i = 0; i < k; i++){
            const poped = nums.pop();
            nums.unshift(poped);
        }

        return nums;
    }

    if(nums.length < k){
        const iter = k % nums.length;

        for(let i = 0; i < iter; i++){
            const poped = nums.pop();
            nums.unshift(poped);
        }

        return nums;
    }
};

정말 단순하게 생각하고 작성한 코드이다.
사실 테스트 케이스는 통과한다.
단, 시간 제한에 걸린다는 것 빼고..
unshift()를 하면 배열의 원소들이 하나씩 밀리기 때문에 O(n)의 시간이 걸리게 되며,
이를 모두 반복한는 것은 상당히 시간을 잡아 먹을 것이다.

solution

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
    if(nums.length === 1 || nums.length === k){
        return nums;
    }

    if(nums.length > k){
        const splicedArray = nums.splice(-k);
        nums.unshift(...splicedArray);

        return nums;
    }

    if(nums.length < k){
        const iter = k % nums.length;

        const splicedArray = nums.splice(-iter);
        nums.unshift(...splicedArray);

        return nums;
    }
};

이 방법은 for문과 pop()을 같이 사용하는 방법 대신,
필요한 범위만큼의 배열을 잘라내서 nums 배열을 재구성하는 방법이다.
덕분에 불필요한 반복문을 줄일 수 있었고, 시간 초과 문제를 해결할 수 있었다.

다른 분의 solution

여러가지 풀이가 있었지만, 이 풀이가 이해가 잘되면서 속도가 빠른 풀이라고 생각한다.

var rotate = function (nums, k) {
  for (let i = nums.length - 1; i >= 0; i--) {
    nums[i + k] = nums[i];
  }

  for (let j = k - 1; j >= 0; j--) {
    nums[j] = nums.pop();
  }

  // Time comlexity = O(a + b)
};

이 분은 이동해야할 것들을 k만큼 뒤로 보내서 배열을 늘린 뒤,
이동이 완료되어야할 부분을 pop()을 통해 추출한 뒤, 올바른 위치에 할당하는 것으로 구현하셨다.
for문으로 인해서 시간 복잡도가 증가한다고 생각했는데, 사용하더라도 시간 복잡도 문제를 해결할 수 있다는 점도 꽤나 흥미로운 부분이다.

예시도 첨부해두셨는데, 사실 코드만 보고 한번에 이해하기 힘들었던 부분을 명확하게 이해할 수 있었다.
한번에 알아보기 쉬운건 내 코드인 것 같기도...

var rotate = function (nums, k) {
  // i.e. nums = [1, 2, 3, 4, 5, 6, 7],  k = 3
  for (let i = nums.length - 1; i >= 0; i--) {
    nums[i + k] = nums[i];
    // i = 6,  k = 3
    // nums[i + k] = nums[i]
    // nums[6 + 3] = nums[6]
    // nums[9] = 7              nums = [1, 2, 3, 4, 5, 6, 7, , , 7]

    // i = 5,  k = 3
    // nums[i + k] = nums[i]
    // nums[5 + 3] = nums[5]
    // nums[8] = 6              nums = [1, 2, 3, 4, 5, 6, 7, , 6, 7]

    // i = 4,  k = 3
    // nums[i + k] = nums[i]
    // nums[4 + 3] = nums[4]
    // nums[7] = 5              nums = [1, 2, 3, 4, 5, 6, 7, 5, 6, 7]

    // i = 3,  k = 3
    // nums[i + k] = nums[i]
    // nums[3 + 3] = nums[3]
    // nums[6] = 4              nums = [1, 2, 3, 4, 5, 6, 4, 5, 6, 7]

    // i = 2,  k = 3
    // nums[i + k] = nums[i]
    // nums[2 + 3] = nums[2]
    // nums[5] = 3              nums = [1, 2, 3, 4, 5, 3, 4, 5, 6, 7]

    // i = 1,  k = 3
    // nums[i + k] = nums[i]
    // nums[1 + 3] = nums[1]
    // nums[4] = 2              nums = [1, 2, 3, 4, 2, 3, 4, 5, 6, 7]

    // i = 0,  k = 3
    // nums[i + k] = nums[i]
    // nums[0 + 3] = nums[0]
    // nums[3] = 1              nums = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7]
  }

  for (let j = k - 1; j >= 0; j--) {
    // nums = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7]
    nums[j] = nums.pop();

    // j = 2
    // nums[j] = nums.pop()
    // nums[2] = 7               nums = [1, 2, 7, 1, 2, 3, 4, 5, 6]

    // j = 1
    // nums[j] = nums.pop()
    // nums[1] = 6               nums = [1, 6, 7, 1, 2, 3, 4, 5]

    // j = 0
    // nums[j] = nums.pop()
    // nums[0] = 5               nums = [5, 6, 7, 1, 2, 3, 4]
  }

  // nums = [5, 6, 7, 1, 2, 3, 4]

  // Time comlexity = O(a + b)
};