Lists & Indexing Operations

def process_shopping_cart():
    cart_items = ["laptop", "mouse", "keyboard", "monitor"]
    item_prices = [999.99, 29.99, 79.99, 249.99]
    tax_rate = 0.08
    
    print("=" * 44)
    print(f"{'PYLABS E-COMMERCE CART AUDITOR':^44}")
    print("=" * 44)
    
    # 1. Remove 'mouse' if present
    item_to_remove = "mouse"
    if item_to_remove in cart_items:
        remove_idx = cart_items.index(item_to_remove)
        removed_product = cart_items.pop(remove_idx)
        removed_price = item_prices.pop(remove_idx)
        print(f"[REMOVED] {removed_product} (-${removed_price:.2f})")
        
    # 2. Add 'webcam' with price $59.99
    cart_items.append("webcam")
    item_prices.append(59.99)
    print(f"[ADDED] webcam (+${59.99:.2f})")
    
    print("-" * 44)
    print("Itemized Cart:")
    for idx in range(len(cart_items)):
        print(f"  {idx + 1}. {cart_items[idx]:<20} ${item_prices[idx]:>8.2f}")
        
    # 3. Financial calculations
    subtotal = sum(item_prices)
    tax_amount = round(subtotal * tax_rate, 2)
    final_total = round(subtotal + tax_amount, 2)
    
    print("-" * 44)
    print(f"Subtotal ({len(cart_items)} items):{'':<10} ${subtotal:>8.2f}")
    print(f"Estimated Tax (8%):{'':<13} ${tax_amount:>8.2f}")
    print(f"Final Order Total:{'':<14} ${final_total:>8.2f}")
    print("=" * 44)
    return cart_items, final_total

items, total = process_shopping_cart()

class CryptoOrderBook:
    def __init__(self, symbol: str):
        self.symbol = symbol
        # Bids: sorted descending (highest buyer first)
        self.bids = [102.50, 101.75, 101.00]
        # Asks: sorted ascending (lowest seller first)
        self.asks = [103.00, 103.50, 104.25]
        
    def add_bid(self, price: float):
        self.bids.append(price)
        self.bids.sort(reverse=True)
        
    def add_ask(self, price: float):
        self.asks.append(price)
        self.asks.sort()
        
    def match_orders(self) -> list[dict]:
        trades = []
        # While best bid >= best ask, an execution occurs
        while self.bids and self.asks and self.bids[0] >= self.asks[0]:
            best_bid = self.bids.pop(0)
            best_ask = self.asks.pop(0)
            exec_price = round((best_bid + best_ask) / 2, 2)
            trades.append({"bid": best_bid, "ask": best_ask, "cleared": exec_price})
        return trades
        
    def get_market_snapshot(self) -> dict:
        # CRITICAL: Return shallow copies so external callers cannot mutate engine state
        return {
            "symbol": self.symbol,
            "bids": self.bids.copy(),
            "asks": self.asks.copy(),
            "spread": round(self.asks[0] - self.bids[0], 2) if self.bids and self.asks else 0.0
        }

# Instantiate order book
book = CryptoOrderBook("BTC/USD")
print(f"Initial Market Spread: ${book.get_market_snapshot()['spread']:.2f}")

# Incoming aggressive buyer places bid at $103.25 (crosses spread!)
print("\n[ORDER] Placing aggressive bid at $103.25...")
book.add_bid(103.25)

# Execute matching engine
executed_trades = book.match_orders()
for t in executed_trades:
    print(f"[TRADE EXECUTED] Matched Bid ${t['bid']:.2f} with Ask ${t['ask']:.2f} -> Cleared at ${t['cleared']:.2f}")

# Verify snapshot isolation
snapshot = book.get_market_snapshot()
print("\nPost-Trade Order Book Snapshot:")
print(f"  Top Bids: {snapshot['bids']}")
print(f"  Top Asks: {snapshot['asks']}")
print(f"  New Spread: ${snapshot['spread']:.2f}")

# Ensure snapshot tampering does not affect live book
snapshot['bids'].append(999.99)
assert 999.99 not in book.bids, "CRITICAL: Live order book corrupted by external snapshot reference!"
print("\nSnapshot isolation verified: External mutation did not affect internal book state.")

class TelemetryRingBuffer:
    """
    Fixed-capacity sliding window metric buffer maintaining recent K observations.
    Provides O(1) append/evict and compute metrics without memory leaks.
    """
    def __init__(self, capacity: int):
        if capacity <= 0:
            raise ValueError("Buffer capacity must be a positive integer")
        self.capacity = capacity
        self._samples = []
        
    def record(self, sample: float):
        # Maintain fixed window capacity: evict oldest if at limit
        if len(self._samples) >= self.capacity:
            self._samples.pop(0)  # Evict oldest element
        self._samples.append(float(sample))
        
    def get_summary(self) -> dict:
        if not self._samples:
            return {"count": 0, "min": 0.0, "max": 0.0, "avg": 0.0, "median": 0.0, "latest": 0.0}
            
        n = len(self._samples)
        min_val = min(self._samples)
        max_val = max(self._samples)
        avg_val = round(sum(self._samples) / n, 2)
        
        # Compute median via sorted copy (do NOT mutate internal buffer!)
        sorted_samples = sorted(self._samples)
        if n % 2 == 1:
            median_val = sorted_samples[n // 2]
        else:
            mid1 = sorted_samples[(n // 2) - 1]
            mid2 = sorted_samples[n // 2]
            median_val = (mid1 + mid2) / 2.0
            
        return {
            "count": n,
            "min": round(min_val, 2),
            "max": round(max_val, 2),
            "avg": avg_val,
            "median": round(median_val, 2),
            "latest": round(self._samples[-1], 2)
        }
        
    def export_window(self) -> list[float]:
        # Slicing [:] creates an independent shallow copy of the window
        return self._samples[:]

# Simulation: Stream 6 server CPU telemetry samples into a capacity-4 buffer
buffer = TelemetryRingBuffer(capacity=4)
simulated_stream = [45.0, 52.0, 48.0, 60.0, 55.0, 72.0]

print("=" * 56)
print(f"{'STREAMING TELEMETRY RING BUFFER (CAPACITY: 4)':^56}")
print("=" * 56)

for i, reading in enumerate(simulated_stream, 1):
    buffer.record(reading)
    summary = buffer.get_summary()
    current_window = buffer.export_window()
    print(f"Sample #{i}: {reading:>5.1f}% | Window: {current_window}")
    print(f"  -> Min: {summary['min']}% | Max: {summary['max']}% | Avg: {summary['avg']}% | Median: {summary['median']}%")

print("=" * 56)