Modular Arithmetic Basics in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is modular arithmetic?

Modular arithmetic is a way of doing math where numbers wrap around after reaching a certain value called the modulus. Think of a clock where after 12 comes 1 again.

beginner

What does the expression a % m mean?

It means the remainder when number a is divided by m. For example, 14 % 5 = 4 because 14 divided by 5 leaves remainder 4.

beginner

How do addition and multiplication work in modular arithmetic?

You add or multiply numbers normally, then take the remainder after dividing by the modulus. For example, with modulus 7: (3 + 5) % 7 = 1, and (3 * 5) % 7 = 1.

intermediate

Why is modular arithmetic useful in programming?

It helps keep numbers within a fixed range, avoids overflow, and is used in hashing, cryptography, and cyclic structures like circular buffers.

intermediate

What is the result of (a % m + b % m) % m compared to (a + b) % m?

They are equal. Modular addition is consistent: adding remainders first or adding then taking remainder gives the same result.

What is 17 % 5?

A 3

B 5

C 4

D 2

17 divided by 5 is 3 with remainder 2, so 17 % 5 = 2.

If modulus is 10, what is (7 + 8) % 10?

A 7

B 15

C 5

D 8

7 + 8 = 15, and 15 % 10 = 5.

Which of these is true for modular multiplication?

A (a * b) % m = ((a % m) * (b % m)) % m

B (a * b) % m = (a + b) % m

C (a * b) % m = (a % m) + (b % m)

D (a * b) % m = a % b

Modular multiplication distributes over modulus like addition does.

Why do numbers 'wrap around' in modular arithmetic?

A Because we only care about the remainder after division by modulus

B Because numbers get smaller automatically

C Because addition is not allowed

D Because multiplication is ignored

Wrapping happens because we take remainder after division by the modulus.

Which real-life example best illustrates modular arithmetic?

A Measuring weight on a scale

B A clock showing hours

C Counting money in a wallet

D Measuring temperature

A clock resets after 12 hours, just like numbers wrap around in modular arithmetic.

Explain modular arithmetic and how addition works with an example.

Think about how a clock resets after 12 hours.

Describe why modular arithmetic is useful in programming and give two examples.

Consider problems where numbers must stay small or repeat in cycles.

Practice

1. What is the result of 7 % 3 in modular arithmetic?

easy

A. 2

B. 1

C. 3

D. 0

Solution

1. Step 1: Understand the modulo operation

   The modulo operator (%) gives the remainder when the first number is divided by the second.

2. Step 2: Calculate 7 % 3

   7 divided by 3 is 2 with a remainder of 1, but since 7 = 3*2 + 1, the remainder is 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   7 % 3 = 1 [OK]

Hint: Modulo gives remainder after division [OK]

Common Mistakes:

• Confusing remainder with quotient
• Thinking modulo returns division result
• Mixing up dividend and divisor

2. Which of the following is the correct TypeScript syntax to compute the remainder of a divided by b?

easy

A. let result = a % b;

B. let result = a / b;

C. let result = a mod b;

D. let result = a & b;

Solution

1. Step 1: Recall TypeScript modulo operator

   In TypeScript, the modulo operator is represented by the percent sign (%).

2. Step 2: Identify correct syntax

   let result = a % b; uses a % b, which correctly computes the remainder.

3. Final Answer:

   let result = a % b; -> Option A

4. Quick Check:

   Modulo operator is % in TypeScript [OK]

Hint: Use % for modulo in TypeScript [OK]

Common Mistakes:

• Using / instead of %
• Using 'mod' keyword which doesn't exist
• Using bitwise & operator by mistake

3. What is the output of the following TypeScript code?

const a = 14;
const b = 5;
console.log(a % b);

medium

A. 3

B. 4

C. 2

D. 0

Solution

1. Step 1: Calculate 14 % 5

   Divide 14 by 5: 5 * 2 = 10, remainder is 14 - 10 = 4.

2. Step 2: Confirm output

   The console.log prints the remainder, which is 4.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   14 % 5 = 4 [OK]

Hint: Modulo is remainder after division [OK]

Common Mistakes:

• Calculating quotient instead of remainder
• Mixing up operands order
• Assuming modulo returns division result

4. Identify the error in this TypeScript code snippet that tries to compute modulo:

function mod(a: number, b: number): number {
  return a % b;
}

console.log(mod(10, 0));

medium

A. Syntax error due to missing semicolon

B. No error, outputs 0

C. Runtime error: division by zero

D. Returns NaN without error

Solution

1. Step 1: Analyze modulo with zero divisor

   In TypeScript/JavaScript, modulo by zero returns NaN and does NOT throw a runtime error.

2. Step 2: Understand error behavior

   Calling mod(10, 0) computes 10 % 0 which is NaN, and console.log prints NaN.

3. Final Answer:

   Returns NaN without error -> Option D

4. Quick Check:

   10 % 0 = NaN [OK]

Hint: Modulo by zero returns NaN in TypeScript [OK]

Common Mistakes:

• Thinking modulo by zero causes runtime error
• Assuming modulo by zero returns 0
• Confusing with languages that raise exceptions

5. You want to find the remainder when the sum of two large numbers a = 123456789 and b = 987654321 is divided by m = 1000. Which expression correctly uses modular arithmetic to compute (a + b) % m without overflow?

hard

A. (a + b) % m

B. a % (b % m)

C. (a % m + b % m) % m

D. (a % b) + (b % m)

Solution

1. Step 1: Understand modular addition property

   Modular arithmetic allows splitting sums: (a + b) % m = ((a % m) + (b % m)) % m.

2. Step 2: Apply property to avoid overflow

   Computing (a % m + b % m) % m prevents large intermediate sums and overflow.

3. Step 3: Check other options

   (a + b) % m risks overflow; B and D misuse modulo operations.

4. Final Answer:

   (a % m + b % m) % m -> Option C

5. Quick Check:

   Use modular addition property [OK]

Hint: Add remainders then modulo again to avoid overflow [OK]

Common Mistakes:

• Directly adding large numbers before modulo
• Misusing modulo on operands incorrectly
• Ignoring overflow in large sums