Декартово произведение

public class Solution {
    private static void Bruteforce(List<List<int>> nums, int idx, List<int> combination, List<List<int>> result) {
        if (idx == nums.Count) {
            result.Add(new List<int>(combination));
            return;
        }
        foreach (int num in nums[idx]) {
            combination.Add(num);
            Bruteforce(nums, idx + 1, combination, result);
            combination.RemoveAt(combination.Count - 1);
        }
    }

    public static List<List<int>> CartesianProduct(List<List<int>> nums) {
        List<List<int>> result = new List<List<int>>();
        Bruteforce(nums, 0, new List<int>(), result);
        return result;
    }
}

#include <vector>

using namespace std;

void bruteforce(vector<vector<int>> &nums, int idx, vector<int> &combination, vector<vector<int>> &result) {
    if (idx == nums.size()) {
        result.push_back(combination);
        return;
    }

    for (int num : nums[idx]) {
        combination.push_back(num);
        bruteforce(nums, idx + 1, combination, result);
        combination.pop_back();
    }
}

vector<vector<int>> cartesianProduct(vector<vector<int>> &nums) {
    vector<vector<int>> result;
    vector<int> combination;
    bruteforce(nums, 0, combination, result);
    return result;
}

package main

func bruteforce(nums [][]int, idx int, combination []int, result *[][]int) {
    if idx == len(nums) {
        temp := make([]int, len(combination))
        copy(temp, combination)
        *result = append(*result, temp)
        return
    }

    for _, num := range nums[idx] {
        combination = append(combination, num)
        bruteforce(nums, idx+1, combination, result)
        combination = combination[:len(combination)-1]
    }
}

func cartesianProduct(nums [][]int) [][]int {
    result := [][]int{}
    combination := []int{}
    bruteforce(nums, 0, combination, &result)
    return result
}

import java.util.*;

public class Solution {
    private void bruteforce(List<List<Integer>> nums, int idx, List<Integer> combination, List<List<Integer>> result) {
        if (idx == nums.size()) {
            result.add(new ArrayList<>(combination));
            return;
        }

        for (int num : nums.get(idx)) {
            combination.add(num);
            bruteforce(nums, idx + 1, combination, result);
            combination.remove(combination.size() - 1);
        }
    }

    public List<List<Integer>> cartesianProduct(List<List<Integer>> nums) {
        List<List<Integer>> result = new ArrayList<>();
        bruteforce(nums, 0, new ArrayList<>(), result);
        return result;
    }
}

from typing import *

def bruteforce(nums: List[List[int]], idx: int, combination: List[int], result: List[List[int]]) -> None:
    if idx == len(nums):
        result.append(list(combination))
        return

    for num in nums[idx]:
        combination.append(num)
        bruteforce(nums, idx + 1, combination, result)
        combination.pop()

def cartesian_product(nums: List[List[int]]) -> List[List[int]]:
    result: List[List[int]] = []
    bruteforce(nums, 0, [], result)
    return result

/**
 * @param {number[][]} nums
 * @returns {number[][]}
 */
function bruteforce(nums, idx, combination, result) {
    if (idx === nums.length) {
        result.push([...combination]);
        return;
    }

    for (const num of nums[idx]) {
        combination.push(num);
        bruteforce(nums, idx + 1, combination, result);
        combination.pop();
    }
}

/**
 * @param {number[][]} nums
 * @returns {number[][]}
 */
export function cartesianProduct(nums) {
    const result = [];
    bruteforce(nums, 0, [], result);
    return result;
}