Reverse an array upto a given position

Last Updated : 13 Feb, 2023

Given an array arr[] and a position in array, k. Write a function name reverse (a[], k) such that it reverses subarray arr[0..k-1]. Extra space used should be O(1) and time complexity should be O(k).
Example:

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

We strongly recommend you to minimize your browser and try this yourself first.

Below is the implementation for the same.

C++

   // C++ program to reverse a subarray arr[0..k-1]
#include <bits/stdc++.h>
using namespace std;
 
// Reverse subarray a[0..k-1]
void reverse(int a[], int n, int k)
{
    if (k > n)
    {
        cout << "Invalid k";
        return;
    }
 
    // One by one reverse first and last elements of a[0..k-1]
    for (int i = 0; i < k/2; i++)
        swap(a[i], a[k-i-1]);
}
 
// Driver program
int main()
{
    int a[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(a) / sizeof(int), k = 4;
 
    reverse(a, n, k);
 
    for (int i = 0; i < n; ++i)
        printf("%d ", a[i]);
 
    return 0;
}
 
  

Java

   // java program to reverse a 
// subarray arr[0..k-1]
 
public class GFG {
 
    // Reverse subarray a[0..k-1]
    static void reverse(int []a, int n, int k)
    {
        if (k > n)
        {
            System.out.println( "Invalid k");
            return;
        }
     
        // One by one reverse first 
        // and last elements of a[0..k-1]
        for (int i = 0; i < k / 2; i++)
        {
            int tempswap = a[i]; 
                a[i] = a[k - i - 1]; 
                a[k - i - 1] = tempswap;             
        } 
    }
 
    // Driver code
    public static void main(String args[])
    {
        int []a = {1, 2, 3, 4, 5, 6};
        int n = a.length, k = 4;
        reverse(a, n, k);
        for (int i = 0; i < n; ++i)
            System.out.print(a[i] + " ");
    }
}
 
// This code is contributed by Sam007.
 
  

Python3

   # python program to reverse a subarray
# arr[0..k-1]
from __future__ import print_function
 
# Reverse subarray a[0..k-1]
def reverse(a, n, k):
     
    if (k > n):
        print( "Invalid k")
        return
     
    # One by one reverse first and
    # last elements of a[0..k-1]
    for i in range(0, (int)(k/2)):
        temp = a[i]
        a[i] = a[k-i-1]
        a[k-i-1] = temp
         
# Driver program
a = [1, 2, 3, 4, 5, 6]
n = len(a)
k = 4
 
reverse(a, n, k);
 
for i in range(0, n):
    print(a[i], end=" ")
     
# This code is contributed by Sam007.
 
  

C#

   // C# program to reverse a 
// subarray arr[0..k-1]
using System;
 
class GFG {
     
static void SwapNum(ref int x, ref int y) 
{
    int tempswap = x; 
    x = y; 
    y = tempswap;             
} 
     
// Reverse subarray a[0..k-1]
static void reverse(int []a, int n, 
                             int k)
{
    if (k > n)
    {
        Console.Write( "Invalid k");
        return;
    }
 
    // One by one reverse first 
    // and last elements of a[0..k-1]
    for (int i = 0; i < k / 2; i++)
        SwapNum(ref a[i], ref a[k - i - 1]);
         
}
 
// Driver Code
public static void Main()
{
    int []a = {1, 2, 3, 4, 5, 6};
    int n = a.Length, k = 4;
 
    reverse(a, n, k);
 
    for (int i = 0; i < n; ++i)
        Console.Write(a[i] + " ");
}
}
 
// This code is contributed by Sam007
 
  

Javascript

   <script>
 
// Javascript program to reverse
// a subarray arr[0..k-1]
 
// Reverse subarray a[0..k-1]
function reverse( a, n, k)
{
    if (k > n)
    {
        document.write("Invalid k");
        return;
    }
 
    // One by one reverse first 
    // and last elements of a[0..k-1]
    for (let i = 0; i < Math.floor(k/2); i++)
    {
      let temp = a[i] ;
      a[i] = a[k-i-1] ;
      a[k-i-1] = temp ;
    }
     
}
    // driver code 
     
    let a = [1, 2, 3, 4, 5, 6];
    let n = a.length, k = 4;
 
    reverse(a, n, k);
 
    for (let i = 0; i < n; ++i)
        document.write(a[i] + " ");
 
</script>
 
  

Output

4 3 2 1 5 6

Time complexity: O(k)

Auxiliary Space: O(1) ,since extra space is used.

Method 2 (using STL):

In this method we will use an in-built C++ STL function named reverse. This function completes the task of reversing K elements of array in O(K) time and also doesn’t use extra space.

implementation of this method is below.

C++

   // C++ program to reverse the first K
// elements using in-built function
#include <bits/stdc++.h>
using namespace std;
int main()
{
 
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int k = 4;
 
    // STL function to reverse element
    // from 0 index to K-1 index.
    reverse(arr, arr + k);
    // printing the array after reversing
    // first K elements.
    for (int i = 0; i < 8; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}
 
// this code is contributed by Machhaliya Muhammad
 
  

Java

   // Java program to reverse the first K
// elements using in-built function
 
import java.io.*;
import java.util.*;
import java.util.Arrays;
 
class GFG {
    public static void main (String[] args) {
    Integer[] arr = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int k = 4;
 
    // Java Library function to reverse element
    // from 0 index to K-1 index.
    Integer[] arr1 = Arrays.copyOfRange(arr, 0, k);   
    Collections.reverse(Arrays.asList(arr1));
    System.arraycopy(arr1, 0, arr, 0, k);  
 
    // printing the array after reversing
    // first K elements.
    for (int i = 0; i < 8; i++) {
    System.out.print(arr[i] + " ");
    }
    }
}
 
// This code is contributed by Aman Kumar.
 
  

Python3

   # Python3 program to reverse the first K
# elements using in-built function
arr = [ 1, 2, 3, 4, 5, 6, 7, 8 ]
k = 4
 
# Using list slicing to reverse the array
# from 0 index to K-1 index.
arr[:k] = arr[:k][::-1]
 
# printing the array after reversing
# first K elements.
print(*arr)
 
# This code is contributed by phasing17
 
  

C#

   // C# program to reverse the first K
// elements using in-built function
using System;
using System.Collections.Generic;
 
class GFG 
{
  public static void Main(string[] args)
  {
    int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int k = 4;
 
    // C# Library function to reverse element
    // from 0 index to K-1 index.
    Array.Reverse(arr, 0, k);
 
    // printing the array after reversing
    // first K elements.
    for (int i = 0; i < 8; i++) {
      Console.Write(arr[i] + " ");
    }
  }
}
 
// this code is contributed by phasing17
 
  

Javascript

   // JavaScript program to reverse the first K
// elements using in-built functions
let arr = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
let k = 4;
 
// Library function to reverse element
// from 0 index to K-1 index.
let arr1 = arr.slice(0, k);
arr1.reverse();
arr.splice(0, k, ...arr1);
 
// printing the array after reversing
// first K elements.
for (var i = 0; i < 8; i++) 
    process.stdout.write(arr[i] + " ");
 
// This code is contributed by phasing17
 
  

Output

4 3 2 1 5 6 7 8

Time Complexity :O(K) , as complexity of reverse() function is O(number of elements of array to be sorted).

Auxiliary Space :O(1), as no extra space used.

Reverse an Array in groups of given size

kartik

Improve

Article Tags :

Practice Tags :

Reverse an array upto a given position

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Similar Reads