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++
#include <iostream>
using namespace std;
void reverse( int arr[], int n, int k)
{
for ( int i = 0; i < n; i += 2*k)
{
int left = i;
int right = min(i + k - 1, n - 1);
while (left < right)
swap(arr[left++], arr[right--]);
}
}
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
class GFG
{
static void reverse( int arr[], int n, int k)
{
for ( int i = 0 ; i < n; i += 2 * k)
{
int left = i;
int right = Math.min(i + k - 1 , n - 1 );
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;
}
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] + " " );
}
}
}
|
Python3
def reverse(arr, n, k):
for i in range ( 0 ,n, 2 * k):
left = i
right = min (i + k - 1 , n - 1 )
while (left < right):
temp = arr[left]
arr[left] = arr[right]
arr[right] = temp
left + = 1
right - = 1
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 = " " )
|
C#
using System;
class GFG
{
static void reverse( int []arr,
int n, int k)
{
for ( int i = 0; i < n; i += 2 * k)
{
int left = i;
int right = Math.Min(i + k - 1, n - 1);
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;
}
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] + " " );
}
}
}
|
Javascript
<script>
function reverse(arr, n, k)
{
for (let i = 0; i < n; i += 2 * k)
{
let left = i;
let right = Math.min(i + k - 1,
n - 1);
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;
}
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] + " " );
}
</script>
|
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++
#include <iostream>
using namespace std;
void reverse( int arr[], int n, int k, int m)
{
for ( int i = 0; i < n; i += k + m)
{
int left = i;
int right = min(i + k - 1, n - 1);
while (left < right)
swap(arr[left++], arr[right--]);
}
}
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
class GFG
{
static void reverse( int [] arr, int n, int k, int m)
{
for ( int i = 0 ; i < n; i += k + m)
{
int left = i;
int right = Math.min(i + k - 1 , n - 1 );
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;
}
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] + " " );
}
}
}
|
Python3
def reverse(arr, n, k, m):
for i in range ( 0 , n, k + m):
left = i;
right = min (i + k - 1 , n - 1 );
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;
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 = " " );
|
C#
using System;
class GFG
{
static void reverse( int [] arr, int n,
int k, int m)
{
for ( int i = 0; i < n; i += k + m)
{
int left = i;
int right = Math.Min(i + k - 1, n - 1);
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;
}
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] + " " );
}
}
}
|
Javascript
<script>
function reverse(arr,n,k,m)
{
for (let i = 0; i < n; i += k + m)
{
let left = i;
let right = Math.min(i + k - 1, n - 1);
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;
}
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] + " " );
}
</script>
|
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++
#include <iostream>
using namespace std;
void reverse( int arr[], int n, int k)
{
for ( int i = 0; i < n; i += k/2)
{
int left = i;
int right = min(i + k - 1, n - 1);
while (left < right)
swap(arr[left++], arr[right--]);
k = k*2;
}
}
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
import java.util.*;
class GFG
{
static void reverse( int arr[], int n, int k)
{
for ( int i = 0 ; i < n; i += k / 2 )
{
int left = i;
int right = Math.min(i + k - 1 , n - 1 );
while (left < right)
swap(arr, left++, right--);
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;
}
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] + " " );
}
}
|
Python3
def reverse(arr, n, k):
i = 0
while (i < n):
left = i
right = min (i + k - 1 , n - 1 )
while (left < right):
arr[left], arr[right] = arr[right], arr[left]
left + = 1
right - = 1
k = k * 2
i + = int (k / 2 )
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 = ' ' )
|
C#
using System;
class GFG
{
static void reverse( int []arr, int n, int k)
{
for ( int i = 0; i < n; i += k / 2)
{
int left = i;
int right = Math.Min(i + k - 1, n - 1);
while (left < right)
swap(arr, left++, right--);
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;
}
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] + " " );
}
}
|
Javascript
<script>
function reverse(arr,n,k)
{
for (let i = 0; i < n; i += k / 2)
{
let left = i;
let right = Math.min(i + k - 1, n - 1);
while (left < right)
swap(arr, left++, right--);
k = k * 2;
}
}
function swap(arr,i,j)
{
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
return arr;
}
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( " " ));
</script>
|
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).
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...