加扰int的每个数字并打印出最大可能的整数

问题描述

我被困在这里。我只是继续制作新的字符串并将其转换为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);
            
            }
            }
    } ```

解决方法

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,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

,

在这种情况下，无需使用转换为String的方法，您可以通过将余数乘以10，然后将输入数字除以10并在数字> 0时重复输入，来从输入数字中获取数字。 >

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

要获得最大数量的这些数字，您应该对它们进行排序（例如Arrays.sort或Collections.sort这样的标准功能就可以了），然后从最低数字“重新组合”最大数字将其乘以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));
}

,

另一种选择是计算您拥有多少个0、1、2，...，9个值，然后将它们重新组合成一个数字，知道这些数字将始终按降序排列（9、8、7， ...，0）。最简单的方法是使用数组。由于这是一项家庭作业，所以比较困难的方法（不按照您在注释中添加的要求使用数组）是每位使用可变计数器。

public class so64125767 {
    public static int biggestBuckets(int a) {
        int[] buckets = { 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
    }
}

如果您将这些结果与其他建议（使用字符串或集合）一起进行基准测试，我也会打赌，您会发现此方法的缩放比例最佳（想象一下，如果您接受的数字超出int的大小）。 / p>

,

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