Umgekehrte Integer-Zahl ohne doppelte Ziffer in Java

Question

Mein Ziel ist die Umkehr der ganzen Zahl ohne doppelte Ziffer in Java Wie verbessere ich die Komplexität des Codes oder gibt es einen guten/Standard-Algorithmus?

Incase von doppelter Ziffer, sollte es letzte Ziffer

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

Erwartete Ausgabe erhalten: -981

Answer 1

Die Komplexität ist in Ordnung. Obwohl es optimiert werden kann.

Die Verwendung von StringBuilder ist besser als der ältere StringBuffer, der unnötigen Overhead (für Thread-Sicherheit) benötigt.

Dann können die Daten numerisch bleiben, und für die zehn möglichen Ziffern ist ein BitSet in Ordnung.

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

Answer 2

Lassen Sie sich eine Lösung Schritt für Schritt aufzubauen. Die folgende Funktion kehrt die Ziffern der positiven Zahl um.

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

könnte Dieser Code leicht zu arbeiten mit negativen Zahlen angepasst werden:

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

Unser nächstes Ziel - doppelte Ziffern überspringen. Wir werden eine Liste der bereits gesehenen Ziffern in der boolean[] seen verfolgen.

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