List Algorithms & Memory Models

Symptom: The list variable is overwritten with None, destroying the data and causing immediate TypeError crashes.

Symptom: Mutating a nested object through a cloned list unexpectedly mutates the original list's data.

Symptom: TypeError: '<' not supported between instances of 'str' and 'int'

Symptom: ValueError: 'cache-01' is not in list

Symptom: Returns meaningless or incorrect index offsets without raising any error or warning.

Symptom: Severe CPU bottleneck; execution slows by 100x to 1000x on large datasets.

🟢 Simple Script: Limit Order Book Matching Engine Priority Queue

Financial exchanges (NYSE, Nasdaq, crypto trading platforms) match incoming orders using Price-Time Priority: best price first, with ties broken by earliest arrival timestamp.

orders = [
    {"order_id": "ord_1", "price": 100.50, "timestamp": 1002},
    {"order_id": "ord_2", "price": 101.00, "timestamp": 1001},
    {"order_id": "ord_3", "price": 100.50, "timestamp": 1000},
    {"order_id": "ord_4", "price": 101.00, "timestamp": 1003}
]

# Price-Time Priority for buy orders: Highest price first (-price), earliest timestamp first (timestamp)
orders.sort(key=lambda o: (-o["price"], o["timestamp"]))

print("Execution Priority Order:")
for rank, o in enumerate(orders, 1):
    print(f"  {rank}. {o['order_id']} | Price: ${o['price']:.2f} | Time: {o['timestamp']}ms")

🟡 Scaled Service: Cluster Workload Pod Node Scheduler

Kubernetes kube-scheduler ranks available worker nodes according to available capacity, prioritizing nodes with the least resource pressure.

nodes = [
    {"node": "worker-alpha", "cpu_free_cores": 4, "ram_free_gb": 16, "cost_per_hr": 0.45},
    {"node": "worker-beta", "cpu_free_cores": 8, "ram_free_gb": 32, "cost_per_hr": 0.90},
    {"node": "worker-gamma", "cpu_free_cores": 8, "ram_free_gb": 16, "cost_per_hr": 0.70}
]

# Scheduling policy: Most free CPU cores (-cpu), most free RAM (-ram), cheapest cost (cost)
scheduled_nodes = sorted(nodes, key=lambda n: (-n["cpu_free_cores"], -n["ram_free_gb"], n["cost_per_hr"]))

print("Optimal Node Scheduling Sequence:")
for n in scheduled_nodes:
    print(f"  Node: {n['node']:<14} CPU: {n['cpu_free_cores']} cores | RAM: {n['ram_free_gb']} GB | Cost: ${n['cost_per_hr']}/hr")

🔴 Enterprise Production: BM25 Document Relevance Ranker & Top-K Slicer

Search engines (Elasticsearch, Apache Solr) compute term relevance scores across matched documents, sorting millions of hits and returning only the top 3 results.

search_hits = [
    {"doc_id": "doc_102", "title": "Python Performance Guide", "score": 8.45},
    {"doc_id": "doc_501", "title": "Intro to Lists", "score": 6.20},
    {"doc_id": "doc_809", "title": "Advanced Timsort Internals", "score": 9.80},
    {"doc_id": "doc_312", "title": "Data Structures Overview", "score": 7.50}
]

# Sort descending by relevance score
search_hits.sort(key=lambda doc: doc["score"], reverse=True)

# Slicing top-3 results
top_k = search_hits[:3]

print("Top 3 Most Relevant Results:")
for rank, doc in enumerate(top_k, 1):
    print(f"  #{rank} [{doc['score']:.2f}] {doc['title']} ({doc['doc_id']})")

🔴 Enterprise Production: Emergency Room Triage Acuity Priority Queue

Emergency department admissions triage incoming patients using Emergency Severity Index (ESI: 1 = Resuscitation, 5 = Non-urgent), ordering treatment by acuity and waiting time.

patients = [
    {"name": "John Doe", "esi": 3, "wait_min": 45},
    {"name": "Jane Smith", "esi": 1, "wait_min": 5},
    {"name": "Emily Brown", "esi": 2, "wait_min": 20},
    {"name": "Michael Lee", "esi": 2, "wait_min": 35}
]

# Highest urgency first: Lowest ESI (esi asc), longest wait time (-wait_min desc)
patients.sort(key=lambda p: (p["esi"], -p["wait_min"]))

print("ER Medical Treatment Priority Queue:")
for p in patients:
    print(f"  [ESI Level {p['esi']}] {p['name']:<14} (Waiting: {p['wait_min']} min)")

Competitive Gaming Tournament Leaderboard Engine

Rank players in an esports tournament based on multi-attribute rules: 1) Score descending; 2) Fewer attempts ascending (tie-breaker); 3) Player name alphabetically (final tie-breaker).

• Input roster: [{'name': 'PlayerA', 'score': 350, 'attempts': 4}, {'name': 'PlayerB', 'score': 400, 'attempts': 5}, {'name': 'PlayerC', 'score': 350, 'attempts': 2}, {'name': 'PlayerD', 'score': 400, 'attempts': 3}, {'name': 'PlayerE', 'score': 350, 'attempts': 4}].
• Sort using sorted() with composite tuple key (-score, attempts, name).
• Store sorted result in ranked_players.
• Print the final rank order (expected: PlayerD, PlayerB, PlayerC, PlayerA, PlayerE).

players = [
    {"name": "PlayerA", "score": 350, "attempts": 4},
    {"name": "PlayerB", "score": 400, "attempts": 5},
    {"name": "PlayerC", "score": 350, "attempts": 2},
    {"name": "PlayerD", "score": 400, "attempts": 3},
    {"name": "PlayerE", "score": 350, "attempts": 4}
]
ranked_players = []
# Implement leaderboard sorting

Deep Configuration Snapshot & Transactional Rollback

Implement a transactional configuration snapshot engine. Given a nested system dictionary containing services and features, create an isolated deep copy. Mutate the staging configuration by adding a new feature and updating a port, then assert that the base configuration was completely insulated.

• Import copy module and use copy.deepcopy().
• Base configuration contains nested dictionaries and lists.
• Mutate staging_config['services'][0]['features'].append('beta_ui') and port = 8080.
• Assert that 'beta_ui' is not in base_config.
• Print both configuration dictionaries.

import copy

base_config = {
    "env": "production",
    "services": [
        {"name": "api", "port": 8000, "features": ["auth", "metrics"]},
        {"name": "worker", "port": 9000, "features": ["queue"]}
    ]
}
# Create isolated deep copy and mutate