Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like 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:

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.

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)




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!