Open in App
Not now

# Reverse an array upto a given position

• Difficulty Level : Easy
• 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 ` `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

 ``

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 ` `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.

My Personal Notes arrow_drop_up
Related Articles