Làm thế nào để tăng bit một cách chính xác trong một mảng?

Question

Nếu tôi có một ký hiệu nhị phân như "1000010" bằng 66 và tôi muốn tăng nó bằng một đến "1000011" bằng 67. Làm thế nào được thực hiện đúng trong mảng của tôi? Hiện tại nó đang in ra "0100010" là 34, nhưng không có nơi gần câu trả lời đúng. Tôi không nghĩ rằng mảng của tôi đang dịch chuyển một cách chính xác, cũng như nó sẽ tăng kích thước khi các con số lớn hơn. Mặc dù, tôi không thể đưa ra bất kỳ giả định nào về mảng lớn có thể khác với những gì được tuyên bố rõ ràng.

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

này đã làm việc cho tôi:

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

ngoại lệ nếu tràn

Answer 3

Cách lười biếng (và an toàn) cho increment bởi một:

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

Output:

1000010 66 
1000011 67 
1000100 68 
1000101 69 
1000110 70 

(Sửa để trình bày)

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

trễ nhưng súc tích:

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