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

这并不完全回答这个问题，但实际上计算整个反转数而不是在计算数字时打印数字。结果是一个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 3

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

到目前为止这是最短/最简单的版本;）

Answer 4

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 5

我发现我必须摘掉最高位（左边）并朝最右边的数字方向前进。我无法让一个递归的工作从右到左工作。

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 6

这应该有效

 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 7

//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 8

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

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 9

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

Answer 10

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

    public static int reverseNumber(int n) 
    {
        System.out.println(n % 10);
        return (n/10 > 0) ? reverseNumber(n/10) : n;
    }

Answer 11

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

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 12

你走了：

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 13

//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 14

   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.

Answer 15

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

123000张照片：

0

3

2

1

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

    private void printIntegerDigitsReversed(int i) {
        if (i / 10== 0 ){
            System.out.println(i);
        }
        else{
            printIntegerDigitsReversed(i%10);
            printIntegerDigitsReversed(i/10);
        }
    }

递归 - 相反顺序的数字

15 个答案: