Ever wondered how a computer — which only understands 0s and 1s — manages to display your name, calculate your marks, and show colourful images? The answer lies in **Data Representation**! This chapter reveals how EVERYTHING (numbers, letters, symbols) gets translated into the binary language computers actually understand. 🔢💻
> [!TIP]
> **How to use these notes:** Practice EVERY conversion by hand first, then verify with a calculator. Binary-Decimal and Decimal-Binary conversions are GUARANTEED in every board exam — master these first! 🎯
---
## 2.1 🏁 Introduction
Computers are essentially just VERY fast switches — millions of tiny electronic switches that can only be in TWO states: ON or OFF.
```mermaid
graph LR
ON["⚡ Switch ON\n= 1"]
OFF["⚫ Switch OFF\n= 0"]
BINARY["🔢 Combined together:\nBINARY NUMBERS\n(0s and 1s)"]
ON --> BINARY
OFF --> BINARY
style ON fill:#4CAF50,color:#fff
style OFF fill:#9E9E9E,color:#fff
style BINARY fill:#2196F3,color:#fff
```
> Think of it this way: A light switch can only be ON or OFF — there's no "half on." Computers work EXACTLY like this, using millions of switches (transistors) to represent EVERY piece of data — numbers, letters, images, sounds — all as combinations of 0s and 1s!
**Why do we need different Number Systems?**
::: grid
::: card 👤 | Humans | We naturally think in Decimal (Base 10) — we have 10 fingers! | 0,1,2,3,4,5,6,7,8,9
::: card 💻 | Computers | Internally, they think ONLY in Binary (Base 2) — ON/OFF switches | 0,1
::: card 🔧 | Programmers | Often use Octal/Hexadecimal as a SHORTHAND for binary | Easier for humans to read long binary strings
:::
---
## 2.2 🔢 Digital Number Systems
A **Number System** is a way of representing numbers using a specific set of symbols (digits) and a **BASE** (also called radix) — the total count of unique digits used.
```mermaid
graph TD
NS["🔢 NUMBER SYSTEMS"]
D["🔟 Decimal\nBase 10\n(0-9)"]
B["🔵 Binary\nBase 2\n(0-1)"]
O["🟠 Octal\nBase 8\n(0-7)"]
H["🟣 Hexadecimal\nBase 16\n(0-9, A-F)"]
NS --> D
NS --> B
NS --> O
NS --> H
style D fill:#4CAF50,color:#fff
style B fill:#2196F3,color:#fff
style O fill:#FF9800,color:#fff
style H fill:#9C27B0,color:#fff
```
---
### 2.2.1 Decimal (Denary) Number System (Base 10) 🔟
The number system we humans use EVERY DAY — uses 10 digits: **0, 1, 2, 3, 4, 5, 6, 7, 8, 9**.
```
Number: 2 5 3
Position: 100s 10s 1s
Value: (2×100) + (5×10) + (3×1) = 253
```
**Positional Value System:**
```
253 (base 10) = 2×10² + 5×10¹ + 3×10⁰
= 2×100 + 5×10 + 3×1
= 200 + 50 + 3 = 253
```
> **Key Concept:** In ANY number system, each digit's position represents a POWER of the base. This "positional value" concept is the foundation for understanding ALL number systems!
---
### 2.2.2 Binary Number System (Base 2) 🔵
Uses only **2 digits: 0 and 1** — the LANGUAGE computers actually speak internally!
```
Binary: 1 0 1 1
Position: 2³ 2² 2¹ 2⁰
Value: (1×8) + (0×4) + (1×2) + (1×1) = 11 (decimal)
```
| Position (Power of 2) | 2³=8 | 2²=4 | 2¹=2 | 2⁰=1 |
| :--- | :--- | :--- | :--- | :--- |
| **Binary Digit** | 1 | 0 | 1 | 1 |
| **Value** | 8 | 0 | 2 | 1 |
**8 + 0 + 2 + 1 = 11** → So (1011)₂ = (11)₁₀
> Each binary digit is called a **BIT** (Binary Digit). 8 bits together = **1 BYTE**!
---
### 2.2.3 Octal Number System (Base 8) 🟠
Uses **8 digits: 0, 1, 2, 3, 4, 5, 6, 7**.
```
Octal: 3 7 2
Position: 8² 8¹ 8⁰
Value: (3×64) + (7×8) + (2×1) = 192+56+2 = 250 (decimal)
```
> Octal was popular in early computing as a SHORTHAND for binary — since 8 = 2³, exactly 3 binary digits map to ONE octal digit!
---
### 2.2.4 Hexadecimal Number System (Base 16) 🟣
Uses **16 digits: 0-9, then A, B, C, D, E, F** (where A=10, B=11, C=12, D=13, E=14, F=15).
| Hex Digit | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
| **Decimal Value** | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
```
Hex: 2 A
Position: 16¹ 16⁰
Value: (2×16) + (A×1) = (2×16) + (10×1) = 32+10 = 42 (decimal)
```
> Hexadecimal is HUGELY popular in programming — since 16 = 2⁴, exactly 4 binary digits map to ONE hex digit! This makes hex a super-compact way to write binary. You've SEEN hex before: color codes like `#FF5733` in CSS/web design are hexadecimal!
**All Four Number Systems — Quick Reference:**
| System | Base | Digits Used | Example |
| :--- | :--- | :--- | :--- |
| **Decimal** | 10 | 0-9 | 253 |
| **Binary** | 2 | 0-1 | 1011 |
| **Octal** | 8 | 0-7 | 372 |
| **Hexadecimal** | 16 | 0-9, A-F | 2A |
> [!IMPORTANT]
> **Board Exam Tip**
> "What is the base of Binary, Octal, and Hexadecimal number systems?" — **1-mark** question, guaranteed!
> Answer: Binary = **2**, Octal = **8**, Hexadecimal = **16**, Decimal = **10**
---
## 2.3 🔄 Number Conversions
This is THE most important, most-tested section of the entire chapter! Let's master EVERY conversion, step by step.
```mermaid
graph TD
DEC["🔟 Decimal"]
BIN["🔵 Binary"]
OCT["🟠 Octal"]
HEX["🟣 Hexadecimal"]
DEC <--> BIN
DEC <--> OCT
DEC <--> HEX
BIN <--> OCT
BIN <--> HEX
HEX <--> OCT
style DEC fill:#4CAF50,color:#fff
style BIN fill:#2196F3,color:#fff
style OCT fill:#FF9800,color:#fff
style HEX fill:#9C27B0,color:#fff
```
---
### 2.3.1 Decimal-to-Binary Conversion 🔟➡️🔵
**Method: Repeated Division by 2** — divide by 2 repeatedly, note the remainders, then read BOTTOM TO TOP.
**Example: Convert (25)₁₀ to Binary**
```
25 ÷ 2 = 12 remainder 1 ↑
12 ÷ 2 = 6 remainder 0 ↑
6 ÷ 2 = 3 remainder 0 ↑
3 ÷ 2 = 1 remainder 1 ↑
1 ÷ 2 = 0 remainder 1 ↑ (Read bottom to top!)
```
**Answer: (25)₁₀ = (11001)₂**
```mermaid
graph TD
A["25 ÷ 2 = 12 R 1"]
B["12 ÷ 2 = 6 R 0"]
C["6 ÷ 2 = 3 R 0"]
D["3 ÷ 2 = 1 R 1"]
E["1 ÷ 2 = 0 R 1"]
F["Read UPWARDS:\n1-1-0-0-1 = 11001"]
A --> B --> C --> D --> E --> F
style F fill:#4CAF50,color:#fff
```
> [!WARNING]
> **The #1 Conversion Mistake!**
> Students often forget to read the remainders BOTTOM TO TOP. The FIRST remainder you calculate is the LAST digit of your binary answer, not the first!
---
### 2.3.2 Binary-to-Decimal Conversion 🔵➡️🔟
**Method: Multiply each digit by its positional power of 2, then ADD.**
**Example: Convert (11001)₂ to Decimal**
```
1 1 0 0 1
2⁴ 2³ 2² 2¹ 2⁰
16 8 4 2 1
(1×16) + (1×8) + (0×4) + (0×2) + (1×1)
= 16 + 8 + 0 + 0 + 1
= 25
```
**Answer: (11001)₂ = (25)₁₀** ✅ *(Matches our earlier conversion — good check!)*
> [!IMPORTANT]
> **Board Exam Tip**
> "Convert (10110)₂ to decimal." — **1-2 mark** question, very common!
> Answer: (1×16)+(0×8)+(1×4)+(1×2)+(0×1) = 16+0+4+2+0 = **22**
---
### 2.3.3 Decimal-to-Octal Conversion 🔟➡️🟠
**Method: Repeated Division by 8** — same process as Decimal-to-Binary, but divide by 8!
**Example: Convert (100)₁₀ to Octal**
```
100 ÷ 8 = 12 remainder 4 ↑
12 ÷ 8 = 1 remainder 4 ↑
1 ÷ 8 = 0 remainder 1 ↑ (Read bottom to top!)
```
**Answer: (100)₁₀ = (144)₈**
---
### 2.3.4 Octal-to-Decimal Conversion 🟠➡️🔟
**Method: Multiply each digit by its positional power of 8, then ADD.**
**Example: Convert (144)₈ to Decimal**
```
1 4 4
8² 8¹ 8⁰
64 8 1
(1×64) + (4×8) + (4×1) = 64 + 32 + 4 = 100
```
**Answer: (144)₈ = (100)₁₀** ✅
---
### 2.3.5 Octal-to-Binary Conversion 🟠➡️🔵
**Method: Convert EACH octal digit into its 3-bit binary equivalent** (since 8 = 2³).
**The Octal-Binary Cheat Sheet:**
| Octal | Binary (3-bit) |
| :--- | :--- |
| 0 | 000 |
| 1 | 001 |
| 2 | 010 |
| 3 | 011 |
| 4 | 100 |
| 5 | 101 |
| 6 | 110 |
| 7 | 111 |
**Example: Convert (372)₈ to Binary**
```
3 → 011
7 → 111
2 → 010
Combine: 011 111 010
```
**Answer: (372)₈ = (011111010)₂**
---
### 2.3.6 Binary-to-Octal Conversion 🔵➡️🟠
**Method: Group binary digits into sets of 3 (from the RIGHT), then convert each group to its octal digit.**
**Example: Convert (11111010)₂ to Octal**
```
Step 1: Group into 3s from the RIGHT (pad with 0s on the LEFT if needed)
11 111 010 → 011 111 010
Step 2: Convert each group:
011 = 3
111 = 7
010 = 2
Answer: 372
```
**Answer: (11111010)₂ = (372)₈**
> [!WARNING]
> **Padding with Zeros!**
> If the leftmost group doesn't have exactly 3 digits, ADD ZEROS on the LEFT to complete the group. `11` becomes `011` — this doesn't change the value!
---
### 2.3.7 Decimal-to-Hex Conversion 🔟➡️🟣
**Method: Repeated Division by 16** — same process, but divide by 16, and convert remainders 10-15 into A-F!
**Example: Convert (250)₁₀ to Hexadecimal**
```
250 ÷ 16 = 15 remainder 10 (=A) ↑
15 ÷ 16 = 0 remainder 15 (=F) ↑ (Read bottom to top!)
```
**Answer: (250)₁₀ = (FA)₁₆**
---
### 2.3.8 Hex-to-Decimal Conversion 🟣➡️🔟
**Method: Multiply each digit by its positional power of 16, then ADD.**
**Example: Convert (FA)₁₆ to Decimal**
```
F A
16¹ 16⁰
16 1
(F×16) + (A×1) = (15×16) + (10×1) = 240 + 10 = 250
```
**Answer: (FA)₁₆ = (250)₁₀** ✅
---
### 2.3.9 Binary-to-Hex Conversion 🔵➡️🟣
**Method: Group binary digits into sets of 4 (from the RIGHT), then convert each group to its hex digit** (since 16 = 2⁴).
**The Binary-Hex Cheat Sheet:**
| Binary (4-bit) | Hex |
| :--- | :--- |
| 0000 | 0 |
| 0001 | 1 |
| 0010 | 2 |
| 0011 | 3 |
| 0100 | 4 |
| 0101 | 5 |
| 0110 | 6 |
| 0111 | 7 |
| 1000 | 8 |
| 1001 | 9 |
| 1010 | A |
| 1011 | B |
| 1100 | C |
| 1101 | D |
| 1110 | E |
| 1111 | F |
**Example: Convert (11111010)₂ to Hex**
```
Step 1: Group into 4s from the RIGHT
1111 1010
Step 2: Convert each group:
1111 = F
1010 = A
Answer: FA
```
**Answer: (11111010)₂ = (FA)₁₆** ✅ *(Matches our earlier work!)*
---
### 2.3.10 Hex-to-Binary Conversion 🟣➡️🔵
**Method: Convert EACH hex digit into its 4-bit binary equivalent.**
**Example: Convert (FA)₁₆ to Binary**
```
F → 1111
A → 1010
Combine: 1111 1010
```
**Answer: (FA)₁₆ = (11111010)₂**
> [!TIP]
> **The Golden Shortcut! 🎵**
> Octal ↔ Binary: group in **3s** (since 8=2³)
> Hex ↔ Binary: group in **4s** (since 16=2⁴)
> Octal ↔ Hex: ALWAYS convert THROUGH Binary as a middle step — there's no direct shortcut!
---
## 📐 The Complete Conversion Map — Quick Reference
```mermaid
graph LR
D["Decimal"]
B["Binary"]
O["Octal"]
H["Hex"]
D -->|"÷2 repeatedly"| B
B -->|"×2ⁿ, add"| D
D -->|"÷8 repeatedly"| O
O -->|"×8ⁿ, add"| D
D -->|"÷16 repeatedly"| H
H -->|"×16ⁿ, add"| D
B -->|"group in 3s"| O
O -->|"3-bit each"| B
B -->|"group in 4s"| H
H -->|"4-bit each"| B
style D fill:#4CAF50,color:#fff
style B fill:#2196F3,color:#fff
```
| Conversion | Method |
| :--- | :--- |
| Decimal → Binary/Octal/Hex | Repeated division by base; read remainders BOTTOM to TOP |
| Binary/Octal/Hex → Decimal | Multiply each digit by positional power of base, then ADD |
| Binary → Octal | Group in 3s from the right |
| Binary → Hex | Group in 4s from the right |
| Octal → Binary | Expand each digit to 3-bit binary |
| Hex → Binary | Expand each digit to 4-bit binary |
> [!IMPORTANT]
> **Board Exam Tip**
> "Convert (156)₁₀ to Binary, Octal, and Hexadecimal." — **3-mark** question, VERY common combined-conversion question!
> Binary: 156÷2 repeatedly → **10011100**
> Octal: 156÷8 repeatedly → **234**
> Hex: 156÷16 repeatedly → **9C**
---
## 2.4 🔤 Character/String Representation
Numbers are easy — computers store them directly in binary. But how does a computer store LETTERS, symbols, and text? Through special CODING SCHEMES that assign a unique number to EVERY character!
```mermaid
graph TD
CHAR["🔤 CHARACTER CODES"]
ASCII["🇺🇸 ASCII\n(English characters,\n7-8 bits)"]
ISCII["🇮🇳 ISCII\n(Indian language\ncharacters)"]
UNI["🌍 Unicode\n(ALL world languages,\n16+ bits)"]
CHAR --> ASCII
CHAR --> ISCII
CHAR --> UNI
style ASCII fill:#2196F3,color:#fff
style ISCII fill:#FF9800,color:#fff
style UNI fill:#9C27B0,color:#fff
```
---
### 2.4.1 ASCII Code 🇺🇸
**ASCII = American Standard Code for Information Interchange.** Assigns a unique number (0-127) to English letters, digits, and symbols.
```
Character 'A' → ASCII value 65 → Binary: 01000001
Character 'a' → ASCII value 97 → Binary: 01100001
Character '0' → ASCII value 48 → Binary: 00110000
```
**Key ASCII Facts:**
| Property | Detail |
| :--- | :--- |
| **Size** | 7 bits (values 0-127) or extended to 8 bits (0-255) |
| **Covers** | English uppercase (A-Z), lowercase (a-z), digits (0-9), symbols |
| **'A' to 'Z'** | ASCII values 65 to 90 |
| **'a' to 'z'** | ASCII values 97 to 122 |
| **'0' to '9'** | ASCII values 48 to 57 |
> **Fun Trick! 🧠** Notice that lowercase letters = uppercase value + 32! 'A' is 65, 'a' is 97 (65+32=97). This is why programmers can easily convert case using simple math!
> [!IMPORTANT]
> **Board Exam Tip**
> "What is ASCII? What is the ASCII value range?" — **2-mark** question!
> Answer: **ASCII (American Standard Code for Information Interchange)** is a character encoding standard that assigns a unique numeric value to English letters, digits, and symbols. Standard ASCII uses 7 bits, giving values from 0 to 127.
---
### 2.4.2 ISCII Code 🇮🇳
**ISCII = Indian Script Code for Information Interchange.** Developed specifically to represent characters from INDIAN languages (Hindi, Tamil, Bengali, etc.) that ASCII cannot handle.
::: grid
::: card 🇮🇳 | Purpose | Represent Indian language scripts digitally | Devanagari, Tamil, Telugu, Bengali scripts
::: card 📏 | Size | 8-bit encoding | Extends beyond basic ASCII's English-only limitation
::: card 🏛️ | Developed By | Indian government standards body | Specifically for Indian language computing needs
:::
> **Analogy:** If ASCII is a phrasebook that ONLY has English words, ISCII is a SPECIAL phrasebook created specifically for Indian regional languages — filling the gap ASCII couldn't cover!
---
### 2.4.3 Unicode 🌍
**Unicode** is a UNIVERSAL character encoding standard designed to represent EVERY character from EVERY language/script in the WORLD — plus emojis, symbols, and more!
```mermaid
graph LR
PROB["😩 Problem\nASCII = English only\nISCII = Indian only\nOther countries need\nTHEIR OWN codes too!"]
UNI["🌍 Unicode\nONE universal standard\nfor ALL languages\nWORLDWIDE"]
PROB -->|"Solved by"| UNI
style PROB fill:#F44336,color:#fff
style UNI fill:#4CAF50,color:#fff
```
**Why Unicode was needed:**
| Old Problem | Unicode's Solution |
| :--- | :--- |
| ASCII only covers English | Unicode covers ALL world languages |
| Each country had its OWN separate code | Unicode is ONE universal standard |
| Couldn't mix languages in one document | Unicode allows English + Hindi + Chinese + Emojis together! |
**Key Unicode Facts:**
| Property | Detail |
| :--- | :--- |
| **Size** | Typically 16 bits (can extend further) — MUCH larger range than ASCII's 7/8 bits |
| **Covers** | Every major world language, mathematical symbols, emojis |
| **Backward Compatible** | The first 128 Unicode values are IDENTICAL to ASCII |
| **Used In** | Modern websites, apps, programming languages (Python 3 strings are Unicode by default!) |
**ASCII vs ISCII vs Unicode — The Ultimate Comparison:**
| Feature | ASCII | ISCII | Unicode |
| :--- | :--- | :--- | :--- |
| **Scope** | English only | Indian languages only | ALL world languages |
| **Bit Size** | 7-8 bits | 8 bits | 16+ bits |
| **Character Range** | 128-256 | 256 | Over 1 million possible! |
| **Modern Usage** | Legacy, still a Unicode subset | Rarely used standalone now | ✅ Universal standard today |
> [!IMPORTANT]
> **Board Exam Tip**
> "Differentiate between ASCII and Unicode." — **2-mark** question, asked frequently!
> Answer: **ASCII** is a 7-8 bit encoding standard representing ONLY English characters, digits, and symbols (128-256 characters total). **Unicode** is a UNIVERSAL encoding standard (16+ bits) that can represent characters from EVERY language in the world, including emojis and special symbols — and importantly, Unicode's first 128 values are backward-compatible with ASCII.
---
## ⚠️ Common Errors and Misconceptions
| Mistake | What's Wrong | Correct Understanding |
| :--- | :--- | :--- |
| ❌ Reading remainders TOP to BOTTOM in Decimal→Binary conversion | Gives the WRONG answer, reversed | ✅ Always read remainders BOTTOM to TOP |
| ❌ Forgetting to pad binary groups with zeros | Incomplete/wrong grouping for Octal/Hex conversion | ✅ Add leading zeros to complete groups of 3 (octal) or 4 (hex) |
| ❌ Thinking Octal-to-Hex can be done directly | No direct shortcut exists | ✅ ALWAYS convert through Binary as the middle step |
| ❌ ASCII and Unicode are the same thing | Unicode covers vastly more characters | ✅ ASCII = English only (128-256 chars); Unicode = ALL world languages (1M+ chars) |
| ❌ ISCII can represent English AND Indian languages equally | ISCII is designed specifically for Indian scripts | ✅ ISCII was created specifically to fill the gap ASCII left for Indian languages |
| ❌ 'a' and 'A' have the same ASCII value | They are different values | ✅ Lowercase = Uppercase value + 32 (e.g., 'A'=65, 'a'=97) |
---
## 🔑 Quick Revision — Exam Ready!
**Number Systems — Bases:**
```
Decimal = Base 10 (0-9)
Binary = Base 2 (0-1)
Octal = Base 8 (0-7)
Hex = Base 16 (0-9, A-F)
```
**Conversion Methods — One-Line Summary:**
| From → To | Method |
| :--- | :--- |
| Decimal → Any Base | Repeated division; read remainders bottom-to-top |
| Any Base → Decimal | Multiply digits by positional powers; add |
| Binary → Octal | Group in 3s |
| Binary → Hex | Group in 4s |
| Octal → Binary | 3-bit expansion per digit |
| Hex → Binary | 4-bit expansion per digit |
| Octal ↔ Hex | Always convert VIA Binary |
**Character Encoding — Quick Table:**
| Code | Covers | Bit Size |
| :--- | :--- | :--- |
| ASCII | English only | 7-8 bits |
| ISCII | Indian languages | 8 bits |
| Unicode | ALL world languages | 16+ bits |
---
## 🎯 Sample Board Exam Questions
### Q1: Very Short Answer [1 mark each]
a) What is the base of the Hexadecimal number system?
**→ 16**
b) What does ASCII stand for?
**→ American Standard Code for Information Interchange**
c) How many bits make up 1 byte?
**→ 8 bits**
d) What is the ASCII value of the character 'A'?
**→ 65**
e) Which number system uses digits 0-7 only?
**→ Octal**
---
### Q2: Conversion [2 marks]
**Q: Convert (45)₁₀ to Binary.**
```
45 ÷ 2 = 22 remainder 1
22 ÷ 2 = 11 remainder 0
11 ÷ 2 = 5 remainder 1
5 ÷ 2 = 2 remainder 1
2 ÷ 2 = 1 remainder 0
1 ÷ 2 = 0 remainder 1
```
**Answer: (45)₁₀ = (101101)₂**
---
### Q3: Conversion [2 marks]
**Q: Convert (11010)₂ to Decimal.**
```
1 1 0 1 0
16 8 4 2 1
(1×16)+(1×8)+(0×4)+(1×2)+(0×1) = 16+8+0+2+0 = 26
```
**Answer: (11010)₂ = (26)₁₀**
---
### Q4: Conversion [3 marks]
**Q: Convert (1101 1010)₂ to Octal and Hexadecimal.**
**To Octal (group in 3s):**
```
011 011 010
011 = 3, 011 = 3, 010 = 2
Answer: 332
```
**To Hex (group in 4s):**
```
1101 1010
1101 = D, 1010 = A
Answer: DA
```
---
### Q5: Short Answer [2 marks]
**Q: Differentiate between ASCII and Unicode.**
**ASCII** is a 7-8 bit encoding covering only English letters, digits, and symbols (128-256 characters).
**Unicode** is a universal 16+ bit encoding that represents characters from ALL world languages, including emojis — with the first 128 values matching ASCII for backward compatibility.
---
## ✏️ Practice Problems
1. Convert (78)₁₀ to Binary, Octal, and Hexadecimal.
2. Convert (110101)₂ to Decimal, Octal, and Hexadecimal.
3. Convert (BC)₁₆ to Decimal and Binary.
4. Convert (57)₈ to Decimal and Binary.
5. Explain why Octal-to-Hexadecimal conversion requires going through Binary as an intermediate step.
6. What is the ASCII value of 'Z'? What would the ASCII value of 'z' be, using the +32 shortcut?
7. Differentiate between ASCII, ISCII, and Unicode with one key feature of each.
8. Convert the decimal number 500 into Binary, Octal, and Hexadecimal, showing all working steps.
9. Explain why computers use the Binary number system internally, rather than Decimal.
10. A student converts (25)₁₀ to binary and gets (10011)₂ instead of the correct (11001)₂. Identify the likely mistake made during the conversion process.
Back to List
Calculating...
UNIT 1 : CH 2
Jul 31, 2026
Data Representation
Learning Support
Need Help With This Chapter?
Save key topics for exam revision, ask questions to teachers, or submit content corrections.
Verified Doubts & Teacher Answers
Loading resolved questions for this note...