Skip to content
Related Articles

Related Articles

Improve Article

Rotate digits of a given number by K

  • Difficulty Level : Easy
  • Last Updated : 29 Apr, 2021

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 34512

Input: 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: 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>
Output: 
34512
 
Time Complexity: O(log10N)
Auxiliary Space: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.



My Personal Notes
arrow_drop_up
Next

Generate all rotations of a number
Recommended Articles
Page :
Find smallest number with given number of digits and sum of digits under given constraints
26, Jan 20
Minimum digits to be removed to make either all digits or alternating digits same
15, Aug 20
Numbers of Length N having digits A and B and whose sum of digits contain only digits A and B
31, Jan 19
Maximize the given number by replacing a segment of digits with the alternate digits given
30, Apr 19
Find smallest number with given number of digits and sum of digits
06, Jun 16
Number of digits in the nth number made of given four digits
07, May 18
Find the Largest number with given number of digits and sum of digits
06, Jun 16
Smallest number with given sum of digits and sum of square of digits
14, Jun 18
Find the average of k digits from the beginning and l digits from the end of the given number
13, Aug 19
Sum of the digits of square of the given number which has only 1's as its digits
20, Sep 19
Find smallest number with given digits and sum of digits
10, Aug 21
Number formed by deleting digits such that sum of the digits becomes even and the number odd
26, Feb 20
Check if sum of digits of a number exceeds the product of digits of that number
13, May 21
Count of integers in a range which have even number of odd digits and odd number of even digits
21, Aug 19
Rotate bits of a number
31, Oct 09
Count numbers in given range such that sum of even digits is greater than sum of odd digits
26, Jun 19
Count numbers from given range having odd digits at odd places and even digits at even places
02, Dec 20
Count numbers from a given range that can be expressed as sum of digits raised to the power of count of digits
02, Mar 21
Minimum number of digits to be removed so that no two consecutive digits are same
26, Oct 18
Check whether product of digits at even places is divisible by sum of digits at odd place of a number
19, Nov 18
Check if the sum of digits of number is divisible by all of its digits
12, Sep 19
Smallest positive number made up of non-repeating digits whose sum of digits is N
17, Dec 20
Count of numbers between range having only non-zero digits whose sum of digits is N and number is divisible by M
13, Feb 19
Rotate a Linked List
23, Aug 12
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
dekay
@dekay
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

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