Practice Questions — Comprehensions and Generators

# 1. Squares of 1-10
squares = [x ** 2 for x in range(1, 11)]
print(f"Squares: {squares}")

# 2. Even numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = [x for x in numbers if x % 2 == 0]
print(f"Evens: {evens}")

# 3. First character of each word
sentence = "The quick brown fox"
initials = [w[0] for w in sentence.split()]
print(f"Initials: {initials}")

# 4. Replace negatives with 0
data = [3, -1, 7, -5, 2]
cleaned = [x if x >= 0 else 0 for x in data]
print(f"Cleaned: {cleaned}")

# 1. Number to cube mapping
cubes = {x: x**3 for x in range(1, 6)}
print(f"Cubes: {cubes}")

# 2. Invert a dictionary
original = {'a': 1, 'b': 2, 'c': 3}
inverted = {v: k for k, v in original.items()}
print(f"Inverted: {inverted}")

# 3. Unique word lengths
sentence = "the quick brown fox jumps"
lengths = {len(w) for w in sentence.split()}
print(f"Lengths: {sorted(lengths)}")

# 4. Filter dictionary by value
scores = {'Aarav': 85, 'Priya': 42, 'Rohan': 91, 'Meera': 38}
passed = {k: v for k, v in scores.items() if v > 50}
print(f"Passed: {passed}")

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 1. First 10 Fibonacci numbers
fib = fibonacci()
first_10 = [next(fib) for _ in range(10)]
print(f"First 10: {first_10}")

# 2. First Fibonacci number > 100
fib = fibonacci()
for num in fib:
    if num > 100:
        print(f"First > 100: {num}")
        break

# 3. Sum of Fibonacci numbers under 50
fib = fibonacci()
total = 0
for num in fib:
    if num >= 50:
        break
    total += num
print(f"Sum under 50: {total}")

def create_matrix(rows, cols, fill=0):
    return [[fill for _ in range(cols)] for _ in range(rows)]

def transpose(matrix):
    if not matrix:
        return []
    return [[row[i] for row in matrix] for i in range(len(matrix[0]))]

def flatten(matrix):
    return [val for row in matrix for val in row]

def matrix_add(a, b):
    return [[a[i][j] + b[i][j] for j in range(len(a[0]))] for i in range(len(a))]

print(f"Created: {create_matrix(2, 3)}")
print(f"Transpose: {transpose([[1, 2, 3], [4, 5, 6]])}")
print(f"Flattened: {flatten([[1, 2, 3], [4, 5, 6]])}")

m1 = [[1, 2], [3, 4]]
m2 = [[5, 6], [7, 8]]
print(f"Sum: {matrix_add(m1, m2)}")

def read_lines(text):
    for line in text.split('\n'):
        yield line

def strip_lines(lines):
    for line in lines:
        yield line.strip()

def remove_empty(lines):
    for line in lines:
        if line:
            yield line

def to_words(lines):
    for line in lines:
        for word in line.split():
            yield word

def unique_words(words):
    seen = set()
    for word in words:
        if word not in seen:
            seen.add(word)
            yield word

text = """  Hello world  
  
  Python is great  
    
  Hello Python  """

all_lines = list(read_lines(text))
print(f"Lines: {len(all_lines)}")

clean = list(remove_empty(strip_lines(read_lines(text))))
print(f"Clean lines: {len(clean)}")

words = list(to_words(remove_empty(strip_lines(read_lines(text)))))
print(f"Words: {words}")

uniq = list(unique_words(to_words(remove_empty(strip_lines(read_lines(text))))))
print(f"Unique: {uniq}")

def naturals(start=1):
    n = start
    while True:
        yield n
        n += 1

def cycle(iterable):
    items = list(iterable)
    while True:
        for item in items:
            yield item

def repeat(value, times=None):
    if times is None:
        while True:
            yield value
    else:
        for _ in range(times):
            yield value

def take(n, gen):
    return [next(gen) for _ in range(n)]

print(f"Naturals: {take(5, naturals())}")
print(f"Cycle: {take(7, cycle(['a', 'b', 'c']))}")
print(f"Repeat forever: {take(5, repeat(42))}")
print(f"Repeat 3 times: {list(repeat(42, 3))}")

students = [
    {"name": "Aarav", "subject": "Math", "score": 85},
    {"name": "Priya", "subject": "Math", "score": 42},
    {"name": "Rohan", "subject": "Math", "score": 96},
    {"name": "Meera", "subject": "Python", "score": 55},
    {"name": "Kavya", "subject": "Python", "score": 81},
    {"name": "Aarav", "subject": "Science", "score": 91},
    {"name": "Rohan", "subject": "Science", "score": 55},
]

# 1. Names of students who scored above 80
above_80 = [s["name"] for s in students if s["score"] > 80]
print(f"Above 80: {above_80}")

# 2. Average score per subject
subjects = {s["subject"] for s in students}
averages = {
    subj: round(sum(s["score"] for s in students if s["subject"] == subj) / 
          sum(1 for s in students if s["subject"] == subj), 2)
    for subj in subjects
}
print(f"Averages: {averages}")

# 3. Top scorer per subject
top_per_subject = {
    subj: max((s for s in students if s["subject"] == subj), key=lambda s: s["score"])["name"]
    for subj in subjects
}
print(f"Top per subject: {top_per_subject}")

# 4. Grade distribution
def grade(score):
    if score >= 90: return "A"
    if score >= 75: return "B"
    if score >= 50: return "C"
    return "F"

grades = [grade(s["score"]) for s in students]
distribution = {g: grades.count(g) for g in sorted(set(grades))}
print(f"Grade distribution: {distribution}")

class LazyCSV:
    def __init__(self, data):
        self.lines = data.strip().split('\n')
        self.header = self.lines[0].split(',')
    
    def rows(self):
        for line in self.lines[1:]:
            yield line.split(',')
    
    def dicts(self):
        for row in self.rows():
            yield {self.header[i]: row[i].strip() for i in range(len(self.header))}
    
    def select(self, columns):
        indices = [self.header.index(col) for col in columns]
        for row in self.rows():
            yield [row[i].strip() for i in indices]
    
    def where(self, column, condition):
        for record in self.dicts():
            if condition(record.get(column, '')):
                yield record

csv_data = """name,age,score
Aarav,16,85
Priya,15,42
Rohan,17,92"""

csv = LazyCSV(csv_data)

row_gen = csv.rows()
print(f"Row: {next(row_gen)}")

dict_gen = csv.dicts()
print(f"Dict: {next(dict_gen)}")

names = list(csv.select(['name']))
print(f"Names: {names}")

high = list(csv.where('score', lambda s: int(s) > 50))
print(f"High scores: {high}")

def integers_from(n):
    while True:
        yield n
        n += 1

def sieve(numbers):
    prime = next(numbers)
    yield prime
    filtered = (n for n in numbers if n % prime != 0)
    yield from sieve(filtered)

def primes():
    yield from sieve(integers_from(2))

import sys
sys.setrecursionlimit(2000)

# First 15 primes
gen = primes()
first_15 = [next(gen) for _ in range(15)]
print(f"First 15 primes: {first_15}")

# 100th prime
gen = primes()
for i in range(99):
    next(gen)
hundredth = next(gen)
print(f"100th prime: {hundredth}")

# Sum of primes below 100
gen = primes()
total = 0
for p in gen:
    if p >= 100:
        break
    total += p
print(f"Sum of primes below 100: {total}")