Modular Arithmetic Basics in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to compute the remainder of 17 divided by 5.

DSA Go

result := 17 [1] 5
fmt.Println(result)

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

A+

B*

C%

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' or '-' instead of modulo operator.

Using '*' which multiplies instead of modulo.

The '%' operator gives the remainder of division, so 17 % 5 equals 2.

2fill in blank

medium

Complete the code to check if a number n is divisible by 3 using modular arithmetic.

DSA Go

if n [1] 3 == 0 {
    fmt.Println("Divisible by 3")
}

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

A+

B-

C/

D%

Attempts:

3 left

💡 Hint

Common Mistakes

Using '/' which gives quotient, not remainder.

Using '+' or '-' which do not check divisibility.

Using '%' checks the remainder. If n % 3 == 0, n is divisible by 3.

3fill in blank

hard

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

DSA Go

result := (a [1] b) % m
fmt.Println(result)

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

A+

B*

C-

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '*' which multiplies instead of adds.

Using '/' which divides and causes error.

To add a and b before modulo, use '+'. Multiplying or dividing is incorrect here.

4fill in blank

hard

Fill both blanks to create a map of numbers to their squares modulo 10 for numbers 1 to 5.

DSA Go

squares := map[int]int{}
for i := 1; i [1] 5; i++ {
    squares[i] = (i [2] i) % 10
}
fmt.Println(squares)

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

A<=

B*

C<

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' excludes 5 from the loop.

Using '+' instead of '*' for squaring.

Use '<=' to include 5 in the loop and '*' to multiply i by itself.

5fill in blank

hard

Fill all three blanks to create a map of uppercase letters to their ASCII codes modulo 26 for letters A to E.

DSA Go

codes := map[rune]int{}
for ch := 'A'; ch [1] 'E'; ch++ {
    codes[ch] = (int(ch) [2] int('A')) [3] 26
}
fmt.Println(codes)

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

A<=

B-

C%

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' excludes 'E' from loop.

Using '+' instead of '-' for normalization.

Using '/' instead of '%' for modulo.

Use '<=' to include 'E', subtract 'A' to get zero-based index, then modulo 26.

Practice

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

easy

A. 0

B. 2

C. 1

D. 3

Solution

1. Step 1: Understand the modulus operation

   The modulus 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, so 7 % 3 = 1.

3. Final Answer:

   1 -> Option C

4. Quick Check:

   7 % 3 = 1 [OK]

Hint: Modulus gives remainder after division [OK]

Common Mistakes:

• Confusing modulus with division
• Using quotient instead of remainder
• Mixing up operands order

2. Which of the following is the correct syntax to compute the modulus of two integers a and b in Go?

easy

A. mod := a % b

B. mod := a mod b

C. mod := a %% b

D. mod := a mod(b)

Solution

1. Step 1: Recall Go syntax for modulus

   In Go, the modulus operator is the percent sign (%) used between two integers.

2. Step 2: Identify correct syntax

   mod := a % b uses a % b, which is the correct way to compute modulus in Go.

3. Final Answer:

   mod := a % b -> Option A

4. Quick Check:

   Go uses % for modulus [OK]

Hint: Use % operator for modulus in Go [OK]

Common Mistakes:

• Using 'mod' keyword instead of %
• Double percent signs %%
• Using function call syntax for modulus

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

package main
import "fmt"
func main() {
    a := 14
    b := 5
    fmt.Println(a % b)
}

medium

A. 2

B. 4

C. 3

D. 0

Solution

1. Step 1: Understand the code variables

   Variable a is 14 and b is 5.

2. Step 2: Calculate 14 % 5

   14 divided by 5 is 2 with remainder 4, so output is 4.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   14 % 5 = 4 [OK]

Hint: Divide and find remainder for modulus [OK]

Common Mistakes:

• Using division result instead of remainder
• Confusing operands order
• Misreading variable values

4. Find the error in this Go code snippet that tries to compute modulus:

package main
import "fmt"
func main() {
    var a, b int = 10, 3
    result := a mod b
    fmt.Println(result)
}

medium

A. Missing import for modulus package

B. fmt.Println syntax error

C. Variables a and b not declared

D. Using 'mod' instead of '%' operator

Solution

1. Step 1: Check modulus operator usage

   The code uses a mod b, but Go does not have a 'mod' keyword.

2. Step 2: Correct operator in Go

   Go uses the percent sign (%) for modulus, so it should be a % b.

3. Final Answer:

   Using 'mod' instead of '%' operator -> Option D

4. Quick Check:

   Modulus in Go uses % [OK]

Hint: Use % operator, not 'mod' keyword [OK]

Common Mistakes:

• Using 'mod' keyword
• Assuming modulus needs import
• Incorrect variable declaration assumptions

5. You want to find the remainder when the sum of two large numbers a = 123456789 and b = 987654321 is divided by 1000. Which expression correctly uses modular arithmetic to compute this efficiently in Go?

hard

A. (a % 1000 + b % 1000) % 1000

B. (a + b) / 1000

C. a % 1000 + b % 1000

D. a + b % 1000

Solution

1. Step 1: Understand modular addition property

   Modular arithmetic allows (a + b) % m = ((a % m) + (b % m)) % m to avoid large sums.

2. Step 2: Apply property to given numbers

   Compute (a % 1000 + b % 1000) % 1000 to get remainder without overflow.

3. Final Answer:

   (a % 1000 + b % 1000) % 1000 -> Option A

4. Quick Check:

   (a + b) % 1000 = ((a % 1000) + (b % 1000)) % 1000 [OK]

Hint: Use modular addition to avoid big sums [OK]

Common Mistakes:

• Adding remainders without final modulus
• Not applying modulus before addition
• Misplacing parentheses