Algorithms and Flowcharts – NIELIT O Level (M3-R5)

💡 Introduction

किसी भी प्रोग्रामिंग प्रक्रिया की शुरुआत Algorithm और Flowchart से होती है। ये दोनों concepts किसी भी प्रोग्राम के पीछे की logical planning को समझाने के लिए उपयोग किए जाते हैं। Algorithm एक step-by-step तरीका बताता है जिससे समस्या को हल किया जाता है, जबकि Flowchart उसी algorithm को एक diagram के रूप में प्रस्तुत करता है।

📘 Why We Need Algorithms and Flowcharts?

• किसी समस्या को systematic तरीके से हल करने के लिए।
• Programming logic को clearly plan और visualize करने के लिए।
• Errors कम करने और debugging आसान बनाने के लिए।
• Team members के बीच communication improve करने के लिए।
• Algorithm → Flowchart → Code: यह logical development का natural sequence है।

🧩 Algorithm – Step-by-Step Explanation

Algorithm वह logical sequence होता है जो किसी समस्या के समाधान के steps को दर्शाता है। हर step clear, finite और executable होना चाहिए।

✅ Characteristics of a Good Algorithm

• Finiteness: Algorithm को सीमित steps में समाप्त होना चाहिए।
• Definiteness: हर step का अर्थ स्पष्ट और unambiguous होना चाहिए।
• Input: 0 या अधिक input values लेने चाहिए।
• Output: कम से कम एक output देना चाहिए।
• Effectiveness: Steps इतने सरल होने चाहिए कि manually भी किए जा सकें।

🧮 Example – Algorithm to Add Two Numbers

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

📊 Flowchart – Visual Representation

जब हम algorithm को graphical रूप में symbols और arrows की मदद से दिखाते हैं, तो उसे Flowchart कहा जाता है। Flowchart का उपयोग program logic को visually समझाने और analyze करने में किया जाता है।

📘 Common Flowchart Symbols

🧠 Example – Flowchart for Adding Two Numbers

# Flowchart-based program
a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
sum = a + b
print("The Sum is:", sum)
    

⚙️ Flowchart for Decision Making (Example)

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

📈 Relationship between Algorithm and Flowchart

• Algorithm logic को शब्दों में दर्शाता है, Flowchart उसी logic को चित्र में।
• Algorithm program की planning का पहला step है।
• Flowchart program की visualization और debugging को आसान बनाता है।
• दोनों का उद्देश्य — clear, error-free programming logic बनाना।

🧩 Summary

• Algorithm step-by-step logical process है।
• Flowchart algorithm का visual diagram है।
• Programming शुरू करने से पहले दोनों को बनाना best practice है।
• Python code directly algorithm और flowchart से derive किया जा सकता है।

💡 Introduction

Flowchart किसी algorithm या program का graphical representation होता है। यह दिखाता है कि program के steps किस क्रम में execute होंगे। Flowchart में अलग-अलग symbols का प्रयोग किया जाता है — जैसे Start/Stop, Input/Output, Process, Decision आदि, जो program के अलग-अलग भागों को दर्शाते हैं।

📘 Purpose of Flowchart Symbols

• Program logic को visualize करने में मदद करते हैं।
• Errors और logical mistakes को पहचानना आसान होता है।
• Complex programs को simple blocks में बाँटकर समझा जा सकता है।
• Developers, testers और students के लिए communication आसान बनता है।

🔹 Common Flowchart Symbols and Their Meanings

Flowchart में प्रयुक्त प्रत्येक symbol का एक विशिष्ट उद्देश्य होता है। नीचे दी गई तालिका में commonly used symbols और उनके अर्थ बताए गए हैं:

📈 Flowchart Example – Simple Input/Output Process

नीचे एक छोटा flowchart logic दिया गया है जो दो संख्याएँ पढ़ता है, उन्हें जोड़ता है और परिणाम दिखाता है।

# Flowchart for addition of two numbers
a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
sum = a + b
print("Sum =", sum)
    

⚙️ Flowchart Example – Decision Making

Decision symbol (🔺 Diamond) का उपयोग तब किया जाता है जब हमें किसी condition पर decision लेना होता है, जैसे कि संख्या even है या odd।

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

🔁 Flowchart Example – Loop (Iterative Process)

जब कोई प्रक्रिया बार-बार दोहराई जाती है, तब हम loop (iteration) symbols का प्रयोग करते हैं। जैसे, किसी संख्या का factorial निकालना।

n = int(input("Enter number: "))
fact = 1
i = 1
while i <= n:
    fact = fact * i
    i += 1
print("Factorial =", fact)
    

🧠 Best Practices for Drawing Flowcharts

• Start और Stop symbols हमेशा oval में रखें।
• हर operation को rectangle में लिखें।
• Input/Output को parallelogram में दिखाएँ।
• Decision (Yes/No) के लिए diamond का प्रयोग करें।
• Arrows के माध्यम से control flow को connect करें।
• Flowchart को साफ और logically aligned रखें।

📚 Real-Life Applications

• ATM transactions (cash withdrawal process)
• Hospital management systems
• Online shopping order flow
• Student grading logic
• Bank loan approval process

🧩 Summary

• Flowchart algorithm का graphical form है।
• Symbols logic के प्रत्येक step का अर्थ बताते हैं।
• Decision, process, input/output symbols program flow define करते हैं।
• Python code flowchart के logic को practically implement करता है।

💡 Introduction

जब किसी प्रोग्राम में statements एक के बाद एक क्रम से execute होते हैं — बिना किसी branching या repetition के — तो उसे Sequential Processing कहते हैं। यह सबसे सरल control structure होती है, जिसमें steps का execution ऊपर से नीचे की ओर होता है।

📘 Key Characteristics

• कोई decision (if-else) या loop (while, for) नहीं होता।
• हर instruction linear sequence में चलता है।
• Program का flow हमेशा top → bottom होता है।
• Simple tasks जैसे addition, area calculation, unit conversion आदि के लिए ideal।

🧩 Flowchart Representation

Sequential flowchart में सभी steps एक single path में connect रहते हैं। नीचे एक example दिया गया है।

# Sequential Example 1: Area of Rectangle
length = float(input("Enter length: "))
breadth = float(input("Enter breadth: "))
area = length * breadth
print("Area of Rectangle =", area)
    

🧮 Example 2 – Simple Interest Calculation

यह example दिखाता है कि sequential steps कैसे financial computation में उपयोग होते हैं।

# Sequential Example 2: Simple Interest
P = float(input("Enter Principal: "))
R = float(input("Enter Rate of Interest: "))
T = float(input("Enter Time (in years): "))
SI = (P * R * T) / 100
print("Simple Interest =", SI)
    

⚙️ Example 3 – Temperature Conversion

यहाँ हम Celsius को Fahrenheit में convert करेंगे — बिना किसी decision या loop के।

# Sequential Example 3: Temperature Conversion
C = float(input("Enter temperature in Celsius: "))
F = (C * 9/5) + 32
print("Temperature in Fahrenheit =", F)
    

📊 Example 4 – Average of Three Numbers

तीन संख्याओं का औसत निकालना sequential structure का classic example है।

# Sequential Example 4: Average of three numbers
A = float(input("Enter first number: "))
B = float(input("Enter second number: "))
C = float(input("Enter third number: "))
avg = (A + B + C) / 3
print("Average =", avg)
    

🧠 Example 5 – Perimeter and Area of Circle

यहाँ sequentially two calculations perform होते हैं — पहले circumference, फिर area।

# Sequential Example 5: Circle Area and Perimeter
R = float(input("Enter radius of circle: "))
area = 3.14 * R * R
circumference = 2 * 3.14 * R
print("Area =", area)
print("Circumference =", circumference)
    

📈 Characteristics of Sequential Flowchart

• Linear connection of all steps.
• Arrows always go downward (top to bottom).
• No branching, no looping.
• Execution order same as written order.

🧩 Summary

• Sequential structure = simple, ordered execution of statements.
• Program का flow हमेशा एक दिशा में चलता है।
• Basic mathematical & logical operations इसी structure में आते हैं।
• Sequential logic coding का सबसे पहला building block है।

💡 Introduction

प्रोग्राम में कई बार ऐसे मौके आते हैं जब हमें किसी शर्त (condition) के आधार पर अलग-अलग actions लेने होते हैं। जैसे — अगर temperature ज्यादा है तो "Hot" दिखाओ, नहीं तो "Cool"। इस प्रकार के logic को Decision Making या Selection Structure कहा जाता है।

📘 Purpose of Decision Making

• Different situations में अलग-अलग output देने के लिए।
• Program को dynamic और intelligent बनाने के लिए।
• Flowchart में branching दिखाने के लिए।
• Python में if, if-else, elif आदि का प्रयोग होता है।

🧩 Flowchart Concept

Decision making को flowchart में Diamond symbol (🔺) द्वारा दर्शाया जाता है, जहाँ दो रास्ते होते हैं — Yes (True) और No (False)।

📘 Types of Decision-Making Statements in Python

• Simple if Statement
• if-else Statement
• Nested if Statement
• if-elif-else Ladder

✅ 1. Simple if Statement

यह केवल तब execute होता है जब condition True होती है। अगर condition False है, तो program simply next line पर चला जाता है।

if condition:
    statement
    

marks = int(input("Enter marks: "))
if marks >= 50:
    print("You Passed!")
print("Exam Over.")
    

✅ 2. if-else Statement

अगर condition True है तो एक block execute होता है, अन्यथा दूसरा block।

if condition:
    statement1
else:
    statement2
    

num = int(input("Enter a number: "))
if num % 2 == 0:
    print("Even Number")
else:
    print("Odd Number")
    

✅ 3. Nested if Statement

जब एक if-statement के अंदर दूसरा if होता है, तो उसे Nested if कहते हैं। इसका प्रयोग तब होता है जब multiple levels की checking करनी हो।

marks = int(input("Enter marks: "))
if marks >= 40:
    if marks >= 75:
        print("Distinction")
    else:
        print("Pass")
else:
    print("Fail")
    

✅ 4. if-elif-else Ladder

जब multiple conditions हों और हर एक condition के लिए अलग result देना हो, तो if-elif-else ladder का प्रयोग किया जाता है।

marks = int(input("Enter marks: "))
if marks >= 90:
    print("Grade A+")
elif marks >= 75:
    print("Grade A")
elif marks >= 60:
    print("Grade B")
elif marks >= 40:
    print("Grade C")
else:
    print("Fail")
    

⚙️ Real-Life Example – Electricity Bill Calculation

नीचे दिया गया example practical decision-making logic को दर्शाता है।

units = int(input("Enter electricity units used: "))

if units <= 100:
    bill = units * 5
elif units <= 200:
    bill = units * 7
else:
    bill = units * 10

print("Total Bill = ₹", bill)
    

🧠 Key Points

• Decision making allows selection among alternatives.
• if handles single condition; if-else handles two-way choice.
• elif is used for multiple conditional checks.
• Nested if can be used for multi-level logical hierarchy.
• Flowchart में Decision symbol (🔺) condition check के लिए अनिवार्य है।

🧩 Summary

• Decision making structure conditions पर आधारित होती है।
• Python में इसके लिए if, elif, else का उपयोग होता है।
• Flowchart में diamond shape decision दिखाती है।
• Program को smart और logical बनाने का यही आधार है।

💡 Introduction

Programming में कई बार हमें किसी process को बार-बार (repeatedly) चलाने की आवश्यकता होती है — जब तक कोई शर्त (condition) पूरी न हो जाए। इस repetitive execution को Looping या Iteration कहा जाता है।

📘 Why We Use Loops?

• Repeated tasks को automate करने के लिए।
• Code को छोटा और efficient बनाने के लिए।
• Table printing, summation, factorial आदि जैसे repetitive operations करने के लिए।

🧩 Flowchart Concept

Looping flowchart में Decision (🔺 Diamond) symbol के साथ Backward Arrow का प्रयोग होता है, जो iteration को दर्शाता है।

📘 Types of Loops in Python

• while Loop – जब तक condition True हो, तब तक चलता है।
• for Loop – किसी sequence (range, list, string) पर iterate करता है।
• Nested Loop – एक loop के अंदर दूसरा loop।

✅ 1. while Loop

while loop तब तक execute होता है जब तक condition True रहती है। जैसे ही condition False होती है, loop समाप्त हो जाता है।

while condition:
    statement(s)
    

i = 1
while i <= 5:
    print(i)
    i += 1
print("Loop Finished")
    

✅ 2. for Loop

for loop का प्रयोग तब किया जाता है जब हमें पता हो कि कितनी बार repetition करनी है। Python में यह किसी sequence (list, tuple, string, range) पर iterate करता है।

for variable in sequence:
    statement(s)
    

for i in range(1, 6):
    print(i)
print("Loop Complete")
    

✅ 3. Example – Sum of First N Natural Numbers

Loop का सबसे common application – summation।

n = int(input("Enter N: "))
sum = 0
i = 1
while i <= n:
    sum += i
    i += 1
print("Sum =", sum)
    

✅ 4. Example – Multiplication Table

यह example दिखाता है कि loop repetitive calculation कैसे करता है।

num = int(input("Enter a number: "))
for i in range(1, 11):
    print(num, "x", i, "=", num * i)
    

✅ 5. Nested Loop Example

जब एक loop के अंदर दूसरा loop हो, तो उसे nested loop कहा जाता है। यह pattern printing और matrices में useful है।

for i in range(1, 4):         # Outer loop
    for j in range(1, 4):     # Inner loop
        print(i, j)
    

⚙️ Loop Control Statements

कभी-कभी हमें loop के normal flow को बदलने की आवश्यकता होती है। इसके लिए Python में कुछ special statements हैं:

• break – Loop को बीच में ही समाप्त करता है।
• continue – Current iteration को skip कर अगले iteration पर जाता है।
• pass – Placeholder, कुछ नहीं करता (empty statement)।

for i in range(1, 10):
    if i == 6:
        break
    print(i)
    

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

📈 Comparison: while vs for Loop

🧠 Real-Life Examples

• ATM pin retry (3 attempts)
• Bank interest calculation for N years
• Automatic message sending to list of users
• Pattern or shape drawing (like stars or numbers)

🧩 Summary

• Loop repetition को handle करता है।
• while – condition-based loop।
• for – range या sequence-based loop।
• break और continue loop control के लिए।
• Flowchart में looping arrow iteration दिखाता है।

💡 Introduction

Algorithm और Flowchart दोनों programming के foundation हैं। इस chapter में हम कुछ common real-life algorithms और उनके flowchart logic को देखेंगे, साथ ही उनके Python implementations भी। हर example में — Algorithm ➜ Flowchart Steps ➜ Python Code तीनों दिए गए हैं।

🧩 Example 1 – Sum of Two Numbers

# Example 1: Sum of Two Numbers
A = int(input("Enter first number: "))
B = int(input("Enter second number: "))
Sum = A + B
print("Sum =", Sum)
    

🧮 Example 2 – Find Maximum of Two Numbers

# Example 2: Find maximum of two numbers
A = int(input("Enter first number: "))
B = int(input("Enter second number: "))

if A > B:
    print("A is greater")
else:
    print("B is greater")
    

🔢 Example 3 – Factorial of a Number

# Example 3: Factorial of a number
N = int(input("Enter a number: "))
Fact = 1
i = 1
while i <= N:
    Fact = Fact * i
    i += 1
print("Factorial =", Fact)
    

🔁 Example 4 – Check Number is Even or Odd

# Example 4: Check even or odd
N = int(input("Enter number: "))
if N % 2 == 0:
    print("Even Number")
else:
    print("Odd Number")
    

🔄 Example 5 – Reverse a Number

# Example 5: Reverse of a number
N = int(input("Enter a number: "))
Rev = 0
while N > 0:
    R = N % 10
    Rev = Rev * 10 + R
    N = N // 10
print("Reversed Number =", Rev)
    

🔁 Example 6 – Check Palindrome Number

# Example 6: Check palindrome number
N = int(input("Enter a number: "))
copy = N
rev = 0
while N > 0:
    r = N % 10
    rev = rev * 10 + r
    N = N // 10
if copy == rev:
    print("Palindrome Number")
else:
    print("Not Palindrome")
    

📊 Example 7 – Student Grade Evaluation

# Example 7: Student grade evaluation
marks = int(input("Enter marks: "))

if marks >= 90:
    grade = "A+"
elif marks >= 75:
    grade = "A"
elif marks >= 60:
    grade = "B"
elif marks >= 40:
    grade = "C"
else:
    grade = "Fail"

print("Grade:", grade)
    

⚙️ Example 8 – Find Smallest of Three Numbers

# Example 8: Smallest of three numbers
A = int(input("Enter first number: "))
B = int(input("Enter second number: "))
C = int(input("Enter third number: "))

if A < B and A < C:
    smallest = A
elif B < C:
    smallest = B
else:
    smallest = C

print("Smallest number =", smallest)
    

🧠 Key Learnings

• Algorithm is the “thinking part”; Flowchart is its visual version.
• Each problem must follow Input → Process → Output structure.
• Python code is direct implementation of the same logic.
• Practicing with dry runs helps visualize the logic flow.

🧩 Summary

• Algorithms are step-by-step procedures.
• Flowcharts help visualize the process.
• Python executes these logical steps sequentially.
• Common examples strengthen programming fundamentals.

💡 Introduction

इस section में हमने NIELIT O-Level syllabus से संबंधित Algorithms और Flowcharts पर आधारित कुछ Frequently Asked Questions (FAQs) को एक जगह संकलित किया है। ये प्रश्न exam preparation और interview दोनों के लिए उपयोगी हैं।

🧩 Frequently Asked Questions

🧩 Summary

• Algorithm और Flowchart दोनों logical thinking सिखाते हैं।
• Exam में इन दोनों का theoretical और practical दोनों उपयोग होता है।
• हर Python program एक algorithm और flowchart से ही शुरू होता है।
• Concept clarity से coding आसान और error-free बनती है।