Prefix Sum Array in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the prefix sum array with the first element of the input array.

DSA Go

prefixSum[0] = [1][0]

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

Anums

Bdata

Carr

Dinput

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong variable name like 'nums' or 'input'.

Trying to assign prefixSum[0] to 0 instead of the first element.

The prefix sum array starts with the first element of the input array named 'arr'.

2fill in blank

medium

Complete the code to calculate the prefix sum for the current index i.

DSA Go

prefixSum[i] = prefixSum[i-1] [1] arr[i]

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

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition.

Using multiplication or division which are incorrect for prefix sums.

Each prefix sum element is the sum of the previous prefix sum and the current element.

3fill in blank

hard

Fix the error in the loop condition to iterate over the array correctly.

DSA Go

for i := 1; i [1] len(arr); i++ {

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

A<

B<=

C>

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' causes index out of range error.

Using '>' or '>=' causes the loop to never run.

The loop should run while i is less than the length of the array to avoid out-of-range errors.

4fill in blank

hard

Fill both blanks to complete the function that returns the prefix sum array.

DSA Go

func prefixSumArray(arr []int) []int {
    prefixSum := make([]int, len(arr))
    prefixSum[0] = arr[0]
    for i := 1; i [1] len(arr); i++ {
        prefixSum[i] = prefixSum[i-1] [2] arr[i]
    }
    return prefixSum
}

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

A<

B+

C-

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' in loop condition causing index errors.

Using subtraction instead of addition for prefix sums.

The loop runs while i < len(arr), and prefixSum[i] is the sum of prefixSum[i-1] and arr[i].

5fill in blank

hard

Fill all three blanks to complete the code that computes prefix sums and prints the result.

DSA Go

func main() {
    arr := []int{1, 2, 3, 4, 5}
    prefixSum := make([]int, len(arr))
    prefixSum[0] = arr[[1]]
    for i := 1; i [2] len(arr); i++ {
        prefixSum[i] = prefixSum[i-1] [3] arr[i]
    }
    fmt.Println(prefixSum)
}

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

A0

B<

C+

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting with arr[1] instead of arr[0].

Using '<=' in loop causing index errors.

Using '-' instead of '+' for prefix sums.

The first element is arr[0], loop runs while i < len(arr), and prefixSum[i] is sum of prefixSum[i-1] and arr[i].

Practice

1. What is the main purpose of a prefix sum array in algorithms?

easy

A. To find the maximum element in the array

B. To sort the array elements in ascending order

C. To reverse the array elements efficiently

D. To quickly find the sum of elements in any subarray

Solution

1. Step 1: Understand prefix sum array concept

   A prefix sum array stores cumulative sums of elements from the start to each position.

2. Step 2: Use prefix sums for subarray sums

   Using prefix sums, sum of any subarray can be found quickly by subtracting two prefix sums.

3. Final Answer:

   To quickly find the sum of elements in any subarray -> Option D

4. Quick Check:

   Prefix sum array helps fast subarray sums [OK]

Hint: Prefix sums store cumulative sums for fast subarray queries [OK]

Common Mistakes:

• Confusing prefix sum with sorting
• Thinking prefix sum reverses array
• Assuming prefix sum finds max element

2. Which of the following Go code snippets correctly initializes a prefix sum array prefix from an integer slice arr?

easy

A. prefix := make([]int, len(arr))
for i := 0; i < len(arr); i++ {
prefix[i] = prefix[i-1] + arr[i]
}

B. prefix := make([]int, len(arr)+1)
for i := 1; i <= len(arr); i++ {
prefix[i] = prefix[i-1] + arr[i-1]
}

C. prefix := make([]int, len(arr)+1)
for i := 0; i < len(arr); i++ {
prefix[i] = prefix[i-1] + arr[i]
}

D. prefix := make([]int, len(arr))
for i := 1; i < len(arr); i++ {
prefix[i] = prefix[i-1] + arr[i]
}

Solution

1. Step 1: Check prefix array size and indexing

   Prefix sum array usually has length one more than original to handle zero prefix sum at start.

2. Step 2: Verify loop and indexing logic

   Loop from 1 to len(arr), prefix[i] = prefix[i-1] + arr[i-1] correctly accumulates sums.

3. Final Answer:

   prefix := make([]int, len(arr)+1) for i := 1; i <= len(arr); i++ { prefix[i] = prefix[i-1] + arr[i-1] } -> Option B

4. Quick Check:

   Correct prefix sum initialization uses offset indexing [OK]

Hint: Prefix array length = original length + 1, loop starts at 1 [OK]

Common Mistakes:

• Using prefix array same length as original
• Starting loop at 0 and accessing prefix[-1]
• Incorrect indexing of arr inside loop

3. What is the output of the following Go code?

arr := []int{2, 4, 6, 8}
prefix := make([]int, len(arr)+1)
for i := 1; i <= len(arr); i++ {
  prefix[i] = prefix[i-1] + arr[i-1]
}
fmt.Println(prefix)

medium

A. [0 2 6 12 20]

B. [2 6 12 20 28]

C. [0 2 4 6 8]

D. [2 4 6 8 0]

Solution

1. Step 1: Calculate prefix sums step-by-step

   prefix[0]=0
   prefix[1]=0+2=2
   prefix[2]=2+4=6
   prefix[3]=6+6=12
   prefix[4]=12+8=20

2. Step 2: Write final prefix array

   The prefix array is [0, 2, 6, 12, 20]

3. Final Answer:

   [0 2 6 12 20] -> Option A

4. Quick Check:

   Sum accumulates correctly in prefix array [OK]

Hint: Start prefix with 0, add elements cumulatively [OK]

Common Mistakes:

• Forgetting initial zero in prefix array
• Adding wrong elements at each step
• Confusing prefix array length

4. Identify the error in this Go code that tries to build a prefix sum array:

arr := []int{1, 3, 5}
prefix := make([]int, len(arr))
for i := 1; i < len(arr); i++ {
  prefix[i] = prefix[i-1] + arr[i]
}
fmt.Println(prefix)

medium

A. prefix array size should be len(arr)+1

B. Loop should start from i=0 instead of i=1

C. prefix[0] is not initialized before use

D. arr indexing is out of range

Solution

1. Step 1: Check prefix array initialization

   Prefix array is size len(arr), which can work but prefix[0] must be set before use.

2. Step 2: Analyze loop and prefix[0]

   Loop starts at i=1, prefix[1] = prefix[0] + arr[1]. prefix[0] is zero by default in Go, but it should be explicitly set to arr[0] before the loop.

3. Step 3: Check correctness of prefix sums

   prefix[0] is zero, but arr[0] is never added, so prefix sums are incomplete.

4. Final Answer:

   prefix[0] is not initialized before use -> Option C

5. Quick Check:

   Missing prefix[0] initialization causes wrong sums [OK]

Hint: Initialize prefix[0] before loop to avoid wrong sums [OK]

Common Mistakes:

• Not initializing prefix[0]
• Wrong prefix array size
• Incorrect loop start index

5. Given an integer slice arr, how can you use a prefix sum array to find the sum of elements between indices l and r (inclusive) efficiently?

hard

A. sum = prefix[r+1] - prefix[l]

B. sum = prefix[r] - prefix[l-1]

C. sum = prefix[r] + prefix[l]

D. sum = prefix[r+1] + prefix[l-1]

Solution

1. Step 1: Understand prefix sum indexing

   Prefix sum array usually has length len(arr)+1 with prefix[0]=0, prefix[i] = sum of arr[0..i-1].

2. Step 2: Calculate subarray sum using prefix sums

   Sum from l to r = prefix[r+1] - prefix[l] because prefix[r+1] sums up to arr[r].

3. Final Answer:

   sum = prefix[r+1] - prefix[l] -> Option A

4. Quick Check:

   Subarray sum = prefix[r+1] - prefix[l] [OK]

Hint: Use prefix[r+1] - prefix[l] for sum between l and r [OK]

Common Mistakes:

• Using prefix[r] - prefix[l-1] without offset
• Adding prefix sums instead of subtracting
• Confusing indices by 1