Besserer Algorithmus für Ergänzung der integer-Wert ohne die führende null binären bits

Werde ich zunächst erklären, was ich meine "Ergänzung integer-Wert ohne die führende null binary bits" (ab jetzt nenne ich Sie Nicht Führenden Null-Bits ergänzen oder NLZ-Ergänzung für die Kürze).

Zum Beispiel gibt es integer-Zahl 92. die binäre Zahl ist 1011100. Wenn wir normal Bitweises NICHT oder zu Ergänzen, ist das Ergebnis: -93 (signed integer) oder 11111111111111111111111110100011 (Binär). Das ist, weil die führende null-bits ergänzt werden auch.

So, für NLZ-Ergänzung, die führende null-bits werden nicht ergänzt, wird das Ergebnis der NLZ-Ergänzung von 92 oder 1011100 ist: 35 oder 100011 (Binär). Die Bedienung erfolgt durch XORing der input-Wert mit einer Folge von 1-bits so viel wie die nicht-führende null Wert. Die Abbildung:

92:  1011100
     1111111 (xor)
     --------
     0100011 => 35

Ich hatte den java-Algorithmus so:

public static int nonLeadingZeroComplement(int n) {
    if (n == 0) {
        return ~n;
    }
    if (n == 1) {
        return 0;
    }

    //This line is to find how much the non-leading zero (NLZ) bits count.
    //This operation is same like: ceil(log2(n))
    int binaryBitsCount = Integer.SIZE - Integer.numberOfLeadingZeros(n - 1);

    //We use the NLZ bits count to generate sequence of 1 bits as much as the NLZ bits count as complementer
    //by using shift left trick that equivalent to: 2 raised to power of binaryBitsCount.
    //1L is one value with Long literal that used here because there is possibility binaryBitsCount is 32
    //(if the input is -1 for example), thus it will produce 2^32 result whom value can't be contained in 
    //java signed int type.
    int oneBitsSequence = (int)((1L << binaryBitsCount) - 1);

    //XORing the input value with the sequence of 1 bits
    return n ^ oneBitsSequence;
}

Ich brauche einen Rat, wie oben beschriebenen Algorithmus zu optimieren, vor allem die Zeile für die Generierung Folge von 1-bits complementer (oneBitsSequence), oder wenn jemand vorschlagen kann, besseren Algorithmus?

UPDATE: ich würde auch gerne wissen, der Begriff der nicht-führende null ergänzen?

Also für alle Potenzen von zwei, die Sie zurückgeben möchten 0. So ab 0 wäre die Folge 1, 0, 0, 0, 0, 2, 1, 0, 0, 6, ... Was ist der nutzen dieser?
Was Sie Anruf "NLZ-Ergänzung" ist, was ist bekannt als' Ergänzen. en.wikipedia.org/wiki/One%27s_compliment
sind Sie sicher? Ich denke, das ist es nicht. Ein Komplement auch als Ergänzung der führenden Nullen.
In diesem Fall haben Sie Recht. Aktualisieren meine Antwort.
Nach einiger überlegung scheint, dass Sie zu rechnen haben, die führende 0. So anstelle des Editier meine Antwort ist falsch, ich werde es löschen, da die erste Antwort ist die richtige.
Es ist ok, ich bin immer noch offen für andere alternativen. Ich bin auch gespannt, was der Begriff dieses zu ergänzen.

InformationsquelleAutor null | 2012-08-06

9

Bekommen Sie die höchsten ein wenig durch die Integer.highestOneBit(i) Methode, shift-einen Schritt Links, dann 1 subtrahieren. Dies bekommt Sie die richtige Länge der 1s:
```
private static int nonLeadingZeroComplement(int i) {
    int ones = (Integer.highestOneBit(i) << 1) - 1;
    return i ^ ones;
}
```
Beispielsweise
```
System.out.println(nonLeadingZeroComplement(92));
```
Drucke
```
35
```
- Ich wusste es! Es muss eine integrierte Funktion, das ist einfacher. Lol, Sie diese sehr einfach zu machen. Wissen Sie, der echte/bekannte Begriff des NLZ-Ergänzung?
- Nein, sorry, ich weiß nicht, einen speziellen Begriff für diese.
InformationsquelleAutor Keppil

offensichtlich @keppil zur Verfügung gestellt hat kürzeste Lösung. Eine andere Lösung Aussehen könnte.

private static int integerComplement(int n){

  String binaryString = Integer.toBinaryString(n);

  String temp = "";
  for(char c: binaryString.toCharArray()){
      if(c == '1'){
          temp += "0";
      }
      else{
          temp += "1";
      }
  }
  int base = 2;
  int complement = Integer.parseInt(temp, base);

  return complement;
}

Beispielsweise

System.out.println(nonLeadingZeroComplement(92));

Druckt Antwort als 35

InformationsquelleAutor shrishinde

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.