Online assessment prep
Kalpana sat down for her first online assessment in a cyber cafe in Rajahmundry. Sixty questions, sixty minutes, one screen at a time. She started at question one and worked in order. Question five was a hard probability sum, and she gave it nine minutes. The clock ran out at question twenty-two. Eleven of the questions she never saw were ones she could have solved in forty seconds. Nobody read her resume. The gate was arithmetic, not talent.
- This is the first gate at most large Indian firms, and a machine decides it. Your project work never gets read if this screen closes first.
- The skill it tests is sorting under a clock, not brilliance. That skill can be built in eight hours, which is rare for anything on a resume.
- The arithmetic here is small and it is yours to compute. After today nobody can sell you a cut-off number without showing where it came from.
An online assessment is a timed test, scored by a machine, taken at home or in a lab. For AI-adjacent fresher roles it usually carries four or five parts. Quantitative aptitude, logical reasoning and verbal ability come first. Then a technical part: pseudo-code or real code, and sometimes a short machine learning question set. Many tests also watch you while you take them.
Names to expect in 2026: TCS NQT on the TCS iON platform, HackerRank and HackerEarth links from product and services firms, and AMCAT-style papers such as Naukri Campus in bulk campus drives. Treat that list as weather, not geography. Vendors and formats change every season, and the triage, marking and timing skills in this module transfer to all of them unchanged.
Do one sum before anything else. Divide the total minutes by the total questions. Sixty questions in sixty minutes gives you sixty seconds each. Take off four minutes for instructions, page loads and scrolling, and it drops to fifty-six. That number, not your talent, decides how you must play.
Triage — sorting work by what you can finish fastest, a habit borrowed from hospital emergency rooms — is the whole skill here. You make three passes over the paper. Pass one takes only the questions you are sure of, with a hard cap of about forty-five seconds each. Pass two returns for the ones you can solve with effort, capped at about ninety seconds. Pass three spends what is left on the rest, and it leaves no box blank when the marking rules allow a guess.
Here is the contrast this module exists for. The wrong way is Kalpana's: start at question one, work in order, and let one hard sum eat nine minutes. Eleven easy marks then sit past the point where the clock stopped. The right way touches every question once, cheaply, before it spends real time on any of them. The figure below draws the same ten questions under both plans, to scale.
Negative marking — a rule that removes a fraction of a mark for every wrong answer — turns guessing into arithmetic. Work out the expected value of a guess: the average marks it earns if you made the same kind of guess many times over. With four options and a quarter-mark penalty, a blind guess averages a small gain. With five options and a full-mark penalty, it averages a heavy loss. The second figure computes both and pulls out one rule.
The rule is one line. Guess when the options still live are fewer than one plus one divided by the penalty. Under a quarter-mark penalty that limit is five, so four live options already pay. Under a full-mark penalty the limit is two, so you must be down to one option. Cutting options is what moves you across the line, and cutting takes seconds you have to budget.
The aptitude topics repeat, year after year and firm after firm. Percentages and ratios, time-speed-distance, number series, permutations and probability basics, syllogisms, and data interpretation cover most of what you will meet. Each one has a fast method that beats school algebra under a clock. Learn the fast method once and a topic costs you thirty seconds instead of three minutes. The next section works five of them end to end.
Data interpretation — questions that hand you a table or a chart and ask you to read numbers out of it — is a bridge back to your own pandas work. It is modules 0.5 and 0.6 under a clock, with no code to help you. The traps are the ones you already met there: a count is not a rate, a total is not an average, and the question asks for one of them. Read the column headings and the units first, then cancel zeros before you divide.
The technical part is closer to home for you. It asks you to predict what a short Python or pandas snippet prints, read a SQL query, or answer a plain machine learning question. Shared list objects, float comparison, groupby results and missing values appear again and again. Your own spine gate sets already drill this shape, so treat every module gate as assessment practice.
Proctoring — a system that watches you during the test through your webcam, your screen, or both — is now common. Expect an identity check, a room scan, and a rule that logs every tab switch. Using a language model during a proctored test is cheating, and it is the fastest way to lose an offer you had already earned. Our stance across this programme is tutor, not generator: use a model to learn a method before the test, never to produce answers during it. Each platform states its own rules, so read the instructions you are sent.
One more rule shapes your plan. A sectional cut-off is a minimum score you must reach in each part, not only overall. Where it exists, a strong quant score cannot rescue a weak verbal one. That changes triage: the last minutes go to your weakest part, not your best. We cannot tell you which firms use it or what any number is, and anyone who quotes you a figure should be asked for the source.
Speed comes from a tracker, not from more hours. Write down every question you got wrong or slow, tag it with a topic, and count the tags each week. The two or three topics at the top of that count are your entire practice plan. Time every round, because untimed practice trains a skill the test does not measure.
Test day has a failure mode nobody warns you about. Power cuts, a dropped connection, a frozen browser and a laptop that sleeps mid-section are ordinary in Tier 2 and Tier 3 towns. Charge everything, keep a phone hotspot ready, book a quiet room, keep your identity card on the table, and save the platform's support contact before you start. If the platform breaks, do not restart at random, because most tests allow a resume and your support message is the evidence trail. WR-153 walks through one such morning.
Six artefacts. Copy each into your notes and rebuild it with your own numbers, because the point is the arithmetic, not the answer.
Artefact 1 — the time-per-question sum, worked for two realistic test shapes. These are shapes, not any company's real paper. Do this sum on the instructions page before you answer anything:
TEST SHAPE A - a services-firm screening test
Quantitative aptitude 15 Q
Logical reasoning 15 Q
Verbal ability 15 Q
Technical MCQ 15 Q
-----------------------------------
TOTAL 60 Q in 60 min
Raw budget : 60 min x 60 s = 3600 s ; 3600 / 60 = 60.0 s per question
Overhead : instructions 2 min + page loads and scrolling 2 min = 240 s
Usable budget : 3600 - 240 = 3360 s ; 3360 / 60 = 56.0 s per question
Pass caps : 45 s in pass 1, 90 s in pass 2 (both under 2 x 56 s)
Pass 3 float : keep 5 min = 300 s, about 5 questions' worth
TEST SHAPE B - an AI-role test with a data-interpretation set
Quantitative + DI 20 Q (10 of them hang off 2 shared tables)
Logical reasoning 10 Q
Python / pandas MCQ 15 Q
-----------------------------------
TOTAL 45 Q in 75 min
Raw budget : 75 x 60 = 4500 s ; 4500 / 45 = 100.0 s per question
Table reading : 2 tables x 90 s = 180 s (paid once, not once per question)
Usable budget : 4500 - 180 = 4320 s ; 4320 / 45 = 96.0 s per question
Pass caps : 70 s in pass 1, 150 s in pass 2
Pass 3 float : keep 6 min = 360 s, about 4 questions' worth
Two things fall out. Shape B looks generous at 100 seconds and is not, because ten of its questions share two tables you must read before any of them make sense, and that reading is a fixed cost you pay whether you answer one of those ten or all ten. And notice that both pass caps sit near or below twice the average: a cap above the average means one question can eat two.
Artefact 2 — the three passes, walked through on a ten-question mini-set with the clock shown. Ten questions, ten minutes, so 600 seconds and a 60-second average:
MINI-SET: 10 questions, 10:00 on the clock = 600 s
PASS 1 - the sure ones only. Cap 45 s. A skip costs 10 s (read, decide, leave).
Q1 solve 35 s clock 09:25
Q2 skip 10 s clock 09:15 (probability, needs setup)
Q3 solve 40 s clock 08:35
Q4 solve 25 s clock 08:10
Q5 skip 10 s clock 08:00 (long DI table)
Q6 skip 10 s clock 07:50 (series, no pattern seen yet)
Q7 solve 30 s clock 07:20
Q8 skip 10 s clock 07:10 (syllogism, three statements)
Q9 solve 45 s clock 06:25
Q10 skip 10 s clock 06:15 (time-speed-distance, two trains)
Spend: 35+40+25+30+45 = 175 s solving, 5 x 10 = 50 s skipping = 225 s
Banked: 5 marks. Left: 375 s for 5 questions.
PASS 2 - the solvable ones. Cap 90 s. 375 s over 5 questions = 75 s each.
Q2 solve 80 s clock 04:55
Q6 solve 70 s clock 03:45
Q10 solve 85 s clock 02:20
Spend: 80+70+85 = 235 s. Banked: 8 marks. Left: 140 s, Q5 and Q8 open.
STOP RULE: 140 s over 2 questions is 70 s each, below the 90 s cap.
Pass 2 ends here by rule, not by feel.
PASS 3 - what remains. Cut options first, then mark. Nothing stays blank.
Q8 cut 2 of 4 (two conclusions fail one drawing), mark 55 s clock 01:25
Q5 cut 1 of 4 from the row totals alone, mark 50 s clock 00:35
Final sweep: confirm every question carries an answer 35 s clock 00:00
Spend: 55+50+35 = 140 s. Total: 225 + 235 + 140 = 600 s exactly.
THE SAME SET, ANSWERED IN ORDER
Q1 35 -> 35 Q2 80 -> 115 Q3 40 -> 155 Q4 25 -> 180
Q5 210 -> 390 (stuck, then gave up) Q6 70 -> 460
Q7 30 -> 490 Q8 110 -> 600. Clock out.
Reached 8 of 10. Solved 6. Q9 and Q10 never seen, and Q9 was a 45 s mark.
Triage: 8 solved + 2 cut-down guesses. In order: 6 solved + 2 blanks.
Same questions, same 600 seconds, same student. Order did all of it.
Read the stop rule in pass 2 again, because it is the part students drop. You do not decide pass 2 is over when you feel tired; you decide it when the remaining seconds divided by the remaining questions fall below your pass-2 cap. That single division, done twice in a test, is what stops a section from ending in a panic.
Artefact 3 — negative marking as arithmetic, computed for two schemes. Do not carry a rumour into the hall. Carry this:
NOTATION
m = marks removed for a wrong answer n = options still live after cutting
EV = (1/n) x (+1) + (1 - 1/n) x (-m) "guess" is worth it when EV > 0
SCHEME 1 : +1 correct, -0.25 wrong, 4 options
n=4 (blind) EV = 0.2500 - 0.7500 x 0.25 = 0.2500 - 0.1875 = +0.0625
n=3 (cut 1) EV = 0.3333 - 0.6667 x 0.25 = 0.3333 - 0.1667 = +0.1667
n=2 (cut 2) EV = 0.5000 - 0.5000 x 0.25 = 0.5000 - 0.1250 = +0.3750
n=1 (cut 3) EV = +1.0000
Break-even accuracy p : p - 0.25(1 - p) = 0 -> 1.25p = 0.25 -> p = 0.20
Blind accuracy is 0.25, which clears 0.20, so a blind guess does pay.
Size check: 0.3750 / 0.0625 = 6. Cutting two options is worth SIX blind
guesses. Blind guessing is a mop-up move, never a rescue plan.
SCHEME 2 : +1 correct, -1 wrong, 5 options
n=5 (blind) EV = 0.2000 - 0.8000 x 1 = -0.6000
n=4 (cut 1) EV = 0.2500 - 0.7500 x 1 = -0.5000
n=3 (cut 2) EV = 0.3333 - 0.6667 x 1 = -0.3333
n=2 (cut 3) EV = 0.5000 - 0.5000 x 1 = 0.0000 <- break-even, not a gain
n=1 (cut 4) EV = +1.0000
Break-even accuracy p : p - 1(1 - p) = 0 -> 2p = 1 -> p = 0.50
Cutting three of five only reaches zero. Under this scheme, guessing pays
nothing until you are certain, and 24 blind guesses would cost 14.4 marks.
DERIVING THE ONE-LINE RULE
EV > 0 <=> 1/n > m(1 - 1/n) <=> (1/n)(1 + m) > m <=> n < 1 + 1/m
m = 0.25 -> n < 5 : four live options already pay
m = 0.33 -> n < 4 : cut at least one of four first
m = 1.00 -> n < 2 : only a certain answer pays
m = 0 -> no limit at all : a blank is strictly worse than a guess
The last line of that table is the one most students lose marks to. When there is no negative marking, an unmarked question has an expected value of exactly zero and a blind guess has an expected value of 1/n, which is above zero for every n. Marking a leftover costs about two seconds. A blank on a test with no penalty is a mark you threw away for nothing. And the schemes matter enormously: on the same 24 leftover questions, blind guessing is worth 24 x 0.0625 = +1.5 marks under scheme 1 and 24 x (-0.6) = -14.4 marks under scheme 2, a swing of 15.9 marks decided entirely by a line in the instructions you were sent.
Artefact 4 — five aptitude topics, each with its fast method and one worked example. The fast method is the whole point; the answer is only proof it works:
1. PERCENTAGES AND RATIO - fast method: multiply the multipliers first
Q: A monthly data recharge costs Rs 250. The price rises 20%, then a
festival offer cuts the new price by 15%. What do you pay?
Slow : 250 + 20% = 300 ; 300 - 15% of 300 = 300 - 45 = 255
Fast : 250 x 1.20 x 0.85 ; do 1.20 x 0.85 = 1.02 first ; 250 x 1.02 = 255
Net move is +2%, not +5%. The trap option is 262.50, which is 250 x 1.05.
Ratio version, same trick: two shares in the ratio 5 : 3 differ by Rs 1,200.
The difference is 2 parts, so 1 part = 600, so the total is 8 x 600 = 4,800.
2. TIME, SPEED, DISTANCE - fast method: equal distances use the harmonic mean
Q: You cycle to the lab at 12 km/h and return by the same road at 18 km/h.
Average speed for the whole trip?
Trap : (12 + 18) / 2 = 15 km/h. Wrong: you spend longer at the slow speed.
Fast : 2ab / (a + b) = 2 x 12 x 18 / 30 = 432 / 30 = 14.4 km/h
Proof: take 36 km each way. 36/12 = 3 h out, 36/18 = 2 h back.
72 km in 5 h = 14.4 km/h. Formula and long route agree.
3. NUMBER SERIES - fast method: write the differences before guessing a rule
Q: 3, 7, 16, 35, 74, ?
Differences: 4, 9, 19, 39. Each one is (previous x 2) + 1, so next is 79.
Answer: 74 + 79 = 153.
Cross-check with the direct rule: term = (previous x 2) + step, with step
running 1,2,3,4,5 -> 2(3)+1=7, 2(7)+2=16, 2(16)+3=35, 2(35)+4=74, 2(74)+5=153.
Two independent routes to 153. That agreement is how you buy certainty fast.
4. SYLLOGISM - fast method: two circles, and never let "some" travel backwards
Statements : (1) All UPI apps are payment apps.
(2) Some payment apps are blocked.
Conclusion I : Some UPI apps are blocked.
Conclusion II: Some payment apps are UPI apps.
I does NOT follow. Draw the blocked payment apps entirely outside the UPI
circle: statements still true, conclusion false. One drawing rejects it.
II DOES follow. "All A are B" with A non-empty gives "some B are A".
Answer: only Conclusion II follows.
5. DATA INTERPRETATION - fast method: cancel zeros, and check rate vs count
Parcels handled by a logistics hub:
MONTH PARCELS FAILED COST (Rs lakh)
Apr 12,000 600 18.0
May 15,000 1,050 21.0
Jun 18,000 720 25.2
Jul 20,000 1,200 30.0
Q1: Which month had the worst failure RATE?
600/12,000 = 5% 1,050/15,000 = 7% 720/18,000 = 4% 1,200/20,000 = 6%
Worst rate = May at 7%. Worst COUNT = Jul at 1,200. Two different months.
Q2: In which months was cost per parcel equal, and at what figure?
Cancel three zeros from both sides before dividing:
1800/12 = 150 2100/15 = 140 2520/18 = 140 3000/20 = 150
May and Jun tie at Rs 140 per parcel. Apr and Jul sit at Rs 150.
Notice what the fast methods have in common. Each one replaces two or three arithmetic steps with a single operation you can do without writing much down: one multiplication of multipliers, one formula, one difference row, one drawing, one cancellation. Under a 56-second budget, the saving is not the sum itself but the paper you never fill.
Artefact 5 — the technical MCQ mini-set for AI roles. These are the shapes that recur. Predict each output before you read the reason:
Q1 x = [1, 2, 3] ; y = x ; y.append(4) ; print(len(x), len(y))
-> 4 4. y is not a copy. Both names point at one list object. Slicing
with b = a[:] is what makes a real copy, and then it would print 3 4.
Q2 print(0.1 + 0.2 == 0.3)
-> False. Binary floats cannot hold 0.1 or 0.2 exactly, so the sum lands
a hair above 0.3. Compare floats with a tolerance, never with ==.
Q3 df = pd.DataFrame({"city": ["A","B","A","C"], "amt": [100,200,300,400]})
print(df.groupby("city")["amt"].sum().loc["A"])
-> 400. Rows 0 and 2 are city A, so 100 + 300. groupby returns a Series
indexed by the group key, which is why .loc["A"] works.
Q4 s = pd.Series([1, None, 3]) ; print(s.sum(), s.mean())
-> 4.0 2.0. Missing values are skipped by default, so the mean divides by
2 and not by 3. This is the most common pandas trap in these sections.
Q5 A fraud model reports 99% accuracy on a month of card payments where 99%
of rows are legitimate. What does that number tell you about the model?
-> Nothing useful. "Always predict legitimate" also scores 99%. Ask for
recall on the fraud class. This is module 1.5 compressed into one line.
Q6 SELECT city, COUNT(*) FROM payments WHERE amount > 500
GROUP BY city HAVING COUNT(*) >= 2;
rows: (Ajmer,600) (Ajmer,900) (Bhilai,400) (Bhilai,700) (Cuttack,800)
-> One row: Ajmer, 2. WHERE drops the Bhilai 400 row first, so Bhilai's
group count is 1 and HAVING removes it; Cuttack is 1 too. WHERE filters
rows before grouping, HAVING filters groups after.
None of that is new material. Q1 and Q2 are module 0.3, Q3 and Q4 are module 0.5, Q6 is module 0.6, and Q5 is module 1.5. What is new is answering them in forty seconds without a laptop, which is why they belong in a timed set and not in a revision note.
Artefact 6 — mark your own answers. Run this in your project environment. Every assertion below is one of the mini-set answers, so a clean run means your predictions were right:
# Self-check for artefact 5. A clean run prints two lines and nothing else.
import pandas as pd
x = [1, 2, 3]; y = x; y.append(4)
assert (len(x), len(y)) == (4, 4) # Q1: one list object, two names
a = [1, 2, 3]; b = a[:]; b.append(4)
assert (len(a), len(b)) == (3, 4) # Q1 variant: a slice is a real copy
assert (0.1 + 0.2 == 0.3) is False # Q2: binary float representation
print(f"0.1 + 0.2 = {0.1 + 0.2:.20f}") # see the error with your own eyes
df = pd.DataFrame({"city": ["A", "B", "A", "C"], "amt": [100, 200, 300, 400]})
assert df.groupby("city")["amt"].sum().loc["A"] == 400 # Q3
s = pd.Series([1, None, 3])
assert (s.sum(), s.mean()) == (4.0, 2.0) # Q4: NaN skipped, mean divides by 2
assert (s.count(), len(s)) == (2, 3) # count() skips NaN, len() does not
# Q5 in code: the do-nothing baseline that scores 99% accuracy
y_true = [0] * 990 + [1] * 10 # 1 = fraud, 10 fraud rows in 1000
y_pred = [0] * 1000 # "always legitimate"
acc = sum(t == p for t, p in zip(y_true, y_pred)) / len(y_true)
caught = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 1)
print(f"accuracy={acc:.3f} fraud_recall={caught / 10:.3f} <- 0.990 and 0.000")
The last two lines are the artefact worth keeping. A model that never predicts fraud scores 0.990 accuracy and 0.000 recall on the class anyone cares about, and an interviewer who asks Q5 is checking whether you reach for accuracy first. If the assertions fail on your machine, read the failing line rather than the whole file, because each one isolates a single behaviour.
Work in a folder called oa-prep in your notes. Three files live there and get updated all week: timing-cards.md, marking-rules.md, and weak-topics.csv. Every timed round you run gets logged, including the bad ones, because the bad ones carry the information.
Build your timing cards. Write a timing card for three different test shapes: 60 questions in 60 minutes, 40 questions in 45 minutes, and 45 questions in 75 minutes with two shared data-interpretation tables. For each shape compute, showing the working: the raw seconds per question, an honest overhead estimate with your reason for the number, the usable seconds per question after overhead, a pass-1 cap and a pass-2 cap, and a pass-3 float in seconds and in questions' worth. Then write one line per card naming the first thing you would cut if the shape turned out to be harder than expected. Check: three cards exist with every division written out, not only the answer; each usable figure is lower than its raw figure and the gap is explained; every pass-1 cap is below the usable average and every pass-2 cap is below twice it; each card states its pass-3 float in both seconds and questions; and you can say in one sentence which of the three shapes is the most dangerous and why.
Build the marking-rule decision card, then audit yourself against it. For three schemes — plus one minus a quarter with four options, plus one minus a third with four options, and plus one minus one with five options — compute the expected value at every level of elimination, from blind down to certain. Derive the break-even accuracy for each and check it against the rule that the live options must be fewer than one plus one over the penalty. Then take any twenty questions you have attempted before, from any practice set, and for each one record what you actually did, what the rule says you should have done, and the marks that decision was worth. Check: three full expected-value tables exist with the arithmetic shown; the break-even accuracy for each scheme is derived, not copied; you can state the threshold rule from memory and show why it follows from the expected-value formula; twenty past attempts are audited into agree or disagree with the rule; and you report the total marks the disagreements cost or saved, with the sign stated honestly.
Run one timed mock section under real conditions, then score your triage. Assemble a twenty-question set of your own from free past papers or public practice sets: eight quantitative, four logical, four verbal, four Python or pandas. Set a marking scheme in writing before you start. Run the test-day checklist first — device charged, hotspot ready, quiet room, identity card on the table, support contact saved, phone away, no other tab open — then take the set in one sitting in twenty-five minutes with a visible timer. Log every question with the seconds you spent and the pass you answered it in. Check: the twenty questions and the marking scheme are saved before the attempt, not after; the checklist is ticked line by line with a note on anything you could not arrange; the log shows seconds and pass number for all twenty; you score three things separately — raw marks, the number of pass-1 questions that broke your cap, and the number of questions you never touched in any pass; and you write one honest sentence naming whether accuracy or triage cost you more, with the numbers behind it.
Run a weak-topic tracker over one week, then report what it did or did not do. Build weak-topics.csv with the columns: date, topic, question source, seconds taken, correct, and the reason for a miss chosen from method, arithmetic, misread, or clock. Fill it from exercise 3 first. Then run three timed rounds across the week, each fifteen questions in eighteen minutes, drawn only from your top two topics by miss count. Recount the tags after every round and let the counts, not your mood, choose the next round's topics. Check: the file holds at least sixty logged questions across four sittings with all six columns filled; the top-two topics are recomputed and named after each round, and you show the count that justified the choice; you report accuracy and median seconds per question for those topics in round one and round three; you state plainly whether they improved, stayed flat, or got worse; and if they got worse or stayed flat you name the most likely cause from your own reason column rather than explaining it away.
Three assessment-day failures cover most of the damage in a first placement season. Each one has a War Room entry with the full diagnosis path:
- WR-151 — the clock ran out at question 22 of 40. A student answered in order and gave nine minutes to a single hard question, which was eight questions' worth of budget; the fix is the three-pass order plus a hard per-question cap that you obey by the clock, not by feel.
- WR-152 — the negative-marking bleed. A student blind-guessed every leftover under a quarter-mark penalty and finished a mark below the score she would have had by leaving them blank; the fix is the elimination threshold and treating guessing as a mop-up, not a rescue.
- WR-153 — the power cut at minute 22. A student lost power and network mid-test with no plan, panicked, and restarted into a locked session; the fix is the pre-test checklist and a written first move for the moment it happens.
An online assessment gives you a fixed number of seconds per question, and that number decides your plan. Divide minutes by questions first, take off the overhead, and set a hard cap for each pass. Three passes beat working in order, because every question is touched once before any question is paid for. Negative marking turns guessing into arithmetic, and the rule is that live options must be fewer than one plus one over the penalty. Track your wrong and slow questions by topic, practise against a clock, and run the test-day checklist before you start.
- IT-services campus drives open with a machine-scored test of this exact shape, and it removes more applicants than every later stage put together. The timing card and the three passes are what a placement coordinator wishes every student built before drive week.
- Bank and logistics analyst roles test data interpretation hard, because reading a table under time pressure is most of the first-year job. The same rate-versus-count trap that costs a mark here costs a wrong number in a real report later.
- Proctored certification exams, including the cloud and analytics ones many freshers sit, use the same identity check, room scan and tab-switch rules. The habits you build this week transfer to every one of them without change.
Answer these before opening the gate assessment. Each question names its kind.
type=interpretation— A test screen says 45 questions in 75 minutes, and ten of those questions hang off two shared tables you must read first. Compute the raw and the usable seconds per question with your overhead assumption written down, then state what the shared tables do to the pass-1 cap you would set.type=scenario-judgement— Eight minutes are left. The instructions you were sent state a minimum score in each section. Your quantitative section is finished and strong, your verbal section has nine unanswered questions, and the scheme is plus one minus a quarter with four options. Give your ruling on where the eight minutes go and show the arithmetic behind it.type=debug— A classmate writes: "Penalty is minus one with five options. I cut it down to two options, so my expected value is 0.5 minus 0.5, which is zero, and zero is not negative, so guessing here is free marks." Find every error in that reasoning and state the correct decision for that question.type=output-prediction— Predict what these two lines print and why:s = pd.Series([4, None, 8])thenprint(s.sum(), s.mean(), s.count(), len(s)). Name the default behaviour that produces the difference between the last two numbers.type=trade-off— Compare a plan that attempts all 60 questions with tight caps against a plan that attempts 40 questions carefully. Give one concrete gain and one concrete cost of each, then say how a quarter-mark penalty and a sectional cut-off would each change your choice.
Explain to a friend in a non-technical degree why a timed online test rewards sorting rather than cleverness. Use the seconds-per-question sum from the scene, describe the three passes in the order you would make them, and explain when a guess is worth marks and when it is not, without using any formula. Then tell your friend the one thing to do on the instructions page before answering anything. Use at most 4 sentences and no word your friend would need to look up. If your friend can name the three passes and the one first move, you own this module.