Modular Arithmetic Basics in DSA Rust - Time & Space Complexity

Time Complexity: Modular Arithmetic Basics

O(1)

Understanding Time Complexity

We want to understand how long modular arithmetic operations take as numbers get bigger.

How does the time to compute remainders or modular sums grow with input size?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn mod_add(a: u64, b: u64, m: u64) -> u64 {
    (a % m + b % m) % m
}

fn mod_mul(a: u64, b: u64, m: u64) -> u64 {
    ((a % m) * (b % m)) % m
}

This code performs modular addition and multiplication, returning results within a fixed range.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Single modular arithmetic operations (remainder and multiplication).
• How many times: Each function runs once per call, no loops or recursion inside.

How Execution Grows With Input

Each modular operation takes roughly the same time regardless of input size because the CPU handles fixed-size numbers.

Input Size (n)	Approx. Operations
10	3 modular operations
100	3 modular operations
1000	3 modular operations

Pattern observation: The number of operations stays constant no matter how big the numbers are.

Final Time Complexity

Time Complexity: O(1)

This means the time to do modular addition or multiplication does not grow with input size; it stays constant.

Common Mistake

[X] Wrong: "Modular arithmetic takes longer as numbers get bigger because the numbers are larger."

[OK] Correct: The operations use fixed-size integers handled by the processor, so time stays the same regardless of number size within that limit.

Interview Connect

Understanding that modular arithmetic operations run in constant time helps you reason about algorithms that use them, like hashing or cryptography, making your solutions efficient and reliable.

Self-Check

"What if we used very large numbers beyond fixed-size integers, like big integers? How would the time complexity change?"

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 after division of the first number by the second.

2. Step 2: Calculate 7 modulo 3

   7 divided by 3 is 2 with a remainder of 1, so 7 % 3 = 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   7 % 3 = 1 [OK]

Hint: Modulo gives remainder after division [OK]

Common Mistakes:

• Confusing modulo with division
• Using 3 instead of remainder
• Thinking modulo returns quotient

2. Which of the following is the correct Rust syntax to compute the remainder of 15 divided by 4?

easy

A. let result = 15 / 4;

B. let result = 15 mod 4;

C. let result = 15 % 4;

D. let result = 15 rem 4;

Solution

1. Step 1: Recall Rust modulo syntax

   In Rust, the modulo operator is the percent sign (%), not 'mod' or 'rem'.

2. Step 2: Identify correct syntax

   let result = 15 % 4; uses % correctly: let result = 15 % 4;

3. Final Answer:

   let result = 15 % 4; -> Option C

4. Quick Check:

   Rust uses % for modulo [OK]

Hint: Use % operator for modulo in Rust [OK]

Common Mistakes:

• Using 'mod' keyword incorrectly
• Using division operator instead of modulo
• Using 'rem' which is invalid syntax

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

fn main() {
    let a = 10;
    let b = 6;
    let c = (a + b) % 7;
    println!("{}", c);
}

medium

A. 4

B. 2

C. 3

D. 1

Solution

1. Step 1: Calculate sum inside parentheses

   a + b = 10 + 6 = 16.

2. Step 2: Compute modulo 7 of the sum

   16 % 7 = 2 (because 7 * 2 = 14, remainder 2).

3. Step 3: Check printed output

   The code prints the value of c, which is 2.

4. Final Answer:

   2 -> Option B

5. Quick Check:

   (10 + 6) % 7 = 2 [OK]

Hint: Calculate sum first, then modulo [OK]

Common Mistakes:

• Modulo before addition
• Wrong remainder calculation
• Confusing modulo with division

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

fn main() {
    let x = 20;
    let y = 0;
    let z = x % y;
    println!("{}", z);
}

medium

A. Division by zero error at runtime

B. Syntax error: % operator not allowed

C. Variable y is not initialized

D. No error, code runs fine

Solution

1. Step 1: Analyze modulo operation with zero divisor

   Modulo by zero is undefined and causes a runtime error in Rust.

2. Step 2: Identify error type

   The code will compile but panic at runtime due to division by zero.

3. Final Answer:

   Division by zero error at runtime -> Option A

4. Quick Check:

   Modulo by zero causes runtime panic [OK]

Hint: Never modulo by zero; causes runtime panic [OK]

Common Mistakes:

• Thinking it's a syntax error
• Ignoring zero divisor
• Assuming code runs fine

5. You want to compute (a * b) % m for very large integers a and b in Rust without overflow. Which approach is best?

hard

A. Compute a * b first, then modulo m

B. Convert numbers to strings and then modulo

C. Use floating point multiplication and then modulo

D. Use modular multiplication: ((a % m) * (b % m)) % m

Solution

1. Step 1: Understand overflow risk

   Multiplying large integers directly can overflow before modulo is applied.

2. Step 2: Apply modular multiplication property

   Using ((a % m) * (b % m)) % m keeps intermediate values small and avoids overflow.

3. Step 3: Evaluate other options

   Compute a * b first, then modulo m risks overflow; options B and C are invalid or inefficient.

4. Final Answer:

   Use modular multiplication: ((a % m) * (b % m)) % m -> Option D

5. Quick Check:

   (a * b) % m = ((a % m) * (b % m)) % m [OK]

Hint: Apply modulo before multiplication to avoid overflow [OK]

Common Mistakes:

• Multiplying before modulo causing overflow
• Using floats incorrectly
• String conversion misuse