# Reverse an Array in groups of given size

Given an array arr[] and an integer K, the task is to reverse every subarray formed by consecutive K elements.

Examples:

Input: arr[] = [1, 2, 3, 4, 5, 6, 7, 8, 9], K = 3
Output: 3, 2, 1, 6, 5, 4, 9, 8, 7

Input: arr[] = [1, 2, 3, 4, 5, 6, 7, 8], K = 5
Output: 5, 4, 3, 2, 1, 8, 7, 6

Input: arr[] = [1, 2, 3, 4, 5, 6], K = 1
Output: 1, 2, 3, 4, 5, 6

Input: arr[] = [1, 2, 3, 4, 5, 6, 7, 8], K = 10
Output: 8, 7, 6, 5, 4, 3, 2, 1

Recommended Practice

Naive Approach: The problem can be solved based on the following idea:

Consider every sub-array of size k starting from the beginning of the array and reverse it. We need to handle some special cases.

• If k is not a multiple of n where n is the size of the array, for the last group we will have less than k elements left, we need to reverse all remaining elements.
• If k = 1, the array should remain unchanged. If k >= n, we reverse all elements present in the array.

Follow the below illustration for a better understanding.

Illustration:

Given array arr[] = {1, 2, 3, 4, 5, 6, 7, 8} and k = 3

1st iteration:

• The selected group is {1, 2, 3, 4, 5, 6, 7, 8}
• After swapping the elements we have {3, 2, 1, 4, 5, 6, 7, 8}

2nd iteration:

• The selected group is {3, 2, 1, 4, 5, 6, 7, 8}
• After swapping the elements {3, 2, 1, 6, 5, 4, 7, 8}

3rd iteration:

• As k is less than the count of remaining elements
• We will reverse the entire remaining subarray {3, 2, 1, 6, 5, 4, 8, 7}

Follow the steps mentioned below to implement the idea:

• Iterate over the array, and on each iteration:
• We will set the left pointer as the current index and the right pointer at a distance of group size(K)
• We will swap elements in the left and right indices, and increase left by one and decrease right by one
• Do the above step until left < right
• After the swap operation is done we will increment the value of the iterator by k ( group size )

Below is the implementation of the above approach:

## C++

 `// C++ program to reverse every sub-array formed by``// consecutive k elements``#include ``using` `namespace` `std;` `// Function to reverse every sub-array formed by``// consecutive k elements``void` `reverse(``int` `arr[], ``int` `n, ``int` `k)``{``    ``for` `(``int` `i = 0; i < n; i += k)``    ``{``        ``int` `left = i;` `        ``// to handle case when k is not multiple of n``        ``int` `right = min(i + k - 1, n - 1);` `        ``// reverse the sub-array [left, right]``        ``while` `(left < right)``            ``swap(arr[left++], arr[right--]);` `    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = {1, 2, 3, 4, 5, 6, 7, 8};``    ``int` `k = 3;` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``reverse(arr, n, k);` `    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;` `    ``return` `0;``}`

## C

 `// C program to reverse every sub-array formed by``// consecutive k elements``#include ``// Function to reverse every sub-array formed by``// consecutive k elements``void` `reverse(``int` `arr[], ``int` `n, ``int` `k)``{``    ``for` `(``int` `i = 0; i < n; i += k)``    ``{``        ``int` `left = i;``        ``int` `right;``        ``// to handle case when k is not multiple of n``        ``if``(i+k-1

## Java

 `// Java program to reverse every sub-array formed by``// consecutive k elements``class` `GFG {``    ` `    ``// Function to reverse every sub-array formed by``    ``// consecutive k elements``    ``static` `void` `reverse(``int` `arr[], ``int` `n, ``int` `k)``    ``{``        ``for` `(``int` `i = ``0``; i < n; i += k)``        ``{``            ``int` `left = i;``    ` `            ``// to handle case when k is not multiple``            ``// of n``            ``int` `right = Math.min(i + k - ``1``, n - ``1``);``            ``int` `temp;``            ` `            ``// reverse the sub-array [left, right]``            ``while` `(left < right)``            ``{``                ``temp=arr[left];``                ``arr[left]=arr[right];``                ``arr[right]=temp;``                ``left+=``1``;``                ``right-=``1``;``            ``}``        ``}``    ``}``    ` `    ``// Driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ` `        ``int` `arr[] = {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``};``        ``int` `k = ``3``;``    ` `        ``int` `n = arr.length;``    ` `        ``reverse(arr, n, k);``    ` `        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python 3 program to reverse every ``# sub-array formed by consecutive k``# elements` `# Function to reverse every sub-array``# formed by consecutive k elements``def` `reverse(arr, n, k):``    ``i ``=` `0``    ` `    ``while``(i

## C#

 `// C# program to reverse every sub-array ``// formed by consecutive k elements``using` `System;` `class` `GFG``{` `// Function to reverse every sub-array ``// formed by consecutive k elements``public` `static` `void` `reverse(``int``[] arr, ``                           ``int` `n, ``int` `k)``{``    ``for` `(``int` `i = 0; i < n; i += k)``    ``{``        ``int` `left = i;` `        ``// to handle case when k is ``        ``// not multiple of n``        ``int` `right = Math.Min(i + k - 1, n - 1);``        ``int` `temp;` `        ``// reverse the sub-array [left, right]``        ``while` `(left < right)``        ``{``            ``temp = arr[left];``            ``arr[left] = arr[right];``            ``arr[right] = temp;``            ``left += 1;``            ``right -= 1;``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = ``new` `int``[] {1, 2, 3, 4, ``                           ``5, 6, 7, 8};``    ``int` `k = 3;` `    ``int` `n = arr.Length;` `    ``reverse(arr, n, k);` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``Console.Write(arr[i] + ``" "``);``    ``}``}``}` `// This code is contributed ``// by Shrikant13`

## Javascript

 ``

## PHP

 ``

Output
```3 2 1 6 5 4 8 7
```

Time complexity: O(N)
Auxiliary space: O(1)

Using STL:

## C++

 `#include ``using` `namespace` `std;` `// Function to reverse subarrays of size k in an array``// Nikunj Sonigara``void` `reverse(``int` `arr[], ``int` `n, ``int` `k)``{``    ``int` `j = 0, i = k;` `    ``// Reverse subarrays of size k until the end of the array is reached``    ``while` `(i < n) {``        ``// Reverse the subarray from arr[j] to arr[i-1]``        ``reverse(arr + j, arr + i);` `        ``// Move to the next subarray of size k``        ``i += k;``        ``j += k;``    ``}` `    ``// Reverse the remaining subarray of size less than k``    ``reverse(arr + j, arr + n);``}` `// Driver code``int` `main()``{``    ``int` `arr[] = {1, 2, 3, 4, 5, 6, 7, 8};``    ``int` `k = 3;` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Reverse subarrays of size k in the array``    ``reverse(arr, n, k);` `    ``// Print the reversed array``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;` `    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;` `public` `class` `ArrayReverse {``    ``// Function to reverse subarrays of size k in an array``    ``// Nikunj Sonigara``    ``public` `static` `void` `reverse(``int``[] arr, ``int` `n, ``int` `k) {``        ``int` `j = ``0``, i = k;` `        ``// Reverse subarrays of size k until the end of the array is reached``        ``while` `(i < n) {``            ``// Reverse the subarray from arr[j] to arr[i-1]``            ``reverseArray(arr, j, i - ``1``);` `            ``// Move to the next subarray of size k``            ``i += k;``            ``j += k;``        ``}` `        ``// Reverse the remaining subarray of size less than k``        ``reverseArray(arr, j, n - ``1``);``    ``}` `    ``// Function to reverse an array from index start to end``    ``private` `static` `void` `reverseArray(``int``[] arr, ``int` `start, ``int` `end) {``        ``while` `(start < end) {``            ``int` `temp = arr[start];``            ``arr[start] = arr[end];``            ``arr[end] = temp;``            ``start++;``            ``end--;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``int``[] arr = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8` `};``        ``int` `k = ``3``;``        ``int` `n = arr.length;` `        ``// Reverse subarrays of size k in the array``        ``reverse(arr, n, k);` `        ``// Print the reversed array``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}``}`

## Python3

 `# Function to reverse subarrays of size k in an array``# Nikunj Sonigara``def` `reverse(arr, n, k):``    ``j ``=` `0``    ``i ``=` `k` `    ``# Reverse subarrays of size k until the end of the array is reached``    ``while` `i < n:``        ``# Reverse the subarray from arr[j] to arr[i-1]``        ``reverse_array(arr, j, i ``-` `1``)` `        ``# Move to the next subarray of size k``        ``i ``+``=` `k``        ``j ``+``=` `k` `    ``# Reverse the remaining subarray of size less than k``    ``reverse_array(arr, j, n ``-` `1``)`  `# Function to reverse an array from index start to end``def` `reverse_array(arr, start, end):``    ``while` `start < end:``        ``arr[start], arr[end] ``=` `arr[end], arr[start]``        ``start ``+``=` `1``        ``end ``-``=` `1`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``]``    ``k ``=` `3``    ``n ``=` `len``(arr)` `    ``# Reverse subarrays of size k in the array``    ``reverse(arr, n, k)` `    ``# Print the reversed array``    ``print``(``*``arr)`

## C#

 `using` `System;` `public` `class` `ArrayReverse``{``    ``// Function to reverse subarrays of size k in an array``    ``// Nikunj Sonigara``    ``public` `static` `void` `Reverse(``int``[] arr, ``int` `n, ``int` `k)``    ``{``        ``int` `j = 0, i = k;` `        ``// Reverse subarrays of size k until the end of the array is reached``        ``while` `(i < n)``        ``{``            ``// Reverse the subarray from arr[j] to arr[i-1]``            ``ReverseArray(arr, j, i - 1);` `            ``// Move to the next subarray of size k``            ``i += k;``            ``j += k;``        ``}` `        ``// Reverse the remaining subarray of size less than k``        ``ReverseArray(arr, j, n - 1);``    ``}` `    ``// Function to reverse an array from index start to end``    ``private` `static` `void` `ReverseArray(``int``[] arr, ``int` `start, ``int` `end)``    ``{``        ``while` `(start < end)``        ``{``            ``int` `temp = arr[start];``            ``arr[start] = arr[end];``            ``arr[end] = temp;``            ``start++;``            ``end--;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 1, 2, 3, 4, 5, 6, 7, 8 };``        ``int` `k = 3;``        ``int` `n = arr.Length;` `        ``// Reverse subarrays of size k in the array``        ``Reverse(arr, n, k);` `        ``// Print the reversed array``        ``foreach` `(``int` `num ``in` `arr)``            ``Console.Write(num + ``" "``);``    ``}``}`

## Javascript

 `// Function to reverse subarrays of size k in an array``// Nikunj Sonigara``function` `reverse(arr, n, k) {``    ``let j = 0;``    ``let i = k;` `    ``// Reverse subarrays of size k until the end of the array is reached``    ``while` `(i < n) {``        ``// Reverse the subarray from arr[j] to arr[i-1]``        ``reverseArray(arr, j, i - 1);` `        ``// Move to the next subarray of size k``        ``i += k;``        ``j += k;``    ``}` `    ``// Reverse the remaining subarray of size less than k``    ``reverseArray(arr, j, n - 1);``}` `// Function to reverse an array from index start to end``function` `reverseArray(arr, start, end) {``    ``while` `(start < end) {``        ``[arr[start], arr[end]] = [arr[end], arr[start]];``        ``start++;``        ``end--;``    ``}``}` `// Driver code``const arr = [1, 2, 3, 4, 5, 6, 7, 8];``const k = 3;``const n = arr.length;` `// Reverse subarrays of size k in the array``reverse(arr, n, k);` `// Print the reversed array``console.log(arr.join(``' '``));`

Output
```3 2 1 6 5 4 8 7
```

Time complexity: O(N)
Auxiliary space: O(1)

Previous
Next