बाइनरी स्ट्रिंग को जावा में आधार 10 पूर्णांक में कैसे परिवर्तित करें

Question

मेरे पास स्ट्रिंग्स की एक सरणी है जो द्विआधारी संख्या (अग्रणी शून्य के बिना) का प्रतिनिधित्व करती है जिसे मैं उनके संबंधित आधार 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गलत दिशा में रूपांतरण करता है। मुझे संदेह है कि मुझे एक मल्टीस्टेप रूपांतरण करने की आवश्यकता होगी, लेकिन तरीकों या उपवर्गों के सही संयोजन को खोजने के लिए प्रतीत नहीं हो सकता। मुझे यह भी निश्चित नहीं है कि ज़ीरो या उसके अभाव में किस हद तक एक मुद्दा होगा। किसी को भी मुझे इंगित करने के लिए कोई अच्छी दिशा है?

Comments

को देखो पूर्णांक # parseInt (स्ट्रिंग है, पूर्णांक मूलांक)

— anubhava

बाइनरी नंबरों को दशमलव संख्याओं में परिवर्तित करने के

— माइक सैमुअल

Answer 1

आपको मूलांक निर्दिष्ट करने की आवश्यकता है । वहाँ एक अधिभार है, Integer#parseInt()जो आपको करने की अनुमति देता है।

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

Comments

पूर्णता। मैं पूरी तरह से parseInt प्रलेखन कि मूलांक के लिए अनुमति देता है पर दूसरी पंक्ति को याद किया। सपने की तरह काम करता है।

— dwwilson66

क्या यह अग्रणी शून्य के साथ भी काम करता है? बस पुष्टि कर रहा हूं, हालांकि मुझे कोई कारण नहीं दिखता है।

— सिद्धार्थ

@ नागभूषणबद्दी उदाहरण? क्या आप एक दो के पूरक प्रतिनिधित्व कर रहे हैं?

— मैट बॉल

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

Comments

मुझे लगता है कि यह अनावश्यक है। ऐसा तब होता है जब आपके पास कक्षाओं के बीच थोड़ा समय होता है।

— हसन

यह मेरे लिए मददगार है क्योंकि मुझे पहले से ही जावा का उपयोग किए बिना रूपांतरणों के साथ एक स्कूल प्रोजेक्ट करना है

— bucksnort2

क्या किसी ने पहले यह परीक्षण किया था? यहाँ संख्या। डायनामिक माइनस इंडेक्स प्लस 1 को 2 से गुणा किया गया है, अगर मैं गलत नहीं हूँ तो आप 1 से शुरू करें और उस मान को 2 से गुणा करें और फिर परिणाम को पकड़ें और 2 से एक को गुणा करें जो कि आपका 3 स्थान होगा और इसलिए ऑन

— क्रिस्टोफर कैबेजूडो रोड्रिगेज

(टिप्पणी बॉक्स SNIPPETS के लिए अच्छा नहीं है) यहाँ कोड है कि मैं तुम्हारा में आधार का उपयोग कर रहा हूँ (मैं खो गया था और एक टेम्पलेट के रूप में तुम्हारा इस्तेमाल करते हैं) सार्वजनिक स्थैतिक int बाइनरीटॉइंटर (स्ट्रिंग बाइनरी) {char] [बाइनरी] toCharArray (); int result = 0; int posValue = 1; for (int i = numbers.Length - 1; i> = 0; i--) {if (नंबर [i] == '1') {result + = posValue; } पॉसवेल्यू * = 2; } वापसी परिणाम; }

— क्रिस्टोफर कैबेजूडो रोड्रिगेज

यह कोड स्निपेट काम नहीं कर रहा है। forनए resultचर का लूप और गणना सही नहीं है।

— प्रयास

Answer 3

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 

मुझे आशा है कि वह मदद करेंगे!

Comments

मुझे बाइनरी से दशमलव में परिवर्तित -1 की आवश्यकता थी, मैंने यह किया। Println ((int) Long.parseLong ( "11111111111111111111111111111111", 2));

— ज़ीउस

Answer 4

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 5

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 6

मेरे लिए नकारात्मक संख्याओं से निपटने की कोशिश करते समय मुझे नंबरफ़ॉर्मैट अपवाद मिला। मैंने नकारात्मक और सकारात्मक संख्याओं के लिए निम्नलिखित का उपयोग किया।

System.out.println(Integer.parseUnsignedInt("11111111111111111111111111110111", 2));      

Output : -9

Answer 7

नकारात्मक संख्याओं के साथ काम करने के लिए java के 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

मैं प्यार करता हूँ! वाह!

String myString = "1001001"; //73

जबकि संचायक के साथ लूप, बाएं से दाएं ( lपरिवर्तन नहीं):

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

जावा में int (पूर्ण रूप से भयानक) में कन्वर्ट बूलियन से प्रेरित, 2 लूप वर्जन के साथ बाएं का अधिकार :

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;

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

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

Answer 9

यदि आप प्रदर्शन के बारे में चिंतित हैं, 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