2

我需要实现一个递归方法 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;
        }
    }
}

我觉得我只缺少一行代码，但不确定我需要做什么来修复它。

4

15 回答 15

8 
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);
    }
}
于 2013-05-06T05:38:17.750 回答
3

这并不能完全回答这个问题，但它实际上计算了整个反转的数字，而不是在计算数字时打印它们。结果是一个 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;
        }
    }
}
于 2014-03-14T02:09:44.487 回答
3 
public static void reversDigits(long number) {
    System.out.println(number % 10);
    if (number >= 10) {
        reversDigits(number / 10);
    }
}

这是迄今为止最短/最简单的版本；）

于 2014-11-24T15:00:40.617 回答
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在你的主要方法中做。

于 2013-05-06T05:40:26.913 回答
1

这应该工作

 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;
}
于 2014-02-25T14:33:38.173 回答
1

我发现我必须选择最高的数字（左侧）并朝着最右边的数字努力。我无法让递归的工作从右到左。

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);
}
于 2013-10-08T15:28:36.377 回答
1

这是两行代码中最短/最简单的方法：

    public static int reverseNumber(int n) 
    {
        System.out.println(n % 10);
        return (n/10 > 0) ? reverseNumber(n/10) : n;
    }
于 2019-01-05T18:27:32.297 回答
1 
//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);
    }    
}
于 2017-03-16T12:25:00.680 回答
1 
 public void reverse(int num){
        System.out.print(num %10);
        if(num / 10 == 0){
              return;
        }
        reverse(num /10);
         return;
    }
于 2018-02-08T08:49:54.650 回答
1

此方法反转整数并返回结果，而不使用任何字符串函数、数学或仅打印

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);
}}
于 2017-03-29T05:09:12.190 回答
0

我来找一个比我的更优雅的版本，但也许这只需要一些混乱的算法。我的还返回实际的整数值，我同意这比仅打印字符串有用得多：我的：

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^current power + (recursive call)

于 2015-02-15T02:16:13.990 回答
0 
//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();


    }

}
于 2016-08-24T19:23:55.930 回答
0

干得好 ：

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

这当然是作为字符串返回的。

如果你想要它作为 int 你所要做的就是使用它来解析它Integer.parseInt()

于 2016-03-27T20:11:17.453 回答
0

相对简单，因为您需要每行打印一个数字。您还声明您打印其数字，这意味着仍将显示前导零。我们的测试用例

123000 次打印：

0

0

0

3

2

1

这是代码，没有时间，没有字符串，也没有数学库：

    private void printIntegerDigitsReversed(int i) {
        if (i / 10== 0 ){
            System.out.println(i);
        }
        else{
            printIntegerDigitsReversed(i%10);
            printIntegerDigitsReversed(i/10);
        }
    }
于 2019-06-20T17:52:45.203 回答
0 
   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

例如： reverse(91) 返回 1 * 10 + reverse (9)，即返回 10 + 9 = 19。

于 2017-01-17T00:33:07.367 回答