¿Cómo incrementar los bits correctamente en una matriz?

Question

Si tengo una notación binaria como "1000010", que es igual a 66 y quiero incrementarlo en uno de "1000011", que es igual a 67. ¿Cómo se hace eso correctamente en mi matriz? Actualmente está imprimiendo "0100010" que es 34, pero no está cerca de la respuesta correcta. No creo que mi matriz esté cambiando correctamente, ni aumentará el tamaño a medida que los números aumentan. Sin embargo, no puedo hacer ninguna suposición sobre qué tan grande puede ser la matriz más allá de lo que se establece explícitamente.

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

Esto funcionó para mí:

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

excepción si desbordamiento

Answer 3

La forma perezosa (y seguro) para la subasta por uno:

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

de salida:

1000010 66 
1000011 67 
1000100 68 
1000101 69 
1000110 70 

(Editado para la presentación)

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

tarde pero concisa:

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