सी अप्रतिबंधित पूर्णांक

Question

में सी रिवर्स बिट्स मैं बिटवाई ऑपरेटरों का उपयोग करके बाइनरी में एक हस्ताक्षरित पूर्णांक को परिवर्तित कर रहा हूं, और वर्तमान में बिट 0 या 0 और आउटपुट की जांच करने के लिए पूर्णांक & 1 पूर्ण करता है, फिर 2 से विभाजित करने के लिए दाएं स्थानांतरित करें। हालांकि बिट्स को गलत क्रम (रिवर्स) में वापस कर दिया जाता है, इसलिए मैंने शुरुआत से पहले पूर्णांक में बिट्स ऑर्डर को उलट दिया।

क्या ऐसा करने का कोई आसान तरीका है?

उदाहरण: तो अगर मैं दिया हूँ अहस्ताक्षरित पूर्णांक 10 = 1010

while (x not eq 0) 
    if (x & 1) 
    output a '1' 
    else 
    output a '0' 
    right shift x by 1 

इस रिटर्न 0101 जो सही नहीं है ... इसलिए मैं बिट्स के क्रम को उल्टा करने के लिए सोच रहा था मूल रूप से पहले से चल रहा है लूप, लेकिन मुझे यकीन नहीं है कि यह कैसे करें?

Answer 1

किसी शब्द में बिट्स को उलटना परेशान है और इसे रिवर्स ऑर्डर में आउटपुट करना आसान है। उदाहरण के लिए,

void write_u32(uint32_t x) 
{ 
    int i; 
    for (i = 0; i < 32; ++i) 
     putchar((x & ((uint32_t) 1 << (31 - i)) ? '1' : '0'); 
} 

यहाँ सा आदेश को पलटने के लिए ठेठ समाधान है:

uint32_t reverse(uint32_t x) 
{ 
    x = ((x >> 1) & 0x55555555u) | ((x & 0x55555555u) << 1); 
    x = ((x >> 2) & 0x33333333u) | ((x & 0x33333333u) << 2); 
    x = ((x >> 4) & 0x0f0f0f0fu) | ((x & 0x0f0f0f0fu) << 4); 
    x = ((x >> 8) & 0x00ff00ffu) | ((x & 0x00ff00ffu) << 8); 
    x = ((x >> 16) & 0xffffu) | ((x & 0xffffu) << 16); 
    return x; 
} 

Answer 2

आप सही बजाय बाईं से चला जाता, कि करने के लिए MSB से एक एक बदलाव है LSB, उदाहरण के लिए:

unsigned n = 20543; 
unsigned x = 1<<31; 
while (x) { 
    printf("%u ", (x&n)!=0); 
    x = x>>1; 
} 

Answer 3

आप की तरह आप उन्हें उत्पादन बिट्स रिवर्स सकता है, और इसके बजाय उन्हें एक अन्य पूर्णांक में स्टोर, और इसे फिर से कार्य करें:

आप प्रमुख निकालना चाहते हैं

unsigned int mask = 1 << ((sizeof(unsigned int) * CHAR_BIT) - 1); 
while (mask > 0) 
{ 
    bit = original_int & mask; 
    mask = mask >> 1; 
    printf("%d", (bit > 0)); 
} 

0 के आप या तो इंतजार एक 1 मुद्रित करने के लिए के लिए, या एक प्रारंभिक जाने के माध्यम से कर सकते हैं:

for (i = 0; i < (sizeof(unsigned int) * CHAR_BIT); i++) 
{ 
    new_int |= (original_int & 1); 
    original_int = original_int >> 1; 
    new_int = new_int << 1; 
} 

या आप बस विपरीत कर सकता है, अपने मुखौटे बदलाव:

unsigned int mask = 1 << ((sizeof(unsigned int) * CHAR_BIT) - 1); 
while ((mask > 0) && ((original_int & mask) == 0)) 
    mask = mask >> 1; 
do 
{ 
    bit = original_int & mask; 
    mask = mask >> 1; 
    printf("%d", (bit > 0)); 
} while (mask > 0); 

इस तरह से आप पहली बार 1 पर मुखौटा स्थापित करेंगे मुद्रित करने के लिए जा और अग्रणी 0 के

के बारे में भूल लेकिन याद रखें: एक पूर्णांक के बाइनरी मान मुद्रण बस किया जा सकता है printf

Answer 4

आप बिट्स के माध्यम से बड़े अंत से थोड़ा अंत तक लूप कर सकते हैं।

#define N_BITS (sizeof(unsigned) * CHAR_BIT) 
#define HI_BIT (1 << (N_BITS - 1)) 

for (int i = 0; i < N_BITS; i++) { 
    printf("%d", !!(x & HI_BIT)); 
    x <<= 1; 
} 

कहाँ !! भी !=0 या >> (N_BITS - 1) लिखा जा सकता है।

Answer 5

unsigned int rev_bits(unsigned int input) 
{ 
    unsigned int output = 0; 
    unsigned int n = sizeof(input) << 3; 
    unsigned int i = 0; 

    for (i = 0; i < n; i++) 
     if ((input >> i) & 0x1) 
      output |= (0x1 << (n - 1 - i)); 

    return output; 
} 

Answer 6

मैं ऐसे समाधान के साथ आया जिसने बिटवाई ऑपरेटरों के किसी भी एप्लिकेशन को शामिल नहीं किया है। यह अंतरिक्ष और समय दोनों के मामले में अक्षम है।

int arr[32]; 
for(int i=0;i<32;i++) 
{ 
    arr[i]=A%2; 
    A=A/2; 
} 
double res=1; 
double re=0; 
for(int i=0;i<32;i++) 
{ 
    int j=31-i; 
    res=arr[i]; 
    while(j>0) 
    { 
     res=res*2; 
     j--; 
    } 
    re=re+res; 
} 
cout<<(unsigned int)re; 

Answer 7

कोई भी पूर्णांक में रिवर्स बिट्स का गोलांग संस्करण है, अगर कोई एक की तलाश में है। मैंने इसे सी में स्ट्रिंग रिवर्स के समान दृष्टिकोण के साथ लिखा था। 0 से 15 (31/2) बिट्स पर जाकर, थोड़ा सा (31-i) के साथ थोड़ा सा स्वैप करें। कृपया निम्नलिखित कोड जांचें।

package main 
import "fmt" 

func main() { 
    var num = 2 
    //swap bits at index i and 31-i for i between 0-15 
    for i := 0; i < 31/2; i++ { 
     swap(&num, uint(i)) 
    } 
    fmt.Printf("num is %d", num) 
} 

//check if bit at index is set 
func isSet(num *int, index uint) int { 
    return *num & (1 << index) 
} 

//set bit at index 
func set(num *int, index uint) { 
    *num = *num | (1 << index) 
} 

//reset bit at index 
func reSet(num *int, index uint) { 
    *num = *num & ^(1 << index) 
} 

//swap bits on index and 31-index 
func swap(num *int, index uint) { 
    //check index and 31-index bits 
    a := isSet(num, index) 
    b := isSet(num, uint(31)-index) 
    if a != 0 { 
     //bit at index is 1, set 31-index 
     set(num, uint(31)-index) 
    } else { 
     //bit at index is 0, reset 31-index 
     reSet(num, uint(31)-index) 
    } 
    if b != 0 { 
     set(num, index) 
    } else { 
     reSet(num, index) 
    } 
}` 

Answer 8

आप एक unsigned 32-bit integer रिवर्स और निम्नलिखित reverse फंक्शन का उपयोग करके लौट सकते हैं:

unsigned int reverse(unsigned int A) { 
    unsigned int B = 0; 
    for(int i=0;i<32;i++){ 
     unsigned int j = pow(2,31-i); 
     if((A & (1<<i)) == (1<<i)) B += j; 
    } 
return B; 
} 

गणित पुस्तकालय शामिल करना न भूलें। हैप्पी कोडिंग :)

Answer 9

मेरा मानना ​​है कि सवाल यह पूछ रहा है कि रिवर्स ऑर्डर में आउटपुट कैसे करें।

मज़ा जवाब (प्रत्यावर्तन):

#include <stdio.h> 

void print_bits_r(unsigned int x){ 
    if(x==0){ 
     printf("0"); 
     return; 
    } 
    unsigned int n=x>>1; 
    if(n!=0){ 
     print_bits_r(n); 
    } 
    if(x&1){ 
     printf("1"); 
    }else{ 
     printf("0"); 
    } 
} 


void print_bits(unsigned int x){ 
    printf("%u=",x); 
    print_bits_r(x); 
    printf("\n"); 
} 

int main(void) { 
    print_bits(10u);//1010 
    print_bits((1<<5)+(1<<4)+1);//110001 
    print_bits(498598u);//1111001101110100110 
    return 0; 
} 

अपेक्षित उत्पादन:

10=1010 
49=110001 
498598=1111001101110100110 

अनुक्रमिक संस्करण (बंद उठाता पहली उच्च बिट):

#include <limits.h>//Defines CHAR_BIT 
//.... 
void print_bits_r(unsigned int x){ 
    //unsigned int mask=(UINT_MAX>>1)+1u;//Also works... 
    unsigned int mask=1u<<(CHAR_BIT*sizeof(unsigned int)-1u); 
    int start=0; 
    while(mask!=0){ 
     if((x&mask)!=0){ 
      printf("1"); 
      start=1; 
     }else{ 
      if(start){ 
       printf("0"); 
      } 
     } 
     mask>>=1; 
    } 
    if(!start){ 
     printf("0"); 
    }  
}