Уникальные подмножества

class Solution
{
    public static void Bruteforce(int idx, List<int> nums, List<int> subset, List<List<int>> allCombinations)
    {
        if (idx == nums.Count)
        {
            // Добавляем текущее подмножество в результат
            allCombinations.Add(new List<int>(subset));
            return;
        }

        // Рекурсивный запуск без добавления элемента
        Bruteforce(idx + 1, nums, subset, allCombinations);

        // Рекурсивный запуск c добавлением элемента
        subset.Add(nums[idx]);
        Bruteforce(idx + 1, nums, subset, allCombinations);
        subset.RemoveAt(subset.Count - 1);
    }

    public static List<List<int>> GenerateSubsets(List<int> nums)
    {
        var allCombinations = new List<List<int>>();
        var subset = new List<int>();
        Bruteforce(0, nums, subset, allCombinations);
        return allCombinations;
    }
}

#include <vector>

using namespace std;

void bruteforce(int idx, const vector<int>& nums, vector<int>& subset, vector<vector<int>>& allCombinations) {
    if (idx == nums.size()) {
        // Добавляем текущее подмножество в результат
        allCombinations.push_back(subset);
        return;
    }

    // Рекурсивный запуск без добавления элемента
    bruteforce(idx + 1, nums, subset, allCombinations);

    // Рекурсивный запуск c добавлением элемента
    subset.push_back(nums[idx]);
    bruteforce(idx + 1, nums, subset, allCombinations);
    subset.pop_back();
}

vector<vector<int>> generateSubsets(const vector<int>& nums) {
    vector<vector<int>> allCombinations;
    vector<int> subset;
    bruteforce(0, nums, subset, allCombinations);
    return allCombinations;
}

package main

func bruteforce(idx int, nums []int, subset []int, allCombinations *[][]int) {
    if idx == len(nums) {
        // Добавляем текущее подмножество в результат
        copySubset := append([]int(nil), subset...)
        *allCombinations = append(*allCombinations, copySubset)
        return
    }

    // Рекурсивный запуск без добавления элемента
    bruteforce(idx+1, nums, subset, allCombinations)

    // Рекурсивный запуск с добавлением элемента
    subset = append(subset, nums[idx])
    bruteforce(idx+1, nums, subset, allCombinations)
    subset = subset[:len(subset)-1]
}

func generateSubsets(nums []int) [][]int {
    allCombinations := [][]int{}
    subset := []int{}
    bruteforce(0, nums, subset, &allCombinations)
    return allCombinations
}

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public static void bruteforce(int idx, List<Integer> nums, List<Integer> subset, List<List<Integer>> allCombinations) {
        if (idx == nums.size()) {
            // Добавляем текущее подмножество в результат
            allCombinations.add(new ArrayList<>(subset));
            return;
        }

        // Рекурсивный запуск без добавления элемента
        bruteforce(idx + 1, nums, subset, allCombinations);

        // Рекурсивный запуск с добавлением элемента
        subset.add(nums.get(idx));
        bruteforce(idx + 1, nums, subset, allCombinations);
        subset.remove(subset.size() - 1);
    }

    public static List<List<Integer>> generateSubsets(List<Integer> nums) {
        List<List<Integer>> allCombinations = new ArrayList<>();
        List<Integer> subset = new ArrayList<>();
        bruteforce(0, nums, subset, allCombinations);
        return allCombinations;
    }
}

from typing import *

def bruteforce(idx: int, nums: List[int], subset: List[int], all_combinations: List[List[int]]):
    if idx == len(nums):
        # Добавляем текущее подмножество в результат
        all_combinations.append(subset.copy())
        return
    
    # Рекурсивный запуск без добавления элемента
    bruteforce(idx + 1, nums, subset, all_combinations)

    # Рекурсивный запуск c добавлением элемента
    subset.append(nums[idx])
    bruteforce(idx + 1, nums, subset, all_combinations)
    subset.pop()

def generate_subsets(nums: List[int]) -> List[List[int]]:
    all_combinations = []
    cur_subset = []
    bruteforce(0, nums, cur_subset, all_combinations)
    return all_combinations

export function bruteforce(idx, nums, subset, allCombinations) {
    if (idx === nums.length) {
        // Добавляем текущее подмножество в результат
        allCombinations.push([...subset]);
        return;
    }

    // Рекурсивный запуск без добавления элемента
    bruteforce(idx + 1, nums, subset, allCombinations);

    // Рекурсивный запуск c добавлением элемента
    subset.push(nums[idx]);
    bruteforce(idx + 1, nums, subset, allCombinations);
    subset.pop();
}

export function generateSubsets(nums) {
    const allCombinations = [];
    const subset = [];
    bruteforce(0, nums, subset, allCombinations);
    return allCombinations;
}