【问题标题】:Recursion - digits in reverse order递归 - 数字倒序
【发布时间】:2013-05-06 05:29:35
【问题描述】:

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

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

【问题讨论】:

标签: java recursion


【解决方案1】:

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

【讨论】:

  • 我确实喜欢创建反向数字的想法。但是,您可以放弃 numDigits 并通过将自身乘以 10 并添加新数字来增加数字。 reversed = 10*reversed + 最右边;
【解决方案2】:
//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);
    }    
}

【讨论】:

    【解决方案3】:
    public static void reversDigits(long number) {
        System.out.println(number % 10);
        if (number >= 10) {
            reversDigits(number / 10);
        }
    }
    

    这是迄今为止最短/最简单的版本;)

    【讨论】:

    • 这段代码不正确,例如测试用例10只会显示数字0。
    • 我很抱歉。你说的对。这个想法是打印数字的最后一位数字,然后如果它的位置值高于执行递归调用的位置值。我只是犯了一个小逻辑错误,所以很平常:)
    【解决方案4】:

    这是两行代码中非常最短/最简单的方式:

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

    【讨论】:

    • 这行代码通过 reverseNumber(1234) 给出输出:43211
    • @RamBhandari:通过传递 reverseNumber(1234),我得到了正确的输出为 4321。
    • 对不起,我写了额外的打印命令,让我输出上述代码按预期工作。谢谢
    【解决方案5】:
    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);
        }
    }
    

    【讨论】:

    • 这给出了不准确的结果。
    • 抱歉,我没有为此编写测试。特别是什么论据?
    • 对我来说似乎是正确的。我想知道“不准确的结果”是什么意思。
    • renz 和 VKSingla 代码都有效,我也看不出renz 代码有什么问题……谢谢你们的帮助。非常感谢
    【解决方案6】:
     public void reverse(int num){
            System.out.print(num %10);
            if(num / 10 == 0){
                  return;
            }
            reverse(num /10);
             return;
        }
    

    【讨论】:

      【解决方案7】:

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

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

      【讨论】:

        【解决方案8】:
        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);
        }
        

        这将以相反的顺序一次打印一个数字。您不需要在 main 方法中使用 System.out。

        【讨论】:

          【解决方案9】:

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

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

          【讨论】:

            【解决方案10】:

            这应该可行

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

            【讨论】:

              【解决方案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^当前幂 +(递归调用)

              【讨论】:

                【解决方案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() 解析它

                【讨论】:

                  【解决方案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();
                  
                  
                      }
                  
                  }
                  

                  【讨论】:

                    【解决方案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。

                    【讨论】:

                      【解决方案15】:

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

                      123000 次打印:

                      0

                      0

                      0

                      3

                      2

                      1

                      这里是代码,没有while,没有字符串,也没有数学库:

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

                      【讨论】:

                        猜你喜欢
                        • 1970-01-01
                        • 1970-01-01
                        • 1970-01-01
                        • 1970-01-01
                        • 2014-03-05
                        • 2013-07-16
                        • 2018-12-30
                        • 2023-03-02
                        相关资源
                        最近更新 更多