打乱 int a 的每个数字并打印出可能的最大整数

Question

我被困在这里了。我是继续创建新字符串并将它们转换为 int 还是我们有更快更好的方法？

public void biggest(int a){
       int random;
       String aS = String.valueOf(a);
       int ah=9;
       if (a<10)
             System.out.println(a);
       for(int i= 0;i<aS.length();i++){
            String firstNum = aS.substring(i,i+1);
            for (int j = ah; j > Integer.parseInt(firstNum); j--){
                System.out.println(ah);
            
            }
            }
    } ```

Answer 1

在这种情况下不需要使用转换为字符串，您可以通过对输入的数字取模 10 的余数，然后将输入的数字除以 10 并在数字 > 0 时重复它来从输入的数字中获取数字。

每个数字都应存储在数组或列表中。

要获得这些数字中最大的数字，您只需对它们进行排序（Arrays.sort 或 Collections.sort 等标准工具就可以了），然后“re-assemble”最大的数字从最低位开始乘以 1、10、100 等，然后求和。

所以，简单的实现可以如下：

public static int biggestPlain(int a) {
    List<Integer> digits = new ArrayList<>();
    while (a > 0) {
        digits.add(a % 10);
        a /= 10;
    }
    Collections.sort(digits);
    int p = 1;
    int num = 0;
    for (int digit : digits) {
        num += p * digit;
        p *= 10;
    }
    return num;
}

此外，可以使用 Stream API 和 lambda 并应用相同的方法来实现此任务：

public static int biggestStream(int a) {

    AtomicInteger p = new AtomicInteger(1); // accumulate powers of 10

    return IntStream.iterate(a, n -> n > 0, n -> n / 10) // divide input number by 10 while it > 0
                    .map(i -> (i % 10)) // get the digit
                    .sorted() // sort (the lower digits first)
                    .map(i -> p.getAndUpdate((x) -> x * 10) * i) // same as p * digit above
                    .sum(); // get the result number
}

更新
遍历从“9”到“0”的数字，并检查它们是否在输入数字的字符串表示中可用。

String基于解决方案：

public static void biggest(int a) {

    String aS = String.valueOf(a);
    if (a < 10) {
        System.out.println(a);
    }
    String num = "";
    int count = 0;
    out: for (char i = '9'; i >= '0'; i--) {
        for (int j = 0; j < aS.length(); j++) {
            char digit = aS.charAt(j);
            if (digit == i) {
                num += digit;
                if (++count == aS.length()) {
                    break out;
                }
            }
        }
    }
    System.out.println(num + " / " + Integer.parseInt(num));
}

Answer 2

public static int biggest(int num) {
    if (num == 0)
        return 0;

    int res = 0;

    if (num > 0) {
        for (int i = 9; i >= 0; i--)
            res = update(res, i, num);
    } else {
        for (int i = 0; i <= 9; i++)
            res = update(res, i, num);

        res *= -1;
    }

    return res;
}

private static int update(int res, int i, int n) {
    n = Math.abs(n);

    while (n > 0) {
        if (n % 10 == i)
            res = res * 10 + i;
        n /= 10;
    }

    return res;
}

输出：

System.out.println(biggest(12341234));  // 44332211
System.out.println(biggest(-12341234)); // -11223344

Answer 3

    String useMe = Integer.toString(argumentOne);
    int rMe = argumentOne;
 
    int x = 0;
    while (x != 1000) {
      int i = 0;
      String returnMe = "";
      String inUse = useMe;
      while (i != useMe.length()) {
        Random random = new Random();
        int index = random.nextInt(inUse.length());
        returnMe = returnMe + inUse.charAt(index);
        inUse = inUse.substring(0, index) + inUse.substring(index + 1);
        i++;
      }
      if (Integer.parseInt(returnMe) > rMe) {
        rMe = Integer.parseInt(returnMe);
      }
      x++;
    }
 
    System.out.print( rMe );
 
  }

Answer 4

另一种选择是计算你有多少个 0、1、2、...、9 个值，然后 assemble 将它们重新组合成一个数字，因为数字将始终按降序排列（ 9、8、7、...、0）。做到这一点的简单方法是使用数组。由于这是一项家庭作业，困难的方法（根据您在评论中添加的要求不使用数组）是使用每个数字的可变计数器。

public class so64125767 {
    public static int biggestBuckets(int a) {
        int[] buckets = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

        while (a > 0) {
            buckets[a % 10]++;
            a /= 10;
        }

        int num = 0;
        for (int i = 9; i >= 0; i--) {
            for (int j = 0; j < buckets[i]; j++) {
                num *= 10;
                num += i;
            }
        }

        return num;
    }

    public static int biggestBucketsVar(int a) {
        int zero = 0;
        int one = 0;
        int two = 0;
        int three = 0;
        int four = 0;
        int five = 0;
        int six = 0;
        int seven = 0;
        int eight = 0;
        int nine = 0;

        while (a > 0) {
            switch (a % 10) {
            case 0:
                zero++;
                break;
            case 1:
                one++;
                break;
            case 2:
                two++;
                break;
            case 3:
                three++;
                break;
            case 4:
                four++;
                break;
            case 5:
                five++;
                break;
            case 6:
                six++;
                break;
            case 7:
                seven++;
                break;
            case 8:
                eight++;
                break;
            case 9:
                nine++;
                break;
            }
            a /= 10;
        }

        int num = 0;
        
        for (int j = 0; j < nine; j++) {
            num *= 10;
            num += 9;
        }
        
        for (int j = 0; j < eight; j++) {
            num *= 10;
            num += 8;
        }

        for (int j = 0; j < seven; j++) {
            num *= 10;
            num += 7;
        }

        for (int j = 0; j < six; j++) {
            num *= 10;
            num += 6;
        }

        for (int j = 0; j < five; j++) {
            num *= 10;
            num += 5;
        }

        for (int j = 0; j < four; j++) {
            num *= 10;
            num += 4;
        }

        for (int j = 0; j < three; j++) {
            num *= 10;
            num += 3;
        }

        for (int j = 0; j < two; j++) {
            num *= 10;
            num += 2;
        }

        for (int j = 0; j < one; j++) {
            num *= 10;
            num += 1;
        }

        for (int j = 0; j < zero; j++) {
            num *= 10;
            // num += 0;
        }

        return num;
    }

    public static void main(String[] args) {
        System.out.println(biggestBuckets(237428379));
        System.out.println(biggestBucketsVar(237428379));
        -- 987743322
    }
}

我敢打赌，如果您将这些结果与其他建议（使用 String 或 Collections）一起进行基准测试，您会发现此方法的缩放比例最好（想象一下，如果您接受的数字超出了 int 的大小） .

打乱 int a 的每个数字并打印出可能的最大整数

Scramble each digit of the int a and print out the biggest possible integer

java

random

shuffle