比较整数并从给定整数的位数中创建尽可能小的整数

Question

我需要编写以下方法：接受两个整数参数并返回一个整数。如果任一整数不是4位数，则该方法应返回较小的整数。否则，该方法应该返回一个由千位、百位、十位和一位中的最小数字组成的四位整数。我们不能将整数转换成字符串，也不能使用列表或数组。

例如大输家（6712,1234）返回1212例如大输家（19,8918）返回19

我是这样开始写的：

public static int biggestLoser(int a, int b){
    if(a<9999 || b<9999){
        if(a<b)
            return a;
        else if(b<a)
            return b;
    }
    int at=a/1000;
    int ah=a%1000/100;
    int an=a%100/10;
    int ae=a%10;
    int bt=b/1000;
    int bh=b%1000/100;
    int bn=b%100/10;
    int be=a%10;
    if(at<bt && ah<bh && an<bn && ae<be)
        return at*1000+ah*100+an*10+ae;
    else if(at<bt && ah<bh && an<bn && be<ae)
        return at*1000+ah*100+an*10+be;
    else if(at<bt&& ah<bh && bn<an && ae<be)
    else return at*1000+ah*100+bn*10+ae;

然而，看起来我将不得不编写太多的if语句，有没有一种更短的方法来编写代码？

Answer 1

使用String和StringBuilder

public class Test
{

 public static void main(String []args)
 {
    System.out.println(biggestLooser(6712,1234));
 }
 public static int biggestLooser(int _a, int _b)
 {
     String a = String.valueOf(_a);
     String b = String.valueOf(_b);
     StringBuilder c = new StringBuilder();

     if(a.length() < b.length()) return Integer.parseInt(a);
     else if(b.length() < a.length()) return Integer.parseInt(b);
     else if(a.length() >= 4 && b.length() >= 4)
     {
        for(int i = 4; i > 0; i--)
        {
            char ch = '\0';
            if(a.charAt(a.length() - i) < b.charAt(b.length() - i))
                ch = a.charAt(a.length() - i);
            else ch = b.charAt(b.length() - i);
            c.append(ch);
        }
        return Integer.parseInt(c.toString());
     }
     else return -1;
 }
}
//ouput: 1212

Answer 2

也许这很愚蠢，但尝试利用String（.charAt（int-index））和Integer（.parseInt（String-value））方法，也许这个示例可以帮助您：

    int x=145;
    int y=826;
    //to know which number have the biggest tens 
    String a=x+"";
    String b=y+"";

    if(Integer.parseInt(a.charAt(1)+"")>Integer.parseInt(b.charAt(1)+""))
    {
        System.out.println("The number which have the biggest tens is "+a);
    }
    else
    {
        System.out.println("The number which have the biggest tens is "+b);
    }

Answer 3

public static int biggestLoser(int a, int b) {
    if (a < 1000 || a >= 10000 || b < 1000 || b >= 10000) {
        return Math.min(a, b);
    } else {
        // both a and b are four digits
        int result = 0 ;
        int multiplier = 1 ;

        for (int digit = 0; digit < 4; digit++) {
            int nextDigit = Math.min(a % 10, b % 10);
            result = result + nextDigit * multiplier  ;
            multiplier = multiplier * 10 ;
            a = a / 10 ;
            b = b / 10 ;
        }

        return result ;
    }
}

这是怎么回事<当a除以10时，code>a%10是余数：换句话说，它是a的最低有效位（“一位”）。

a=a/10执行整数除法，因此它将a除以10，并忽略任何分数。因此，1234变成了123，在下一次迭代中，123变成了12，等等。换句话说，它丢弃了“一个位置”。

因此，在第一次循环中，您查看a和b中的“一”，找到最小的一个，并将其添加到结果中。然后从a和b中删除“一”。所以过去的“十”现在变成了“一”。第二次循环时，你又得到了最小的“一”：但这本来是最小的“十”。您想将其添加到结果，但需要乘以10。这是乘数：每次通过循环，乘数都会乘以10。所以每次，你都会得到最小的“一”，乘以正确的东西，加上结果，然后从a和b中删除“一”。

只是为了好玩，这里有一个只需要一个语句的实现（如果您将“四位数”替换为任何正数位数，它就可以工作）。你可以让你的老师解释一下；）。

public static final int NUM_DIGITS = 4 ;
public static final int MAX = (int) Math.pow(10, NUM_DIGITS) ;
public static final int MIN = MAX / 10 ;


public static int biggestLoser(int a, int b) {
    return (a < MIN || a >= MAX || b < MIN || b >= MAX) ? Math.min(a, b) :
        IntStream.iterate(1, multiplier -> multiplier * 10).limit(NUM_DIGITS)
            .map(multiplier -> Math.min((a / multiplier) % 10, (b / multiplier) % 10) * multiplier )
            .sum();
}