遞歸 - 以相反順序的數字

Question

我需要實現一個遞歸方法printDigits，它將整數num作爲參數，並以相反的順序打印其數字，每行一位。

這是我到目前爲止有：

public class PrintDigits { 

    public static void main(String[] args) { 
     System.out.println("Reverse of no. is " + reversDigits(91)); 
    } 

    /* Recursive function to reverse digits of num */ 
    public static int reversDigits(int number) { 
     if (number == 0) 
      return number; 
     else { 
      return number % 10; 
     } 
    } 
} 

感覺好像是，我很想念只有一行代碼，但不知道我需要做什麼來解決它。

Answer 1

public static void main(String[] args) { 
    reverseDigits(98198187); 
} 

/* Recursive function to reverse digits of num */ 
public static void reverseDigits(long number) { 
    if (number < 10) { 
     System.out.println(number); 
     return; 
    } 
    else { 
     System.out.println(number % 10); 
     reverseDigits(number/10); 
    } 
} 

Answer 2

public static int reversDigits(int num) { 
    if(num < 1) { 
     return 0; 
    } 

    int temp = num % 10; 
    num = (num - temp)/10; 
    System.out.println(temp); 

    return reversDigits(num); 
} 

這將打印數字，並以相反次序的時間。您不需要在主要方法中使用System.out。

Answer 3

我發現我不得不挑出最高的數字（在左邊），並朝着最右邊的數字工作。我無法得到一個遞歸的工作從右向左工作。

public static int reverseItRecursive(int number) 
{ 
    if (number == 0) 
     return 0; 

    int n = number; 
    int pow = 1; 

    while (n >= 10) 
    { 
     n = n/10; 
     pow = pow * 10; 
    } 
    return (n + reverseItRecursive(number - n*pow)*10); 
} 

Answer 4

這應該工作

int rev = 0; 
int reverse(int num) 
{ 
    if (num < 10) { 
     rev = rev*10 + num; 
    } 
    else { 
     rev = rev*10 + (num % 10); 
     num = reverse(num/10); 

    } 
    return rev; 
} 

Answer 5

這並不完全回答這個問題，但它實際上計算整個顛倒數，而不是打印數字，因爲他們計算。結果是一個int數字顛倒的順序。更強大的比一個打印出號碼之一的字符串形式：

public class Reverse { 
    public static void main(String[] args) { 
     // input int parameter 
     int param = Integer.parseInt(args[0]); 
     System.out.println(reverse(param)); 
    } 

    public static int reverse(int input) { 
     return reverse(input, 0); 
    } 

    private static int reverse(int original, int reversed) { 
     // get the rightmost original digit and remove it 
     int rightmost = original % 10; 
     original -= rightmost; 
     original /= 10; 

     // add rightmost original digit to left of reversed 
     reversed += rightmost * Math.pow(10, numDigits(original)); 

     return (original == 0) 
      ? reversed 
      : reverse(original, reversed); 
    } 

    public static int numDigits(int number) { 
     number = Math.abs(number); 

     if (number >= 10) { 
      return 1 + numDigits(number /= 10); 
     } else if (number > 0) { 
      return 1; 
     } else { 
      return 0; 
     } 
    } 
} 

Answer 6

public static void reversDigits(long number) { 
    System.out.println(number % 10); 
    if (number >= 10) { 
     reversDigits(number/10); 
    } 
} 

這是最短/最簡單到目前爲止版）

Answer 7

我來找一個更優雅的版本比我，但也許這隻需要一點點雜亂的算法。煤礦也將返回實際整數值是我同意的，是不是隻打印字符串有用得多： 礦：

public static int reverse(int n){ 
     if(n<10)return n; 
     return n%10*(int)Math.pow(10,(int)Math.log10((double)n)) + reverse(n/10); 
    } 

所以這個返回的最後一位數字，乘以10 ^電流功率+（遞歸調用）

Answer 8

在這裏你去：

static String reverseDigits(int n) 
{ 
    String N = ""; 
    if (n== 0) 
     return N; 
    else 
    { 
     N += n%10; 
     return N + reverseDigits(n/= 10); 
    }    
} 

當然，這是返回的字符串。

如果你想把它當作INT所有你需要做的就是使用Integer.parseInt()

Answer 9

//Reverse a number using recursion by bibhu.rank 
public class Rev_num { 
    public static int revnum(int x){ 
     int temp1=x,temp2=1; 
     if(x<10){ 
      return x; 
     } 
     while(temp1>=10){ 
      temp2*=10; 
      temp1/=10; 
     } 
     if(((x%temp2) < (temp2/10))&& x%temp2!=0){ 
      int c=temp2; 
      while(c> x%temp2){ 
       c/=10; 
      } 
      c=temp2/c; 
      temp2=x%temp2; 
      return((temp1)+(c*revnum(temp2))); 
     } 
     temp2=x%temp2; 

     return (temp1+(10*revnum(temp2))); 

    } 

    public static void main(String[] args) { 
     // TODO Auto-generated method stub 
     System.out.println("Enter a number"); 
     Scanner y=new Scanner(System.in); 
     System.out.println(revnum(y.nextInt())); 
     y.close(); 


    } 

} 

Answer 10

public class reverseIntRec{ 
     public static void main(String args[]) { 
      System.out.println(reverse(91)); 
     } 
     public static int reverse(int x) { 
     String strX = String.valueOf(x); 
      if (Math.abs(x) < 10) 
       return x; 
      else 
      return x % 10 * ((int) Math.pow(10, strX.length()-1)) + reverse(x/10); 
     } 
    } 

這裏是我的回答回報整數解析它。我將x轉換爲字符串以查看您應該乘以多少個0s。

例如：反向（91）返回1 * 10 +反向（9），並返回10 + 9 = 19。

Answer 11

//Try out this, recursion with singe variable using Math class. 
public static void main(String[] args) { 
    // Let the number be 139 
    int n=139; 
    System.out.println("reverse is "+rev(n)); 
} 
static int rev(int n){ 
    if (n==0)return 0; 
    else { 
     return n%10*(int) Math.pow(10,(double) (int)Math.log10(n))+rev(n/10); 
    }  
} 

Answer 12

此方法扭轉整數，並返回結果，而無需使用任何字符串函數，數學，或通過僅印刷

public class ReverseNumber { 

    public static void main (String[] args) { 
     ReverseNumber rNumber = new ReverseNumber(); 
     System.out.println(rNumber.reverseRecursive(1234,0)); // pass zero to initialize the reverse number 
    } 
    public int reverseRecursive(int n, int reverse) {// n - the number to reverse 
     // System.out.println(n); 

     if (n != 0){ 
      reverse = reverse * 10; 
      reverse = reverse + n %10; 
      n = n/10; 
     } else { 
       return reverse; 
     } 
    return reverseRecursive(n,reverse); 
}} 

Answer 13

public void reverse(int num){ 
     System.out.print(num %10); 
     if(num/10 == 0){ 
       return; 
     } 
     reverse(num /10); 
     return; 
    }