जावा

Question

में बाइनरी स्ट्रिंग को आधार 10 पूर्णांक में परिवर्तित करने के लिए कैसे करें मेरे पास स्ट्रिंग्स की एक सरणी है जो बाइनरी संख्याओं (बिना अग्रणी शून्य के) का प्रतिनिधित्व करती है जिसे मैं उनके संबंधित आधार 10 संख्याओं में परिवर्तित करना चाहता हूं। विचार करें:

binary 1011 becomes integer 11 
binary 1001 becomes integer 9 
binary 11 becomes integer 3 etc. 

आगे बढ़ने का सबसे अच्छा तरीका क्या है? मैं java.lang.number खोज रहा हूं। * प्रत्यक्ष रूपांतरण विधि खोजने के बिना। Integer.parseInt(b) स्ट्रिंग के लिए एक पूर्णांक समानता उत्पन्न करता है ... उदा।, 1001 9 के बजाय 1,001 बन जाता है ... और आउटपुट बेस के लिए पैरामीटर शामिल नहीं लगता है। toBinaryString रूपांतरण गलत दिशा करता है। मुझे संदेह है कि मुझे एक मल्टीस्टेप रूपांतरण करने की आवश्यकता होगी, लेकिन विधियों या उप-वर्गों का सही संयोजन नहीं लग रहा है। मुझे यह भी यकीन नहीं है कि किस सीमा तक प्रमुख शून्य या इसकी कमी होगी। किसी को भी मुझे इंगित करने के लिए कोई अच्छी दिशा है?

Answer 1

आपको specify the radix की आवश्यकता है। Integer#parseInt() का अधिभार है जो आपको अनुमति देता है।

int foo = Integer.parseInt("1001", 2); 

Answer 2

यह काम हो सकता है:

public int binaryToInteger(String binary) { 
    char[] numbers = binary.toCharArray(); 
    int result = 0; 
    for(int i=numbers.length - 1; i>=0; i--) 
     if(numbers[i]=='1') 
      result += Math.pow(2, (numbers.length-i - 1)); 
    return result; 
} 

Answer 3

public Integer binaryToInteger(String binary){ 
    char[] numbers = binary.toCharArray(); 
    Integer result = 0; 
    int count = 0; 
    for(int i=numbers.length-1;i>=0;i--){ 
     if(numbers[i]=='1')result+=(int)Math.pow(2, count); 
     count++; 
    } 
    return result; 
} 

मुझे लगता है मैं और भी अधिक ऊब रहा हूँ! सही ढंग से काम करने के लिए संशोधित हसन का जवाब।

Answer 4

int foo = Integer.parseInt("1001", 2); 

काम करता है ठीक है अगर आप सकारात्मक संख्या के साथ काम कर रहे हैं, लेकिन आप अपने स्ट्रिंग का विस्तार साइन करना पड़ सकता आप पर हस्ताक्षर किए संख्या के साथ सौदा करने की आवश्यकता है तो एक इंट

public class bit_fun { 
    public static void main(String[] args) { 
     int x= (int)Long.parseLong("FFFFFFFF", 16); 
     System.out.println("x =" +x);  

     System.out.println(signExtend("1")); 
     x= (int)Long.parseLong(signExtend("1"), 2); 
     System.out.println("x =" +x); 

     System.out.println(signExtend("0")); 
     x= (int)Long.parseLong(signExtend("0"), 2); 
     System.out.println("x =" +x); 

     System.out.println(signExtend("1000")); 
     x= (int)Long.parseLong(signExtend("1000"), 2); 
     System.out.println("x =" +x); 

     System.out.println(signExtend("01000")); 
     x= (int)Long.parseLong(signExtend("01000"), 2); 
     System.out.println("x =" +x); 
    } 

    private static String signExtend(String str){ 
     //TODO add bounds checking 
     int n=32-str.length(); 
     char[] sign_ext = new char[n]; 
     Arrays.fill(sign_ext, str.charAt(0)); 

     return new String(sign_ext)+str; 
    } 
} 

output: 
x =-1 
11111111111111111111111111111111 
x =-1 
00000000000000000000000000000000 
x =0 
11111111111111111111111111111000 
x =-8 
00000000000000000000000000001000 
x =8 

में बदलने का मुझे आशा है कि मदद करता है !

Answer 5

static int binaryToInt (String binary){ 
    char []cA = binary.toCharArray(); 
    int result = 0; 
    for (int i = cA.length-1;i>=0;i--){ 
     //111 , length = 3, i = 2, 2^(3-3) + 2^(3-2) 
     //     0   1 
     if(cA[i]=='1') result+=Math.pow(2, cA.length-i-1); 
    } 
    return result; 
} 

Answer 6

मुझे लूप पसंद है! वाह!

String myString = "1001001"; //73 

जबकि संचायक के साथ पाश, बाएं से दाएं (l परिवर्तन नहीं करता है): 2 पाश वार्स के साथ छोड़ दिया करने के लिए

int n = 0, 
    j = -1, 
    l = myString.length(); 
while (++j < l) n = (n << 1) + (myString.charAt(j) == '0' ? 0 : 1); 
return n; 

ठीक है, Convert boolean to int in Java (बिल्कुल भयानक) से प्रेरित:

int n = 0, 
    j = myString.length, 
    i = 1; 
while (j-- != 0) n -= (i = i << 1) * new Boolean(myString.charAt(j) == '0').compareTo(true); 
return n >> 1; 

कुछ हद तक अधिक उचित कार्यान्वयन:

int n = 0, 
    j = myString.length(), 
    i = 1; 
while (j-- != 0) n += (i = i << 1) * (myString.charAt(j) == '0' ? 0 : 1); 
return n >> 1; 

एक पठनीय संस्करण: p

int n = 0; 
for (int j = 0; j < myString.length(); j++) { 
    n *= 2; 
    n += myString.charAt(j) == '0' ? 0 : 1; 
} 
return n; 

Answer 7

जावा के Integer.parseInt (पाठ) के फिक्स्ड संस्करण ऋणात्मक संख्याओं के साथ काम करने के लिए:

public static int parseInt(String binary) { 
    if (binary.length() < Integer.SIZE) return Integer.parseInt(binary, 2); 

    int result = 0; 
    byte[] bytes = binary.getBytes(); 

    for (int i = 0; i < bytes.length; i++) { 
     if (bytes[i] == 49) { 
      result = result | (1 << (bytes.length - 1 - i)); 
     } 
    } 

    return result; 
} 

Answer 8

आप प्रदर्शन के बारे में चिंतित हैं, Integer.parseInt() और Math.pow() हैं बहुत महंगा।(मेरे अनुभव के आधार पर) आप थोड़ा हेरफेर का उपयोग कर सकते एक ही बात तेजी के रूप में दो बार करने के लिए:

final int num = 87; 
String biStr = Integer.toBinaryString(num); 

System.out.println(" Input Number: " + num + " toBinary "+ biStr); 
int dec = binaryStringToDecimal(biStr); 
System.out.println("Output Number: " + dec + " toBinary "+Integer.toBinaryString(dec)); 

कहाँ

int binaryStringToDecimal(String biString){ 
    int n = biString.length();  
    int decimal = 0; 
    for (int d = 0; d < n; d++){ 
    // append a bit=0 (i.e. shift left) 
    decimal = decimal << 1; 

    // if biStr[d] is 1, flip last added bit=0 to 1 
    if (biString.charAt(d) == '1'){ 
     decimal = decimal | 1; // e.g. dec = 110 | (00)1 = 111 
    } 
    } 
    return decimal; 
} 

आउटपुट:

Input Number: 87 toBinary 1010111 
Output Number: 87 toBinary 1010111