Rotate digits of a given number by K
Given two integers N and K, the task is to rotate the digits of N by K. If K is a positive integer, left rotate its digits. Otherwise, right rotate its digits.
Examples:
Input: N = 12345, K = 2
Output: 34512
Explanation:
Left rotating N(= 12345) by K(= 2) modifies N to 34512.
Therefore, the required output is 34512Input: N = 12345, K = -3
Output: 34512
Explanation:
Right rotating N(= 12345) by K( = -3) modifies N to 34512.
Therefore, the required output is 34512
Approach:
Approach to solve this problem is to convert the given number N into a string, and then perform string rotations using substrings and concatenation operations. For left rotation, we can extract the first K digits of the string, and append them to the end of the remaining digits of the string. For right rotation, we can extract the last K digits of the string, and prepend them to the beginning of the remaining digits of the string. Finally, we can convert the resulting rotated string back to an integer and return it as the output.
Here are the steps of approach:
- Convert the given integer N to a string.
- Check whether K is positive or negative. If K is positive, perform a left rotation; otherwise, perform a right rotation.
- For left rotation, extract the first K digits of the string using the substr() function and store it in a new string. Then, extract the remaining digits of the string using substr() and append the first K digits at the end of it using concatenation.
- For right rotation, extract the last K digits of the string using substr() and store it in a new string. Then, extract the remaining digits of the string using substr() and prepend the last K digits at the beginning of it using concatenation.
- Convert the rotated string back to an integer using stoi() function.
- Return the rotated integer as the output.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h> using namespace std; // Function to rotate the digits of N by K void rotateNumberByK( int N, int K) { // Convert N to a string string num = to_string(N); int len = num.length(); // Rotate the string if (K > 0){ string rotated = num.substr(K) + num.substr(0, K); cout << stoi(rotated); } else { K = abs (K); string rotated = num.substr(len-K) + num.substr(0, len-K); cout << stoi(rotated); } } // Driver code int main() { int N = 12345, K = 2; // Function Call rotateNumberByK(N, K); return 0; } |
Java
/*package whatever //do not write package name here */ import java.util.*; public class GFG { // Function to rotate the digits of N by K public static void rotateNumberByK( int N, int K) { // Convert N to a string String num = Integer.toString(N); int len = num.length(); // Rotate the string if (K > 0 ) { String rotated = num.substring(K) + num.substring( 0 , K); System.out.print(Integer.parseInt(rotated)); } else { K = Math.abs(K); String rotated = num.substring(len - K) + num.substring( 0 , len - K); System.out.print(Integer.parseInt(rotated)); } } // Driver code public static void main(String[] args) { int N = 12345 , K = 2 ; // Function Call rotateNumberByK(N, K); } } |
Python3
def rotate_number_by_k(N, K): # Convert N to a string num = str (N) length = len (num) # Rotate the string if K > 0 : rotated = num[K:] + num[:K] print ( int (rotated)) else : K = abs (K) rotated = num[length - K:] + num[:length - K] print ( int (rotated)) # Driver code if __name__ = = "__main__" : N = 12345 K = 2 # Function Call rotate_number_by_k(N, K) |
C#
using System; public class GFG { // Function to rotate the digits of N by K public static void RotateNumberByK( int N, int K) { // Convert N to a string string num = N.ToString(); int len = num.Length; // Rotate the string if (K > 0) { string rotated = num.Substring(K) + num.Substring(0, K); Console.WriteLine( int .Parse(rotated)); } else { K = Math.Abs(K); string rotated = num.Substring(len - K) + num.Substring(0, len - K); Console.WriteLine( int .Parse(rotated)); } } // Driver code public static void Main() { int N = 12345, K = 2; // Function Call RotateNumberByK(N, K); } } |
Javascript
// Function to rotate the digits of N by K function rotateNumberByK(N, K) { // Convert N to a string let num = N.toString(); let len = num.length; // Rotate the string if (K > 0) { let rotated = num.substring(K) + num.substring(0, K); console.log(parseInt(rotated)); } else { K = Math.abs(K); let rotated = num.substring(len - K) + num.substring(0, len - K); console.log(parseInt(rotated)); } } // Driver code const N = 12345; const K = 2; // Function Call rotateNumberByK(N, K); |
34512
Time Complexity: O(N), where N is the number of digits in the given integer.
Space Complexity: O(N), as it involves creating a string representation of the integer and storing it in memory.
Approach: Follow the steps below to solve the problem:
- Initialize a variable, say X, to store the count of digits in N.
- Update K = (K + X) % X to reduce it to a case of left rotation.
- Remove the first K digits of N and append all the removed digits to the right of the digits of N.
- Finally, print the value of N.
Below is the implementation of the above approach:
C++
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function to find the count of // digits in N int numberOfDigit( int N) { // Stores count of // digits in N int digit = 0; // Calculate the count // of digits in N while (N > 0) { // Update digit digit++; // Update N N /= 10; } return digit; } // Function to rotate the digits of N by K void rotateNumberByK( int N, int K) { // Stores count of digits in N int X = numberOfDigit(N); // Update K so that only need to // handle left rotation K = ((K % X) + X) % X; // Stores first K digits of N int left_no = N / ( int )( pow (10, X - K)); // Remove first K digits of N N = N % ( int )( pow (10, X - K)); // Stores count of digits in left_no int left_digit = numberOfDigit(left_no); // Append left_no to the right of // digits of N N = (N * ( int )( pow (10, left_digit))) + left_no; cout << N; } // Driver code int main() { int N = 12345, K = 7; // Function Call rotateNumberByK(N, K); return 0; } // The code is contributed by Dharanendra L V |
Java
// Java program to implement // the above approach import java.io.*; class GFG { // Function to find the count of // digits in N static int numberOfDigit( int N) { // Stores count of // digits in N int digit = 0 ; // Calculate the count // of digits in N while (N > 0 ) { // Update digit digit++; // Update N N /= 10 ; } return digit; } // Function to rotate the digits of N by K static void rotateNumberByK( int N, int K) { // Stores count of digits in N int X = numberOfDigit(N); // Update K so that only need to // handle left rotation K = ((K % X) + X) % X; // Stores first K digits of N int left_no = N / ( int )(Math.pow( 10 , X - K)); // Remove first K digits of N N = N % ( int )(Math.pow( 10 , X - K)); // Stores count of digits in left_no int left_digit = numberOfDigit(left_no); // Append left_no to the right of // digits of N N = (N * ( int )(Math.pow( 10 , left_digit))) + left_no; System.out.println(N); } // Driver Code public static void main(String args[]) { int N = 12345 , K = 7 ; // Function Call rotateNumberByK(N, K); } } |
Python3
# Python3 program to implement # the above approach # Function to find the count of # digits in N def numberOfDigit(N): # Stores count of # digits in N digit = 0 # Calculate the count # of digits in N while (N > 0 ): # Update digit digit + = 1 # Update N N / / = 10 return digit # Function to rotate the digits of N by K def rotateNumberByK(N, K): # Stores count of digits in N X = numberOfDigit(N) # Update K so that only need to # handle left rotation K = ((K % X) + X) % X # Stores first K digits of N left_no = N / / pow ( 10 , X - K) # Remove first K digits of N N = N % pow ( 10 , X - K) # Stores count of digits in left_no left_digit = numberOfDigit(left_no) # Append left_no to the right of # digits of N N = N * pow ( 10 , left_digit) + left_no print (N) # Driver Code if __name__ = = '__main__' : N, K = 12345 , 7 # Function Call rotateNumberByK(N, K) # This code is contributed by mohit kumar 29 |
C#
// C# program to implement // the above approach using System; class GFG { // Function to find the count of // digits in N static int numberOfDigit( int N) { // Stores count of // digits in N int digit = 0; // Calculate the count // of digits in N while (N > 0) { // Update digit digit++; // Update N N /= 10; } return digit; } // Function to rotate the digits of N by K static void rotateNumberByK( int N, int K) { // Stores count of digits in N int X = numberOfDigit(N); // Update K so that only need to // handle left rotation K = ((K % X) + X) % X; // Stores first K digits of N int left_no = N / ( int )(Math.Pow(10, X - K)); // Remove first K digits of N N = N % ( int )(Math.Pow(10, X - K)); // Stores count of digits in left_no int left_digit = numberOfDigit(left_no); // Append left_no to the right of // digits of N N = (N * ( int )(Math.Pow(10, left_digit))) + left_no; Console.WriteLine(N); } // Driver Code public static void Main( string []args) { int N = 12345, K = 7; // Function Call rotateNumberByK(N, K); } } // This code is contributed by AnkThon |
Javascript
<script> // Javascript program to implement // the above approach // Function to find the count of // digits in N function numberOfDigit(N) { // Stores count of // digits in N let digit = 0; // Calculate the count // of digits in N while (N > 0) { // Update digit digit++; // Update N N = Math.floor( N / 10); } return digit; } // Function to rotate the digits of N by K function rotateNumberByK(N, K) { // Stores count of digits in N let X = numberOfDigit(N); // Update K so that only need to // handle left rotation K = ((K % X) + X) % X; // Stores first K digits of N let left_no = Math.floor (N / Math.floor(Math.pow(10, X - K))); // Remove first K digits of N N = N % Math.floor(Math.pow(10, X - K)); // Stores count of digits in left_no let left_digit = numberOfDigit(left_no); // Append left_no to the right of // digits of N N = (N * Math.floor(Math.pow(10, left_digit))) + left_no; document.write(N); } // Driver Code let N = 12345, K = 7; // Function Call rotateNumberByK(N, K); // This code is contributed by souravghosh0416. </script> |
34512
Time Complexity: O(log10N)
Auxiliary Space: O(1)