Kadane's Algorithm Maximum Subarray in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the variable that stores the maximum sum found so far.

DSA C#

int maxSoFar = [1];

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

Aint.MinValue

B0

Cint.MaxValue

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing maxSoFar to 0 can cause wrong results if all numbers are negative.

We initialize maxSoFar to the smallest possible integer to ensure any subarray sum will be larger.

2fill in blank

medium

Complete the code to update the current subarray sum by adding the current element.

DSA C#

currentSum = currentSum [1] nums[i];

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

A/

B+

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

We add the current element to the current sum to extend the subarray.

3fill in blank

hard

Fix the error in the code to reset currentSum when it becomes negative.

DSA C#

if (currentSum [1] 0) currentSum = 0;

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

A>

B==

C>=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using > or >= instead of < causes wrong resets.

If the current sum is less than zero, we reset it to zero to start a new subarray.

4fill in blank

hard

Fill both blanks to update maxSoFar if currentSum is greater.

DSA C#

if (currentSum [1] maxSoFar) maxSoFar = [2];

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

A>

B<

CcurrentSum

DmaxSoFar

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > in the comparison.

Assigning maxSoFar to itself instead of currentSum.

If currentSum is greater than maxSoFar, update maxSoFar to currentSum.

5fill in blank

hard

Fill all three blanks to complete the Kadane's algorithm loop.

DSA C#

for (int [1] = 0; i < [2]; i++) {
    currentSum = currentSum + nums[i];
    if (currentSum > maxSoFar) maxSoFar = [3];
    if (currentSum < 0) currentSum = 0;
}

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

Ai

Bnums.Length

CcurrentSum

Dj

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong loop variable names.

Looping beyond array length.

Assigning maxSoFar incorrectly.

The loop variable is i, iterating from 0 to nums.Length. We update maxSoFar with currentSum when currentSum is greater.

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