Question

我的目标是在Java中反转没有重复数字的整数如何提高代码的复杂性或是否存在良好/标准的算法？

包含重复数字，应保留最后一位数

public static void main(String[] args) {
    int n = -19890;
    System.out.println(reverseNumberWithoutDuplicate(n));
}

public static int reverseNumberWithoutDuplicate(int number) {
    boolean isNegative = (number < 0);
    number = isNegative ? number * -1 : number;

    Set<Character> lookup = new HashSet<>();

    StringBuffer sb = new StringBuffer();
    char[] digits = String.valueOf(number).toCharArray();
    for (int i = digits.length - 1; i >= 0; --i) {
        if (lookup.contains(digits[i])) {
            continue;
        }
        sb.append(digits[i]);
        lookup.add(digits[i]);
    }
    return isNegative ? Integer.parseInt(sb.toString()) * -1 : Integer.parseInt(sb.toString());
}

预期输出：-981

Answer 1

让我们逐步构建解决方案。以下函数反转正数的数字。

int reverseNumber(int number) {
    int answer = 0;
    for (int n = number; n != 0; n /= 10) {
        // Digits are taken from least significant to most significant
        int digit = n % 10; 
        // And added the other way round
        answer = answer * 10 + digit;
    }
    return answer;
}

此代码可以很容易地适应负数用于：

int reverseNumber(int number) {
    if (number < 0) {
        return -reverseNumber(-number);
    }
    // The rest is the same

我们的下一个目标 - 跳过重复的数字。我们将跟踪boolean[] seen中已经看到的数字列表。

private static int reverseNumberWithoutDuplicate(int number) {
    if (number < 0) {
        return -reverseNumberWithoutDuplicate(-number);
    }

    boolean[] seen = new boolean[10];
    int answer = 0;
    for (int n = number; n != 0; n /= 10) {
        int digit = n % 10;            
        if (!seen[digit]) {
            seen[digit] = true;
            answer = answer * 10 + digit;
        }
    }
    return answer;
}

Answer 2

复杂性很好。虽然可以进行优化。

使用StringBuilder比旧的StringBuffer更好，后者不需要开销（为了线程安全）。

然后数据可以保持数字，对于十个可能的数字，BitSet就可以了。

public static int reverseNumberWithoutDuplicate(int number) {
    if (number == Integer.MIN_VALUE) {
        // -2147483648 is a special case, not negatable.
        return -8463712;
    }
    boolean isNegative = number < 0;
    number = isNegative ? -number : number;

    BitSet usedDigits = new BitSet(10);
    int reversedNumber = 0;
    while (number != 0) {
        int digit = number % 10;
        number /= 10;
        if (!usedDigits.get(digit)) {
            usedDigits.set(digit);
            reversedNumber = 10 * reversedNumber + digit;
        }
    }
    return isNegative ? -reversedNumber : reversedNumber;
}

反向整数在java中没有重复数字

2 个答案: