Partition Equal Subset Sum in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate the total sum of elements in the array.

DSA C++

int totalSum = 0;
for (int num : nums) {
    totalSum [1] num;
}

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

A-=

B+=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-=' instead of '+=' causes subtraction instead of addition.

Using '*=' or '/=' changes the total incorrectly.

We add each number to totalSum using the '+=' operator to get the total sum.

2fill in blank

medium

Complete the code to check if the total sum is odd, which means partition is impossible.

DSA C++

if (totalSum [1] 2 != 0) {
    return false;
}

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

A%

B/

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '/' instead of '%' gives the quotient, not remainder.

Using '==' or '!=' without modulus does not check oddness.

We use the modulus operator '%' to check if totalSum divided by 2 has a remainder, indicating oddness.

3fill in blank

hard

Fix the error in the dynamic programming initialization to create a boolean vector of size target+1.

DSA C++

vector<bool> dp([1], false);
dp[0] = true;

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

Atarget

Btarget - 1

Ctarget + 1

Dnums.size()

Attempts:

3 left

💡 Hint

Common Mistakes

Using target or target-1 misses the last index.

Using nums.size() is unrelated to sum target size.

We need a vector of size target+1 to include index 'target' for subset sum checks.

4fill in blank

hard

Fill both blanks to update the dp vector for subset sums using the current number.

DSA C++

for (int i = [1]; i >= 0; i--) {
    if (dp[i] && i + num [2] target) {
        dp[i + num] = true;
    }
}

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

Atarget - num

Btarget + num

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using target + num causes out-of-bound errors.

Using '>=' reverses the condition incorrectly.

We iterate down from target - num to 0 and check if i + num is less than or equal to target to update dp.

5fill in blank

hard

Fill all three blanks to complete the function that returns true if the array can be partitioned into two equal subsets.

DSA C++

bool canPartition(vector<int>& nums) {
    int totalSum = 0;
    for (int num : nums) {
        totalSum [1] num;
    }
    if (totalSum [2] 2 != 0) return false;
    int target = totalSum / 2;
    vector<bool> dp([3], false);
    dp[0] = true;
    for (int num : nums) {
        for (int i = target - num; i >= 0; i--) {
            if (dp[i] && i + num <= target) {
                dp[i + num] = true;
            }
        }
    }
    return dp[target];
}

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

A+=

B%

Ctarget + 1

D-=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-=' instead of '+=' for sum.

Using '/' instead of '%' for odd check.

Creating dp vector with wrong size.

We add numbers to totalSum with '+='; check oddness with '%'; and create dp vector of size target+1.

Practice

1. What does the Partition Equal Subset Sum problem ask you to determine about a given array of positive integers?

easy

A. If the array can be split into two subsets with equal sums

B. If the array contains any duplicate elements

C. If the array is sorted in ascending order

D. If the array contains only even numbers

Solution

1. Step 1: Understand the problem statement

   The problem asks whether the array can be divided into two parts where the sum of elements in both parts is the same.

2. Step 2: Identify the key condition

   This means the total sum of the array must be even, and there must be a subset with sum equal to half of the total sum.

3. Final Answer:

   If the array can be split into two subsets with equal sums -> Option A

4. Quick Check:

   Partition Equal Subset Sum = Split into equal sum subsets [OK]

Hint: Check if total sum is even to start [OK]

Common Mistakes:

• Thinking it checks for duplicates
• Assuming sorting is required
• Confusing with subset sum existence

2. Which of the following C++ code snippets correctly initializes a boolean DP array for the Partition Equal Subset Sum problem with size (sum/2 + 1) and sets the base case?

easy

A. bool dp[sum / 2 + 1]; std::fill(dp, dp + sum / 2 + 1, false); dp[0] = true;

B. std::vector<int> dp(sum / 2 + 1, 0); dp[0] = 1;

C. std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true;

D. std::vector<bool> dp(sum + 1, false); dp[sum] = true;

Solution

1. Step 1: Choose correct data type and size

   We need a boolean vector of size (sum/2 + 1) to track subset sums. std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true; uses correct size and type.

2. Step 2: Set base case correctly

   dp[0] = true means sum zero is always possible. std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true; does this correctly. std::vector<int> dp(sum / 2 + 1, 0); dp[0] = 1; uses int vector, which is less appropriate. std::vector<bool> dp(sum + 1, false); dp[sum] = true; uses wrong size and sets dp[sum] instead of dp[0].

3. Final Answer:

   std::vector<bool> dp(sum / 2 + 1, false); dp[0] = true; -> Option C

4. Quick Check:

   Boolean vector with dp[0] true = Correct initialization [OK]

Hint: Use bool vector and set dp[0] = true for base case [OK]

Common Mistakes:

• Using int vector instead of bool
• Incorrect dp array size
• Setting wrong base case index

3. What is the output of the following C++ code snippet for the input array {1, 5, 11, 5}?

bool canPartition(std::vector<int>& nums) {
    int sum = 0;
    for (int num : nums) sum += num;
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    std::vector<bool> dp(target + 1, false);
    dp[0] = true;
    for (int num : nums) {
        for (int j = target; j >= num; --j) {
            dp[j] = dp[j] || dp[j - num];
        }
    }
    return dp[target];
}

int main() {
    std::vector<int> nums = {1, 5, 11, 5};
    std::cout << (canPartition(nums) ? "true" : "false") << std::endl;
    return 0;
}

medium

A. true

B. false

C. Compilation error

D. Runtime error

Solution

1. Step 1: Calculate total sum and check parity

   Sum = 1 + 5 + 11 + 5 = 22, which is even, so proceed.

2. Step 2: Use DP to check subset sum of 11

   The code uses a boolean dp array to check if subset sum 11 is possible. The subsets {11} and {1,5,5} both sum to 11, so dp[11] becomes true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Subset sum 11 exists = true [OK]

Hint: Check if half sum subset exists using DP [OK]

Common Mistakes:

• Assuming sum odd means true
• Not iterating dp backwards
• Confusing output with subset elements

4. Identify the bug in the following code snippet for Partition Equal Subset Sum and select the fix:

bool canPartition(std::vector<int>& nums) {
    int sum = 0;
    for (int num : nums) sum += num;
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    std::vector<bool> dp(target + 1, false);
    dp[0] = true;
    for (int num : nums) {
        for (int j = num; j <= target; ++j) {
            dp[j] = dp[j] || dp[j - num];
        }
    }
    return dp[target];
}

medium

A. Change sum check to if (sum % 2 == 0) return false

B. Initialize dp vector with true instead of false

C. Remove dp[0] = true assignment

D. Change inner loop to iterate backwards: for (int j = target; j >= num; --j)

Solution

1. Step 1: Analyze inner loop direction

   The inner loop iterates forwards, which causes dp to use updated values in the same iteration, leading to incorrect results.

2. Step 2: Correct loop direction

   Iterating backwards ensures dp[j - num] uses values from previous iteration, preserving correctness.

3. Final Answer:

   Change inner loop to iterate backwards: for (int j = target; j >= num; --j) -> Option D

4. Quick Check:

   Backward iteration in DP loop fixes state update [OK]

Hint: Iterate dp array backwards to avoid overwriting states [OK]

Common Mistakes:

• Iterating dp forwards causing wrong results
• Incorrect dp initialization
• Wrong sum parity check

5. Given the array {2, 2, 3, 5}, which of the following statements is true regarding the Partition Equal Subset Sum problem?

hard

A. The array can be partitioned into two subsets with equal sum: {2,3} and {2,5}

B. The array cannot be partitioned into two subsets with equal sum because no subset sums to half the total

C. The array can be partitioned into two subsets with equal sum: {2,2,3} and {5}

D. The array cannot be partitioned into two subsets with equal sum because total sum is odd

Solution

1. Step 1: Calculate total sum

   Sum = 2 + 2 + 3 + 5 = 12, which is even, so partition might be possible.

2. Step 2: Check for subset with sum 6

   Half sum = 6. Possible subsets: - {2,2,3} sum = 7 (too high) - {2,3} sum = 5 (too low) - {5} sum = 5 (too low) - {2,2} sum = 4 (too low) No subset sums exactly to 6.

3. Final Answer:

   The array cannot be partitioned into two subsets with equal sum because no subset sums to half the total -> Option B

4. Quick Check:

   Half sum subset missing = No partition [OK]

Hint: Check if half sum subset exists before concluding [OK]

Common Mistakes:

• Assuming total sum even means partition possible
• Incorrect subset sums calculation
• Confusing subsets with unequal sums