నంబర్ సిస్టమ్ – బైనరీ (Number Systems)

సంఖ్యలను రాయడానికి వాడే పద్ధతిని సంఖ్యా పద్ధతి (Number System) అంటారు. ప్రతి పద్ధతికి ఒక 'బేస్' లేదా 'రేడిక్స్' (Base/Radix) ఉంటుంది. బేస్ అంటే ఆ పద్ధతిలో వాడే మొత్తం అంకెల సంఖ్య.

• డెసిమల్ (Decimal) – బేస్ 10: అంకెలు 0 నుండి 9 వరకు (10 అంకెలు). మనం రోజూ వాడేది ఇదే.
• బైనరీ (Binary) – బేస్ 2: అంకెలు 0, 1 మాత్రమే. కంప్యూటర్ అర్థం చేసుకునే పద్ధతి. ప్రతి అంకెను 'బిట్' (Bit) అంటారు.
• ఆక్టల్ (Octal) – బేస్ 8: అంకెలు 0 నుండి 7 వరకు (8 అంకెలు). 8, 9 ఉండవు.
• హెక్సాడెసిమల్ (Hexadecimal) – బేస్ 16: అంకెలు 0–9 మరియు అక్షరాలు A–F (మొత్తం 16).
• A = 10, B = 11, C = 12, D = 13, E = 14, F = 15.
• స్థాన విలువ (Positional Value): ప్రతి అంకె విలువ దాని స్థానాన్ని బట్టి బేస్ యొక్క ఘాతం (power) గా మారుతుంది.
• డెసిమల్: ...1000, 100, 10, 1 (10³, 10², 10¹, 10⁰)
• బైనరీ: ...8, 4, 2, 1 (2³, 2², 2¹, 2⁰)
• సూచించే విధానం: బేస్‌ను చిన్న అంకెగా కింద రాస్తారు, ఉదా: (1011)₂, (25)₁₀, (17)₈, (2F)₁₆.
• కంప్యూటర్ ఎందుకు బైనరీ వాడుతుంది?: ఎలక్ట్రానిక్ సర్క్యూట్‌లో రెండు స్థితులే (స్విచ్ ఆన్ = 1, ఆఫ్ = 0) సులభంగా గుర్తించగలవు కాబట్టి.

డెసిమల్ సంఖ్యను బైనరీగా మార్చడానికి సులభ పద్ధతి 'రెండుతో భాగించడం' (Repeated Division by 2). భాగహారం చేస్తూ మిగిలిన శేషాలను (Remainders) నమోదు చేసి, కింద నుండి పైకి చదవాలి.

• పద్ధతి:
  1. సంఖ్యను 2 తో భాగించండి; శేషం (0 లేదా 1) రాయండి.
  2. భాగఫలాన్ని మళ్లీ 2 తో భాగించండి; భాగఫలం 0 అయ్యే వరకు కొనసాగించండి.
  3. శేషాలను కిందినుండి పైకి (చివరి శేషం నుండి మొదటి శేషం వరకు) చదవండి.
• ఉదాహరణ 1: (25)₁₀ → బైనరీ
• 25 ÷ 2 = 12, శేషం 1
• 12 ÷ 2 = 6, శేషం 0
• 6 ÷ 2 = 3, శేషం 0
• 3 ÷ 2 = 1, శేషం 1
• 1 ÷ 2 = 0, శేషం 1
• కింద నుండి పైకి: 11001. కాబట్టి (25)₁₀ = (11001)₂.
• ఉదాహరణ 2: (45)₁₀ → బైనరీ
• 45 ÷ 2 = 22 శేషం 1
• 22 ÷ 2 = 11 శేషం 0
• 11 ÷ 2 = 5 శేషం 1
• 5 ÷ 2 = 2 శేషం 1
• 2 ÷ 2 = 1 శేషం 0
• 1 ÷ 2 = 0 శేషం 1.
• చదవగా: 101101.
• షార్ట్‌కట్ పద్ధతి (2 యొక్క ఘాతాలు): 128, 64, 32, 16, 8, 4, 2, 1 వాడండి. 45 = 32 + 8 + 4 + 1 → ఆ స్థానాల్లో 1, మిగిలిన స్థానాల్లో 0 → 101101.
• తనిఖీ: 101101 = 32 + 0 + 8 + 4 + 0 + 1 = 45 ✓.

గుర్తుంచుకునే చిట్కా 2 యొక్క ఘాతాలు గుర్తుంచుకోండి: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024. ఇవి బైనరీ లెక్కలన్నిటికీ ఉపయోగపడతాయి.

బైనరీ సంఖ్యను డెసిమల్‌గా మార్చడం చాలా సులభం. ప్రతి అంకెను దాని స్థాన విలువ (2 యొక్క ఘాతం) తో గుణించి, అన్నీ కలపాలి.

• పద్ధతి: కుడివైపు చివరి అంకె నుండి స్థానాలు 2⁰, 2¹, 2², 2³... గా లెక్కించండి. 1 ఉన్న స్థానాల విలువలను మాత్రమే కూడండి.
• ఉదాహరణ 1: (1011)₂ → డెసిమల్
• 1×8 + 0×4 + 1×2 + 1×1 = 8 + 0 + 2 + 1 = 11.
• ఉదాహరణ 2: (11010)₂ → డెసిమల్
• 1×16 + 1×8 + 0×4 + 1×2 + 0×1 = 16 + 8 + 2 = 26.
• ఉదాహరణ 3: (1111)₂ → డెసిమల్
• 8 + 4 + 2 + 1 = 15. (4-బిట్ గరిష్ఠ విలువ 15)
• n బిట్లతో గరిష్ఠ విలువ:
  1. 2ⁿ − 1. అంటే 8 బిట్లతో గరిష్ఠం 255
  2. 4 బిట్లతో 15
  3. 16 బిట్లతో 65,535.
• n బిట్లతో సంఖ్యల సంఖ్య: 2ⁿ. 8 బిట్లతో 256 వేర్వేరు విలువలు (0 నుండి 255).
• కనీస బిట్లు: ఒక సంఖ్యను రాయడానికి కావలసిన బిట్ల సంఖ్య – 2 యొక్క ఘాతాన్ని చూసి కనుగొనవచ్చు. ఉదా: 13 కు 4 బిట్లు (1101).
• పూర్ణాంకం తర్వాత భిన్నం: బైనరీ పాయింట్ తర్వాత అంకెలకు 2⁻¹, 2⁻²... విలువలు (0.5, 0.25...). ఉదా: (0.1)₂ = 0.5.

గుర్తుంచుకునే చిట్కా కుడినుండి ఎడమకు 1, 2, 4, 8, 16, 32... అని పైన రాసుకొని, ఏ స్థానాల్లో 1 ఉందో అవి కూడండి.

ఆక్టల్, హెక్సాడెసిమల్ పద్ధతులు పొడవైన బైనరీ సంఖ్యలను చిన్నగా రాయడానికి వాడతారు. ఎందుకంటే 8 = 2³, 16 = 2⁴. అందుకే బైనరీతో వీటి మార్పిడి చాలా సులభం.

• బైనరీ → ఆక్టల్: బైనరీ అంకెలను కుడినుండి 3 చొప్పున గ్రూపులుగా విభజించి, ప్రతి గ్రూప్‌కు ఆక్టల్ అంకె రాయండి.
• ఉదా: (101110)₂ → 101 | 110 → 5 | 6 → (56)₈.
• ఆక్టల్ → బైనరీ: ప్రతి ఆక్టల్ అంకెను 3 బిట్లుగా రాయండి.
• ఉదా: (75)₈ → 7 = 111, 5 = 101 → (111101)₂.
• బైనరీ → హెక్సాడెసిమల్: కుడినుండి 4 చొప్పున గ్రూపులు.
• ఉదా: (10101111)₂ → 1010 | 1111 → A | F → (AF)₁₆.
• హెక్సాడెసిమల్ → బైనరీ: ప్రతి అంకెను 4 బిట్లుగా రాయండి.
• ఉదా: (2F)₁₆ → 2 = 0010, F = 1111 → (00101111)₂.
• హెక్సా → డెసిమల్: (2F)₁₆ = 2×16 + 15 = 47. (FF)₁₆ = 15×16 + 15 = 255.
• డెసిమల్ → హెక్సా (16 తో భాగించడం): (156)₁₀ → 156 ÷ 16 = 9 శేషం 12 (C) → (9C)₁₆.
• ఆక్టల్ → డెసిమల్: (17)₈ = 1×8 + 7 = 15.
• హెక్సాడెసిమల్ వాడకం: రంగుల కోడ్‌లు (HTML లో #FF0000 = ఎరుపు), మెమరీ చిరునామాలు, MAC అడ్రస్.

గుర్తుంచుకునే చిట్కా ఆక్టల్ = 3 బిట్ల గ్రూపులు (8 = 2³); హెక్సా = 4 బిట్ల గ్రూపులు (16 = 2⁴). కొన్నిసార్లు గ్రూప్ నింపడానికి ఎడమవైపు 0 లు చేర్చాలి.

బైనరీ లెక్కలు డెసిమల్ లెక్కల్లాగే ఉంటాయి, కానీ అంకెలు 0, 1 మాత్రమే కాబట్టి కొన్ని నియమాలు గుర్తుంచుకుంటే చాలు.

• బైనరీ కూడిక నియమాలు:
  1. 0 + 0 = 0
  2. 0 + 1 = 1
  3. 1 + 0 = 1
  4. 1 + 1 = 10 (అంటే 0 రాసి, 1 'క్యారీ' (Carry) చేయాలి)
  5. 1 + 1 + 1 = 11 (1 రాసి, 1 క్యారీ)
• బైనరీ తీసివేత నియమాలు:
  1. 0 − 0 = 0; 1 − 0 = 1; 1 − 1 = 0
  2. 0 − 1 = 1 (పక్క అంకె నుండి 1 'బారో' (Borrow) చేసుకోవాలి)
• ఉదాహరణ 1: 1011 + 110
• కుడినుండి:
  1. 1+0 = 1
  2. 1+1 = 10 → 0 రాసి 1 క్యారీ
  3. 0+1+1(క్యారీ) = 10 → 0 రాసి 1 క్యారీ
  4. 1+1(క్యారీ) = 10 → 0 రాసి 1 క్యారీ
  5. చివరి క్యారీ 1.
• ఫలితం: 10001. తనిఖీ: 11 + 6 = 17 = (10001)₂ ✓.
• ఉదాహరణ 2: 1101 − 101
• ఫలితం: 1000. తనిఖీ: 13 − 5 = 8 = (1000)₂ ✓.
• ఉదాహరణ 3: 111 + 1 = 1000 (7 + 1 = 8).
• బైనరీ గుణకారం:
  1. 1 × 1 = 1
  2. మిగిలినవి 0. బైనరీని ఎడమవైపు ఒక స్థానం జరిపితే 2 తో గుణించినట్టే.
• 1's కాంప్లిమెంట్ (1's Complement): బైనరీ సంఖ్యలో 0 లను 1 గా, 1 లను 0 గా మార్చడం. 2's కాంప్లిమెంట్ = 1's కాంప్లిమెంట్ + 1. రుణ సంఖ్యలను కంప్యూటర్లో నిల్వ చేయడానికి 2's కాంప్లిమెంట్ వాడతారు.

కంప్యూటర్ అక్షరాలు, అంకెలు, చిహ్నాలను నేరుగా నిల్వ చేయలేదు. ప్రతి అక్షరానికి ఒక సంఖ్య కోడ్ (బైనరీ రూపంలో) కేటాయిస్తారు. ఈ కోడింగ్ ప్రమాణాలు పరీక్షలకు ముఖ్యం.

• ASCII (American Standard Code for Information Interchange):
  1. ప్రామాణిక ASCII 7 బిట్లు వాడుతుంది → 2⁷ = 128 అక్షరాలు (0 నుండి 127).
  2. ఎక్స్‌టెండెడ్ ASCII 8 బిట్లు → 256 అక్షరాలు.
  3. ముఖ్య విలువలు: 'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122, '0' = 48.
  4. చిన్న అక్షరం – పెద్ద అక్షరం తేడా = 32 (ఉదా: 'a' 97 − 'A' 65).
• EBCDIC (Extended Binary Coded Decimal Interchange Code):
  1. IBM అభివృద్ధి చేసిన 8-బిట్ కోడ్ (256 అక్షరాలు)
  2. పాత IBM మెయిన్‌ఫ్రేమ్‌లలో వాడేవారు.
• BCD (Binary Coded Decimal): ప్రతి డెసిమల్ అంకెకు 4 బిట్లు. ఉదా: 25 → 0010 0101.
• Unicode: ప్రపంచంలోని అన్ని భాషల అక్షరాలను (తెలుగు, హిందీ, చైనీస్ సహా) సూచించే సార్వత్రిక కోడింగ్. UTF-8, UTF-16 దీని రూపాలు. తెలుగులో కంప్యూటర్‌లో రాయడం సాధ్యమైంది Unicode వల్లే.
• Unicode కు ఇంగ్లీష్ భాగంలో ASCII తో అనుకూలత ఉంటుంది.
• ISCII (Indian Script Code for Information Interchange): భారతీయ లిపుల కోసం 8-బిట్ కోడ్.
• గ్రే కోడ్ (Gray Code): వరుస సంఖ్యల మధ్య ఒకే బిట్ తేడా ఉండే కోడ్.
• పారిటీ బిట్ (Parity Bit): డేటా ప్రసారంలో లోపాలు గుర్తించడానికి చేర్చే అదనపు బిట్.

గుర్తుంచుకునే చిట్కా ASCII = 128 (7 బిట్), Extended ASCII = 256 (8 బిట్), Unicode = అన్ని భాషలు.

లాజిక్ గేట్లు డిజిటల్ సర్క్యూట్‌ల ప్రాథమిక నిర్మాణ ఘటాలు (Building Blocks). ఇవి బైనరీ ఇన్‌పుట్‌లను (0, 1) తీసుకొని ఒక అవుట్‌పుట్ ఇస్తాయి. CPU లోని ALU ఇవే గేట్లతో తయారవుతుంది.

• AND గేట్:
  1. రెండు ఇన్‌పుట్‌లూ 1 అయితేనే అవుట్‌పుట్ 1. (1 AND 1 = 1
  2. మిగిలిన అన్నీ 0)
• OR గేట్: ఏ ఒక్క ఇన్‌పుట్ 1 అయినా అవుట్‌పుట్ 1. రెండూ 0 అయితేనే 0.
• NOT గేట్ (Inverter):
  1. ఒకే ఇన్‌పుట్
  2. విలోమం (వ్యతిరేకం) ఇస్తుంది. NOT 1 = 0
  3. NOT 0 = 1.
• NAND గేట్:
  1. AND ఫలితానికి NOT. రెండు ఇన్‌పుట్‌లూ 1 అయితేనే అవుట్‌పుట్ 0
  2. మిగిలినప్పుడు 1.
• NOR గేట్:
  1. OR ఫలితానికి NOT. రెండూ 0 అయితేనే అవుట్‌పుట్ 1
  2. మిగిలినప్పుడు 0.
• XOR గేట్ (Exclusive OR):
  1. ఇన్‌పుట్‌లు వేరుగా ఉంటే అవుట్‌పుట్ 1
  2. ఒకేలా ఉంటే 0.
• XNOR గేట్:
  1. XOR ఫలితానికి NOT
  2. ఇన్‌పుట్‌లు ఒకేలా ఉంటే 1.
• యూనివర్సల్ గేట్లు (Universal Gates): NAND మరియు NOR. వీటితో ఏ ఇతర గేటునైనా తయారు చేయవచ్చు.
• బూలియన్ ఆల్జీబ్రా (Boolean Algebra): లాజిక్ గేట్ల గణితం. దీన్ని జార్జ్ బూల్ (George Boole) రూపొందించారు.
• ఫ్లిప్-ఫ్లాప్ (Flip-Flop):
  1. ఒక బిట్‌ను నిల్వ చేసే సర్క్యూట్
  2. మెమరీ, రిజిస్టర్‌లకు ఆధారం.
• సాధారణ ఉపయోగం: AND – ఇన్‌పుట్‌లన్నీ సరిగా ఉంటేనే పని చేయాలి (ఉదా: భద్రతా వ్యవస్థ). OR – ఏదైనా ఒకటి చాలు.