GFG App
Open App
Browser
Continue

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

Algorithm:

1. Define a function reverse() that takes an integer array arr, its size n, and the size of the sub-arrays k as input
2. Traverse the array in multiples of 2k starting from the first element, i.e., for i = 0, 2k, 4k, and so on.
3. For each such i, set the left pointer to i and the right pointer to min(i + k – 1, n – 1) to handle the case when 2k is not a multiple of n.
4. Reverse the sub-array [left, right] using a while loop and the swap() function.
5. Repeat steps 3-4 for every alternate sub-array formed by consecutive k elements.
6. In the main function, declare an integer array arr, initialize it with some values, and define the size of the sub-arrays k.
7. Determine the size of the array n using the sizeof() operator.
8. Call the reverse() function passing the integer array arr, its size n, and the size of the sub-arrays k as input.
9. Print the modified array arr.

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[0]);`   `    ``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

 `# Python3 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 contributed by PrinciRaj1992`

## Javascript

 ``

Output

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

Time Complexity: O(N)

Auxiliary Space: O(1)

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[0]);`   `    ``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`

## Javascript

 ``

Output

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

Time Complexity: O(N)

Auxiliary Space: O(1)

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:
[1], [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[0]);`   `    ``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`

## Python3

 `# Python3 program to reverse every ` `# sub-array formed by consecutive ` `# k elements where k doubles itself` `# with every sub-array`   `# Function to reverse every sub-array` `# formed by consecutive k elements ` `# where k doubles itself with every ` `# sub-array` `def` `reverse(arr, n, k):` `    `  `    ``i ``=` `0`   `    ``# Increment i in multiples of k where ` `    ``# value of k is doubled with each ` `    ``# iteration ` `    ``while` `(i < n):` `        ``left ``=` `i`   `        ``# To handle case when number of elements` `        ``# in last group is less than k ` `        ``right ``=` `min``(i ``+` `k ``-` `1``, n ``-` `1``)`   `        ``# Reverse the sub-array [left, right] ` `        ``while` `(left < right):` `            ``arr[left], arr[right] ``=` `arr[right], arr[left]` `            ``left ``+``=` `1` `            ``right ``-``=` `1` `            `  `        ``# Double value of k with each iteration ` `        ``k ``=` `k ``*` `2` `        ``i ``+``=` `int``(k ``/` `2``)`   `# Driver code ` `arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``,` `        ``10``, ``11``, ``12``, ``13``, ``14``, ``15``, ``16``]` `k ``=` `1`   `n ``=` `len``(arr)`   `reverse(arr, n, k)`   `print``(``*``arr, sep ``=` `' '``)`   `# This code is contributed by avanitrachhadiya2155`

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

## Javascript

 ``

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).