मैं एक मनमाना 8 बिट द्विआधारी संख्या जैसे, 11101101एक बाइट में बिट्स की जोड़ी गमागमन
मैं की तरह बिट्स के सभी जोड़ी स्वैप करने के लिए है है:
अदला-बदली से पहले: 11-10-11-01 अदला-बदली के बाद : 11-01-11-10
मुझे यह एक साक्षात्कार में पूछा गया था!
छद्म कोड में:
x = ((x & 0b10101010) >> 1) | ((x & 0b01010101) << 1)
यह अलग से कम बिट और प्रत्येक बिट-जोड़ी के उच्च बिट्स से निपटने और उसके बाद के संयोजन परिणाम से काम करता है:
x & 0b10101010 उच्च अर्क प्रत्येक जोड़ी से थोड़ा, और फिर >> 1 इसे कम बिट स्थिति में बदल देता है।(x & 0b01010101) << 1 प्रत्येक जोड़ी से कम बिट निकालती है और इसे उच्च बिट स्थिति में स्थानांतरित करती है।के बाद से नहीं सभी भाषाओं आप द्विआधारी शाब्दिक सीधे लिखने की अनुमति है, तो उन्हें उदाहरण हेक्साडेसिमल के लिए लिख सकते हैं:
Binary Hexadecimal Decimal 0b10101010 0xaa 170 0b01010101 0x55 85
पर प्रश्न का उत्तर नहीं देता है यह देखते हुए कि सभी भाषा पैटर्न 0b का सम्मान नहीं करते हैं ..., शायद यह ध्यान देने योग्य है कि यह क्रमश: 0xAA और 0x55 हेक्स में है। – userx
@userx: +1 हां, यह निश्चित रूप से ध्यान देने योग्य है। जोड़ा गया। –
धन्यवाद मार्क। भयानक विधि है! – RaviPathak
b = (a & 170 >> 1) | (a & 85 << 1)
को लागू करने के लिए तंत्र की आवश्यकता है यह पूरी तरह से पढ़ा जा सकता है; यह भी, किनारे के मामलों के लिए अक्षम और गलत भी है। दो से विभाजित नकारात्मक संख्याओं के लिए एक-बिट दाएं शिफ्ट के बराबर नहीं है। – tdammers
tdammers उत्तर के समान ही है लेकिन यह क्लीनर और स्पष्ट रूप से बाइनरी है, जबकि आप दशमलव संख्याओं का उपयोग करते हैं। – vulkanino
-1 बहुत अपठनीय – Tomas
मैं पहली बार यह कोड होगा 'पूरे अक्षरों में लिखावट' - कि कई स्पष्ट, स्पष्ट चरणों में कहते हैं, और का उपयोग करें कि मान्य करने के लिए है कि इकाई परीक्षण जगह में मैं था सही ढंग से कार्य कर रहे थे, और उसके बाद ही अधिक करने के लिए स्थानांतरित करने के लिए है गूढ़ बिट मैनिपुलेशन समाधान अगर मुझे प्रदर्शन की आवश्यकता थी (और उस अतिरिक्त प्रदर्शन को सुधार के द्वारा दिया गया था)
लोगों के लिए कोड पहले, कंप्यूटर दूसरे।
-1 जो सभी – Tomas
10101010 और 01010101)।16 बिट्स (वास्तविक नहीं कोड) के लिए उदाहरण:
short swap_bit_pair(short i) {
return ((i & 0101010110101010b) >> 1) | ((i & 0x0101010101010101b) << 1));
}
उम .. मुझे लगता है कि 0x010101010 के बजाय 0xAA का मतलब है (0xAA बाइनरी में 10101010 है) और 0x01010101 के बजाय 0x55। वैसे भी एक बाइट के लिए। एक संक्षिप्त के लिए क्रमशः 0xAAAA और 0x5555। – userx
हाँ, इसके बजाय पहले से ही बाइनरी का उपयोग करने के लिए सी-जैसे छद्म कोड संपादित किया गया है। मूल प्रश्न 8 बिट्स को वैसे भी बताता है, इसलिए ... – tdammers
सबसे सुंदर और लचीला समाधान है, जैसा कि अन्य लोगों, ने कहा है कि दोनों भी और अजीब बिट्स के लिए एक 'कंघी' मुखौटा लागू करने के लिए अलग-अलग और फिर, उन्हें क्रमशः बाएं और दाएं स्थानांतरित कर दिया गया ताकि उन्हें बिटवॉइड का उपयोग करके गठबंधन किया जा सके।
एक अन्य समाधान जिसे आप सोचना चाहते हैं, आपके डेटाटाइप के अपेक्षाकृत छोटे आकार का लाभ उठाता है।
const unsigned char lookup[] = { 0x02, 0x01, 0x03, 0x08, 0x0A, 0x09, 0x0B ...
प्रत्येक मान सरणी में रखा गया है सूचकांक के परिवर्तन का प्रतिनिधित्व करने के: आप 256 मूल्यों जो स्थिर मूल्यों आप आउटपुट के रूप में अपने इनपुट करना चाहते हैं initialised है की एक तालिका को देखने बना सकते हैं। तो अगर आप तो ऐसा करते हैं:
unsigned char out = lookup[ 0xAA ];
out0x55
यह अधिक बोझिल और पहली दृष्टिकोण से कम लचीला है में शामिल होंगे (क्या आप 8 बिट से 16 ले जाना चाहते हैं?), लेकिन है इन परिचालनों की बड़ी संख्या में प्रदर्शन करते समय यह दृष्टिकोण तेजी से तेज़ होगा।
मान लीजिए कि आपका नंबर num है।
पहले भी स्थिति सा लगता है:
num & oxAAAAAAAA
दूसरा कदम अजीब स्थिति सा लगता है:
num & ox55555555
3 कदम परिवर्तन स्थिति अजीब स्थिति के लिए भी स्थिति बिट और अजीब स्थिति के लिए भी स्थिति बिट बिट:
Even = (num & oxAAAAAAAA)>>1
Odd = (num & 0x55555555)<<1
अंतिम चरण ... result = Even | Odd
प्रिंट परिणाम
क्या सवाल? – JamesM
अगर मैंने आपको उलझन में दिया तो पहले जवाब के लिए खेद है। मैं गलत से पहले/बाद में पूरी तरह से पढ़ता हूं। – colithium
@JamesM: क्षमा करें, अगर यह स्पष्ट नहीं है लेकिन सवाल यह है: एक बाइट में, उदाहरण के लिए बिट्स को जोड़ दें, अगर बाइट 10101100 है तो बिट्स को जोड़ना - 10 - 10 - 11 - 00' जैसा दिखता है। अब, अगर हम अलग-अलग जोड़े को स्वैप करते हैं, तो यह बन जाएगा - '01 - 01 - 11 - 00'। मुझे स्वैपिंग – RaviPathak