Question

我想要做的是计算帕斯卡三角形中坐标的值，我得到一张带有 X和Y轴的表格，其中我的上半部分和左边的帕斯卡三角形对齐，我要做的是创建一个函数来返回特定点的值[例如（3,2）= 2] 这是我尝试过的：

var getCalc = function value( x, y ) {

    if( y == 0 || y == x ){
        return 1;
    }

    return value(x - 1, y - 1) + value(x - 1, y);
}

这是带有pascal三角形的表格：

enter image description here 我们在这里得到的是一个在最后一次返回时调用两次的递归函数，在执行它时我得到以下错误：

未捕获RangeError：超出最大调用堆栈大小

此外，我想知道如何使用ES6

Answer 1

getCalc(3,2) = 3 //这个功能错了

请查看印有Pascal三角形的this implementation：

getCalc(3,2)
-> getCalc(2,1) + getCalc(2,2)
   ->getCalc(1,0) + getCalc(1,1) + 1
      ->1 +1 +1= 3

建立整个三角形的片段：

＆＃13;

function pascalRecursive(n, a) {

  if (n < 2) return a; // We already have the top row

  var prevTier = a[a.length-1];
  var curTier = [1];

  for (var i = 1; i < prevTier.length; i++) {
    curTier[i] = prevTier[i] + prevTier[i-1];
  }
  curTier.push(1);
  a.push(curTier);

  return pascalRecursive(n-1, a);
}
var triangle = pascalRecursive(100, [[1]]);
alert(triangle[1]);
///sum
alert(triangle[1].reduce(function(pv, cv) { return pv + cv; }, 0))

＆＃13;

Answer 2

JavaScript主要是ECMAScript，你正在做任何违反版本6规范的事情，但你可以lint here。

你的pascal triangle表看起来像是行而不是标准对角线（这个答案涉及对角线，但如果这就是你想要的话，最后提供一个非对角线示例。）
您的代码应该通过美化器运行。
无需制作2个函数（getCalc和value）
当y == x时，结果不应总是1
你总结错误的方框（x - 1，y - 1）就像一个正方形而不是一个三角形（x，y - 1）

更正的功能：

var value = function(x, y) {
    if (y == 0 || x == 0) {
        return 1;
    }
    return value(x - 1, y) + value(x, y - 1);
};

此外，您仍然可以使用非常大的数字或无效的数字来“超出调用堆栈大小”，安全包装器可能如下所示：

var safeValue = function(x, y) {
    if (x > 20 || y > 20 || y < 0 || x < 0 || Math.floor(x) != x || Math.floor(y) != y ) {
        return null;
    }
    return value(x, y);
};

如果您在任何浏览器中使用Web开发人员工具来创建断点，您可以跟踪每个递归以及所有变量。您可以添加深度变量来跟踪发生的递归次数。

输出verification：

(-1,0)=null
(0,0)=1
(2,3)=10
(2.5,3)=null

与大多数递归一样，您也可以将其表示为循环，并且深度限制会大大降低。

var value2 = function(x, y) {
    var xp;
    var yp;
    var theArray = {};
    for (xp = 0; xp <= x; xp += 1) {
        for (yp = 0; yp <= y; yp += 1) {
            if (xp === 0 || yp === 0) {
                if (!theArray[xp]) {
                    theArray[xp] = {};
                }
                theArray[xp][yp] = 1;
            } else {
                if (!theArray[xp]) {
                    theArray[xp] = {};
                }
                theArray[xp][yp] = theArray[xp - 1][yp] + theArray[xp][yp - 1];
                //memory saving step
                if (theArray[xp - 1][yp]) {
                    delete theArray[xp - 1][yp];
                }
            }
        }
    }
    return theArray[x][y];
};

从时间测试中可以看出，它产生了巨大的差异：

var a=new Date().getTime();console.log(value(13,13));console.log('time='+(new Date().getTime()-a));
10400600
time=4526

var a=new Date().getTime();console.log(value2(13,13));console.log('time='+(new Date().getTime()-a));
10400600
time=0

因此，将函数从O(n^n)内存转换为O（n），有一个函数将使用O（n）时间而不是O（n * n）;

var value3 = function(x, y) {
    var sum = 0;
    var tmp;
    var xp;
    for (xp = 0; xp <= x; xp += 1) {
        if (xp === 0) {
            tmp = 1;
        } else {
            tmp = (y + xp) / xp;
        }
        if (sum === 0) {
            sum = tmp;
        } else {
            sum = sum * tmp;
        }
    }
    return sum;
};

再次，时间差异很大;

var a=new Date().getTime();console.log(value2(500,500));console.log('time='+(new Date().getTime()-a));
2.702882409454366e+299
time=24

var a=new Date().getTime();console.log(value3(500,500));console.log('time='+(new Date().getTime()-a));
2.7028824094543663e+299
time=0

或者如果你想要非对角行：

var value4 = function(x, y) {
    if (y < x) {
        return null;
    }
    var sum = 0;
    var tmp;
    var xp;
    for (xp = 0; xp <= x; xp += 1) {
        if (xp === 0) {
            tmp = 1;
        } else {
            tmp = (y - (xp - 1)) / xp;
        }
        if (sum === 0) {
            sum = tmp;
        } else {
            sum = sum * tmp;
        }
    }
    return sum;
};

调用两次递归函数

2 个答案: