Python Itertools and Functools Exercises: 20 Coding Problems with Solutions

from itertools import permutations

chars = "ABC"

all_perms = list(permutations(chars))

print(f"All permutations of '{chars}':")
for p in all_perms:
    print(f"  {''.join(p)}")

print(f"\nTotal: {len(all_perms)}")

# Partial permutations: choose r=2 from 3 characters
print(f"\n2-character permutations of '{chars}':")
for p in permutations(chars, 2):
    print(f"  {''.join(p)}")

# Verify count matches factorial formula
import math
print(f"\nExpected total (3!): {math.factorial(len(chars))}")
print(f"Expected 2-perm (P(3,2) = 3!/1!): {math.factorial(len(chars)) // math.factorial(len(chars) - 2)}")Code language: Python (python)

from itertools import combinations
import math

players = ["Alice", "Bob", "Charlie", "Diana", "Eve"]

all_pairs = list(combinations(players, 2))

print(f"All 2-player pairs from {players}:\n")
for i, pair in enumerate(all_pairs, 1):
    print(f"  {i:2d}. {pair[0]} vs {pair[1]}")

print(f"\nTotal pairs: {len(all_pairs)}")
print(f"Verified by C(5,2) = math.comb(5,2): {math.comb(5, 2)}")

# Contrast with permutations count
from itertools import permutations
perm_count = len(list(permutations(players, 2)))
print(f"\nPermutations P(5,2): {perm_count}  (order matters - Alice-Bob and Bob-Alice counted separately)")
print(f"Combinations C(5,2): {len(all_pairs)}  (order ignored - Alice-Bob and Bob-Alice are the same pair)")
print(f"Ratio P/C = k! = {perm_count // len(all_pairs)}  (= 2! because each pair has 2 orderings)")Code language: Python (python)

from itertools import combinations_with_replacement, combinations
import math

toppings = ["Cheese", "Pepperoni", "Mushrooms", "Olives"]

orders_with_rep    = list(combinations_with_replacement(toppings, 2))
orders_without_rep = list(combinations(toppings, 2))

print(f"Toppings: {toppings}\n")
print(f"All 2-topping orders (with replacement):")
for i, order in enumerate(orders_with_rep, 1):
    double = " (double topping)" if order[0] == order[1] else ""
    print(f"  {i:2d}. {order[0]} + {order[1]}{double}")

print(f"\nWith replacement    : {len(orders_with_rep)} orders")
print(f"Without replacement : {len(orders_without_rep)} orders")
print(f"Extra (double) orders added: {len(orders_with_rep) - len(orders_without_rep)}")

# Count formula verification: C(n+r-1, r)
n, r = len(toppings), 2
formula_count = math.comb(n + r - 1, r)
print(f"\nFormula C({n}+{r}-1, {r}) = C({n+r-1}, {r}) = {formula_count}")Code language: Python (python)

from itertools import product
sizes   = ["S", "M", "L"]
colours = ["Red", "Blue", "Green", "Black"]
variants = list(product(sizes, colours))
print(f"Sizes   : {sizes}")
print(f"Colours : {colours}")
print(f"\nAll product variants ({len(sizes)} × {len(colours)} = {len(variants)}):")
print(f"{'#':>4}  {'Size':<6}  {'Colour'}")
print("-" * 22)
for i, (size, colour) in enumerate(variants, 1):
    print(f"{i:>4}  {size:<6}  {colour}")
print(f"\nTotal variants: {len(variants)}")
# Equivalent nested loop for comparison
print("\nEquivalent nested loop output (first 4 only):")
count = 0
for size in sizes:
    for colour in colours:
        print(f"  ({size}, {colour})")
        count += 1
        if count == 4:
            print("  ...")
            break
    if count >= 4:
        break
# Three-attribute example
materials = ["Cotton", "Polyester"]
three_attr = list(product(sizes, colours, materials))
print(f"\n3-attribute variants (sizes × colours × materials): {len(three_attr)}")Code language: Python (python)

from itertools import product, islice

digits     = "0123456789"
pin_length = 4

# Generate all 4-digit PINs lazily
all_pins = product(digits, repeat=pin_length)

# Preview first 5 without materialising all 10,000
first_5 = ["".join(p) for p in islice(product(digits, repeat=pin_length), 5)]
print(f"First 5 PINs : {first_5}")

# Total count using exponentiation (no need to generate all)
total = len(digits) ** pin_length
print(f"Total {pin_length}-digit PINs: {total:,}")

# Last 5 PINs (must materialise to access the end)
all_pins_list = ["".join(p) for p in product(digits, repeat=pin_length)]
print(f"Last 5 PINs  : {all_pins_list[-5:]}")

# Search space growth table
print(f"\nSearch space growth (alphabet size = {len(digits)}):")
print(f"{'Length':>8} | {'Total PINs':>14} | {'vs previous':>12}")
print("-" * 40)
prev = 1
for length in range(1, 7):
    count = len(digits) ** length
    factor = count // prev
    print(f"{length:>8} | {count:>14,} | {factor:>10}×")
    prev = countCode language: Python (python)

from itertools import chain

engineering = ["Alice", "Bob", "Charlie"]
marketing   = ["Diana", "Eve"]
hr          = ["Frank", "Grace", "Heidi"]

# chain() merges iterables lazily - no new list created
all_employees = list(chain(engineering, marketing, hr))

print("All employees (chained):")
for name in all_employees:
    print(f"  {name}")

print(f"\nTotal employees: {len(all_employees)}")

# chain.from_iterable: when the lists are inside a collection
departments = [engineering, marketing, hr]
all_from_iterable = list(chain.from_iterable(departments))
print(f"\nUsing chain.from_iterable: {all_from_iterable}")
print(f"Results match: {all_employees == all_from_iterable}")

# Contrast with list concatenation (creates a new list in memory)
combined_list = engineering + marketing + hr
print(f"\nList concatenation result : {combined_list}")
print(f"chain is lazy (no copy)   : True  |  '+' always copies: True")Code language: Python (python)

from itertools import count, islice, takewhile
# Infinite counter: start=100, step=5
counter = count(start=100, step=5)
# Safe extraction using islice
first_8 = list(islice(counter, 8))
print(f"First 8 values (start=100, step=5): {first_8}")
# islice with start, stop, step arguments
counter2  = count(start=0, step=1)
every_3rd = list(islice(counter2, 0, 15, 3))
print(f"Every 3rd from 0 (islice step=3)  : {every_3rd}")
# Alternative: takewhile for condition-based stopping
counter3    = count(start=100, step=5)
below_140   = list(takewhile(lambda x: x < 140, counter3))
print(f"Values below 140                   : {below_140}")
# Practical use: generating unique sequential IDs
id_gen = count(start=1001)
new_ids = [next(id_gen) for _ in range(5)]
print(f"\nGenerated IDs : {new_ids}")
# Float step support
float_counter = list(islice(count(0.0, 0.25), 6))
print(f"Float counter (step=0.25): {float_counter}")Code language: Python (python)

from itertools import cycle, islice
shifts    = ["Morning", "Afternoon", "Night"]
employees = ["Alice", "Bob", "Charlie", "Diana", "Eve",
             "Frank", "Grace", "Heidi", "Ivan", "Judy"]
# zip() terminates at the shorter iterable (employees list)
schedule = list(zip(employees, cycle(shifts)))
print("Shift Schedule:")
print(f"{'Employee':<12}  {'Shift'}")
print("-" * 24)
for employee, shift in schedule:
    print(f"  {employee:<10}  {shift}")
# Alternative: islice to get exactly n cycle values
n_items = 7
cycled_labels = list(islice(cycle(shifts), n_items))
print(f"\nFirst {n_items} shift labels (islice): {cycled_labels}")
# Practical: alternating row styles for a table
rows = ["Row A", "Row B", "Row C", "Row D", "Row E"]
styles = cycle(["light", "dark"])
print(f"\nAlternating table rows:")
for row, style in zip(rows, styles):
    print(f"  {row}: {style}")Code language: Python (python)

from itertools import repeat
products = [
    ("Laptop",   999.99),
    ("Mouse",     29.99),
    ("Keyboard",  79.99),
    ("Monitor",  349.99),
]
discount_rate = 0.15
# Pair each product with the fixed discount rate
print(f"Discount rate: {discount_rate * 100:.0f}%\n")
print(f"{'Product':<12}  {'Original':>10}  {'Discount':>10}  {'Sale Price':>10}")
print("-" * 48)
for (name, price), rate in zip(products, repeat(discount_rate)):
    discount   = price * rate
    sale_price = price - discount
    print(f"  {name:<10}  £{price:>9.2f}  £{discount:>9.2f}  £{sale_price:>9.2f}")
# map() with repeat: apply pow(price, exponent) to each price
import math
prices = [p for _, p in products]
log_prices = list(map(math.log, prices, repeat(10)))   # log base 10 of each price
print(f"\nlog10 of each price:")
for (name, _), lp in zip(products, log_prices):
    print(f"  {name:<10}: {lp:.4f}")
# repeat with a fixed count
fixed_repeat = list(repeat("N/A", 3))
print(f"\nrepeat('N/A', 3): {fixed_repeat}")Code language: Python (python)

from itertools import takewhile, dropwhile, chain
temperatures = [18.2, 21.5, 24.8, 27.1, 29.6, 31.3, 28.4, 33.7, 30.1, 26.5]
threshold    = 30.0
below_30 = list(takewhile(lambda x: x < threshold, temperatures))
from_hot = list(dropwhile(lambda x: x < threshold, temperatures))
print(f"Full sequence              : {temperatures}")
print(f"\ntakewhile (below {threshold}°C)  : {below_30}")
print(f"dropwhile (skip below {threshold}°C): {from_hot}")
# Verify: chain of both halves recovers the original
recovered = list(chain(below_30, from_hot))
print(f"\nchain(takewhile, dropwhile): {recovered}")
print(f"Matches original           : {recovered == temperatures}")
# Contrast with filter(): filter checks EVERY element, not just the prefix
filtered = list(filter(lambda x: x < threshold, temperatures))
print(f"\nfilter(< {threshold})          : {filtered}")
print("Note: filter() finds 26.5 at the end; takewhile() stops at 31.3 and misses it.")
# Practical: skip log header lines then process entries
log_lines = ["# header", "# generated 2025-01-01", "INFO starting", "ERROR failed", "INFO done"]
data_lines = list(dropwhile(lambda line: line.startswith("#"), log_lines))
print(f"\nLog after skipping headers : {data_lines}")Code language: Python (python)

from itertools import groupby

transactions = [
    ("Food",   12.50), ("Food",    8.30), ("Travel", 45.00),
    ("Travel", 22.10), ("Travel", 15.75), ("Food",    6.90),
    ("Tech",  299.99),
]

# MUST sort before groupby - it only groups consecutive identical keys
sorted_txns = sorted(transactions, key=lambda x: x[0])

print("Transactions grouped by category:\n")
for category, group in groupby(sorted_txns, key=lambda x: x[0]):
    items    = list(group)   # materialise immediately before iterator advances
    subtotal = sum(amount for _, amount in items)
    print(f"  {category} ({len(items)} items, subtotal: £{subtotal:.2f})")
    for _, amount in items:
        print(f"    £{amount:.2f}")

# Demonstrate the danger of NOT sorting first
print("\nWithout sorting (incorrect grouping):")
for category, group in groupby(transactions, key=lambda x: x[0]):
    items = list(group)
    print(f"  {category}: {len(items)} item(s)")Code language: Python (python)

from itertools import compress

products  = ["Laptop", "Mouse", "Keyboard", "Monitor", "Headphones", "Webcam"]
in_stock  = [1, 0, 1, 1, 0, 1]

available = list(compress(products, in_stock))
print(f"All products  : {products}")
print(f"In stock mask : {in_stock}")
print(f"Available     : {available}")

# Out-of-stock items (inverted selector)
out_of_stock = list(compress(products, [not s for s in in_stock]))
print(f"Out of stock  : {out_of_stock}")

# Dynamic selector: products with price above threshold
products_with_prices = [
    ("Laptop", 999.99), ("Mouse", 29.99), ("Keyboard", 79.99),
    ("Monitor", 349.99), ("Headphones", 49.99), ("Webcam", 89.99),
]
threshold = 75.0
selector  = [price > threshold for _, price in products_with_prices]
names     = [name for name, _ in products_with_prices]

premium = list(compress(names, selector))
print(f"\nProducts above £{threshold}: {premium}")
print(f"Selector used            : {selector}")Code language: Python (python)

from itertools import accumulate
import operator
monthly_sales = [12000, 15400, 9800, 18200, 21000, 14300, 16700]
months        = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul"]
running_total   = list(accumulate(monthly_sales))
running_max     = list(accumulate(monthly_sales, max))
running_min     = list(accumulate(monthly_sales, min))
print(f"{'Month':<6}  {'Sales':>8}  {'Cumulative':>12}  {'Running Max':>12}  {'Running Min':>12}")
print("-" * 58)
for month, sales, total, rmax, rmin in zip(months, monthly_sales, running_total, running_max, running_min):
    print(f"{month:<6}  £{sales:>7,}  £{total:>11,}  £{rmax:>11,}  £{rmin:>11,}")
# Running product using operator.mul (on small growth factors)
growth_factors = [1.05, 0.98, 1.12, 1.03, 0.97, 1.08, 1.01]
running_product = list(accumulate(growth_factors, operator.mul))
print(f"\nRunning compound growth:")
for month, factor, product in zip(months, growth_factors, running_product):
    print(f"  {month}: factor={factor:.2f}  cumulative={product:.4f}  ({(product - 1)*100:+.2f}%)")
# initial keyword (Python 3.8+): prepend a starting value
with_initial = list(accumulate(monthly_sales[:3], initial=0))
print(f"\nWith initial=0: {with_initial}")Code language: Python (python)

from functools import reduce
import operator
import math

numbers = [2, 3, 4, 5, 6]

# Product using reduce with operator.mul
product = reduce(operator.mul, numbers)
print(f"Numbers          : {numbers}")
print(f"Product (reduce) : {product}")
print(f"math.prod verify : {math.prod(numbers)}")
print(f"Results match    : {product == math.prod(numbers)}")

# Maximum value using reduce
maximum = reduce(lambda a, b: a if a > b else b, numbers)
print(f"\nMaximum (reduce) : {maximum}  (built-in max: {max(numbers)})")

# String concatenation using reduce
words = ["Python", " is", " powerful"]
sentence = reduce(lambda a, b: a + b, words)
print(f"\nConcatenated     : '{sentence}'")

# Flatten nested lists using reduce
nested = [[1, 2], [3, 4], [5, 6], [7]]
flat = reduce(lambda acc, lst: acc + lst, nested, [])
print(f"\nNested lists     : {nested}")
print(f"Flattened        : {flat}")

# initializer prevents TypeError on empty input
empty_product = reduce(operator.mul, [], 1)
print(f"\nreduce on empty list (initializer=1): {empty_product}")Code language: Python (python)

from functools import partial

exponents = list(range(11))   # [0, 1, 2, ..., 10]

# Create specialised functions via partial
power_of_2  = partial(pow, 2)
power_of_3  = partial(pow, 3)
square      = partial(pow, base=None)   # illustrative - see note below

# Apply using map()
powers_of_2 = list(map(power_of_2, exponents))
powers_of_3 = list(map(power_of_3, exponents))

print(f"Exponents   : {exponents}")
print(f"Powers of 2 : {powers_of_2}")
print(f"Powers of 3 : {powers_of_3}")

# Partial with keyword arguments
def greet(name, greeting="Hello", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

formal_greet   = partial(greet, greeting="Good morning", punctuation=".")
casual_greet   = partial(greet, greeting="Hey")

names = ["Alice", "Bob", "Charlie"]
print(f"\nFormal greetings:")
for name in names:
    print(f"  {formal_greet(name)}")

print(f"\nCasual greetings:")
for name in names:
    print(f"  {casual_greet(name)}")

# Inspect the partial object
print(f"\npartial object info:")
print(f"  power_of_2.func  : {power_of_2.func}")
print(f"  power_of_2.args  : {power_of_2.args}")
print(f"  power_of_2.keywords: {power_of_2.keywords}")Code language: Python (python)

from functools import lru_cache
import time
# Uncached recursive Fibonacci - O(2^n) time complexity
call_count_uncached = 0
def fib_uncached(n):
    global call_count_uncached
    call_count_uncached += 1
    if n <= 1:
        return n
    return fib_uncached(n - 1) + fib_uncached(n - 2)
# Cached recursive Fibonacci - O(n) time complexity
@lru_cache(maxsize=None)
def fib_cached(n):
    if n <= 1:
        return n
    return fib_cached(n - 1) + fib_cached(n - 2)
n = 35
# Time the uncached version
start = time.perf_counter()
result_uncached = fib_uncached(n)
time_uncached   = time.perf_counter() - start
# Time the cached version
start = time.perf_counter()
result_cached = fib_cached(n)
time_cached   = time.perf_counter() - start
print(f"fibonacci({n}) = {result_cached}")
print(f"\nUncached:")
print(f"  Time       : {time_uncached:.4f}s")
print(f"  Calls made : {call_count_uncached:,}")
print(f"\nCached:")
print(f"  Time       : {time_cached:.6f}s")
info = fib_cached.cache_info()
print(f"  Cache hits : {info.hits}")
print(f"  Cache miss : {info.misses}")
print(f"  Cache size : {info.currsize}")
speedup = time_uncached / time_cached if time_cached > 0 else float("inf")
print(f"\nSpeedup     : ~{speedup:.0f}x")
# Cache management
fib_cached.cache_clear()
print(f"\nAfter cache_clear(): {fib_cached.cache_info()}")Code language: Python (python)

from functools import cmp_to_key
versions = ["1.10.2", "1.9.1", "2.0.0", "1.10.1",
            "1.2.3",  "2.1.0", "1.10.10"]
# Lexicographic sort (WRONG for version numbers)
lex_sorted = sorted(versions)
print(f"Lexicographic (wrong) : {lex_sorted}")
# Custom comparator: split on '.' and compare as integer tuples
def version_comparator(v1, v2):
    parts1 = [int(x) for x in v1.split(".")]
    parts2 = [int(x) for x in v2.split(".")]
    if parts1 < parts2:
        return -1
    if parts1 > parts2:
        return 1
    return 0
correct_sorted = sorted(versions, key=cmp_to_key(version_comparator))
print(f"Numeric (correct)     : {correct_sorted}")
# Reverse order (newest first)
desc_sorted = sorted(versions, key=cmp_to_key(version_comparator), reverse=True)
print(f"Descending            : {desc_sorted}")
# Simpler alternative using a key function (preferred when possible)
def version_key(v):
    return tuple(int(x) for x in v.split("."))
key_sorted = sorted(versions, key=version_key)
print(f"\nKey function (simpler): {key_sorted}")
print(f"Both approaches match : {correct_sorted == key_sorted}")Code language: Python (python)

from itertools import chain
from functools import reduce
import operator
north = [15200, 18400, 12100]
south = [22300, 19800, 25100]
east  = [11500, 14200, 16800, 13400]
# Materialise once so we can do multiple aggregations
all_sales = list(chain(north, south, east))
n         = len(all_sales)
print(f"North sales : {north}")
print(f"South sales : {south}")
print(f"East sales  : {east}")
print(f"Combined    : {all_sales}")
# Aggregations using reduce
total   = reduce(operator.add, all_sales)
maximum = reduce(lambda a, b: a if a > b else b, all_sales)
minimum = reduce(lambda a, b: a if a < b else b, all_sales)
average = total / n
print(f"\nTotal revenue   : £{total:,}")
print(f"Maximum sale    : £{maximum:,}")
print(f"Minimum sale    : £{minimum:,}")
print(f"Average sale    : £{average:,.2f}")
# Single-pass tuple accumulation: (total, max, min)
def combined_reducer(acc, x):
    total, mx, mn = acc
    return (total + x, max(mx, x), min(mn, x))
first = all_sales[0]
total2, max2, min2 = reduce(combined_reducer, all_sales[1:], (first, first, first))
print(f"\nSingle-pass reduce:")
print(f"  Total: £{total2:,}  Max: £{max2:,}  Min: £{min2:,}")
print(f"  Matches separate passes: {total == total2 and maximum == max2 and minimum == min2}")Code language: Python (python)

from functools import lru_cache
import math
# Uncached Pascal's triangle recurrence
uncached_calls = 0
def comb_uncached(n, k):
    global uncached_calls
    uncached_calls += 1
    if k == 0 or k == n:
        return 1
    return comb_uncached(n - 1, k - 1) + comb_uncached(n - 1, k)
# Cached version
@lru_cache(maxsize=None)
def comb_cached(n, k):
    if k == 0 or k == n:
        return 1
    return comb_cached(n - 1, k - 1) + comb_cached(n - 1, k)
test_cases = [(10, 3), (15, 6), (20, 10)]
print(f"{'(n,k)':<12}  {'comb_cached':>12}  {'math.comb':>10}  {'Match':>6}")
print("-" * 46)
for n, k in test_cases:
    cached  = comb_cached(n, k)
    builtin = math.comb(n, k)
    print(f"C({n},{k}){'':<6}  {cached:>12,}  {builtin:>10,}  {str(cached == builtin):>6}")
info = comb_cached.cache_info()
print(f"\nCache statistics after all calls:")
print(f"  Hits    : {info.hits}")
print(f"  Misses  : {info.misses}  (unique subproblems computed)")
print(f"  Size    : {info.currsize}")
# Count uncached calls for C(20,10) alone
uncached_calls = 0
comb_uncached(20, 10)
print(f"\nC(20,10) uncached calls : {uncached_calls:,}")
print(f"C(20,10) cached misses  : {info.misses}")
print(f"Call reduction          : {uncached_calls / info.misses:.0f}x")Code language: Python (python)

from itertools import islice
from functools import reduce, partial
import random
random.seed(42)
# Simulate a large data stream as a generator (never fully in memory)
regions  = ["North", "South", "East", "West"]
products = ["Widget", "Gadget", "Doohickey", "Thingamajig"]
def sales_stream(n):
    """Generator simulating n sales records."""
    for _ in range(n):
        yield (
            random.choice(products),
            random.choice(regions),
            round(random.uniform(50, 2000), 2),
        )
# Define a multi-parameter predicate
def is_qualifying(record, region, min_amount):
    _, rec_region, amount = record
    return rec_region == region and amount >= min_amount
# Create a single-argument predicate using partial
north_high_value = partial(is_qualifying, region="North", min_amount=500)
# Build the lazy pipeline
stream      = sales_stream(1000)          # infinite-ish generator
capped      = islice(stream, 200)          # stage 1: limit to first 200
qualifying  = filter(north_high_value, capped)  # stage 2: filter by region + amount
results     = list(qualifying)             # materialise only at the end
# Aggregate
if results:
    total   = reduce(lambda acc, r: acc + r[2], results, 0.0)
    maximum = reduce(lambda a, b: a if a[2] > b[2] else b, results)
    count   = len(results)
else:
    total, count = 0.0, 0
print(f"Pipeline stages:")
print(f"  Stage 1 (islice)  : capped stream at 200 records")
print(f"  Stage 2 (filter)  : kept North region with amount >= £500")
print(f"  Stage 3 (reduce)  : aggregated qualifying records")
print(f"\nQualifying records  : {count}")
print(f"Total revenue       : £{total:,.2f}")
if results:
    print(f"Highest single sale : £{maximum[2]:,.2f} ({maximum[0]}, {maximum[1]})")
print(f"\nSample qualifying records (first 5):")
for product, region, amount in results[:5]:
    print(f"  {product:<15}  {region:<6}  £{amount:,.2f}")Code language: Python (python)