NumPy Interview Questions

┌─────────────────────────────────────────────────────────────────┐
│         PYTHON LIST vs NUMPY ARRAY MEMORY LAYOUT               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  PYTHON LIST: [1, 2, 3, 4]  (each element = PyObject)         │
│  ┌────────┐    ┌────────┐    ┌────────┐    ┌────────┐         │
│  │ PTR────┼───→│PyInt(1)│    │PyInt(2)│    │PyInt(3)│         │
│  │ PTR────┼───→│refcount│    │refcount│    │refcount│         │
│  │ PTR────┼───→│ type   │    │ type   │    │ type   │         │
│  │ PTR────┼───→│ value=1│    │ value=2│    │ value=3│         │
│  └────────┘    └────────┘    └────────┘    └────────┘         │
│  Memory: 4 pointers (32 bytes) + 4 objects (96 bytes) = 128B   │
│                                                                 │
│  NUMPY ARRAY: np.array([1, 2, 3, 4], dtype=np.int32)          │
│  ┌──────────────────────────────────┐                          │
│  │ Metadata (dtype, shape, strides) │                          │
│  ├──────────────────────────────────┤                          │
│  │ Data Buffer (contiguous):        │                          │
│  │ [1][2][3][4]  (raw int32s)       │                          │
│  └──────────────────────────────────┘                          │
│  Memory: 16 bytes (4 × int32) + overhead ≈ 100 bytes           │
│                                                                 │
│  Speedup: Contiguous → SIMD vectorization (process 4-8 at once)│
└─────────────────────────────────────────────────────────────────┘

import numpy as np
import time
import sys
from typing import List

class PerformanceBenchmark:
    """Compare Python list vs NumPy array performance."""

    def __init__(self, size: int = 1_000_000):
        self.size = size
        self.py_list = list(range(size))
        self.np_array = np.arange(size)

    def benchmark_arithmetic(self):
        """Benchmark element-wise multiplication."""
        print(f"\n{'='*70}")
        print("BENCHMARK 1: ELEMENT-WISE MULTIPLICATION (x * 2)")
        print(f"{'='*70}")

        # Python list
        start = time.perf_counter()
        result_list = [x * 2 for x in self.py_list]
        list_time = time.perf_counter() - start

        # NumPy array
        start = time.perf_counter()
        result_np = self.np_array * 2
        np_time = time.perf_counter() - start

        speedup = list_time / np_time

        print(f"   Python list: {list_time:.4f}s")
        print(f"   NumPy array: {np_time:.4f}s")
        print(f"   Speedup:     {speedup:.1f}x")

        return speedup

    def benchmark_sum(self):
        """Benchmark reduction operation."""
        print(f"\n{'='*70}")
        print("BENCHMARK 2: SUM REDUCTION")
        print(f"{'='*70}")

        # Python list
        start = time.perf_counter()
        result_list = sum(self.py_list)
        list_time = time.perf_counter() - start

        # NumPy array
        start = time.perf_counter()
        result_np = np.sum(self.np_array)
        np_time = time.perf_counter() - start

        speedup = list_time / np_time

        print(f"   Python list: {list_time:.4f}s")
        print(f"   NumPy array: {np_time:.4f}s")
        print(f"   Speedup:     {speedup:.1f}x")

        return speedup

    def benchmark_filtering(self):
        """Benchmark conditional filtering."""
        print(f"\n{'='*70}")
        print("BENCHMARK 3: CONDITIONAL FILTERING (x > 500,000)")
        print(f"{'='*70}")

        # Python list
        start = time.perf_counter()
        result_list = [x for x in self.py_list if x > 500_000]
        list_time = time.perf_counter() - start

        # NumPy array
        start = time.perf_counter()
        result_np = self.np_array[self.np_array > 500_000]
        np_time = time.perf_counter() - start

        speedup = list_time / np_time

        print(f"   Python list: {list_time:.4f}s")
        print(f"   NumPy array: {np_time:.4f}s")
        print(f"   Speedup:     {speedup:.1f}x")

        return speedup

    def benchmark_memory(self):
        """Compare memory usage."""
        print(f"\n{'='*70}")
        print("MEMORY USAGE COMPARISON")
        print(f"{'='*70}")

        list_mem = sys.getsizeof(self.py_list) + sum(sys.getsizeof(x) for x in self.py_list[:100]) * (self.size // 100)
        np_mem = self.np_array.nbytes + sys.getsizeof(self.np_array)

        print(f"   Python list:  {list_mem / 1e6:.2f} MB")
        print(f"   NumPy array:  {np_mem / 1e6:.2f} MB")
        print(f"   Memory saved: {(list_mem - np_mem) / list_mem * 100:.1f}%")

        return list_mem / np_mem

    def run_all(self):
        """Run all benchmarks."""
        print(f"\n{'='*70}")
        print(f"PERFORMANCE BENCHMARK: {self.size:,} ELEMENTS")
        print(f"{'='*70}")

        speedups = []
        speedups.append(self.benchmark_arithmetic())
        speedups.append(self.benchmark_sum())
        speedups.append(self.benchmark_filtering())
        mem_ratio = self.benchmark_memory()

        print(f"\n{'='*70}")
        print("SUMMARY")
        print(f"{'='*70}")
        print(f"   Average speedup: {np.mean(speedups):.1f}x")
        print(f"   Memory efficiency: {mem_ratio:.1f}x less memory")
        print(f"\n   ✅ NumPy is {np.mean(speedups):.0f}x faster on average!")

# Example: Netflix user similarity computation
print("="*70)
print("NETFLIX - USER SIMILARITY COMPUTATION (100M RATINGS)")
print("="*70)

# Simulate 100M user ratings (user_id, movie_id, rating)
n_ratings = 1_000_000  # Scaled down for demo

print(f"\nComputing cosine similarity for {n_ratings:,} ratings...")

# Method 1: Python lists (naive)
ratings_list = [float(i % 5 + 1) for i in range(n_ratings)]

start = time.perf_counter()
# Compute mean
mean_list = sum(ratings_list) / len(ratings_list)
# Compute std
variance_list = sum((x - mean_list)**2 for x in ratings_list) / len(ratings_list)
std_list = variance_list ** 0.5
list_time = time.perf_counter() - start

# Method 2: NumPy (vectorized)
ratings_np = np.array(ratings_list, dtype=np.float32)

start = time.perf_counter()
mean_np = np.mean(ratings_np)
std_np = np.std(ratings_np)
np_time = time.perf_counter() - start

print(f"\n📊 RESULTS:")
print(f"   Python list approach: {list_time:.4f}s")
print(f"   NumPy vectorized:     {np_time:.4f}s")
print(f"   Speedup:              {list_time / np_time:.1f}x")
print(f"\n   Mean:  {mean_np:.3f}")
print(f"   Std:   {std_np:.3f}")

print(f"\n💡 At 100M ratings scale:")
print(f"   Python lists: ~{list_time * 100:.1f}s ({list_time * 100 / 60:.1f} minutes)")
print(f"   NumPy:        ~{np_time * 100:.2f}s")
print(f"   Time saved:   {(list_time - np_time) * 100:.1f}s per computation")

print("\n" + "="*70)
print("SIMD VECTORIZATION ILLUSTRATION")
print("="*70)

print("""
Python List (Scalar Processing):
┌───────────────────────────────────────┐
│ for x in list:                        │
│     result.append(x * 2)              │
│                                       │
│ Process 1 element per CPU cycle       │
│ [1] → [2]  (1 op)                     │
│ [2] → [4]  (1 op)                     │
│ [3] → [6]  (1 op)                     │
│ [4] → [8]  (1 op)                     │
│ Total: 4 cycles                       │
└───────────────────────────────────────┘

NumPy (SIMD Vectorization):
┌───────────────────────────────────────┐
│ arr * 2                               │
│                                       │
│ Process 4-8 elements per CPU cycle    │
│ [1, 2, 3, 4] → [2, 4, 6, 8]  (1 op)   │
│ Total: 1 cycle (4x speedup)           │
│                                       │
│ Modern CPUs (AVX-512): 16 floats/cycle│
└───────────────────────────────────────┘
""")

# Run full benchmark
benchmark = PerformanceBenchmark(size=1_000_000)
benchmark.run_all()

print("\n" + "="*70)

┌────────────────────────────────────────────────────────────────┐
│               NUMPY BROADCASTING RULES                         │
├────────────────────────────────────────────────────────────────┤
│                                                                │
│  RULE 1: Compare shapes element-wise from RIGHT to LEFT        │
│  ┌──────────────────────────────────────────────────────────┐ │
│  │ Array A: shape (8, 1, 6, 1)                              │ │
│  │ Array B: shape    (7, 1, 5)                              │ │
│  │                   ↑  ↑  ↑  ↑                              │ │
│  │ Compare from right: 1 vs 5 → 1 broadcasts to 5           │ │
│  │                     6 vs 1 → 1 broadcasts to 6           │ │
│  │                     1 vs 7 → 1 broadcasts to 7           │ │
│  │                     8 vs _ → _ treated as 1, broadcasts  │ │
│  │ Result shape: (8, 7, 6, 5) ✅                             │ │
│  └──────────────────────────────────────────────────────────┘ │
│                                                                │
│  RULE 2: Dimensions are compatible if:                         │
│     - They are equal (e.g., 5 == 5)                            │
│     - One of them is 1 (e.g., 1 broadcasts to any size)        │
│                                                                │
│  RULE 3: Missing dimensions treated as 1                       │
│  ┌──────────────────────────────────────────────────────────┐ │
│  │ Array A: shape    (3, 4)  →  treated as (1, 3, 4)        │ │
│  │ Array B: shape (2, 1, 4)                                 │ │
│  │ Result:        (2, 3, 4)                                 │ │
│  └──────────────────────────────────────────────────────────┘ │
│                                                                │
│  MEMORY: No actual copying happens! Arrays share base data    │
│  ┌──────────────────────────────────────────────────────────┐ │
│  │ Original: [1, 2, 3] (12 bytes)                           │ │
│  │ Broadcast to (3, 3): [[1, 2, 3],                         │ │
│  │                       [1, 2, 3],                         │ │
│  │                       [1, 2, 3]]                         │ │
│  │ Still 12 bytes! (virtual expansion via strides)          │ │
│  └──────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────────┘

import numpy as np
import time
from typing import Tuple, Optional
from dataclasses import dataclass

@dataclass
class BroadcastResult:
    """Results from broadcasting operation."""
    result: np.ndarray
    input_memory: int
    output_memory: int
    computation_time: float
    memory_saved_pct: float

class BroadcastingMaster:
    """Production-quality broadcasting examples."""

    @staticmethod
    def example1_scalar_broadcast():
        """Most basic: scalar broadcasts to array."""
        print("="*70)
        print("EXAMPLE 1: SCALAR BROADCASTING")
        print("="*70)

        arr = np.arange(5)
        scalar = 10

        print(f"\nArray shape: {arr.shape}")
        print(f"Scalar: {scalar} (treated as shape ())")
        print(f"\nBroadcast rule: () → (5,)")

        result = arr + scalar
        print(f"\nResult: {result}")
        print(f"Result shape: {result.shape}")

    @staticmethod
    def example2_vector_matrix_broadcast():
        """Row/column vector broadcasting (common in ML)."""
        print("\n" + "="*70)
        print("EXAMPLE 2: VECTOR-MATRIX BROADCASTING (ML Normalization)")
        print("="*70)

        # Batch of samples (100 samples, 5 features)
        data = np.random.randn(100, 5)

        # Compute mean per feature (shape: (5,))
        mean = data.mean(axis=0)
        std = data.std(axis=0)

        print(f"\nData shape: {data.shape}")
        print(f"Mean shape: {mean.shape}")
        print(f"Std shape:  {std.shape}")

        # Broadcasting: (100, 5) - (5,) → (100, 5) - (1, 5) → (100, 5)
        normalized = (data - mean) / std

        print(f"\nBroadcast: (100, 5) - (5,) → (100, 5)")
        print(f"Result shape: {normalized.shape}")
        print(f"\nVerify normalization:")
        print(f"  New mean per feature: {normalized.mean(axis=0)}")
        print(f"  New std per feature:  {normalized.std(axis=0)}")

    @staticmethod
    def example3_outer_product():
        """Create outer product via broadcasting."""
        print("\n" + "="*70)
        print("EXAMPLE 3: OUTER PRODUCT (Distance Matrix Pattern)")
        print("="*70)

        row = np.array([[1, 2, 3]])      # Shape (1, 3)
        col = np.array([[10], [20], [30]])  # Shape (3, 1)

        print(f"\nRow vector: {row.shape} = {row.flatten()}")
        print(f"Col vector: {col.shape} = {col.flatten()}")

        # Broadcasting: (1, 3) + (3, 1) → (3, 3)
        result = row + col

        print(f"\nBroadcast: (1, 3) + (3, 1) → (3, 3)")
        print(f"\nResult:\n{result}")
        print("\nExplanation:")
        print("  Row [1,2,3] copied down 3 times")
        print("  Col [10,20,30] copied across 3 times")
        print("  Then element-wise addition")

    @staticmethod
    def example4_distance_matrix():
        """Compute pairwise distances (critical for ML/KNN)."""
        print("\n" + "="*70)
        print("EXAMPLE 4: PAIRWISE DISTANCE MATRIX (KNN, Clustering)")
        print("="*70)

        # Points in 2D space
        A = np.array([[1, 2], [3, 4], [5, 6]])  # 3 points
        B = np.array([[0, 0], [1, 1], [2, 2]])  # 3 points

        print(f"\nPoints A: {A.shape}")
        print(f"{A}")
        print(f"\nPoints B: {B.shape}")
        print(f"{B}")

        # METHOD 1: Naive loops (DON'T DO THIS)
        start = time.perf_counter()
        dist_naive = np.zeros((len(A), len(B)))
        for i in range(len(A)):
            for j in range(len(B)):
                dist_naive[i, j] = np.linalg.norm(A[i] - B[j])
        naive_time = time.perf_counter() - start

        # METHOD 2: Broadcasting (CORRECT APPROACH)
        start = time.perf_counter()
        # A: (3, 2) → (3, 1, 2)  [add axis for B]
        # B: (3, 2) → (1, 3, 2)  [add axis for A]
        # Difference: (3, 1, 2) - (1, 3, 2) → (3, 3, 2)
        diff = A[:, np.newaxis, :] - B[np.newaxis, :, :]
        # Sum of squares along last axis: (3, 3, 2) → (3, 3)
        dist_broadcast = np.sqrt(np.sum(diff**2, axis=-1))
        broadcast_time = time.perf_counter() - start

        print(f"\nDistance matrix shape: {dist_broadcast.shape}")
        print(f"\nDistances:\n{dist_broadcast}")
        print(f"\nPerformance:")
        print(f"  Naive loops:  {naive_time*1000:.4f} ms")
        print(f"  Broadcasting: {broadcast_time*1000:.4f} ms")
        print(f"  Speedup:      {naive_time/broadcast_time:.1f}x")

    @staticmethod
    def example5_netflix_normalization():
        """Netflix-style user rating normalization."""
        print("\n" + "="*70)
        print("NETFLIX - USER RATING NORMALIZATION (100M RATINGS)")
        print("="*70)

        # Simulate: 1000 users, 500 movies (scaled down from 100M ratings)
        n_users, n_movies = 1000, 500

        # Ratings matrix (sparse in reality, dense for demo)
        np.random.seed(42)
        ratings = np.random.rand(n_users, n_movies) * 5  # 1-5 stars

        print(f"\nRatings shape: {ratings.shape}")
        print(f"Total ratings: {n_users * n_movies:,}")
        print(f"Memory: {ratings.nbytes / 1e6:.2f} MB")

        # Compute user mean (each user's average rating)
        start = time.perf_counter()
        user_mean = ratings.mean(axis=1, keepdims=True)  # Shape: (1000, 1)
        user_std = ratings.std(axis=1, keepdims=True)

        # Normalize: subtract user mean, divide by std
        # Broadcasting: (1000, 500) - (1000, 1) → (1000, 500)
        normalized = (ratings - user_mean) / (user_std + 1e-8)
        broadcast_time = time.perf_counter() - start

        print(f"\nUser mean shape: {user_mean.shape}")
        print(f"Broadcasting: ({n_users}, {n_movies}) - ({n_users}, 1) → ({n_users}, {n_movies})")

        print(f"\nTime taken: {broadcast_time:.4f}s")
        print(f"\nMemory comparison:")
        print(f"  Without broadcasting (explicit): {ratings.nbytes * 2 / 1e6:.2f} MB")
        print(f"  With broadcasting: {(ratings.nbytes + user_mean.nbytes) / 1e6:.2f} MB")
        print(f"  Memory saved: {(ratings.nbytes * 2 - ratings.nbytes - user_mean.nbytes) / 1e6:.2f} MB")

        print(f"\n✅ Normalized ratings:")
        print(f"  Mean per user: ~{normalized.mean(axis=1).mean():.2e} (should be ~0)")
        print(f"  Std per user:  ~{normalized.std(axis=1).mean():.3f} (should be ~1)")

        print(f"\n💡 At Netflix scale (100M ratings):")
        print(f"   Memory saved: {(ratings.nbytes * 2 - ratings.nbytes) * 100 / 1e9:.1f} GB")
        print(f"   Time saved: {broadcast_time * 100:.1f}s of computation avoided")

    @staticmethod
    def example6_common_errors():
        """Common broadcasting errors and fixes."""
        print("\n" + "="*70)
        print("COMMON BROADCASTING ERRORS & FIXES")
        print("="*70)

        # Error 1: Incompatible shapes
        print("\n❌ ERROR 1: Incompatible shapes")
        a = np.array([1, 2, 3])     # (3,)
        b = np.array([1, 2, 3, 4])  # (4,)
        print(f"  a.shape: {a.shape}")
        print(f"  b.shape: {b.shape}")
        print(f"  a + b → ValueError: shapes (3,) and (4,) not aligned")
        print(f"\n  Fix: Make sure trailing dimensions match or are 1")

        # Error 2: Need explicit newaxis
        print("\n✅ FIX: Using np.newaxis for explicit broadcasting")
        row = np.array([1, 2, 3])      # (3,)
        col = np.array([10, 20, 30])   # (3,)
        print(f"  row.shape: {row.shape}")
        print(f"  col.shape: {col.shape}")
        print(f"  row + col → Element-wise: {row + col} (not outer product!)")

        # Correct outer product
        row_2d = row[np.newaxis, :]     # (1, 3)
        col_2d = col[:, np.newaxis]     # (3, 1)
        outer = row_2d + col_2d          # (3, 3)
        print(f"\n  row[np.newaxis, :]: {row_2d.shape}")
        print(f"  col[:, np.newaxis]: {col_2d.shape}")
        print(f"  Outer product:\n{outer}")

# Run all examples
print("="*70)
print("NUMPY BROADCASTING MASTERCLASS")
print("="*70)

master = BroadcastingMaster()
master.example1_scalar_broadcast()
master.example2_vector_matrix_broadcast()
master.example3_outer_product()
master.example4_distance_matrix()
master.example5_netflix_normalization()
master.example6_common_errors()

┌──────────────────────────────────────────────────────────────────┐
│          flatten() vs ravel() MEMORY BEHAVIOR                   │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  FLATTEN() - Always Creates COPY                                │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ Original array:  [[1, 2],     Memory: Address 0x1000       │ │
│  │                   [3, 4]]                                   │ │
│  │                                                             │ │
│  │ a.flatten() →    [1, 2, 3, 4] Memory: Address 0x2000 (NEW)│ │
│  │                                                             │ │
│  │ ✅ Safe: Modifying flat[0] does NOT affect original         │ │
│  │ ❌ Cost: Allocates new memory (can be expensive for large)  │ │
│  └────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  RAVEL() - Returns VIEW (if possible)                           │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ Original array:  [[1, 2],     Memory: Address 0x1000       │ │
│  │                   [3, 4]]                                   │ │
│  │                                                             │ │
│  │ a.ravel() →      [1, 2, 3, 4] Memory: Address 0x1000 (SAME)│ │
│  │                                                             │ │
│  │ ⚠️  Warning: Modifying raveled[0] DOES affect original      │ │
│  │ ✅ Fast: Zero-copy operation (instant for large arrays)     │ │
│  └────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  RESHAPE(-1) - Returns VIEW (if possible, like ravel)          │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ a.reshape(-1) → Same as ravel(), more explicit             │ │
│  │ Returns view when array is C/F-contiguous                   │ │
│  └────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

import numpy as np
import time
import sys
from typing import Optional

class FlattenRavelAnalyzer:
    """Analyze flatten() vs ravel() behavior and performance."""

    @staticmethod
    def example1_basic_difference():
        """Demonstrate core difference with side effects."""
        print("="*70)
        print("EXAMPLE 1: BASIC DIFFERENCE (View vs Copy)")
        print("="*70)

        original = np.array([[1, 2, 3],
                             [4, 5, 6]])

        print(f"\nOriginal array:")
        print(original)
        print(f"Address: {hex(original.__array_interface__['data'][0])}")

        # Test flatten() - always copy
        print("\n" + "-"*70)
        print("TEST 1: flatten() - Always Creates Copy")
        print("-"*70)
        flat = original.flatten()
        print(f"Flattened: {flat}")
        print(f"Address:   {hex(flat.__array_interface__['data'][0])}")
        print(f"Same memory? {flat.base is original}  (False = copy)")

        flat[0] = 999
        print(f"\nAfter flat[0] = 999:")
        print(f"  Original[0,0]: {original[0,0]} (unchanged)")
        print(f"  Flat[0]:       {flat[0]} (modified)")
        print(f"✅ Safe: Changes don't affect original")

        # Test ravel() - view if possible
        print("\n" + "-"*70)
        print("TEST 2: ravel() - Returns View (if contiguous)")
        print("-"*70)
        raveled = original.ravel()
        print(f"Raveled: {raveled}")
        print(f"Address: {hex(raveled.__array_interface__['data'][0])}")
        print(f"Same memory? {raveled.base is original}  (True = view)")

        raveled[0] = 777
        print(f"\nAfter raveled[0] = 777:")
        print(f"  Original[0,0]: {original[0,0]} (modified!)")
        print(f"  Raveled[0]:    {raveled[0]} (modified)")
        print(f"⚠️  Warning: Changes affect original (shared memory)")

    @staticmethod
    def example2_when_ravel_copies():
        """Show cases where ravel() must create copy."""
        print("\n" + "="*70)
        print("EXAMPLE 2: When ravel() MUST Create Copy")
        print("="*70)

        # Case 1: Non-contiguous array (slice with stride)
        print("\nCase 1: Non-contiguous (every other element)")
        a = np.arange(20).reshape(4, 5)
        sliced = a[:, ::2]  # Every other column
        print(f"Original shape: {a.shape}, contiguous: {a.flags['C_CONTIGUOUS']}")
        print(f"Sliced shape:   {sliced.shape}, contiguous: {sliced.flags['C_CONTIGUOUS']}")

        raveled = sliced.ravel()
        print(f"\nravel() result: {raveled.base is sliced}")
        print(f"Explanation: Non-contiguous arrays require copy to flatten")

        # Case 2: Fortran order array with C-order ravel
        print("\n" + "-"*70)
        print("Case 2: Fortran-order array")
        f_order = np.array([[1, 2, 3], [4, 5, 6]], order='F')
        print(f"F-order contiguous: {f_order.flags['F_CONTIGUOUS']}")
        print(f"C-order contiguous: {f_order.flags['C_CONTIGUOUS']}")

        raveled_c = f_order.ravel()  # Default order='C'
        raveled_f = f_order.ravel(order='F')

        print(f"\nravel(order='C'): is view? {raveled_c.base is not None}")
        print(f"ravel(order='F'): is view? {raveled_f.base is f_order}")
        print(f"Explanation: Must match array's native order for view")

    @staticmethod
    def example3_performance_benchmark():
        """Benchmark flatten() vs ravel() performance."""
        print("\n" + "="*70)
        print("EXAMPLE 3: PERFORMANCE BENCHMARK (1M elements)")
        print("="*70)

        sizes = [100, 1_000, 10_000, 1_000_000]

        for size in sizes:
            n = int(np.sqrt(size))
            arr = np.arange(n * n).reshape(n, n)

            # Benchmark flatten()
            start = time.perf_counter()
            for _ in range(100):
                _ = arr.flatten()
            flatten_time = (time.perf_counter() - start) / 100

            # Benchmark ravel()
            start = time.perf_counter()
            for _ in range(100):
                _ = arr.ravel()
            ravel_time = (time.perf_counter() - start) / 100

            # Memory usage
            flatten_mem = arr.flatten().nbytes
            ravel_mem = 0  # View doesn't allocate

            speedup = flatten_time / ravel_time

            print(f"\nArray size: {n}×{n} = {n*n:,} elements")
            print(f"  flatten(): {flatten_time*1000:.4f} ms, {flatten_mem/1e6:.2f} MB allocated")
            print(f"  ravel():   {ravel_time*1000:.4f} ms, {ravel_mem/1e6:.2f} MB allocated")
            print(f"  Speedup:   {speedup:.0f}x faster")

    @staticmethod
    def example4_netflix_use_case():
        """Netflix-style embedding flattening."""
        print("\n" + "="*70)
        print("NETFLIX - USER EMBEDDING FLATTENING (50M users × 128d)")
        print("="*70)

        # Simulate Netflix scale (scaled down)
        n_users = 50_000  # 50M in production
        embedding_dim = 128

        embeddings = np.random.randn(n_users, embedding_dim).astype(np.float32)

        print(f"\nEmbeddings shape: {embeddings.shape}")
        print(f"Memory: {embeddings.nbytes / 1e6:.2f} MB")

        # Method 1: flatten() - creates copy
        start = time.perf_counter()
        flat_copy = embeddings.flatten()
        flatten_time = time.perf_counter() - start
        flatten_mem = flat_copy.nbytes

        # Method 2: ravel() - zero-copy view
        start = time.perf_counter()
        flat_view = embeddings.ravel()
        ravel_time = time.perf_counter() - start
        ravel_mem = 0  # No additional memory

        print(f"\nMethod 1: flatten()")
        print(f"  Time: {flatten_time*1000:.2f} ms")
        print(f"  Memory allocated: {flatten_mem / 1e6:.2f} MB")
        print(f"  Total memory: {(embeddings.nbytes + flatten_mem) / 1e6:.2f} MB")

        print(f"\nMethod 2: ravel()")
        print(f"  Time: {ravel_time*1000:.4f} ms")
        print(f"  Memory allocated: {ravel_mem / 1e6:.2f} MB")
        print(f"  Total memory: {embeddings.nbytes / 1e6:.2f} MB")

        print(f"\n💰 Savings:")
        print(f"  Time saved: {(flatten_time - ravel_time)*1000:.2f} ms")
        print(f"  Memory saved: {flatten_mem / 1e6:.2f} MB")
        print(f"  Speedup: {flatten_time / ravel_time:.0f}x")

        print(f"\n📊 At Netflix scale (50M users):")
        print(f"  flatten() total memory: {(embeddings.nbytes * 2 * 1000) / 1e9:.1f} GB")
        print(f"  ravel() total memory:   {(embeddings.nbytes * 1000) / 1e9:.1f} GB")
        print(f"  Memory saved: {(embeddings.nbytes * 1000) / 1e9:.1f} GB")

    @staticmethod
    def example5_safe_usage_patterns():
        """Best practices for using ravel() safely."""
        print("\n" + "="*70)
        print("EXAMPLE 5: SAFE USAGE PATTERNS")
        print("="*70)

        arr = np.arange(12).reshape(3, 4)

        print("\n✅ SAFE: Read-only operations")
        raveled = arr.ravel()
        result = np.sum(raveled)  # Just reading
        max_val = np.max(raveled)  # Just reading
        print(f"  Sum: {result}, Max: {max_val}")
        print(f"  Original unchanged: {arr[0, 0]}")

        print("\n⚠️  RISKY: Modifying view")
        raveled[0] = 999
        print(f"  After raveled[0] = 999")
        print(f"  Original[0,0] = {arr[0, 0]} (modified!)")

        print("\n✅ SAFE: Explicit copy when needed")
        arr2 = np.arange(12).reshape(3, 4)
        raveled_copy = arr2.ravel().copy()  # Explicit copy
        raveled_copy[0] = 888
        print(f"  After raveled_copy[0] = 888")
        print(f"  Original[0,0] = {arr2[0, 0]} (unchanged!)")

        print("\n✅ SAFE: Use flatten() when you'll modify")
        arr3 = np.arange(12).reshape(3, 4)
        flat = arr3.flatten()
        flat[0] = 777
        print(f"  After flat[0] = 777")
        print(f"  Original[0,0] = {arr3[0, 0]} (unchanged!)")

    @staticmethod
    def example6_check_if_view():
        """How to check if result is view or copy."""
        print("\n" + "="*70)
        print("EXAMPLE 6: CHECK IF VIEW OR COPY")
        print("="*70)

        arr = np.arange(12).reshape(3, 4)

        flat = arr.flatten()
        raveled = arr.ravel()
        reshaped = arr.reshape(-1)

        print(f"\nMethod 1: Check .base attribute")
        print(f"  flat.base is None:    {flat.base is None}  (True = copy)")
        print(f"  raveled.base is arr:  {raveled.base is arr}  (True = view)")
        print(f"  reshaped.base is arr: {reshaped.base is arr}  (True = view)")

        print(f"\nMethod 2: Check memory address")
        orig_addr = arr.__array_interface__['data'][0]
        flat_addr = flat.__array_interface__['data'][0]
        raveled_addr = raveled.__array_interface__['data'][0]

        print(f"  Original:  {hex(orig_addr)}")
        print(f"  Flat:      {hex(flat_addr)} (different = copy)")
        print(f"  Raveled:   {hex(raveled_addr)} (same = view)")

        print(f"\nMethod 3: Use np.shares_memory()")
        print(f"  np.shares_memory(arr, flat):    {np.shares_memory(arr, flat)}")
        print(f"  np.shares_memory(arr, raveled): {np.shares_memory(arr, raveled)}")

# Run all examples
analyzer = FlattenRavelAnalyzer()
analyzer.example1_basic_difference()
analyzer.example2_when_ravel_copies()
analyzer.example3_performance_benchmark()
analyzer.example4_netflix_use_case()
analyzer.example5_safe_usage_patterns()
analyzer.example6_check_if_view()

import numpy as np

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# Method 1: @ operator (Python 3.5+)
C = A @ B

# Method 2: np.matmul()
C = np.matmul(A, B)

# Method 3: np.dot() - works for 1D and 2D
C = np.dot(A, B)

# All give same result:
# [[19, 22],
#  [43, 50]]

# Batched matrix multiplication
batch_A = np.random.rand(10, 3, 4)  # 10 matrices of 3x4
batch_B = np.random.rand(10, 4, 5)  # 10 matrices of 4x5

result = batch_A @ batch_B  # Shape: (10, 3, 5)

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Basic: np.where(condition, if_true, if_false)
result = np.where(arr > 3, arr * 10, arr)
# [1, 2, 3, 40, 50]

# Return indices where condition is True
indices = np.where(arr > 3)
# (array([3, 4]),)

# Multiple conditions
result = np.where(arr < 2, 'small',
                  np.where(arr < 4, 'medium', 'large'))
# ['small', 'medium', 'medium', 'large', 'large']

# Better for multiple conditions: np.select
conditions = [arr < 2, arr < 4, arr >= 4]
choices = ['small', 'medium', 'large']
result = np.select(conditions, choices)

┌────────────────────────────────────────────────────────────────────┐
│           C-ORDER (ROW-MAJOR) vs F-ORDER (COLUMN-MAJOR)           │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│  ARRAY: [[1, 2, 3],                                                │
│          [4, 5, 6]]                                                │
│                                                                    │
│  C-ORDER (Row-Major) - DEFAULT in NumPy/C                         │
│  ┌──────────────────────────────────────────────────────────────┐ │
│  │ Memory: [1][2][3][4][5][6]                                   │ │
│  │         └───Row 0───┘└───Row 1───┘                           │ │
│  │                                                               │ │
│  │ Access Pattern: row0[0,1,2] → row1[0,1,2]                    │ │
│  │ Stride: (12, 4) - 12 bytes to next row, 4 bytes to next col │ │
│  │                                                               │ │
│  │ ✅ Fast: Row iteration (a[i, :] for all i)                    │ │
│  │ ❌ Slow: Column iteration (a[:, j] for all j)                 │ │
│  └──────────────────────────────────────────────────────────────┘ │
│                                                                    │
│  F-ORDER (Column-Major) - DEFAULT in MATLAB/Fortran               │
│  ┌──────────────────────────────────────────────────────────────┐ │
│  │ Memory: [1][4][2][5][3][6]                                   │ │
│  │         └─Col 0─┘└─Col 1─┘└─Col 2─┘                          │ │
│  │                                                               │ │
│  │ Access Pattern: col0[0,1] → col1[0,1] → col2[0,1]            │ │
│  │ Stride: (4, 8) - 4 bytes to next row, 8 bytes to next col   │ │
│  │                                                               │ │
│  │ ❌ Slow: Row iteration (a[i, :] for all i)                    │ │
│  │ ✅ Fast: Column iteration (a[:, j] for all j)                 │ │
│  └──────────────────────────────────────────────────────────────┘ │
│                                                                    │
│  CACHE LOCALITY:                                                   │
│  Sequential access → Cache hits → Fast ⚡                          │
│  Random access → Cache misses → Slow 🐌                           │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

import numpy as np
import time
from typing import Tuple

class MemoryLayoutAnalyzer:
    """Analyze and demonstrate C vs F order performance."""

    @staticmethod
    def example1_basic_layout():
        """Show memory layout difference."""
        print("="*70)
        print("EXAMPLE 1: C-ORDER vs F-ORDER MEMORY LAYOUT")
        print("="*70)

        arr = np.array([[1, 2, 3],
                       [4, 5, 6]], dtype=np.int32)

        # C-order (default)
        c_order = np.array(arr, order='C')
        # F-order
        f_order = np.array(arr, order='F')

        print(f"\nOriginal array:")
        print(arr)

        print(f"\n{'='*70}")
        print("C-ORDER (Row-Major)")
        print('='*70)
        print(f"Flags:")
        print(f"  C_CONTIGUOUS: {c_order.flags['C_CONTIGUOUS']}")
        print(f"  F_CONTIGUOUS: {c_order.flags['F_CONTIGUOUS']}")
        print(f"\nStrides (bytes to next element):")
        print(f"  {c_order.strides} - (12 bytes/row, 4 bytes/col)")
        print(f"\nMemory layout:")
        print(f"  [1][2][3][4][5][6]  (rows sequential)")
        print(f"  └───row 0──┘└───row 1──┘")

        print(f"\n{'='*70}")
        print("F-ORDER (Column-Major)")
        print('='*70)
        print(f"Flags:")
        print(f"  C_CONTIGUOUS: {f_order.flags['C_CONTIGUOUS']}")
        print(f"  F_CONTIGUOUS: {f_order.flags['F_CONTIGUOUS']}")
        print(f"\nStrides (bytes to next element):")
        print(f"  {f_order.strides} - (4 bytes/row, 8 bytes/col)")
        print(f"\nMemory layout:")
        print(f"  [1][4][2][5][3][6]  (columns sequential)")
        print(f"  └─col0─┘└─col1─┘└─col2─┘")

    @staticmethod
    def example2_performance_row_vs_col():
        """Benchmark row vs column access."""
        print(f"\n{'='*70}")
        print("EXAMPLE 2: ROW vs COLUMN ACCESS PERFORMANCE")
        print('='*70)

        size = 5000
        iterations = 100

        # Create arrays in both orders
        c_order = np.random.rand(size, size)
        f_order = np.asfortranarray(c_order)

        print(f"\nArray size: {size} × {size} = {size*size:,} elements")
        print(f"Memory per array: {c_order.nbytes / 1e6:.1f} MB")

        # Benchmark row-wise sum on C-order
        start = time.perf_counter()
        for _ in range(iterations):
            for i in range(size):
                _ = np.sum(c_order[i, :])  # Row access
        c_row_time = time.perf_counter() - start

        # Benchmark column-wise sum on C-order (BAD)
        start = time.perf_counter()
        for _ in range(iterations):
            for j in range(size):
                _ = np.sum(c_order[:, j])  # Column access
        c_col_time = time.perf_counter() - start

        # Benchmark row-wise sum on F-order (BAD)
        start = time.perf_counter()
        for _ in range(iterations):
            for i in range(size):
                _ = np.sum(f_order[i, :])  # Row access
        f_row_time = time.perf_counter() - start

        # Benchmark column-wise sum on F-order (GOOD)
        start = time.perf_counter()
        for _ in range(iterations):
            for j in range(size):
                _ = np.sum(f_order[:, j])  # Column access
        f_col_time = time.perf_counter() - start

        print(f"\n{'='*70}")
        print("RESULTS")
        print('='*70)
        print(f"\nC-ORDER array:")
        print(f"  Row-wise access:    {c_row_time:.3f}s  ✅ (contiguous)")
        print(f"  Column-wise access: {c_col_time:.3f}s  ❌ (strided)")
        print(f"  Penalty: {c_col_time/c_row_time:.1f}x slower")

        print(f"\nF-ORDER array:")
        print(f"  Row-wise access:    {f_row_time:.3f}s  ❌ (strided)")
        print(f"  Column-wise access: {f_col_time:.3f}s  ✅ (contiguous)")
        print(f"  Penalty: {f_row_time/f_col_time:.1f}x slower")

        print(f"\n💡 LESSON: Match memory order to access pattern!")
        print(f"   C-order for row operations: {c_col_time/c_row_time:.1f}x faster")
        print(f"   F-order for column operations: {f_row_time/f_col_time:.1f}x faster")

    @staticmethod
    def example3_transpose_cost():
        """Analyze transpose with different orders."""
        print(f"\n{'='*70}")
        print("EXAMPLE 3: TRANSPOSE COST (C vs F order)")
        print('='*70)

        size = 2000
        c_order = np.random.rand(size, size)
        f_order = np.asfortranarray(c_order)

        # Transpose C-order
        start = time.perf_counter()
        c_transposed = c_order.T
        c_time = time.perf_counter() - start

        # Transpose F-order
        start = time.perf_counter()
        f_transposed = f_order.T
        f_time = time.perf_counter() - start

        print(f"\nTranspose {size}×{size} array:")
        print(f"  C-order → T: {c_time*1000:.4f} ms")
        print(f"  F-order → T: {f_time*1000:.4f} ms")
        print(f"\n✅ Both are instant (view, not copy)!")

        print(f"\nBUT - accessing transposed data:")
        print(f"  Original C-order: C_CONTIGUOUS={c_order.flags['C_CONTIGUOUS']}")
        print(f"  After transpose:  C_CONTIGUOUS={c_transposed.flags['C_CONTIGUOUS']}")
        print(f"  After transpose:  F_CONTIGUOUS={c_transposed.flags['F_CONTIGUOUS']}")
        print(f"\n💡 Transpose flips contiguity!")
        print(f"   C-order.T becomes F-order contiguous")
        print(f"   F-order.T becomes C-order contiguous")

    @staticmethod
    def example4_jane_street_use_case():
        """Jane Street tick processing simulation."""
        print(f"\n{'='*70}")
        print("JANE STREET - TICK DATA COLUMN-WISE PROCESSING")
        print('='*70)

        # Simulate tick data: 1M ticks × 10 features
        n_ticks = 100_000  # Scaled down from 10M
        n_features = 10  # [price, volume, bid, ask, ...]

        print(f"\nTick data: {n_ticks:,} ticks × {n_features} features")
        print(f"Task: Compute statistics PER FEATURE (column-wise)")

        # Method 1: C-order (DEFAULT - BAD for column access)
        data_c = np.random.randn(n_ticks, n_features)

        start = time.perf_counter()
        stats_c = {}
        for j in range(n_features):
            col = data_c[:, j]  # Column access (strided in C-order)
            stats_c[j] = {'mean': np.mean(col), 'std': np.std(col)}
        c_time = time.perf_counter() - start

        # Method 2: F-order (OPTIMAL for column access)
        data_f = np.asfortranarray(data_c)

        start = time.perf_counter()
        stats_f = {}
        for j in range(n_features):
            col = data_f[:, j]  # Column access (contiguous in F-order)
            stats_f[j] = {'mean': np.mean(col), 'std': np.std(col)}
        f_time = time.perf_counter() - start

        print(f"\n{'='*70}")
        print("RESULTS")
        print('='*70)
        print(f"\nMethod 1: C-order (default)")
        print(f"  Time: {c_time*1000:.2f} ms")
        print(f"  Problem: Column access jumps in memory (cache misses)")

        print(f"\nMethod 2: F-order (optimized)")
        print(f"  Time: {f_time*1000:.2f} ms")
        print(f"  Benefit: Column access is contiguous (cache hits)")

        print(f"\n💰 SAVINGS:")
        print(f"  Speedup: {c_time/f_time:.1f}x")
        print(f"  Time saved: {(c_time - f_time)*1000:.2f} ms per iteration")

        print(f"\n📊 At Jane Street scale (10M ticks):")
        print(f"  C-order: ~{c_time * 100:.1f}s")
        print(f"  F-order: ~{f_time * 100:.1f}s")
        print(f"  Enables real-time processing at 10M ticks/sec!")

    @staticmethod
    def example5_convert_and_check():
        """How to convert between orders and check contiguity."""
        print(f"\n{'='*70}")
        print("EXAMPLE 5: CONVERT BETWEEN ORDERS & CHECK CONTIGUITY")
        print('='*70)

        arr = np.random.rand(1000, 1000)

        print(f"\nOriginal array (C-order by default):")
        print(f"  C_CONTIGUOUS: {arr.flags['C_CONTIGUOUS']}")
        print(f"  F_CONTIGUOUS: {arr.flags['F_CONTIGUOUS']}")
        print(f"  Memory: {arr.nbytes / 1e6:.1f} MB")

        # Convert to F-order
        print(f"\n{'='*70}")
        print("Method 1: np.asfortranarray() - Creates copy if needed")
        print('='*70)
        f_arr = np.asfortranarray(arr)
        print(f"  C_CONTIGUOUS: {f_arr.flags['C_CONTIGUOUS']}")
        print(f"  F_CONTIGUOUS: {f_arr.flags['F_CONTIGUOUS']}")
        print(f"  Is copy? {f_arr.base is not arr}")

        # Convert back to C-order
        print(f"\n{'='*70}")
        print("Method 2: np.ascontiguousarray() - Ensures C-order")
        print('='*70)
        c_arr = np.ascontiguousarray(f_arr)
        print(f"  C_CONTIGUOUS: {c_arr.flags['C_CONTIGUOUS']}")
        print(f"  F_CONTIGUOUS: {c_arr.flags['F_CONTIGUOUS']}")

        # Check specific order
        print(f"\n{'='*70}")
        print("Method 3: Create with order parameter")
        print('='*70)
        new_c = np.array([[1, 2], [3, 4]], order='C')
        new_f = np.array([[1, 2], [3, 4]], order='F')
        print(f"  C-order: {new_c.flags['C_CONTIGUOUS']}")
        print(f"  F-order: {new_f.flags['F_CONTIGUOUS']}")

        # Transpose side effect
        print(f"\n{'='*70}")
        print("BONUS: Transpose flips contiguity")
        print('='*70)
        print(f"  arr (C-order).T → F_CONTIGUOUS: {arr.T.flags['F_CONTIGUOUS']}")
        print(f"  f_arr (F-order).T → C_CONTIGUOUS: {f_arr.T.flags['C_CONTIGUOUS']}")

# Run all examples
analyzer = MemoryLayoutAnalyzer()
analyzer.example1_basic_layout()
analyzer.example2_performance_row_vs_col()
analyzer.example3_transpose_cost()
analyzer.example4_jane_street_use_case()
analyzer.example5_convert_and_check()

import numpy as np

A = np.random.rand(3, 4)
B = np.random.rand(4, 5)

# Matrix multiplication: C_ij = sum_k A_ik * B_kj
C = np.einsum('ik,kj->ij', A, B)

# Transpose
A_T = np.einsum('ij->ji', A)

# Trace (diagonal sum)
trace = np.einsum('ii->', np.eye(3))  # 3.0

# Outer product
outer = np.einsum('i,j->ij', np.arange(3), np.arange(4))

# Batch matrix multiply
batch_A = np.random.rand(10, 3, 4)
batch_B = np.random.rand(10, 4, 5)
result = np.einsum('bij,bjk->bik', batch_A, batch_B)

# Attention mechanism (simplified)
Q = np.random.rand(8, 64)  # queries
K = np.random.rand(8, 64)  # keys
attention = np.einsum('qd,kd->qk', Q, K)  # (8, 8)

import numpy as np

# Create a generator
rng = np.random.default_rng(seed=42)

# Uniform [0, 1)
rng.random(size=(3, 4))

# Integers
rng.integers(low=0, high=10, size=5)

# Normal distribution
rng.normal(loc=0, scale=1, size=100)

# Choice/sampling
rng.choice(['a', 'b', 'c'], size=10, replace=True)

# Shuffle
arr = np.arange(10)
rng.shuffle(arr)

np.random.seed(42)              # Global seed
np.random.rand(3, 4)            # Uniform [0, 1)
np.random.randn(3, 4)           # Standard normal
np.random.randint(0, 10, 5)     # Integers
np.random.choice([1, 2, 3], 5)  # Random choice

┌──────────────────────────────────────────────────────────────────┐
│                    VIEW vs COPY SEMANTICS                        │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  VIEW - Shares underlying data buffer                            │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ Original: [1, 2, 3, 4, 5]  Memory: 0x1000                  │ │
│  │ View:     [2, 3, 4]        Memory: 0x1000 + offset         │ │
│  │                                                             │ │
│  │ Characteristics:                                            │ │
│  │   • .base points to original array                         │ │
│  │   • Modifying view AFFECTS original                        │ │
│  │   • Zero memory allocation (instant)                       │ │
│  │   • Uses different strides/shape on same data              │ │
│  └────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  COPY - Independent data buffer                                  │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ Original: [1, 2, 3, 4, 5]  Memory: 0x1000                  │ │
│  │ Copy:     [2, 3, 4]        Memory: 0x2000 (NEW)            │ │
│  │                                                             │ │
│  │ Characteristics:                                            │ │
│  │   • .base is None (independent)                            │ │
│  │   • Modifying copy does NOT affect original                │ │
│  │   • Allocates new memory (slower)                          │ │
│  │   • Completely separate array                              │ │
│  └────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  DANGER: Unintended modifications via views                      │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ >>> original = np.arange(10)                               │ │
│  │ >>> view = original[2:7]     # Creates view!               │ │
│  │ >>> view[:] = 999            # Modifies original!          │ │
│  │ >>> print(original)                                        │ │
│  │ [0, 1, 999, 999, 999, 999, 999, 7, 8, 9]  # Corrupted!    │ │
│  └────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

import numpy as np
import sys
from typing import Optional

class ViewCopyAnalyzer:
    """Comprehensive view vs copy behavior analysis."""

    @staticmethod
    def example1_basic_view_vs_copy():
        """Demonstrate fundamental difference."""
        print("="*70)
        print("EXAMPLE 1: BASIC VIEW vs COPY")
        print("="*70)

        original = np.array([1, 2, 3, 4, 5])
        print(f"\nOriginal: {original}")
        print(f"Memory address: {hex(original.__array_interface__['data'][0])}")

        # Create view via slicing
        print("\n" + "-"*70)
        print("SLICING → VIEW")
        print("-"*70)
        view = original[1:4]
        print(f"view = original[1:4]: {view}")
        print(f"Memory address: {hex(view.__array_interface__['data'][0])}")
        print(f"view.base is original: {view.base is original}  ✅ (view)")

        # Modify view
        view[0] = 999
        print(f"\nAfter view[0] = 999:")
        print(f"  view:     {view}")
        print(f"  original: {original}  ⚠️  MODIFIED!")

        # Create copy
        print("\n" + "-"*70)
        print("EXPLICIT COPY")
        print("-"*70)
        original2 = np.array([1, 2, 3, 4, 5])
        copy = original2[1:4].copy()
        print(f"copy = original2[1:4].copy(): {copy}")
        print(f"Memory address: {hex(copy.__array_interface__['data'][0])}")
        print(f"copy.base is None: {copy.base is None}  ✅ (copy)")

        # Modify copy
        copy[0] = 888
        print(f"\nAfter copy[0] = 888:")
        print(f"  copy:      {copy}")
        print(f"  original2: {original2}  ✅ UNCHANGED")

    @staticmethod
    def example2_operation_matrix():
        """Which operations create views vs copies."""
        print("\n" + "="*70)
        print("EXAMPLE 2: OPERATION MATRIX (View vs Copy)")
        print("="*70)

        a = np.arange(24).reshape(4, 6)

        operations = [
            ("Slicing a[1:3]", a[1:3]),
            ("Transpose a.T", a.T),
            ("Reshape a.reshape(6, 4)", a.reshape(6, 4)),
            ("Ravel a.ravel()", a.ravel()),
            ("Boolean index a[a > 10]", a[a > 10]),
            ("Fancy index a[[0, 2]]", a[[0, 2]]),
            ("Flatten a.flatten()", a.flatten()),
        ]

        print("\n{:<30} {:<10} {:<15}".format("Operation", "Is View?", "Shares Memory?"))
        print("-"*70)

        for name, result in operations:
            is_view = result.base is not None
            shares_mem = np.shares_memory(a, result)
            view_str = "✅ VIEW" if is_view else "❌ COPY"
            print(f"{name:<30} {view_str:<10} {shares_mem}")

    @staticmethod
    def example3_meta_feed_ranking_bug():
        """Simulate Meta's feed ranking bug (view modification)."""
        print("\n" + "="*70)
        print("META - FEED RANKING BUG (View Modification)")
        print("="*70)

        # Simulate feed scores for posts
        all_posts = np.array([
            [1.0, 0.8, 0.9],  # post_id 0
            [0.7, 0.6, 0.8],  # post_id 1
            [0.9, 0.9, 0.7],  # post_id 2
            [0.6, 0.5, 0.6],  # post_id 3
        ])  # columns: relevance, engagement, recency

        print("\nOriginal post scores (4 posts × 3 features):")
        print(all_posts)

        # BUG: Extract top posts (creates view!)
        print("\n" + "-"*70)
        print("BUGGY CODE: top_posts = all_posts[:2] (creates view)")
        print("-"*70)
        top_posts = all_posts[:2]  # View!

        print(f"Is view? {top_posts.base is all_posts}")

        # Apply boost to top posts (CORRUPTS original!)
        print("\nApplying 1.2x boost to top posts...")
        top_posts *= 1.2

        print("\nAfter boost:")
        print(f"  top_posts:\n{top_posts}")
        print(f"\n  all_posts (CORRUPTED):\n{all_posts}")
        print("\n⚠️  BUG: Original data modified! All future rankings affected!")

        # FIX: Use explicit copy
        print("\n" + "-"*70)
        print("FIXED CODE: top_posts = all_posts[:2].copy()")
        print("-"*70)

        all_posts_fixed = np.array([
            [1.0, 0.8, 0.9],
            [0.7, 0.6, 0.8],
            [0.9, 0.9, 0.7],
            [0.6, 0.5, 0.6],
        ])

        top_posts_copy = all_posts_fixed[:2].copy()  # Copy!
        print(f"Is copy? {top_posts_copy.base is None}")

        top_posts_copy *= 1.2

        print("\nAfter boost:")
        print(f"  top_posts_copy:\n{top_posts_copy}")
        print(f"\n  all_posts_fixed (SAFE):\n{all_posts_fixed}")
        print("\n✅ FIX: Original data unchanged!")

    @staticmethod
    def example4_check_sharing():
        """Methods to check if arrays share memory."""
        print("\n" + "="*70)
        print("EXAMPLE 4: CHECK IF VIEW OR COPY")
        print("="*70)

        a = np.arange(10)
        view = a[2:7]
        copy = a[2:7].copy()

        print("\nMethod 1: Check .base attribute")
        print(f"  view.base is a:  {view.base is a}  (True = view)")
        print(f"  copy.base is None: {copy.base is None}  (True = copy)")

        print("\nMethod 2: np.shares_memory()")
        print(f"  np.shares_memory(a, view): {np.shares_memory(a, view)}")
        print(f"  np.shares_memory(a, copy): {np.shares_memory(a, copy)}")

        print("\nMethod 3: Memory address")
        a_addr = a.__array_interface__['data'][0]
        view_addr = view.__array_interface__['data'][0]
        copy_addr = copy.__array_interface__['data'][0]

        print(f"  a address:    {hex(a_addr)}")
        print(f"  view address: {hex(view_addr)} (same base)")
        print(f"  copy address: {hex(copy_addr)} (different)")

        print("\nMethod 4: .flags (check writeable)")
        a_readonly = a[2:7]
        a_readonly.flags.writeable = False
        print(f"  view writeable: {a_readonly.flags['WRITEABLE']}")
        print(f"  Can use to detect views and prevent modification")

    @staticmethod
    def example5_surprising_behaviors():
        """Surprising view/copy behaviors."""
        print("\n" + "="*70)
        print("EXAMPLE 5: SURPRISING BEHAVIORS")
        print("="*70)

        a = np.arange(12).reshape(3, 4)

        # Surprise 1: Boolean indexing creates copy
        print("\n1. Boolean indexing → COPY (not view!)")
        mask = a > 5
        subset = a[mask]
        print(f"   a[a > 5] is copy: {subset.base is None}")
        print(f"   Reason: Result may be non-contiguous")

        # Surprise 2: Fancy indexing creates copy
        print("\n2. Fancy indexing → COPY (not view!)")
        fancy = a[[0, 2]]  # Select rows 0 and 2
        print(f"   a[[0, 2]] is copy: {fancy.base is None}")
        print(f"   Reason: Selected elements may be non-contiguous")

        # Surprise 3: reshape may or may not copy
        print("\n3. reshape() → View OR Copy (depends!)")
        view_reshape = a.reshape(4, 3)  # Contiguous → view
        print(f"   reshape(4, 3) is view: {view_reshape.base is a}")

        # Non-contiguous reshape forces copy
        non_contig = a.T
        copy_reshape = non_contig.reshape(12)
        print(f"   a.T.reshape(12) is copy: {copy_reshape.base is None}")
        print(f"   Reason: Transpose broke contiguity")

        # Surprise 4: Diagonal view
        print("\n4. Diagonal → VIEW (special strides!)")
        diag = np.diag(a)
        # Note: np.diag returns array, but diagonal_view shows concept
        print(f"   np.diag() returns copy, but conceptually a view")

    @staticmethod
    def example6_performance_implications():
        """Performance: view vs copy."""
        print("\n" + "="*70)
        print("EXAMPLE 6: PERFORMANCE IMPLICATIONS")
        print("="*70)

        import time

        large_array = np.random.rand(10000, 1000)

        # Benchmark slicing (view)
        start = time.perf_counter()
        for _ in range(1000):
            view = large_array[100:200]
        view_time = time.perf_counter() - start

        # Benchmark slicing + copy
        start = time.perf_counter()
        for _ in range(1000):
            copy = large_array[100:200].copy()
        copy_time = time.perf_counter() - start

        view_mem = 0  # Views don't allocate
        copy_mem = large_array[100:200].copy().nbytes

        print(f"\nSlicing 100 rows from (10000, 1000) array:")
        print(f"\n  View (no copy):")
        print(f"    Time: {view_time*1000:.2f} ms")
        print(f"    Memory: 0 bytes (shares original)")

        print(f"\n  Copy (explicit):")
        print(f"    Time: {copy_time*1000:.2f} ms")
        print(f"    Memory: {copy_mem/1e6:.1f} MB allocated")

        print(f"\n  Copy is {copy_time/view_time:.0f}x slower")
        print(f"  For read-only: use views (zero-cost)")
        print(f"  For modifications: use copies (safety)")

# Run all examples
analyzer = ViewCopyAnalyzer()
analyzer.example1_basic_view_vs_copy()
analyzer.example2_operation_matrix()
analyzer.example3_meta_feed_ranking_bug()
analyzer.example4_check_sharing()
analyzer.example5_surprising_behaviors()
analyzer.example6_performance_implications()