Reverse an array in groups of given size | Set 2 (Variations of Set 1 )
Last Updated :
21 Mar, 2023
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:
- Define a function reverse() that takes an integer array arr, its size n, and the size of the sub-arrays k as input
- Traverse the array in multiples of 2k starting from the first element, i.e., for i = 0, 2k, 4k, and so on.
- 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.
- Reverse the sub-array [left, right] using a while loop and the swap() function.
- Repeat steps 3-4 for every alternate sub-array formed by consecutive k elements.
- In the main function, declare an integer array arr, initialize it with some values, and define the size of the sub-arrays k.
- Determine the size of the array n using the sizeof() operator.
- Call the reverse() function passing the integer array arr, its size n, and the size of the sub-arrays k as input.
- Print the modified array arr.
Below is the implementation :
C++
// C++ program to reverse every alternate sub-array
// formed by consecutive k elements
#include <iostream>
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 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 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# 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
<script>
// Javascript program to reverse
// every alternate sub-array
// formed by consecutive k elements
// Function to reverse every
// alternate sub-array formed
// by consecutive k elements
function reverse(arr, n, k)
{
// Increment i in multiples of 2*k
for(let i = 0; i < n; i += 2 * k)
{
let left = i;
// To handle case when 2*k is
// not multiple of n
let right = Math.min(i + k - 1,
n - 1);
// reverse the sub-array [left, right]
while (left < right)
{
swap(arr, left++, right--);
}
}
}
function swap(array, i, j)
{
let temp = array[i];
array[i] = array[j];
array[j] = temp;
return array;
}
// Driver code
let arr = [ 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14 ];
let k = 3;
let n = arr.length;
reverse(arr, n, k);
for(let i = 0; i < n; i++)
{
document.write(arr[i] + " ");
}
// This code is contributed by rag2127
</script>
Output3 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 <iostream>
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 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 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# 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
<script>
// javascript 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
function reverse(arr,n,k,m)
{
// increment i in multiples of k + m
for (let i = 0; i < n; i += k + m)
{
let left = i;
// to handle case when k + m is not multiple of n
let right = Math.min(i + k - 1, n - 1);
// reverse the sub-array [left, right]
while (left < right)
swap(arr,left++, right--);
}
}
function swap(arr,i,j)
{
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
return arr;
}
// Driver code
let arr=[1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14];
let k = 3;
let m = 2;
let n = arr.length;
reverse(arr, n, k, m );
for (let i = 0; i < n; i++)
{
document.write(arr[i] + " ");
}
// This code is contributed by ab2127
</script>
Output3 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 <iostream>
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 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 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# 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
<script>
// Javascript 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.
function reverse(arr,n,k)
{
// increment i in multiples of k where value
// of k is doubled with each iteration
for (let i = 0; i < n; i += k / 2)
{
let left = i;
// to handle case when number of elements in
// last group is less than k
let 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;
}
}
function swap(arr,i,j)
{
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
return arr;
}
// Driver code
let arr=[1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16];
let k = 1;
let n = arr.length;
reverse(arr, n, k);
document.write(arr.join(" "));
// This code is contributed by unknown2108
</script>
Output1 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).
Similar Reads
Reverse an array in groups of given size | Set 3 (Single traversal) Given an array, reverse every sub-array formed by consecutive k elements. Examples: Input: arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3. Output: [3, 2, 1, 6, 5, 4, 9, 8, 7, 10]Input: arr = [1, 2, 3, 4, 5, 6, 7], k = 5. Output: [5, 4, 3, 2, 1, 7, 6] Approach: We will use two pointers technique to sol
6 min read
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, 7Input: arr[] = [1, 2, 3, 4, 5, 6, 7, 8], k = 5 Output: 5, 4, 3, 2, 1, 8, 7, 6Input: arr[] = [1, 2
6 min read
Print all subsets of a given Set or Array Given an array arr of size n, your task is to print all the subsets of the array in lexicographical order.A subset is any selection of elements from an array, where the order does not matter, and no element appears more than once. It can include any number of elements, from none (the empty subset) t
12 min read
Count of pairs in an Array with same number of set bits Given an array arr containing N integers, the task is to count the possible number of pairs of elements with the same number of set bits. Examples: Input: N = 8, arr[] = {1, 2, 3, 4, 5, 6, 7, 8} Output: 9 Explanation: Elements with 1 set bit: 1, 2, 4, 8 Elements with 2 set bits: 3, 5, 6 Elements wit
7 min read
Split the given ranges into two groups Given a 2D array span[][] of length N which contains spans [L, R] (0 ≤ L ≤ R ≤ 109), the task is to merge those spans which are coinciding and after that split those spans into two groups. Note: Return numbers of ways these spans can be split following the given condition. Since the answer may be ve
7 min read
Minimize the cost of partitioning an array into K groups Given an array arr[] and an integer K, the task is to partition the array into K non-empty groups where each group is a subarray of the given array and each element of the array is part of only one group. All the elements in a given group must have the same value. You can perform the following opera
15+ min read
Product of all Subarrays of an Array | Set 2 Given an array arr[] of integers of size N, the task is to find the products of all subarrays of the array.Examples: Input: arr[] = {2, 4} Output: 64 Explanation: Here, subarrays are {2}, {2, 4}, and {4}. Products of each subarray are 2, 8, 4. Product of all Subarrays = 64Input: arr[] = {1, 2, 3} Ou
5 min read
Count all possible groups of size 2 or 3 that have sum as multiple of 3 Given an unsorted integer (positive values only) array of size ‘n’, we can form a group of two or three, the group should be such that the sum of all elements in that group is a multiple of 3. Count all possible number of groups that can be generated in this way. Examples: Input: arr[] = {3, 6, 7, 2
13 min read
Queries to count array elements from a given range having a single set bit Given an array arr[] consisting of N integers and a 2D array Q[][] consisting of queries of the following two types: 1 L R: Print the count of numbers from the range [L, R] having only a single set bit.2 X V: Update the array element at Xth index with V.Examples: Input: arr[] = { 12, 11, 16, 2, 32 }
15+ min read
Dividing an array into two halves of same sum Given an even size array of integers. We need to find if it is possible to divide array elements into two sets such that following conditions are true. Size of both subsets is same.Sum of elements in bot sets is same.Every element is part of one of the two sets. Examples : Input: arr[] = {1, 3, 2, 1
10 min read