బిట్‌వైజ్ ఆపరేషన్‌లు, పార్ట్ 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ఎడమవైపు బిట్ అయితే ఎడమవైపున జోడించబడుతుంది 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. ఇది బిట్‌వైజ్‌తో చేయడం చాలా సులభం &.

ఉదాహరణకు, మీరు 4వ బిట్ 1సంఖ్యకు సెట్ చేయబడిందో లేదో తనిఖీ చేయాలి 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));
   }
}