Nested Loops in Python

# io.thecodeforge: Basic Nested Loop — Multiplication Table
total_iterations = 0

for i in range(1, 4):
    for j in range(1, 4):
        print(f'{i} x {j} = {i * j}', end='   ')
        total_iterations += 1
    print()

print(f'\nTotal iterations: {total_iterations}')
print(f'Formula: 3 outer x 3 inner = {3*3}')

print()

# Scaling warning — show how fast it grows
print('=== Iteration Scaling ===')
for n in [10, 100, 1000, 10000]:
    total = n * n
    print(f'range({n:>5}) x range({n:>5}) = {total:>12,} iterations')

# io.thecodeforge: 2D List Iteration Patterns
# Real-world patterns for processing matrices and grids

matrix = [
    [1,  2,  3],
    [4,  5,  6],
    [7,  8,  9]
]

# Pattern 1: Sum all elements
total = 0
for row in matrix:
    for value in row:
        total += value
print(f'Sum of all elements: {total}')  # 45

print()

# Pattern 2: Find position of a value (using enumerate for indices)
target = 5
for row_idx, row in enumerate(matrix):
    for col_idx, value in enumerate(row):
        if value == target:
            print(f'Found {target} at row={row_idx}, col={col_idx}')

print()

# Pattern 3: Transpose a matrix (swap rows and columns)
rows = len(matrix)
cols = len(matrix[0])
transposed = []
for col in range(cols):
    new_row = []
    for row in range(rows):
        new_row.append(matrix[row][col])
    transposed.append(new_row)

print('Original:')
for row in matrix:
    print(f'  {row}')
print('Transposed:')
for row in transposed:
    print(f'  {row}')

print()

# Pattern 4: Process CSV-like data (rows = records, columns = fields)
students = [
    ['Alice', 92, 88, 95],
    ['Bob',   78, 85, 80],
    ['Carol', 95, 91, 97],
]

print('Student Averages:')
for student in students:
    name = student[0]
    scores = student[1:]
    avg = sum(scores) / len(scores)
    print(f'  {name}: {avg:.1f}')

# io.thecodeforge: Mixed Loop Nesting Patterns
# Real-world combinations of for and while loops

# Pattern 1: for inside while — processing a stream of records
# Outer: keep reading until stream is empty (dynamic)
# Inner: process fixed fields in each record (fixed)
print('=== Pattern 1: for inside while ===')
records = [
    {'name': 'Alice', 'scores': [90, 85, 92]},
    {'name': 'Bob',   'scores': [78, 82, 80]},
]

record_index = 0
while record_index < len(records):
    record = records[record_index]
    print(f"Processing {record['name']}:")
    for score in record['scores']:
        print(f'  Score: {score}')
    record_index += 1

print()

# Pattern 2: while inside for — retry logic per item
# Outer: iterate over API endpoints (fixed collection)
# Inner: retry until success or max attempts (dynamic)
print('=== Pattern 2: while inside for (retry pattern) ===')
endpoints = ['users', 'orders', 'products']

for endpoint in endpoints:
    attempt = 0
    max_attempts = 3
    success = False
    while attempt < max_attempts and not success:
        attempt += 1
        # Simulate: succeed on attempt 2 for 'orders', first attempt for others
        if endpoint == 'orders' and attempt < 2:
            print(f'  {endpoint}: attempt {attempt} failed, retrying...')
        else:
            success = True
            print(f'  {endpoint}: success on attempt {attempt}')

print()

# Pattern 3: Nested for with zip — parallel iteration
print('=== Pattern 3: Parallel iteration with zip ===')
products = ['Widget A', 'Widget B', 'Widget C']
prices = [29.99, 49.99, 19.99]
quantities = [3, 1, 5]

for product, price, qty in zip(products, prices, quantities):
    total = price * qty
    print(f'{product}: {qty} x ${price:.2f} = ${total:.2f}')

# io.thecodeforge: break and continue in Nested Loops
# Shows scope limitations and workarounds

# DEMO 1: break only exits the inner loop
print('=== break exits inner loop only ===')
for i in range(3):
    for j in range(3):
        if j == 1:
            break  # exits inner loop only — outer loop keeps going
        print(f'i={i}, j={j}')
print('Outer loop continued after break\n')
# Output: i=0,j=0 / i=1,j=0 / i=2,j=0
# j never reaches 1 or 2, but all 3 outer iterations complete

# DEMO 2: continue skips current inner iteration only
print('=== continue skips inner iteration only ===')
for i in range(3):
    for j in range(3):
        if j == 1:
            continue  # skips j=1, continues with j=2
        print(f'i={i}, j={j}')
print()
# Output: j=0 and j=2 for every i — j=1 is skipped each time

# DEMO 3: Flag variable — exit both loops
print('=== Flag variable to exit both loops ===')
found = False
for i in range(5):
    for j in range(5):
        if i * j > 6:
            found = True
            break  # exits inner loop
    if found:
        break  # exits outer loop too
print(f'Stopped at i={i}, j={j} (product={i*j})\n')

# DEMO 4: Function + return — cleanest approach
print('=== Function + return (recommended) ===')
def find_first_value_above(matrix, threshold):
    """Search a 2D matrix and return the first value above threshold."""
    for i, row in enumerate(matrix):
        for j, val in enumerate(row):
            if val > threshold:
                return i, j, val  # exits ALL loops instantly
    return None  # nothing found

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
result = find_first_value_above(matrix, 5)
print(f'First value > 5: {result}')

# io.thecodeforge: Pattern Printing with Nested Loops
# Classic exercises that teach inner-loop-range-dependency

rows = 5

# Pattern 1: Right triangle
print('=== Right Triangle ===')
for i in range(1, rows + 1):
    for j in range(i):
        print('*', end='')
    print()

print()

# Pattern 2: Inverted right triangle
print('=== Inverted Right Triangle ===')
for i in range(rows, 0, -1):
    for j in range(i):
        print('*', end='')
    print()

print()

# Pattern 3: Pyramid (centered)
print('=== Pyramid ===')
for i in range(1, rows + 1):
    # Print leading spaces
    for space in range(rows - i):
        print(' ', end='')
    # Print stars
    for star in range(2 * i - 1):
        print('*', end='')
    print()

print()

# Pattern 4: Number triangle
print('=== Number Triangle ===')
for i in range(1, rows + 1):
    for j in range(1, i + 1):
        print(j, end=' ')
    print()

# io.thecodeforge: Flattening and Comprehension Patterns

nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

# Method 1: Explicit nested loop
flat_loop = []
for sublist in nested:
    for item in sublist:
        flat_loop.append(item)
print(f'Explicit loop:   {flat_loop}')

# Method 2: List comprehension — same result, one line
flat_comp = [item for sublist in nested for item in sublist]
print(f'Comprehension:   {flat_comp}')

# Method 3: itertools.chain — fastest for large lists
import itertools
flat_chain = list(itertools.chain.from_iterable(nested))
print(f'itertools.chain: {flat_chain}')

print()

# Nested comprehension with filtering
# Get all even numbers from a 2D list
evens = [val for row in nested for val in row if val % 2 == 0]
print(f'Even numbers: {evens}')

print()

# Cartesian product — every combination of two lists
# This is what nested loops really do under the hood
letters = ['a', 'b', 'c']
numbers = [1, 2, 3]
pairs = [(l, n) for l in letters for n in numbers]
print(f'Cartesian product: {pairs}')

# io.thecodeforge: Nested Loop Performance Patterns
# Real-world optimization examples

import time
import random

# BAD: O(n²) duplicate check
print('=== BAD: O(n²) Duplicate Detection ===')
items = list(range(10000))
# Add a few duplicates
items.append(5000)
items.append(8000)

def find_duplicates_slow(items):
    duplicates = []
    n = len(items)
    for i in range(n):
        for j in range(i + 1, n):
            if items[i] == items[j]:
                duplicates.append(items[i])
    return duplicates

# GOOD: O(n) using a set
print('=== GOOD: O(n) Set-Based Duplicate Detection ===')
def find_duplicates_fast(items):
    seen = set()
    duplicates = set()
    for item in items:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)

# BAD: Nested loop lookup
def find_matches_slow(list_a, list_b):
    matches = []
    for a in list_a:
        for b in list_b:
            if a == b:
                matches.append(a)
    return matches

# GOOD: Set-based lookup
def find_matches_fast(list_a, list_b):
    set_b = set(list_b)
    return [a for a in list_a if a in set_b]

# PAIR COMPARISON: j = i+1 pattern
print('=== Pair Comparison: Avoid Double-Counting ===')
items = ['A', 'B', 'C', 'D']

# BAD: compares each pair twice (A-B and B-A)
print('BAD: O(n²) with double counting:')
for i in range(len(items)):
    for j in range(len(items)):
        if i != j:
            print(f'  Compare {items[i]} vs {items[j]}')

# GOOD: each pair once
print('\nGOOD: O(n²/2) with single counting:')
for i in range(len(items)):
    for j in range(i + 1, len(items)):
        print(f'  Compare {items[i]} vs {items[j]}')

# io.thecodeforge: Real-World Nested Loop Patterns

print('=== Pattern 1: CSV Validation ===')
csv_data = [
    ['Alice', '25', 'alice@example.com'],
    ['Bob', 'invalid', 'bob@example.com'],
    ['Carol', '30', 'not-an-email'],
]

for row_idx, row in enumerate(csv_data):
    name, age_str, email = row
    errors = []
    try:
        age = int(age_str)
        if age < 0 or age > 120:
            errors.append('age out of range')
    except ValueError:
        errors.append('age not a number')
    if '@' not in email or '.' not in email:
        errors.append('invalid email format')
    if errors:
        print(f'Row {row_idx + 1}: {", ".join(errors)}')

print('\n=== Pattern 2: Duplicate Detection with Hashing ===')
# Instead of O(n²) nested loops, use a set
users = [
    {'id': 1, 'email': 'alice@example.com'},
    {'id': 2, 'email': 'bob@example.com'},
    {'id': 3, 'email': 'alice@example.com'},  # duplicate email
    {'id': 4, 'email': 'carol@example.com'},
]

seen_emails = {}
for user in users:
    email = user['email']
    if email in seen_emails:
        print(f'Duplicate email "{email}": user {seen_emails[email]} and user {user["id"]}')
    else:
        seen_emails[email] = user['id']

print('\n=== Pattern 3: Cartesian Product (SKU Generation) ===')
sizes = ['S', 'M', 'L']
colors = ['Red', 'Blue']
styles = ['Crew', 'V-Neck']

skus = []
for size in sizes:
    for color in colors:
        for style in styles:
            sku = f'{size}-{color}-{style}'
            skus.append(sku)
print(f'{len(skus)} SKUs generated:')
for sku in skus[:5]:  # show first 5 only
    print(f'  {sku}')
print('  ...')

print('\n=== Pattern 4: Adjacent Comparison (Time Series Spikes) ===')
metrics = [100, 102, 105, 200, 101, 98, 95]
for i in range(1, len(metrics)):
    prev = metrics[i - 1]
    curr = metrics[i]
    if curr > prev * 1.5:  # 50% spike
        print(f'Spike at position {i}: {prev} → {curr}')