Kadane's Algorithm Maximum Subarray in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of Kadane's Algorithm on this array?

Given the array int[] arr = {-2, 1, -3, 4, -1, 2, 1, -5, 4};, what is the maximum subarray sum found by Kadane's Algorithm?

DSA C#

int[] arr = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
int maxSoFar = arr[0];
int maxEndingHere = arr[0];
for (int i = 1; i < arr.Length; i++) {
    maxEndingHere = Math.Max(arr[i], maxEndingHere + arr[i]);
    maxSoFar = Math.Max(maxSoFar, maxEndingHere);
}
Console.WriteLine(maxSoFar);

A 4

B 6

C 5

D 7

💡 Hint

Look for the contiguous subarray with the largest sum.

The maximum subarray is [4, -1, 2, 1] which sums to 6.

❓ Predict Output

intermediate

What is the maximum subarray sum for all negative numbers?

Given the array int[] arr = {-8, -3, -6, -2, -5, -4};, what will Kadane's Algorithm output as the maximum subarray sum?

DSA C#

int[] arr = {-8, -3, -6, -2, -5, -4};
int maxSoFar = arr[0];
int maxEndingHere = arr[0];
for (int i = 1; i < arr.Length; i++) {
    maxEndingHere = Math.Max(arr[i], maxEndingHere + arr[i]);
    maxSoFar = Math.Max(maxSoFar, maxEndingHere);
}
Console.WriteLine(maxSoFar);

A -2

B -5

C -4

D -3

💡 Hint

Kadane's Algorithm returns the largest single element if all are negative.

The largest number in the array is -2, so the maximum subarray sum is -2.

🔧 Debug

advanced

What error occurs in this Kadane's Algorithm code?

Consider this code snippet for Kadane's Algorithm. What error will it cause when run?

int[] arr = {1, -2, 3};
int maxSoFar = 0;
int maxEndingHere = 0;
for (int i = 1; i < arr.Length; i++) {
    maxEndingHere = Math.Max(arr[i], maxEndingHere + arr[i]);
    maxSoFar = Math.Max(maxSoFar, maxEndingHere);
}
Console.WriteLine(maxSoFar);

DSA C#

int[] arr = {1, -2, 3};
int maxSoFar = 0;
int maxEndingHere = 0;
for (int i = 1; i <= arr.Length; i++) {
    maxEndingHere = Math.Max(arr[i], maxEndingHere + arr[i]);
    maxSoFar = Math.Max(maxSoFar, maxEndingHere);
}
Console.WriteLine(maxSoFar);

A No error, outputs 3

B NullReferenceException

C IndexOutOfRangeException

D SyntaxError

💡 Hint

Check the loop boundary conditions carefully.

The loop uses i <= arr.Length which tries to access arr[arr.Length], causing IndexOutOfRangeException.

🧠 Conceptual

advanced

Why does Kadane's Algorithm reset the current sum?

In Kadane's Algorithm, why do we choose the maximum between the current element and the sum of current element plus previous sum?

A To sort the array before summing

B To always add all elements regardless of sum

C To find the minimum subarray sum

D To discard negative sums and start fresh from current element

💡 Hint

Think about when continuing the previous subarray is worse than starting new.

If the previous sum is negative, starting fresh from current element gives a better sum.

🚀 Application

expert

Find the maximum subarray sum and its indices

Modify Kadane's Algorithm to find not only the maximum subarray sum but also the start and end indices of that subarray in int[] arr = { -1, 4, -2, 3, -2, 3, -5, 4 };. What are the correct start and end indices of the maximum subarray?

DSA C#

int[] arr = { -1, 4, -2, 3, -2, 3, -5, 4 };
int maxSoFar = arr[0];
int maxEndingHere = arr[0];
int start = 0, end = 0, s = 0;
for (int i = 1; i < arr.Length; i++) {
    if (arr[i] > maxEndingHere + arr[i]) {
        maxEndingHere = arr[i];
        s = i;
    } else {
        maxEndingHere += arr[i];
    }
    if (maxEndingHere > maxSoFar) {
        maxSoFar = maxEndingHere;
        start = s;
        end = i;
    }
}
Console.WriteLine($"Max sum: {maxSoFar}, Start: {start}, End: {end}");

A Start: 1, End: 5

B Start: 0, End: 3

C Start: 2, End: 6

D Start: 3, End: 7

💡 Hint

Track the start index when resetting the current sum.

The maximum subarray is [4, -2, 3, -2, 3] from index 1 to 5 with sum 6.

Practice

1. What does Kadane's Algorithm primarily help to find in an array of integers?

easy

A. The minimum element in the array

B. The maximum sum of a contiguous subarray

C. The total sum of all elements

D. The number of positive elements

Solution

1. Step 1: Understand the problem Kadane's Algorithm solves

   Kadane's Algorithm is designed to find the maximum sum of any contiguous subarray within a given array.

2. Step 2: Differentiate from other array operations

   It does not find minimum elements, total sums, or count positives, but specifically the largest sum of a continuous segment.

3. Final Answer:

   The maximum sum of a contiguous subarray -> Option B

4. Quick Check:

   Maximum subarray sum = The maximum sum of a contiguous subarray [OK]

Hint: Kadane's finds max sum in continuous subarray fast [OK]

Common Mistakes:

• Confusing maximum subarray sum with total array sum
• Thinking it finds minimum or count of elements
• Assuming it works on non-contiguous elements

2. Which of the following is the correct initialization for Kadane's Algorithm variables in C#?

easy

A. int maxSoFar = 0, maxEndingHere = 0;

B. int maxSoFar = int.MaxValue, maxEndingHere = int.MaxValue;

C. int maxSoFar = int.MinValue, maxEndingHere = 0;

D. int maxSoFar = 0, maxEndingHere = int.MinValue;

Solution

1. Step 1: Understand variable roles in Kadane's Algorithm

   maxSoFar stores the maximum sum found so far, so it should start very low (int.MinValue) to handle negative arrays. maxEndingHere tracks current subarray sum and starts at 0.

2. Step 2: Check each initialization

   int maxSoFar = int.MinValue, maxEndingHere = 0; correctly initializes maxSoFar to int.MinValue and maxEndingHere to 0, allowing correct updates during iteration.

3. Final Answer:

   int maxSoFar = int.MinValue, maxEndingHere = 0; -> Option C

4. Quick Check:

   Initialize maxSoFar low, maxEndingHere zero [OK]

Hint: Start maxSoFar at int.MinValue to handle negatives [OK]

Common Mistakes:

• Initializing maxSoFar to 0 causes wrong results with all negatives
• Setting maxEndingHere to int.MinValue breaks sum calculation
• Using int.MaxValue causes logic errors

3. What is the output of the following C# code using Kadane's Algorithm?

int[] arr = { -2, 1, -3, 4, -1, 2, 1, -5, 4 };
int maxSoFar = int.MinValue, maxEndingHere = 0;
foreach (int x in arr) {
    maxEndingHere = Math.Max(x, maxEndingHere + x);
    maxSoFar = Math.Max(maxSoFar, maxEndingHere);
}
Console.WriteLine(maxSoFar);

medium

A. 6

B. 7

C. 5

D. 4

Solution

1. Step 1: Trace Kadane's Algorithm on the array

   Iterate and update maxEndingHere and maxSoFar:
   - Start maxSoFar = -∞, maxEndingHere = 0
   - x=-2: maxEndingHere=max(-2,0-2)=-2; maxSoFar=max(-∞,-2)=-2
   - x=1: maxEndingHere=max(1,-2+1)=1; maxSoFar=max(-2,1)=1
   - x=-3: maxEndingHere=max(-3,1-3)=-2; maxSoFar=1
   - x=4: maxEndingHere=max(4,-2+4)=4; maxSoFar=4
   - x=-1: maxEndingHere=max(-1,4-1)=3; maxSoFar=4
   - x=2: maxEndingHere=max(2,3+2)=5; maxSoFar=5
   - x=1: maxEndingHere=max(1,5+1)=6; maxSoFar=6
   - x=-5: maxEndingHere=max(-5,6-5)=1; maxSoFar=6
   - x=4: maxEndingHere=max(4,1+4)=5; maxSoFar=6

2. Step 2: Identify the maximum sum found

   The maximum sum found is 6, which corresponds to the subarray [4, -1, 2, 1].

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Max subarray sum = 6 [OK]

Hint: Track maxEndingHere and maxSoFar stepwise [OK]

Common Mistakes:

• Adding all positive numbers incorrectly
• Not resetting maxEndingHere properly
• Confusing maxSoFar with last maxEndingHere

4. Identify the bug in this Kadane's Algorithm implementation and select the fix:

int maxSoFar = 0, maxEndingHere = 0;
foreach (int x in arr) {
    maxEndingHere += x;
    if (maxSoFar < maxEndingHere) maxSoFar = maxEndingHere;
    if (maxEndingHere < 0) maxEndingHere = 0;
}
return maxSoFar;

medium

A. Add a check to skip negative numbers in the loop

B. Remove resetting maxEndingHere to 0 when negative

C. Change maxEndingHere += x to maxEndingHere = x

D. Initialize maxSoFar to int.MinValue instead of 0

Solution

1. Step 1: Analyze initialization impact

   Initializing maxSoFar to 0 causes wrong results if all numbers are negative, as maxSoFar will never be less than 0.

2. Step 2: Correct initialization to handle negatives

   Setting maxSoFar to int.MinValue allows the algorithm to correctly track maximum sums even if all elements are negative.

3. Final Answer:

   Initialize maxSoFar to int.MinValue instead of 0 -> Option D

4. Quick Check:

   Use int.MinValue for maxSoFar to handle negatives [OK]

Hint: Use int.MinValue for maxSoFar to handle all negatives [OK]

Common Mistakes:

• Leaving maxSoFar at 0 causes wrong max for negative arrays
• Removing reset breaks Kadane's logic
• Changing addition to assignment loses cumulative sum

5. Given an array of integers, how would you modify Kadane's Algorithm to also return the start and end indices of the maximum sum subarray?

hard

A. Track temporary start index when maxEndingHere resets and update final start/end when maxSoFar changes

B. Store all subarrays and pick the max sum one at the end

C. Use two nested loops to find all subarrays and their sums

D. Return the first positive element's index as start and end

Solution

1. Step 1: Understand Kadane's Algorithm extension

   When maxEndingHere resets to current element, record that index as temporary start. When maxSoFar updates, update final start and end indices accordingly.

2. Step 2: Avoid brute force methods

   Storing all subarrays and using two nested loops are brute force and inefficient. Returning the first positive element's index as start and end is incorrect as max subarray may not start at first positive element.

3. Final Answer:

   Track temporary start index when maxEndingHere resets and update final start/end when maxSoFar changes -> Option A

4. Quick Check:

   Track indices on resets and max updates [OK]

Hint: Update start index when resetting maxEndingHere [OK]

Common Mistakes:

• Using nested loops instead of Kadane's linear approach
• Ignoring index tracking during sum updates
• Assuming max subarray always starts at first positive