Given an array arr[] of size N and a value K (-10^5<K<10^5), the task is to print the array rotated by K times to the right.
Examples:
Input: arr = {1, 3, 5, 7, 9}, K = 2
Output: 7 9 1 3 5
Explanation:
Rotating array 1 time right: 9, 1, 3, 5, 7
Rotating array 2 time right: 7, 9, 1, 3, 5Input: arr = {1, 2, 3, 4, 5}, K = -2
Output: 3 4 5 1 2
Explanation:
Rotating array -1 time right: 2, 3, 4, 5, 1
Rotating array -2 time right: 3, 4, 5, 1, 2
Naive Approach: The brute force approach to solve this problem is to use a temporary array to rotate the array K or -K times.
Time Complexity: O(N)
Auxiliary Space: O(N)
Efficient Approach: The given problem can be solved by breaking the problem into the following parts:
- Round up the value of K in range [0, N), using below steps:
- If K is negative, first change it into positive, find the modulo with N, and then again change it to negative
- If K is positive, just find the modulo with N
- Handle the case when K is negative. If K is negative, it means we need to rotate the array K times left, or -K times right.
- Next we can simply rotate the array K times by reversing subarrays. Below steps can be followed to solve the problem:
- Reverse all the array elements from 1 to N -1
- Reverse the array elements from 1 to K – 1
- Reverse the array elements from K to N -1
// C++ implementation for the above approach #include <bits/stdc++.h> using namespace std;
// Function to rotate the array // to the right, K times void RightRotate(vector< int >& nums, int K)
{ int n = nums.size();
// Case when K > N or K < -N
K = K < 0 ? ((K * -1) % n) * -1 : K % n;
// Case when K is negative
K = K < 0 ? (n - (K * -1)) : K;
// Reverse all the array elements
reverse(nums.begin(), nums.end());
// Reverse the first k elements
reverse(nums.begin(), nums.begin() + K);
// Reverse the elements from K
// till the end of the array
reverse(nums.begin() + K, nums.end());
} // Driver code int main()
{ // Initialize the array
vector< int > Array = { 1, 2, 3, 4, 5 };
// Find the size of the array
int N = Array.size();
// Initialize K
int K = -2;
// Call the function and
// print the answer
RightRotate(Array, K);
// Print the array after rotation
for ( int i = 0; i < N; i++) {
cout << Array[i] << " " ;
}
cout << endl;
return 0;
} |
// Java implementation for the above approach import java.util.*;
class GFG{
// Initialize the array
static int [] Array = { 1 , 2 , 3 , 4 , 5 };
static void reverse( int start, int end) {
// Temporary variable to store character
int temp;
while (start <= end)
{
// Swapping the first and last character
temp = Array[start];
Array[start] = Array[end];
Array[end] = temp;
start++;
end--;
}
}
// Function to rotate the array // to the right, K times static void RightRotate( int K)
{ int n = Array.length;
// Case when K > N or K < -N
K = K < 0 ? ((K * - 1 ) % n) * - 1 : K % n;
// Case when K is negative
K = K < 0 ? (n - (K * - 1 )) : K;
// Reverse all the array elements
reverse( 0 , n- 1 );
// Reverse the first k elements
reverse( 0 , n - K);
// Reverse the elements from K
// till the end of the array
reverse( K, n- 1 );
} // Driver code public static void main(String[] args)
{ // Find the size of the array
int N = Array.length;
// Initialize K
int K = - 2 ;
// Call the function and
// print the answer
RightRotate(K);
// Print the array after rotation
for ( int i = 0 ; i < N; i++) {
System.out.print(Array[i]+ " " );
}
System.out.println();
} } // This code is contributed by Rajput-Ji |
# Python code for the above approach # Function to rotate the array # to the right, K times def RightRotate(nums, K) :
n = len (nums)
# Case when K > N or K < -N
K = ((K * - 1 ) % n) * - 1 if K < 0 else K % n;
# Case when K is negative
K = (n - (K * - 1 )) if K < 0 else K;
# Reverse all the array elements
nums.reverse();
# Reverse the first k elements
p1 = nums[ 0 :K]
p1.reverse();
# Reverse the elements from K
# till the end of the array
p2 = nums[K:]
p2.reverse();
arr = p1 + p2
return arr;
# Driver code # Initialize the array Array = [ 1 , 2 , 3 , 4 , 5 ];
# Find the size of the array N = len (Array)
# Initialize K K = - 2 ;
# Call the function and # print the answer Array = RightRotate(Array, K);
# Print the array after rotation for i in Array:
print (i, end = " " )
# This code is contributed by Saurabh jaiswal |
// C# implementation for the above approach using System;
public class GFG {
// Initialize the array
static int [] Array = { 1, 2, 3, 4, 5 };
static void reverse( int start, int end)
{
// Temporary variable to store character
int temp;
while (start <= end) {
// Swapping the first and last character
temp = Array[start];
Array[start] = Array[end];
Array[end] = temp;
start++;
end--;
}
}
// Function to rotate the array
// to the right, K times
static void RightRotate( int K) {
int n = Array.Length;
// Case when K > N or K < -N
K = K < 0 ? ((K * -1) % n) * -1 : K % n;
// Case when K is negative
K = K < 0 ? (n - (K * -1)) : K;
// Reverse all the array elements
reverse(0, n - 1);
// Reverse the first k elements
reverse(0, n - K);
// Reverse the elements from K
// till the end of the array
reverse(K, n - 1);
}
// Driver code
public static void Main(String[] args) {
// Find the size of the array
int N = Array.Length;
// Initialize K
int K = -2;
// Call the function and
// print the answer
RightRotate(K);
// Print the array after rotation
for ( int i = 0; i < N; i++) {
Console.Write(Array[i] + " " );
}
Console.WriteLine();
}
} // This code is contributed by Rajput-Ji |
<script> // JavaScript code for the above approach
// Function to rotate the array
// to the right, K times
function RightRotate(nums, K)
{
let n = nums.length;
// Case when K > N or K < -N
K = K < 0 ? ((K * -1) % n) * -1 : K % n;
// Case when K is negative
K = K < 0 ? (n - (K * -1)) : K;
// Reverse all the array elements
nums = nums.reverse();
// Reverse the first k elements
let p1 = nums.slice(0, K)
p1 = p1.reverse();
// Reverse the elements from K
// till the end of the array
let p2 = nums.slice(K)
p2 = p2.reverse();
let arr = p1.concat(p2);
return arr;
}
// Driver code
// Initialize the array
let Array = [1, 2, 3, 4, 5];
// Find the size of the array
let N = Array.length;
// Initialize K
let K = -2;
// Call the function and
// print the answer
Array = RightRotate(Array, K);
// Print the array after rotation
for (let i = 0; i < N; i++) {
document.write(Array[i] + " " );
}
document.write( '<br>' )
// This code is contributed by Potta Lokesh
</script>
|
3 4 5 1 2
Time Complexity: O(N)
Auxiliary Space: O(1)