Chapter 1: Introduction to Programming — Languages, Algorithms, Flowcharts व Python की शुरुआत

🤔 Programming Language की ज़रूरत क्यों?

• Computer केवल binary language (0 और 1) समझता है — इसे machine language कहते हैं।
• मनुष्य के लिए binary में लिखना लगभग असंभव है (कल्पना कीजिए — "Hello" print करने के लिए हज़ारों 0/1!)।
• Programming languages instructions को human-readable (English जैसा) बनाती हैं।
• फिर Compiler या Interpreter उन्हें machine code में translate कर देता है।

🧬 Languages की 5 Generations (Evolution)

1️⃣ Machine Language (1st Generation)

सबसे नीचले स्तर (lowest level) की भाषा — instructions केवल 0 और 1 में। यह hardware द्वारा सीधे समझी जाती है, कोई translation नहीं चाहिए।

10110100 00001111
// yah kisi CPU instruction ka binary roop hai
// jaise "register me value load karo"

2️⃣ Assembly Language (2nd Generation)

Machine language की readability बढ़ाने के लिए mnemonics (छोटे English words) आए — जैसे MOV (move), ADD (जोड़ो), SUB (घटाओ)। इसे machine code में बदलने के लिए Assembler चाहिए।

MOV A, 05H    ; Register A me 5 daalo
MOV B, 06H    ; Register B me 6 daalo
ADD A, B      ; A = A + B (yaani 11)

3️⃣ High-Level Languages (3rd Generation)

मनुष्यों के लिए आसान — syntax English जैसा। Compiler/Interpreter translate करता है। Python, C, C++, Java, BASIC इसी category में हैं।

a = 5
b = 10
sum = a + b
print("Sum =", sum)

4️⃣ Fourth Generation Languages (4GL)

और भी high-level — आप बताते हैं "क्या चाहिए", यह नहीं कि "कैसे करना है"। SQL, MATLAB, R जैसे। उद्देश्य: programming effort कम करना।

SELECT name, age FROM students WHERE age > 18;
-- humne sirf bataya KYA chahiye,
-- HOW (loop/compare) database khud karega

5️⃣ Fifth Generation Languages (5GL)

Logic-based व AI-oriented languages — Machine Learning, Artificial Intelligence व Expert Systems में उपयोग। उदाहरण: Prolog, Mercury और Python के AI frameworks (TensorFlow आदि)।

🧠 Key Programming Concepts (Exam में पूछे जाते हैं)

🚀 Python ही क्यों? (M3-R5 की language)

• Simple, readable syntax — beginners के लिए सबसे आसान।
• Interpreter-based — code लिखो और तुरंत run करो, compile step नहीं।
• Free, open source व platform-independent — Windows/Mac/Linux सबपर।
• Huge libraries — Data Science, AI, Web Development सबके लिए ready-made।
• O Level syllabus के practical implementation के लिए perfect।

⚖️ Master Comparison Table

print("Hello, World!")

📘 Computational Models के 3 Types

• 1. Mathematical Model: Computation को equations व logic में दर्शाता है।
• 2. Physical Model: बताता है CPU, Memory व Storage computation को वास्तव में कैसे चलाते हैं।
• 3. Abstract Model: Logical steps व data flow पर केंद्रित — जैसे Turing Machine व RAM Model।

1️⃣ Turing Machine — Theory का बादशाह

Alan Turing (father of computer science) द्वारा दिया गया theoretical model। इसके 3 parts:

• Infinite Tape: जिस पर symbols लिखे जाते हैं (memory की तरह)।
• Head: जो symbols को पढ़ता और लिखता है।
• Control Unit: जो next step तय करती है।

x = 2        # Step 1: memory me 2 rakha
y = 3        # Step 2: memory me 3 rakha
z = x + y    # Step 3: dono padhe, joda, result rakha
print(z)     # Step 4: result dikhaya

2️⃣ Finite Automata (FA) — Limited Memory वाला Model

Input symbols को पढ़कर states बदलता है और final state तक पहुँचता है। Pattern matching में उपयोग होता है।

• DFA (Deterministic FA): हर symbol के लिए केवल एक next state।
• NFA (Non-Deterministic FA): एक symbol के लिए कई possible states।

s = "10101"
if "101" in s:
    print("Pattern found!")
else:
    print("Pattern not found!")

3️⃣ RAM Model (Random Access Machine) — Practice का Model

Computation का practical रूप — जैसा असली computers में होता है:

• हर instruction को 1 unit time माना जाता है।
• Memory access O(1) time में (किसी भी location पर सीधे पहुँच)।
• Algorithm analysis के लिए सबसे उपयुक्त model।

arr = [10, 20, 30, 40]
arr[2] = arr[2] + 5   # index 2 par SEEDHE pahunche (koi loop nahi)
print(arr)

⚙️ Computational Model के 5 Components

num = int(input("Enter a number: "))   # INPUT
square = num * num                      # PROCESS
print("Square is:", square)             # OUTPUT

⭐ Algorithm की 5 Characteristics (बहुत Important)

📝 Example 1 — दो Numbers का Sum

a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
sum = a + b
print("Sum =", sum)

📝 Example 2 — दो Numbers में बड़ा (Largest of Two)

a = int(input("Enter A: "))
b = int(input("Enter B: "))
if a > b:
    print("Largest =", a)
else:
    print("Largest =", b)

📝 Example 3 — Even या Odd

n = int(input("Enter number: "))
if n % 2 == 0:
    print(n, "is Even")
else:
    print(n, "is Odd")

🧩 Algorithms के Types

for i in range(1, 6):
    print(i, end=" ")

⏱️ Algorithm Complexity (Efficiency मापना)

• Time Complexity: Algorithm कितना समय लेगा — Big-O notation में: O(1) constant, O(n) linear, O(n²) quadratic।
• Space Complexity: कितनी memory लेगा।

🔣 Flowchart Symbols (Exam का पक्का प्रश्न)

📊 Example Flowchart — दो Numbers में बड़ा

✔️ Flowchart बनाने के Rules

• हमेशा Start से शुरू और Stop पर खत्म।
• Flow की दिशा ऊपर से नीचे या बाएँ से दाएँ।
• Decision (diamond) से हमेशा 2 रास्ते निकलते हैं — Yes व No।
• Arrows एक-दूसरे को cross न करें; हर symbol में short, clear text।

⚖️ Algorithm vs Flowchart

🏭 Compilation की 7 Stages (C जैसी compiled languages)

🐍 Python का Execution Model — Bytecode + PVM

• Step 1: आप .py file लिखते हैं (source code)।
• Step 2: Python इसे internally bytecode (.pyc) में compile करता है — platform-independent बीच की भाषा।
• Step 3: PVM (Python Virtual Machine) bytecode को line-by-line execute करती है।
• Step 4: Output screen पर आता है।

🧪 Testing के 4 मुख्य Types

def add(a, b):
    return a + b

# Testing different cases
assert add(2, 3) == 5      # Pass
assert add(-1, 1) == 0     # Pass
assert add(0, 0) == 0      # Pass
print("All tests passed!")

❌ Errors के 3 Types (सबसे Important Topic)

1️⃣ Syntax Error — Grammar की गलती

Language के rules टूटने पर — program चलता ही नहीं।

print("Hello"     # closing bracket bhool gaye!

2️⃣ Logical Error — सोच की गलती

Program चलता है, error नहीं आती — लेकिन output गलत आता है। सबसे खतरनाक, क्योंकि पकड़ना मुश्किल!

a = 10
b = 20
average = a + b / 2     # GALAT! pehle b/2 hoga (BODMAS)
print("Average =", average)

3️⃣ Runtime Error — चलते-चलते Crash

Execution के दौरान आने वाली error — जैसे zero से divide, गलत index।

a = 10
b = 0
print(a / b)     # zero se divide!

🛠️ Debugging की 4 Techniques

• 1. Print Statement Debugging: बीच-बीच में print() लगाकर values check करना (सबसे simple)।
• 2. Python Debugger (pdb): import pdb; pdb.set_trace() से program को रोककर step-by-step देखना।
• 3. IDE Debugger: VS Code/PyCharm में breakpoints लगाकर।
• 4. Exception Handling: try-except से errors को gracefully संभालना।

try:
    a = int(input("Enter number: "))
    result = 100 / a
    print("Result =", result)
except ZeroDivisionError:
    print("Error: Zero se divide nahi kar sakte!")
except ValueError:
    print("Error: Sahi number enter karein!")

📝 Python में Documentation के 3 तरीके

1️⃣ Single-line Comments (#)

# Yah program area calculate karta hai
radius = 5           # circle ki radius
area = 3.14 * radius ** 2    # formula: πr²
print("Area =", area)

2️⃣ Multi-line Comments (''' ''')

'''
Program: Simple Interest Calculator
Author: Boosting Skills
Date: 2026
Purpose: SI = (P × R × T) / 100 calculate karna
'''
p, r, t = 1000, 5, 2
si = (p * r * t) / 100
print("Simple Interest =", si)

3️⃣ Docstrings — Functions की Official Documentation

def square(n):
    """Yah function number ka square return karta hai."""
    return n * n

print(square(6))
print(square.__doc__)    # docstring ko access karna

📋 Good Documentation के Rules

• Comments "क्यों" बताएँ, "क्या" नहीं (code खुद बताता है क्या हो रहा है)।
• Meaningful variable names रखें — student_age, न कि x।
• हर function में docstring; ज़रूरत से ज़्यादा comments भी बुरे हैं।
• Documentation को code के साथ update रखें।

Q1. Print का basic behavior

print("5 + 3")
print(5 + 3)

Q2. Integer vs Float Division

print(10 / 3)
print(10 // 3)
print(10 % 3)

Q3. Variable Update

x = 5
x = x + 2
x = x * 3
print(x)

Q4. String Concatenation vs Addition

a = "10"
b = "20"
print(a + b)
print(int(a) + int(b))

Q5. BODMAS Trap

result = 2 + 3 * 4 ** 2
print(result)

Q6. Loop Output

for i in range(1, 6):
    if i == 3:
        continue
    print(i, end=" ")

Q7. Condition का Output

a = 15
if a > 10:
    print("Big")
if a > 20:
    print("Bigger")
else:
    print("Small")

Q8. Error पहचानिए

x = int("hello")
print(x)

Q9. While Loop Trace

n = 10
while n > 0:
    print(n, end=" ")
    n = n - 3

Q10. Logical Error पकड़िए

# 3 numbers ka average
a, b, c = 10, 20, 30
avg = a + b + c / 3
print("Average =", avg)

Q11. Type पहचानिए

print(type(10))
print(type(10.5))
print(type("10"))

Q12. Assert का Behavior

def double(n):
    return n * 2

assert double(4) == 8
print("Test 1 passed")
assert double(5) == 11
print("Test 2 passed")

Program 1 — Factorial निकालना (Loop से)

n = int(input("Enter number: "))
fact = 1
for i in range(1, n + 1):
    fact = fact * i
print("Factorial of", n, "=", fact)

Program 2 — N Numbers का Sum व Average

n = int(input("Kitne numbers? "))
total = 0
for i in range(n):
    num = float(input("Number " + str(i+1) + ": "))
    total = total + num
average = total / n
print("Sum =", total)
print("Average =", average)

Program 3 — Prime Number Check

n = int(input("Enter number: "))
is_prime = True
if n < 2:
    is_prime = False
for i in range(2, n):
    if n % i == 0:
        is_prime = False
        break
if is_prime:
    print(n, "is a Prime number")
else:
    print(n, "is NOT a Prime number")

Program 4 — Multiplication Table

n = int(input("Kis number ki table? "))
for i in range(1, 11):
    print(n, "x", i, "=", n * i)

Program 5 — Number Reverse करना

n = int(input("Enter number: "))
rev = 0
while n > 0:
    digit = n % 10        # aakhri digit nikala
    rev = rev * 10 + digit
    n = n // 10           # aakhri digit hataya
print("Reversed =", rev)

Program 6 — Fibonacci Series

n = int(input("Kitne terms? "))
a, b = 0, 1
for i in range(n):
    print(a, end=" ")
    a, b = b, a + b

Program 7 — Largest of Three Numbers

a = int(input("A: "))
b = int(input("B: "))
c = int(input("C: "))
if a >= b and a >= c:
    print("Largest =", a)
elif b >= a and b >= c:
    print("Largest =", b)
else:
    print("Largest =", c)

Program 8 — Palindrome Number Check

n = int(input("Enter number: "))
temp = n
rev = 0
while temp > 0:
    rev = rev * 10 + temp % 10
    temp = temp // 10
if n == rev:
    print(n, "is a Palindrome")
else:
    print(n, "is NOT a Palindrome")

• Programming Language = computer से बात करने का माध्यम; 5 generations: Machine → Assembly → High-Level → 4GL → 5GL।
• Compiler = पूरा program एक साथ translate (C, C++); Interpreter = line-by-line (Python, JavaScript)।
• Models of Computation: Turing Machine (theory), Finite Automata (patterns), RAM Model (practice — O(1) memory access)।
• Algorithm = finite, well-defined steps; 5 characteristics = Finiteness, Definiteness, Input, Output, Effectiveness।
• Flowchart = algorithm का चित्र; Oval=Start/Stop, Rectangle=Process, Diamond=Decision, Parallelogram=I/O।
• Compilation की 7 stages: Lexical → Syntax → Semantic → Intermediate → Optimization → Code Gen → Linking।
• Python execution: .py → bytecode (.pyc) → PVM → Output; इसीलिए "Interpreted + Compiled"।
• Testing: Unit → Integration → System → Acceptance (छोटे से बड़े)।
• Errors: Syntax (चलने से पहले), Logical (गलत output), Runtime (crash — ZeroDivisionError आदि)।
• Documentation: # comments, ''' multi-line, docstrings (__doc__) — good programming की पहचान।

❓ A. Multiple Choice Questions (50)

📝 B. 15 Theory Questions (Short Answers)

1. Programming language क्या है और इसकी ज़रूरत क्यों है?Computer को instructions देने का माध्यम। Computer केवल binary समझता है, मनुष्य के लिए binary कठिन है — इसलिए human-readable languages चाहिए जिन्हें compiler/interpreter translate करे।
2. Languages की 5 generations बताइए।1GL Machine (0/1), 2GL Assembly (mnemonics), 3GL High-Level (Python, C), 4GL (SQL, MATLAB), 5GL AI-based (Prolog)।
3. Compiler और Interpreter में 4 अंतर लिखिए।Compiler: पूरा program एक साथ, fast, सभी errors एक साथ, object code बनता है (C)। Interpreter: line-by-line, slow, पहली error पर रुकता, object code नहीं (Python)।
4. Source code व Object code में अंतर बताइए।Source code = programmer द्वारा लिखा high-level code (.py); Object code = translate किया हुआ machine-readable code।
5. Turing Machine के 3 parts बताइए।Infinite Tape (symbols के लिए), Head (पढ़ने-लिखने के लिए), Control Unit (next step तय करने के लिए)।
6. DFA और NFA में क्या अंतर है?DFA में हर symbol के लिए केवल एक next state; NFA में एक symbol के लिए कई possible states हो सकती हैं।
7. RAM Model की विशेषताएँ लिखिए।हर instruction = 1 unit time; memory access O(1); algorithm analysis के लिए सबसे उपयुक्त practical model।
8. Algorithm की 5 characteristics बताइए।Finiteness (finite steps), Definiteness (हर step clear), Input (0+), Output (1+), Effectiveness (steps simple व practical)।
9. Flowchart के 5 symbols व उनके उपयोग लिखिए।Oval = Start/Stop; Rectangle = Process; Diamond = Decision; Parallelogram = Input/Output; Arrow = flow direction।
10. Algorithm और Flowchart में अंतर बताइए।Algorithm text/steps में होता है, बनाना आसान, modify करना आसान; Flowchart symbols/diagram में, देखते ही समझ आता है पर redraw करना पड़ता है।
11. Compilation की 7 stages क्रम से लिखिए।Lexical Analysis → Syntax Analysis → Semantic Analysis → Intermediate Code → Code Optimization → Code Generation → Linking & Loading।
12. Python को Interpreted + Compiled क्यों कहते हैं?क्योंकि .py source पहले internally bytecode (.pyc) में compile होता है, फिर PVM उस bytecode को line-by-line interpret/execute करती है।
13. Testing के 4 types क्रम से बताइए।Unit (एक function), Integration (modules साथ में), System (पूरा system), Acceptance (user requirements) — छोटे से बड़े की ओर।
14. Errors के 3 types उदाहरण सहित लिखिए।Syntax (bracket missing — चलने से पहले), Logical (गलत formula — output गलत), Runtime (10/0 — ZeroDivisionError, चलते हुए crash)।
15. Python में documentation के तरीके बताइए।# single-line comments, ''' ''' multi-line comments, और docstrings (function की पहली line पर """ """, __doc__ से access) — interpreter इन्हें ignore करता है।