Java 一种递归方法，它以一个大于或等于第一位且小于最后一位的数字打印所有数字

问题：

public static void print(int n) {
     print(n,n%10);
}
private static void print(int n,int lastDigit) {
    if(n==0)
        return;
    if(n%10<lastDigit)
        System.out.println(n%10);
    print(n/10,lastDigit);
}

我正在尝试编写一个递归方法，它以大于或等于第一个数字、小于最后一个数字的数字打印所有数字。 我完成了编写一个递归方法的工作，该方法可以打印出所有大于或小于最后一个数字的数字。我不知道如何检查这个数字是否比第一个数字更大

示例：

public static void print(int n) {
     print(n,n%10);
}
private static void print(int n,int lastDigit) {
    if(n==0)
        return;
    if(n%10<lastDigit)
        System.out.println(n%10);
    print(n/10,lastDigit);
}

对于打印（325648），它将打印5、6、4

对于打印（237），它将打印3

对于打印（925648），它不会打印任何数字

这是我的代码：

public static void print(int n) {
     print(n,n%10);
}
private static void print(int n,int lastDigit) {
    if(n==0)
        return;
    if(n%10<lastDigit)
        System.out.println(n%10);
    print(n/10,lastDigit);
}

公共静态无效打印（int n）{
打印（n，n%10）；
}
私有静态无效打印（整数n，整数lastDigit）{
如果（n==0）
返回；
如果（n%10将第一个数字作为参数传递

public static int firstDigit(int n) {
    return (int) (n / Math.pow(10, Math.floor(Math.log10(n))));
}

public static void print(int n) {
     print(n, firstDigit(n), n%10);
}

private static void print(int n, int firstDigit, int lastDigit) {
    if(n == 0)
        return;
    if(n % 10 < lastDigit && n % 10 > firstDigit)
        System.out.println(n%10);

    print(n/10, lastDigit);
}

publicstaticintfirstdigit（intn）{
如果（n==0）{
返回0；
}
如果（n！=0&&n/10==0）{
返回n；
}
返回第一位数字（n/10）；
}
公共静态无效打印（int n）{
打印（n，第一位数字（n），n%10）；
}
专用静态无效打印（整数n、整数第一位数、整数最后位数）{
如果（n==0）
返回；
如果（n%10firstDigit）
系统输出打印项次（n%10）；
打印（n/10，第一位数字，最后一位数字）；
}
这里的想法是通过除以10进行递归，直到数字减少到其第一个数字。在所有递归的返回中，您将第一个数字作为返回值，并且非常容易进行比较

private static void print( int n ){
    print( n/10, n%10 );
}

private static int print( int n, int ld ){
    if( n < 10 ) return n;
    int digit = n % 10;
    int first = print( n/10, ld );
    if( digit < ld && digit > first )
        System.out.println( digit );
    return first;
}

私有静态无效打印（int n）{
打印（n/10，n%10）；
}
专用静态整型打印（整型n，整型ld）{
如果（n<10）返回n；
整数位数=n%10；
int first=打印（n/10，ld）；
如果（数字第一位）
系统输出打印项次（位数）；
先返回；
}
非常简单，几乎就是您的代码

public static void print(int n) {
         int first = Integer.parseInt(Integer.toString(n).substring(0, 1));
     print(n, first, n%10);
}
private static void print(int n, int first, int lastDigit) {
    if(n==0)
        return;

    if(n%10<lastDigit && n%10 > first)
        System.out.println(n%10);
    print(n/10, first, lastDigit);
}

公共静态无效打印（int n）{
int first=Integer.parseInt（Integer.toString（n）.substring（0，1））；
打印（n，第一，n%10）；
}
私有静态无效打印（整数n，整数第一，整数最后一位）{
如果（n==0）
返回；
如果（n%10优先）
系统输出打印项次（n%10）；
打印（n/10，第一位，最后一位）；
}
另一种解决方案是将要检查的数字表示为字符串：

public static void main(String[] args) throws IOException {

    int n = 325648;
    print(n);
}

private static void print(int n) {

    String intAsString = String.valueOf(n);
    int numberLength = intAsString.length();
    if( numberLength < 3) {
        System.out.println("Can't do with ints shorted than 3 digits");
    }

    int firstDigit = Integer.valueOf(intAsString.substring(0,1));
    int lastDigit = Integer.valueOf(intAsString.substring(numberLength-1,numberLength));
    print(intAsString, 0, firstDigit, lastDigit  );
}

private static void print(String intAsString,int index, int firstDigit, int lastDigit) {

    int digit = Integer.valueOf(intAsString.substring(index,index+1));

    if((digit > firstDigit) && (digit < lastDigit)) {
        System.out.print(digit);
    }

    if((index +1) < intAsString.length()) {
        print(intAsString,++index, firstDigit, lastDigit);
    }
}

publicstaticvoidmain（字符串[]args）引发IOException{
int n=325648；
打印（n）；
}
专用静态无效打印（int n）{
字符串intAsString=String.valueOf（n）；
int numberLength=intassString.length（）；
如果（数字长度<3）{
System.out.println（“不能处理短于3位的整数”）；
}
int firstDigit=Integer.valueOf（intAsString.substring（0,1））；
int lastDigit=整数.valueOf（intAsString.substring（numberLength-1，numberLength））；
打印（凹版字符串，0，第一位数字，最后一位数字）；
}
私有静态无效打印（字符串intAsString、int index、int firstDigit、int lastDigit）{
int digit=Integer.valueOf（intAsString.substring（index，index+1））；
如果（（位数>第一位数）和（&（位数<最后位数））{
系统输出打印（数字）；
}
如果（（索引+1）
我刚刚尝试了字符串和数组比较，我使用字符串是因为我希望代码有点灵活

public class Data {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        print(3245);
    }

    static void print(int n){
        String s = n+"";
        String[] s1 = s.split("");

        printF(Integer.valueOf(s1[0]),Integer.valueOf(s1[s1.length-1]),s1,0);
    }

    static void printF(int lst,int end, String[] ar,int index){

        if(Integer.valueOf(ar[index])>lst && Integer.valueOf(ar[index])<end){
            System.out.println(ar[index]);
        }

        if(index < ar.length-1){
            index = index+1;
            Data.printF(lst,end, ar,index);
        }

    }
}

您可以使用公式-dig=Math.floor（Math.log10（n））+1找出位数。然后用dig-1除以第一个位数。我认为这个函数使用循环。请给出一个或两个例子以更好地理解no。它是一个对数函数。它可以被认为与使用递归计算位数相同。你提到的3个例子，我认为第二个例子的结果是错误的Math.floor（Math.log10（n）函数使用loops.Math.floor不（）并且Math.log10是本机的。我不能说它不是，但是现在你可以使用递归找到第一个数字或数字的数量，然后用dig-1除以它。@BB-8但是StrictMath类包含Math.log10方法，我无法理解给出了什么there@BrijRajKishore数学地板（Math.log10（n））基本上计算数字n的长度。很好的解决方案，但我只能对该数字运行一次递归。我的错误是，我会更改它。@laune最后还有一个}。@sara谢谢。复制粘贴…修复。很好的解决方案。+1does Integer.parseInt（Integer.toString（n）。substring（0，1））是否包含循环？是的。对于子字符串，您将从索引i到j。这是一个示例，很好的解决方案，但我不能使用循环作为此方法的要求。您可以检查上面的链接，没有提到的地方，该子字符串使用任何循环公共字符串子字符串（int beginIndex，int endIndex）{//check boundary返回新字符串（offset+beginIndex，endIndex-beginIndex，value）；}很好的解决方案！！但完成这样的任务不是太难吗？这里肯定有一些较短的解决方案。这是一个替代方案，不一定是最好的。使用所有函数或不使用循环（s.split，Integer.valueOf，）？Split将在每个输入中只执行一次，其余时间的操作将在递归函数上进行。当我们转到递归时，我们将使用are Integer.valueOf进行比较，而不是任何物理或变量赋值。
Input: 3245
output: 4

Input:1234567
output:23456

Input:58697
output:8