PHP 或 JavaScript 迭代无限数量的数组

Question

我面临一个挑战，我有三个数组，每个数组只包含数字。 我有一个函数get_sum，该函数接收2个参数，一个数组数组和一个数字。该数字是我想从每个数组中对一个或多个数字求和得到的总和，例如： 如果我有 2 个数组 [[1,2,3], [1,2,3]] 并且第二个参数是 4 该函数将返回总和为 4 的组合数。在这种情况下：

1+3 = 4
2+2 = 4
3+1 = 4

所以该函数将重新调整 int 3

我编写了下面的函数，它工作得很好，但我正在寻找一种方法来提高它的效率。目前，如果我的阵列少于 6 个，它将起作用，如果我有一百个阵列，我希望它起作用。 这里有什么数组函数可以帮到我吗？

这是代码：

<?php
function get_sum ($dice, $sum) {
    $sumcount = array();
    $num_of_dice = count($dice);    
    foreach($dice[0] as $die1){
        foreach($dice[1] as $die2){
            if($num_of_dice == 5){
                foreach($dice[2] as $die3){
                    foreach($dice[3] as $die4){
                        foreach($dice[4] as $die5){
                            if($die1 + $die2 + $die3+ $die4 + $die5 == $sum){
                                $good_res = array();
                                array_push( $good_res, $die1, $die2, $die3, $die4, $die5);
                                array_push($sumcount, $good_res);
                            }
                        }
                    }
                }
            }
            if($num_of_dice == 4){
                foreach($dice[2] as $die3){
                    foreach($dice[3] as $die4){
                        if($die1 + $die2 + $die3+ $die4 == $sum){
                            $good_res = array();
                            array_push( $good_res, $die1, $die2, $die3, $die4);
                            array_push($sumcount, $good_res);
                        }
                    }
                }
            }elseif ($num_of_dice == 3){
                foreach($dice[2] as $die3){
                    if($die1 + $die2 + $die3 == $sum){
                        $good_res = array();
                        array_push( $good_res, $die1, $die2, $die3);
                        array_push($sumcount, $good_res);
                    }
                }
            }else{
                if($die1 + $die2 == $sum){
                    $good_res = array();
                    array_push( $good_res, $die1, $die2);
                    array_push($sumcount, $good_res);
                }
            }

        }
    };



    echo count($sumcount);
}



get_sum([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]], 9)
?>

如果 JavaScript 中有一个函数也很好。

谢谢

Answer 1

想法

这个想法是为所有数组的所有元素创建一个笛卡尔积，然后计算给出预期总和的行。

JavaScript

在 JavaScript ES6 中，这个想法可以这样实现：

const simpleCartesian = (arr1, arr2) => [].concat( ...arr1.map( el1 => arr2.map( el2 => [].concat( el1, el2 ) ) ) );
const fullCartesian = (arr1, arr2, ...arrN) => (arr2 ? fullCartesian(simpleCartesian(arr1, arr2), ...arrN) : arr1);
const reduceSum = (a, b) => a + b;
const getSum = (arr, sum) =>  fullCartesian(...arr).reduce((prev, currArr) => prev += currArr.reduce(reduceSum) == sum ? 1 : 0, 0);

函数simpleCartesian、fullCartesian和reduceSum是getSum函数的辅助函数。

使用中：

getSum( [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]], 9)
// Returned value: 25

PHP

在 PHP 中，这个想法可以像这样实现：

function cartesian_product($arrays) {
    $cartesian_product = [[]];
    foreach ($arrays as $key => $arr) {
        $appendArr = [];
        foreach ($cartesian_product as $product) {
            foreach ($arr as $item) {
                $product[$key] = $item;
                $appendArr[] = $product;
            }
        }
        $cartesian_product = $appendArr;
    }
    return $cartesian_product;
}
function get_sum($arrays, $sum) {
    $counter = 0;
    $cartesian_product = cartesian_product($arrays);
    foreach ($cartesian_product as $row) {
        if ($sum == array_sum($row)) {
            $counter++;
        }
    }
    return $counter;
}

函数cartesian_product是get_sum函数的辅助函数。

使用中：

get_sum( [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 7]], 7);
// Returned value: 15

优化

我们需要知道，当我们使用许多数组或一些非常大的数组时，使用 笛卡尔积创建一个完整的数组会消耗大量内存。

• 如果我们假设表格的元素是非负数，我们可以通过移除所有等于或大于sum参数的元素优化该算法 em> 来自输入表，在创建笛卡尔积之前。

• 如果我们假设表格的元素是正数，我们可以通过删除所有等于或大于sum 参数减去输入计数的元素来优化该算法数组来自输入表，在创建笛卡尔积之前。

谢谢

特别感谢@rsp 和@SergiySokolenko 就JavaScript 和PHP 中笛卡尔积 实现的回答。