Prefix Sum Array in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Prefix Sum Array?

A Prefix Sum Array is a new array where each element at index i is the sum of all elements from the start up to index i in the original array.

beginner

How do you compute the prefix sum array for [2, 4, 6, 8]?

Start with the first element: 2. Then add each next element to the sum of all previous elements: [2, 6, 12, 20].

intermediate

Why is a prefix sum array useful?

It helps quickly find the sum of any subarray by subtracting prefix sums, reducing repeated addition and improving efficiency.

beginner

What is the time complexity to build a prefix sum array of size n?

The time complexity is O(n) because you compute each prefix sum by adding one element at a time in a single pass.

intermediate

How to find the sum of elements between indices i and j using a prefix sum array?

Sum from i to j = prefixSum[j] - prefixSum[i-1] (if i > 0), else prefixSum[j] if i = 0.

What does the element at index 3 in a prefix sum array represent?

A Sum of elements from index 0 to 3 in the original array

B Value of the original array at index 3

C Sum of elements from index 3 to end of the array

D Difference between elements at index 3 and 2

Each prefix sum element at index i is the sum of all elements from start up to i.

What is the time complexity to answer sum queries using a prefix sum array?

A O(n)

B O(log n)

C O(1)

D O(n^2)

Once prefix sums are built, sum queries between any two indices can be answered in constant time.

If prefixSum = [3, 7, 12, 18], what is the sum of elements from index 1 to 3?

A 9

B 18

C 12

D 15

Sum = prefixSum[3] - prefixSum[0] = 18 - 3 = 15.

Which of the following is NOT a benefit of using prefix sum arrays?

A Less memory usage than original array

B Simplifies repeated sum calculations

C Faster subarray sum queries

D Reduces time complexity of sum queries

Prefix sum arrays use extra memory equal to the original array size.

How do you initialize the first element of a prefix sum array?

A Zero

B Same as the first element of the original array

C Sum of all elements

D Double the first element of original array

The first prefix sum element equals the first element of the original array.

Explain how to build a prefix sum array from a given array.

Think about adding elements one by one to the sum of all before.

Describe how prefix sum arrays help in finding the sum of any subarray quickly.

Consider how subtraction of prefix sums gives subarray sums.

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