GATE CS & DA Preparation Guide Module 2 – A preparation system: plan, official papers and error logs
Error logs and spaced revision for GATE
Log every GATE practice mistake by its cause, group mistakes into problem families, re-attempt them at growing gaps and keep a one-page note per section.
What you will learn
- Classify every mistake by cause, as concept, method, misreading, arithmetic, time or guess
- Rank the causes by the marks and minutes they cost, and choose the first fix
- Group errors into problem families you can re-attempt, and schedule spaced reviews
- Write one-page revision notes that record the method, the trap and a fresh example
Before you start
What you’ll learn · Before you start
What you will learn
- Classify every mistake by cause, as concept, method, misreading, arithmetic, time or guess
- Rank the causes by the marks and minutes they cost, and choose the first fix
- Group errors into problem families you can re-attempt, and schedule spaced reviews
- Write one-page revision notes that record the method, the trap and a fresh example
Before you start
On this page
Twenty mistakes in four timed sets and one mock cost an invented GATE candidate 37.33 marks and 106 minutes, and three kinds of problem went wrong twice. An error log: A list of every mark lost in practice, one row per question, with its problem family, one of six causes and the minutes it took, summed each week to choose what to fix first. is the list that shows this: every mark you lose in practice, why you lost it and when you will meet that kind of problem again.
Give each mistake one of six causes, because each cause has its own fix, and log its problem family: A kind of problem that can be practised again with fresh numbers, such as "B+ tree order from block size". An error log names the family rather than the question number. rather than the question number, so that you can practise the family again with a fresh instance. Re-attempt each family after growing gaps, by default 1, 3, 7 and 21 days, and send it back to the first gap whenever you miss it again. Below, a log you can copy is summed by a program, the review ladder: A schedule of re-attempts at growing gaps, 1, 3, 7 and 21 days by default: a right answer moves a problem family one rung up, and a wrong one sends it back to the first gap. comes with the research behind spacing, and the log becomes one page of notes per section.
Not affiliated
MySmartCoPilot works independently of IISc and the IITs that run GATE. The method in this lesson is a way to study, not part of the exam’s rules.
Each of six causes has its own fix
A mistake’s cause decides its fix, and the wrong fix wastes the hours you have. Rereading a lesson does nothing for a misread unit, and a checklist does nothing for a missing idea:
| Cause | What happened | Fix | Fixed when |
|---|---|---|---|
| Concept gap | You could not have solved it even with unlimited time | Re-learn the idea from its lesson, then solve three fresh problems on it | You can explain the idea and solve a new instance untimed |
| Method gap | You knew the idea but not a reliable procedure, or it took far too long | Drill the family: timed sets of new instances | Two timed instances in a row are right, within the paper’s pace |
| Misreading | You solved a different question from the one asked | A read-twice checklist before you answer | The cause disappears from two mocks in a row |
| Arithmetic | Right method, wrong number | Estimate the answer first; keep full precision until the end | Your NAT answers land near your estimates |
| Time | You ran out of time, or gave up after a long try | A triage rule: move on after 5 minutes and come back at the end | No question takes more than twice its share of minutes |
| Guess | A wrong MCQ guess cost a penalty | Guess only after you have ruled out at least one option | Penalties fall while right answers do not |
The paper’s pace is 1.8 minutes a mark, 180 minutes for 100 marks, so a 2-mark question has a share of about 3.6 minutes and “twice its share” is about 7. A misreading checklist is short enough to write on the first line of every rough sheet: the units (KB or KiB, ms or µs), negations (“which is NOT”), “at least” and “at most”, “is/are” (an MSQ may have only one correct option), and the decimal places a NAT asks for. The arithmetic fix follows the brochure’s own advice for numerical answers: round only at the end of the calculation, never at intermediate steps.
When one mistake has two causes, log the first one whose fix would have saved the marks: a misread unit that led you to a wrong method is a misreading. When you cannot tell a concept gap from a method gap, try the question again untimed, with your notes open. If you solve it, it was method; if you still cannot, it was concept.
Key idea
Give every lost mark the cause whose fix would have saved it: a concept gap is re-learnt, a method gap drilled, a misreading caught by a checklist, an arithmetic slip by an estimate, time by a triage rule and a guess by a rule for guessing.
Checkpoint
Check: Six causes and their fixes
Log families, not question numbers
“Question 37 of mock 2” tells you nothing a week later, and it cannot be practised again: the next time you see that question, you will remember its answer. A problem family names the kind of problem instead: “pumping lemma: is it regular?”, “highest normal form from FDs”, “B+ tree order from block size”. A family can be practised again with a fresh instance, with new numbers, a new language or a new set of dependencies, from the exercises of this track’s lessons, a textbook, or your own changes to the numbers of a problem you have solved.
Each row of the log is one question that lost marks: the study day, where it happened, the section, the family, the cause, the question’s type and marks, whether the answer was wrong or blank, and the minutes it took. Here is the log of an invented candidate after four timed sets and one mock:
day,source,section,family,cause,type,marks,outcome,minutes
3,timed set 1,Computer organisation,cache: tag/index/offset split,misreading,NAT,2,wrong,6
3,timed set 1,Computer organisation,pipeline: stall cycles with forwarding,method,MCQ,2,wrong,9
5,timed set 2,Theory of computation,DFA for remainders,method,MCQ,1,wrong,4
5,timed set 2,Theory of computation,pumping lemma: is it regular?,concept,MSQ,2,wrong,7
8,timed set 3,Databases,highest normal form from FDs,concept,MCQ,2,wrong,8
8,timed set 3,Databases,B+ tree order from block size,arithmetic,NAT,2,wrong,5
10,mock 1,General Aptitude,percentage change,misreading,MCQ,1,wrong,2
10,mock 1,Engineering mathematics,conditional probability,method,NAT,2,wrong,6
10,mock 1,Algorithms,recurrences: divide-and-conquer cases,guess,MCQ,1,wrong,1
10,mock 1,Operating systems,page faults under LRU,time,NAT,2,blank,11
10,mock 1,Computer organisation,cache: tag/index/offset split,misreading,MCQ,2,wrong,4
10,mock 1,Compiler design,LL(1) table conflicts,concept,MSQ,2,wrong,6
10,mock 1,Computer networks,sliding window utilisation,arithmetic,NAT,2,wrong,5
10,mock 1,Digital logic,K-map minimal SOP,method,MCQ,1,wrong,3
10,mock 1,Algorithms,DP: counting paths,time,NAT,2,blank,9
10,mock 1,Programming and DS,C pointer output,misreading,MCQ,1,wrong,2
10,mock 1,General Aptitude,seating arrangement,guess,MCQ,2,wrong,1
12,timed set 4,Computer organisation,pipeline: stall cycles with forwarding,method,NAT,2,wrong,8
12,timed set 4,Databases,highest normal form from FDs,concept,MSQ,1,wrong,5
12,timed set 4,Engineering mathematics,eigenvalues of a 3x3 matrix,arithmetic,NAT,1,wrong,4Read the family column first: “cache: tag/index/offset split”, “pipeline: stall cycles with forwarding” and “highest normal form from FDs” each appear twice, on different days, and each time with the same cause.
Checkpoint
Check: Problem families in the log
Count what each cause costs, in marks and in minutes
The program adds up what each cause cost, in marks lost against a right answer and in minutes, and lists the families that came back. A wrong MCQ loses its marks and its penalty: 2.67 marks for a wrong 2-mark MCQ. A blank, a wrong MSQ or a wrong NAT loses the question’s marks:
"""What the mistakes in error_log.csv cost, by cause and by section, and which problem families keep coming back."""
import csv
from collections import Counter, defaultdict
from fractions import Fraction
FIX = {
"concept": "re-learn it from the lesson, then 3 fresh problems",
"method": "drill the family in timed sets",
"misreading": "a read-twice checklist before answering",
"arithmetic": "estimate first, keep full precision to the end",
"time": "triage: move on after 5 minutes, come back later",
"guess": "guess an MCQ only after ruling out an option",
}
def lost(row):
"""Marks lost against a right answer: the question's marks, plus the penalty for a wrong MCQ."""
marks = Fraction(row["marks"])
if row["type"] == "MCQ" and row["outcome"] == "wrong":
return marks + marks / 3
return marks
with open("error_log.csv", newline="", encoding="utf-8") as f:
log = list(csv.DictReader(f))
total = sum(lost(r) for r in log)
print(f"{len(log)} mistakes cost {float(total):.2f} marks and {sum(int(r['minutes']) for r in log)} minutes")
by_cause = defaultdict(list)
for r in log:
by_cause[r["cause"]].append(r)
print("\nCause mistakes marks minutes fix")
for cause, rows in sorted(by_cause.items(), key=lambda kv: (-sum(lost(r) for r in kv[1]), kv[0])):
marks = sum(lost(r) for r in rows)
minutes = sum(int(r["minutes"]) for r in rows)
print(f"{cause:12} {len(rows):8} {float(marks):7.2f} {minutes:8} {FIX[cause]}")
penalties = sum(Fraction(r["marks"]) / 3 for r in by_cause["guess"])
print(f"The wrong guesses cost {float(penalties):.2f} marks against leaving those questions blank")
by_section = Counter()
for r in log:
by_section[r["section"]] += lost(r)
print("\nSection marks")
for section, marks in sorted(by_section.items(), key=lambda kv: (-kv[1], kv[0])):
print(f"{section:24} {float(marks):7.2f}")
families = defaultdict(list)
for r in log:
families[r["family"]].append(r["cause"])
print("\nFamilies missed more than once:")
for family, causes in families.items():
if len(causes) > 1:
same = f"{causes[0]} each time" if len(set(causes)) == 1 else ", ".join(causes)
print(f" {family}: {len(causes)} times, {same}")Output
20 mistakes cost 37.33 marks and 106 minutes Cause mistakes marks minutes fix method 5 9.33 30 drill the family in timed sets concept 4 7.67 26 re-learn it from the lesson, then 3 fresh problems misreading 4 7.33 14 a read-twice checklist before answering arithmetic 3 5.00 14 estimate first, keep full precision to the end guess 2 4.00 2 guess an MCQ only after ruling out an option time 2 4.00 20 triage: move on after 5 minutes, come back later The wrong guesses cost 1.00 marks against leaving those questions blank Section marks Computer organisation 9.33 Databases 5.67 General Aptitude 4.00 Algorithms 3.33 Theory of computation 3.33 Engineering mathematics 3.00 Compiler design 2.00 Computer networks 2.00 Operating systems 2.00 Digital logic 1.33 Programming and DS 1.33 Families missed more than once: cache: tag/index/offset split: 2 times, misreading each time pipeline: stall cycles with forwarding: 2 times, method each time highest normal form from FDs: 2 times, concept each time
Recorded with Python 3.14.8 on macOS 26 arm64. To run it yourself: mise exec python@3.14.8 -- python3 summarise.py
Runs on this device, in your browser. The first run downloads Python (about 13.5 MB), which is kept for the next runs.
Your run, in this browser
Read it the way the weekly review does:
- Method gaps cost the most, 9.33 marks, and the most minutes, 30: these questions were slow and still wrong. Two of the five came from one family, stall counting in pipelines, which makes it the first drill of the week.
- Misreading cost 7.33 marks in only 14 minutes, and its fix costs nothing but a habit. Start the read-twice checklist in the next session, beside the drill: the largest cause is not always the one to fix alone.
- Two concept gaps came from one family, normal forms from functional dependencies. A second miss on a family you have re-learnt means the first re-learning did not hold, so go back to the lesson, not to more questions.
- The guesses cost 4 marks against right answers, but only 1 mark against leaving those two questions blank. That 1 mark is the true price of the guesses, and the expected-value rule of the marking lesson says when it is worth paying.
- Computer organisation lost the most marks, 9.33 of the 37.33. The study plan should move hours there in its next weekly review.
Key idea
Count each cause in marks lost against a right answer and in minutes, fix the costliest first, and start the cheap habits, such as the read-twice checklist, at once beside it.
Checkpoint
Check: What each cause costs
Re-attempt each family at growing gaps, shorter near the exam
A re-attempt is a test, and taking a test is itself a way of learning, the testing effect: The finding that taking a test on what you have studied helps you remember it later more than studying it again, even though restudying can leave you feeling more sure.. In two experiments, students either restudied prose passages or took recall tests on them: restudying won on a test given five minutes later, but the tested group recalled far more when the final test came two days or a week later, even though restudying had left students more sure of their memory (Roediger and Karpicke). A review of ten study techniques reached the same conclusion from a wider set of studies, rating practice testing and spreading study over time as the most useful and rereading among the least (Dunlosky and colleagues).
Spacing the re-attempts matters too. A meta-analysis of 317 experiments on spaced study found that the gap between sessions which gives the best final recall grows as the retention interval grows (Cepeda and colleagues). A later study taught more than 1,350 people a set of facts, reviewed them after a gap of up to three and a half months and tested them up to a year later. The best gap grew with the delay before the test, but as a share of that delay it fell: from about 20 to 40 % of a one-week delay to about 5 to 10 % of a one-year delay (Cepeda and colleagues).
Neither study used GATE problem families, and neither gives a schedule to copy. MySmartCoPilot’s default ladder of 1, 3, 7 and 21 days is a starting point you can change. A right answer moves a family one rung up and a wrong answer sends it back to the 1-day gap; a family that is right after the 21-day gap leaves the ladder and joins the mixed timed sets, where it still turns up now and then.
The review ladder for one problem family
Text description of the diagram
The diagram is a column of boxes joined by arrows, from top to bottom:
- A family is missed.
- Review 1 day later. The box adds that a wrong answer at any review brings the family back here.
- Review 3 days later.
- Review 7 days later.
- Review 21 days later.
- Into the mixed timed sets.
Each arrow from one review to the next is labelled "right": a right answer moves the family one rung up, and a right answer after the 21-day gap moves it into the mixed timed sets.
The diagram is the ladder as a whole. Step through one family’s climb, with one miss on the way, and watch the reset:
The drawing shows the whole scene; its 7 steps are listed below.
Every step as text
- The miss. On day 5 the family "DFA for remainders" costs a mark in a timed set. It joins the ladder, and its first re-attempt, a fresh instance with new numbers, is due one day later.
- Day 6, right. One day later the re-attempt is right. A right answer moves the family one rung up, so the next re-attempt comes 3 days later.
- Day 9, right. Right again on day 9, so the family climbs to the 7-day rung.
- Day 16, wrong. Wrong on day 16. A miss at any rung sends the family back to the first gap, so the next re-attempt is one day later, on day 17, and the climb starts again.
- Days 17 and 20. Right on day 17 and again on day 20, three days later. The gaps keep their order after a reset, 1, 3 and then 7 days.
- Day 27, right. Right at the 7-day rung this time, on day 27, so the longest gap, 21 days, comes next.
- Day 48, off the ladder. Right on day 48, after 21 days. The family leaves the ladder and joins the mixed timed sets, where it still turns up now and then. With the exam on day 126, that last gap was 27 % of the 78 days still left.
The program below plans the ladder for families first missed on three days of an 18-week plan, and compares each last gap with the days left before the exam:
"""Review days for a problem family on a ladder of growing gaps, counted in days from today."""
GAPS = (1, 3, 7, 21) # MySmartCoPilot's default ladder, in days: a starting point to change, not a research result
LAST_MONTH = (1, 2, 3) # shorter gaps for a family first missed in the last month
EXAM_DAY = 126 # the first exam day, 18 weeks from today
def ladder(first_miss, gaps, exam_day=EXAM_DAY):
"""The review days of a family that is right at every review, and what happens after the last rung."""
days, day = [], first_miss
for gap in gaps:
if day + gap >= exam_day:
return days, f"the next gap, {gap} days, would reach the exam"
day += gap
days.append(day)
return days, "then it joins the mixed timed sets"
def show(first_miss, gaps):
days, after = ladder(first_miss, gaps)
left = EXAM_DAY - days[-1]
last_gap = days[-1] - (days[-2] if len(days) > 1 else first_miss)
print(f"Missed on day {first_miss}: reviews on days {', '.join(map(str, days))}; {after}")
print(f" the last gap, {last_gap} days, is {100 * last_gap / left:.0f} % of the {left} days from that review to the exam")
print(f"Gaps {', '.join(map(str, GAPS))} days; the exam is on day {EXAM_DAY}")
for first_miss in (3, 60, 110):
show(first_miss, GAPS)
print(f"\nIn the last month, gaps of {', '.join(map(str, LAST_MONTH))} days")
show(110, LAST_MONTH)Output
Gaps 1, 3, 7, 21 days; the exam is on day 126 Missed on day 3: reviews on days 4, 7, 14, 35; then it joins the mixed timed sets the last gap, 21 days, is 23 % of the 91 days from that review to the exam Missed on day 60: reviews on days 61, 64, 71, 92; then it joins the mixed timed sets the last gap, 21 days, is 62 % of the 34 days from that review to the exam Missed on day 110: reviews on days 111, 114, 121; the next gap, 21 days, would reach the exam the last gap, 7 days, is 140 % of the 5 days from that review to the exam In the last month, gaps of 1, 2, 3 days Missed on day 110: reviews on days 111, 113, 116; then it joins the mixed timed sets the last gap, 3 days, is 30 % of the 10 days from that review to the exam
Recorded with Python 3.14.8 on macOS 26 arm64. To run it yourself: mise exec python@3.14.8 -- python3 schedule.py
Runs on this device, in your browser. The first run downloads Python (about 13.5 MB), which is kept for the next runs.
Your run, in this browser
For a family missed in the first week, the last rung comes on day 35, and its 21-day gap is 23 % of the 91 days still left. For a family missed on day 60, the same gap is 62 % of the 34 days that remain, a larger share than the study found best even for a one-week delay, and for a family missed on day 110 the ladder cannot even finish. In the last month, use shorter gaps such as 1, 2 and 3 days: for the family missed on day 110 they keep the last gap at 30 % of the time left. Keeping the last gap under about 40 % of the days that remain is MySmartCoPilot’s reading of the study, not a figure it measured.
Flashcard Maker Turn the definitions and traps of your log into cards that come back at growing gaps.Key idea
Re-attempt each family at growing gaps, 1, 3, 7 and 21 days by default, send it back to the first gap after any miss, and shorten the gaps in the last month so that the last one stays well inside the days left.
Checkpoint
Check: Re-attempts at growing gaps
One page per section, written from your own mistakes
Notes help in the last month only if they are short and come from your own mistakes, so keep one page per section and rewrite it every week from the log. A page has four parts:
- Definitions you keep forgetting, in your own words.
- Method sheets: the steps of each family’s method, as a numbered list.
- The traps you actually fell into, each with its cause and how often.
- One fresh worked example, with numbers you chose yourself, never a past paper’s question.
Here is a page for computer organisation, written from the log above; its two traps are the two families that came back:
CS section 3, Computer organisation: one page, rewritten every week from the error log
Definitions I keep forgetting
- Average memory access time = hit time + miss rate x miss penalty, in one level; nest it for two levels.
- A k-way set-associative cache has (cache size) / (block size x k) sets; direct-mapped is k = 1.
Method sheets
1. Address split for a cache: offset bits = log2(block size in bytes); index bits = log2(number of sets);
tag bits = address bits - index bits - offset bits.
2. Stalls in a 5-stage pipeline: write the stages of each instruction in a table, one row each, then mark the
cycle where each needed value is produced and the cycle where it is used; with forwarding, only a load
followed at once by an instruction that uses the loaded value waits one cycle.
Traps I fell into (from the log)
- Read "64 KB" as 64,000 bytes: the question's cache held 2^16 bytes. Read the units line twice. (misreading, 2 times)
- Counted stalls as if there were no forwarding when the question said there was. Underline "forwarding". (method, 2 times)
A fresh example, with my own numbers
- 32-bit addresses, a 4-way set-associative cache of 64 KiB, 64-byte blocks:
offset = log2(64) = 6 bits; sets = 65,536 / (64 x 4) = 256, so index = 8 bits; tag = 32 - 8 - 6 = 18 bits.In the last weeks, revise from these pages and the families on your ladder, not from whole lessons: a page takes minutes to read, and everything on it is something you have already got wrong once.
Checkpoint
Check: One page of notes per section
Twenty minutes a week turn the log into one change
Once a week, after the week’s timed sets, spend 20 minutes on the log:
- Run the summary and pick the cause that cost the most marks. Write down one concrete change for next week: a checklist line, a drill of one family, a triage time.
- Look at the families missed more than once. Put them at the bottom of the ladder, and for a concept gap, back on the list of lessons to re-learn.
- Move hours in the study plan towards the sections that lost the most marks.
- A week later, check the change: did the marks lost to that cause fall? If not, the fix was the wrong one, and the cause may be another.
Step through one such review of the invented log, from the summary to the check a week later:
The drawing shows the whole scene; its 5 steps are listed below.
Every step as text
- The summary. After the week's timed sets, run the summary. In the invented log 20 mistakes cost 37.33 marks and 106 minutes, and method gaps cost the most, 9.33 marks and 30 minutes.
- One change. Write down one concrete change for the costliest cause. Two of the five method gaps were stall counting in pipelines, so the change is a drill of that family, and the read-twice checklist starts beside it, because misreading cost 7.33 marks in only 14 minutes.
- Families missed twice. Three families came back, the cache address split, stall counting and normal forms. They go to the bottom of the ladder, and normal forms, a concept gap both times, also goes back on the list of lessons to re-learn.
- Hours in the plan. Computer organisation lost the most marks, 9.33 of the 37.33, so the study plan moves hours towards it at its next weekly review.
- The check. A week later, check each change by its own number. Did the marks lost to method gaps and to misreading fall? If not, the fix was the wrong one, and the cause may be another.
Key idea
Once a week, turn the costliest cause into one concrete change, send the families missed twice back to the first rung, move plan hours to the sections that lost the most marks, and check the change a week later.
Checkpoint
Check: The weekly review of the log
Practise: a ladder that resets, then the whole lesson
The schedule above assumes every re-attempt goes right. Write the ladder for real reviews, where a wrong answer sends the family back to the first gap and no review is planned on or after the exam; the sample tests run in your browser:
Exercise · Easy · Python
Schedule the reviews of a family that you sometimes miss
The lesson's schedule.py plans a family that you get right at every review. Real reviews go wrong sometimes. Write review_days(first_miss, results, exam_day, gaps=(1, 3, 7, 21)) in ladder.py: it returns the day of every review, in order, counted in days from the same start as first_miss and exam_day.
- The first review is
gaps[0]days afterfirst_miss, on the first rung. results[i]isTruewhen reviewiwent right andFalsewhen it went wrong.- After a right answer the family climbs one rung, and the next review comes that rung's gap later. After a wrong answer it goes back to the first rung, so the next review is
gaps[0]days later. - A right answer on the last rung ends the ladder: no more reviews.
- When the results run out, the last day returned is the next review still to do.
- A review that would fall on or after
exam_dayis never planned, and the ladder stops there.
For example, review_days(0, [True, False, True], 200) is [1, 4, 5, 8]: right on day 1, wrong on day 4, right on day 5 after the reset, and the next review due on day 8. The sample tests import the function from ladder.py and run in your browser.
Starter code · ladder.py
def review_days(first_miss, results, exam_day, gaps=(1, 3, 7, 21)):
"""The days of every review of a problem family, with a reset to the first gap after a wrong answer."""
# Replace this line with your code.
return NoneThe sample tests · test_ladder.py
from ladder import review_days
def test_all_right():
"""right at every review: one review per rung, then the ladder ends"""
assert review_days(0, [True, True, True, True], 200) == [1, 4, 11, 32]
assert review_days(10, [True, True, True, True, True, True], 200) == [11, 14, 21, 42]
def test_reset():
"""a wrong answer sends the family back to the first gap"""
assert review_days(0, [True, False, True], 200) == [1, 4, 5, 8]
assert review_days(5, [True, True, False, False, True], 200) == [6, 9, 16, 17, 18, 21]
def test_next_review():
"""with no results yet, the only day is the first review"""
assert review_days(7, [], 200) == [8]
assert review_days(0, [True], 200) == [1, 4]
def test_exam_day():
"""no review falls on or after the exam day"""
assert review_days(100, [True, True, True], 115) == [101, 104, 111]
assert review_days(100, [True, True, True], 111) == [101, 104]
assert review_days(114, [], 115) == []
def test_own_gaps():
"""the gaps are a parameter"""
assert review_days(0, [True, True], 50, gaps=(2, 5)) == [2, 7]
assert review_days(0, [False, True, True], 50, gaps=(1, 2, 3)) == [1, 2, 4, 7]A hint
Keep two variables, the day of the next review and the rung you are on (start at first_miss + gaps[0] and rung 0). Loop over the results: append the day, then either finish (a right answer on rung len(gaps) - 1), climb a rung or go back to rung 0, and add the new rung's gap to the day. Check the exam day before you append any day.
Results of the sample tests
| Test | Result | Details |
|---|
What your code printed
The sample tests run on this device, in your browser (Pyodide): nothing is sent to mysmartcopilot.com. The first run downloads Python (about 13.5 MB), which is kept for the next runs. A check in your browser is feedback for you, not proof that the code is right for every input.
Then quiz yourself on the six ideas of the lesson. Like the ladder, this self-check returns to your misses: your weakest idea comes first, each right answer earns a harder question, and one you get wrong is asked once more at the end:
Practice that adapts to you
Practise this lesson
18 questions about 6 ideas of this lesson. Each answer is explained at once, and what you get right is kept in this browser.
Interview questions
What is the difference between a concept gap and a method gap in an error log? (warm-up)
A concept gap means you could not have solved the question even with unlimited time, because an idea it rests on is missing or wrong, for example what a pumping-lemma argument has to show. The fix is to re-learn the idea from its lesson and then solve two or three fresh problems on it. A method gap means you knew the idea but had no reliable procedure, so you lost your way or took far too long, for example miscounting stall cycles although you know what a hazard is. The fix is drill: timed sets of new instances of that family until the steps are automatic. Rereading does little for a method gap and drilling does little for a missing idea, so the label matters. If unsure, retry the question untimed with notes: solved means method, still stuck means concept.
Model answers open with any pass: ₹79 for 1 week ($2.99), one payment that never renews.
-
Fresher to mid
Your log from four mocks shows 31 marks lost: 13 to misreading, 9 to concept gaps, 6 to arithmetic and 3 to wrong guesses. Five weeks remain. What do you change first, how will you know it worked, and what do you deliberately leave alone?
-
Fresher to mid
Three weeks before GATE your review queue holds 40 problem families, each due on a different day, and you have about an hour a day for reviews besides mocks. How do you schedule them, and which families do you drop?
Key takeaways
- Log every lost mark with one of six causes, because each cause has its own fix: concept, method, misreading, arithmetic, time or guess.
- Log problem families, not question numbers, so that a family can be practised again with a fresh instance.
- Count marks lost against a right answer (2.67 for a wrong 2-mark MCQ) and minutes, and fix the costliest cause first, starting cheap habits such as a read-twice checklist at once.
- Testing yourself and spacing the tests both help memory; the best gap grows with the time until the test but falls as a share of it.
- Climb a ladder of 1, 3, 7 and 21 days per family, back to the start after every miss, and use shorter gaps in the last month.
- Keep one page per section: definitions, method sheets, your own traps and a fresh example.
Terms in this lesson
- error log
- A list of every mark lost in practice, one row per question, with its problem family, one of six causes and the minutes it took, summed each week to choose what to fix first.
- problem family
- A kind of problem that can be practised again with fresh numbers, such as "B+ tree order from block size". An error log names the family rather than the question number.
- review ladder
- A schedule of re-attempts at growing gaps, 1, 3, 7 and 21 days by default: a right answer moves a problem family one rung up, and a wrong one sends it back to the first gap.
- testing effect
- The finding that taking a test on what you have studied helps you remember it later more than studying it again, even though restudying can leave you feeling more sure.
References
- Distributed practice in verbal recall tasks: a review and quantitative synthesis (Cepeda, Pashler, Vul, Wixted and Rohrer) (Psychological Bulletin (PubMed record))
- Spacing effects in learning: a temporal ridgeline of optimal retention (Cepeda, Vul, Rohrer, Wixted and Pashler) (Psychological Science (PubMed record))
- Test-enhanced learning: taking memory tests improves long-term retention (Roediger and Karpicke) (Psychological Science (PubMed record))
- Improving students' learning with effective learning techniques (Dunlosky, Rawson, Marsh, Nathan and Willingham) (Psychological Science in the Public Interest (PubMed record))
- GATE 2027 Information Brochure (Indian Institute of Technology Madras (GATE 2027))
- collections: Counter and defaultdict (Python Software Foundation)
Related tools
Report a problem with this lesson
Kept only in this browser. Your Learn progress