Skip to content
Related Articles

Related Articles

Reverse an array in groups of given size | Set 3 (Single traversal)
  • Last Updated : 06 Nov, 2020

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: 

  1. We will use two pointers technique to solve this problem. 
  2. First, we will initialize our 1st pointer d with value k-1 (d = k-1) and a variable m with value 2 (m = 2). 
  3. Now, we will iterate the array with our 2nd pointer i and check 
    • If i < d, Swap (arr[i], arr[d]) and decrement d by 1. Otherwise, 
    • Make d = k * m – 1, i = k * (m – 1) – 1 and m = m + 1. 

Below is the implementation of the above approach.
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to reverse every sub-array
// formed by consecutive k elements
#include<bits/stdc++.h>
using namespace std;
 
// Function to reverse every sub-array
// formed by consecutive k elements
void ReverseInGroup(int arr[], int n, int k)
{
    if(n < k)
    {
        k = n;
    }
 
    // Initialize variables
    int d = k - 1, m = 2;
    int i = 0;
         
    for(i = 0; i < n; i++)
    {
        
       if (i >= d)
       {
           // Update the variables
           d = k * (m);
           if(d >= n)
           {
               d = n;        
           }    
           i = k * (m - 1) - 1;
           m++;
       }
       else
       {
           int t = arr[i];
           arr[i] = arr[d];
           arr[d] = t;
       }
       d = d - 1;
    }
    return;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
    int k = 3;
    int n = sizeof(arr) / sizeof(arr[0]);
 
    ReverseInGroup(arr, n, k);
 
    for(int i = 0; i < n; i++)
       cout << arr[i] << " ";
 
    return 0;
}
 
// This code is contributed by Code_Mech

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to reverse every sub-array
// formed by consecutive k elements
#include<stdio.h>
 
// Function to reverse every sub-array
// formed by consecutive k elements
void ReverseInGroup(int arr[], int n, int k)
{
    if(n<k)
    {
       k=n;
    }
 
    // Initialize variables
    int d = k-1, m=2;
    int i = 0;
         
    for (i = 0; i < n; i++)
    {
        if (i >= d)
        {  
            // Update the variables
            d = k * (m);
            if(d>=n)
            {
                d = n;            
            }          
            i = k * (m - 1)-1;
            m++;
             
        }
        else
        {
            int t = arr[i];
            arr[i] = arr[d];
            arr[d] = t;
        }
 
     d = d - 1;     
        
    }
    return;
         
}
 
// Driver code
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int k = 3;
   
    int n = sizeof(arr) / sizeof(arr[0]);
   
    ReverseInGroup(arr, n, k);
   
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
   
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to reverse every sub-array
// formed by consecutive k elements
class GFG{
     
// Function to reverse every sub-array
// formed by consecutive k elements
static void ReverseInGroup(int arr[],
                           int n, int k)
{
    if(n < k)
    {
        k = n;
    }
 
    // Initialize variables
    int d = k - 1, m = 2;
    int i = 0;
         
    for(i = 0; i < n; i++)
    {
       if (i >= d)
       {
            
           // Update the variables
           d = k * (m);
           if(d >= n)
           {
               d = n;            
           }        
           i = k * (m - 1) - 1;
           m++;
       }
       else
       {
           int t = arr[i];
           arr[i] = arr[d];
           arr[d] = t;
       }
       d = d - 1;    
    }
    return;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
    int k = 3;
    int n = arr.length;
     
    ReverseInGroup(arr, n, k);
     
    for(int i = 0; i < n; i++)
       System.out.printf("%d ", arr[i]);
}
}
 
// This code is contributed by sapnasingh4991

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to reverse
# every sub-array formed by
# consecutive k elements
 
# Function to reverse every
# sub-array formed by consecutive
# k elements
def ReverseInGroup(arr, n, k):
 
    if(n < k):
        k = n
 
    # Initialize variables
    d = k - 1
    m = 2
    i = 0
 
    while i < n:
        if (i >= d):
 
            # Update the
            # variables
            d = k * (m)
             
            if(d >= n):
                d = n
 
            i = k * (m - 1) - 1
            m += 1
 
        else:
            arr[i], arr[d] = (arr[d],
                              arr[i])
        d = d - 1
        i += 1
 
    return
 
# Driver code
if __name__ == "__main__":
 
    arr = [1, 2, 3,
           4, 5, 6, 7]
    k = 3
    n = len(arr)
    ReverseInGroup(arr, n, k)
 
    for i in range(n):
        print(arr[i],
              end = " ")
 
# This code is contributed by Chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to reverse every sub-array
// formed by consecutive k elements
using System;
class GFG{
     
// Function to reverse every sub-array
// formed by consecutive k elements
static void ReverseInGroup(int []arr,
                           int n, int k)
{
    if(n < k)
    {
        k = n;
    }
 
    // Initialize variables
    int d = k - 1, m = 2;
    int i = 0;
         
    for(i = 0; i < n; i++)
    {
        if (i >= d)
        {
                 
            // Update the variables
            d = k * (m);
            if(d >= n)
            {
                d = n;            
            }        
            i = k * (m - 1) - 1;
            m++;
        }
        else
        {
            int t = arr[i];
            arr[i] = arr[d];
            arr[d] = t;
        }
        d = d - 1;    
    }
    return;
}
 
// Driver code
public static void Main()
{
    int []arr = { 1, 2, 3, 4, 5, 6, 7 };
    int k = 3;
    int n = arr.Length;
     
    ReverseInGroup(arr, n, k);
     
    for(int i = 0; i < n; i++)
        Console.Write(arr[i] + " ");
}
}
 
// This code is contributed by Code_Mech

chevron_right


Output: 

3 2 1 6 5 4 7



 

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
Recommended Articles
Page :