Programming Problem Solving: From Problem to Logic, Logic to Code

01–06 Programming Transcends Syntax — Mindset & Decomposition

The most prevalent novice mistake is prematurely typing code before thoroughly understanding the domain requirements:

Input, Processing, Output (The IPO Pattern)

Whenever confronted with an engineering task, dissect it using these three fundamental inquiries:

Decomposition: Conquering Complexity

Tackling an entire e-commerce checkout flow as a single monolith is overwhelming. Decomposing it into discrete, isolated sub-problems makes implementation straightforward:

07–12 Algorithms, Pseudocode & Flowcharts

An Algorithm is a finite, unambiguous sequence of instructions designed to solve a specific problem. Pseudocode represents these algorithmic steps in readable, informal prose free of language-specific syntax.

START
  INPUT number
  SET result = 1

  REPEAT for count from 1 to number:
      result = result * count

  OUTPUT result
END

number = int(input("Enter number: "))
result = 1

for count in range(1, number + 1):
    result *= count

print(f"Factorial: {result}")

Flowcharts: Visualizing Decision Paths

Determining whether a given numeric value is positive, negative, or zero illustrates the clarity provided by diagrammatic decision branching:

               [ START ]
                   │
            [ Input Number ]
                   │
            /──────────────\
           /  Number > 0?   \
           \────────────────/
             /            \
          Yes              No
           │                │
     [ "Positive" ]  /──────────────\
                     /  Number < 0?   \
                     \────────────────/
                       /            \
                    Yes              No
                     │                │
               [ "Negative" ]    [ "Zero" ]
                     │                │
                     \───────┬────────/
                             │
                          [ END ]

13–19 Edge Cases, Repetition Patterns & Function Encapsulation

Software is only robust when it accounts for boundary conditions and anomalous inputs, known as Edge Cases.

if a > b:
    print(a)
else:
    print(b)
# What if a = 10 and b = 10?
# Falsely claims b is larger despite equality!

if a > b:
    print("First number is larger")
elif a < b:
    print("Second number is larger")
else:
    print("Both numbers are equal (Edge Case)")

Threshold Calculations: The Discount Calculator

Requirement: Provide 20% discount on purchases of 5,000 or greater; otherwise 10%. Encapsulated cleanly within a pure function:

def calculate_discounted_price(price: float) -> float:
    discount_rate = 0.20 if price >= 5000 else 0.10
    discount_amount = price * discount_rate
    return price - discount_amount

# Verify boundary test cases
print(calculate_discounted_price(6000))  # 4800.0 (20% discount)
print(calculate_discounted_price(3000))  # 2700.0 (10% discount)
print(calculate_discounted_price(5000))  # 4000.0 (exact threshold edge case)

20–28 The 10-Step Master Framework, Dry Runs & Code Quality

Follow this dependable heuristic whenever approaching any programming challenge:

What is a Dry Run?

A Dry Run is the disciplined practice of manually stepping through source code line-by-line using pen and paper to trace variable state mutations without machine execution:

numbers = [10, 40, 25, 90, 30]
largest = numbers[0]

for num in numbers:
    if num > largest:
        largest = num

print(f"Maximum value: {largest}")  # 90

Correctness, Efficiency & Readability

The immutable hierarchy of software quality is: Correctness (it must produce valid outcomes) → Efficiency (computational scaling when dataset grows from 10 items to 10,000,000 items) → Readability (source code is read far more often than it is composed).

29–37 The 3 Thinking Layers, Abstraction & The AI Era

Distinguished engineers deconstruct development into three cognitive planes:

Abstraction: Managing Cognitive Load

When invoking sum(numbers) or max(numbers), we intentionally ignore pointer arithmetic and memory traversal. Packaging complex internal mechanics behind clean interfaces is the essence of Abstraction.

38–43 Comprehensive Case Study & 15-Point Framework

Real-world problem: Ingest scores across 5 subjects, compute sum, average, and determine pass/fail (minimum average 40 required), enforcing that scores outside 0–100 prompt a retry:

def get_valid_mark(subject_name: str) -> float:
    while True:
        try:
            val = float(input(f"Enter score for {subject_name} (0-100): "))
            if 0 <= val <= 100:
                return val
            print("Validation error: Mark must be between 0 and 100!")
        except ValueError:
            print("Format error: Please supply a valid numerical value!")

def evaluate_student_results(num_subjects: int = 5) -> dict:
    marks = []
    for i in range(1, num_subjects + 1):
        marks.append(get_valid_mark(f"Subject {i}"))
    
    total = sum(marks)
    average = total / len(marks)
    status = "Pass" if average >= 40.0 else "Fail"
    
    return {"total": total, "average": average, "status": status}

if __name__ == "__main__":
    result = evaluate_student_results(5)
    print(f"\n--- Grade Report ---")
    print(f"Total Score: {result['total']:.1f}")
    print(f"Average Score: {result['average']:.2f}")
    print(f"Verdict: {result['status']}")

Formulate your algorithmic logic and pseudocode prior to expanding the verified Python solutions:

def find_maximum(nums):
    if not nums: return None
    highest = nums[0]
    for n in nums[1:]:
        if n > highest:
            highest = n
    return highest

print(find_maximum([45, 12, 89, 33, 72]))  # 89

def find_minimum(nums):
    if not nums: return None
    lowest = nums[0]
    for n in nums[1:]:
        if n < lowest:
            lowest = n
    return lowest

print(find_minimum([45, 12, 89, 33, 72]))  # 12

def calculate_mean(values):
    if not values:
        return 0.0  # Guard against ZeroDivisionError
    total = 0
    for v in values:
        total += v
    return total / len(values)

print(calculate_mean([10, 20, 30, 40]))  # 25.0
print(calculate_mean([]))                # 0.0

def count_evens(nums):
    count = 0
    for n in nums:
        if n % 2 == 0:
            count += 1
    return count

print(count_evens([1, 4, 7, 8, 10, 13, 14]))  # 4

def count_word_occurrences(text, target):
    words = text.lower().split()
    target_clean = target.lower()
    return words.count(target_clean)

sentence = "Python is great and python is powerful because Python has simple syntax"
print("Occurrences of 'python':", count_word_occurrences(sentence, "python"))  # 3

def calculate_invoice_item(unit_price, quantity, discount_pct=0):
    raw_subtotal = unit_price * quantity
    discount_amount = raw_subtotal * (discount_pct / 100)
    net_total = raw_subtotal - discount_amount
    return round(net_total, 2)

# 5 pens at $50 each with 10% promotional discount
print("Total price:", calculate_invoice_item(50, 5, 10))  # 225.0

students = [
    {"name": "Rahim", "marks": [80, 75, 90]},
    {"name": "Karim", "marks": [30, 42, 35]},
    {"name": "Ayesha", "marks": [85, 92, 88]}
]

for s in students:
    avg = sum(s["marks"]) / len(s["marks"])
    verdict = "PASS" if avg >= 50 else "FAIL"
    print(f"{s['name']}: Average {avg:.1f} ({verdict})")

def analyze_numeric_file(filepath):
    nums = []
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            stripped = line.strip()
            if stripped:
                nums.append(float(stripped))
    
    if not nums: return None
    return {
        "count": len(nums),
        "total": sum(nums),
        "average": sum(nums) / len(nums),
        "max": max(nums),
        "min": min(nums)
    }