prep_guide

Part 0: Visualizations & Mental Models

Variable Assignment (References, not Boxes)

Architect Mode
Building Architecture Diagram...

Control Flow (The Loop Engine)

Architect Mode
Building Architecture Diagram...

Part 1: Core Theory & Jargon (The Lexicon)

1. Primitives vs Composites

• Primitives (Immutable): These are the atomic building blocks of Python. Once created, their value in memory cannot be changed. If you modify them, Python destroys the old one and generates a new one.
  • int: Whole numbers (5, -10).
  • float: Decimals (3.14). Precision can sometimes drift (e.g., 0.1 + 0.2 != 0.3).
  • bool: Truth states (True, False). Internally, these are just 1 and 0.
  • str: Strings of characters ("IITM"). Strings are technically sequences and are immutable.
• Composites (Data Structures): Objects that hold multiple Primitives.
  • list ([]): Ordered, Mutable sequence. You can change elements at will.
  • tuple (()): Ordered, Immutable sequence. Locked permanently after creation.
  • dict ({}): Unordered (historically mapping, now insertion-ordered), Mutable key-value pairs.
  • set ({}): Unordered, Mutable collection of theoretically unique elements.

2. Operators Theory & Minute Tacit Details

• Arithmetic: +, -, *, / (always returns float), // (Floor division - truncates decimals), % (Modulo - returns remainder), ** (Exponentiation).
• Relational (Comparison): Evaluates to Booleans. == (Equality), != (Not Equal), >, <, >=, <=.
• Logical: and (True if BOTH are true), or (True if AT LEAST ONE is true), not (Inverts truth).

Fact: Python uses "Short-circuit evaluation". For A and B, if A is False, Python doesn't even bother evaluating B because the whole statement is guaranteed to be False.

• Arithmetic Operators:
  • / (Standard Division): Always returns a Float (even 4/2 is 2.0).
  • // (Floor Division): Performs division and rounds down to the nearest integer less than or equal to the quotient (toward negative infinity). Discards the fractional part.
    • Example (Tacit Detail): 10 // 3 is 3, but -10 // 3 is -4 (rounds toward more negative).
  • % (Modulo): Returns the remainder. Used for even/odd testing (x % 2 == 0).
  • ** (Exponentiation): 2**3 is 8.
• Built-in Numeric "GOTCHAS" (IITM MCQ Favorites):
  • The Rounding Rule: round(x) in Python 3 uses Banker's Rounding. It rounds to the nearest even number on a .5 boundary.
    • Example: round(2.5) is 2, but round(3.5) is 4.
  • Implicit Boolean Truthiness: Almost every object has a boolean value.
    • 0, 0.0, "" (Empty String), [] (Empty List), {} (Empty Dict), None are all False.
    • Literally everything else is True.
• Logical Operators:
  • and (True if BOTH true), or (True if ANY true), not (Inverts).
  • Fact: Python uses "Short-circuit evaluation". For A and B, if A is False, Python doesn't evaluate B.

3. Iterables and Iterators

• Iterable: Any object capable of returning its members one at a time (Strings, Lists, Dictionaries).
• Iteration: The physical process of taking one element at a time from an iterable (e.g., running a for loop).

Part 2: OPPE Evaluation Mechanics

1. Standard I/O (The Loop Input Pattern)

python
Run Inline
num_lines = int(input())   # Server passes the count of datasets
for _ in range(num_lines):
    data = input()          # Server passes N sequential string payloads
    print(data.upper())     # Print result verbatim!

2. Functional Injection (The Skeleton Pattern)

python
Run Inline
def reverse_substring(s: str) -> str:
    # Process the argument directly
    return s[::-1]

3. State Evaluation (Variable Checking - e.g. GrPA 2)

Part 3: Core Manipulation Hacks & Procedures

The String Slicing Formula [start:stop:step]

• start: Inclusive limit. Default is 0.
• stop: Exclusive limit. Default is len(word).
• step: Interval leap. Default is 1.

python
Run Inline
s = "IITMadras"
s[::-1]        # "sardaMTII" (Strict Reverse)
s[::2]         # "ITars" (Every Even Index)
s[1::2]        # "IMda" (Every Odd Index)
s[:-1]         # Drops the last character

Enumeration & Zip

python
Run Inline
word = "Python"
for index, char in enumerate(word):
    if index % 2 == 0:
        print(f"Index {index}: {char}")

python
Run Inline
listA = [1, 2, 3]
listB = ["A", "B", "C"]
for num, char in zip(listA, listB):
    print(num, char) # Evaluates in exact positional parity

Part 4: Nested Execution Spaces (Week 3 Dynamics)

python
Run Inline
for r in range(3):        # Outer loop controls Rows (0, 1, 2)
    for c in range(3):    # Inner loop controls Columns (0, 1, 2)
        print(f"[{r},{c}]", end=" ")
    print()               # Line break after an entire row of columns finishes

Break vs Continue

• continue: Instantly aborts the current inner loop cycle and triggers the next cycle of that exact loop.
• break: Completely destroys and exits the active loop layer permanently. (If placed in an inner loop, it only breaks the inner loop, leaving the outer loop running!).

Part 5: HashMaps (The Frequency Counter Pattern)

python
Run Inline
inbox = ["apple", "banana", "apple", "orange", "banana", "apple"]
frequency_map = {}

for fruit in inbox:
    if fruit not in frequency_map:
        frequency_map[fruit] = 1   # Initialize the key
    else:
        frequency_map[fruit] += 1  # Increment existing mapping

# frequency_map -> {"apple": 3, "banana": 2, "orange": 1}

Set Reductions

python
Run Inline
a = {1, 2, 3}
b = {3, 4, 5}
a & b   # Intersection -> {3}
a | b   # Union -> {1, 2, 3, 4, 5}
a - b   # Difference -> {1, 2}
a ^ b   # Symmetric Diff -> {1, 2, 4, 5}

Part 6: Function Mechanics & Scoping

Arguments vs Parameters

• Parameter: The variable listed inside the parentheses in the function definition (e.g. def test(a, b):).
• Argument: The actual value that is sent to the function when it is called (e.g. test(5, 10)).

Variable Scope (LEGB Rule)

1. Local: Inside the current function.
2. Enclosing: Inside any overarching wrapper functions.
3. Global: At the top level of the module/script.
4. Built-in: Python's native reserved keywords (len, sum, print).

Note: If you want to modify a Global variable inside a Local scope, you must explicitly declare global x inside the function, otherwise Python creates a shadowing Local copy.

Part 7: Edge-Case Formatting

1. Empty Buffers: Did you account for s = "" or arr = []? Don't blindly slice s[0].
2. Endings: Does your output natively inject \n linebreaks incorrectly? Use print(ans, end="") to suppress implicit newlines.
3. Format Alignment: If an expected integer needs padding: f"{num:02d}" automatically pads 5 into 05.
4. String Immutability Pitfall: You cannot do string[0] = 'a'. You must build a new string: new_string = 'a' + string[1:].

Part 8: Advanced Minute Details & "Gotchas"

1. Equality (==) vs. Identity (is)

• ==: Compares Values. If they look consistent, it returns True.
• is: Compares Memory Locations (id()).
• Tact Detail: 2 == 2.0 is True, but 2 is 2.0 is False (one is an int object, one is a float object).

2. Search Methods: find() vs index()

• string.find("x"): Returns -1 if "x" is not found. (Best for safe if checks).
• string.index("x"): Raises a ValueError (crashes code) if "x" is not found.

3. Shallow Copy Trap (* with Lists)

python
Run Inline
matrix = [0](/viewer?path=0) * 3  # Looks like [0], [0], [0](/viewer?path=0], [0], [0)
matrix[0][0] = 1    # BEWARE: This changes ALL sublists!
# Result: [1], [1], [1](/viewer?path=1], [1], [1)

4. The Mutable Default Argument Bug

python
Run Inline
def add_item(val, items=[]):
    items.append(val)
    return items

print(add_item(1)) # [1]
print(add_item(2)) # [1, 2] !!! (The list persists across calls)

5. String Methods Invariants

• s.split(): If no delimiter is given, it splits by any whitespace (space, tab, newline) and discards empty strings.
• s.strip(): Only removes whitespace from the ends of the string. It does nothing to spaces in the middle.

6. Mapping & Collection Invariants

• Dictionary Keys: Must be Hashable (Immutable). You can use a tuple as a key, but never a list.
• Set Membership: Checking if x in my_set is lightning fast ($O(1)$) compared to a list ($O(N)$). If you are doing thousands of lookups, convert your list to a set first!

Part 9: Canonical OPPE Question Patterns

1. The Frequency Tally (The #1 Most Common Pattern)

python
Run Inline
items = ["A", "B", "A", "C", "B", "A"]
tally = {}
for item in items:
    tally[item] = tally.get(item, 0) + 1 # Shortest way to handle initialization
# Find max frequency
most_common = max(tally, key=tally.get) 

2. Matrix Row/Column Sums

python
Run Inline
matrix = [1, 2, 3], [4, 5, 6](/viewer?path=1, 2, 3], [4, 5, 6)
# Row Sums
row_sums = [sum(row) for row in matrix]
# Column Sums
col_sums = []
for c in range(len(matrix[0])):
    current_sum = 0
    for r in range(len(matrix)):
        current_sum += matrix[r][c]
    col_sums.append(current_sum)

3. The Running Accumulator (Min/Max/Avg)

python
Run Inline
n = int(input())
res = None
for _ in range(n):
    val = int(input())
    if res is None or val > res: # Pattern for first-item assignment
        res = val
print(res)

4. The "Substring Sieve" (String Parsing)

python
Run Inline
data = "ID:001|Name:Alice"
parts = data.split("|") # ['ID:001', 'Name:Alice']
for p in parts:
    key, val = p.split(":") # Split every pair again
    print(f"{key} is {val}")

5. Nested Loops: Coordinate Filter

python
Run Inline
n = 5
for i in range(1, n + 1):
    # Print a right-angled triangle
    print("*" * i) 

6. Parity Filter (List Comprehension)

python
Run Inline
raw = [1, 5, 8, 12, 13]

Part 10: The Mental Blueprint Mapping

Part 14: Deep Dictionary & Collection Patterns

1. Dictionary Grouping (Parity/Categorization)

python
Run Inline
# Grouping numbers by parity
nums = [1, 2, 3, 4, 5, 6]
groups = {"even": [], "odd": []}

for x in nums:
    if x % 2 == 0:
        groups["even"].append(x)
    else:
        groups["odd"].append(x)

# Result: {"even": [2, 4, 6], "odd": [1, 3, 5]}

2. Dictionary Inversion (Keys ↔ Values)

python
Run Inline
d = {"apple": "fruit", "carrot": "vegetable"}
inverted = {}

for key, val in d.items():
    inverted[val] = key  # WARNING: Only works if values are unique!

# Result: {"fruit": "apple", "vegetable": "carrot"}

3. Collection Speed Patterns (Sets)

python
Run Inline
# Remove duplicates while preserving order
lst = [1, 2, 2, 3, 1, 4]
seen = set()
unique_lst = []

for x in lst:
    if x not in seen:
        unique_lst.append(x)
        seen.add(x)

Part 15: The OPPE Readiness Kit

1. The "Second Largest" Algorithm (The Trap)

python
Run Inline
lst = [10, 20, 20, 15, 5]
mx = max(lst)
second_mx = None

for x in lst:
    if x != mx:  # Skip the absolute highest
        if second_mx is None or x > second_mx:
            second_mx = x
# Result: 15 (correctly skips the second 20)

2. The 1-Day Crash Revision Plan

1. Hour 1-2: Review basic arithmetic, Banker's rounding, and floor division.
2. Hour 3-4: Practice String/List slicing and the [start:stop:step] formula.
3. Hour 5-6: Master Dictionary Frequency Counters and .get(x, 0) + 1.
4. Hour 7-8: Solve 5 mock questions from scratch without autocomplete.

3. Mock OPPE Drill Questions (with Solutions)

Q1: Frequency Mapping

python
Run Inline
def char_frequency(s):
    freq = {}
    for char in s:
        freq[char] = freq.get(char, 0) + 1
    return freq

Q2: Palindrome Filter

python
Run Inline
def get_palindromes(words):
    # s[::-1] is the most efficient way to reverse
    return [w for w in words if w == w[::-1]]

Q3: Substring Parsing (The "Value Split")

python
Run Inline
def parse_data(s):
    res = {}
    parts = s.split("|") # Split into ['temp:32', 'humidity:80', ...]
    for p in parts:
        key, val = p.split(":") # Split every pair again
        res[key] = val
    return res

Q4: Nested List Flattening

python
Run Inline
def flatten(matrix):
    res = []
    for row in matrix:
        for item in row:
            res.append(item)
    return res

Part 16: Final Tacit "Gotcha" Cheat Sheet

Part 11: The "What to Write" Manual (Logic & Breakdown)

1. The ILO Framework

2. The def Contract

• The Input (numbers): You trust this variable already exists. Don't redefine it inside!
• The Body: Use the parameter numbers as if it's a real list holding data.
• The End: If the instructions say "Return", you must use return result. Printing it won't pass.

3. Using the Underscore _

• Don't write: for i in range(10): (unless you need i)
• Do write: for _ in range(10):
• Why? The _ tells Python (and you) "I just need the loop to run, I don't need the counter variable." This reduces mental clutter.

Part 12: Slicing, Dots, and Method Etiquette

1. The "Dot" (.) — Accessing Power

• **"hello".upper()**: You are telling the String object "Hey, use your upper power on yourself."
• **my_list.append(5)**: You are telling the List object "Hey, use your append power to add 5."

• String Methods (e.g., .replace(), .upper()) RETURN a new string. They never change the original.
• List Methods (e.g., .append(), .sort(), .reverse()) CHANGE the original list directly (in-place) and return None.

2. Slicing Mastery [start:stop:step]

• s[2:5] -> From index 2 up to (but not including) 5.
• s[:3] -> From the very beginning up to 3.
• s[4:] -> From 4 all the way to the end.
• s[::-1] -> Step is negative, so start from the end and walk backward (Reverse).

3. "The Dots" vs "The Built-ins"

• Methods (obj.method()): Specific to a type. [1,2].append(3) works, "abc".append("d") crashes!
• Functions (func(obj)): Universal. len() works on strings, lists, dicts, and tuples.

Part 13: Coding Etiquette (Anti-Chaos Rules)

1. Meaningful Variables (Names Matter):

• ❌ a = [1, 2, 3]
• ✅ price_list = [1, 2, 3]
• If you name it price_list, you won't accidentally try to "capitalize" it later.

1. Indentation is Logic:

• In Python, space is not just for style; it defines where a block starts and ends.
• Always check your alignment. If a print is under an if, it only runs if the if is True. If it's outside the if, it runs regardless.

1. Mental Housekeeping:

• If a problem asks for 3 things (Sum, Max, Min), solve them one by one.
• Step 1: Get the sum working.
• Step 2: Get the max working.
• Step 3: Get the min working.
• Step 4: Combine.

1. The "Check" Habit:

• Always run your code locally or in the simulator before submitting.
• If Case 1 passes but Case 2 fails, look for Edge Cases (Empty inputs? Negative numbers? Large strings?).