Reverse array in groups

Problem

Given an array arr[] of positive integers of size N. Reverse every sub-array group of size K.

Note: If at any instance, there are no more subarrays of size greater than or equal to K, then reverse the last subarray (irrespective of its size). You shouldn't return any array, modify the given array in-place.

Examples:

Example 1:

Input:
N = 5, K = 3
arr[] = {1,2,3,4,5}
Output: 3 2 1 5 4
Explanation: First group consists of elements 1, 2, 3. Second group consists of 4,5.

Example 2:

Input:
N = 4, K = 3
arr[] = {5,6,8,9}
Output: 8 6 5 9

Your Task:

You don't need to read input or print anything. The task is to complete the function reverseInGroups() which takes the array, N and K as input parameters and modifies the array in-place.

• Expected Time Complexity: $O(N)$
• Expected Auxiliary Space: $O(1)$

Constraints:

• $1 ≤ N, K ≤ 10^7$
• $1 ≤ A[i] ≤ 10^{18}$

Solution

Python

def reverseInGroups(self, 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
            i+= K

Java

void reverseInGroups(ArrayList<Integer> arr, int n, int k) {
    for (int i = 0; i < n; i += k) {
        int left = i;
        int right = Math.min(i + k - 1, n - 1); 
        while (left < right) {
            int temp = arr.get(left);
            arr.set(left, arr.get(right));
            arr.set(right, temp);
            left++; 
            right--; 
        }
    }
}

C++

void reverseInGroups(vector<long long>& arr, int n, int k){
    for (int i = 0; i < n; i += k) {
        int left = i;
        int right = min(i + k - 1, n - 1);
        while (left < right)
            swap(arr[left++], arr[right--]);
    }
}

C

void reverse(int arr[], int n, int k) {
    for (int i = 0; i < n; i += k) {
        int left = i;
        int right;
        if(i+k-1<n-1)
        right = i+k-1;
        else
        right = n-1;
        while (left < right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
        }
    }
}

• Time Complexity: $O(N)$
• Auxiliary Space: $O(1)$