递归 - 以相反顺序的数字

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