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 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:

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)

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);

Output

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

Time Complexity: O(log₁₀N)
Auxiliary Space: O(1)

Article Tags :

DSA

Mathematical

number-digits

rotation