Array Left Shift by Reversal - Problem

Given an array of integers and a number k, left-shift the array elements by k positions using the triple-reversal technique with O(1) extra space.

The triple-reversal technique works by:

Reverse the entire array
Reverse the first n-k elements
Reverse the last k elements

Where n is the length of the array and k is normalized to k % n to handle cases where k > n.

Example: Array [1,2,3,4,5] left-shifted by 2 positions becomes [3,4,5,1,2]

Input & Output

Example 1 — Basic Left Shift

$ Input: nums = [1,2,3,4,5], k = 2

› Output: [3,4,5,1,2]

💡 Note: Left shift by 2: elements 1,2 move to end, elements 3,4,5 move to front. Triple reversal: [1,2,3,4,5] → [5,4,3,2,1] → [3,4,5,2,1] → [3,4,5,1,2]

Example 2 — Full Rotation

$ Input: nums = [1,2,3], k = 3

› Output: [1,2,3]

💡 Note: k=3 equals array length, so k%3=0. No shift needed, array remains [1,2,3]

Example 3 — Large k Value

$ Input: nums = [1,2], k = 5

› Output: [2,1]

💡 Note: k=5 > array length 2, so k%2=1. Left shift by 1: [1,2] → [2,1] → [1,2] → [2,1]

Constraints

1 ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
0 ≤ k ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 32 M Microsoft 28 G Google 25 f Meta 18

The triple-reversal technique is an elegant approach to left-shift arrays in-place. The key insight is that three reversal operations can achieve the same result as copying elements to new positions. Best approach uses O(1) space with O(n) time.

Common Approaches

✓ Extra Array Approach

⏱️ Time: O(n) Space: O(n)

Store elements from index k to end in result array, then append elements from start to index k-1. Simple but uses O(n) extra space.

Triple Reversal Technique

⏱️ Time: O(n) Space: O(1)

Reverse entire array, then reverse first n-k elements, then reverse last k elements. This elegant technique achieves left shift without extra space.

Extra Array Approach — Algorithm Steps

Step 1: Create new result array of same size
Step 2: Copy elements from index k onwards to start of result
Step 3: Copy elements from start to index k-1 to end of result
Step 4: Copy result back to original array

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with [1,2,3,4,5], k=2

Copy Elements

Copy from index k onwards: [3,4,5] then [1,2]

Result

New array [3,4,5,1,2] copied back to original

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void solution(int* nums, int numsSize, int k, int* result) {
    if (numsSize == 0 || k == 0) {
        for (int i = 0; i < numsSize; i++) {
            result[i] = nums[i];
        }
        return;
    }
    
    k = k % numsSize;  // Handle k > numsSize
    
    // Create temporary array
    int* temp = (int*)malloc(numsSize * sizeof(int));
    
    // Copy elements from index k to end
    for (int i = 0; i < numsSize - k; i++) {
        temp[i] = nums[i + k];
    }
    
    // Copy elements from start to index k-1
    for (int i = 0; i < k; i++) {
        temp[numsSize - k + i] = nums[i];
    }
    
    // Copy result back
    for (int i = 0; i < numsSize; i++) {
        result[i] = temp[i];
        nums[i] = temp[i];
    }
    
    free(temp);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array (simple parsing for [1,2,3,4,5] format)
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result[100];
    solution(nums, numsSize, k, result);
    
    // Print result
    printf("[");
    for (int i = 0; i < numsSize; i++) {
        printf("%d", result[i]);
        if (i < numsSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to copy elements to new array, then copy back

✓ Linear Growth

Space Complexity

O(n)

Extra array of size n to store shifted elements

✓ Linear Space

89.2K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Array Left Shift by Reversal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Extra Array Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler