Problem Solving & Algorithms

What is problem solving?

A computer cannot think on its own. To make it solve a problem — calculate a bill, find the topper, book a ticket — we must first understand the problem and work out the exact steps. Then we write those steps in a programming language. This whole process of identifying a problem, designing a solution and turning it into a working program is called problem solving.

Steps for problem solving

Example: "Find the percentage of a student from marks of 5 subjects."

• Input: 5 marks (each out of 100).
• Process: total = sum of marks; percentage = total ÷ 500 × 100.
• Output: total and percentage.

What is an algorithm?

An algorithm is a finite sequence of well-defined steps to solve a problem. The word comes from the Persian mathematician al-Khwarizmi. An algorithm is independent of any programming language — the same algorithm can be written in Python, C++ or Java.

Characteristics of a good algorithm

Algorithm examples

Example 1: Area of a rectangle

1. Start
2. Input length L and breadth B
3. Area ← L × B
4. Print Area
5. Stop

Example 2: Check whether a number is even or odd

1. Start
2. Input N
3. If N mod 2 = 0, print "Even", otherwise print "Odd"
4. Stop

Example 3: Largest of three numbers

1. Start
2. Input A, B, C
3. Largest ← A
4. If B > Largest then Largest ← B
5. If C > Largest then Largest ← C
6. Print Largest
7. Stop

Example 4: Factorial of N (N! = 1 × 2 × … × N)

1. Start
2. Input N
3. Fact ← 1, i ← 1
4. Repeat while i ≤ N: Fact ← Fact × i; i ← i + 1
5. Print Fact
6. Stop

Verifying an algorithm (dry run)

Before coding, we verify the algorithm by doing a dry run: we act as the computer, take sample input, and write every variable's value in a trace table. Let us dry-run Example 4 with N = 4.

Also test special cases: N = 0 should give 1 (the loop does not run, Fact stays 1 ✔), and N = 1 gives 1 ✔.

Comparing algorithms

Problem: find the sum 1 + 2 + … + N. Two correct algorithms:

def sum_loop(n):          # Algorithm A: add one by one
    total = 0
    for i in range(1, n + 1):
        total += i
    return total

def sum_formula(n):       # Algorithm B: Gauss formula
    return n * (n + 1) // 2

n = 1000000
print(sum_loop(n), sum_formula(n))
print('Loop steps:', n, '| Formula steps: 1')

Another example: to check if N is prime, we only need to test divisors up to √N, not up to N − 1. For N = 10,007 that is about 100 checks instead of 10,000.

From algorithm to code

Here is Example 3 written in Python. Each line maps directly to one algorithm step.

a = int(input('First number: '))
b = int(input('Second number: '))
c = int(input('Third number: '))
largest = a
if b > largest:
    largest = b
if c > largest:
    largest = c
print('Largest =', largest)

Summary & practice

• Problem solving: analyse → algorithm → code → test & debug.
• Algorithm = finite, definite, effective steps with input and output.
• Verify with a dry run and a trace table; test special cases.
• Compare algorithms by steps (time) and memory.