🧠 IIT Madras Notes

CT W1 to W4 Triage

14 min read

Ultimate CT Problem-Solver’s Arsenal (Weeks 1-4)

This guide decodes the logic of Computational Thinking. It’s built from a complete analysis of your assignments and focuses on recognizing patterns, understanding the underlying abstractions, and executing a clear, step-by-step procedure for any problem you encounter.

TL;DR Concepts: The Language of Procedures

  • Core Idea: CT is about writing unambiguous recipes (procedures/algorithms) that a simple-minded “processor” (you) can follow to solve a problem using a stack of cards (the data).
  • The Trinity of Control Flow:
    1. Sequence: Do this, then do this, then do this.
    2. Selection (If/Then): If a condition is met, do this. Otherwise, do that or do nothing.
    3. Iteration (Loop): Repeat a block of steps until a condition is met (e.g., the pile is empty).
  • Key Variables:
    • Counter: A variable that you increment by 1. Used for counting things.
    • Accumulator: A variable that you add a value to. Used for summing things.
    • Holder (Min/Max): A variable that “holds” the best value seen so far.
    • Flag (Boolean): A True/False variable that acts as a memory switch.

Identified Patterns & Solved Examples

Pattern 1: The Aggregator (Counting, Summing, Averaging)

  • Category: Week 1 | Frequency: High | Difficulty: Easy
  • Abstraction: This is the most basic loop. It processes each card independently to calculate a total statistic for a filtered subset of the data.
  • How to Spot It: Look for Initialize to 0, If [condition] then increment/add, and often a final calculation after the loop.

Example Problem (from Week 1 Assignment):

What will X represent at the end of this procedure on the “Shopping Bills” dataset?

Step 1: Arrange all cards in Pile 1
Step 2: Initialize variables A, B and X to 0
Step 3: If Pile 1 is empty then go to Step 7
Step 4: Read the top card
Step 5: If Shop Name is “SV Stores” then add total bill amount to A and increment B
Step 6: Move card to Pile 2 and repeat from Step 3
Step 7: X = A / B
Click for Solution 1. **Analyze the Roles of `A` and `B`:** * `A` is an **accumulator**. It starts at 0 and sums the `total bill amount` *only* for cards where the shop is "SV Stores". So, `A` = Total money spent at SV Stores. * `B` is a **counter**. It starts at 0 and increments by 1 *only* for cards from "SV Stores". So, `B` = Number of bills from SV Stores. 2. **Analyze the Final Step:** * `X = A / B` is `(Sum of values) / (Count of values)`. 3. **Conclusion:** This is the definition of an average.

Final Answer: X represents the Average of total bill amount from “SV Stores”.

Pattern 2: The Best-in-Show Finder (Minimum/Maximum)

  • Category: Week 2 | Frequency: High | Difficulty: Easy-Medium
  • Abstraction: The “King of the Hill” algorithm. A “champion” variable holds the best value seen so far. Each new card is a “challenger”. If the challenger is better, it becomes the new champion.
  • How to Spot It: Look for a variable initialized to an extreme value (0 for max, a very large number for min) and an If statement that compares a card’s value to this variable.

Example Problem (from Week 2 Assignment):

What do A and B represent at the end of this procedure on the “Scores” dataset (scores 0-100)?

Step 2: Initialize A to 101 and B to 0
...
Step 5: If A > X.Chemistry, then set A = X.Chemistry
Step 6: If B < X.Mathematics, then set B = X.Mathematics
Click for Solution 1. **Analyze `A` (The Limbo Dance):** * `A` is initialized to **101** (higher than any possible score). * The condition `A > X.Chemistry` means `A` is only updated if a new score is **smaller** than the current `A`. * This is the algorithm for finding the **minimum**. `A` will hold the lowest Chemistry score. 2. **Analyze `B` (King of the Hill):** * `B` is initialized to **0** (lower than or equal to any possible score). * The condition `B < X.Mathematics` means `B` is only updated if a new score is **larger** than the current `B`. * This is the algorithm for finding the **maximum**. `B` will hold the highest Mathematics score.

Final Answer: A = Lowest marks in Chemistry, B = Highest marks in Mathematics.

Pattern 3: The Group Processor (Re-initialization in a Loop)

  • Category: Week 2 | Frequency: Low | Difficulty: Hard
  • Abstraction: This pattern processes data in “groups” (like sentences in a text, or items in a shopping trip). The key is a variable that accumulates data for a group, and a Re-initialize step that resets the accumulator when a group boundary is detected (like a full stop or a new bill ID).
  • How to Spot It: Look for an Initialize or Re-initialize command inside the main loop, usually triggered by an If statement.

Example Problem (from Week 2 Assignment):

What does A represent at the end of this procedure on the “Words” dataset?

Step 2: Initialize A to 1000 and B to 0
... [Loop starts] ...
Step 5: Add Letter Count to B
Step 7: If Word ends with a full stop AND B < A then store B in A
Step 8: Re-initialize B to 0
... [Loop continues] ...
Click for Solution 1. **Identify Variable Roles:** * `B` is an **accumulator** (`Add Letter Count to B`). * `A` is a **minimum-holder** (`Initialize to 1000`, `If B < A then store B in A`). 2. **Identify the Grouping Logic:** * **Step 8 `Re-initialize B to 0`** is the crucial clue. It resets the accumulator `B`. * This reset is triggered by a "full stop". This means the procedure is treating each **sentence** as a group. 3. **Combine the Logic:** * For each sentence, the procedure sums the letters of its words into `B`. * At the end of the sentence, it checks if this sentence's total length (`B`) is the shortest one seen so far by comparing it to `A`. * It then resets `B` to start fresh for the next sentence.

Final Answer: A represents the length of the shortest sentence based on the number of letters.

Pattern 4: The Inspector (Boolean Flag Logic)

  • Category: Week 3 | Frequency: High | Difficulty: Medium
  • Abstraction: A Boolean (True/False) variable acts as a memory. It answers a question about the entire dataset.
    • “For All” Check: Assume it’s True, and look for one counterexample to make it False.
    • “At Least One” Check: Assume it’s False, and look for one example to make it True.
  • How to Spot It: Look for a variable initialized to True or False.

Example Problem (from Week 3 Assignment):

If E is True at the end, what does this procedure prove?

Initialize E to True
While Pile 1 is not empty:
    Read card X
    If X.Gender is "F" then
        If X.Physics < 60 OR X.Chemistry < 60 OR X.Maths < 60 then
            Set E to False
Click for Solution 1. **Analyze the Flag's Setup:** `E` starts as `True`. This is an optimistic "innocent until proven guilty" approach. It's a "For All" check. 2. **Analyze the "Crime":** The flag is set to `False` (the "crime" is found) if a female student has a score `< 60` in *at least one* subject. 3. **Conclusion:** For `E` to remain `True`, the "crime" must never be found. This means no female student ever has a score less than 60 in any subject. 4. **State the Positive:** The opposite of "at least one score is < 60" is "all scores are >= 60".

Final Answer: It proves that all female students have scores greater than or equal to 60 in all three subjects.

Pattern 5: The Delegator (Using Procedures)

  • Category: Week 3 | Frequency: High | Difficulty: Medium-Hard
  • Abstraction: The main procedure “delegates” a repetitive task to a specialized sub-procedure. The key is to trace the main flow, and when you see a procedure call, treat it like a black box: you give it an input, and you get a specific output.
  • How to Spot It: You will see a Procedure [Name](...) definition and then a call to that [Name] in the main algorithm.

Example Problem (from Week 3 Assignment):

A procedure avg(P) returns the average total marks of cards in pile P. What does A count?

Vellore_Avg = avg(Vellore_Pile)
Chennai_Avg = avg(Chennai_Pile)
Initialize A to 0
While Madurai_Pile is not empty:
    Read card X
    If X.Total > Vellore_Avg AND X.Total < Chennai_Avg then
        Increment A
Click for Solution 1. **Deconstruct the Procedure Calls:** * `Vellore_Avg = avg(Vellore_Pile)`: This line runs the `avg` procedure on all Vellore cards and stores the resulting number in the `Vellore_Avg` variable. * `Chennai_Avg = avg(Chennai_Pile)`: This does the same for Chennai cards. 2. **Analyze the Main Loop:** The procedure now iterates through *only* the `Madurai_Pile`. 3. **Analyze the Condition:** For each Madurai student (`X`), it checks if their `Total` score is numerically between the two averages calculated in the first steps. 4. **Conclusion:** `A` is counting the number of Madurai students whose total score is higher than the Vellore average but lower than the Chennai average.

Final Answer: The number of students from Madurai with a total score between the Vellore average and the Chennai average.

Pattern 6: The Social Networker (All-Pairs Nested Loop)

  • Category: Week 4 | Frequency: High | Difficulty: Hard
  • Abstraction: This pattern finds properties of pairs of items. It compares every item against every other item.
  • How to Spot It: The classic three-pile structure: An outer loop reads a card X from Pile 1. An inner loop reads every card Y from Pile 2 (the pile of already-processed cards) to compare with X.

Example Problem (from Week 4 Assignment):

What does E count in this nested loop procedure on the “Olympics” dataset?

// [Standard 3-pile nested loop setup]
// Inside the inner loop, the core logic is:
If X.Country is equal to Y.Country AND X.Medal is not equal to Y.Medal then
    Increment E
Click for Solution 1. **Recognize the Structure:** This is an **All-Pairs Comparison**. The procedure is systematically generating every possible pair of players (`X`, `Y`). 2. **Analyze the `If` Condition:** The counter `E` is only incremented if a pair is a "match". A match requires two things to be true: * `X.Country is equal to Y.Country`: The players are from the **same country**. * `X.Medal is not equal to Y.Medal`: They won **different types of medals**. 3. **Synthesize the Meaning:** The procedure is counting every pair of teammates who won different medals (e.g., a (Gold, Silver) pair from the same country).

Final Answer: E represents the number of pairs of players from the same country with different medals.

You’ve got it. This is the final and most crucial step: turning knowledge into a strategic weapon. Here is your Ultimate Computational Thinking Arsenal, focusing on the core concepts and a practical guide for assessing and applying them.

The Strategist’s CT Arsenal: Concepts, Patterns, and Application Guide (Weeks 1-4)

This guide distills Computational Thinking into its core concepts and provides a strategic framework for problem-solving. It’s designed to help you instantly recognize a problem’s type and deploy the right mental algorithm.

Part 1: The Arsenal (Core Concepts & Abstractions)

Think of these not as formulas, but as blueprints for procedures.

The Three Fundamental Blueprints

Blueprint NameCore Abstraction & PurposeMinimal Pseudocode Structure
1. The Aggregator”Filter & Accumulate.” Go through a pile once, find the cards that match a condition, and count them or sum one of their attributes.Initialize Sum=0, Count=0
Loop:
  Read X
  If X matches filter:
    Sum = Sum + X.Value
    Count = Count + 1
2. The Best-in-Show Finder”King of the Hill.” Go through a pile once, keeping track of the “best” card seen so far and updating it whenever a better one is found.Initialize BestValue = [extreme]
Loop:
  Read X
  If X.Value is better than BestValue:
    BestValue = X.Value
3. The Social Networker”All-Pairs Comparison.” Compare every card with every other card to find pairs that share a property. This requires a nested loop.Loop (Outer):
  Read X from Pile1
  Loop (Inner):
    Read Y from Pile2
    If X and Y make a valid pair:
      Count++
  Move X to Pile2

Advanced Concept Modifiers

These are not standalone blueprints but are modifications or additions to the fundamental three.

Concept NameCore Abstraction & PurposeHow to Spot It & What It Means
The Group Processor”Process in Batches.” An Aggregator or Best-in-Show that works on sub-groups of data (e.g., sentences, bills).Look for a Re-initialize step inside the loop. This marks the end of one group and the start of the next.
The Inspector (Boolean Flag)“Memory Switch.” A True/False variable that remembers if an event has occurred across the entire dataset.Look for a variable initialized to True or False. Used to answer “For all items…” or “For at least one item…”
The Delegator (Procedure)“Specialized Helper.” A named, reusable block of code that performs one specific task (like calculating an average).Look for Procedure [Name](...) and then calls to that [Name] in the main logic.

Part 2: The Strategist’s Guide (How to Assess and Apply)

This is the TAA (Triage, Abstract, Act) framework for Computational Thinking.

The Nifty Keyword-to-Blueprint Assessor

Scan any problem for these keywords and structures. They are your triggers to instantly select the right mental blueprint.

IF THE QUESTION ASKS FOR…OR THE PSEUDOCODE CONTAINS…THEN THE BLUEPRINT IS…AND YOUR IMMEDIATE ACTION PLAN IS…
”What is the average/total/count of items that are…”Initialize to 0, Increment, Add to...The AggregatorFind the If statement to understand the filter. Find the update step to see if it’s counting (+1) or summing (+ value).
”What is the highest/lowest/shortest/longest…”Initialize to 0 (for max) or a large number (for min). If X.Value > BestValue...The Best-in-Show FinderCheck the Initialize value and the > or < in the If statement to confirm if it’s finding a minimum or a maximum.
”How many pairs of items…”, “Find items that are duplicates”Three piles, a Loop within a Loop (While Pile 2...)The Social Networker (Nested Loop)Go straight to the If statement inside the inner loop. This is the core logic that defines what makes a valid pair. Translate it to English.
The final result is True or False.Initialize Flag = True/False, Set Flag = ...The Inspector (Boolean Flag)Init True? It’s a “For All” check. Find the condition that proves it false.
Init False? It’s an “At Least One” check. Find the condition that proves it true.
”…the shortest sentence…”, “…total for each customer…”Re-initialize Variable = 0 inside the main loop.The Group ProcessorFind the If statement that triggers the reset. That If condition defines the boundary of each group (e.g., a full stop, a change in customer name).
A bug, an error, or a wrong answer.repeat from Step 2 (initialization), wrong condition.Bug Hunt1. Check the loop: Does it repeat from the right place? (Should be the termination check). 2. Check initialization: Is the min/max setup correct? 3. Check logic: Does the If condition match the problem’s goal?

The “Memory Palace” Nifty Tricks

  • The Three Blueprints Analogy (A Party):

    1. The Aggregator: You are the host standing at the door (single loop). You have a clicker to count how many guests are wearing hats. You just look at each person once.
    2. The Best-in-Show Finder: You are a judge looking for the tallest person. You have a measuring tape. The first person is the “tallest so far”. You compare everyone else to them, updating your champion if you find someone taller.
    3. The Social Networker: You want to find out how many pairs of people know each other. You have to ask every person about every other person in the room (nested loop). This is a much longer process!

  • The Flag Detective:

    • “For All” Check (Init True): You are a detective trying to prove a defendant is innocent (True). You assume they are innocent. You only change your mind if you find a single piece of evidence that proves them guilty (Set Flag = False).
    • “At Least One” Check (Init False): You are a detective trying to prove a suspect is guilty (False). You assume they are not guilty. You only change your mind if you find a single piece of incriminating evidence (Set Flag = True).

  • The Re-initialization “New Bag” Trick:

    • Whenever you see Re-initialize X = 0 inside a loop, shout “NEW BAG!” in your head. The procedure was filling up a bag (a sentence, a customer’s order), and now it’s finished with that one and is starting a new, empty one. This instantly tells you you’re working with groups.

By using this arsenal, you can triage any CT problem within seconds, select the correct mental model, and follow a clear, logical path to the solution.

Graph View

Recent Features

    Backlinks