Open In App

Reverse an array upto a given position

Last Updated : 13 Feb, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

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.


K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

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