ప్రాక్టికల్ అప్లికేషన్ (బిట్ మాస్క్‌లు, …)

"హాయ్, అమిగో!"

"నేను బిట్‌మాస్క్‌లు మరియు XOR గురించి కూడా మాట్లాడాలనుకుంటున్నాను."

"సంఖ్యలు బిట్‌లను కలిగి ఉంటాయని మరియు మీరు ఈ బిట్‌లపై వివిధ కార్యకలాపాలను నిర్వహించవచ్చని మీకు ఇప్పటికే తెలుసు. బిట్‌మాస్క్ అనేది ఒకే పూర్ణాంకం వలె అనేక విభిన్న తార్కిక విలువలను (నిజమైన/తప్పుడు విలువలు) ప్రాతినిధ్యం వహిస్తుంది. ఈ సందర్భంలో, ప్రతి బూలియన్-విలువకు అనుగుణంగా ఉంటుంది ఒక నిర్దిష్ట బిట్. దీన్ని ఎలా చేయవచ్చో ఇక్కడ ఉంది:"

"రెండు (1, 2, 4, 8, 16, 32, ...) యొక్క శక్తుల బైనరీ ప్రాతినిధ్యం కేవలం ఒక బిట్‌ను మాత్రమే సెట్ చేస్తుంది:"

"కాబట్టి, ఏదైనా పూర్ణాంకం బిట్‌ల శ్రేణిగా లేదా బూలియన్ విలువల శ్రేణిగా పరిగణించబడుతుంది."

"ఒకే సంఖ్యలో వివిధ బూలియన్ విలువలను మీరు ఎలా నిల్వ చేయవచ్చో ఇక్కడ ఉంది:"

boolean a = true;
boolean b = false;
boolean c = true;
boolean d = false;

int result = 0;
 if (a) result += 1; // 1 == 20 — bit 0
 if (b) result += 2; // 2 == 21 — bit 1
 if (c) result += 4; // 4 == 22 — bit 2
 if (d) result += 8; // 8 == 23 — bit 3

"సంబంధిత బూలియన్ వేరియబుల్ నిజమైతే ఇప్పుడు ప్రతి బిట్ 1 అవుతుంది."

మా విషయంలో, వేరియబుల్స్ a మరియు c నిజమైనవి, కాబట్టి ఫలితం 1+4 == 5కి సమానం

0000 0101
0000 dcba

"ఏమి జరుగుతుందో నాకు తెలుసునని నేను అనుకుంటున్నాను."

"సరే, మీరు అర్థం చేసుకుంటే, ముందుకు వెళ్దాం."

"ఒక పూర్ణాంకానికి 32 బిట్‌లు ఉన్నాయి. వాటిలో ఒకటి సంఖ్య యొక్క గుర్తు కోసం ఉపయోగించబడుతుంది మరియు ఇతర 31 31 బూలియన్ వేరియబుల్స్ యొక్క విలువలను నిల్వ చేయడానికి ఉపయోగించవచ్చు."

"ఒక లాంగ్‌లో 64 బిట్‌లు ఉన్నాయి, ఇక్కడ మనం 63 బూలియన్ వేరియబుల్‌లను నిల్వ చేయవచ్చు."

"అవును."

"డజన్‌ల కొద్దీ వేరియబుల్‌లు ఒక సంఖ్యతో నిండిపోయాయి. ఇది చాలా కొన్ని."

"అయితే ఇది ఎక్కడ వర్తించబడుతుంది?"

"ప్రధానంగా మీరు వస్తువుల గురించి చాలా సమాచారాన్ని నిల్వ చేయాల్సిన సందర్భాలలో. మీరు ఒక వస్తువు గురించి చాలా సమాచారాన్ని నిల్వ చేసినప్పుడు, ఎల్లప్పుడూ రెండు డజన్ల బూలియన్ వేరియబుల్స్ ఉంటాయి. "ఈ విధానంతో, అవన్నీ సౌకర్యవంతంగా ఒకే సంఖ్యలో నిల్వ చేయబడతాయి. ."

"నిల్వ చేసిన పదానికి ప్రాధాన్యత ఇవ్వడంతో. వాస్తవానికి నంబర్‌ని ఉపయోగించడం అంత అనుకూలమైనది కాదు."

"అయితే, నేను అడగాలనుకున్నది అదే. సంఖ్య నుండి బూలియన్ విలువను ఎలా సంగ్రహించాలి?"

"ఇది సంక్లిష్టంగా ఏమీ లేదు. బిట్ 6 1కి సెట్ చేయబడిందో లేదో మీరు గుర్తించాలి అనుకుందాం (2 నుండి ఐదు పవర్ 32). మేము ఇలా తనిఖీ చేయవచ్చు:"

int a = 32; // 25 == 0010 0000
int b = 8; // 23 == 0000 1000
int c = 2; // 21 == 0000 0010

int result = a + b + c; // 32 + 8 + 2 == 42 == 0010 1010

int a = result & 32; // 0010 1010 & 0010 0000 = 0010 0000
int b = result & 8; // 0010 1010 & 0000 1000 = 0000 1000
int c = result & 2; // 0010 1010 & 0000 0010 = 0000 0010

"అందువలన, బిట్‌మాస్క్‌లతో పనిచేయడం మూడు కార్యకలాపాలను కలిగి ఉంటుంది:"

1)  నిర్దిష్ట బిట్‌ను 0కి సెట్ చేయండి

2)  నిర్దిష్ట బిట్‌ను 1కి సెట్ చేయండి

3)  నిర్దిష్ట బిట్ విలువను తనిఖీ చేయండి.

"ఉదాహరణకు బిట్ 6 తీసుకోండి."

"మీరు బిట్ 6 నుండి 1కి ఎలా సెట్ చేస్తారు?"

result = result | 01000000;
result |= 01000000;

result = result & 10111111;
result &= 10111111;

c = result & 01000000;

"అది చాలా అసాధారణమైనది, కానీ కష్టం కాదు. మనిషి, ఇప్పుడు నేను హాట్-షాట్ ప్రోగ్రామర్‌ని."

"మరియు 0 లేదా 1: 01000000 లేదా 10111111కి సెట్ చేయబడిన నిర్దిష్ట బిట్‌తో సంఖ్యలను సులభంగా ఎలా పొందాలనే దానిపై మరో చిన్న చిట్కా."

దీని కోసం, మాకు  >> మరియు  << ఆపరేటర్లు ఉన్నారు.

"1 అనేది సున్నా శక్తికి 2. మరో మాటలో చెప్పాలంటే, బిట్ 0తో 1కి సెట్ చేయబడిన సంఖ్య. మనకు బిట్ 6 సెట్‌తో కూడిన సంఖ్య అవసరం."

int c = 1 << 6; // 0000 0001 << 6 == 0100 0000 == 64

"కూల్! అలాంటి సందర్భాలలో ఇది నిజంగా ఉపయోగకరంగా ఉంటుంది."

"కానీ ఒక నిర్దిష్ట బిట్ 0కి సెట్ చేయబడితే తప్ప ప్రతి బిట్ 1కి సెట్ చేయబడిన సంఖ్య నాకు అవసరమైతే ఏమి చేయాలి?"

"అది కూడా కష్టం కాదు:"

int d = ~(1 << 6); // ~0100 0000 == 10111111

"మరో మాటలో చెప్పాలంటే, ఇది చాలా సులభం:"

result = result | (1 << 6);
result |= (1 << 6);

result = result & ~(1 << 6);
result &= ~(1 << 6);

c = result & (1 << 6);

"ఇది చాలా కష్టంగా అనిపించడం లేదు. కానీ నాకు వెంటనే గుర్తుకు రాదు."

"కానీ, మీరు వేరొకరి కోడ్‌లో "ఫలితం &= ~(1 << 6)" వంటి భయానక వ్యక్తీకరణను ఎదుర్కొంటే, ఈ వ్యక్తి కేవలం బిట్‌మాస్క్‌తో పని చేస్తున్నాడని మీకు తెలుస్తుంది."

"మరియు మీరు దానిని తరచుగా ఎదుర్కొంటే, అది మీ కోసం గుర్తుంచుకుంటుంది."

"గుర్తుంచుకో... బాగుంది కదూ. పాఠానికి ధన్యవాదాలు."