175 lines
4.4 KiB
Markdown
175 lines
4.4 KiB
Markdown
# Powerset Exercise - Simple Explanation 🧮
|
|
|
|
## What is this exercise about?
|
|
|
|
Imagine you have a bag of numbered balls, and you want to find all the different ways you can pick some balls so that the numbers on them add up to a specific target number.
|
|
|
|
This is exactly what the **powerset** exercise does!
|
|
|
|
## Real-world example 🎯
|
|
|
|
Let's say you have these numbered balls: **1, 2, 3, 4, 5**
|
|
|
|
And you want to find all the ways to pick balls that add up to **5**.
|
|
|
|
Here are all the possible ways:
|
|
- Pick just ball **5** → 5 = 5 ✅
|
|
- Pick balls **1** and **4** → 1 + 4 = 5 ✅
|
|
- Pick balls **2** and **3** → 2 + 3 = 5 ✅
|
|
|
|
So the answer would be:
|
|
```
|
|
5
|
|
1 4
|
|
2 3
|
|
```
|
|
|
|
## How does our program work? 🤖
|
|
|
|
### Step 1: Understanding the input
|
|
When you run the program like this:
|
|
```bash
|
|
./powerset 5 1 2 3 4 5
|
|
```
|
|
|
|
- **5** is our target number (what we want the balls to add up to)
|
|
- **1 2 3 4 5** are our numbered balls
|
|
|
|
### Step 2: The magic behind the scenes
|
|
|
|
Our program is like a smart robot that tries **every possible combination**:
|
|
|
|
1. **Try no balls at all** → sum = 0 (not 5, so skip)
|
|
2. **Try just ball 1** → sum = 1 (not 5, so skip)
|
|
3. **Try just ball 2** → sum = 2 (not 5, so skip)
|
|
4. **Try just ball 3** → sum = 3 (not 5, so skip)
|
|
5. **Try just ball 4** → sum = 4 (not 5, so skip)
|
|
6. **Try just ball 5** → sum = 5 ✅ **FOUND ONE!**
|
|
7. **Try balls 1 and 2** → sum = 3 (not 5, so skip)
|
|
8. **Try balls 1 and 3** → sum = 4 (not 5, so skip)
|
|
9. **Try balls 1 and 4** → sum = 5 ✅ **FOUND ANOTHER!**
|
|
10. **Try balls 2 and 3** → sum = 5 ✅ **FOUND ANOTHER!**
|
|
|
|
...and so on until it tries every possible combination!
|
|
|
|
## Code explanation 📝
|
|
|
|
### The main parts of our code:
|
|
|
|
#### 1. Reading the input (`main` function)
|
|
```c
|
|
target = atoi(argv[1]); // Get the target number (5 in our example)
|
|
set[i] = atoi(argv[i + 2]); // Get each ball number (1, 2, 3, 4, 5)
|
|
```
|
|
|
|
#### 2. The smart robot (`find_subsets` function)
|
|
This function is like our robot that tries every combination:
|
|
|
|
```c
|
|
// For each ball, we have 2 choices:
|
|
find_subsets(..., index + 1); // Don't pick this ball
|
|
subset[subset_size] = set[index]; // Pick this ball
|
|
find_subsets(..., subset_size + 1, ...); // Continue with this ball included
|
|
```
|
|
|
|
#### 3. Checking if we found a winner (`print_subset`)
|
|
```c
|
|
if (current_sum == target) // If the sum equals our target
|
|
print_subset(subset, subset_size); // Show this combination!
|
|
```
|
|
|
|
## More examples to understand better 🎲
|
|
|
|
### Example 1: Finding combinations that sum to 3
|
|
```bash
|
|
./powerset 3 1 0 2 4 5 3
|
|
```
|
|
|
|
**What the robot finds:**
|
|
- Ball **3** alone → 3 ✅
|
|
- Balls **0** and **3** → 0 + 3 = 3 ✅
|
|
- Balls **1** and **2** → 1 + 2 = 3 ✅
|
|
- Balls **1**, **0**, and **2** → 1 + 0 + 2 = 3 ✅
|
|
|
|
**Output:**
|
|
```
|
|
3
|
|
0 3
|
|
1 2
|
|
1 0 2
|
|
```
|
|
|
|
### Example 2: Finding the empty combination
|
|
```bash
|
|
./powerset 0 1 -1
|
|
```
|
|
|
|
**What the robot finds:**
|
|
- No balls picked → sum = 0 ✅ (shows as empty line)
|
|
- Balls **1** and **-1** → 1 + (-1) = 0 ✅
|
|
|
|
**Output:**
|
|
```
|
|
|
|
1 -1
|
|
```
|
|
(Notice the empty line at the top!)
|
|
|
|
### Example 3: When nothing works
|
|
```bash
|
|
./powerset 7 3 8 2
|
|
```
|
|
|
|
**What the robot finds:**
|
|
- No combination of 3, 8, and 2 can make 7
|
|
- So nothing gets printed (empty output)
|
|
|
|
## Important rules 📏
|
|
|
|
1. **Order matters**: We always keep balls in the same order as given
|
|
- ✅ Correct: `1 4` (1 comes before 4 in input)
|
|
- ❌ Wrong: `4 1` (this changes the order)
|
|
|
|
2. **No duplicates**: Each ball can only be used once per combination
|
|
|
|
3. **Empty combination counts**: If target is 0, picking no balls is valid!
|
|
|
|
## How to use the program 🚀
|
|
|
|
1. **Compile it:**
|
|
```bash
|
|
make
|
|
```
|
|
|
|
2. **Run tests:**
|
|
```bash
|
|
make test
|
|
```
|
|
|
|
3. **Try your own examples:**
|
|
```bash
|
|
./powerset [target_number] [ball1] [ball2] [ball3] ...
|
|
```
|
|
|
|
4. **Clean up:**
|
|
```bash
|
|
make clean # Remove temporary files
|
|
make fclean # Remove everything
|
|
```
|
|
|
|
## Fun challenge! 🎮
|
|
|
|
Try to predict what this will output before running it:
|
|
```bash
|
|
./powerset 6 1 2 3 4
|
|
```
|
|
|
|
**Think about it:**
|
|
- Which combinations of 1, 2, 3, 4 add up to 6?
|
|
- Remember: order matters and each number can only be used once!
|
|
|
|
**Answer:** `2 4` and `1 2 3` (because 2+4=6 and 1+2+3=6)
|
|
|
|
---
|
|
|
|
*Now you understand how the powerset exercise works! It's like having a super-smart robot that can instantly try every possible combination of numbers to find the ones that add up to your target. Pretty cool, right?* 🤖✨ |