Conversions: Decimal → others by repeated division; others → decimal by positional weights; binary ↔ octal in groups of 3, binary ↔ hex in groups of 4.
1's complement = flip all bits; 2's complement = 1's complement + 1 (used for subtraction).
7 logic gates: NOT, AND, OR, NAND, NOR, XOR, XNOR. NAND and NOR are universal gates — any gate can be built from them.
Languages: Machine (binary) → Assembly (mnemonics) → High-level (English-like). Compiler translates the whole program at once; interpreter line by line; assembler converts assembly to machine code.
2.1 What is a Number System?
A number system is a method of representing numbers using a fixed set of symbols (digits). Every number system has a base (radix) — the number of unique digits it uses — and each digit's value depends on its position (place value = baseposition).
Number System
Base
Digits Used
Binary
2
0, 1
Octal
8
0, 1, 2, 3, 4, 5, 6, 7
Decimal
10
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hexadecimal
16
0–9 and A(10), B(11), C(12), D(13), E(14), F(15)
Remember: Computers work in binary because electronic circuits have two states — ON (1) and OFF (0). Each binary digit is called a bit.
2.2 Number System Conversions
(a) Decimal → Binary (repeated division by 2)
Divide the number by 2 repeatedly, note each remainder, and read the remainders from bottom to top.
Computers use 2's complement to represent negative numbers and to perform subtraction using addition.
2.4 Logic Gates
A logic gate is an electronic circuit that performs a logical operation on one or more binary inputs to produce a single binary output.
Basic Gates: NOT, AND, OR
Symbols of the three basic gates: NOT (inverter), AND and OR.
NAND, NOR, XOR, XNOR
Symbols of NAND, NOR, XOR and XNOR gates. The small circle (bubble) means inversion.
Truth Tables
A
B
NOT A
A AND B
A OR B
A NAND B
A NOR B
A XOR B
A XNOR B
0
0
1
0
0
1
1
0
1
0
1
1
0
1
1
0
1
0
1
0
0
0
1
1
0
1
0
1
1
0
1
1
0
0
0
1
One-line rules: NOT = inverts. AND = 1 only when both are 1. OR = 1 when at least one is 1. NAND = opposite of AND. NOR = opposite of OR. XOR = 1 when inputs differ. XNOR = 1 when inputs are equal. NAND and NOR are universal gates — any other gate can be built using only NAND gates (or only NOR gates).
PYQ Alert: "Which gates are universal?" — NAND and NOR. Also asked: "XOR gives 1 when…" (inputs are different), "Output of NAND when both inputs are 1" (0). Learn the combined truth table above by heart.
2.5 Computer Languages
Machine Language
The lowest-level language — programs written in binary (0s and 1s). It is machine-dependent (different for each CPU), executes the fastest, but is the hardest for humans to write and debug.
Assembly Language
Uses mnemonics (short codes like ADD, SUB, MOV) instead of binary. Easier than machine language but still machine-dependent. It is converted to machine code by an assembler.
High-Level Language
Uses English-like words and mathematical symbols (C, C++, Java, Python). Machine-independent — the same program runs on different computers. Translated by a compiler or interpreter.
Point
Machine Language
Assembly Language
High-Level Language
Form
Binary (0, 1)
Mnemonics (ADD, MOV)
English-like words
Translated by
None (directly executed)
Assembler
Compiler / Interpreter
Machine dependent?
Yes
Yes
No
Ease of use
Hardest
Hard
Easiest
Execution speed
Fastest
Fast
Slower
Example
10110000 01100001
MOV AL, 61H
print("Hello")
Compiler vs Interpreter vs Assembler
Translator
Translates
How it works
Compiler
High-level → machine code
Translates the whole program at once; produces an executable file; faster execution (e.g., C, C++)
Interpreter
High-level → machine code
Translates and executes line by line; no executable file; slower, but easier debugging (e.g., Python, BASIC)
Assembler
Assembly → machine code
Converts mnemonics into binary instructions
3GL vs 4GL
3GL (Third Generation Language): Procedural high-level languages — the programmer writes step-by-step procedures. Examples: FORTRAN, COBOL, C, C++, Java, Pascal.
4GL (Fourth Generation Language): Non-procedural, problem-oriented languages — the programmer states what is needed, not how. Used for databases, queries and reports. Examples: SQL, Oracle, MATLAB.
Remember: Machine and assembly = low-level languages (machine-dependent, fast). High-level = 3GL/4GL (machine-independent, easy). Compiler = whole program at once; Interpreter = line by line.
Exam Tip: Favourite MCQs — "SQL is an example of…" (4GL), "C is an example of…" (3GL / high-level), "Which translator converts assembly language?" (Assembler), "Interpreter translates…" (line by line). Machine language is also called the first-generation language.
30 सेकंड में इकाई 2
संख्या पद्धति = आधार (base) और अंकों के समूह का उपयोग करके संख्याओं को दर्शाने की विधि। कंप्यूटर बाइनरी (आधार 2) उपयोग करते हैं; मनुष्य दशमलव (आधार 10) उपयोग करते हैं।
रूपांतरण: दशमलव → अन्य में बार-बार भाग देकर; अन्य → दशमलव में स्थितीय भार से; बाइनरी ↔ ऑक्टल 3 के समूह में, बाइनरी ↔ हेक्स 4 के समूह में।
1's कॉम्प्लिमेंट = सभी बिट पलट दें; 2's कॉम्प्लिमेंट = 1's कॉम्प्लिमेंट + 1 (घटाने में उपयोग)।
7 लॉजिक गेट: नॉट (NOT), एंड (AND), ऑर (OR), नैंड (NAND), नॉर (NOR), एक्स-ऑर (XOR), एक्स-नॉर (XNOR)। नैंड और नॉर सार्वभौमिक गेट हैं — इनसे कोई भी गेट बनाया जा सकता है।
भाषाएं: मशीनी (बाइनरी) → असेंबली (स्मृति-चिह्न) → उच्च-स्तरीय (अंग्रेजी जैसी)। कम्पाइलर पूरा प्रोग्राम एक साथ अनुवाद करता है; इंटरप्रेटर पंक्ति दर पंक्ति; असेंबलर असेंबली को मशीनी कोड में बदलता है।
2.1 संख्या पद्धति क्या है?
संख्या पद्धति प्रतीकों (अंकों) के निश्चित समूह का उपयोग करके संख्याओं को दर्शाने की विधि है। हर संख्या पद्धति का एक आधार (रेडिक्स) होता है — अर्थात वह कितने अद्वितीय अंक उपयोग करती है — और हर अंक का मान उसकी स्थिति पर निर्भर करता है (स्थानीय मान = आधारस्थिति)।
संख्या पद्धति
आधार
प्रयुक्त अंक
बाइनरी
2
0, 1
ऑक्टल
8
0, 1, 2, 3, 4, 5, 6, 7
दशमलव
10
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
हेक्साडेसिमल
16
0–9 और A(10), B(11), C(12), D(13), E(14), F(15)
याद रखें: कंप्यूटर बाइनरी में काम करते हैं क्योंकि इलेक्ट्रॉनिक परिपथों की दो अवस्थाएं होती हैं — चालू (1) और बंद (0)। हर बाइनरी अंक को बिट कहते हैं।
2.2 संख्या पद्धति रूपांतरण
(क) दशमलव → बाइनरी (2 से बार-बार भाग)
संख्या को 2 से बार-बार भाग दें, हर शेषफल नोट करें और शेषफलों को नीचे से ऊपर की ओर पढ़ें।
उदाहरण: (25)10 → बाइनरी
25 ÷ 2 = 12, शेषफल 1
12 ÷ 2 = 6, शेषफल 0
6 ÷ 2 = 3, शेषफल 0
3 ÷ 2 = 1, शेषफल 1
1 ÷ 2 = 0, शेषफल 1
शेषफलों को नीचे से ऊपर पढ़ने पर: (25)10 = (11001)2। जांच: 16 + 8 + 1 = 25 ✓
(ख) बाइनरी → दशमलव (स्थितीय भार)
हर बिट को 2स्थिति से गुणा करें (स्थिति दाईं ओर से 0 से शुरू) और जोड़ दें।
बाइनरी → ऑक्टल: दाईं ओर से बिटों को 3-3 के समूह में बांटें। (11010111)2 → 11|010|111 → 3|2|7 = (327)8।
बाइनरी → हेक्स: दाईं ओर से बिटों को 4-4 के समूह में बांटें। (11010111)2 → 1101|0111 → D|7 = (D7)16।
ऑक्टल → बाइनरी: हर ऑक्टल अंक को 3 बिट में फैलाएं। हेक्स → बाइनरी: हर हेक्स अंक को 4 बिट में फैलाएं।
(छ) दशमलव भिन्न → बाइनरी
भिन्न को 2 से बार-बार गुणा करें; हर बार पूर्णांक भाग नोट करें, ऊपर से नीचे की ओर।
उदाहरण: (0.625)10 → बाइनरी
0.625 × 2 = 1.25 → पूर्णांक 1
0.25 × 2 = 0.5 → पूर्णांक 0
0.5 × 2 = 1.0 → पूर्णांक 1
(0.625)10 = (0.101)2। जांच: 0.5 + 0.125 = 0.625 ✓
परीक्षा टिप: रूपांतरण के प्रश्न पक्के बहुविकल्पीय प्रश्न हैं। प्रिय जाल: शेषफलों को ऊपर से नीचे पढ़ना (सही नीचे से ऊपर है), और हेक्स अंक A=10 … F=15। अभ्यास करें: (1010)2 = 10, (FF)16 = 255, (77)8 = 63।
कंप्यूटर ऋणात्मक संख्याओं को दर्शाने और जोड़ द्वारा घटाव करने के लिए 2's कॉम्प्लिमेंट उपयोग करते हैं।
2.4 लॉजिक गेट
लॉजिक गेट एक इलेक्ट्रॉनिक परिपथ है जो एक या अधिक बाइनरी इनपुट पर तार्किक क्रिया करके एक बाइनरी आउटपुट देता है।
मूल गेट: नॉट, एंड, ऑर
तीन मूल गेटों के प्रतीक: नॉट (NOT, इन्वर्टर), एंड (AND) और ऑर (OR)।
नैंड, नॉर, एक्स-ऑर, एक्स-नॉर
नैंड (NAND), नॉर (NOR), एक्स-ऑर (XOR) और एक्स-नॉर (XNOR) गेटों के प्रतीक। छोटा वृत्त (बबल) उलटाव दर्शाता है।
सत्यता सारणी (Truth Tables)
A
B
NOT A
A AND B
A OR B
A NAND B
A NOR B
A XOR B
A XNOR B
0
0
1
0
0
1
1
0
1
0
1
1
0
1
1
0
1
0
1
0
0
0
1
1
0
1
0
1
1
0
1
1
0
0
0
1
एक-पंक्ति नियम: नॉट = उलट देता है। एंड = 1 तभी जब दोनों 1 हों। ऑर = 1 जब कम से कम एक 1 हो। नैंड = एंड का विपरीत। नॉर = ऑर का विपरीत। एक्स-ऑर = 1 जब इनपुट भिन्न हों। एक्स-नॉर = 1 जब इनपुट समान हों। नैंड और नॉर सार्वभौमिक गेट हैं — केवल नैंड गेटों (या केवल नॉर गेटों) से कोई भी अन्य गेट बनाया जा सकता है।
परीक्षा टिप: "कौन से गेट सार्वभौमिक हैं?" — नैंड और नॉर। यह भी पूछा जाता है: "एक्स-ऑर 1 कब देता है…" (इनपुट भिन्न हों), "दोनों इनपुट 1 होने पर नैंड का आउटपुट" (0)। ऊपर दी संयुक्त सत्यता सारणी कंठस्थ करें।
2.5 कंप्यूटर भाषाएं
मशीनी भाषा (Machine Language)
सबसे निम्न-स्तरीय भाषा — बाइनरी (0 और 1) में लिखे प्रोग्राम। यह मशीन-निर्भर है (हर सीपीयू के लिए अलग), सबसे तेज चलती है, लेकिन मनुष्यों के लिए लिखना और त्रुटि खोजना सबसे कठिन है।
असेंबली भाषा (Assembly Language)
बाइनरी के बजाय स्मृति-चिह्नों (mnemonics) का उपयोग करती है (जैसे ADD, SUB, MOV)। मशीनी भाषा से आसान, लेकिन फिर भी मशीन-निर्भर है। इसे असेंबलर द्वारा मशीनी कोड में बदला जाता है।
उच्च-स्तरीय भाषा (High-Level Language)
अंग्रेजी जैसे शब्दों और गणितीय प्रतीकों का उपयोग करती है (सी, सी++, जावा, पायथन)। मशीन-स्वतंत्र — एक ही प्रोग्राम अलग-अलग कंप्यूटरों पर चलता है। कम्पाइलर या इंटरप्रेटर द्वारा अनुवादित होती है।
बिंदु
मशीनी भाषा
असेंबली भाषा
उच्च-स्तरीय भाषा
रूप
बाइनरी (0, 1)
स्मृति-चिह्न (ADD, MOV)
अंग्रेजी जैसे शब्द
अनुवादक
कोई नहीं (सीधे चलती है)
असेंबलर
कम्पाइलर / इंटरप्रेटर
मशीन-निर्भर?
हां
हां
नहीं
उपयोग में सरलता
सबसे कठिन
कठिन
सबसे आसान
निष्पादन गति
सबसे तेज
तेज
धीमी
उदाहरण
10110000 01100001
MOV AL, 61H
print("Hello")
कम्पाइलर बनाम इंटरप्रेटर बनाम असेंबलर
अनुवादक
अनुवाद करता है
कार्यविधि
कम्पाइलर
उच्च-स्तरीय → मशीनी कोड
पूरा प्रोग्राम एक साथ अनुवाद करता है; निष्पादन योग्य फाइल बनाता है; तेज निष्पादन (जैसे सी, सी++)
इंटरप्रेटर
उच्च-स्तरीय → मशीनी कोड
पंक्ति दर पंक्ति अनुवाद और निष्पादन करता है; निष्पादन योग्य फाइल नहीं; धीमा, लेकिन त्रुटि खोजना आसान (जैसे पायथन, बेसिक)
असेंबलर
असेंबली → मशीनी कोड
स्मृति-चिह्नों को बाइनरी निर्देशों में बदलता है
3GL बनाम 4GL
3GL (तृतीय पीढ़ी भाषा): प्रक्रियात्मक उच्च-स्तरीय भाषाएं — प्रोग्रामर चरण-दर-चरण प्रक्रिया लिखता है। उदाहरण: फोरट्रान, कोबोल, सी, सी++, जावा, पास्कल।
4GL (चतुर्थ पीढ़ी भाषा): गैर-प्रक्रियात्मक, समस्या-उन्मुख भाषाएं — प्रोग्रामर बताता है क्या चाहिए, कैसे नहीं। डेटाबेस, क्वेरी और रिपोर्ट के लिए। उदाहरण: एसक्यूएल (SQL), ओरेकल, मैटलैब।
याद रखें: मशीनी और असेंबली = निम्न-स्तरीय भाषाएं (मशीन-निर्भर, तेज)। उच्च-स्तरीय = 3GL/4GL (मशीन-स्वतंत्र, आसान)। कम्पाइलर = पूरा प्रोग्राम एक साथ; इंटरप्रेटर = पंक्ति दर पंक्ति।
परीक्षा टिप: प्रिय बहुविकल्पीय प्रश्न — "एसक्यूएल किसका उदाहरण है…" (4GL), "सी किसका उदाहरण है…" (3GL / उच्च-स्तरीय), "असेंबली भाषा को कौन अनुवाद करता है?" (असेंबलर), "इंटरप्रेटर अनुवाद करता है…" (पंक्ति दर पंक्ति)। मशीनी भाषा को प्रथम पीढ़ी की भाषा भी कहते हैं।
