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).
Share your thoughts in the comments
Please Login to comment...