Modular Arithmetic Basics in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to compute the remainder of 10 divided by 3 using modular arithmetic.

DSA Typescript

const result = 10 [1] 3;
console.log(result);

Drag options to blanks, or click blank then click option'

A*

B/

C%

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using division operator instead of modulo

Using multiplication or addition by mistake

The % operator gives the remainder after division, which is the core of modular arithmetic.

2fill in blank

medium

Complete the code to check if a number is even using modular arithmetic.

DSA Typescript

function isEven(num: number): boolean {
  return num [1] 2 === 0;
}

Drag options to blanks, or click blank then click option'

A/

B-

C*

D%

Attempts:

3 left

💡 Hint

Common Mistakes

Using division instead of modulo

Using multiplication or subtraction

Using % 2 checks the remainder when dividing by 2. If remainder is 0, the number is even.

3fill in blank

hard

Fix the error in the code to correctly compute (a + b) mod m.

DSA Typescript

function modAdd(a: number, b: number, m: number): number {
  return (a + b) [1] m;
}

Drag options to blanks, or click blank then click option'

A%

B/

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using division instead of modulo

Using multiplication or subtraction

The modulo operator % is needed to get the remainder after addition, ensuring the result stays within the modulus.

4fill in blank

hard

Fill both blanks to compute (a * b) mod m correctly.

DSA Typescript

function modMultiply(a: number, b: number, m: number): number {
  return (a [1] b) [2] m;
}

Drag options to blanks, or click blank then click option'

A*

B%

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the order of operations

Using addition or subtraction instead of multiplication

First multiply a and b using *, then apply modulo % to keep the result within bounds.

5fill in blank

hard

Fill all three blanks to create a function that computes (a - b) mod m correctly, handling negative results.

DSA Typescript

function modSubtract(a: number, b: number, m: number): number {
  const diff = (a [1] b) [2] m;
  return (diff [3] m) [2] m;
}

Drag options to blanks, or click blank then click option'

A-

B%

C+

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Not handling negative modulo results

Using multiplication or wrong operators

Subtract b from a using -, then modulo with %. If the result is negative, add m to keep it positive.

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