Modular Arithmetic Basics in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Modular Addition

What is the output of the following TypeScript code that performs modular addition?

DSA Typescript

const a = 17;
const b = 23;
const mod = 10;
const result = (a + b) % mod;
console.log(result);

A 1

B 5

C 0

D 10

💡 Hint

Remember to add first, then take the remainder when divided by the modulus.

17 + 23 = 40. 40 % 10 = 0. The output is 0.

❓ Predict Output

intermediate

Output of Modular Multiplication

What is the output of this TypeScript code that calculates modular multiplication?

DSA Typescript

const x = 7;
const y = 8;
const mod = 12;
const result = (x * y) % mod;
console.log(result);

A 8

B 9

C 4

D 2

💡 Hint

Multiply first, then take the remainder after dividing by the modulus.

7 * 8 = 56. 56 % 12 = 8 (56 - 4*12 = 56 - 48 = 8). The output is 8.

🧠 Conceptual

advanced

Understanding Modular Inverse

Which of the following statements correctly describes the modular inverse of a number 'a' modulo 'm'?

A A number 'x' such that (a * x) % m = 0, only if 'a' divides 'm'.

B A number 'x' such that (a * x) % m = 1, only if 'a' and 'm' are coprime.

C A number 'x' such that (a - x) % m = 1, only if 'a' is even.

D A number 'x' such that (a + x) % m = 0, for any 'a' and 'm'.

💡 Hint

Think about what multiplying by the modular inverse achieves.

The modular inverse of 'a' modulo 'm' is a number 'x' such that (a * x) % m = 1. This exists only if 'a' and 'm' share no common factors other than 1 (coprime).

🔧 Debug

advanced

Identify the Error in Modular Exponentiation Code

What error will this TypeScript code produce when computing modular exponentiation?

DSA Typescript

function modExp(base: number, exponent: number, mod: number): number {
  let result = 1;
  for (let i = 0; i < exponent; i++) {
    result = (result * base) % mod;
  }
  return result;
}
console.log(modExp(2, -3, 5));

A Returns 1, ignoring negative exponent.

B Returns 0 due to modulo operation.

C Runs infinite loop because exponent is negative.

D Returns NaN due to negative exponent usage.

💡 Hint

Check how the loop behaves with a negative exponent.

The loop runs from 0 to exponent-1. If exponent is negative, the loop does not run at all, so result remains 1.

🚀 Application

expert

Number of Distinct Remainders

Given an array of integers and a modulus 'm', how many distinct remainders can be produced by taking each element modulo 'm'?

DSA Typescript

const arr = [12, 25, 7, 14, 30];
const m = 10;
const remainders = new Set<number>();
for (const num of arr) {
  remainders.add(num % m);
}
console.log(remainders.size);

A 4

B 3

C 2

D 5

💡 Hint

Calculate each remainder and count unique values.

Remainders: 12%10=2, 25%10=5, 7%10=7, 14%10=4, 30%10=0. Unique: {0,2,4,5,7} — 5 distinct.

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