给定一个整数N。java中大于N的最小整数是什么

Question

我试着写一个代码，它接受一个介于1和1_000_000之间的整数，并返回一个比相同数字的整数大的最小整数，如果它不存在，则打印0。

举个例子

输入：156

输出165

输入330

输出0

输入27711

输出71127

我的问题是，下面的代码没有为其他输入返回正确的输出。

例如，在输入4231中，输出应该是4312。

我很难找到为每个输入返回正确输出的最佳算法。

TNX提前

import java.util.Scanner;

public class Test4 {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String x = sc.nextLine();
    char[] chars = new char[x.length()];
    char[] oldChars = new char[x.length()];


    char temp;
    for (int i = 0; i < x.length(); i++) {
        chars[i] = x.charAt(i);
        oldChars[i] = chars[i];
    }


    if (x.length() > 3){
        for (int j = 0; j < x.length(); j++) {      
            if (chars[0] < chars[j]) {
                temp = chars[0];
                chars[0] = chars[j];
                chars[j] = temp;
                break;
            }
        }

        for (int j = 1; j <= x.length() ; j++) {           
            for (int i = 1; i < x.length() - 1; i++) {
                if (chars[i] > chars[i+1]){
                    temp = chars[i];
                    chars[i] = chars[i+1];
                    chars[i+1] = temp;
                }
            }
        }
        for (int i = 0; i < x.length(); i++) {
            System.out.print(chars[i]);
        }
    }
    
    else if (x.length() == 1)
        System.out.println(0);

    else {
            temp = chars[x.length()-2];
            chars[x.length()-2] = chars[x.length()-1];
            chars[x.length()-1] = temp;
            if (chars[x.length()-2] > oldChars[x.length()-2])
                for (int i = 0; i < x.length(); i++) {
                    System.out.print(chars[i]);
                }
            else
                System.out.println(0);
    }
    

    sc.close();
}

}

Answer 1

如果您可以使用apache commons collections4，并且性能无关紧要，那么您可以使用以下内容：

package test;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.List;
import java.util.stream.Collectors;

public class NextNumberCalculator {
    public int calculateNearest(int input) {
        List<Character> inputChars = String.valueOf(input).chars()
                .mapToObj(c -> (char) c)
                .collect(Collectors.toList());
        
        return CollectionUtils.permutations(inputChars)
                .stream()
                .mapToInt(chars -> Integer.parseInt(StringUtils.join(chars, "")))
                .filter(permutation -> permutation > input)
                .min()
                .orElse(0);
    }
}

下面是一些单元测试：

package test;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class NextNumberCalculatorTest {
    private NextNumberCalculator calculator;
    
    @BeforeEach
    void setUp() {
        calculator = new NextNumberCalculator();
    }
    
    @Test
    void calculateNearest() {
        Assertions.assertEquals(165, calculator.calculateNearest(156));
        Assertions.assertEquals(0, calculator.calculateNearest(330));
        Assertions.assertEquals(71127, calculator.calculateNearest(27711));
        Assertions.assertEquals(414, calculator.calculateNearest(144));
    }
}

Answer 2

这里有一种方法。

• 从最少的N有效数字开始<代码>N以2开头。保存一份副本
• 然后创建那些N数字的所有排列
• 将它们连接成一个字符串并放入TreeMap

public class NextLargestInteger {
    public static void main(String[] args) {
 

生成10个随机数。

        Random r = new Random();
        for (int i = 0; i < 10; i++) {
          int val = r.nextInt(Integer.MAX_VALUE);
          System.out.printf("%-12s   %-12s%n",val,nextHighest(Integer.toString(val)));
        }

打印出类似于

1446553155     1446553[515]
1801279982     18012[82799]
1894877459     18948774[95]
805018669      8050186[96] 
521703779      5217037[97] 
1926164416     19261644[61]
1236907656     12369076[65]
1326860288     1326860[828]
1049149602     10491496[20]
1516995584     1516995[845]

右边的括号显示了为获得最小值而排列的endpoint

主要方法。

    public static String nextHighest(String e) {
        char[] digits = e.toCharArray();
        // start two digits from the end
        int i = digits.length - 2;
        // tree set to store the permuted strings
        NavigableSet<String> set = new TreeSet<>();
        for (; i >= 0; i--) {
            
            // the last N digits
            char[] shortList =
                    Arrays.copyOfRange(digits, i, digits.length);

            // save a copy of the original N digit ending
            String originalTail = new String(shortList);

            permute(shortList, digits.length - i, set);
            
            // get the next higher ending from the set
            String minTail = set.higher(originalTail);
            // if it exists, return the value.
            if (minTail != null) {
                String head =
                        new String(Arrays.copyOfRange(digits, 0, i));
                return String.format("%s[%s]", head, minTail);
            }
            // clear the set and try a larger ending.
            set.clear();
        }
        // no success, return the original value.
        return e;
    }

置换字符数组的实用方法

    public static void permute(char[] elements, int length,
            Set<String> vals) {
        if (length == 1) {
            vals.add(new String(elements));
        } else {
            for (int i = 0; i < length; i++) {
                permute(elements, length - 1, vals);
                if (length % 2 == 1) {
                    swap(elements, 1, length - 1);
                } else {
                    swap(elements, i, length - 1);
                }
            }
        }
        
    }

交换数组元素的实用程序方法。

    public static void swap(char[] list, int i, int j) {
        char temp = list[i];
        list[i] = list[j];
        list[j] = temp;
    }
} 

Answer 3

请试试这个

int muldigits(int n){

    int result = 0;

    String [] strings = String.valueOf(Math.abs(n)).split("(?!^)");
    List<Integer> intsList = new ArrayList<>();
    for (String string : strings) {
        intsList.add(Integer.parseInt(string));
    }

    if(n<0){
        Collections.sort(intsList);
        String temp = Arrays.toString(intsList.toArray()).replace(", ", "");
        System.out.println(temp);
        result = - Integer.parseInt(temp.substring(1, temp.length()-1));
    }else{
        Collections.sort(intsList, Collections.reverseOrder());
        String temp = Arrays.toString(intsList.toArray()).replace(", ", "");
        result = Integer.parseInt(temp.substring(1, temp.length()-1));
    }
    return result;
}