Generar todas las rotaciones de un número

Dado un número entero n , la tarea es generar todos los números de desplazamiento a la izquierda posibles. Un número de desplazamiento a la izquierda es un número que se genera cuando todos los dígitos del número se desplazan una posición a la izquierda y el dígito de la primera posición se desplaza al último.
Ejemplos: 
 

Entrada: n = 123 
Salida: 231 312
Entrada: n = 1445 
Salida: 4451 4514 5144 
 

Acercarse: 
 

• Suponga que n = 123 .
• Multiplique n por 10 , es decir , n = n * 10 = 1230 .
• Agregue el primer dígito al número resultante, es decir , 1230 + 1 = 1231 .
• Resta (primer dígito) * 10 ^k del número resultante donde k es el número de dígitos en el número original (en este caso, k = 3).
• 1231 – 1000 = 231 es el número de desplazamiento a la izquierda del número original.

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of digits of n
int numberOfDigits(int n)
{
    int cnt = 0;
    while (n > 0) {
        cnt++;
        n /= 10;
    }
    return cnt;
}
 
// Function to print the left shift numbers
void cal(int num)
{
    int digits = numberOfDigits(num);
    int powTen = pow(10, digits - 1);
 
    for (int i = 0; i < digits - 1; i++) {
 
        int firstDigit = num / powTen;
 
        // Formula to calculate left shift
        // from previous number
        int left
            = ((num * 10) + firstDigit)
              - (firstDigit * powTen * 10);
        cout << left << " ";
 
        // Update the original number
        num = left;
    }
}
 
// Driver Code
int main()
{
    int num = 1445;
    cal(num);
    return 0;
}

// Java implementation of the approach
class GFG
{
 
// Function to return the count of digits of n
static int numberOfDigits(int n)
{
    int cnt = 0;
    while (n > 0)
    {
        cnt++;
        n /= 10;
    }
    return cnt;
}
 
// Function to print the left shift numbers
static void cal(int num)
{
    int digits = numberOfDigits(num);
    int powTen = (int) Math.pow(10, digits - 1);
 
    for (int i = 0; i < digits - 1; i++)
    {
        int firstDigit = num / powTen;
 
        // Formula to calculate left shift
        // from previous number
        int left = ((num * 10) + firstDigit) -
                    (firstDigit * powTen * 10);
                 
        System.out.print(left + " ");
                 
        // Update the original number
        num = left;
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int num = 1445;
    cal(num);
}
}
 
// This code is contributed by
// PrinciRaj1992

# Python3 implementation of the approach
 
# function to return the count of digit of n
def numberofDigits(n):
    cnt = 0
    while n > 0:
        cnt += 1
        n //= 10
    return cnt
     
# function to print the left shift numbers
def cal(num):
    digit = numberofDigits(num)
    powTen = pow(10, digit - 1)
     
    for i in range(digit - 1):
         
        firstDigit = num // powTen
         
        # formula to calculate left shift
        # from previous number
        left = (num * 10 + firstDigit -
               (firstDigit * powTen * 10))
        print(left, end = " ")
         
        # Update the original number
        num = left
         
# Driver code
num = 1445
cal(num)
 
# This code is contributed
# by Mohit Kumar

// C# implementation of the approach
using System;
 
public class GFG{
     
// Function to return the count of digits of n
static int numberOfDigits(int n)
{
    int cnt = 0;
    while (n > 0) {
        cnt++;
        n /= 10;
    }
    return cnt;
}
 
// Function to print the left shift numbers
static void cal(int num)
{
    int digits = numberOfDigits(num);
    int powTen = (int)Math.Pow(10, digits - 1);
 
    for (int i = 0; i < digits - 1; i++) {
 
        int firstDigit = num / powTen;
 
        // Formula to calculate left shift
        // from previous number
        int left
            = ((num * 10) + firstDigit)
            - (firstDigit * powTen * 10);
        Console.Write(left +  " ");
 
        // Update the original number
        num = left;
    }
}
 
// Driver Code
    static public void Main (){
        int num = 1445;
        cal(num);
    }
}
 
// This code is contributed by akt_mit....  

<?php
// PHP implementation of the approach
 
// Function to return the count
// of digits of n
function numberOfDigits($n)
{
    $cnt = 0;
    while ($n > 0)
    {
        $cnt++;
        $n = floor($n / 10);
    }
    return $cnt;
}
 
// Function to print the left shift numbers
function cal($num)
{
    $digits = numberOfDigits($num);
    $powTen = pow(10, $digits - 1);
 
    for ($i = 0; $i < $digits - 1; $i++)
    {
 
        $firstDigit = floor($num / $powTen);
 
        // Formula to calculate left shift
        // from previous number
        $left
            = (($num * 10) + $firstDigit) -
               ($firstDigit * $powTen * 10);
             
        echo $left, " ";
 
        // Update the original number
        $num = $left;
    }
}
 
// Driver Code
$num = 1445;
cal($num);
 
// This code is contributed by Ryuga
?>

<script>
 
    // Javascript implementation of the approach
     
    // Function to return the count of digits of n
    function numberOfDigits(n)
    {
        let cnt = 0;
        while (n > 0) {
            cnt++;
            n = parseInt(n / 10, 10);
        }
        return cnt;
    }
 
    // Function to print the left shift numbers
    function cal(num)
    {
        let digits = numberOfDigits(num);
        let powTen = Math.pow(10, digits - 1);
 
        for (let i = 0; i < digits - 1; i++) {
 
            let firstDigit = parseInt(num / powTen, 10);
 
            // Formula to calculate left shift
            // from previous number
            let left = ((num * 10) + firstDigit)
                - (firstDigit * powTen * 10);
            document.write(left +  " ");
 
            // Update the original number
            num = left;
        }
    }
     
    let num = 1445;
    cal(num);
     
</script>

4451 4514 5144

Complejidad de Tiempo: O(log ₁₀ n)
Espacio Auxiliar: O(1), ya que no se ha tomado espacio extra.