एक पूर्णांक

Question

के रूप में दो पूर्णांक पास करें मेरे पास दो पूर्णांक हैं जिन्हें मुझे एक पूर्णांक से गुज़रने की आवश्यकता है और फिर दो पूर्णांक के मान प्राप्त करें।

मैं तर्क ऑपरेटर (AND, OR, XOR, आदि) का उपयोग करने के बारे में सोच रहा हूं।

Answer 1

दो पूर्णांक एक पूर्णांक फिट नहीं हो सकता है, या कम से कम आप दो मूल को वापस नहीं प्राप्त कर सकते हैं।
लेकिन वैसे भी, दो मूल पूर्णांक बिट्स की एक निश्चित संख्या के लिए घिरा रहे हैं आप कर सकते हैं (preudocode में): पहले पूर्णांक या साथ (दूसरा पूर्णांक SHIFTLEFT (nOfBits))

दो पूर्णांक वापस पाने के लिए

मास्क पूर्णांक को उस संख्या के साथ मास्क करें जो nOfBitsOne द्वारा दर्शाया गया बाइनरी है और आप पहले पूर्णांक प्राप्त करते हैं, फिर विस्फोट पूर्णांक nOfBits द्वारा ShiftRight, और आपने दूसरा वापस किया है।

Answer 2

खैर .. @Felice ठीक है, लेकिन अगर वे दोनों 16 बिट में फिट वहाँ एक रास्ता है:

output_int = (first_int << 16) | second_int 
          ^
          means 'or' 

उन्हें पैक करने के लिए, और

first_int = output_int & 0xffff 
second_int = (output int >> 16) & 0xffff 
           ^
          means 'and' 

उन्हें निकालने के लिए।

Answer 3

आप 32-बिट पूर्णांक के भीतर 2 16-बिट पूर्णांक स्टोर कर सकते हैं। पिछले 16 बिट्स में सबसे पहले मैं 16 पहले बिट्स और दूसरा एक। उस मूल्य को पुनर्प्राप्त करने और लिखने के लिए आप Shift-operators का उपयोग करते हैं।

Answer 4

सी प्रोग्रामिंग भाषा का उपयोग करना, यह के रूप में यह सोचते हैं कि दो पूर्णांकों से भी कम समय 65535.

void take2IntegersAsOne(int x) 
{ 
    // int1 is stored in the bottom half of x, so take just that part. 
    int int1 = x & 0xFFFF; 

    // int2 is stored in the top half of x, so slide that part of the number 
    // into the bottom half, and take just that part. 
    int int2 = (x >> 16) & 0xFFFF 

    // use int1 and int2 here. They must both be less than 0xFFFF or 65535 in decimal 

} 


void pass2() 
{ 
    int int1 = 345; 
    int int2 = 2342; 
    take2Integers(int1 | (int2 << 16)); 
} 

इस तथ्य यह है कि सी में एक पूर्णांक 4 बाइट में संग्रहित है पर निर्भर करता है इस प्रकार हैं किया जा सकता है। तो, उदाहरण पूर्णांक में से एक को स्टोर करने के लिए पहले दो बाइट्स का उपयोग करता है, और दूसरे के लिए अगले दो बाइट्स का उपयोग करता है। यह सीमा को लागू करता है हालांकि प्रत्येक पूर्णांक में एक छोटा सा मूल्य होना चाहिए ताकि वे प्रत्येक 2 बाइट्स में फिट हो जाए।

शिफ्ट ऑपरेटर < < और >> एक पूर्णांक के बिट्स को नीचे और नीचे स्लाइड करने के लिए उपयोग किया जाता है। 16 से स्थानांतरित करना, बिट्स को दो बाइट्स से चलाता है (क्योंकि प्रति बाइट 8 बिट्स होते हैं)।

0xFFFF का उपयोग बिट पैटर्न का प्रतिनिधित्व करता है जहां संख्या के निचले दो बाइट्स में सभी बिट्स 1 एस हैं, इसलिए एंडिंग (& ऑपरेटर के साथ) उन सभी बिट्स का कारण बनता है जो इन दो बाइट्स में बंद नहीं होते हैं (शून्य पर वापस)। इसका उपयोग उस समय से 'अन्य पूर्णांक' के किसी भी हिस्से को निकालने के लिए किया जा सकता है, जिसे आप निकालने वाले हैं।

Answer 5

इस प्रश्न के दो भाग हैं। सबसे पहले, आप 64-बिट लंबे इंटीजर में दो 32-बिट इंटेजर्स को बिटमैस्क कैसे करते हैं?

जैसा कि अन्य ने कहा है, मान लीजिए कि मेरे पास एक ऐसा कार्य है जो एक्स और वाई समन्वय लेता है, और उस बिंदु के रैखिक मान का प्रतिनिधित्व करने वाला एक लम्बाई देता है। मैं 2 डी डेटा के इस linearization कॉल करते हैं:

public long asLong(int x, int y) { 
    return (((long)x) << 32) | y; 
} 

public int getX(long location) { 
    return (int)((location >> 32) & 0xFFFFFFFF); 
} 

public int getY(long location) { 
    return (int)(location & 0xFFFFFFFF); 
} 

मुझे माफ कर दो अगर मैं आपरेशन के आदेश के बारे में पागल हूँ, कभी कभी अन्य कार्यों greedier से < < हैं, जिससे चीजों की तुलना में वे चाहिए आगे शिफ्ट करने के लिए।

यह क्यों काम करता है? यह कब विफल हो सकता है? यह सुविधाजनक है कि पूर्णांक लम्बाई के आकार के आधे आकार के होते हैं। हम जो कर रहे हैं वह एक्स को लंबे समय तक कास्टिंग कर रहा है, जब तक यह पूरी तरह से वाई के बाईं ओर नहीं बैठता है, और फिर दोनों के बिट्स को गठबंधन करने के लिए यूनियन ऑपरेशन (OR) कर रहा है।

के वे 4-बिट नंबर एक 8 बिट संख्या में संयुक्त किया जा रहा हो ढोंग करते हैं:

x = 14  :  1110 
y = 5  :  0101 

x = x << 4 : 1110 0000 

p = x | y : 1110 0000 
      OR  0101 
      --------- 
      1110 0101 

इस बीच, रिवर्स:

p = 229 : 1110 0101 
x = p >> 4 : 1111 1110 //depending on your language and data type, sign extension 
         //can cause the bits to smear on the left side as they're 
         //shifted, as shown here. Doesn't happen in unsigned types 
x = x & 0xF: 
      1111 1110 
     AND 0000 1111 
     ------------- 
      0000 1110 //AND selects only the bits we have in common 

y = p & 0xF: 
      1110 0101 
     AND 0000 1111 
     ------------- 
      0000 0101 //AND strikes again 

दृष्टिकोण इस तरह की एक लंबी अस्तित्व में आया समय पहले, ऐसे वातावरण में जिन्हें उनके भंडारण या संचरण स्थान से हर बिट को निचोड़ने की आवश्यकता होती थी। सिर्फ एक वापसी मान मुक्केबाजी के लिए

• यह रास्ता बहुत ज्यादा काम है: आप एक एम्बेडेड सिस्टम पर नहीं कर रहे हैं या तुरंत एक नेटवर्क पर प्रसारण के लिए इस डेटा पैकिंग हैं, तो यह पूरी प्रक्रिया की व्यावहारिकता वास्तव में तेजी से तोड़ने के लिए शुरू होता है कि लगभग हमेशा तुरंत अनबॉक्स किया जाना चाहिए और कॉलर द्वारा पढ़ा जाना चाहिए। यह एक छेद खोदने और फिर इसे भरने की तरह है।
• यह आपके कोड पठनीयता को बहुत कम करता है। "किस प्रकार का लौटाया जाता है?" उह ... एक int .. और एक और int ... एक लंबे समय में।
• यह लाइन के नीचे हार्ड-टू-ट्रेस बग पेश कर सकता है। उदाहरण के लिए, यदि आप हस्ताक्षरित प्रकारों का उपयोग करते हैं और साइन एक्सटेंशन को अनदेखा करते हैं, तो बाद में उस प्लेटफॉर्म पर माइग्रेट करें जो उन प्रकारों को दो पूरक के रूप में ले जाता है। यदि आप लांगिंट को सेव करते हैं, और इसे बाद में अपने कोड के किसी अन्य हिस्से में पढ़ने की कोशिश करते हैं, तो आप बिट्सफ़िफ्ट पर एक-एक-एक त्रुटि को दबा सकते हैं और यह गलत तरीके से पता लगाने के लिए केवल आपके फ़ंक्शन को डिबग करने में एक घंटे बिता सकते हैं।

यदि यह बहुत बुरा है, तो विकल्प क्या हैं?

यही कारण है कि लोग आपको अपनी भाषा के बारे में पूछ रहे थे। आदर्श रूप में, यदि आप सी या सी की तरह कुछ कर रहे हैं ++, यह सबसे अच्छा नहीं तो

struct Point { int x; int y; }; 

public Point getPosition() { 
    struct Point result = { 14,5 }; 
    return result; 
} 

कहने के लिए, जावा की तरह HLLs में, आप एक ही कार्यक्षमता प्राप्त करने के लिए एक आंतरिक वर्ग के साथ हवा हो सकता है हो जाएगा:

public class Example { 
    public class Point { 
     public int x; 
     public int y; 
     public Point(int x, int y) { this.x=x; this.y=y; } 
    } 

    public Point getPosition() { 
     return new Point(14,5); 
    } 
} 

इस मामले में, getPosition एक उदाहरण देता है। प्वाइंट - यदि आप अक्सर प्वाइंट का उपयोग करते रहते हैं, तो इसे अपने स्वयं के पूर्ण वर्ग में प्रचारित करें। वास्तव में, जावा.एट के पास प्वाइंट और प्वाइंट सहित कई प्वाइंट क्लासेस हैं। फ्लोट

अंत में, कई आधुनिक भाषाओं में अब बॉक्सिंग एकाधिक मानों के लिए सिंटैक्टिक चीनी होती है जो टुपल्स में या सीधे फ़ंक्शन से कई मान लौटाती है। यह एक आखिरी उपाय है। मेरे अनुभव में, जब भी आप उस डेटा का नाटक करते हैं तो यह नहीं है कि यह है, तो आप लाइन के नीचे समस्याओं के साथ हवा में हैं। लेकिन अगर आपकी विधि पूरी तरह से दो नंबर लौटाएं जो वास्तव में सभी पर समान डेटा का हिस्सा नहीं हैं, तो टुपल्स या सरणी जाने का तरीका हैं।

C++ stdlib टपल के लिए संदर्भ http://www.cplusplus.com/reference/std/tuple/