Four Sum Problem All Unique Quadruplets in DSA Rust - Build from Scratch

Four Sum Problem All Unique Quadruplets

📖 Scenario: You are working on a shopping app that wants to find all unique groups of four products whose prices add up to a special discount target. This helps the app suggest bundles to customers.

🎯 Goal: Build a Rust program that finds all unique quadruplets of numbers in a list that sum up to a given target value.

📋 What You'll Learn

Create a vector called nums with the exact values: [1, 0, -1, 0, -2, 2]

Create an integer variable called target and set it to 0

Write a function called four_sum that takes nums and target and returns a vector of vectors of integers with all unique quadruplets that sum to target

Print the result of calling four_sum(&nums, target)

💡 Why This Matters

🌍 Real World

Finding combinations of products or items that meet a specific sum is useful in shopping apps, budgeting tools, and financial software.

💼 Career

This problem helps practice nested loops, sorting, and two-pointer techniques, which are common in coding interviews and real-world algorithmic challenges.

1

Create the input vector nums

Create a vector called nums with the exact values [1, 0, -1, 0, -2, 2].

DSA Rust

# Create the vector nums with values [1, 0, -1, 0, -2, 2]
# Your code here

Hint

Use let nums = vec![1, 0, -1, 0, -2, 2]; to create the vector.

2

Add the target variable

Create an integer variable called target and set it to 0.

DSA Rust

fn main() {
    let nums = vec![1, 0, -1, 0, -2, 2];
    // Create target variable set to 0
    // Your code here
}

Hint

Use let target = 0; to create the target variable.

3

Write the four_sum function

Write a function called four_sum that takes a reference to a vector of integers called nums and an integer target, and returns a vector of vectors of integers containing all unique quadruplets that sum to target. Use sorting and two-pointer technique inside the function.

DSA Rust

fn main() {
    let nums = vec![1, 0, -1, 0, -2, 2];
    let target = 0;

    // Write four_sum function below
    // Your code here
}

Hint

Sort the vector first. Use nested loops for the first two numbers, then two pointers for the last two numbers. Skip duplicates to keep quadruplets unique.

4

Print the result of four_sum

Print the result of calling four_sum(&nums, target) inside the main function.

DSA Rust

fn four_sum(nums: &Vec, target: i32) -> Vec> {
    // function code here
}

fn main() {
    let nums = vec![1, 0, -1, 0, -2, 2];
    let target = 0;
    // Print the result of four_sum(&nums, target)
    // Your code here
}

Hint

Use println!("{:?}", four_sum(&nums, target)); to print the result.

Practice

1. What is the main goal of the Four Sum Problem in data structures and algorithms?

easy

A. Count the number of pairs with a given sum

B. Find all unique quadruplets in an array that sum up to a target value

C. Find the maximum element in the array

D. Sort the array in ascending order

Solution

1. Step 1: Understand the problem statement

   The Four Sum Problem asks to find all unique groups of four numbers (quadruplets) in an array that add up to a specific target sum.

2. Step 2: Identify the goal

   The goal is not sorting or counting pairs, but specifically finding quadruplets whose sum equals the target.

3. Final Answer:

   Find all unique quadruplets in an array that sum up to a target value -> Option B

4. Quick Check:

   Four Sum Problem = Find quadruplets with target sum [OK]

Hint: Look for four numbers adding to target, not sorting or counting [OK]

Common Mistakes:

• Confusing Four Sum with sorting problems
• Looking for pairs instead of quadruplets
• Ignoring uniqueness of quadruplets

2. Which Rust syntax correctly declares a vector of integers named nums?

easy

A. let nums = {1, 2, 3, 4};

B. let nums = [1, 2, 3, 4];

C. let nums = (1, 2, 3, 4);

D. let nums = vec![1, 2, 3, 4];

Solution

1. Step 1: Identify Rust vector syntax

   In Rust, vectors are created using vec![elements] macro, which creates a growable array.

2. Step 2: Check each option

   let nums = vec![1, 2, 3, 4]; uses vec![1, 2, 3, 4] which is correct. let nums = [1, 2, 3, 4]; is an array, not a vector. let nums = (1, 2, 3, 4); is a tuple. let nums = {1, 2, 3, 4}; is invalid syntax.

3. Final Answer:

   let nums = vec![1, 2, 3, 4]; -> Option D

4. Quick Check:

   Vector syntax = vec![...] [OK]

Hint: Use vec! macro for vectors, arrays use brackets only [OK]

Common Mistakes:

• Using array syntax when vector is needed
• Confusing tuples with vectors
• Using curly braces which are invalid here

3. What is the output of the following Rust code snippet that finds quadruplets summing to 0?

let nums = vec![1, 0, -1, 0, -2, 2];
let target = 0;
// Assume function four_sum returns Vec of quadruplets
let result = four_sum(nums, target);
println!("{:?}", result);

Assuming four_sum is correctly implemented, what is the printed output?

medium

A. [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]

B. [[1, 0, -1, 0]]

C. [[0, 0, 0, 0]]

D. []

Solution

1. Step 1: Understand the input and target

   The input array is [1, 0, -1, 0, -2, 2] and target sum is 0. We want all unique quadruplets that sum to 0.

2. Step 2: Identify all quadruplets summing to 0

   Possible quadruplets are [-2, -1, 1, 2], [-2, 0, 0, 2], and [-1, 0, 0, 1]. These are unique and sum to 0.

3. Final Answer:

   [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]] -> Option A

4. Quick Check:

   Quadruplets sum to 0 = [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]] [OK]

Hint: Sort array and find quadruplets summing to target [OK]

Common Mistakes:

• Returning incomplete quadruplets
• Ignoring duplicates
• Returning empty list incorrectly

4. Identify the bug in this Rust code snippet for the Four Sum problem:

fn four_sum(nums: Vec<i32>, target: i32) -> Vec {
    let mut nums = nums;
    nums.sort();
    let mut result = Vec::new();
    for i in 0..nums.len() {
        for j in i+1..nums.len() {
            let mut left = j + 1;
            let mut right = nums.len() - 1;
            while left < right {
                let sum = nums[i] + nums[j] + nums[left] + nums[right];
                if sum == target {
                    result.push(vec![nums[i], nums[j], nums[left], nums[right]]);
                    left += 1;
                    right -= 1;
                } else if sum < target {
                    left += 1;
                } else {
                    right -= 1;
                }
            }
        }
    }
    result
}

What is the main issue causing duplicate quadruplets in the result?

medium

A. The vector nums is not sorted before processing

B. The while loop condition left < right is incorrect and should be left <= right

C. The code does not skip duplicate values for i, j, left, and right indices after finding a quadruplet

D. The function does not return the result vector

Solution

1. Step 1: Analyze duplicate handling in loops

   The code finds quadruplets but does not skip over duplicate values for indices i, j, left, and right after adding a quadruplet, causing duplicates in the result.

2. Step 2: Check other options

   The vector is sorted correctly, the while loop condition is correct, and the function returns the result vector properly.

3. Final Answer:

   The code does not skip duplicate values for i, j, left, and right indices after finding a quadruplet -> Option C

4. Quick Check:

   Skipping duplicates needed to avoid repeated quadruplets [OK]

Hint: Skip duplicates after adding quadruplet to avoid repeats [OK]

Common Mistakes:

• Not skipping duplicates for all pointers
• Changing loop conditions incorrectly
• Forgetting to sort the array

5. Given the array nums = [2, 2, 2, 2, 2] and target 8, what is the correct output of a Four Sum function that returns all unique quadruplets summing to the target?

hard

A. [[2, 2, 2, 2]]

B. [[2, 2, 2, 2], [2, 2, 2, 2]]

C. []

D. [[2, 2, 2]]

Solution

1. Step 1: Understand the input and target

   The array contains five 2's and the target sum is 8. We need quadruplets of four numbers summing to 8.

2. Step 2: Identify unique quadruplets

   Only one unique quadruplet exists: [2, 2, 2, 2]. Although multiple combinations exist, duplicates must be avoided.

3. Final Answer:

   [[2, 2, 2, 2]] -> Option A

4. Quick Check:

   Unique quadruplet summing to 8 = [[2, 2, 2, 2]] [OK]

Hint: Avoid duplicates; only one quadruplet of identical numbers [OK]

Common Mistakes:

• Returning duplicate quadruplets multiple times
• Returning empty list incorrectly
• Returning triples instead of quadruplets