Negative marking: when guessing pays

Under negative markingnegative marking: A scoring rule under which a wrong answer loses marks, often a fixed share of what a right answer earns. A question left blank usually scores zero., a 1-mark GATE MCQ takes away a third of a mark for a wrong answer. Is a guess among its four options worth taking? On average it is worth exactly nothing, and ruling out one option makes it worth +1/9 of a mark.

In general, if a right answer earns c marks and a wrong one costs w, an answer you are right about with chance p is worth p × c − (1 − p) × w marks on average, against 0 for a blank. So answering gains marks whenever p is above w ÷ (c + w), the break-even chancebreak-even chance: The chance of being right at which answering is worth exactly as much as leaving a question blank: what a wrong answer loses, divided by what a right answer earns plus what a wrong answer loses.. Under SSC CGL Tier-I (+2, −0.50) that chance is 1/5, so even a blind guess gains 1/8 of a mark on average, and where there is no penalty, as in TCS iON NQT, a blank is never the best choice. You will work these values out exactly, see what an average hides in 10,000 simulated guesses, and check your own guesses against your mock records.

A guess pays once your chance beats the break-even

Take that GATE question with one of its four options ruled out: you pick among three, so you are right 1 time in 3 and earn 1 mark, and wrong 2 times in 3 and lose 1/3. Every answer works this way: you are right and earn c marks, or you are wrong and lose w. If your chance of being right is p, the average over many such answers, the expected marksexpected marks: The average marks an answer earns over many questions like it: the chance of being right times the marks for a right answer, minus the chance of being wrong times the marks a wrong answer loses., is

A blank is worth 0, so answering is worth it when E is above 0. The two parts balance when p × c = (1 − p) × w, which gives the break-even chance:

Step through the GATE question part by part, first with one option ruled out and then blind:

With one option out the guess earns +1/9 of a mark; blind, its chance of 1/4 is the break-even chance itself and it earns 0. A pure guess among k options that are equally likely has p = 1/k, so a random pick is worth c/k − w(k − 1)/k. The break-even depends only on how large the penalty is compared with the reward: +3/−1 and +1/−1/3 both break even at 1/4, because in both a wrong answer costs a third of what a right one earns.

The whole decision fits in four checks:

Each published scheme has its own break-even chance

The program applies both formulas to the schemes of the tests in this module, with exact fractions, so a third of a mark never becomes 0.33. Press Edit, add the scheme of your own test as a row, and run it again:

// The break-even chance and the value of a random guess under five marking schemes, in exact fractions.
// A fraction is [numerator, denominator] in lowest terms, with a positive denominator.
const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
function frac(n, d = 1) {
  if (n === 0) return [0, 1];
  const s = d < 0 ? -1 : 1;
  const g = gcd(n, d);
  return [(s * n) / g, (s * d) / g];
}
const add = ([a, b], [c, d]) => frac(a * d + c * b, b * d);
const mul = ([a, b], [c, d]) => frac(a * c, b * d);
const div = ([a, b], [c, d]) => frac(a * d, b * c);
const neg = ([a, b]) => frac(-a, b);
const plain = ([n, d]) => (d === 1 ? String(n) : `${n}/${d}`);
const signed = (x) => (x[0] > 0 ? `+${plain(x)}` : plain(x));

/** Expected marks of a random guess among k options: right/k - wrong(k - 1)/k. */
const guessValue = (right, wrong, k) => add(div(right, frac(k)), neg(mul(wrong, frac(k - 1, k))));
/** The chance of being right at which answering is worth exactly as much as a blank: wrong / (right + wrong). */
const breakEven = (right, wrong) => div(wrong, add(right, wrong));

const schemes = [
  // [scheme, marks for a right answer, marks lost for a wrong one]
  ['GATE 2027 MCQ, 1 mark', frac(1), frac(1, 3)],
  ['GATE 2027 MCQ, 2 marks', frac(2), frac(2, 3)],
  ['SSC CGL 2026 Tier-I', frac(2), frac(1, 2)],
  ['SSC CGL 2026 Tier-II, Paper-I', frac(3), frac(1)],
  ['No penalty, per mark', frac(1), frac(0)],
];

for (const [name, right, wrong] of schemes) {
  console.log(`${name} (${signed(right)}, ${signed(neg(wrong))}): break-even ${plain(breakEven(right, wrong))}`);
  const guesses = [4, 3, 2].map((k) => `${k} left ${signed(guessValue(right, wrong, k))}`);
  console.log(`  a random guess with ${guesses.join(', ')}`);
}

GATE 2027 MCQ, 1 mark (+1, -1/3): break-even 1/4
  a random guess with 4 left 0, 3 left +1/9, 2 left +1/3
GATE 2027 MCQ, 2 marks (+2, -2/3): break-even 1/4
  a random guess with 4 left 0, 3 left +2/9, 2 left +2/3
SSC CGL 2026 Tier-I (+2, -1/2): break-even 1/5
  a random guess with 4 left +1/8, 3 left +1/3, 2 left +3/4
SSC CGL 2026 Tier-II, Paper-I (+3, -1): break-even 1/4
  a random guess with 4 left 0, 3 left +1/3, 2 left +1
No penalty, per mark (+1, 0): break-even 0
  a random guess with 4 left +1/4, 3 left +1/3, 2 left +1/2

Reading it scheme by scheme:

• GATE 2027 MCQs. Each has four options and one right answer, and a wrong answer costs a third of the question’s marks: 1/3 on a 1-mark question, 2/3 on a 2-mark one. Both break even at 1/4. A blind guess is worth 0; ruling out one option makes a guess worth +1/9 or +2/9 of a mark, about 0.11 and 0.22; ruling out two makes it +1/3 or +2/3.
• GATE 2027 MSQs and numerical answers carry no negative marks at all, so any answer is better than a blank. An MSQ has four options and one or more right ones, which allows 15 different choices: even a blind pick is right 1 time in 15, and a wrong one costs nothing.
• SSC CGL 2026 Tier-I. Each subject has 25 questions for 50 marks, so 2 marks a question, and a wrong answer costs 0.50. The break-even is 1/5 and a blind guess is worth +1/8, about 0.13 of a mark. The notice does not say how many options a question has; these values assume four.
• SSC CGL 2026 Tier-II, Paper-I. Its first three sections give 3 marks a question and take 1 mark for a wrong answer. Like GATE’s MCQs, that breaks even at 1/4, with a blind guess worth 0 and a guess between two options worth a whole mark.
• No penalty. TCS iON says its tests have no negative marking, so a guess there can only gain: a quarter of the marks on average for a blind pick among four options.

An average of zero still loses more often than not

An expected value is an average over many questions. On a single question you either gain or lose, and the program below shows what that means for 10,000 blind guesses among four options under +3/−1, a scheme whose blind guess is worth exactly 0:

// 10,000 blind guesses among 4 options under +3 / -1, from a seeded random generator (the same numbers on every run),
// next to the exact values: the average, the spread, and what 10 blind guesses can do to a score.
function mulberry32(seed) {
  let a = seed >>> 0;
  return () => {
    a = (a + 0x6d2b79f5) >>> 0;
    let t = a;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

const RIGHT = 3; // marks for a right answer
const WRONG = 1; // marks lost for a wrong one
const N = 10000;
const random = mulberry32(2027);

let total = 0;
let rights = 0;
const runs = []; // the total of each run of 10 guesses
for (let i = 0; i < N; i += 10) {
  let run = 0;
  for (let j = 0; j < 10; j++) {
    const right = Math.floor(random() * 4) === 0; // one option in four is right
    run += right ? RIGHT : -WRONG;
    if (right) rights++;
  }
  runs.push(run);
  total += run;
}
const sign = (x) => (x > 0 ? `+${x}` : String(x));
console.log(`${N} blind guesses: ${rights} right (expected 2500, give or take about ${Math.sqrt(N * 0.25 * 0.75).toFixed(0)})`);
console.log(`total ${sign(total)} marks, average ${(total / N).toFixed(3)} a guess; exact average 0`);
console.log(`spread of a single guess: the square root of 3, about ${Math.sqrt(3).toFixed(2)} marks`);
const behindRuns = runs.filter((r) => r < 0).length;
console.log(`${runs.length} runs of 10 guesses: worst ${sign(Math.min(...runs))}, best ${sign(Math.max(...runs))}, behind in ${behindRuns}`);

// Exact chances for 10 blind guesses: r right answers give 3r - (10 - r) = 4r - 10 marks.
const choose = (n, k) => (k === 0 ? 1 : (choose(n, k - 1) * (n - k + 1)) / k);
const chance = (r) => choose(10, r) * 0.25 ** r * 0.75 ** (10 - r);
console.log('exact chance of each total after 10 blind guesses:');
let behind = 0;
let shown = 0;
for (let r = 0; r <= 6; r++) {
  const p = chance(r);
  shown += p;
  if (4 * r - 10 < 0) behind += p;
  console.log(`  ${r} right ${sign(4 * r - 10).padStart(4)} marks ${(100 * p).toFixed(1).padStart(5)} %  ${'#'.repeat(Math.round(100 * p))}`);
}
console.log(`  7 to 10 right: ${(100 * (1 - shown)).toFixed(1)} % together`);
console.log(`chance of ending behind (2 or fewer right): ${(100 * behind).toFixed(1)} %`);

10000 blind guesses: 2439 right (expected 2500, give or take about 43)
total -244 marks, average -0.024 a guess; exact average 0
spread of a single guess: the square root of 3, about 1.73 marks
1000 runs of 10 guesses: worst -10, best +22, behind in 554
exact chance of each total after 10 blind guesses:
  0 right  -10 marks   5.6 %  ######
  1 right   -6 marks  18.8 %  ###################
  2 right   -2 marks  28.2 %  ############################
  3 right   +2 marks  25.0 %  #########################
  4 right   +6 marks  14.6 %  ###############
  5 right  +10 marks   5.8 %  ######
  6 right  +14 marks   1.6 %  ##
  7 to 10 right: 0.4 % together
chance of ending behind (2 or fewer right): 52.6 %

What the run shows:

• The average lands near zero, not on it. 2,439 guesses were right where 2,500 were expected, a normal shortfall when a typical miss is about 43 either way, and the total came to −244 marks: −0.024 a guess.
• A single guess swings by about 1.73 marks either way: it gains 3 or loses 1, and it loses three times in four.
• Ten blind guesses leave you behind more often than not. The exact chance of ending below zero is 52.6 %, and the simulated runs were behind 554 times in 1,000. You gain 6 marks or more only 22.4 % of the time (14.6 + 5.8 + 1.6 + 0.4).

Those exact chances follow the binomial distributionThe chances of each number of successes in a fixed number of independent tries that each succeed with the same chance, such as the number of right answers among 10 blind guesses.. The figure starts at ten guesses, each right with chance 0.25, and asks for at least 3 right, the fewest that leave you ahead (3 × 3 − 7 = +2 marks):

The readout is 0.4744, so you end ahead 47.4 % of the time and behind 52.6 %. Set k to 4 and it shows the 22.4 % chance of gaining 6 marks or more. So at break-even, blind guesses add risk and no marks. Where the scheme pays for them, as SSC CGL Tier-I does, they add marks on average and risk as well; where it does not, leave them.

Ruling out options pays only if your records agree

Ruling out options raises your chance of being right, but only if what you ruled out was really wrong. With four options and one ruled out, a fair pick among the three left is right 1 time in 3; with two ruled out, 1 time in 2. If the right answer was sometimes among the options you crossed out, your real chance is lower than that, and the only way to know is to count. Mark every guess in your mocks with how many options were left, then compare how often those guesses were right with the break-even chance. Press Edit and put your own counts in the rows:

// Are your guesses worth taking? Count, from your marked mocks, the guesses you made with a given number of options
// left and how many were right; replace the rows below with your own and press Run.
const guesses = [
  // [marking scheme, marks for a right answer, marks lost for a wrong one, options left, guesses, right]
  ['+3 / -1', 3, 1, 2, 24, 9],
  ['GATE 1-mark MCQ', 1, 1 / 3, 3, 30, 6],
  ['+2 / -0.50', 2, 0.5, 4, 20, 5],
];

for (const [scheme, right, wrong, left, count, hits] of guesses) {
  const p = hits / count; // your measured chance of being right
  const breakEven = wrong / (right + wrong);
  const perGuess = p * right - (1 - p) * wrong;
  const verdict = p > breakEven ? 'worth taking' : 'costing you marks: stop these until you find why';
  console.log(`${scheme}, ${left} options left: ${hits} of ${count} right (${(100 * p).toFixed(1)} %)`);
  console.log(`  break-even ${(100 * breakEven).toFixed(1)} %; a random pick would be right ${(100 / left).toFixed(1)} % of the time`);
  console.log(`  ${perGuess >= 0 ? '+' : ''}${perGuess.toFixed(3)} marks a guess, ${perGuess >= 0 ? '+' : ''}${(perGuess * count).toFixed(2)} over these ${count}: ${verdict}`);
}

+3 / -1, 2 options left: 9 of 24 right (37.5 %)
  break-even 25.0 %; a random pick would be right 50.0 % of the time
  +0.500 marks a guess, +12.00 over these 24: worth taking
GATE 1-mark MCQ, 3 options left: 6 of 30 right (20.0 %)
  break-even 25.0 %; a random pick would be right 33.3 % of the time
  -0.067 marks a guess, -2.00 over these 30: costing you marks: stop these until you find why
+2 / -0.50, 4 options left: 5 of 20 right (25.0 %)
  break-even 20.0 %; a random pick would be right 25.0 % of the time
  +0.125 marks a guess, +2.50 over these 20: worth taking

The three rows are an invented candidate’s records:

• Under +3/−1, guesses between two options were right 9 times in 24. 37.5 % is above the 25 % break-even, so each guess is worth +0.5 marks, +12 over the 24. But a fair pick between two would be right half the time, so if the final pick was a fair toss, the right answer survived the candidate’s eliminations only about 3 times in 4 (0.375 ÷ 0.5 = 0.75). Keep these guesses, and look at which eliminations failed.
• On 1-mark GATE MCQs with three options left, guesses were right 6 times in 30. 20 % is below the 25 % break-even, so each costs about 0.07 marks, 2 marks over the 30. Stop those guesses until the records show where the eliminations go wrong, which is usually one or two topics.
• Under +2/−0.50, blind guesses were right 5 times in 20, exactly the one in four that chance gives, worth +0.125 marks each.

Twenty or thirty guesses is a small count: one more right answer moves the rate by 3 to 5 percentage points. Wait until a pattern repeats across two or three mocks before you change a rule.

Each kind of scheme calls for its own strategy

Put together, the break-even chance and your records give one strategy for each kind of scheme:

Time is part of the price too. A guess takes seconds, while a question you can solve may need a minute or two and is worth its full marks, so make the first pass through a section on questions you can work out, and guess, where the scheme pays for it, only when the time for that section is nearly over.

When the penalty depends on your attempts

eLitmus uses negative marking it calls handicap-based and keeps its formula to itself. It describes two features: the penalty for each wrong answer depends on the questions you attempted, so that 4 wrong answers among 30 attempts are penalised more, each, than 4 among 40; and a wrong option close to the right answer is treated differently from one that is unrelated. Without a formula there is no break-even chance to compute. What the first feature does say is that each wrong answer costs more when wrong answers make up a larger share of your attempts, so in this test answer the questions you have worked out and leave blind guesses alone.

Your own test, decided

Answer four questions about your test and your records; the table rules out the strategies that do not fit and says why:

In short: with no penalty, answer everything; under a published penalty, answer above the break-even chance that your records support; under an unpublished one, answer only what you have worked out.

Practise: the value of a guess in exact fractions

The exercise turns both formulas into code with exact fractions. The questions after it start where your answers have been weakest so far.

guessValue([1, 1], [1, 3], 3); // [1, 9]: a 1-mark GATE MCQ with one option ruled out
guessValue([2, 1], [1, 2], 4); // [1, 8]: a blind guess under +2 / -0.50
breakEven([3, 1], [1, 1]);     // [1, 4]: answer once you are right more than 1 time in 4

/** Greatest common divisor of two integers (never negative). */
export function gcd(a, b) {
  return b === 0 ? Math.abs(a) : gcd(b, a % b);
}

/** The fraction n/d as [numerator, denominator] in lowest terms, with a positive denominator. */
export function reduce(n, d) {
  if (n === 0) return [0, 1];
  const sign = d < 0 ? -1 : 1;
  const g = gcd(n, d);
  return [(sign * n) / g, (sign * d) / g];
}

/**
 * The expected marks of a random guess among `left` options, as a fraction [n, d].
 * right: the marks for a right answer; wrong: the marks lost for a wrong one (positive, or [0, 1] for no penalty).
 */
export function guessValue(right, wrong, left) {
  // Replace this line with your code.
  return [0, 1];
}

/** The chance of being right at which answering is worth exactly as much as a blank, as a fraction [n, d]. */
export function breakEven(right, wrong) {
  // Replace this line with your code.
  return [0, 1];
}

import { test, assert } from 'mysmartcopilot:test';
import { breakEven, guessValue, reduce } from './guess.mjs';

test('reduce keeps fractions in lowest terms with a positive denominator', () => {
  assert.deepEqual(reduce(6, 8), [3, 4]);
  assert.deepEqual(reduce(3, -6), [-1, 2]);
  assert.deepEqual(reduce(0, 5), [0, 1]);
});

test('a blind guess on a 1-mark GATE MCQ is worth exactly nothing', () => {
  assert.deepEqual(guessValue([1, 1], [1, 3], 4), [0, 1]);
});

test('ruling out one option of a 1-mark GATE MCQ makes the guess worth 1/9', () => {
  assert.deepEqual(guessValue([1, 1], [1, 3], 3), [1, 9]);
});

test('a 2-mark GATE MCQ with two options left is worth 2/3', () => {
  assert.deepEqual(guessValue([2, 1], [2, 3], 2), [2, 3]);
});

test('a blind guess under +2 / -0.50 is worth 1/8', () => {
  assert.deepEqual(guessValue([2, 1], [1, 2], 4), [1, 8]);
});

test('under +3 / -1 a guess between two options is worth a whole mark', () => {
  assert.deepEqual(guessValue([3, 1], [1, 1], 2), [1, 1]);
});

test('a blind guess can lose marks: +1 / -1 with four options', () => {
  assert.deepEqual(guessValue([1, 1], [1, 1], 4), [-1, 2]);
});

test('with no penalty a blind guess earns a quarter of the marks', () => {
  assert.deepEqual(guessValue([1, 1], [0, 1], 4), [1, 4]);
});

test('with one option left the guess is sure to be right', () => {
  assert.deepEqual(guessValue([2, 1], [1, 2], 1), [2, 1]);
});

test('break-even chances of four schemes', () => {
  assert.deepEqual(breakEven([1, 1], [1, 3]), [1, 4]);
  assert.deepEqual(breakEven([2, 1], [1, 2]), [1, 5]);
  assert.deepEqual(breakEven([4, 1], [1, 1]), [1, 5]);
  assert.deepEqual(breakEven([3, 1], [1, 1]), [1, 4]);
});

test('with no penalty the break-even chance is 0', () => {
  assert.deepEqual(breakEven([1, 1], [0, 1]), [0, 1]);
});

Interview questions

When does answering a question under negative marking gain marks on average? (warm-up)

When your chance of being right is above the break-even chance. If a right answer earns c marks and a wrong one costs w, an answer with chance p of being right is worth p × c − (1 − p) × w on average, and a blank is worth 0. The two are equal at p = w ÷ (c + w). For GATE’s MCQs, where a wrong answer costs a third of the marks, that is 1/4: a blind guess among four options is worth exactly nothing, and ruling out one option makes a guess pay. Under +2/−0.50 the break-even is 1/5, and even a blind guess gains 1/8 of a mark on average. A good answer adds that this is an average over many questions, and that your real chance comes from your mock records, not from the number of options left.

Key takeaways

• An answer you are right about with chance p is worth p × c − (1 − p) × w; it beats a blank when p is above w ÷ (c + w).
• GATE MCQs and +3/−1 break even at 1/4: blind guesses are worth 0, and one option ruled out is enough to make a guess worth taking.
• SSC CGL Tier-I (+2/−0.50) breaks even at 1/5, so a blind guess gains 1/8 of a mark on average; with no penalty, never leave a blank.
• An average of zero still loses more often than not: ten blind guesses under +3/−1 end behind 52.6 % of the time.
• Check your guesses against your mock records, and where the penalty is unpublished, as in eLitmus, answer only what you have worked out.