Fast Exponentiation Power in Log N in DSA C# - Time & Space Complexity

Time Complexity: Fast Exponentiation Power in Log N

O(log n)

Understanding Time Complexity

We want to understand how fast the power calculation grows as the exponent gets bigger.

How does the number of steps change when we raise a number to a large power?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public 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;
}
    

This code calculates x raised to the power n using a fast method by splitting the problem in half each time.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive calls that split the exponent n by half each time.
• How many times: About log base 2 of n times, because n is divided by 2 each step.

How Execution Grows With Input

Each time we call the function, the exponent gets cut in half, so the number of steps grows slowly.

Input Size (n)	Approx. Operations
10	About 4 recursive calls
100	About 7 recursive calls
1000	About 10 recursive calls

Pattern observation: Doubling n adds only one more step, so growth is very slow.

Final Time Complexity

Time Complexity: O(log n)

This means the number of steps grows slowly as the exponent gets bigger, making it very efficient.

Common Mistake

[X] Wrong: "The function runs in O(n) time because it looks like it does one step per n."

[OK] Correct: Actually, the function cuts n in half each time, so it only needs about log n steps, not n.

Interview Connect

Understanding this fast power method shows you can improve simple tasks by clever thinking, a skill valued in interviews and real projects.

Self-Check

"What if we changed the code to use a loop instead of recursion? How would the time complexity change?"

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