top of page

ISS 2016 Statistics Paper-1 Solution: Question 68 (Operator Precedence in Boolean Expressions)

Oct 29
6 min read

We're continuing our question-by-question walkthrough of the ISS Statistics Paper-1 previous year papers, and this post picks up right where the last one left off. Today we're tackling a question that trips up a lot of aspirants not because the underlying rule is hard, but because it's rarely explained slowly enough to actually stick.


Quick Summary


  • Topic:Operator precedence in relational and logical expressions (Computer Fundamentals)

  • Question Reference:ISS 2016, Statistics Paper-1, Question 68

  • Correct Answer:Option (d) — ((X > (P + Q))) AND (I = J)

The Question As Asked

Here is the question exactly as it appears in the paper:


68. Computation of X > P + Q AND I = J is equivalent to


  • (a) ((X > P) + Q) AND (I = J)

  • (b) (X > P) + (Q AND I = J)

  • (c) (X > P) + (Q AND I) = J

  • (d) ((X > (P + Q))) AND (I = J)

Step 1: What Is Actually Being Tested Here

At first glance this looks like a trick question about brackets, but it's really a question about operator precedence — the fixed order in which different kinds of operators get evaluated when an expression has no explicit parentheses to guide you. In computing (and this carries over directly into how conditions are written when processing statistical data), every operator belongs to a "family," and each family has a rank. When you see a raw expression like X > P + Q AND I = J, you are not free to evaluate it left to right. You must first sort out which operators go first, exactly the way you were taught "multiplication before addition" in school arithmetic, just extended to cover comparisons and logic as well.

Step 2: List the Operators Present and Their Ranks

Let's list out every operator that appears in the expression: greater-than (>), plus (+), AND, and equals (=). These fall into three different families, and the standard precedence order used across most programming and computing conventions (and the one this exam is testing) is, from highest priority to lowest:


  1. Arithmetic operators — multiplication, division, addition, subtraction (so the + here)

  2. Relational operators — greater than, less than, equal to, and so on (so > and = here)

  3. Logical NOT

  4. Logical AND (so AND here)

  5. Logical OR


The rule to internalise is simple: arithmetic always gets "wrapped up" first, because its result is just a number, and relational operators need numbers on both sides to compare. Only once the comparisons produce their own results (true or false) can the logical operators like AND step in to combine those results.

Step 3: Apply the Precedence, One Operator at a Time

Now let's walk through the original expression and resolve it piece by piece, exactly as the computer (or your own mental evaluator) would.


3a. Start with arithmetic.The only arithmetic operator in the whole expression is the + between P and Q. Since arithmetic outranks everything else here, this is evaluated first, in isolation, as if it were sitting inside its own brackets: P + Q is treated as a single computed value, (P + Q).


So the expression effectively becomes: X > (P + Q) AND I = J


3b. Move to relational operators.There are two relational operators left: > and =. Relational operators outrank AND, so both comparisons are resolved next, independently of each other, each producing its own true/false result:


  • X > (P + Q) becomes one self-contained comparison

  • I = J becomes a second, completely separate comparison


Notice that the = between I and J has no connection at all to the > comparison — they are two independent relational tests sitting on either side of the AND, not one long chain.


3c. Finally, apply AND.AND is the lowest-ranked operator remaining, so it acts last, simply joining the two already-resolved comparisons together: (X > (P + Q)) AND (I = J)


Pro Tip: The fastest way to avoid getting tangled up in a question like this under exam pressure is to physically circle each operator in the expression and label it with its family (A for arithmetic, R for relational, L for logical) before you touch any option. Once the labels are down, the correct bracketing almost writes itself — this is exactly the kind of mechanical, no-guesswork habit that's usually drilled repeatedly in a proper computer fundamentals class until it becomes automatic rather than something you have to reason out fresh every time.

Step 4: Eliminate the Wrong Options

It helps to see exactly why the distractors fail, since ISS examiners design them to catch very specific, common mistakes:


  • Option (a)— ((X > P) + Q) AND (I = J) — incorrectly lets the relational > happen before the arithmetic +, which inverts the actual precedence order.

  • Option (b)— (X > P) + (Q AND I = J) — tries to add a logical AND result to a plain value using +, which is not even a meaningful operation; it mixes arithmetic and logical operators in a way precedence rules never allow.

  • Option (c)— (X > P) + (Q AND I) = J — compounds the same mistake as (b) and then adds a dangling = J at the very end, which doesn't correspond to anything in the original expression.

  • Option (d)— ((X > (P + Q))) AND (I = J) — correctly applies arithmetic first, then both relational comparisons independently, then AND last. This matches our derivation exactly.

Final Answer

The correct answer is option (d): ((X > (P + Q))) AND (I = J). This matches the official ISS 2016 Statistics Paper-1 answer key, which also lists D for Question 68, so our step-by-step derivation and the official key are in full agreement here.

Why This Question Matters

Operator precedence questions appear repeatedly across ISS Paper-1's computer fundamentals section, and they are deliberately designed to be solvable in under a minute once you know the rule — which also means they're the fastest marks on the entire paper if you've internalised the order correctly, and some of the costliest if you haven't. Beyond the exam itself, this exact logic underlies how conditions are written in statistical software and query languages when filtering or subsetting data, so getting comfortable with it now pays off well beyond this one paper. Sunrise Classes students tend to drill this kind of labelling exercise on several past-year questions in one sitting, which is usually what turns it from a slow, careful process into an instant reflex.

Frequently Asked Questions

What exactly is operator precedence?

Operator precedence is the fixed set of rules that decides which operator in an expression gets evaluated first when there are no parentheses to make the order explicit. It works the same way arithmetic precedence does in ordinary maths — multiplication before addition — just extended to cover comparisons (relational operators) and logic (AND, OR, NOT) as well.

Why does addition get evaluated before a comparison like greater-than?

Because a relational operator like > needs two finished values to compare — it cannot compare "P + Q" as a half-finished expression. The arithmetic has to be completed first so that the relational operator has a single number on each side to work with.

Why does AND get evaluated after both relational comparisons, rather than in between them?

AND is a logical operator, and logical operators sit at the bottom of the precedence hierarchy because they combine results, not raw values. Both X > (P+Q) and I = J have to resolve into their own true/false outcomes before AND has anything meaningful to combine.

Is this precedence order the same across all programming languages?

The broad hierarchy — arithmetic, then relational, then logical NOT, then AND, then OR — is close to universal across mainstream languages and pseudocode conventions, including the ones ISS computer fundamentals questions are typically modelled on. Minor details can differ between languages, but for exam purposes this standard order is the one to memorise.

How should I prepare for this type of question in ISS Paper-1?

Practice writing out the precedence ladder from memory until it's instant, then work through several raw, unbracketed expressions by labelling each operator's family before attempting to group it — the method shown in this post. Repetition on past-paper questions like this one is the most reliable way to make the process fast rather than effortful.

What's the easiest way to remember the order of arithmetic, relational, NOT, AND, OR?

Think of it as moving from "concrete to abstract" — arithmetic produces plain numbers, relational operators turn those numbers into true/false judgments, and logical operators then combine those judgments, with NOT (which flips a single judgment) naturally outranking AND and OR (which combine two).


If any step above felt unclear, drop your doubt in the comments and we'll work through it together — and if you found this useful, pass it along to a fellow ISS aspirant who's working through the same paper.

Recent Posts

See All

Comments


bottom of page