0

我应该使用递归方法垂直打印出数字的数字。

例如，如果我输入 13749，输出将是：

1
3
7
4
9

我应该如何处理这个问题？它还指出我应该使用 if/else 方法来检查基本情况。我刚开始学习 java，但我并不擅长它:(

import java.util.Scanner;

public class test2 {
  public static void main (String [] args){
    Scanner sc = new Scanner(System.in);
    System.out.print("Enter a positive integer: ");
    int n = sc.nextInt();
    System.out.println();
    System.out.println(numbers(n));  

  } 

public static int numbers(int n){
  int sum;
  if (n == 0) {
    sum = 1;
    } else {

     System.out.println(n%10);
     sum = numbers(n / 10) + (n % 10);


    }
  return sum;
  }      
}
4

7 回答 7

2

这是我在 C++ 中的代码

只需为 Java 修改它。您需要在调用函数后显示数字，以首先显示最后一个...根据 s.ts 的答案

void recursive(int n) {
    if (n < 10)
        cout << n << endl;
    else
    {
        recursive(n / 10);
        cout << n % 10 << endl;
    }
}
于 2014-02-24T16:03:02.417 回答
2

今天面试被问到这个问题！

 public class Sandbox {
   static void prints(int d) {
        int rem = d % 10;
        if (d == 0) {
            return;
        } else {
            prints(d / 10);
        }
        System.out.println(rem);
    }

    public static void main(String[] args) {
        prints(13749);
    }
}

输出：

1
3
7
4
9
于 2014-03-19T00:59:34.913 回答
1 
class PrintDigits {

   public static void main(String[] args) {
     String originalNumber, reverse = "";

     // Creating an Scanner object
     Scanner in = new Scanner(System.in);

     System.out.println("Enter a number:");
     // Reading an input 
     originalNumber = in.nextLine();

     // Calculating a length
     int length = originalNumber.length();

     // Reverse a given number
     for ( int i = length - 1 ; i >= 0 ; i-- )
        reverse = reverse + originalNumber.charAt(i);
     //System.out.println("Reverse number: "+reverse);
     digits(Integer.parseInt(reverse));
   }

   /* digits of num */
   public static void digits(int number) {
       if (number == 0)
          System.out.println("");
       else {
          int mode=10;
          System.out.println(+number%mode);
          digits(number/mode);
       }
   }
}
于 2013-09-10T14:15:36.467 回答
1

你问如何处理这个问题，所以我给你一个提示：建立堆栈然后开始打印输出会容易得多。它也不涉及操作字符串，这在我的书中是一个很大的优点。操作顺序为：

  1. 检查基本情况，如果是则返回
  2. 递归调用
  3. 打印

这样，当您到达基本情况时，您将开始从调用的尾部到头部打印：

recursive call 1
    recursive call 2
        recursive call 3
            .... reached base case
        print 3
    print 2
print 1

这样，您可以简单地打印数字 % 10 并使用数字 / 10 进行递归调用，基本情况是数字为 0 时。

于 2013-09-10T13:59:41.987 回答
0

尝试这个

public class Digits {

    public static void main(String[] args) {
        printDigits(13749);
    }

    private static void printDigits(Integer number) {
        int[] m = new int[number.toString().toCharArray().length];

        digits(number, 0, m, 0);

        for (int i= m.length - 1; i>=0; i--) {
            System.out.println(m[i]);
        }
    }

    public static int digits(int number, int reversenumber, int[] m, int i) {

        if (number <= 0) {
            return reversenumber;
        }

        m[i] = (number % 10);
        reversenumber = reversenumber * 10 + (number % 10);
        return digits(number/10, reversenumber, m, ++i);
    }

}
于 2013-09-10T14:30:21.050 回答
0 
If number consists of more than one digit print ( n / 10 )

print ( n % 10 )

如果您希望它们以其他顺序打印

print ( n % 10 )

If number consists of more than one digit print ( n / 10 )
于 2013-09-10T13:45:39.653 回答
0

Python 示例

def printNoVertically(number):
    if number <  9:
      print(number)
      return
    else:
        printNoVertically(number/10)
        print(number % 10)
于 2019-06-16T09:21:52.020 回答