The Wayback Machine - https://web.archive.org/web/20210512231037/https://www.geeksforgeeks.org/reverse-an-array-in-groups-of-given-size/
Skip to content
Related Articles

Related Articles

Reverse an array in groups of given size
  • Difficulty Level : Easy
  • Last Updated : 17 May, 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]
k = 3
Output:
[3, 2, 1, 6, 5, 4, 9, 8, 7]

Input:
arr = [1, 2, 3, 4, 5, 6, 7, 8]
k = 5
Output:
[5, 4, 3, 2, 1, 8, 7, 6]

Input:
arr = [1, 2, 3, 4, 5, 6]
k = 1
Output:
[1, 2, 3, 4, 5, 6]



Input:
arr = [1, 2, 3, 4, 5, 6, 7, 8]
k = 10
Output:
[8, 7, 6, 5, 4, 3, 2, 1]

Approach: Consider every sub-array of size k starting from the beginning of the array and reverse it. We need to handle some special cases. If k is not multiple of n where n is the size of the array, for the last group we will have less than k elements left, we need to reverse all remaining elements. If k = 1, the array should remain unchanged. If k >= n, we reverse all elements present in the array.

Below image is a dry run of the above approach:

Below is the implementation of the above approach:

C++




// C++ program to reverse every sub-array formed by
// consecutive k elements
#include <iostream>
using namespace std;
  
// Function to reverse every sub-array formed by
// consecutive k elements
void reverse(int arr[], int n, int k)
{
    for (int i = 0; i < n; i += k)
    {
        int left = i;
  
        // to handle case when 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};
    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 sub-array formed by
// consecutive k elements
class GFG {
      
    // Function to reverse every sub-array formed by
    // consecutive k elements
    static void reverse(int arr[], int n, int k)
    {
        for (int i = 0; i < n; i += k)
        {
            int left = i;
      
            // to handle case when k is not multiple
            // of n
            int right = Math.min(i + k - 1, n - 1);
            int temp;
              
            // reverse the sub-array [left, right]
            while (left < right)
            {
                temp=arr[left];
                arr[left]=arr[right];
                arr[right]=temp;
                left+=1;
                right-=1;
            }
        }
    }
      
    // Driver method
    public static void main(String[] args)
    {
          
        int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
        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 is contributed by Anant Agarwal.
Python3



# Python 3 program to reverse every 
# sub-array formed by consecutive k
# elements
  
# Function to reverse every sub-array
# formed by consecutive k elements
def reverse(arr, n, k):
    i = 0
      
    while(i<n):
      
        left = i 
  
        # To handle case when k is not
        # multiple of n
        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
        i+= k
      
# Driver code
arr = [1, 2, 3, 4, 5, 6,
                   7, 8] 
  
k = 3
n = len(arr) 
reverse(arr, n, k)
  
for i in range(0, n):
        print(arr[i], end =" ")
          
# This code is contributed by Smitha Dinesh Semwal
C#



// 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
public static void reverse(int[] arr, 
                           int n, int k)
{
    for (int i = 0; i < n; i += k)
    {
        int left = i;
  
        // to handle case when k is 
        // not multiple of n
        int right = Math.Min(i + k - 1, n - 1);
        int temp;
  
        // 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
public static void Main(string[] args)
{
    int[] arr = new int[] {1, 2, 3, 4, 
                           5, 6, 7, 8};
    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 Shrikant13
PHP



<?php
// PHP program to reverse every sub-array 
// formed by consecutive k elements
      
// Function to reverse every sub-array 
// formed by consecutive k elements
function reverse($arr, $n, $k)
{
    for ($i = 0; $i < $n; $i += $k)
    {
        $left = $i;
  
        // to handle case when k is not 
        // multiple of n
        $right = min($i + $k - 1, $n - 1);
        $temp;
          
        // reverse the sub-array [left, right]
        while ($left < $right)
        {
            $temp = $arr[$left];
            $arr[$left] = $arr[$right];
            $arr[$right] = $temp;
            $left += 1;
            $right -= 1;
        }
    }
    return $arr;
}
  
// Driver Code
$arr = array(1, 2, 3, 4, 5, 6, 7, 8);
$k = 3;
  
$n = sizeof($arr);
  
$arr1 = reverse($arr, $n, $k);
  
for ($i = 0; $i < $n; $i++)
    echo $arr1[$i] . " ";
  
// This code is contributed 
// by Akanksha Rai
?>

Output:
3 2 1 6 5 4 8 7

Time complexity of above solution is O(n).
Auxiliary space used by the program is O(1).
This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
My Personal Notes
arrow_drop_up
Previous
Minimum Number of Platforms Required for a Railway/Bus Station
Next

K'th Smallest/Largest Element in Unsorted Array | Set 1
Recommended Articles
Page :
Reverse an array in groups of given size | Set 3 (Single traversal)
27, Apr 20
Reverse an array in groups of given size | Set 2 (Variations of Set 1 )
23, Aug 16
Reverse a doubly linked list in groups of given size
13, Jan 18
XOR Linked List - Reverse a Linked List in groups of given size
17, Jan 21
Reverse a Linked List in groups of given size | Set 1
14, Jun 10
Minimum difference between groups of size two
03, May 18
Maximize number of groups formed with size not smaller than its largest element
18, May 20
Find the size of largest group where groups are according to the xor of digits
26, Apr 20
Count all possible groups of size 2 or 3 that have sum as multiple of 3
24, Mar 14
Maximum difference between groups of size two
04, May 18
Count of unique pairs (i, j) in an array such that sum of A[i] and reverse of A[j] is equal to sum of reverse of A[i] and A[j]
12, Feb 21
Minimum sum obtained from groups of four elements from the given array
19, Sep 19
Merge an array of size n into another array of size m+n
05, Sep 09
Reverse a Linked List according to its Size
12, Jun 18
Divide N segments into two non-empty groups such that given condition is satisfied
21, Jan 19
Queries to count groups of N students possible having sum of ratings within given range
29, Oct 20
Partition the array into two odd length groups with minimized absolute difference between their median
26, Feb 20
Ways to split array into two groups of same XOR value
13, Dec 17
Split an array into groups of 3 such that X3 is divisible by X2 and X2 is divisible by X1
14, Feb 19
Reverse the substrings of the given String according to the given Array of indices
26, Feb 20
First string from the given array whose reverse is also present in the same array
12, Mar 19
Number of groups of magnets formed from N magnets
30, Oct 18
Python | Split string in groups of n consecutive characters
19, Feb 19
Maximize the happiness of the groups on the Trip
03, Jun 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox