Left Rotate an Array by One Place

Given an array of integers, your task is to left rotate the array by 1 position. This means that each element moves one place to the left, and the first element is moved to the end of the array.

The operation should be performed in-place using an optimal solution, without using extra space for a new array.

If the array is empty or contains only one element, it should remain unchanged after rotation.

Understanding the Problem

We are given an array, and our goal is to left rotate it by one position. This means that each element in the array should shift one position to the left, and the first element should move to the last position.

Let’s solve this step by step using an example. We'll also think like a beginner, and make sure we handle all the edge cases clearly.

Step-by-Step Example

Original Array:

[1, 2, 3, 4, 5]

Step 1: Save the first element

We store 1 in a temporary variable because it will be moved to the end later.

Step 2: Shift all other elements left

Move each element one step to the left:

[2, 3, 4, 5, _]

Step 3: Place the saved element at the end

Put 1 in the last position:

[2, 3, 4, 5, 1]

Final Result:

[2, 3, 4, 5, 1]

Edge Cases

1. Empty Array

If the array is [], there’s nothing to rotate. We return it as-is.

2. Single Element Array

If the array is [10], rotating it won't change anything since there's only one item.

3. All Elements Identical

If the array is [0, 0, 0], the result looks the same after rotation, but the operation is still performed internally.

1. Given an array arr of size n.
2. Store the first element in a temporary variable first.
3. Shift all elements of the array one position to the left (from index 1 to n-1).
4. Assign first to the last index of the array.
5. The array is now left-rotated by one place.

Worked example

Let's left rotate the array by one position.

Store the first element 10 in a temporary variable.

Shift index 1

Move 20 from index 1 to index 0.

Shift index 2

Move 30 from index 2 to index 1.

Shift index 3

Move 40 from index 3 to index 2.

Shift index 4

Move 50 from index 4 to index 3.

Place the first element at the end

Set 10 to index 4.

Final Result:

Array after left rotation: [20, 30, 40, 50, 10]

#include <stdio.h>

void leftRotateByOne(int arr[], int n) {
    if (n == 0) return;
    int first = arr[0];
    for (int i = 1; i < n; i++) {
        arr[i - 1] = arr[i];
    }
    arr[n - 1] = first;
}

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int n = sizeof(arr) / sizeof(arr[0]);
    leftRotateByOne(arr, n);
    printf("After Left Rotation: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

void leftRotateByOne(vector<int>& arr) {
    if (arr.empty()) return;
    int first = arr[0];
    for (int i = 1; i < arr.size(); i++) {
        arr[i - 1] = arr[i];
    }
    arr[arr.size() - 1] = first;
}

int main() {
    vector<int> arr = {10, 20, 30, 40, 50};
    leftRotateByOne(arr);
    cout << "After Left Rotation: ";
    for (int num : arr) cout << num << " ";
    return 0;
}

def left_rotate_by_one(arr):
    if not arr:
        return arr
    first = arr[0]
    for i in range(1, len(arr)):
        arr[i - 1] = arr[i]
    arr[-1] = first
    return arr

# Sample Input
arr = [10, 20, 30, 40, 50]
print("After Left Rotation:", left_rotate_by_one(arr))

public class LeftRotateOne {
    public static void leftRotateByOne(int[] arr) {
        if (arr.length == 0) return;
        int first = arr[0];
        for (int i = 1; i < arr.length; i++) {
            arr[i - 1] = arr[i];
        }
        arr[arr.length - 1] = first;
    }

    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        leftRotateByOne(arr);
        System.out.print("After Left Rotation: ");
        for (int num : arr) System.out.print(num + " ");
    }
}

function leftRotateByOne(arr) {
    if (arr.length === 0) return arr;
    const first = arr[0];
    for (let i = 1; i < arr.length; i++) {
        arr[i - 1] = arr[i];
    }
    arr[arr.length - 1] = first;
    return arr;
}

// Sample Input
const arr = [10, 20, 30, 40, 50];
console.log('After Left Rotation:', leftRotateByOne(arr));

package main

import "fmt"

func leftRotateByOne(arr []int) {
    if len(arr) == 0 {
        return
    }
    first := arr[0]
    for i := 1; i < len(arr); i++ {
        arr[i-1] = arr[i]
    }
    arr[len(arr)-1] = first
}

func main() {
    arr := []int{10, 20, 30, 40, 50}
    leftRotateByOne(arr)
    fmt.Print("After Left Rotation: ")
    for _, val := range arr {
        fmt.Print(val, " ")
    }
}

fn left_rotate_by_one(arr: &mut Vec<i32>) {
    if arr.is_empty() {
        return;
    }
    let first = arr[0];
    for i in 1..arr.len() {
        arr[i - 1] = arr[i];
    }
    arr[arr.len() - 1] = first;
}

fn main() {
    let mut arr = vec![10, 20, 30, 40, 50];
    left_rotate_by_one(&mut arr);
    print!("After Left Rotation: ");
    for val in arr {
        print!("{} ", val);
    }
}

fun leftRotateByOne(arr: IntArray) {
    if (arr.isEmpty()) return
    val first = arr[0]
    for (i in 1 until arr.size) {
        arr[i - 1] = arr[i]
    }
    arr[arr.size - 1] = first
}

fun main() {
    val arr = intArrayOf(10, 20, 30, 40, 50)
    leftRotateByOne(arr)
    print("After Left Rotation: ")
    for (num in arr) print("$num ")
}

func leftRotateByOne(_ arr: inout [Int]) {
    if arr.isEmpty { return }
    let first = arr[0]
    for i in 1..<arr.count {
        arr[i - 1] = arr[i]
    }
    arr[arr.count - 1] = first
}

var arr = [10, 20, 30, 40, 50]
leftRotateByOne(&arr)
print("After Left Rotation:", terminator: " ")
for num in arr {
    print(num, terminator: " ")
}

function leftRotateByOne(arr: number[]): number[] {
    if (arr.length === 0) return arr;
    const first = arr[0];
    for (let i = 1; i < arr.length; i++) {
        arr[i - 1] = arr[i];
    }
    arr[arr.length - 1] = first;
    return arr;
}

// Sample Input
const arr: number[] = [10, 20, 30, 40, 50];
console.log('After Left Rotation:', leftRotateByOne(arr));

Time complexity

Space complexity

O(1)

Only one temporary variable is used to store the first element. No additional space is required proportional to input size.