 GFG App
Open App Browser
Continue

# 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);`   `    ``reverse(arr, n, k);`   `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cout << arr[i] << ``" "``;`   `    ``return` `0;` `}`

## 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`

## PHP

 ``

## Javascript

 ``

## 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

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);`   `    ``// 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;` `}`

Output

`3 2 1 6 5 4 8 7 `

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