நடைமுறை பயன்பாடு (பிட் முகமூடிகள், ...)

"வணக்கம், அமிகோ!"

"நான் பிட்மாஸ்க் மற்றும் 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)" போன்ற பயங்கரமான வெளிப்பாடுகளை நீங்கள் சந்தித்தால், அவர் ஒரு பிட்மாஸ்க் மூலம் வேலை செய்கிறார் என்பதை நீங்கள் அறிவீர்கள்."

"நீங்கள் அதை அடிக்கடி சந்தித்தால், அது உங்களுக்காக தன்னை நினைவில் கொள்ளும்."

"நினைவில் கொள்ளுங்கள்... அது நன்றாக இருக்கிறது. பாடத்திற்கு நன்றி."