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++ 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 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. |
# 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# 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 |
<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> |
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++ 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 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 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# 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 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 |
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.