एक सरणी में सही ढंग से बिट्स को कैसे बढ़ाया जाए?

Question

यदि मेरे पास बाइनरी नोटेशन है जैसे "1000010" जो कि 66 के बराबर है और मैं इसे एक से "1000011" तक बढ़ा सकता हूं जो 67 के बराबर है। यह मेरी सरणी में सही तरीके से कैसे किया जाता है? वर्तमान में यह "0100010" प्रिंट कर रहा है जो 34 है, लेकिन सही उत्तर के पास कहीं नहीं। मुझे नहीं लगता कि मेरी सरणी सही ढंग से स्थानांतरित हो रही है, न ही यह आकार बढ़ेगी क्योंकि संख्याएं बड़ी हो जाती हैं। हालांकि, मैं इस बारे में कोई धारणा नहीं कर सकता कि सरणी स्पष्ट रूप से बताई गई चीज़ों के अलावा अन्य कितनी बड़ी हो सकती है।

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

यह मेरे लिए काम किया:

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

अपवाद अगर अतिप्रवाह

Answer 3

एक के बाद वेतन वृद्धि के लिए आलसी (और सुरक्षित) तरीका:

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

आउटपुट:

1000010 66 
1000011 67 
1000100 68 
1000101 69 
1000110 70 

(प्रस्तुति के लिए संपादित)

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

देर लेकिन संक्षिप्त:

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