DEV Community: Saravanan Lakshmanan

More Python Programs

Saravanan Lakshmanan — Fri, 21 Aug 2026 14:32:39 +0000

3) user input number: 123456 -> 56 34 12
6) user input number: 123456 -> Sum of 56 34 12

Program names:
Reverse Number in Pairs
Sum of 2-digit groups after reversing the groups

n = int(input("Enter the number: "))
total = 0

while n > 0:
    m = n % 100
    n = n // 100
    print(m)
    total += m

print(f'Sum of 2-digit groups = {total}')

Output:

Enter the number: 123456
56
34
12
Sum = 102

====================================================================
4) user input number: 123456 -> 456 123
7) user input number: 123456 -> Sum of 456 123

Program names:
Halves of a Number
Sum of Halves of a Number

n = int(input("Enter the number: "))
total = 0

while n > 0:
    m = n % 1000
    n = n // 1000
    print(m)
    total += m

print(f'Sum of 3-digit groups = {total}')

Output:

Enter the number: 123456
456
123
Sum of 3-digit groups = 579

====================================================================

5) user input number: 123456 -> 56 45 34 23 12

Program name:
Print Overlapping Two-Digit Pairs

n = int(input("Enter the number: "))
total = 0

while n > 1:
    m = n % 100
    n = n // 10
    print(m)
    total += m

print(f'Sum of Overlapping Two-Digit Pairs = {total}')

Output:

Enter the number: 123456
56
45
34
23
12
Sum of Overlapping Two-Digit Pairs = 170

====================================================================
1) user input number: 123456 -> 1+3+5

Method 1:

n = 123456

m = n // 100000
n = n % 10000
print(m)

m = n // 1000
n = n % 100
print(m)

m = n // 10
n = n % 1
print(m)

Method 2:

n = 123456
div = 100000
total = 0

while div > 0:
    m = n // div
    n = n % (div //10)
    total += m
    print(m)
    div = div // 100

print(f'total = {total}')

Output:

1
3
5
total = 9

====================================================================

2) user input number: 123456 -> 2 + 4 + 6
Method 1:

n = 123456

n = n % 100000
m = n // 10000
print(m)

n = n % 1000
m = n // 100
print(m)

n = n % 10
m = n // 1
print(m)

Method 2:

n = 123456
div = 100000
total = 0

while div > 0:
    n = n % div
    m = n // (div//10)
    total += m
    print(m)
    div = div // 100

print(f'total = {total}')

Output:

2
4
6
total = 12

Python Looping Programs - Continued

Saravanan Lakshmanan — Thu, 20 Aug 2026 13:56:05 +0000

Task 6:
Find the program, if the number is divisible by 4.

n = 124

lastTwoDigits = n % 100

if lastTwoDigits % 4 == 0:
    print(f'{n} is divisible by 4')
else:
    print(f'{n} is not divisible by 4')

n = 124

if n % 4 == 0:
    print(f'{n} is divisible by 4')
else:
    print(f'{n} is not divisible by 4')

Output:

124 is divisible by 4

Task 7:
Find the program, if the number is divisible by 5.

n = 100

value = n % 10
if value == 0 or value == 5:
    print(f'{n} is divisible by 5')
else:
        print(f'{n} is not divisible by 5')

n = 100

value = n % 10
if value in (0,5):
    print(f'{n} is divisible by 5')
else:
        print(f'{n} is not divisible by 5')

n = 100

if n % 5 == 0:
    print(f'{n} is divisible by 5')
else:
    print(f'{n} is not divisible by 5')

Output:

100 is divisible by 5

Task 8:
Find the program, if the number is divisible by 6.

n = 60

if n % 2 == 0 and n % 3 == 0:
    print(f'{n} is divisible by 6')
else:
    print(f'{n} is not divisible by 6')

n = 60

if n % 6 == 0:
    print(f'{n} is divisible by 6')
else:
    print(f'{n} is not divisible by 6')

Output:

60 is divisible by 6

Task 9:
Find the program, if the number is divisible by 8.

n = 8000

value = n % 1000
if value % 8 == 0:
    print(f'{n} is divisible by 8')
else:
    print(f'{n} is not divisible by 8')

n = 8000

if n % 8 == 0:
    print(f'{n} is divisible by 8')
else:
    print(f'{n} is not divisible by 8')

Output:

8000 is divisible by 8

Task 10:
Find the program, if the number is divisible by 9.

n = 9567
original = n
total = 0

while n > 0:
    m = n % 10
    total = total + m
    n = n // 10

print(total)    

if total % 9 == 0:
    print(f'{original} is divisible by 9')
else:
        print(f'{original} is not divisible by 9')

Output:

27
9567 is divisible by 9

Task 11:
Find the program, if the number is divisible by 10.

n = 100

value = n % 10

if value == 0:
    print(f'{n} is divisible by 10')
else:
        print(f'{n} is not divisible by 10')

Output:

100 is divisible by 10

Python Practice Programs

Saravanan Lakshmanan — Wed, 19 Aug 2026 14:24:46 +0000

Task 1:

List the prime and composite number from 2 to 31.

def findPrime(no):
    i = 2
    while i < no:
        if no % i == 0:
            return 'Composite number'
        i+=1
    else:
        return 'Prime number'    

n = 2
while n <= 31:
    result = findPrime(n)
    print(f'{n} is {result}')
    n+=1

Output:

2 is Prime number
3 is Prime number
4 is Composite number
5 is Prime number
6 is Composite number
7 is Prime number
8 is Composite number
9 is Composite number
10 is Composite number
11 is Prime number
12 is Composite number
13 is Prime number
14 is Composite number
15 is Composite number
16 is Composite number
17 is Prime number
18 is Composite number
19 is Prime number
20 is Composite number
21 is Composite number
22 is Composite number
23 is Prime number
24 is Composite number
25 is Composite number
26 is Composite number
27 is Composite number
28 is Composite number
29 is Prime number
30 is Composite number
31 is Prime number

Task 2:

Find 42 as sum of 2 consecutive prime numbers.

def findPrime(no):
    i = 2
    while i < no:
        if no % i == 0:
            return False
        i+=1
    else:
        return no    

no = 3
n1 = 2
while True:
    n2 = findPrime(no)

    if n2 != False:
        if n1 + n2 == 42:
            print(n1, n2)
            break
        else:
            n1 = n2
    no+=1

Output:

19 23

Task 3
Find Twin Primes? A pair of prime numbers whose difference is 2.

def findPrime(no):
    i = 2
    while i < no:
        if no % i == 0:
            return False
        i+=1
    else:
        return no    

no = 3
n1 = 2
while no <= 100:
    n2 = findPrime(no)

    if n2 != False:
        if n2 - n1 == 2:
            print(n1, n2)
        # else:
        n1 = n2
    no+=1

Output:

Task 4:
Find the program, if the number is divisible by 2.

n = 11

if n % 2 == 0:
    print("Divisible by 2")
else:
    print("Not Divisible by 2")

Output:

11 is not Divisible by 2

Task 5:
Find the program, if the number is divisible by 3.

n = 96

if n % 3 == 0:
    print("Divisible by 3")
else:
    print("Not Divisible by 3")

no = 96

onesPlace = no % 10
tensPlace = no // 10

sum = onesPlace  + tensPlace

if sum % 3 == 0:
    print("Divisible by 3")
else:
    print("Not Divisible by 3")

Output:

Divisible by 3

Python Looping Programs

Saravanan Lakshmanan — Tue, 18 Aug 2026 19:48:47 +0000

The Special Lock Number

A treasure box has a number lock with a number N. The lock designer follows a special rule: A number is considered a Special Number if it can be divided equally into groups in only two ways:
One group containing all the items.
Groups containing one item each.
For example, if the number is 7, the items can be arranged equally only as:
1 group of 7 or 7 groups of 1. But if the number is 8, it can also be arranged as 2 groups of 4, so it is not a Special Number.

n = 100

i = 2

while i <= n//2:
    if n % i == 0:
        print("Not a Prime")
        break
    i+=1    
else:
    print("Prime number")

Output

Prime number

Secret VIP Numbers

A security system assigns special numbers to the first few VIP lockers. A number is considered a VIP number if it can be divided exactly by only 1 and itself. The security officer wants the numbers of the first 5 VIP lockers. Write a Python program to display those 5 numbers.

Expected Result: 2, 3, 5, 7, 11

def findVIPNumbers(n):
    i = 2
    while i <= n//2:
        if n % i == 0:
            return 'Not Prime'
        i+=1    
    else:
        return 'Prime'

no = 2
count = 0

while count < 5:
    result = findVIPNumbers(no)    
    if result == 'Prime':
        print(f'{no} is {result}') 
        count+=1   
    no+=1

Output

2 is Prime
3 is Prime
5 is Prime
7 is Prime
11 is Prime

The Special Numbers
A teacher is preparing a Number Exhibition for students. She writes the numbers 1 to 20 on 20 cards. She wants to select only the special cards. A card is special if its number can be divided exactly by only two numbers: 1 and the number itself.

The teacher asks the students:
“Check all the cards from 1 to 20 and display the numbers that are special.”

def findVIPNumbers(n):
    i = 2
    while i <= n//2:
        if n % i == 0:
            return 'Not Prime'
        i+=1    
    else:
        return 'Prime'

no = 1
# count = 0

while no <= 20:
    result = findVIPNumbers(no)    
    if result == 'Prime':
        print(f'{no} is {result}') 
        # count+=1   
    no+=1

Output

1 is Prime
2 is Prime
3 is Prime
5 is Prime
7 is Prime
11 is Prime
13 is Prime
17 is Prime
19 is Prime

You have Rs. 100 /- One chocolate costs Rs. 5. Every time you buy a chocolate, you get one wrapper. You can exchange 3 wrappers for 1 additional chocolate. What is the maximum number of chocolates you can have with Rs. 100?

amount = 100
oneChocolate = 5
totChocolate = amount // oneChocolate
wrapper = totChocolate

while wrapper >= 3:
    wrapper -= 3
    totChocolate += 1
    wrapper += 1

print(f'Total Chocolates = {totChocolate}')

Output

Total Chocolates = 29

There is one person called Viyan. He is a Software Engineer. He employs a maid for cooking. One day, the maid prepared n number of chapathis and kept in a hot box. Viyan ate those chapathis and the count is as follows:
* For Morning breakfast, he completed 1/3 number of chapathis in the hot box.
* For Lunch, He had 1/3 of what was there in the hot box.
* For Dinner, again he took and ate 1/3 number of chapathis present in the box.

The next day morning, When the maid checked the number of chapathis remaining, it was 8. What was the number of chapathis, She made - in total?

rem = 8

i = 1
while i <= 3:
    rem = rem//2 + rem
    i+=1

print(f'Total = {rem}')

Output

Total = 27

JS/Python Looping program with if condition

Saravanan Lakshmanan — Fri, 14 Aug 2026 14:25:55 +0000

Write a Program to find Two-Digit Divisors Where the Tens Digit Is Greater Than the Units Digit.

//JS
let n = 1092;

let i = 10;
while(i < 100){
    if(n % i == 0){
        let a = Math.floor(i / 10);
        let b = i % 10;
        if(a > b){
        console.log(i);
        }
    }
     i++;
}

#Python
n = 1092

i = 10

while i < 100:
    if n % i == 0:
        a = i // 10
        b = i % 10

        if a > b:
            print(i)

    i += 1

Output:

SQL JOIN Practice: From Basic to Advanced — 39 Real-World Queries with Solutions

Saravanan Lakshmanan — Fri, 14 Aug 2026 10:16:29 +0000

Students & Courses

Display student name and course name.

SELECT s.student_name, c.course_name
FROM students s
JOIN courses c
ON s.course_id = c.course_id;

Output:

 student_name |   course_name    
--------------+------------------
 Viyan        | Java
 Kavin        | Python
 Mathi        | Java
 Arul         | Software Testing
(4 rows)

Display only students who are enrolled in Java.

SELECT s.student_name
FROM students s
JOIN courses c
ON s.course_id = c.course_id
WHERE c.course_name = 'Java';

Output:

 student_name 
--------------
 Viyan
 Mathi
(2 rows)

Display students enrolled in Python.

SELECT s.student_name
FROM students s
JOIN courses c
ON s.course_id = c.course_id
WHERE c.course_name = 'Python';

Output:

 student_name 
--------------
 Kavin
(1 row)

Display student name and course name ordered by student name.

SELECT s.student_name, c.course_name
FROM students s
JOIN courses c
ON s.course_id = c.course_id
ORDER BY student_name;

Output:

 student_name |   course_name    
--------------+------------------
 Arul         | Software Testing
 Kavin        | Python
 Mathi        | Java
 Viyan        | Java
(4 rows)

Level 2 — Employee & Department

Display employee name and department name.

SELECT e.emp_name, d.dept_name
FROM employeesTab e
JOIN departments d
ON e.dept_id = d.dept_id;

Output:

 emp_name  | dept_name 
-----------+-----------
 SARAVANAN | IT
 SAMUEL    | AI
 RAJ       | MIS
 KAMAL     | AI
(4 rows)

Display employees working in IT.

SELECT e.emp_name
FROM employeesTab e
JOIN departments d
ON e.dept_id = d.dept_id
WHERE dept_name = 'IT';

Output:

 emp_name  
-----------
 SARAVANAN
(1 row)

Display employees earning more than Rs. 50,000 along with their department.

SELECT e.emp_name, d.dept_name
FROM employeesTab e
JOIN departments d
ON e.dept_id = d.dept_id
WHERE salary > 50000;

Output:

 emp_name | dept_name 
----------+-----------
 SAMUEL   | AI
 RAJ      | MIS
(2 rows)

Display employees sorted by department name.

SELECT e.emp_name
FROM employeesTab e
JOIN departments d
ON e.dept_id = d.dept_id
ORDER BY dept_name;

Output:

 emp_name  
-----------
 SAMUEL
 KAMAL
 SARAVANAN
 RAJ
(4 rows)

Display employee name, salary and department name.

SELECT e.emp_name, e.salary, d.dept_name
FROM employeesTab e
JOIN departments d
ON e.dept_id = d.dept_id;

Output:

 emp_name  |  salary  | dept_name 
-----------+----------+-----------
 SARAVANAN | 35000.00 | IT
 SAMUEL    | 55000.00 | AI
 RAJ       | 52000.00 | MIS
 KAMAL     | 30000.00 | AI
(4 rows)

3. Products & Categories

Display product name and category name.

SELECT p.product_name, c.category_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id;

Output:

      product_name       |  category_name  
-------------------------+-----------------
 Wireless Mouse          | Electronics
 Bluetooth Speaker       | Electronics
 Dell Laptop             | Laptops
 HP Laptop               | Laptops
 iPhone 15               | Mobile Phones
 Samsung Galaxy          | Mobile Phones
 Office Chair            | Furniture
 Computer Table          | Furniture
 Java Programming Book   | Books
 Python Programming Book | Books
 Air Conditioner         | Home Appliances
 Microwave Oven          | Home Appliances

Display product name, price and category name.

SELECT p.product_name, p.price, c.category_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id;

Output:

      product_name       |  price   |  category_name  
-------------------------+----------+-----------------
 Wireless Mouse          |   799.00 | Electronics
 Bluetooth Speaker       |  1499.00 | Electronics
 Dell Laptop             | 65000.00 | Laptops
 HP Laptop               | 58000.00 | Laptops
 iPhone 15               | 65000.00 | Mobile Phones
 Samsung Galaxy          | 42000.00 | Mobile Phones
 Office Chair            |  7500.00 | Furniture
 Computer Table          | 12000.00 | Furniture
 Java Programming Book   |   850.00 | Books
 Python Programming Book |   950.00 | Books
 Air Conditioner         | 45000.00 | Home Appliances
 Microwave Oven          | 12000.00 | Home Appliances
(12 rows)

Display product name, category name and stock.

SELECT p.product_name, c.category_name, p.stock
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id;

Output:

      product_name       |  category_name  | stock 
-------------------------+-----------------+-------
 Wireless Mouse          | Electronics     |    50
 Bluetooth Speaker       | Electronics     |    25
 Dell Laptop             | Laptops         |    10
 HP Laptop               | Laptops         |     8
 iPhone 15               | Mobile Phones   |    15
 Samsung Galaxy          | Mobile Phones   |    20
 Office Chair            | Furniture       |    12
 Computer Table          | Furniture       |     5
 Java Programming Book   | Books           |    30
 Python Programming Book | Books           |    20
 Air Conditioner         | Home Appliances |     7
 Microwave Oven          | Home Appliances |     9
(12 rows)

Display products belonging to Electronics.

SELECT p.product_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id
WHERE c.category_name = 'Electronics';

Output:

   product_name    
-------------------
 Wireless Mouse
 Bluetooth Speaker
(2 rows)

Display products whose price is greater than Rs. 50,000.

SELECT p.product_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id
WHERE p.price > 50000;

Output:

 product_name 
--------------
 Dell Laptop
 HP Laptop
 iPhone 15
(3 rows)

Display products from Laptops category costing more than Rs. 60,000.

SELECT p.product_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id
WHERE c.category_name = 'Laptops' AND p.price > 60000;

Output:

 product_name 
--------------
 Dell Laptop
(1 row)

Display products whose stock is less than 10.

SELECT p.product_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id
WHERE p.stock < 10;

Output:

  product_name   
-----------------
 HP Laptop
 Computer Table
 Air Conditioner
 Microwave Oven
(4 rows)

Display products from Books category with price less than Rs. 1,000.

SELECT p.product_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id
WHERE c.category_name = 'Books' AND p.price < 10000;

Output:

      product_name       
-------------------------
 Java Programming Book
 Python Programming Book
(2 rows)

Display all products from Mobile Phones category costing more than Rs. 40,000.

SELECT p.product_name
FROM productsTab p
JOIN categories c
ON p.category_id = c.category_id
WHERE c.category_name = 'Mobile Phones' AND p.price > 40000;

Output:

  product_name  
----------------
 iPhone 15
 Samsung Galaxy
(2 rows)

Level 2 — Products & Categories

Display products from Electronics costing more than Rs. 1,000.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name = 'Electronics'and p.price > 1000;

Output:

   product_name    
-------------------
 Bluetooth Speaker
(1 row)

Display products from Furniture costing less than Rs. 10,000.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name = 'Furniture'and p.price < 10000;

Output:

 product_name 
--------------
 Office Chair
(1 row)

Display products from Mobile Phones having stock greater than 10.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name = 'Mobile Phones'and p.stock > 10;

Output:

  product_name  
----------------
 iPhone 15
 Samsung Galaxy
(2 rows)

Display products from Home Appliances costing more than Rs. 20,000.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name = 'Home Appliances'and p.price > 20000;

Output:

  product_name   
-----------------
 Air Conditioner
(1 row)

Display products whose price is between Rs. 10,000 and Rs. 50,000, along with their category.

select p.product_name, c.category_name
from productsTab p
join categories c
on p.category_id = c.category_id
where p.price between 10000 and 50000;

Output:

  product_name   |  category_name  
-----------------+-----------------
 Samsung Galaxy  | Mobile Phones
 Computer Table  | Furniture
 Air Conditioner | Home Appliances
 Microwave Oven  | Home Appliances
(4 rows)

Display products from Books where stock is greater than 20.

select p.product_name                 
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name = 'Books' and p.stock > 20;

Output:

     product_name      
-----------------------
 Java Programming Book
(1 row)

Display products from Laptops where price is less than Rs.60,000

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name = 'Laptops' and p.stock < 60000;

Output:

 product_name 
--------------
 Dell Laptop
 HP Laptop
(2 rows)

Level 3

Display products whose price is greater than ₹40,000 and stock is greater than 10.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where p.price > 40000 and p.stock > 10;

Output:

  product_name  
----------------
 Samsung Galaxy
 iPhone 15
(2 rows)

Display products belonging to either Laptops or Mobile Phones.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name = 'Laptops' or c.category_name = 'Mobile Phones';

Output:

  product_name  
----------------
 Dell Laptop
 HP Laptop
 iPhone 15
 Samsung Galaxy
(4 rows)

Display products belonging to either Books or Electronics, with price greater than ₹1,000.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name IN ('Books' , 'Electronics')
and p.price > 1000;

Output:

   product_name    
-------------------
 Bluetooth Speaker
(1 row)

Display products whose category is not Books.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name NOT IN ('Books');

Output:

   product_name    
-------------------
 Wireless Mouse
 Bluetooth Speaker
 Dell Laptop
 HP Laptop
 iPhone 15
 Samsung Galaxy
 Office Chair
 Computer Table
 Air Conditioner
 Microwave Oven
(10 rows)

Display products whose category name starts with 'M'.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name LIKE 'M%';

Output:

  product_name  
----------------
 iPhone 15
 Samsung Galaxy
(2 rows)

Display products whose category name contains the word 'Phone'.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where c.category_name LIKE '%Phone%';

Output:

  product_name  
----------------
 iPhone 15
 Samsung Galaxy
(2 rows)

Display products priced between ₹10,000 and ₹60,000 and having stock greater than 8.

select p.product_name
from productsTab p
join categories c
on p.category_id = c.category_id
where (p.price between 10000 and 60000)
and p.stock > 8;

Output:

  product_name  
----------------
 Samsung Galaxy
 Microwave Oven
(2 rows)

Level 4: Students → Student Courses → Trainers → Courses

Level 1: Difficulty Level: Easy

1. Display the course name and trainer name for every course.

select c.course_name, t.trainer_name
from course c join trainers t
on c.trainer_id = t.trainer_id;

Output:

   course_name    | trainer_name 
------------------+--------------
 Python           | Vijay
 Java             | Muthu
 PostgreSQL       | Arun
 Spring Boot      | Muthu
 React            | Prithvi
 Software Testing | Vallarasu
 AWS              | Vijay
(7 rows)

2. Display:

Course Name
Trainer Name
Trainer Specialization

select c.course_name, t.trainer_name, t.specialization
from course c join trainers t
on c.trainer_id = t.trainer_id;

Output:

   course_name    | trainer_name |   specialization   
------------------+--------------+--------------------
 Python           | Vijay        | Python & AWS
 Java             | Muthu        | Java & Spring Boot
 PostgreSQL       | Arun         | PostgreSQL
 Spring Boot      | Muthu        | Java & Spring Boot
 React            | Prithvi      | React
 Software Testing | Vallarasu    | Software Testing
 AWS              | Vijay        | Python & AWS
(7 rows)

3. Display all courses taught by Vijay.

select c.course_name, t.trainer_name 
from course c join trainers t
on c.trainer_id = t.trainer_id
where trainer_name = 'Vijay';

Output:

 course_name | trainer_name 
-------------+--------------
 Python      | Vijay
 AWS         | Vijay
(2 rows)

4. Display all courses taught by trainers having more than 5 years of experience.

select c.course_name from course c join trainers t
on c.trainer_id = t.trainer_id
where experience_years > 5;

Output:

   course_name    
------------------
 Python
 Java
 PostgreSQL
 Spring Boot
 Software Testing
 AWS
(6 rows)

5. Display the course name and fee along with the trainer name.

select c.course_name, c.fee, t.trainer_name
from course c join trainers t
on c.trainer_id = t.trainer_id;

Output:

   course_name    |   fee    | trainer_name 
------------------+----------+--------------
 Python           | 25000.00 | Vijay
 Java             | 30000.00 | Muthu
 PostgreSQL       | 20000.00 | Arun
 Spring Boot      | 28000.00 | Muthu
 React            | 22000.00 | Prithvi
 Software Testing | 18000.00 | Vallarasu
 AWS              | 32000.00 | Vijay
(7 rows)

Level 2 — Student + Course

Difficulty: Easy

6. Display the student name and course name for every enrollment.

select s.student_name, c.course_name
from student s join student_courses sc
on s.student_id  = sc.student_id
join course c
on c.course_id = sc.course_id;

Output:

 student_name |   course_name    
--------------+------------------
 Arul         | Python
 Arul         | AWS
 Kavin        | Java
 Venba        | PostgreSQL
 Venba        | Spring Boot
 Kanmani      | React
 Mathi        | Software Testing
 Paari        | Python
 Paari        | Spring Boot
 Kathir       | Java
 Seyon        | React
(11 rows)

7. Display:

Student Name
City
Course Name
Enrollment Date

select s.student_name, s.city, c.course_name, sc.enrolled_date
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on c.course_id = sc.course_id;

Output:

 student_name |    city    |   course_name    | enrolled_date 
--------------+------------+------------------+---------------
 Arul         | Chennai    | Python           | 2026-01-10
 Arul         | Chennai    | AWS              | 2026-02-15
 Kavin        | Madurai    | Java             | 2026-01-12
 Venba        | Chennai    | PostgreSQL       | 2026-01-15
 Venba        | Chennai    | Spring Boot      | 2026-02-01
 Kanmani      | Coimbatore | React            | 2026-01-20
 Mathi        | Salem      | Software Testing | 2026-02-05
 Paari        | Chennai    | Python           | 2026-01-25
 Paari        | Chennai    | Spring Boot      | 2026-02-10
 Kathir       | Trichy     | Java             | 2026-02-12
 Seyon        | Coimbatore | React            | 2026-02-20
(11 rows)

8. Find all courses taken by Muthu.

select c.course_name
from course c
join trainers t
on c.trainer_id = t.trainer_id
where trainer_name = 'Muthu';

Output:

 course_name 
-------------
 Java
 Spring Boot
(2 rows)

9. Find all students who have enrolled in Java.

select s.student_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on c.course_id = sc.course_id
where course_name = 'Java';

Output:

 student_name 
--------------
 Kavin
 Kathir
(2 rows)

10. Find all students from Chennai and the courses they have enrolled in.

select s.student_name, c.course_name
from student s join student_courses sc
on s.student_id = sc.student_id
join course c
on c.course_id = sc.course_id
where s.city = 'Chennai';

Output:

 student_name | course_name 
--------------+-------------
 Arul         | Python
 Arul         | AWS
 Venba        | PostgreSQL
 Venba        | Spring Boot
 Paari        | Python
 Paari        | Spring Boot
(6 rows)

Level 3 - Three/Four Table JOIN

Difficulty Level: Intermediate

11. Display Student Name, Course Name and Trainer Name

select s.student_name, c.course_name, t.trainer_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on c.course_id = sc.course_id
join trainers t
on c.trainer_id = t.trainer_id;

Output:

 student_name |   course_name    | trainer_name 
--------------+------------------+--------------
 Arul         | Python           | Vijay
 Arul         | AWS              | Vijay
 Kavin        | Java             | Muthu
 Venba        | PostgreSQL       | Arun
 Venba        | Spring Boot      | Muthu
 Kanmani      | React            | Prithvi
 Mathi        | Software Testing | Vallarasu
 Paari        | Python           | Vijay
 Paari        | Spring Boot      | Muthu
 Kathir       | Java             | Muthu
 Seyon        | React            | Prithvi
(11 rows)

12. Display Student Name, Student City, Course Name, Trainer Name

from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on c.course_id = sc.course_id
join trainers t
on c.trainer_id = t.trainer_id;

Output:

 student_name |    city    |   course_name    | trainer_name 
--------------+------------+------------------+--------------
 Arul         | Chennai    | Python           | Vijay
 Arul         | Chennai    | AWS              | Vijay
 Kavin        | Madurai    | Java             | Muthu
 Venba        | Chennai    | PostgreSQL       | Arun
 Venba        | Chennai    | Spring Boot      | Muthu
 Kanmani      | Coimbatore | React            | Prithvi
 Mathi        | Salem      | Software Testing | Vallarasu
 Paari        | Chennai    | Python           | Vijay
 Paari        | Chennai    | Spring Boot      | Muthu
 Kathir       | Trichy     | Java             | Muthu
 Seyon        | Coimbatore | React            | Prithvi
(11 rows)

13. Display Student Name, Course Name, Trainer Name, Trainer Specialization

select s.student_name, c.course_name, t.trainer_name, t.specialization
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on c.course_id = sc.course_id
join trainers t
on c.trainer_id = t.trainer_id;

Output:

 student_name |   course_name    | trainer_name |   specialization   
--------------+------------------+--------------+--------------------
 Arul         | Python           | Vijay        | Python & AWS
 Arul         | AWS              | Vijay        | Python & AWS
 Kavin        | Java             | Muthu        | Java & Spring Boot
 Venba        | PostgreSQL       | Arun         | PostgreSQL
 Venba        | Spring Boot      | Muthu        | Java & Spring Boot
 Kanmani      | React            | Prithvi      | React
 Mathi        | Software Testing | Vallarasu    | Software Testing
 Paari        | Python           | Vijay        | Python & AWS
 Paari        | Spring Boot      | Muthu        | Java & Spring Boot
 Kathir       | Java             | Muthu        | Java & Spring Boot
 Seyon        | React            | Prithvi      | React
(11 rows)

14. Find all students who are learning courses handled by Vallarasu.

select s.student_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
where t.trainer_name = 'Vallarasu';

Output:

 student_name 
--------------
 Mathi
(1 row)

15. Find all students who are learning Python, along with their trainer's name.

select s.student_name, t.trainer_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on c.course_id = sc.course_id
join trainers t
on t.trainer_id = c.trainer_id
where c.course_name = 'Python';

Output:

 student_name | trainer_name 
--------------+--------------
 Arul         | Vijay
 Paari        | Vijay
(2 rows)

16. Find all students who are learning courses taught by trainers having more than 7 years of experience.

select s.student_name                
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
where t.experience_years > 7;

Output:

 student_name 
--------------
 Arul
 Arul
 Kavin
 Venba
 Paari
 Paari
 Kathir
(7 rows)

Level 4 - JOIN + WHERE

Difficulty Level: Intermediate

17. Display students from Chennai who are learning Python.

select s.student_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
where s.city = 'Chennai' and c.course_name = 'Python';

Output:

 student_name 
--------------
 Arul
 Paari
(2 rows)

18. Display students from Coimbatore along with their course and trainer.

select s.student_name, c.course_name, t.trainer_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
where s.city = 'Coimbatore';

Output:

 student_name | course_name | trainer_name 
--------------+-------------+--------------
 Kanmani      | React       | Prithvi
 Seyon        | React       | Prithvi
(2 rows)

19. Find courses costing more than Rs. 25,000 and display their trainers.

SELECT c.course_name, t.trainer_name
FROM course c
JOIN trainers t
    ON c.trainer_id = t.trainer_id
WHERE c.fee > 25000;

Output:

 course_name | trainer_name 
-------------+--------------
 Java        | Muthu
 Spring Boot | Muthu
 AWS         | Vijay
(3 rows)

20. Find students enrolled in courses costing more than Rs. 25,000.

select s.student_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
where c.fee > 25000;

Output:

 student_name 
--------------
 Arul
 Kavin
 Venba
 Paari
 Kathir
(5 rows)

21. Find students learning courses taught by trainers with at least 8 years of experience.

select s.student_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
where t.experience_years >= 8;

Output:

 student_name 
--------------
 Arul
 Arul
 Kavin
 Venba
 Paari
 Paari
 Kathir
(7 rows)

22. Find all students from Chennai who are learning courses costing more than Rs.20,000.

select s.student_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
where c.fee > 20000 and s.city = 'Chennai';

Output:

 student_name 
--------------
 Arul
 Arul
 Venba
 Paari
 Paari
(5 rows)

Level 5 - JOIN + ORDER BY

Difficulty Level: Easy

23. Display all students, their courses and trainers, sorted by student name.

select s.student_name, c.course_name, t.trainer_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
order by s.student_name;

Output:

 student_name |   course_name    | trainer_name 
--------------+------------------+--------------
 Arul         | Python           | Vijay
 Arul         | AWS              | Vijay
 Kanmani      | React            | Prithvi
 Kathir       | Java             | Muthu
 Kavin        | Java             | Muthu
 Mathi        | Software Testing | Vallarasu
 Paari        | Spring Boot      | Muthu
 Paari        | Python           | Vijay
 Seyon        | React            | Prithvi
 Venba        | Spring Boot      | Muthu
 Venba        | PostgreSQL       | Arun
(11 rows)

24. Display all courses and trainers, sorted by course fee from highest to lowest.

select c.course_name, t.trainer_name
from course c
join trainers t
on c.trainer_id = t.trainer_id
order by c.fee desc;

Output:

   course_name    | trainer_name 
------------------+--------------
 AWS              | Vijay
 Java             | Muthu
 Spring Boot      | Muthu
 Python           | Vijay
 React            | Prithvi
 PostgreSQL       | Arun
 Software Testing | Vallarasu
(7 rows)

25. Display students and their courses, sorted by enrollment date.

select s.student_name, c.course_name
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
join trainers t
on c.trainer_id = t.trainer_id
order by sc.enrolled_date;

Output:

 student_name |   course_name    
--------------+------------------
 Arul         | Python
 Kavin        | Java
 Venba        | PostgreSQL
 Kanmani      | React
 Paari        | Python
 Venba        | Spring Boot
 Mathi        | Software Testing
 Paari        | Spring Boot
 Kathir       | Java
 Arul         | AWS
 Seyon        | React
(11 rows)

26. Display courses with their trainers, sorted by trainer experience from highest to lowest.

select c.course_name, t.trainer_name
from course c
join trainers t
on c.trainer_id = t.trainer_id
order by t.experience_years desc;

Output:

   course_name    | trainer_name 
------------------+--------------
 Spring Boot      | Muthu
 Java             | Muthu
 Python           | Vijay
 AWS              | Vijay
 Software Testing | Vallarasu
 PostgreSQL       | Arun
 React            | Prithvi
(7 rows)

Level 6 - JOIN + GROUP BY

Difficulty Level: Easy

27. Find the number of students enrolled in each course.

select c.course_name, count(s.student_name) "student_count"
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id
group by c.course_name;

Output:

   course_name    | student_count 
------------------+---------------
 Python           |             2
 Software Testing |             1
 React            |             2
 PostgreSQL       |             1
 Spring Boot      |             2
 AWS              |             1
 Java             |             2
(7 rows)

28. Find the number of students handled by each trainer.

select t.trainer_name, count(s.student_name) "student_count"
from student s
join student_courses sc
on s.student_id = sc.student_id
join course c
on sc.course_id = c.course_id 
join trainers t 
on c.trainer_id = t.trainer_id
group by t.trainer_name;

Output:

 trainer_name | student_count 
--------------+---------------
 Muthu        |             4
 Prithvi      |             2
 Vijay        |             3
 Arun         |             1
 Vallarasu    |             1
(5 rows)

29. Find the number of courses handled by each trainer.

select t.trainer_name, count(c.course_name)
from trainers t 
join course c
on t.trainer_id = c.trainer_id
group by t.trainer_name;

Output:

 trainer_name | count 
--------------+-------
 Muthu        |     2
 Prithvi      |     1
 Vijay        |     2
 Arun         |     1
 Vallarasu    |     1
(5 rows)

30. Find trainers who are handling more than one course.

select t.trainer_name, count(c.course_name)
from trainers t 
join course c
on t.trainer_id = c.trainer_id
group by t.trainer_name
having count(c.course_name)>1;

Output:

 trainer_name | count 
--------------+-------
 Muthu        |     2
 Vijay        |     2
(2 rows)

31. Find courses having more than one student.

select c.course_name, count(s.student_name) "student_count"
from course c
join student_courses sc
on c.course_id = sc.course_id
join student s
on sc.student_id = s.student_id
group by c.course_name
having count(s.student_name)>1;

Output:

 course_name | student_count 
-------------+---------------
 Python      |             2
 React       |             2
 Spring Boot |             2
 Java        |             2
(4 rows)

32. Find the total course fee of all courses handled by each trainer.

select t.trainer_name, sum(c.fee)
from trainers t 
join course c
on t.trainer_id = c.trainer_id
group by t.trainer_name;

Output:

 trainer_name |   sum    
--------------+----------
 Muthu        | 58000.00
 Prithvi      | 22000.00
 Vijay        | 57000.00
 Arun         | 20000.00
 Vallarasu    | 18000.00
(5 rows)

Level 7 - LEFT JOIN

Now introduce students who haven't enrolled in any course.
For this, insert as below first:

INSERT INTO students (student_name, email, city) VALUES
('Vijay', 'vijay@gmail.com', 'Chennai'),
('Anitha', 'anitha@gmail.com', 'Madurai');

33. Display all students, including students who haven't enrolled in any course.

select s.student_name, c.course_name
from student s
left join student_courses sc
on s.student_id = sc.student_id
left join course c
on sc.course_id = c.course_id;

Output:

 student_name |   course_name    
--------------+------------------
 Arul         | Python
 Arul         | AWS
 Kavin        | Java
 Venba        | PostgreSQL
 Venba        | Spring Boot
 Kanmani      | React
 Mathi        | Software Testing
 Paari        | Python
 Paari        | Spring Boot
 Kathir       | Java
 Seyon        | React
 Anitha       | 
 Vijay        | 
(13 rows)

34. Find students who have not enrolled in any course.

select s.student_name, c.course_name
from student s
left join student_courses sc
on s.student_id = sc.student_id
left join course c
on sc.course_id = c.course_id
where c.course_name is null;

Output:

 student_name | course_name 
--------------+-------------
 Anitha       | 
 Vijay        | 
(2 rows)

35. Display all courses, including courses that currently have no students.

select c.course_name, count(s.student_name)
from course c
left join student_courses sc
on c.course_id = sc.course_id
left join student s
on sc.student_id = s.student_id
group by c.course_name;

Output:

   course_name    | count 
------------------+-------
 Python           |     2
 Software Testing |     1
 React            |     2
 PostgreSQL       |     1
 Spring Boot      |     2
 AWS              |     1
 Java             |     2
(7 rows)

36. Display all trainers, including trainers who are currently not teaching any course.

select t.trainer_name, c.course_name
from trainers t
left join course c
on t.trainer_id = c.trainer_id;

Output:

 trainer_name |   course_name    
--------------+------------------
 Vijay        | Python
 Muthu        | Java
 Arun         | PostgreSQL
 Muthu        | Spring Boot
 Prithvi      | React
 Vallarasu    | Software Testing
 Vijay        | AWS
 Siva         | 
(8 rows)

37. Find trainers who are not assigned to any course.

select t.trainer_name, c.course_name
from trainers t
left join course c
on t.trainer_id = c.trainer_id
where c.course_name is null;

Output:

 trainer_name | course_name 
--------------+-------------
 Siva         | 
(1 row)

Level 8 – DIFFICULTY LEVEL: HARD

38. Find the trainer who teaches the maximum number of students.

(I tried with sub-query concept, but it didn't work)

select t.trainer_name, max(count)
from    (select t.trainer_name, count(s.student_name)
        from trainers t
    join course c
    on t.trainer_id = c.trainer_id
    join student_courses sc
    on c.course_id = sc.course_id
    join student s
    on sc.student_id = s.student_id
    group by t.trainer_name
);

(Referred Online)

SELECT t.trainer_name, COUNT(s.student_id) AS student_count
FROM trainers t
JOIN course c
    ON t.trainer_id = c.trainer_id
JOIN student_courses sc
    ON c.course_id = sc.course_id
JOIN student s
    ON sc.student_id = s.student_id
GROUP BY t.trainer_name
ORDER BY student_count DESC
LIMIT 1;

Output:

 trainer_name | student_count 
--------------+---------------
 Muthu        |             4
(1 row)

39. Find the course with the maximum number of students.

(I was able to find the count of each students, but I couldn't figure out how to find Max number)

select c.course_name, count(s.student_id) AS student_count
from course c
join student_courses sc
    on c.course_id = sc.course_id
join student s
    on  sc.student_id = s.student_id
group by c.course_name
order by student_count desc;

Output:

   course_name    | student_count 
------------------+---------------
 Spring Boot      |             2
 React            |             2
 Java             |             2
 Python           |             2
 PostgreSQL       |             1
 Software Testing |             1
 AWS              |             1
(7 rows)

Looping Programs in JS and Python

Saravanan Lakshmanan — Wed, 12 Aug 2026 14:22:19 +0000

A king announces a unique reward for Hard Workers. On each day, the reward is multiplied by the day's number. The reward starts at 1 gold coin. Given the number of days n, write a program to calculate the final reward. hint: factorial

//JS
let reward = 1;
let n = 5;

let i = 1;
while(i <= n){
    reward *= i;
    i++;
}
console.log(`${n} days reward = ${reward}`);

#Python
reward = 1
n = 5
i = 1

while i <= n:
    reward *= i
    i += 1

print(f"{n} days reward = {reward}")

Output: 5 days reward = 120

Suppose a password consists of the letters: A, B, C, D. Each letter must be used exactly once. How many different passwords are possible? hint: factorial

//JS
let letters = 4;
let result = 1;
let i = 1;

while (i <= letters) {
    result *= i;
    i++;
}

console.log(result);

#Python
letters = 4
result = 1
i = 1

while i <= letters:
    result *= i
    i += 1

print(result)

output: 24

A frog accidentally falls into a 60-foot-deep well.

Every day:

During the day, the frog climbs 2 feet.
During the night, it slips down 0.5 feet.

This pattern continues every day until the frog reaches the top of the well and escapes.

Write a program to determine:

How many days it takes for the frog to get out of the well.
On which day the frog escapes.

Note: Once the frog reaches or crosses the top of the well during the daytime, it escapes immediately and does not slip back that night.

//JS
let up = 0;
let day = 0;
let n = 60;


while(up<=60){
    up = up + 2;
    day = day + 1;

    if(up >= n){
        break;
    }
    up = up - 0.5;
}
console.log("Number of days:", day);
console.log("Frog escapes on day:", day);

#Python
up = 0
day = 0
n = 60

while up <= 60:
    up = up + 2
    day = day + 1

    if up >= n:
        break

    up = up - 0.5

print("Number of days:", day)
print("Frog escapes on day:", day)

Output: Number of days: 40
Frog escapes on day: 40

11) The Saint's Flower Basket

A saint goes for a morning walk every day. During his walk, he plucks flowers and keeps them in a basket.

On his way back home, he visits 7 temples. At each temple, he offers half of the flowers currently in his basket.

After visiting all 7 temples, he reaches home with exactly one flower remaining in his basket.

Write a program to determine how many flowers the saint had in his basket before he visited the first temple.

Hint: Think carefully about whether it is easier to solve the problem from the beginning or by working backwards from the final flower.

//JS
let flower = 1;
let temple = 0;

while(temple < 7){
    flower = flower *2;
    temple += 1;
}

console.log("Total Flowers = " + flower);

#Python
flower = 1
temple = 0

while temple < 7:
    flower = flower * 2
    temple += 1

print("Total Flowers =", flower)

Output: Total Flowers = 128

Looping Exercises (With & Without if Condition)

Saravanan Lakshmanan — Wed, 05 Aug 2026 10:38:15 +0000

1) Five students enter the classroom one after another. The first student gets roll number 1, the second gets 2, and so on. Display the assigned roll numbers.

let students = 5;

for(let i = 1; i <= students; i++){
console.log(i);
}

Output:
1
2
3
4
5

2) A coach asks students to stand only at even-numbered positions in a queue. Display the first five positions.

let reqPositions = 5;

(without if condition)

for(let i = 2; i <= reqPositions * 2; i += 2){
console.log(i);
}

(with if condition)

for(let i = 1; i <= reqPositions * 2; i++){
if(i % 2 === 0){
console.log(i);
}
}

Output:
2
4
6
8
10

3) A newly constructed building has a special lift that does not stop on every floor. For safety reasons, it stops only at every third floor. A person enters the lift at the ground floor and presses the "Up" button. Display the first five floors where the lift will stop. (TBD)

let reqFloors = 5;

(without if condition)

for(let i = 0; i <= reqFloors * 3; i += 3){
console.log(i);
}

(with if condition)

for(let i = 0; i <= reqFloors * 3; i++){
if(i % 3 === 0){
console.log(i);
}
}

Output:
0
3
6
9
12
15

4) A rocket launches with a countdown using only even numbers from 10. Display the countdown.

(without if condition)

for(let i = 10; i >= 0; i -= 2){
console.log(i);
}

(with if condition)

for(let i = 10; i >= 0; i--){
if(i % 2 === 0){
console.log(i);
}
}

Output:
10
8
6
4
2
0

Stop Prop Drilling: Learn React useContext with Easy Examples

Saravanan Lakshmanan — Sun, 02 Aug 2026 06:37:20 +0000

React `useContext` Hook Explained with Simple Examples

If you've started learning React Hooks, you've probably heard about useContext. At first, it may seem confusing, but once you understand the problem it solves, it becomes much easier.

What is `useContext`?

useContext is a React Hook that allows multiple components to access the same data without passing it through every intermediate component as props.

In simple words:

useContext helps you share data between components directly.

Why do we need `useContext`?

Imagine the following component structure:

App
 ├── Parent
      ├── Child
            ├── GrandChild

Suppose the GrandChild component needs the user's name.

Without useContext, you would have to pass the data like this:

<App user="Saravanan">
   ↓
<Parent user={user}>
   ↓
<Child user={user}>
   ↓
<GrandChild user={user}>

Even though only GrandChild needs the data, every component in between has to receive and pass it.

This process is called prop drilling.

useContext solves this problem.

Real-Time Example

Think of a company.

The CEO announces a holiday.
Every employee should know about it.
The CEO doesn't tell each employee individually.
Instead, the announcement is placed on the company notice board where everyone can read it.

In React:

Context = Notice board
Provider = Person who posts the announcement
Consumer (useContext) = Employees reading the announcement

No need to pass the information through every manager.

Another Simple Example

Imagine your house has Wi-Fi.

Every family member connects to the same Wi-Fi.

The password is not passed from one family member to another every time someone wants internet access.

Instead, everyone accesses the same network directly.

useContext works similarly.

Syntax

Step 1: Create a Context

import { createContext } from "react";

const UserContext = createContext();

Step 2: Provide the Data

<UserContext.Provider value="Saravanan">
    <Child />
</UserContext.Provider>

The value prop contains the data that will be shared.

Step 3: Consume the Data

import { useContext } from "react";

const user = useContext(UserContext);

return <h1>{user}</h1>;

Now the component can access the shared data directly.

Complete Example

App.jsx

import { createContext } from "react";
import Child from "./Child";

export const UserContext = createContext();

function App() {
  return (
    <UserContext.Provider value="Saravanan">
      <Child />
    </UserContext.Provider>
  );
}

export default App;

Child.jsx

import GrandChild from "./GrandChild";

function Child() {
  return <GrandChild />;
}

export default Child;

GrandChild.jsx

import { useContext } from "react";
import { UserContext } from "./App";

function GrandChild() {
  const user = useContext(UserContext);

  return <h2>Hello, {user}</h2>;
}

export default GrandChild;

Output

Hello, Saravanan

Notice that Child never receives any props.

GrandChild directly accesses the shared value.

How `useContext` Works

createContext()
        │
        ▼
Context Object
        │
        ▼
Provider shares data
        │
        ▼
Child Components
        │
        ▼
useContext() reads the data

Python Is More Than Just print("Hello World"): Understanding the Fundamentals

Saravanan Lakshmanan — Sun, 26 Jul 2026 14:41:56 +0000

I recently started learning Python, and in my first session, we explored some important fundamentals about Python, programming languages, Python versions, Python implementations, and the features that make Python popular.

Before jumping directly into coding, understanding these basics gives us a better idea of what Python actually is and why it is widely used.

What is Python?

Python is a high-level, general-purpose programming language known for its simple and readable syntax.

It is used in many areas, including:

Web Development
Automation
Data Science
Artificial Intelligence
Machine Learning
Scripting
Backend Development
Software Development

Python is designed to be easy to read and write, which makes it popular among beginners as well as experienced developers.

Understanding Python Version Numbers

You may have seen Python versions written like this:

Python 3.14.6

Let's understand what these numbers mean.

Major Version

The first number represents the major version.

Examples:

Python 2
Python 3

Python 2 and Python 3 are major versions with significant differences.

Minor Version

The second number represents the minor version.

Examples:

Python 3.13
Python 3.14

A new minor version can introduce new language features, improvements, and changes.

Maintenance or Patch Version

The third number represents the maintenance or patch release.

Example:

Python 3.14.6

This can be understood as:

3 → Major version
14 → Minor version
6 → Maintenance/Patch release

Patch releases generally focus on:

Bug fixes
Security fixes
Stability improvements
Other small improvements

Understanding Alpha, Beta, RC, and Development Versions

When looking at Python releases, we may see versions such as:

3.15.0a1
3.15.0b1
3.15.0rc1
3.15.0
3.15.0.dev1

These indicate different stages of development.

Alpha (a)

Example:

3.15.0a1

An Alpha version is an early development version.

It may contain new features, but the features and behavior can still change.

Alpha versions are mainly useful for developers and testers.

Beta (b)

Example:

3.15.0b1

A Beta version is more mature than an Alpha version, but it may still contain bugs and changes.

It is released for further testing before the final version.

Release Candidate (rc)

Example:

3.15.0rc1

A Release Candidate is almost ready for the final release.

If no major problems are discovered, the Release Candidate may become the final version.

Final Release

Example:

3.15.0

This is the official stable release.

It is considered ready for general use.

Development Version (dev)

Example:

3.15.0.dev1

A development version represents an early stage of development before the Alpha stage.

The general progression is:

Development
     ↓
Alpha
     ↓
Beta
     ↓
Release Candidate
     ↓
Final Release

What is CPython?

CPython is the original and most widely used implementation of Python.

It is written primarily in the C programming language.

When most people download and install Python from the official Python website, they are generally using CPython.

A simple representation is:

Python Code
     ↓
CPython
     ↓
Execution

CPython is the reference implementation of Python and is the implementation most commonly used by Python developers.

What is Jython?

Jython is an implementation of Python designed to run on the Java platform.

It allows Python code to interact with Java libraries and Java applications.

In simple terms:

Python + Java Platform = Jython

Jython can be useful when Python code needs to work with Java-based applications and libraries.

What is IronPython?

IronPython is an implementation of Python designed for the .NET platform.

It allows Python code to work with the .NET ecosystem and interact with .NET libraries.

In simple terms:

Python + .NET Platform = IronPython

Important Features of Python

1. Simple and Easy to Learn

Python has a clean and readable syntax.

For example:

print("Hello, Python!")

This code is simple and easy to understand.

Python syntax is designed to be close to natural language, which makes it beginner-friendly.

Compared to many other programming languages, Python generally requires less code to perform the same task.

2. Open Source

Python is open-source software.

This means:

Anyone can use Python.
Anyone can download Python.
Developers can study its source code.
Developers can contribute to its development.
Python can be used for personal and commercial projects.

Python is freely available to developers around the world.

3. Object-Oriented Programming

Python supports Object-Oriented Programming, commonly known as OOP.

Object-Oriented Programming allows us to organize programs using:

Classes
Objects
Inheritance
Encapsulation
Polymorphism
Abstraction

Example:

class Student:
    pass

Here, Student is a class.

A class can be used as a blueprint for creating objects.

Python also supports other programming styles, including:

Procedural Programming
Functional Programming

Therefore, Python is a multi-paradigm programming language.

4. High-Level Programming Language

Python is a high-level programming language.

High-level languages are designed to be easier for humans to read and understand.

Example:

print("Hello, Python!")

We do not need to directly manage:

CPU registers
Memory addresses
Machine instructions

The Python implementation handles many low-level details for us.

Low-Level Language

Examples:

Machine Language
Assembly Language

These languages are closer to the hardware and are more difficult for humans to understand.

High-Level Language

Examples:

Python
Java
JavaScript
C++
C#

These languages are easier for humans to read and write.

5. Dynamically Typed Language

Python is a dynamically typed programming language.

This means we do not need to explicitly declare the data type of a variable.

Example:

x = 10

Python automatically understands that x contains an integer.

name = "Saravanan"

Python understands that name contains a string.

price = 99.99

Python understands that price contains a floating-point number.

The data type is determined automatically during program execution.

6. Interpreted Language

Python is commonly described as an interpreted programming language.

Python code is executed by the Python interpreter.

A simple representation is:

Python Source Code
        ↓
Python Interpreter
        ↓
Program Execution

The interpreter reads and executes Python code.

In CPython, Python source code is first compiled into an intermediate form called bytecode.

The bytecode is then executed by the Python Virtual Machine, commonly known as the PVM.

A simplified representation is:

Python Source Code
        ↓
Bytecode
        ↓
Python Virtual Machine
        ↓
Execution

7. Extensive Standard Library

Python comes with a large collection of built-in modules and libraries.

These libraries provide ready-made functionality for many tasks.

Examples include:

File handling
Mathematics
Date and time operations
Regular expressions
Internet communication
Operating system interaction

For example:

import math

print(math.sqrt(25))

Output:

5.0

Instead of writing the square root logic ourselves, we can use the built-in math module.

Python is often called:

"Batteries included"

This means Python provides many useful tools and libraries out of the box.

8. Large Ecosystem of Third-Party Libraries

In addition to the standard library, Python has a huge ecosystem of third-party libraries.

Developers can install additional packages to add more functionality.

Examples:

NumPy → Numerical computing
Pandas → Data analysis
Matplotlib → Data visualization
Django → Web development
Flask → Web development
TensorFlow → Machine Learning
PyTorch → Deep Learning
Requests → HTTP requests

This large ecosystem is one of the major reasons Python is so popular.

9. Platform Independent

Python is a cross-platform programming language.

Python programs can generally run on different operating systems, including:

Windows
Linux
macOS

For example, a Python program written on Windows can usually be executed on Linux or macOS with little or no modification.

A simple representation is:

Python Program
      ↓
Python Interpreter
      ↓
Windows / Linux / macOS

However, certain operating-system-specific features may require modifications.

10. General-Purpose Programming Language

Python is a general-purpose programming language.

This means it is not limited to only one specific type of application.

Python can be used for:

Web Development
Automation
Data Analysis
Data Science
Artificial Intelligence
Machine Learning
Backend Development
Scripting
Game Development
Desktop Applications
Cybersecurity
Scientific Computing

Because of this flexibility, Python is useful in many different industries.

11. Portable

Python programs can often be moved from one operating system to another.

For example:

Windows
    ↓
Python Program
    ↓
Linux

In many cases, the same Python code can work on both systems.

This makes Python portable.

However, external dependencies and operating-system-specific features may sometimes require additional configuration.

12. Extensible

Python can be extended using code written in other programming languages such as:

C
C++
Rust

This can be useful when high performance is required.

For example, Python can use code written in C to perform certain operations more quickly.

This allows developers to combine:

Python
   +
High-Performance Languages

13. Embeddable

Python can be embedded inside applications written in other programming languages.

For example, Python can be integrated into applications written using languages such as C or C++.

This allows developers to use Python's flexibility inside larger software applications.

14. Automatic Memory Management

Python provides automatic memory management.

Developers generally do not need to manually allocate and release memory.

Python uses a mechanism called Garbage Collection to manage unused objects.

For example:

x = 10

When an object is no longer needed, Python can automatically clean up the memory associated with it.

This makes programming easier and reduces certain types of memory-management errors.

React useEffect Explained: Understanding Mounting, Updating, and Unmounting

Saravanan Lakshmanan — Fri, 24 Jul 2026 09:17:52 +0000

When learning React, two important concepts are the component lifecycle and the useEffect Hook.

A React component is not just created once and forgotten. It goes through different stages during its existence:

Mounting
Updating
Unmounting

The useEffect Hook helps us perform side effects during these stages. Examples of side effects include fetching data from an API, working with timers, adding event listeners, and interacting with external systems.

What is a React Component?

A React component is an independent and reusable part of a user interface. In modern React, components are commonly created using JavaScript functions.

For example:

function Welcome() {
    return <h1>Welcome to React</h1>;
}

When React uses this component, it renders the JSX returned by the function.

A component can have its own state, receive props, and respond to changes during its lifetime.

This is where the concept of the component lifecycle becomes important.

The Three Stages of a React Component

Every React component goes through three major stages:

Mounting → Updating → Unmounting

We can understand these stages using a simple real-life example.

Think of a component like a person:

Birth → Life and Changes → Departure

In React:

Component Created → Component Updated → Component Removed

1. Mounting

Mounting is the first stage of a component's lifecycle.

It happens when a component is created and added to the page for the first time.

For example:

function App() {
    return <h1>Hello React</h1>;
}

When React displays this component for the first time, the component is mounted.

The basic process is:

Component is created
        ↓
React renders the component
        ↓
The UI appears on the page

For function components, useEffect with an empty dependency array is commonly used when an effect should run after the initial render.

Example:

import { useEffect } from "react";

function App() {

    useEffect(() => {
        console.log("Component mounted");
    }, []);

    return <h1>Hello React</h1>;
}

export default App;

The empty dependency array is:

[]

This tells React that the effect should run after the initial render and should not run again because of later state or prop changes.

A common use case is fetching initial data:

useEffect(() => {
    fetchData();
}, []);

The empty array is useful when the operation should happen only when the component initially appears.

2. Updating

After a component has been mounted, it may change.

A component can update when:

Its state changes
Its props change
Its parent component causes it to render again

For example:

import { useState } from "react";

function Counter() {

    const [count, setCount] = useState(0);

    return (
        <div>
            <h2>{count}</h2>

            <button onClick={() => setCount(count + 1)}>
                Increase
            </button>
        </div>
    );
}

export default Counter;

Initially:

count = 0

When the button is clicked:

count: 0 → 1

Because the state changed, React renders the component again with the updated value.

The process is:

State or props change
        ↓
React renders the component again
        ↓
The UI is updated

This is called the updating stage.

Understanding useEffect

The useEffect Hook is used to perform side effects in a component.

The basic syntax is:

useEffect(() => {
    // Side effect code
}, [dependencies]);

The second argument is called the dependency array.

The dependency array controls when the effect should run.

There are three important patterns.

Pattern 1: useEffect Without a Dependency Array

Example:

useEffect(() => {
    console.log("Effect executed");
});

When no dependency array is provided, the effect runs after every render.

Example:

function App() {

    const [count, setCount] = useState(0);

    useEffect(() => {
        console.log("Effect executed");
    });

    return (
        <button onClick={() => setCount(count + 1)}>
            {count}
        </button>
    );
}

The sequence is:

Initial render
      ↓
useEffect runs

Click button
      ↓
State changes
      ↓
Component renders again
      ↓
useEffect runs again

So:

Every render → useEffect runs

This can sometimes cause unwanted repeated operations.

For example, if an effect changes state and the effect runs after every render, it can potentially create repeated renders.

Therefore, the dependency array is important for controlling when an effect should execute.

Pattern 2: useEffect With an Empty Dependency Array

Example:

useEffect(() => {
    console.log("Effect executed");
}, []);

The empty dependency array means that the effect does not depend on any state or prop value.

The effect runs after the initial render.

The sequence is:

Component mounts
      ↓
Initial render
      ↓
useEffect runs
      ↓
Later re-renders occur
      ↓
Effect does not run again because of those changes

Example:

function App() {

    const [count, setCount] = useState(0);

    useEffect(() => {
        console.log("This runs after the initial render");
    }, []);

    return (
        <button onClick={() => setCount(count + 1)}>
            {count}
        </button>
    );
}

When the button is clicked:

count changes
      ↓
Component re-renders
      ↓
useEffect does not run again

A common example is fetching initial data:

useEffect(() => {
    fetch("https://example.com/api/data");
}, []);

The effect is intended to run when the component initially appears.

Pattern 3: useEffect With Dependencies

Example:

useEffect(() => {
    console.log("Count changed");
}, [count]);

Here, count is the dependency.

The effect runs:

After the initial render
Whenever count changes

Example:

function Counter() {

    const [count, setCount] = useState(0);
    const [count2, setCount2] = useState(10);

    useEffect(() => {
        console.log("Count changed");
    }, [count]);

    return (
        <div>

            <button onClick={() => setCount(count + 1)}>
                +
            </button>

            <button onClick={() => setCount2(count2 + 1)}>
                +2
            </button>

            <h2>Counter: {count}</h2>
            <h2>Counter 2: {count2}</h2>

        </div>
    );
}

Now consider what happens when each button is clicked.

Clicking the first button

count changes
      ↓
Component re-renders
      ↓
[count] has changed
      ↓
useEffect runs

Clicking the second button

count2 changes
      ↓
Component re-renders
      ↓
[count] has not changed
      ↓
useEffect does not run

This is a very important point:

The entire component can re-render even though a particular useEffect does not run.

The dependency array controls the execution of the effect, not whether the entire component renders.

A Simple Example to Understand the Difference

Consider:

const [count, setCount] = useState(0);
const [count2, setCount2] = useState(10);

useEffect(() => {
    console.log("Effect executed");
}, [count]);

When count changes:

count: 0 → 1

Component re-renders
        ↓
React checks [count]
        ↓
count changed
        ↓
useEffect runs

When count2 changes:

count2: 10 → 11

Component re-renders
        ↓
React checks [count]
        ↓
count did not change
        ↓
useEffect does not run

The component re-render and the effect execution are two different things.

This distinction is essential for understanding React.

3. Unmounting

Unmounting is the final stage of a component's lifecycle.

It happens when a component is removed from the page.

For example:

function App() {

    const [show, setShow] = useState(true);

    return (
        <div>

            {show && <Child />}

            <button onClick={() => setShow(false)}>
                Remove Component
            </button>

        </div>
    );
}

Initially:

show = true
      ↓
Child component is displayed

After clicking the button:

show = false
      ↓
Child component is removed
      ↓
Child component is unmounted

The lifecycle becomes:

Mount
  ↓
Update
  ↓
Unmount

useEffect Cleanup Function

Some effects create resources that should be stopped or removed when they are no longer needed.

Examples include:

Timers
Intervals
Event listeners
Subscriptions

The cleanup function is created by returning a function from useEffect.

Example:

useEffect(() => {

    const timer = setTimeout(() => {
        console.log("Timer completed");
    }, 1000);

    return () => {
        clearTimeout(timer);
    };

}, []);

The cleanup function is:

return () => {
    clearTimeout(timer);
};

When the component is removed, the cleanup code runs.

The process is:

Component mounts
      ↓
Timer starts
      ↓
Component is removed
      ↓
Cleanup function runs
      ↓
Timer is cleared

This prevents unnecessary operations from continuing after the component is gone.

Cleanup During Updates

Cleanup is not only used when a component is unmounted.

Suppose an effect depends on a value:

useEffect(() => {

    console.log("Effect started");

    return () => {
        console.log("Cleanup executed");
    };

}, [count]);

When count changes, React performs the following general sequence:

Previous effect cleanup
        ↓
Component updates
        ↓
New effect runs

So the lifecycle of an effect can look like:

Effect starts
      ↓
Dependency changes
      ↓
Previous effect cleanup
      ↓
New effect starts

This is particularly useful for subscriptions, timers, and event listeners.

Complete Component Lifecycle

The complete lifecycle can be represented like this:

                 MOUNTING
                    ↓
          Component is created
                    ↓
             Initial render
                    ↓
              useEffect runs
                    ↓
                 UPDATING
                    ↓
       State or props change
                    ↓
             Component renders
                    ↓
     Dependency value changed?
             ↙              ↘
           Yes               No
            ↓                 ↓
    Effect runs again     Effect does not run
                    ↓
                UNMOUNTING
                    ↓
       Component removed
                    ↓
            Cleanup runs

Ever wondered why React applications feel so fast? The answer lies in one of React's smartest concepts: the Virtual DOM.

Saravanan Lakshmanan — Thu, 16 Jul 2026 14:53:10 +0000

Real DOM vs Virtual DOM in React

What is the DOM?

DOM (Document Object Model) is a programming interface for HTML and XML documents. It represents the structure of a webpage as a tree of objects, allowing JavaScript to access, modify, add, or remove elements dynamically.

When a browser loads an HTML document, it creates the DOM in memory.

Example:

<body>
  <h1>Hello</h1>
  <p>Welcome</p>
</body>

DOM Tree:

Document
   │
  html
   │
  body
  ├── h1
  │     └── Hello
  └── p
        └── Welcome

JavaScript can manipulate these elements using methods like:

document.getElementById()
document.querySelector()
document.createElement()
document.removeChild()

What is Real DOM?

The Real DOM is the actual DOM created and maintained by the browser. Every HTML element becomes an object in memory.

Whenever JavaScript changes an element, the browser updates the Real DOM and may need to recalculate layout, repaint, and render the page again.

Example

<h1 id="title">Hello</h1>

document.getElementById("title").innerText = "Welcome";

The browser immediately updates the actual <h1> element on the webpage.

Problem with Real DOM

Imagine a webpage with 5,000 elements.

If only one button's text changes, the browser still needs to determine what changed, update the DOM, and potentially recalculate layout and repaint affected parts of the page.

Frequent DOM updates can become expensive because DOM operations are generally slower than working with plain JavaScript objects.

What is Virtual DOM?

The Virtual DOM is a lightweight JavaScript representation (copy) of the Real DOM.

It is not displayed on the screen. Instead, React uses it internally to determine what has changed before updating the browser's Real DOM.

When data changes:

React creates a new Virtual DOM.
React compares it with the previous Virtual DOM.
It identifies only the changed elements.
It updates only those elements in the Real DOM.

This comparison process is called Diffing, and the update strategy is known as Reconciliation.

Example

Initial UI

<h1>Hello</h1>
<p>React</p>
<button>Click</button>

Virtual DOM Copy

App
├── h1 → Hello
├── p → React
└── button → Click

After clicking a button:

<h1>Welcome</h1>
<p>React</p>
<button>Click</button>

React compares the old and new Virtual DOM.

It finds that only the <h1> text changed.

Instead of rebuilding the whole page, React updates only:

<h1>Welcome</h1>

The <p> and <button> remain untouched.

How React Updates the UI

State Changes
      │
      ▼
Create New Virtual DOM
      │
      ▼
Compare with Old Virtual DOM
      │
      ▼
Find Differences (Diffing)
      │
      ▼
Update Only Changed Elements
      │
      ▼
Real DOM Updated

Real DOM vs Virtual DOM

Feature	Real DOM	Virtual DOM
Meaning	Actual DOM maintained by the browser	Lightweight JavaScript copy of the Real DOM
Location	Browser memory	JavaScript memory
Update Speed	Comparatively slower for frequent updates	Faster because React computes changes in memory first
Update Method	Updates the actual DOM directly	Compares two virtual trees, then updates only necessary parts of the Real DOM
Rendering	Browser handles rendering directly	React optimizes updates before the browser renders
Performance	Can become slower with many repeated updates	Improves efficiency by minimizing direct DOM operations
Used By	Vanilla JavaScript	React

Real-Life Analogy

Imagine you are editing a 500-page book.

Real DOM

You erase and rewrite directly in the original printed book every time you find a mistake.

Even a small correction means working on the actual book.

Virtual DOM

You first make corrections on a photocopy.

Then you compare the photocopy with the original.

Finally, you update only the pages that actually changed.

This saves time and avoids unnecessary work.

Why React Uses Virtual DOM

Reduces unnecessary DOM updates.
Improves application performance for frequent UI changes.
Makes user interfaces more responsive.
Updates only the required elements instead of the entire page.
Provides a declarative way to build interactive interfaces.

DEV Community: Saravanan Lakshmanan

More Python Programs

Python Looping Programs - Continued

Python Practice Programs

Python Looping Programs

JS/Python Looping program with if condition

SQL JOIN Practice: From Basic to Advanced — 39 Real-World Queries with Solutions

Students & Courses

Level 2 — Employee & Department

3. Products & Categories

Level 2 — Products & Categories

Level 3

Level 4: Students → Student Courses → Trainers → Courses

Level 1: Difficulty Level: Easy

Level 2 — Student + Course

Level 3 - Three/Four Table JOIN

Level 4 - JOIN + WHERE

Level 5 - JOIN + ORDER BY

Level 6 - JOIN + GROUP BY

Level 7 - LEFT JOIN

Level 8 – DIFFICULTY LEVEL: HARD

Looping Programs in JS and Python

Looping Exercises (With & Without if Condition)

1) Five students enter the classroom one after another. The first student gets roll number 1, the second gets 2, and so on. Display the assigned roll numbers.

2) A coach asks students to stand only at even-numbered positions in a queue. Display the first five positions.

3) A newly constructed building has a special lift that does not stop on every floor. For safety reasons, it stops only at every third floor. A person enters the lift at the ground floor and presses the "Up" button. Display the first five floors where the lift will stop. (TBD)

4) A rocket launches with a countdown using only even numbers from 10. Display the countdown.

Stop Prop Drilling: Learn React useContext with Easy Examples

React useContext Hook Explained with Simple Examples

What is useContext?

Why do we need useContext?

Real-Time Example

Another Simple Example

Syntax

Step 1: Create a Context

Step 2: Provide the Data

Step 3: Consume the Data

Complete Example

App.jsx

Child.jsx

GrandChild.jsx

Output

How useContext Works

Python Is More Than Just print("Hello World"): Understanding the Fundamentals

What is Python?

Understanding Python Version Numbers

Major Version

Minor Version

Maintenance or Patch Version

Understanding Alpha, Beta, RC, and Development Versions

Alpha (a)

Beta (b)

Release Candidate (rc)

Final Release

Development Version (dev)

What is CPython?

What is Jython?

What is IronPython?

Important Features of Python

1. Simple and Easy to Learn

2. Open Source

3. Object-Oriented Programming

4. High-Level Programming Language

Low-Level Language

High-Level Language

5. Dynamically Typed Language

6. Interpreted Language

7. Extensive Standard Library

8. Large Ecosystem of Third-Party Libraries

9. Platform Independent

10. General-Purpose Programming Language

11. Portable

12. Extensible

13. Embeddable

14. Automatic Memory Management

React useEffect Explained: Understanding Mounting, Updating, and Unmounting

What is a React Component?

The Three Stages of a React Component

1. Mounting

2. Updating

React `useContext` Hook Explained with Simple Examples

What is `useContext`?

Why do we need `useContext`?

How `useContext` Works