GATE score, qualifying marks and normalisation

Your GATE marks are out of 100; your GATE scoreGATE score: A score from a straight line through two points of a paper's own results: 350 at the general qualifying marks and 900 at the mean marks of the top candidates. is out of 1000 and says where those marks stand in your paper. The brochure turns marks into a score with a straight line that gives 350 to the general qualifying marksqualifying marks: The marks a candidate must reach to qualify in a paper: for the general category the mean plus one standard deviation of all marks, kept between 25 and 40; 9/10 of that for OBC-NCL and EWS, 2/3 for SC, ST and PwD., Mq, and 900 to MtMt: The mean marks of the top 0.1 % of a paper's candidates, or of the top 10 if that is more, over all sessions: the marks the GATE score formula maps to 900., the mean marks of the top 0.1 % or the top 10 candidates, whichever is larger. The general qualifying marks are the paper’s mean plus one standard deviation, kept between 25 and 40; OBC-NCL and EWS candidates need 9/10 of them and SC, ST and PwD candidates 2/3.

When a paper runs in several sessions, every candidate’s marks are first normalisednormalised marks: Marks of a multi-session paper after each session's marks are slid and stretched so that its mean plus one standard deviation and its top 0.1 % mean match the values of all sessions together., so that a mark from a harder session counts for more. With the GATE 2026 CS numbers, 50 marks scored 583.89, and a score of 600 needed 51.38 marks. Below, all three formulas are worked on the numbers of the official GATE 2026 report, including the places where the report’s printed numbers and the formulas differ.

A straight line through two points turns marks into a score

Section 8.1 of the brochure gives the score of a candidate with marks M as

• M is your marks: the actual marks in a single-session paper, the normalised marks in a multi-session one.
• Mq is the general category’s qualifying marks for the paper.
• Mt is the mean marks of the top 0.1 % of the candidates who appeared, or of the top 10 if that is more people, over all sessions together.

In words, the score climbs 550 points, from 350 to 900, over the gap between Mq and Mt, so every mark above Mq adds 550 ÷ (Mt − Mq) points. In GATE 2026 CS that gap was 77.03 − 30 = 47.03 marks, so each mark was worth about 11.69 points, and 50 marks scored 350 + 20 × 550 ÷ 47.03 = 583.89.

So the score is a straight line through two points of the paper’s own results, and it changes from year to year and from paper to paper. Here is the line for GATE 2026 CS, where Mq was 30 and Mt was 77.03:

The line passes 350 at 30 marks and 900 at 77.03, crosses zero at about 0.07 marks, and the dashed stretch at 1000 is what the report prints above it. The program below implements the formula and its inverse and checks them against the report’s own numbers. Press Edit, put your own mock marks in place of both 50s in its first print line, and run it again:

"""The GATE score and qualifying marks (brochure section 8.1), checked against the official GATE 2026 report."""

S_Q, S_T = 350, 900  # the scores given to the qualifying marks and to the top candidates' mean


def qualifying(mean, sd):
    """General, OBC-NCL/EWS and SC/ST/PwD qualifying marks from the paper's mean and standard deviation."""
    general = max(25, min(40, mean + sd))
    return general, 0.9 * general, 2 * general / 3


def score(m, mq, mt):
    """The score of m marks: a straight line through (mq, 350) and (mt, 900)."""
    return S_Q + (S_T - S_Q) * (m - mq) / (mt - mq)


def marks_for(target, mq, mt):
    """The marks that give a target score: the same line, read the other way."""
    return mq + (target - S_Q) * (mt - mq) / (S_T - S_Q)


# Rows of the GATE 2026 report: Mt (mean of the top 0.1 % or top 10), mean, standard deviation, the published
# qualifying marks (general, OBC-NCL/EWS, SC/ST/PwD), their published scores, and the highest and lowest marks.
REPORT = {
    "CS": {"mt": 77.03, "mean": 18.51, "sd": 11.58, "q": (30, 27, 20), "qs": (350, 315, 233), "top": 92.57, "low": -19.32, "low_s": -227},
    "DA": {"mt": 72.01, "mean": 15.45, "sd": 11.0, "q": (26.4, 23.7, 17.5), "qs": (350, 317, 243), "top": 90.0, "low": -13.67, "low_s": -133},
}

cs = REPORT["CS"]
print(f"CS 2026: 50 marks score {score(50, 30, cs['mt']):.2f}; a score of 600 needs {marks_for(600, 30, cs['mt']):.2f} marks")
print()
print("check                          formula  report")
for paper, r in REPORT.items():
    mq = r["q"][0]
    for name, m, published in (("OBC-NCL/EWS", r["q"][1], r["qs"][1]), ("SC/ST/PwD", r["q"][2], r["qs"][2]), ("lowest mark", r["low"], r["low_s"])):
        print(f"{paper} {name:<12} {m:>7}       {score(m, mq, r['mt']):>8.2f}  {published:>5}")
    print(f"{paper} top mark     {r['top']:>7}       {score(r['top'], mq, r['mt']):>8.2f}   1000")
print()
for paper, r in REPORT.items():
    g, o, s = qualifying(r["mean"], r["sd"])
    print(f"{paper}: mean + SD = {r['mean'] + r['sd']:.2f}, so general {g:.2f}, OBC-NCL/EWS {o:.2f}, SC/ST/PwD {s:.2f}")
    print(f"    published: {r['q'][0]}, {r['q'][1]}, {r['q'][2]}")

CS 2026: 50 marks score 583.89; a score of 600 needs 51.38 marks

check                          formula  report
CS OBC-NCL/EWS       27         314.92    315
CS SC/ST/PwD         20         233.05    233
CS lowest mark   -19.32        -226.78   -227
CS top mark       92.57        1081.74   1000
DA OBC-NCL/EWS     23.7         317.44    317
DA SC/ST/PwD       17.5         242.68    243
DA lowest mark   -13.67        -133.19   -133
DA top mark        90.0        1116.94   1000

CS: mean + SD = 30.09, so general 30.09, OBC-NCL/EWS 27.08, SC/ST/PwD 20.06
    published: 30, 27, 20
DA: mean + SD = 26.45, so general 26.45, OBC-NCL/EWS 23.80, SC/ST/PwD 17.63
    published: 26.4, 23.7, 17.5

What the checks show:

• The formula reproduces the report. The category qualifying marks, 27 and 20 in CS and 23.7 and 17.5 in DA, give 314.92, 233.05, 317.44 and 242.68, which the report prints rounded as 315, 233, 317 and 243. The lowest marks, −19.32 in CS and −13.67 in DA, give the negative scores the report lists, −227 and −133.
• Scores can be negative. The FAQ says so too: any marks far enough below Mq give a score below zero. On the 2026 CS line, a mark of zero gives −0.84.
• The report stops at 1000. The formula gives 1081.74 for the top CS mark of 92.57 and 1116.94 for the top DA mark of 90, but the report lists 1000 as the highest score of both papers and calls scores “out of 1000”. Where the formula gives less than 1000 for a paper’s top mark, the report shows the formula’s value: Architecture and Planning’s top mark of 80.33 gives 966.67, and the report lists 967. The brochure itself states no cap, so read 1000 as what the report prints, not as a rule.

Inverting the line gives the marks a target score needs: 51.38 for 600 with the 2026 CS line. Those marks are only a guide for another year, because next year’s Mq and Mt come from next year’s paper.

Qualifying marks are the mean plus one SD, kept between 25 and 40

The general qualifying marks are

where μ is the mean and σ the standard deviation of the marks of everyone who appeared in the paper. The other categories use fixed ratios: 9/10 of Mq for OBC-NCL and EWS candidates, and 2/3 of Mq for SC, ST and PwD candidates. In words, add one standard deviation to the mean, then raise the result to 25 or lower it to 40 if it falls outside them. Step through GATE 2026 CS, and then two papers where the floor and the ceiling decide:

The floor and the ceiling both bite in practice: in GATE 2026, Chemistry’s μ + σ was 19.49, so its general qualifying marks were 25, while Architecture and Planning’s was 43.57, so its were 40.

The last block of the program’s output recomputes CS and DA from the report’s rounded mean and standard deviation and lands slightly above the published values: 30.09 against 30 for CS, and 26.45, 23.80 and 17.63 against 26.4, 23.7 and 17.5 for DA. The same check over all 36 rows of the report finds every published qualifying mark at the formula’s value or slightly below it, never above: at most 0.1 below for the general category and at most 0.17 below for the other two. The brochure does not say how these numbers are rounded, so take the published qualifying marks from the report or your scorecard, and use your own recomputation only to understand them.

Qualifying matters for two things. The scorecard: the FAQ issues one only to candidates whose marks reach the SC, ST and PwD qualifying marks of their paper. And admission: the brochure opens postgraduate admission with financial assistance to candidates who qualify, and each institute then sets its own rules on top.

Normalisation lets a mark from a harder session count for more

When too many candidates sit a paper for one session, it runs in several, each with its own question paper; in GATE 2026, CS ran in two sessions. Two papers are never exactly as hard as each other, so the brochure converts each candidate’s actual marks into normalised marks before the score is computed. For candidate j in session i:

• Mtg and Mti are the mean marks of the top 0.1 % of candidates, over all sessions and in session i.
• Mqg and Miq are the mean plus the standard deviation of the marks, over all sessions and in session i.

The formula slides and stretches each session’s marks so that its “mean plus one standard deviation” lands on the all-sessions value and its top 0.1 % mean lands on the all-sessions top mean. The fraction in front is the stretch: the gap between the two all-sessions values over the same gap in the session. That is fair only under one assumption, which the brochure states: the candidates in every session are equally able, because there are many of them, they are allotted to sessions at random and the sessions are of comparable size. Then any difference between the sessions’ marks is a difference between their papers.

The program below builds an invented two-session paper with exactly that property, 5,000 candidates per session of the same ability, where the first session’s paper is harder, and prints each session’s stretch:

"""GATE normalisation (brochure section 8.1) on an invented two-session paper: is a raw 40 or a raw 42 better?"""
import math
import random
import statistics

N = 5000  # candidates per session, so the top 0.1 % of a session is its best 5
rng = random.Random(2027)


def session(base, spread):
    """Marks for N candidates of the same spread of ability; `base` and `spread` say how hard the paper was."""
    return [max(-15.0, min(100.0, round(base + spread * rng.gauss(0, 1), 2))) for _ in range(N)]


hard = session(16, 11)  # session 1: a harder paper
easy = session(21, 12)  # session 2: an easier paper, the same kind of candidates


def top_mean(marks):
    """Mean marks of the top 0.1 % of candidates."""
    top = sorted(marks, reverse=True)[: math.ceil(len(marks) / 1000)]
    return statistics.fmean(top)


def mean_plus_sd(marks):
    return statistics.fmean(marks) + statistics.pstdev(marks)


everyone = hard + easy
mt_g, mq_g = top_mean(everyone), mean_plus_sd(everyone)


def stretch(marks):
    """How much the formula stretches the marks of the session `marks`: (Mt_g - Mq_g) / (Mt_i - Mq_i)."""
    return (mt_g - mq_g) / (top_mean(marks) - mean_plus_sd(marks))


def normalised(m, marks):
    """M' = (Mt_g - Mq_g) / (Mt_i - Mq_i) * (m - Mq_i) + Mq_g, with the statistics of the session `marks`."""
    return stretch(marks) * (m - mean_plus_sd(marks)) + mq_g


print("               top 0.1 % mean   mean + SD   stretch")
print(f"session 1      {top_mean(hard):>14.2f}   {mean_plus_sd(hard):>9.2f}   {stretch(hard):>7.3f}")
print(f"session 2      {top_mean(easy):>14.2f}   {mean_plus_sd(easy):>9.2f}   {stretch(easy):>7.3f}")
print(f"both sessions  {mt_g:>14.2f}   {mq_g:>9.2f}")
print()
for raw, marks, name in ((40, hard, "session 1"), (42, easy, "session 2")):
    above = raw - mean_plus_sd(marks)
    share = sum(m <= raw for m in marks) / len(marks)
    print(f"raw {raw} in {name}: {above:.2f} above its mean + SD, stretched to {stretch(marks) * above:.2f},"
          f" so {mq_g:.2f} + {stretch(marks) * above:.2f} = {normalised(raw, marks):.2f}")
    print(f"    {share:.1%} of {name} scored {raw} or less")

               top 0.1 % mean   mean + SD   stretch
session 1               53.64       26.82     1.226
session 2               66.13       33.09     0.996
both sessions           63.16       30.26

raw 40 in session 1: 13.18 above its mean + SD, stretched to 16.17, so 30.26 + 16.17 = 46.43
    98.5% of session 1 scored 40 or less
raw 42 in session 2: 8.91 above its mean + SD, stretched to 8.87, so 30.26 + 8.87 = 39.13
    95.9% of session 2 scored 42 or less

The candidate with 40 in the harder session ends up with 46.43 normalised marks, the one with 42 in the easier session with 39.13. The line under each says why: 98.5 % of the first session scored 40 or less, but only 95.9 % of the second scored 42 or less, so the 40 was the stronger result. Normalisation turns that comparison into marks. Step through the formula on the same numbers:

Each session gets one straight line of its own, so inside a session the order of the candidates never changes; only marks from different sessions move against each other.

The official distributions describe one year, not next year’s ranks

The report also says how many candidates scored what. The program below reads its marks table for CS and DA:

"""What the GATE 2026 report's marks table says about the CS and DA papers, as shares of the candidates who appeared."""

# Candidates who appeared, by marks: below 0, then 0-10, 10-20, ..., 80-90 and 90-100 (section 5 of the report).
BINS = ["<0", "0-10", "10-20", "20-30", "30-40", "40-50", "50-60", "60-70", "70-80", "80-90", "90-100"]
APPEARED = {
    "CS": [6243, 39077, 83614, 52475, 19271, 6685, 2485, 875, 253, 38, 4],
    "DA": [2121, 21175, 26668, 12272, 4595, 1644, 556, 173, 34, 3, 1],
}
QUALIFIED = {"CS": 40661, "DA": 12849}

for paper, counts in APPEARED.items():
    total = sum(counts)
    print(f"{paper}: {total:,} appeared, {QUALIFIED[paper]:,} qualified ({QUALIFIED[paper] / total:.1%})")
    print(f"    below 0 marks: {counts[0] / total:.2%}")
    for start, label in ((4, "30"), (5, "40"), (6, "50"), (7, "60")):
        print(f"    {label} marks or more: {sum(counts[start:]) / total:.2%}")

CS: 211,020 appeared, 40,661 qualified (19.3%)
    below 0 marks: 2.96%
    30 marks or more: 14.03%
    40 marks or more: 4.90%
    50 marks or more: 1.73%
    60 marks or more: 0.55%
DA: 69,242 appeared, 12,849 qualified (18.6%)
    below 0 marks: 3.06%
    30 marks or more: 10.12%
    40 marks or more: 3.48%
    50 marks or more: 1.11%
    60 marks or more: 0.30%

In GATE 2026, 14.03 % of the CS candidates who appeared scored 30 or more, 4.90 % scored 40 or more and 1.73 % scored 50 or more, while 2.96 % ended below zero. More candidates qualified (19.3 %) than reached 30, because the OBC-NCL, EWS, SC, ST and PwD qualifying marks were lower. DA’s shares were lower at every level: 10.12 % at 30 or more and 1.11 % at 50 or more.

These are facts about one year’s papers. They do not give next year’s ranks or cut-offs, which depend on next year’s paper, its statistics and each institute’s own rules, and MySmartCoPilot does not predict ranks, cut-offs or admissions. Use them for what they are good at: a sense of how hard the paper was, and how much a few marks move you when most of the field is between 10 and 30.

Practise: the score from marks, then the whole lesson

Write the three formulas of this lesson as functions. The sample tests use the GATE 2026 CS and Architecture and Planning statistics, the floor of 25, a negative score and the uncapped top mark:

qualifying_marks(18.51, 11.58)    # (30.09, 27.081, 20.06), up to rounding
gate_score(50, 30, 77.03)         # 583.89, up to rounding
marks_for_score(600, 30, 77.03)   # 51.38, up to rounding

def qualifying_marks(mean, sd):
    """(general, OBC-NCL/EWS, SC/ST/PwD) qualifying marks of a paper with this mean and standard deviation."""
    # Replace this line with your code.
    return (0, 0, 0)


def gate_score(m, mq, mt):
    """The GATE score of m marks, for qualifying marks mq and top candidates' mean mt."""
    # Replace this line with your code.
    return 0


def marks_for_score(score, mq, mt):
    """The marks that give this GATE score."""
    # Replace this line with your code.
    return 0

from gate import gate_score, marks_for_score, qualifying_marks


def close(a, b):
    return abs(a - b) < 0.01


def test_qualifying_cs():
    """GATE 2026 CS: mean 18.51, standard deviation 11.58"""
    general, obc_ews, sc_st_pwd = qualifying_marks(18.51, 11.58)
    assert close(general, 30.09) and close(obc_ews, 27.081) and close(sc_st_pwd, 20.06)


def test_qualifying_floor():
    """mean plus standard deviation below 25 gives 25"""
    general, obc_ews, sc_st_pwd = qualifying_marks(10.53, 8.96)
    assert close(general, 25) and close(obc_ews, 22.5) and close(sc_st_pwd, 16.667)


def test_qualifying_cap():
    """mean plus standard deviation above 40 gives 40 (GATE 2026 AR: 30.13 and 13.44)"""
    general, obc_ews, sc_st_pwd = qualifying_marks(30.13, 13.44)
    assert close(general, 40) and close(obc_ews, 36) and close(sc_st_pwd, 26.667)


def test_score_at_the_two_points():
    """350 at the qualifying marks and 900 at the top candidates' mean"""
    assert close(gate_score(30, 30, 77.03), 350) and close(gate_score(77.03, 30, 77.03), 900)


def test_score_between():
    """50 marks with the GATE 2026 CS statistics"""
    assert close(gate_score(50, 30, 77.03), 583.89)


def test_score_negative():
    """the lowest CS mark of GATE 2026 gives a negative score"""
    assert close(gate_score(-19.32, 30, 77.03), -226.78)


def test_score_not_capped():
    """the brochure's formula goes above 1000"""
    assert close(gate_score(92.57, 30, 77.03), 1081.74)


def test_marks_for_score():
    """a score of 600 needs 51.38 marks"""
    assert close(marks_for_score(600, 30, 77.03), 51.38)


def test_round_trip():
    """the marks for a score give that score back"""
    assert close(gate_score(marks_for_score(750, 26.4, 72.01), 26.4, 72.01), 750)

Then practise one question at a time. Your weakest idea comes up first, and right answers bring harder questions:

Interview questions

What do Mq and Mt mean in the GATE score formula? (warm-up)

Mq is the general category’s qualifying marks for the paper: the mean plus one standard deviation of all candidates’ marks, kept between 25 and 40. Mt is the mean marks of the top 0.1 % of the candidates who appeared, or of the top 10 if that is more, counted over all sessions. The formula gives a score of 350 to Mq and 900 to Mt and joins them with a straight line, so a mark’s score depends on how that year’s candidates did in that paper. In GATE 2026 CS, Mq was 30 and Mt was 77.03, so 50 marks scored 583.89.

Key takeaways

• The score is a straight line through (Mq, 350) and (Mt, 900): S = 350 + 550 (M − Mq) / (Mt − Mq). It can be negative, and the 2026 report prints 1000 wherever the formula goes above it.
• Mq = max(25, min(40, mean + standard deviation)); OBC-NCL and EWS candidates need 9/10 of it, SC, ST and PwD candidates 2/3. Use the published values: in 2026 they sat up to 0.1 below a recomputation for the general category and up to 0.17 below for the others.
• Multi-session papers are normalised first, assuming every session’s candidates are equally able, so a mark in a harder session counts for more, while the order inside a session never changes.
• With GATE 2026 CS, 50 marks gave 583.89 and a score of 600 needed 51.38 marks. Another year’s line will differ.
• Distributions describe a past paper. They are not rank or cut-off predictions.