# Reverse an array in groups of given size | Set 2 (Variations of Set 1 )

Given an array, reverse every sub-array that satisfies the given constraints.

We have discussed a solution where we reverse every sub-array formed by consecutive k elements in Set 1. In this set, we will discuss various interesting variations of this problem.

Variation 1 (Reverse Alternate Groups):
Reverse every alternate sub-array formed by consecutive k elements.

Examples:

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

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

Below is the implementation –

## C++

 `// C++ program to reverse every alternate sub-array  ` `// formed by consecutive k elements ` `#include ` `using` `namespace` `std; ` ` `  `// Function to reverse every alternate sub-array  ` `// formed by consecutive k elements ` `void` `reverse(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``// increment i in multiples of 2*k ` `    ``for` `(``int` `i = 0; i < n; i += 2*k) ` `    ``{ ` `        ``int` `left = i; ` ` `  `        ``// to handle case when 2*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, 9, 10, 11, 12, 13, 14}; ` `    ``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 alternate sub-array  ` `// formed by consecutive k elements ` `class` `GFG ` `{ ` ` `  `// Function to reverse every  ` `// alternate sub-array formed  ` `// by consecutive k elements ` `    ``static` `void` `reverse(``int` `arr[], ``int` `n, ``int` `k) ` `    ``{ ` `         `  `        ``// increment i in multiples of 2*k ` `        ``for` `(``int` `i = ``0``; i < n; i += ``2` `* k) ` `        ``{ ` `            ``int` `left = i; ` ` `  `            ``// to handle case when 2*k is not multiple of n ` `            ``int` `right = Math.min(i + k - ``1``, n - ``1``); ` ` `  `            ``// reverse the sub-array [left, right] ` `            ``while` `(left < right) { ` `                ``swap(arr, left++, right--); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``static` `int``[] swap(``int``[] array, ``int` `i, ``int` `j)  ` `    ``{ ` `        ``int` `temp = array[i]; ` `        ``array[i] = array[j]; ` `        ``array[j] = temp; ` `        ``return` `array; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `arr[] = {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ` `                    ``9``, ``10``, ``11``, ``12``, ``13``, ``14``}; ` `        ``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 has been contributed by 29AjayKumar `

## Python3

 `# Python 3 program to reverse every alternate sub-array  ` `# formed by consecutive k elements ` ` `  `# Function to reverse every alternate sub-array  ` `# formed by consecutive k elements ` `def` `reverse(arr, n, k): ` `    ``# increment i in multiples of 2*k ` `    ``for` `i ``in` `range``(``0``,n,``2``*``k): ` `        ``left ``=` `i ` ` `  `        ``# to handle case when 2*k is not multiple of n ` `        ``right ``=` `min``(i ``+` `k ``-` `1``, n ``-` `1``) ` ` `  `        ``# 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 ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10``, ``11``, ``12``, ``13``, ``14``] ` `    ``k ``=` `3` ` `  `    ``n ``=` `len``(arr) ` ` `  `    ``reverse(arr, n, k) ` ` `  `    ``for` `i ``in` `range``(``0``,n,``1``): ` `        ``print``(arr[i],end ``=``" "``) ` `         `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# program to reverse every alternate  ` `// sub-array formed by consecutive k elements ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `    ``// Function to reverse every  ` `    ``// alternate sub-array formed  ` `    ``// by consecutive k elements ` `    ``static` `void` `reverse(``int` `[]arr,  ` `                        ``int` `n, ``int` `k) ` `    ``{ ` `         `  `        ``// increment i in multiples of 2*k ` `        ``for` `(``int` `i = 0; i < n; i += 2 * k) ` `        ``{ ` `            ``int` `left = i; ` ` `  `            ``// to handle case when 2*k is ` `            ``// not multiple of n ` `            ``int` `right = Math.Min(i + k - 1, n - 1); ` ` `  `            ``// reverse the sub-array [left, right] ` `            ``while` `(left < right)  ` `            ``{ ` `                ``swap(arr, left++, right--); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``static` `int``[] swap(``int``[] array, ``int` `i, ``int` `j)  ` `    ``{ ` `        ``int` `temp = array[i]; ` `        ``array[i] = array[j]; ` `        ``array[j] = temp; ` `        ``return` `array; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int` `[]arr = {1, 2, 3, 4, 5, 6, 7, 8, ` `                     ``9, 10, 11, 12, 13, 14}; ` `        ``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 ontributed by PrinciRaj1992 `

Output:

```3 2 1 4 5 6 9 8 7 10 11 12 14 13
```

Variation 2 (Reverse at given distance):
Reverse every sub-array formed by consecutive k elements at given distance apart.
Examples:

```Input:
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
k = 3
m = 2
Output:
[3, 2, 1, 4, 5, 8, 7, 6, 9, 10]

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

Input:
arr = [1, 2, 3, 4, 5, 6, 7, 8]
k = 2
m = 0
Output:
[2, 1, 4, 3, 6, 5, 8, 7]
```

Below is its implementation –

## C++

 `// C++ program to reverse every sub-array formed by  ` `// consecutive k elements at given distance apart ` `#include ` `using` `namespace` `std; ` ` `  `// Function to reverse every sub-array formed by  ` `// consecutive k elements at m distance apart ` `void` `reverse(``int` `arr[], ``int` `n, ``int` `k, ``int` `m) ` `{ ` `    ``// increment i in multiples of k + m ` `    ``for` `(``int` `i = 0; i < n; i += k + m) ` `    ``{ ` `        ``int` `left = i; ` ` `  `        ``// to handle case when k + m 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, 9, 10, 11, 12, 13, 14}; ` `    ``int` `k = 3; ` `    ``int` `m = 2; ` ` `  `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``reverse(arr, n, k, m); ` ` `  `    ``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 at given distance apart ` `class` `GFG ` `{ ` ` `  `// Function to reverse every sub-array formed by  ` `// consecutive k elements at m distance apart ` `static` `void` `reverse(``int``[] arr, ``int` `n, ``int` `k, ``int` `m) ` `{ ` `    ``// increment i in multiples of k + m ` `    ``for` `(``int` `i = ``0``; i < n; i += k + m) ` `    ``{ ` `        ``int` `left = i; ` ` `  `        ``// to handle case when k + m is not multiple of n ` `        ``int` `right = Math.min(i + k - ``1``, n - ``1``); ` ` `  `        ``// reverse the sub-array [left, right] ` `        ``while` `(left < right) ` `            ``swap(arr,left++, right--); ` `    ``} ` `} ` ` ``static` `int``[] swap(``int``[] arr, ``int` `i, ``int` `j)  ` `    ``{ ` `        ``int` `temp = arr[i]; ` `        ``arr[i] = arr[j]; ` `        ``arr[j] = temp; ` `        ``return` `arr; ` `    ``} ` ` `  `// Driver code ` ` ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `arr[] = {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ` `                    ``9``, ``10``, ``11``, ``12``, ``13``, ``14``}; ` `        ``int` `k = ``3``; ` `        ``int` `m = ``2``; ` `        ``int` `n = arr.length; ` `  `  `        ``reverse(arr, n, k, m ); ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``System.out.print(arr[i] + ``" "``); ` `        ``} ` `    ``} ` `} ` `// This code has been contributed by Rajput-Ji `

## Python3

 `# Python3 program to reverse every  ` `# sub-array formed by consecutive ` `# k elements at given distance apart ` ` `  `# Function to reverse every  ` `# sub-array formed by consecutive  ` `# k elements at m distance apart ` `def` `reverse(arr, n, k, m): ` `     `  `    ``# increment i in multiples of k + m ` `    ``for` `i ``in` `range``(``0``, n, k ``+` `m): ` `        ``left ``=` `i; ` ` `  `        ``# to handle case when k + m  ` `        ``# is not multiple of n ` `        ``right ``=` `min``(i ``+` `k ``-` `1``, n ``-` `1``); ` ` `  `        ``# reverse the sub-array [left, right] ` `        ``while` `(left < right): ` `            ``arr ``=` `swap(arr,left, right); ` `            ``left ``+``=` `1``; ` `            ``right ``-``=` `1``; ` `    ``return` `arr; ` ` `  `def` `swap(arr, i, j): ` ` `  `    ``temp ``=` `arr[i]; ` `    ``arr[i] ``=` `arr[j]; ` `    ``arr[j] ``=` `temp; ` `    ``return` `arr; ` ` `  `# Driver code ` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``,  ` `       ``8``, ``9``, ``10``, ``11``, ``12``, ``13``, ``14``]; ` `k ``=` `3``; ` `m ``=` `2``; ` `n ``=` `len``(arr); ` ` `  `arr ``=` `reverse(arr, n, k, m ); ` `for` `i ``in` `range``(``0``, n):  ` `    ``print``(arr[i], end ``=` `" "``); ` `     `  `# This code is contributed by Rajput-Ji `

## C#

 `// C# program to reverse every sub-array  ` `// formed by consecutive k elements at ` `// given distance apart ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `// Function to reverse every sub-array  ` `// formed by consecutive k elements ` `// at m distance apart ` `static` `void` `reverse(``int``[] arr, ``int` `n,  ` `                    ``int` `k, ``int` `m) ` `{ ` `    ``// increment i in multiples of k + m ` `    ``for` `(``int` `i = 0; i < n; i += k + m) ` `    ``{ ` `        ``int` `left = i; ` ` `  `        ``// to handle case when k + m is ` `        ``// not multiple of n ` `        ``int` `right = Math.Min(i + k - 1, n - 1); ` ` `  `        ``// reverse the sub-array [left, right] ` `        ``while` `(left < right) ` `            ``swap(arr, left++, right--); ` `    ``} ` `} ` ` `  `static` `int``[] swap(``int``[] arr, ``int` `i, ``int` `j)  ` `{ ` `    ``int` `temp = arr[i]; ` `    ``arr[i] = arr[j]; ` `    ``arr[j] = temp; ` `    ``return` `arr; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[]arr = {1, 2, 3, 4, 5, 6, 7, 8, ` `                 ``9, 10, 11, 12, 13, 14}; ` `    ``int` `k = 3; ` `    ``int` `m = 2; ` `    ``int` `n = arr.Length; ` ` `  `    ``reverse(arr, n, k, m ); ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``Console.Write(arr[i] + ``" "``); ` `    ``} ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```3 2 1 4 5 8 7 6 9 10 13 12 11 14
```

Variation 3 (Reverse by doubling the group size):
Reverse every sub-array formed by consecutive k elements where k doubles itself with every sub-array.
Examples:

```Input:
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
k = 1
Output:
, [3, 2], [7, 6, 5, 4], [15, 14, 13, 12, 11, 10, 9, 8]
```

Below is its implementation –

## C++

 `// C++ program to reverse every sub-array formed by  ` `// consecutive k elements where k doubles itself with  ` `// every sub-array. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to reverse every sub-array formed by  ` `// consecutive k elements where k doubles itself  ` `// with every sub-array. ` `void` `reverse(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``// increment i in multiples of k where value ` `    ``// of k is doubled with each iteration ` `    ``for` `(``int` `i = 0; i < n; i += k/2) ` `    ``{ ` `        ``int` `left = i; ` ` `  `        ``// to handle case when number of elements in  ` `        ``// last group is less than k ` `        ``int` `right = min(i + k - 1, n - 1); ` ` `  `        ``// reverse the sub-array [left, right] ` `        ``while` `(left < right) ` `            ``swap(arr[left++], arr[right--]); ` ` `  `        ``// double value of k with each iteration ` `        ``k = k*2; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; ` `    ``int` `k = 1; ` ` `  `    ``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 where  ` `// k doubles itself with every sub-array.  ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to reverse every sub-array formed by  ` `// consecutive k elements where k doubles itself  ` `// with every sub-array.  ` `static` `void` `reverse(``int` `arr[], ``int` `n, ``int` `k)  ` `{  ` `    ``// increment i in multiples of k where value  ` `    ``// of k is doubled with each iteration  ` `    ``for` `(``int` `i = ``0``; i < n; i += k / ``2``)  ` `    ``{  ` `        ``int` `left = i;  ` ` `  `        ``// to handle case when number of elements in  ` `        ``// last group is less than k  ` `        ``int` `right = Math.min(i + k - ``1``, n - ``1``);  ` ` `  `        ``// reverse the sub-array [left, right]  ` `        ``while` `(left < right)  ` `            ``swap(arr, left++, right--);  ` ` `  `        ``// double value of k with each iteration  ` `        ``k = k * ``2``;  ` `    ``}  ` `}  ` ` `  `static` `int``[] swap(``int``[] arr, ``int` `i, ``int` `j)  ` `{ ` `    ``int` `temp = arr[i]; ` `    ``arr[i] = arr[j]; ` `    ``arr[j] = temp; ` `    ``return` `arr; ` `} ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `arr[] = {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``,  ` `                ``10``, ``11``, ``12``, ``13``, ``14``, ``15``, ``16``};  ` `    ``int` `k = ``1``;  ` ` `  `    ``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 29AjayKumar `

## C#

 `// C# program to reverse every sub-array  ` `// formed by consecutive k elements where  ` `// k doubles itself with every sub-array. ` `using` `System; ` `     `  `class` `GFG  ` `{ ` ` `  `// Function to reverse every sub-array formed by  ` `// consecutive k elements where k doubles itself  ` `// with every sub-array.  ` `static` `void` `reverse(``int` `[]arr, ``int` `n, ``int` `k)  ` `{  ` `    ``// increment i in multiples of k where value  ` `    ``// of k is doubled with each iteration  ` `    ``for` `(``int` `i = 0; i < n; i += k / 2)  ` `    ``{  ` `        ``int` `left = i;  ` ` `  `        ``// to handle case when number of elements in  ` `        ``// last group is less than k  ` `        ``int` `right = Math.Min(i + k - 1, n - 1);  ` ` `  `        ``// reverse the sub-array [left, right]  ` `        ``while` `(left < right)  ` `            ``swap(arr, left++, right--);  ` ` `  `        ``// double value of k with each iteration  ` `        ``k = k * 2;  ` `    ``}  ` `}  ` ` `  `static` `int``[] swap(``int``[] arr, ``int` `i, ``int` `j)  ` `{ ` `    ``int` `temp = arr[i]; ` `    ``arr[i] = arr[j]; ` `    ``arr[j] = temp; ` `    ``return` `arr; ` `} ` ` `  `// Driver code  ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[]arr = {1, 2, 3, 4, 5, 6, 7, 8, 9,  ` `                ``10, 11, 12, 13, 14, 15, 16};  ` `    ``int` `k = 1;  ` ` `  `    ``int` `n = arr.Length;  ` ` `  `    ``reverse(arr, n, k);  ` ` `  `    ``for` `(``int` `i = 0; i < n; i++)  ` `        ``Console.Write(arr[i] + ``" "``); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```1 3 2 7 6 5 4 15 14 13 12 11 10 9 8 16
```

Time complexity of all solutions discussed above is O(n).
Auxiliary space used by the program is O(1).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

3

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.