Question

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

例如，largestLoser（6712,1234）返回1212 例如，largestLoser（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

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是a除以10时的余数：换句话说，它是a的最低有效数字（＆＃34;的地点＆＃34;）

a = a / 10执行整数除法，因此它将a除以10并忽略任何分数。因此，1234变为123，并且在下一次迭代123变为12等等。换句话说，它会丢弃＆＃34;的地点＆＃34;。< / p>

所以第一次通过循环，你看看＆＃34;那些＆＃34;从a和b，找到最小的一个，并将其添加到result。然后你放弃＆＃34;那些＆＃34;来自a和b。那么过去是什么＆＃34;数十＆＃34;现在是＆＃34;那些＆＃34;。第二次循环，你得到最小的＆＃34;＆＃34;再次：但这本来是最小的＆＃34;数十＆＃34;。您想将其添加到result，但您需要乘以10。这是multiplier：每次循环时，乘数乘以10。所以每次，你得到最小的＆＃34;那些＆＃34;，乘以正确的东西，添加到结果，然后放弃＆＃34;那些＆＃34;＆＃34;来自a和b。

只是为了好玩，这里的实现只需要一个声明（如果你用'＃34;四位数＆＃34;任何正数位数）都可以使用。你可以请你的导师解释一下;）。

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

Answer 2

这是简单的答案

nasm

Answer 3

使用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 4

也许它是愚蠢的但是尝试利用String（.charAt（int index））和Integer（.parseInt（String value））方法，也许这个例子可以帮助你：

distance,food

比较整数并从给定整数的数字创建可能的最小整数

4 个答案: