🧠 IIT Madras Notes

CT TLDR

8 min read

You got it. We will now build the complete, detailed TAA Framework for Computational Thinking. This Master Guide synthesizes every unique pattern from your assignment files into a strategic, problem-solving arsenal, with a focus on making the abstract logic of procedures explicit and understandable.

The Ultimate Strategist’s Arsenal: Computational Thinking (Weeks 1-4) - The Complete Edition

This guide covers every identified question pattern from your assignments for Computational Thinking. Each pattern is broken down with the TAA Framework (Triage, Abstract, Act) to make the logic explicit and easy to follow.

Week 1: Procedural Thinking & Basic Operations

  • Core Idea: Learning to think in simple, repeatable steps. The focus is on basic data processing: filtering cards, counting them, and summing their values.

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

  • Triage: “Does the procedure initialize a variable to 0, loop through cards, and then add to that variable if a condition is met?”

  • Abstract: This is the most fundamental algorithm. It filters the data with an If statement and aggregates it with a counter (+1) or an accumulator (+ value). An average is just the result of two aggregators (a sum and a count).

  • Act (Execution):

    Problem: A sums the bill amounts for “SV Stores”, B counts the bills for “SV Stores”. The last step is X = A / B. What is X?

    1. Analyze A: It’s an accumulator for total bill amount, filtered by Shop Name == "SV Stores".
    2. Analyze B: It’s a counter, filtered by the same condition.
    3. Analyze Final Step: The formula is Sum / Count. Final Answer: The average bill amount for “SV Stores”.

Pattern 1.2: Bug Hunting - The Loop Reset

  • Triage: “Does the procedure give the wrong answer? Is a variable not accumulating correctly?”

  • Abstract: The most common bug is an incorrect loop instruction. A loop must repeat from the termination check (e.g., If Pile 1 is empty...), NOT from the initialization step.

  • Act (Execution):

    Problem: The procedure is supposed to count all cards, but the repeat instruction points to the initialization step. Why is it wrong? Step 2: Initialize count to 0 ... Step 6: ... repeat from Step 2

    1. Trace the Logic: After processing the first card, count becomes 1.
    2. Follow the Loop: The procedure jumps back to Step 2.
    3. Identify the Bug: Step 2 resets count back to 0. All previous work is erased. Final Answer: The bug is in Step 6; it creates a reset that prevents the counter from ever exceeding 1.

Week 2: Advanced Logic & Finding Extrema

  • Core Idea: Moving beyond simple counting to finding the “best” item in a list (min/max) and handling more complex, multi-part conditions.

Pattern 2.1: The Best-in-Show Finder (Min/Max)

  • Triage: “Does the pseudocode have a variable that is only updated if a new card’s value is greater than or less than its current value?”

  • Abstract: This is the “King of the Hill” algorithm. The initialization value is the key:

    • To find a MAX: Initialize your “champion” to a very small number (like 0).
    • To find a MIN: Initialize your “champion” to a very large number (like 101 for scores of 0-100).

  • Act (Execution):

    Problem: Initialize A to 101. Inside loop: If A > X.Chemistry, then set A = X.Chemistry. What is A?

    1. Analyze Initialization: A starts high.
    2. Analyze Condition: A only changes if a new score is smaller. Final Answer: A finds the minimum score in Chemistry.

Pattern 2.2: The Group Processor (Re-initialization)

  • Triage: “Do I see an Initialize or Re-initialize command inside the main loop?”

  • Abstract: This is the “New Bag” trick. The procedure is processing items in batches (sentences, bills). The re-initialize step marks the end of one batch and the start of a new, empty one.

  • Act (Execution):

    Problem: What does A represent? Initialize A=1000, B=0. Loop: Add Letter Count to B. If Word ends with ".", then check if B < A and then Re-initialize B=0.

    1. Identify Roles: B is an accumulator (current sentence length). A is a minimum-holder.
    2. Identify Group Boundary: The Re-initialize is triggered by a ”.“. This means sentences are the groups.
    3. Conclusion: The procedure calculates the length of each sentence and uses A to keep track of the shortest length found so far. Final Answer: A is the length of the shortest sentence.

Week 3: Procedures & Boolean Flags

  • Core Idea: Organizing logic into reusable “helper” procedures and using True/False flags to track dataset-wide conditions.

Pattern 3.1: The Inspector (Boolean Flag Logic)

  • Triage: “Does the procedure use a variable that is only ever True or False?”

  • Abstract: This variable is a “flag” that answers a big question.

    • “For All” Check: Initialize flag = True. The code then hunts for a single counterexample to flip it to False.
    • “At Least One” Check: Initialize flag = False. The code then hunts for a single example to flip it to True.

  • Act (Execution):

    Problem: Initialize E = True. Inside a loop over female students: If score < 60 then Set E = False. If E is still True at the end, what does it mean?

    1. Analyze Setup: It’s a “For All” check. The procedure assumes the statement is true.
    2. Analyze “Failure” Condition: The procedure “fails” (sets E=False) if it finds a female student with a score less than 60.
    3. Conclusion: For E to remain True, the failure condition must never have been met. This means no female student had a score less than 60. Final Answer: All female students scored 60 or more.

Pattern 3.2: The Delegator (Using Procedures)

  • Triage: “Does the pseudocode define a Procedure and then Call it later, possibly with different inputs?”

  • Abstract: The procedure is a specialist. The main algorithm is the general contractor. Trace the main algorithm, and when the specialist is called, simply determine its output and plug that value back into the main logic.

  • Act (Execution):

    Problem: 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 = 0
While Madurai_Pile is not empty:
    Read card X
    If X.Total > Vellore_Avg AND X.Total < Chennai_Avg then
        Increment A
    1. Resolve Procedure Calls: Vellore_Avg becomes a fixed number (e.g., 210). Chennai_Avg becomes a fixed number (e.g., 230).
    2. Analyze the Main Loop: The procedure now iterates through Madurai_Pile.
    3. Translate the Condition: It’s counting Madurai students where X.Total > 210 AND X.Total < 230 (using the example numbers). Final Answer: A counts the number of students from Madurai whose total score is between the Vellore average and the Chennai average.

Week 4: Nested Loops & All-Pairs Comparisons

  • Core Idea: The powerful “all-pairs” pattern is used to compare every item in a dataset with every other item to find pairs, duplicates, or complex relationships.

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

  • Triage: “Do I see the classic three-pile structure? An outer loop over Pile 1 and an inner loop over Pile 2?”

  • Abstract: This structure’s only purpose is to generate every possible pair of items (X, Y) for comparison. Your job is to find the If statement inside the inner loop—that is the core logic.

  • Act (Execution):

    Problem: What does E count in this nested loop on the “Olympics” dataset? // Inside the inner loop: If X.Country == Y.Country AND X.Medal != Y.Medal then Increment E

    1. Recognize Structure: This is an All-Pairs Comparison. It’s looking for special pairs.
    2. Translate the If Condition: A pair (X, Y) is counted if:
      • The two players are from the same country.
      • AND they won different medals. Final Answer: E counts the number of pairs of players from the same country with different medals.

Pattern 4.2: The Word Detective (Nested Logic on a Single Card)

  • Triage: “Does the procedure have a loop inside a loop, but the inner loop iterates over a property of a single card (like the letters of a word)?”

  • Abstract: This is not an all-pairs comparison. This procedure is asking a complex question about each individual card. The inner loop is a “sub-check” for that one card.

  • Act (Execution):

    Problem: What does count represent?

    Initialize count = 0
While Pile 1 is not empty:
    Read card X
    Initialize flag = False
    For i from 1 to (Letter Count - 1):
        If (i-th letter is consonant) AND ((i+1)-th letter is consonant) then
            Set flag = True
    If flag is True then Increment count
    1. Analyze Inner Loop: The For loop checks every adjacent pair of letters in the current word (X.Word). If it finds just one pair of consecutive consonants, it sets flag = True.
    2. Analyze Outer Logic: The main count is only incremented if the flag was successfully flipped to True for that word. Final Answer: count represents the number of words containing at least one pair of consecutive consonants.

Graph View

Recent Features

    Backlinks