Fast Exponentiation Power in Log N in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to multiply the result by x when n is odd.

DSA C#

if (n % 2 == 1) result = result [1] x;

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

A+

B/

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of multiplication.

Using division or subtraction which changes the value incorrectly.

When n is odd, multiply the current result by x to include the extra factor.

2fill in blank

medium

Complete the code to halve the exponent n in each iteration.

DSA C#

n = n [1] 2;

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

A//

B/

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using floating division which results in a float.

Using subtraction which decreases n by 2 instead of halving.

Use integer division to halve n, discarding any remainder.

3fill in blank

hard

Fix the error in squaring x for the next iteration.

DSA C#

x = x [1] x;

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

A*

B+

C-

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition which doubles x but does not square it.

Using division or subtraction which changes the value incorrectly.

To square x, multiply it by itself.

4fill in blank

hard

Fill the blank to complete the while loop condition.

DSA C#

int result = 1;
while (n [1] 0) {
    if (n % 2 == 1) result = result * x;
    x = x * x;
    n = n / 2;
}

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

A<=

B<

C>=

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than instead of greater than in the loop condition.

Using incorrect comparison operators that cause infinite loops.

The loop runs while n is greater than 0, and n is halved using integer division.

5fill in blank

hard

Fill all three blanks to complete the fast exponentiation method.

DSA C#

public static int FastPower(int x, int n) {
    int result = [1];
    while (n [2] 0) {
        if (n % 2 == 1) result = result [3] x;
        x = x * x;
        n = n / 2;
    }
    return result;
}

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

A0

B1

C*

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing result to 0 which makes the final result always 0.

Using addition instead of multiplication for accumulating the result.

Initialize result to 1, loop while n > 0, multiply result by x when n is odd.

Practice

1. What is the main advantage of using Fast Exponentiation Power in Log N over the simple repeated multiplication method?

easy

A. It works only for positive exponents

B. It uses less memory by storing all intermediate powers

C. It reduces the time complexity from linear to logarithmic

D. It avoids multiplication altogether

Solution

1. Step 1: Understand the time complexity of simple exponentiation

   Simple repeated multiplication multiplies the base by itself n times, which takes O(n) time.

2. Step 2: Understand the time complexity of fast exponentiation

   Fast exponentiation uses squaring and reduces the number of multiplications to about O(log n).

3. Final Answer:

   It reduces the time complexity from linear to logarithmic -> Option C

4. Quick Check:

   Fast exponentiation = O(log n) time [OK]

Hint: Remember: halve the exponent each step for log speed [OK]

Common Mistakes:

• Thinking it avoids multiplication
• Assuming it only works for positive exponents
• Confusing memory usage with speed

2. Which of the following C# code snippets correctly implements the fast exponentiation method to compute pow(base, exponent)?

easy

A. int FastPow(int baseVal, int exp) { int result = 1; while (exp > 0) { if ((exp & 1) == 1) result *= baseVal; baseVal *= baseVal; exp >>= 1; } return result; }

B. int FastPow(int baseVal, int exp) { int result = 0; for (int i = 0; i < exp; i++) result += baseVal; return result; }

C. int FastPow(int baseVal, int exp) { if (exp == 0) return 0; return baseVal * FastPow(baseVal, exp - 1); }

D. int FastPow(int baseVal, int exp) { int result = 1; for (int i = 0; i < exp; i++) result *= baseVal; return result; }

Solution

1. Step 1: Analyze the code for fast exponentiation logic

   int FastPow(int baseVal, int exp) { int result = 1; while (exp > 0) { if ((exp & 1) == 1) result *= baseVal; baseVal *= baseVal; exp >>= 1; } return result; } uses bitwise operations to check odd exponent and squares base, which is the fast exponentiation method.

2. Step 2: Check other options for correctness

   int FastPow(int baseVal, int exp) { int result = 0; for (int i = 0; i < exp; i++) result += baseVal; return result; } adds baseVal repeatedly (wrong for power), C returns 0 for exp=0 (should be 1), D uses simple loop (not fast).

3. Final Answer:

   int FastPow(int baseVal, int exp) { int result = 1; while (exp > 0) { if ((exp & 1) == 1) result *= baseVal; baseVal *= baseVal; exp >>= 1; } return result; } -> Option A

4. Quick Check:

   Bitwise & squaring = fast exponentiation [OK]

Hint: Look for bitwise checks and squaring in code [OK]

Common Mistakes:

• Using addition instead of multiplication
• Returning 0 for exponent 0
• Using simple loops instead of bitwise

3. What is the output of the following C# code snippet?

int FastPow(int baseVal, int exp) {
    int result = 1;
    while (exp > 0) {
        if ((exp & 1) == 1) result *= baseVal;
        baseVal *= baseVal;
        exp >>= 1;
    }
    return result;
}

Console.WriteLine(FastPow(3, 4));

medium

A. 81

B. 64

C. 27

D. 12

Solution

1. Step 1: Trace the fast exponentiation for base=3, exp=4

   exp=4 (100b): - exp even, skip multiply, base=3*3=9, exp=2 - exp=2 (10b): even, skip multiply, base=9*9=81, exp=1 - exp=1 (1b): odd, multiply result=1*81=81, base=81*81=6561, exp=0 Loop ends.

2. Step 2: Final result is 81

   The function returns 81, which is 3^4.

3. Final Answer:

   81 -> Option A

4. Quick Check:

   3^4 = 81 [OK]

Hint: Remember to square base and halve exponent each step [OK]

Common Mistakes:

• Multiplying when exponent bit is zero
• Not updating base correctly
• Confusing exponent bits

4. Identify the bug in the following fast exponentiation code and select the correct fix:

int FastPow(int baseVal, int exp) {
    int result = 1;
    while (exp > 0) {
        if ((exp & 1) == 1) result *= baseVal;
        baseVal *= baseVal;
        exp = exp / 2;
    }
    return result;
}

medium

A. Replace exp = exp / 2; with exp >>= 1; for efficiency

B. Change multiplication to addition in result *= baseVal;

C. Initialize result to 0 instead of 1

D. Add a check for negative exponent at start

Solution

1. Step 1: Analyze the code for handling negative exponents

   The code does not handle negative exponents, since while (exp > 0) skips the loop and returns 1, which is wrong.

2. Step 2: Identify the fix

   Adding a check for negative exponent and handling it (e.g., returning 0 or using reciprocal) is necessary.

3. Final Answer:

   Add a check for negative exponent at start -> Option D

4. Quick Check:

   Negative exponent needs special handling [OK]

Hint: Always check for negative exponents before loop [OK]

Common Mistakes:

• Ignoring negative exponents
• Changing result initialization incorrectly
• Replacing division with bit shift without understanding

5. You want to compute pow(base, exponent) modulo m efficiently using fast exponentiation. Which modification should you make to the standard fast exponentiation algorithm to handle large numbers and avoid overflow?

hard

A. Use floating point arithmetic instead of integers

B. Apply modulo m after every multiplication step

C. Only apply modulo m at the end of the computation

D. Increase the size of integer variables to long long

Solution

1. Step 1: Understand overflow risk in large exponentiation

   Multiplying large numbers repeatedly can cause integer overflow before final modulo.

2. Step 2: Apply modulo at each multiplication

   Taking modulo after every multiplication keeps intermediate results small and prevents overflow.

3. Final Answer:

   Apply modulo m after every multiplication step -> Option B

4. Quick Check:

   Modulo after each multiply avoids overflow [OK]

Hint: Modulo after each multiply keeps numbers small [OK]

Common Mistakes:

• Applying modulo only once at end
• Using floating point causing precision loss
• Ignoring overflow risk