बिटवाई ऑपरेटरों के साथ "==" को बदलना

Question

केवल बिटवाई ऑपरेटरों (|, &, ~, ^, >> < <) और अन्य बुनियादी ऑपरेटरों जैसे +, -, और! का उपयोग करके, "= = "नीचे?

int equal(int x, int y) { 
    return x == y; 
} 

Answer 1

दो नंबर के बराबर हैं, तो उन दोनों के बीच कोई अंतर नहीं है:

int equal(int x, int y){ 
    return !(x-y); 
} 

Answer 2

याद रखें कि एक XORNOT EQUALS के रूप में बिल्कुल वैसा ही है और XNOR बिल्कुल EQUALS के समान है। तो, निम्नलिखित आप दे देंगे आप क्या चाहते हैं:

return !(x^y); 

Answer 3

यह उदाहरण घटाव के रूप में ही है, लेकिन अधिक स्पष्ट है कैसे कुछ आर्किटेक्चर रजिस्टर तुलना करते हैं (जैसे एआरएम, मुझे विश्वास है)।

return !(1 + ~x + y); 

1 एएलयू में कैर्री-बिट इनपुट को दर्शाता है। एक नंबर x बिटवाई पूरक है। पूरक लेना और जोड़ना 1 के दो पूरक का उत्पादन करता है (x-x बन जाता है), और फिर समानता निर्धारित करने के लिए अंतर प्राप्त करने के लिए इसे दूसरे नंबर में जोड़ा जाता है।

तो यदि दोनों संख्या बराबर हैं, तो आपको -x + x => 0 मिलते हैं।

(एक रजिस्टर स्तर पर ! ऑपरेटर नहीं किया गया है, और आप बस हालत कोड या झंडे रजिस्टर के "शून्य बिट" का परीक्षण करते हैं, जो सेट हो जाता है यदि रजिस्टर ऑपरेशन शून्य का परिणाम उत्पन्न करता है, और स्पष्ट है । अन्यथा)

Answer 4

इस

int equal(int x, int y){ 
    if((x & ~y) == 0) 
     return 1; 
    else 
     return 0; 
} 

स्पष्टीकरण पर लेने के लिए मेरे: x == y, तो x & ~y0 वापसी 1, और वापसी 0 x!=y के रूप में करने के लिए मूल्यांकन करता है।

Edit1: The above is equivalent to 

int equal(int x, int y){ 
    return !(x & ~y) ; // returns 1 if equal , 0 otherwise. 
} 

ऊपर कोड कुछ मामलों में सबसे महत्वपूर्ण बिट 1. में बदल जाता है समाधान जोड़ने के लिए एक 1. यानी सही जवाब

return !(x & (~y +1)); 

Answer 5

है सी ! ऑपरेटर वास्तव में सिर्फ आशुलिपि है है में विफल रहता है != 0 के लिए, इसलिए इसका उपयोग धोखाधड़ी के बहुत करीब लगता है :)

यहां मेरी बिट लेफ्ट ऑपरेशंस का उपयोग कर लिया गया है, जिसमें 32-बिट दो पूरक मशीन को अंकगणितीय दाएं बदलावों के साथ माना जाता है (तकनीकी रूप से, सी अंकगणितीय दाएं बदलावों में अपरिभाषित हैं, लेकिन हर सी संकलक मैंने कभी एक दो के पूरक मशीन पर देखा है सही ढंग से इस का समर्थन करता है):

int t = (x - y) | (y - x); // <0 iff x != y, 0 otherwise 
t >>= 31; // -1 iff x != y, 0 otherwise 
return 1 + t; // 0 iff x != y, 1 otherwise 

जिसके अनुसार, वास्तविक compilers इस समस्या नहीं है। असली हार्डवेयर वास्तव में तुलना के लिए सीधा समर्थन है। विवरण वास्तुकला पर निर्भर करते हैं, लेकिन वहाँ दो बुनियादी मॉडल है:

1. स्थिति कोड अंकगणितीय आपरेशनों के लिए लौट आए (जैसे x86 और एआरएम ऐसा करने)। इस मामले में, आमतौर पर एक "तुलना" निर्देश होता है जो दो मानों को घटाता है, एक पूर्णांक रजिस्टर पर वापस नहीं लिखता है बल्कि परिणाम के आधार पर स्थिति कोड/झंडे सेट करता है।

2. अधिक आरआईएससी-जैसे प्लेटफार्मों में आमतौर पर "शाखा अगर बराबर" होती है और परिणामस्वरूप कम से कम शाखा होती है जो परिणाम के आधार पर तुलना और शाखा करता है। यह मूल रूप से सी कोड

   if (a == b) goto label; 
   

   या

   if (a < b) goto label; 
   

   सभी में एक मशीन अनुदेश के बराबर है।

Answer 6

XOR के रूप में, (x^y) 0 वापस आ जाएगी केवल बराबर मूल्यों के लिए के रूप में (! =) एक ही है इसलिए। मेरा लेना निम्नलिखित है क्योंकि यह समझदार है, बिट-वार ऑपरेटर का उपयोग करता है और काम करता है।

int notEqual(int x, int y){ 
     return (x^y); 
}