删除给定整数的重复数字

Question

我的结果基于以下方法，但我不满意。

我想要其他一些方式和有效的方式来获得预期的输出。

输入：

112341

输出：

1234 

不应在输出中显示重复，答案必须为1234。

我的解决方案：

public class PrintUnique {
    public static void main(String[] args) {
        int result = printUniquNums(112341);
        System.out.println(result);
    }

    private static int printUniquNums(int num) {

        String nums =  Integer.toString(num);
        char [] ch = nums.toCharArray();
        Set<Character> store = new LinkedHashSet<>();

        String res = "";
        for (int i = 0; i < ch.length; i++){
            if (store.add(ch[i])){
                res += ch[i];
            }
        }
        return Integer.parseInt(res);
    }
 }

Answer 1

与Java Lambdas和Streams进行了一些调整。您的代码也很好。

public static void main(String[] args) {
        int result = printUniquNums(112341);
        System.out.println(result);
    }

    private static int printUniquNums(int num) {

        String nums =  Integer.toString(num);
        List<String> digits = List.of(nums.split(""));
        Set<String> uniqueDigits = new HashSet<>();
        String uniqueNum = digits.stream().filter(uniqueDigits::add).reduce(String::concat).orElse(""); // set add method returns true if value not present
        return Integer.parseInt(uniqueNum);
    }

Answer 2

不使用字符串的另一种方法意味着将数字除以10，以供电数字减去一个数字，并在set set linkedhashset中从左到右收集每个数字维护插入顺序。然后，使用流来重建不重复数字的数字：

public static int uniqueNumber(int num) {
    int temp;
    Set<Integer> set = new LinkedHashSet<>();
    while (num > 10) {
        temp = (int) Math.pow(10, Math.ceil(Math.log10(num)) - 1);
        set.add(num / temp);
        num %= temp;
    }
    set.add(num);

    Integer[] digits = set.toArray(new Integer[set.size()]);
    return IntStream.range(0, digits.length)
            .map(i -> digits[i] * ((int) Math.pow(10, (digits.length - 1) - i)))
            .reduce(0, (a, b) -> a + b);
}

输出

1234

是测试代码的链接：

https://www.jdoodle.com/iembed/v0/rsi

Answer 3

在性能方面，这并不是更有效的。但是，它的代码线较少，更容易阅读的行为更重要。

    private static int printUniquNums(int num) {
        TreeSet<String> tree= new TreeSet<>();
        for (char c : Integer.toString(num).toCharArray()) {
            tree.add(String.valueOf(c));
        }
        return Integer.parseInt(String.join("", tree));
    }

Answer 4

您的方法可以使用 stream api 重新进化。

最简单的方法之一是创建一个代码点的流。

然后，我们需要应用 dinters（） 确保流元素的唯一性。此操作利用linkedhashset在引擎盖下拒绝重复并保留初始订单。

最后，应用终端操作 cocal> collect> collect（） 代码> StringBuilder 作为A 容器用于执行可变减少的。

private static int printUniquNums(int num) {
    
    String result = String.valueOf(num).codePoints() // generating a stream of code points
        .distinct()                              // ensure uniqueness
        .collect(StringBuilder::new,             // mutable container
                 StringBuilder::appendCodePoint, // defining how values should be accumulated in the container
                 StringBuilder::append)          // how to merge the containers obtained while executing the stream in parallel
        .toString();
    
    return Integer.parseInt(result);
}

实现此目的的另一种方法是 map 流元素到string类型中，并使用内置 collector joning（）< /code>将照顾AS的流串联：

private static int printUniquNums(int num) {
    
    String result = String.valueOf(num).codePoints() // generating a stream of code points
        .distinct()                      // ensure uniqueness
        .map(Character::getNumericValue) // getting a numeric value from a code point
        .mapToObj(String::valueOf)       // creating a single-character string
        .collect(Collectors.joining());  // combining the strings together
    
    return Integer.parseInt(result);
}

public static void main(String[] args) {
    int result = printUniquNums(112341);
    System.out.println(result);
}

output （对于两个解决方案）：

1234

链接到在线演示