Fast Exponentiation Power in Log N in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Fast Exponentiation Function

What is the output of the following C# code that calculates 3 to the power 5 using fast exponentiation?

DSA C#

using System;
class Program {
  static long FastPower(long x, long n) {
    if (n == 0) return 1;
    long half = FastPower(x, n / 2);
    if (n % 2 == 0) return half * half;
    else return half * half * x;
  }
  static void Main() {
    Console.WriteLine(FastPower(3, 5));
  }
}

A 81

B 15

C 243

D 125

💡 Hint

Recall that 3^5 means 3 multiplied by itself 5 times.

The function uses recursion to compute powers efficiently by dividing the exponent by 2 each time. 3^5 = 243.

❓ Predict Output

intermediate

Result of Fast Exponentiation with Zero Exponent

What will be printed when running this C# code that calculates 10 to the power 0 using fast exponentiation?

DSA C#

using System;
class Program {
  static long FastPower(long x, long n) {
    if (n == 0) return 1;
    long half = FastPower(x, n / 2);
    if (n % 2 == 0) return half * half;
    else return half * half * x;
  }
  static void Main() {
    Console.WriteLine(FastPower(10, 0));
  }
}

A 0

B 1

C 10

D Exception thrown

💡 Hint

Any number to the power 0 is 1.

The base case returns 1 when exponent is zero, so output is 1.

❓ Predict Output

advanced

Output of Fast Exponentiation with Negative Exponent

What happens when you run this C# code that tries to compute 2 to the power -3 using the given fast exponentiation function?

DSA C#

using System;
class Program {
  static double FastPower(double x, int n) {
    if (n == 0) return 1;
    double half = FastPower(x, n / 2);
    if (n % 2 == 0) return half * half;
    else if (n > 0) return half * half * x;
    else return (half * half) / x;
  }
  static void Main() {
    Console.WriteLine(FastPower(2, -3));
  }
}

A 0.125

B -8

C 8

D StackOverflowException

💡 Hint

Negative powers mean 1 divided by the positive power.

The function handles negative exponents by dividing instead of multiplying. 2^-3 = 1/(2^3) = 0.125.

🧠 Conceptual

advanced

Time Complexity of Fast Exponentiation

What is the time complexity of the fast exponentiation algorithm that computes x^n by recursively dividing the exponent by 2?

A O(1)

B O(n)

C O(n^2)

D O(log n)

💡 Hint

Each recursive call halves the exponent.

Because the exponent is divided by 2 each time, the number of calls is proportional to log n.

🔧 Debug

expert

Identify the Bug in Fast Exponentiation Code

What error will this C# code produce when computing 2 to the power 10 using fast exponentiation?

DSA C#

using System;
class Program {
  static long FastPower(long x, long n) {
    if (n == 0) return 1;
    long half = FastPower(x, n / 2);
    if (n % 2 == 0) return half * half;
    else return half * half * x;
  }
  static void Main() {
    Console.WriteLine(FastPower(2, 10));
  }
}

A Output: 1024

B OverflowException at runtime

C StackOverflowException due to infinite recursion

D Compilation error due to missing return

💡 Hint

Check if the recursion base case and multiplication are correct.

The code correctly computes 2^10 = 1024 without errors or overflow for this input.

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