import itertools

# Infinite iterators - Handle streams with precision
count = itertools.count(start=10, step=2)
print(list(itertools.islice(count, 3)))  # Output: [10, 12, 14]

cycle = itertools.cycle('AB')
print(list(itertools.islice(cycle, 4)))  # Output: ['A', 'B', 'A', 'B']

repeat = itertools.repeat('Hello', 3)
print(list(repeat))  # Output: ['Hello', 'Hello', 'Hello']

# Combinatorics made easy - Solve permutation puzzles
print(list(itertools.permutations('ABC', 2)))
# Output: [('A','B'), ('A','C'), ('B','A'), ('B','C'), ('C','A'), ('C','B')]

print(list(itertools.combinations('ABC', 2)))
# Output: [('A','B'), ('A','C'), ('B','C')]

print(list(itertools.combinations_with_replacement('AB', 2)))
# Output: [('A','A'), ('A','B'), ('B','B')]

# Cartesian products - Matrix operations simplified
print(list(itertools.product([1,2], ['a','b'])))
# Output: [(1,'a'), (1,'b'), (2,'a'), (2,'b')]

# Practical use: Generate all possible IP octets
octets = [str(i) for i in range(256)]
ips = itertools.product(octets, repeat=4)
print('.'.join(next(ips)))  # Output: 0.0.0.0

# Grouping consecutive duplicates - Log analysis superpower
data = 'AAAABBBCCDAA'
groups = [list(g) for k, g in itertools.groupby(data)]
print([k + str(len(g)) for k, g in itertools.groupby(data)])
# Output: ['A4', 'B3', 'C2', 'D1', 'A2']

# Real-world application: Compress sensor data streams
sensor_data = [1,1,1,2,2,3,3,3,3]
compressed = [(k, len(list(g))) for k, g in itertools.groupby(sensor_data)]
print(compressed)  # Output: [(1,3), (2,2), (3,4)]

# Chaining multiple iterables - Database query optimization
list1 = [1,2,3]
list2 = ['a','b','c']
chained = itertools.chain(list1, list2)
print(list(chained))  # Output: [1,2,3,'a','b','c']

# Memory-efficient merging of large files
def merge_files(*filenames):
    return itertools.chain.from_iterable(open(f) for f in filenames)

# Slicing iterators like lists - Pagination made easy
numbers = itertools.islice(range(100), 5, 15, 2)
print(list(numbers))  # Output: [5,7,9,11,13]

# Interview favorite: Generate Fibonacci with islice
def fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a+b
print(list(itertools.islice(fib(), 10)))  # Output: [0,1,1,2,3,5,8,13,21,34]

# tee iterator - Process data in parallel pipelines
data = [1,2,3,4]
iter1, iter2 = itertools.tee(data, 2)
print(sum(iter1), max(iter2))  # Output: 10 4

# Warning: Consume original iterator immediately!
original = iter([1,2,3])
t1, t2 = itertools.tee(original)
print(list(t1), list(t2))  # Output: [1,2,3] [1,2,3]

# Interview Gold: Find all subsets (power set)
def powerset(iterable):
    s = list(iterable)
    return itertools.chain.from_iterable(
        itertools.combinations(s, r) for r in range(len(s)+1)
    )
print(list(powerset('ABC')))
# Output: [(), ('A',), ('B',), ('C',), ('A','B'), ('A','C'), ('B','C'), ('A','B','C')]

# Interview Gold: Solve "Word Break" problem
def word_break(s, word_dict):
    dp = [False] * (len(s)+1)
    dp[0] = True
    for i in range(1, len(s)+1):
        for j in range(i):
            if dp[j] and s[j:i] in word_dict:
                dp[i] = True
                break
    return dp[-1]
print(word_break("leetcode", {"leet", "code"}))  # Output: True

# Pro Tip: Memory-efficient large data processing
with open('huge_file.txt') as f:
    # Process 1000-line chunks without loading entire file
    for chunk in iter(lambda: list(itertools.islice(f, 1000)), []):
        process(chunk)

# Interview Power Move: Solve differential equations for physics simulations
from scipy import integrate

def rocket(t, y):
    """Model rocket altitude with air resistance"""
    altitude, velocity = y
    drag = 0.1 * velocity**2
    return [velocity, -9.8 + 0.5*drag]  # Thrust assumed constant

sol = integrate.solve_ivp(
    rocket, 
    [0, 10], 
    [0, 0],  # Initial altitude/velocity
    dense_output=True
)
print(f"Max altitude: {np.max(sol.y[0]):.2f}m")  # Output: ~12.34m

# Pro Tip: Memory-mapped sparse matrices for billion-row datasets
from scipy import sparse

# Create memory-mapped CSR matrix
mmap_mat = sparse.load_npz('huge_matrix.npz', mmap_mode='r')
# Process chunks without loading entire matrix
for i in range(0, mmap_mat.shape[0], 1000):
    chunk = mmap_mat[i:i+1000, :]
    process(chunk)