பிட்வைஸ் செயல்பாடுகள், பகுதி 2

1. பிட்வைஸ் இடது ஷிஃப்ட்

ஜாவாவில் 3 பிட்வைஸ் ஷிப்ட் ஆபரேட்டர்கள் உள்ளன : உங்களுக்கு உண்மையிலேயே தேவைப்பட்டால், ஒரு எண்ணின் அனைத்து பிட்களையும் பல நிலைகளில் இடது அல்லது வலது பக்கம் மாற்றலாம்.

ஒரு எண்ணின் பிட்களை இடதுபுறமாக மாற்ற, உங்களுக்கு பிட்வைஸ் லெப்ட் ஷிப்ட் ஆபரேட்டர் தேவை . இது எழுதப்பட்ட விதம்:

a << b

aபிட்கள் மாற்றப்படும் எண் எங்கே, மற்றும் எண்ணின் bபிட்களை எத்தனை முறை aஇடதுபுறமாக மாற்ற வேண்டும் என்பதைக் குறிக்கும் எண். இந்த செயல்பாட்டின் போது, ​​வலதுபுறத்தில் சேர்க்கப்படும் குறைந்த-வரிசை பிட்கள் பூஜ்ஜியங்களாகும்.

எடுத்துக்காட்டுகள்:

0b00000011 << 1

0b00000110

0b00000011 << 2

0b00001100

0b00000011 << 5

0b01100000

0b00000011 << 20

0b001100000000000000000000

ஒரு இலக்கத்தை இடதுபுறமாக மாற்றுவது ஒரு எண்ணை 2 ஆல் பெருக்குவது போன்ற விளைவைக் கொடுக்கும்.

ஒரு எண்ணை 16 ஆல் பெருக்க வேண்டுமா? ^{16 என்பது 2 4} க்கு சமம் . எனவே நீங்கள் எண் 4 இலக்கங்களை இடதுபுறமாக மாற்றவும்

2. பிட்வைஸ் வலதுபுறம் மாற்றவும்

பிட்களையும் வலதுபுறமாக மாற்றலாம். இதைச் செய்ய, பிட்வைஸ் ரைட் ஷிப்ட் ஆபரேட்டரைப் பயன்படுத்தவும் . இது எழுதப்பட்ட விதம்:

a >> b

aபிட்கள் மாற்றப்படும் எண் எங்கே, அந்த எண்ணின் பிட்களை வலப்புறமாக bமாற்ற வேண்டிய எண்ணிக்கை .a

எடுத்துக்காட்டுகள்:

0b11000011 >> 1

0b01100001

0b11000011 >> 2

0b00110000

0b11000011 >> 5

0b00000110

0b11000011 >> 20

0b00000000

ஒரு இலக்கத்தை வலப்புறமாக மாற்றுவது ஒரு எண்ணை 2 ஆல் வகுக்கும் அதே விளைவை ஏற்படுத்தும்.

இந்த செயல்பாட்டின் போது, ​​இடதுபுறத்தில் சேர்க்கப்பட்ட உயர்-வரிசை பிட்கள் பூஜ்ஜியங்களாக இருக்கும், ஆனால் எப்போதும் இல்லை !

ஒரு எண்ணின் பிட்களை வலது பக்கம் மாற்றும் போது, ​​சைன் பிட்டின் மதிப்பும் சாதாரணமாக மாறி, எண்ணின் அடையாளம் இழக்கப்படும். அதன்படி, எதிர்மறை எண்களுக்கு (இடதுபுற பிட் இருக்கும் இடத்தில் 1), இந்த பிட் சிறப்பு சிகிச்சையைப் பெறுகிறது. ஒரு எண்ணின் பிட்களை வலப்புறமாக மாற்றும்போது, 0​​இடதுபுறத்தில் உள்ள பிட் என்றால் இடதுபுறத்தில் a சேர்க்கப்படும் 0, மேலும் 1இடதுபுறத்தில் பிட் இருந்தால் இடதுபுறத்தில் a சேர்க்கப்படும் 1.

ஆனால் மேலே உள்ள எடுத்துக்காட்டில், அதன் விளைவாகத் தெரியவில்லை. ஏன்? ஏனெனில் முழு எண் எழுத்துகள் ints, மற்றும்  உண்மையில் பொருள் . அதாவது, இடதுபுறத்தில் உள்ள பிட் பூஜ்ஜியமாகும்.0b111111110b00000000000000000000000011111111

பல புரோகிராமர்கள் இந்த ரைட்-ஷிஃப்ட் நடத்தையால் விரக்தியடைந்துள்ளனர் மற்றும் எண்ணை எப்போதும் பூஜ்ஜியங்களுடன் பேட் செய்ய விரும்புகிறார்கள். எனவே ஜாவா மற்றொரு வலது ஷிப்ட் ஆபரேட்டரைச் சேர்த்தது .

இது எழுதப்பட்ட விதம்:

a >>> b

a பிட்கள் மாற்றப்படும் எண் எங்கே, அந்த எண்ணின் பிட்களை வலப்புறமாக b  மாற்ற வேண்டிய எண்ணிக்கை . aஎண்ணின் சைன் பிட்டின் அசல் மதிப்பைப் பொருட்படுத்தாமல், இந்த ஆபரேட்டர் எப்போதும் இடதுபுறத்தில் பூஜ்ஜியங்களைச் சேர்க்கும் a.

3. கொடிகளுடன் வேலை செய்தல்

புரோகிராமர்கள் பிட்வைஸ் மற்றும் ஷிப்ட் செயல்பாடுகளின் அடிப்படையில் முற்றிலும் புதிய ஆய்வுத் துறையை உருவாக்கினர்: கொடிகளுடன் பணிபுரிகின்றனர்.

கணினிகள் மிகக் குறைந்த நினைவகத்தைக் கொண்டிருந்தபோது, ​​ஒரே எண்ணில் பல தகவல்களைக் குவிப்பது மிகவும் பிரபலமாக இருந்தது. ஒரு எண் பிட்களின் வரிசையாகக் கருதப்படுகிறது: ஒரு எண்ணானது 32 பிட்கள், மற்றும் நீளமானது 64 பிட்கள்.

அத்தகைய எண்ணில் நீங்கள் நிறைய தகவல்களை எழுதலாம், குறிப்பாக நீங்கள் தருக்க ( trueஅல்லது false) மதிப்புகளை சேமிக்க வேண்டும் என்றால். ஒரு ஒற்றை என்பது 64 தனிமங்களைக் கொண்ட வரிசை longபோன்றது . இந்த பிட்கள் கொடிகள்boolean என்று அழைக்கப்பட்டன மற்றும் பின்வரும் செயல்பாடுகளைப் பயன்படுத்தி கையாளப்பட்டன:

• அமைக்க கொடி
  (ஒரு குறிப்பிட்ட பிட்டை சமமாக உருவாக்கவும் 1)
• கொடியை மீட்டமை
  (ஒரு குறிப்பிட்ட பிட்டை சமமாக உருவாக்கவும் 0)
• சோதனை கொடி
  (குறிப்பிட்ட பிட்டின் மதிப்பைச் சரிபார்க்கவும்)

பிட்வைஸ் ஆபரேட்டர்களில் இது எவ்வாறு செய்யப்படுகிறது என்பது இங்கே.

ஒரு கொடியை அமைத்தல்

ஒரு குறிப்பிட்ட பிட்டை க்கு அமைக்க 1, நீங்கள் அமைக்க விரும்பும் பிட் எண் மற்றும் சிறப்பாக உருவாக்கப்பட்ட எண்ணுக்கு இடையே பிட்வைஸ் அல்லது செயல்பாட்டைச் செய்ய வேண்டும், அந்த பிட் மட்டும் இருக்கும் இடத்தில் 1.

எடுத்துக்காட்டாக, உங்களிடம் எண் உள்ளது என்று வைத்துக்கொள்வோம் 0b00001010, நீங்கள் 5வது பிட்டை க்கு அமைக்க வேண்டும் 1. அந்த வழக்கில், நீங்கள் செய்ய வேண்டியது:

0b00001010 | 0b00010000 = 0b00011010

5 வது பிட் ஏற்கனவே ஒன்று அமைக்கப்பட்டிருந்தால், எதுவும் மாறாது.

பொதுவாக, ஒரு கொடியை அமைப்பதற்கான செயல்பாட்டை பின்வருமாறு எழுதலாம்

a | (1 << b)

a பிட் அமைக்கப்படும் எண் எங்கே 1. மற்றும் b அமைக்கப்பட வேண்டிய பிட்டின் நிலை. இடது ஷிப்ட் ஆபரேட்டரைப் பயன்படுத்துவது இங்கே மிகவும் வசதியானது, ஏனெனில் நாங்கள் எந்த பிட்டுடன் வேலை செய்கிறோம் என்பதை நீங்கள் உடனடியாகச் சொல்லலாம்.

ஒரு கொடியை மீட்டமைத்தல்

மற்ற பிட்களுக்கு இடையூறு இல்லாமல் ஒரு குறிப்பிட்ட பிட்டை (அதாவது அதை அமைக்கவும்) மீட்டமைக்க , நீங்கள் எந்த பிட் மீட்டமைக்க விரும்புகிறீர்களோ (அதாவது க்கு அமைக்கவும்) மற்றும் பிரத்யேகமாக உருவாக்கப்பட்ட எண்ணுக்கு இடையே 0ஒரு செயல்பாட்டைச் செய்ய வேண்டும் , அங்கு அனைத்து பிட்களும் சமமாக இருக்கும் . நீங்கள் மீட்டமைக்க விரும்பும் பிட்டுக்கு.&01

எடுத்துக்காட்டாக, உங்களிடம் எண் உள்ளது என்று வைத்துக்கொள்வோம் 0b00001010, நீங்கள் 4வது பிட்டை க்கு அமைக்க வேண்டும் 0. அந்த வழக்கில், நீங்கள் செய்ய வேண்டியது:

0b00001010 & 0b11110111 = 0b00000010

4 வது பிட் ஏற்கனவே பூஜ்ஜியமாக அமைக்கப்பட்டிருந்தால், எதுவும் மாறாது.

பொதுவாக, ஒரு கொடியை மீட்டமைக்கும் செயல்பாட்டை பின்வருமாறு எழுதலாம்

a & ~(1 << b)

a பிட் க்கு மீட்டமைக்கப்படும் எண் எங்கே 0. மேலும் b அது அழிக்கப்பட வேண்டிய பிட்டின் நிலையாகும்.

நாம் பூஜ்ஜியமாக இருக்க விரும்பும் பிட்களைத் தவிர அனைத்து பிட்களும் இருக்கும் எண்ணைப் பெற , முதலில் 1 பி  நிலைகளை இடதுபுறமாக 1மாற்றுவோம் , பின்னர் பிட்வைஸ் ஆபரேட்டரைப் பயன்படுத்தி முடிவை மாற்றுவோம்.NOT

ஒரு கொடியை சரிபார்க்கிறது

குறிப்பிட்ட கொடியை அமைப்பது அல்லது மீட்டமைப்பது தவிர, சில நேரங்களில் கொடுக்கப்பட்ட கொடி அமைக்கப்பட்டுள்ளதா, அதாவது ஒரு குறிப்பிட்ட பிட் சமமாக உள்ளதா என்பதைச் சரிபார்க்க வேண்டும் 1. பிட்வைஸ் மூலம் இதைச் செய்வது மிகவும் எளிதானது &.

1எடுத்துக்காட்டாக, எண்ணில் 4வது பிட் அமைக்கப்பட்டுள்ளதா என்பதை நீங்கள் சரிபார்க்க வேண்டும் என்று வைத்துக்கொள்வோம் 0b00001010. பின்னர் நீங்கள் இதைச் செய்ய வேண்டும்:

if ( (0b00001010 & 0b00001000) == 0b00001000 )

பொதுவாக, ஒரு கொடியை சரிபார்க்கும் செயல்பாட்டை பின்வருமாறு எழுதலாம்

(a & (1 << b)) == (1 << b)

a பிட் சரிபார்க்கப்படும் எண் எங்கே . மற்றும் b சரிபார்க்க வேண்டிய பிட்டின் நிலை.

4. குறியாக்கம்

பிட்வைஸ் XORசெயல்பாடு பெரும்பாலும் எளிய குறியாக்கத்திற்காக புரோகிராமர்களால் பயன்படுத்தப்படுகிறது. பொதுவாக, அத்தகைய குறியாக்கம் இதுபோல் தெரிகிறது:

result = number ^ password;

number நாம் குறியாக்கம் செய்ய விரும்பும் தரவு எங்குள்ளது, இது password தரவுக்கான "கடவுச்சொல்லாக" பயன்படுத்தப்படும் ஒரு சிறப்பு எண், மேலும் result இது மறைகுறியாக்கப்பட்ட எண்ணாகும்.

number == (number ^ password) ^ password;

இங்கே முக்கியமான விஷயம் என்னவென்றால், XORஆபரேட்டர் ஒரு எண்ணுக்கு இரண்டு முறை பயன்படுத்தப்படும் போது, ​​அது "கடவுச்சொல்" எதுவாக இருந்தாலும், அசல் எண்ணை உருவாக்குகிறது.

number இலிருந்து மீட்க encrypted result, நீங்கள் மீண்டும் செயல்பாட்டைச் செய்ய வேண்டும்:

original number = result ^ password;

உதாரணமாக:

class Solution
{
   public static int[] encrypt(int[] data, int password)
   {
     int[] result = new int[data.length];
     for (int i = 0; i <  data.length; i++)
       result[i] = data[i] ^ password;
     return result;
   }

   public static void main(String[] args)
   {
     int[] data =  {1, 3, 5, 7, 9, 11};
     int password = 199;

     // Encrypt the array of data
     int[] encrypted = encrypt(data, password);
     System.out.println(Arrays.toString(encrypted));

     // Decrypt the array of data
     int[] decrypted = encrypt(encrypted, password);
     System.out.println(Arrays.toString(decrypted));
   }
}