Jak poprawnie zwiększyć bity w tablicy?

Question

Jeśli mam notację binarną, taką jak "1000010", która wynosi 66 i chcę ją zwiększyć o jeden do "1000011", co równa się 67. Jak to zrobić poprawnie w mojej tablicy? Obecnie drukuje "0100010", czyli 34, ale nie w pobliżu właściwej odpowiedzi. Nie sądzę, aby moja tablica poprawnie się przesuwała, ani nie zwiększy rozmiaru, gdy liczby będą większe. Chociaż nie mogę założyć, że duża tablica może być inna niż to, co zostało wyraźnie powiedziane.

public class math { 


//================================================================= 
    // increment(A) returns an array of bits representing A+1. 
    //================================================================= 

    public static byte[] increment(byte[] A) 
    { 
    byte carry= 1; 
    for(int i = 0; i<A.length; i++){ 
     byte b = A[i]; 
     A [i] ^= carry; 
     carry &= b; 
    } 
    return A; 
    } 

    private static String toBinString (byte [] a) 
    { 
     String res = ""; 
     for (int i = 0; i <a. length; i++) 
     { 
      res = (a [i] == 0 ? "0": "1") + res; 
     } 
     return res; 
} 


/** 
* @param args 
*/ 
public static void main(String[] args) { 
     byte [] A ={1,0,0,0,0,1,0}; 

     increment(A); 
      System.out.println (toBinString (A)); 


} 
} 

Answer 1

Ten pracował dla mnie:

public static void main(String[] args) { 
    byte [] A ={1,0,0,0,0,1,0}; 
    increment(A); 
    System.out.println (toBinString (A)); 
} 

public static byte[] increment(byte[] A) { 
    boolean carry = true; 
    for (int i = (A.length - 1); i >= 0; i--) { 
     if (carry) { 
      if (A[i] == 0) { 
       A[i] = 1; 
       carry = false; 
      } 
      else { 
       A[i] = 0; 
       carry = true; 
      } 
     } 
    } 

    return A; 
} 

private static String toBinString (byte [] a) { 
     String res = ""; 
     for (int i = 0; i < a. length; i++) { 
      res += (a [i] == 0 ? "0": "1") ; 
     } 
     return res; 
} 

Answer 2

public static byte[] increment(byte[] array) { 
    byte[] r = array.clone(); 
    for (int i = array.length - 1; i >= 0; i--) { 
     byte x = array[ i ]; 
     if (x == -1) 
      continue; 
     r[ i ] = (byte) (x + 1); 
     Arrays.fill(r, i + 1, array.length, (byte) 0); 
     return r; 
    } 
    throw new IllegalArgumentException(Arrays.toString(array)); 
} 

wyjątek jeśli przepełnienie

Answer 3

Leniwy (i bezpieczny) sposób na przyrost o jednym:

String s = "1000010"; 
    for (int i = 0; i < 5; i++) { 
     System.out.print(s); 
     System.out.println("\t" + Integer.valueOf(s, 2)); 
     s = Integer.toBinaryString(Integer.valueOf(s, 2) + 1); 
    } 

Wyjście:

1000010 66 
1000011 67 
1000100 68 
1000101 69 
1000110 70 

(Edytowane do prezentacji)

Answer 4

//Function call 
incrementCtr(ctr, ctr.length - 1); 

//Increments the last byte of the array 
private static void incrementCtr(byte[] ctr, int index) {  

    ctr[index]++; 

    //If byte = 0, it means I have a carry so I'll call 
    //function again with previous index 
    if(ctr[index] == 0) { 
     if(index != 0) 
      incrementCtr(ctr, index - 1); 
     else 
      return; 
    } 
} 

Answer 5

późno, ale zwięzły:

public static void increment(byte[] a) { 
    for (int i = a.length - 1; i >= 0; --i) { 
     if (++a[i] != 0) { 
      return a; 
     } 
    } 
    throw new IllegalStateException("Counter overflow"); 
}