Учитывая целое число N. Какое наименьшее целое число больше N в java

Если вы можете использовать коллекции apache commons4, а производительность не имеет значения, вы можете использовать что-то вроде этого:

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

Попробуйте это, пожалуйста

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

Вот один подход.

• Начиная с наименее N значащих цифр. N начинается с 2. Сохрани копию.
• затем создайте все перестановки этих N цифр.
• соедините их в строку и поставьте TreeMap<String>
• если существует следующее большее значение исходных N цифр, вернуть новое значение с новым окончанием, присоединенным к оригиналу.
• в противном случае увеличьте N на единицу и повторите процесс.

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]

В скобках справа показано, какие окончания были переставлены, чтобы получить минимум

Основной метод.

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