Javascript 监视：使用递归找到最佳期望

最近，我采访的一家初创公司向我提交了一份编码作业。他们给了我以下问题并要求解决：

恭喜你！你是一群恶棍中的新精英黑客 奈尔·多威尔

幸运的是，这群人比你的上一帮流氓更狡猾，而且 他们希望软件（和你）能提高他们的收视率。骗局 该队的一名队员，在每条街道上挨家挨户扮成一名队员 白蚁检查员，这样他就可以秘密地把有价值的货物全部放在箱子里 每家每户。通常这帮人只会抢劫所有有价值的房子， 但是有一个陷阱！在这个富裕的国家，每当一所房子被抢劫时 附近，警察监视着它和附近的房子 几个月

因此，如果他们选择抢劫，团伙不能简单地抢劫所有的房屋 第一，他们再也不能在房子两边抢劫了

头目想知道他应该抢劫什么房子以最大限度地提高利润 球队的利润，他现在想知道。编写一个需要 在正整数（主值）数组中，并返回最大值 抢劫那条街的预期价值

例如：

[20,10,50,5,1]应该返还71美元，因为抢劫了第一个，第三个， 第五宫是最优的[20，x，50，x，1]

[20,50,10,1,5]应该返还55美元，就像抢劫第二个和第三个一样 第五宫是最优的[x，50，x，x，5]

基本上，你只能对其他房屋的价值求和，因为如果房屋被抢，由于街道上的高度安全，房屋前后的房屋都不能被抢

我使用递归编写了一个解决方案，并将其呈现给他们
我提出了一个解决方案，该方案考虑了除以下情况以外的所有情况：

[2,3,2]，返回的答案是3，而不是4

他们告诉我修复这个错误。因为这是唯一一个算法不起作用的情况，所以我使用以下代码来解决这个问题（用JavaScript编写）：

因此，完整的最终解决方案如下（包括上述代码片段）：

//期望值的全局变量：
var期望值=0；
函数（数组）{
//“array”包含主值
//递归算法不考虑长度为3的数组。
if（array.length==3）{
if（数组[0]+数组[2]>数组[1]）{
返回“robbing street的最佳期望：”+字符串（数组[0]+数组[2]）；
}否则{
返回“robbing street的最佳期望：”+字符串（数组[1]）；
}
}
//递归的基本情况：
if（array.sum（）==0）{
返回“抢劫街的最佳期望值：”+字符串（期望值）；
}否则{
期望值+=array.max（）；
var maxIndex=array.indexOf（array.max（））；
//递归调用：
返回最优期望值（注入零（数组，maxIndex））；
}
}
//===============================================================================
//最大值和总和的Protypal方法：
//所有阵列对象都从阵列原型继承以下方法：
Array.prototype.max=函数（）{
如果（this.length==1）{
返回此[0]；
}else if（this.length==0）{
返回null；
}
var最大值=0；
for（var i=0；i0）{
if（索引0）
数组[索引-1]=0；
}
数组[索引]=0；
返回数组；
}
//==================================================================================
log（最佳预期（[2,3,2]）；//正确返回4，而不是3

我提交上述解决方案后被拒绝。在我最初的解决方案之后，他们没有拒绝我（他们当然可以拒绝）。他们想让我解释我的思维过程以及我是如何修复这个bug的。br>

---

如果您能告诉我哪里出了问题，我将不胜感激。有没有办法改进我的算法？我的代码组织得好吗？这是正确的方法吗？如果你是一名专业开发人员，了解创业公司如何做出招聘决定，你能详细说明是什么导致团队拒绝我吗

我不是招聘经理。但一个快速的检查表明，你只能尽可能多地选择最大的房子。这个问题是概念性的，你把它隐藏起来而不是修正你的算法（这个问题也会出现在

[2,3,2,0.5]

，当你选择

3

，然后选择

0.5

，而不是最佳的

2

和

2

，长度3没有什么特别之处）。正确的解决方案至少应该使用回溯来探索选择不同的元素是否会获得更多的利润，而不是贪婪地选择局部最大值而不考虑上下文。在每一步检查最大值和相邻值就足够了。

var值=[2,3,2,0.5]；
函数（值）{
if（values.every（函数（e）{returne e==null}））返回[]；
var len=value.length；
var max=Math.max.apply（null，值）；
var subMax=-无穷大；
var子数组=[]；
对于（变量i=0；i// The recursive alrogithm doesn't account for arrays of length 3.
    if(array.length === 3) {
        if(array[0] + array[2] > array[1]) {
            return 'Optimal expectation of robbing street: ' + String(array[0] + array[2]);
        } else{
            return 'Optimal expectation of robbing street: ' + String(array[1]);
        }
    }

    // Global variable for expectation:
    var expectation = 0;

    function optimalExpectation(array) {
        // 'array' contains the home values

        // The recursive alrogithm doesn't account for arrays of length 3.
        if(array.length === 3) {
            if(array[0] + array[2] > array[1]) {
                return 'Optimal expectation of robbing street: ' + String(array[0] + array[2]);
            } else{
                return 'Optimal expectation of robbing street: ' + String(array[1]);
            }
        }
        // Base case for recursion:
        if(array.sum() === 0) {
                return 'Optimal expectation of robbing street: ' + String(expectation);
        } else{
            expectation += array.max();
            var maxIndex = array.indexOf(array.max());
            // Recursive call:
            return optimalExpectation(injectZeros(array, maxIndex));
        }
    }

    //===============================================================================
    // Protypal methods for maximum & sum:
    // All array objects inherit these methods from the Array prototype:

    Array.prototype.max = function(){
        if(this.length === 1){
            return this[0];
        } else if(this.length === 0){
            return null;
        }
        var maximum = 0;
        for(var i = 0; i < this.length; i++){
            if(maximum < Math.max(this[i], this[i + 1])){
                maximum = Math.max(this[i], this[i + 1]);
            }
        }
        return maximum;
    };

    Array.prototype.sum = function(){
        var sum = 0;
        this.forEach(function(el){
            sum += el;
        });
        return sum;
    };

    // Function to replace maximum values, already accounted for, with zeroes:
    function injectZeros(array, index){
        if(array.length > 0){
            if(index < array.length - 1)
                array[index + 1] = 0;
            if(index > 0)
                array[index - 1] = 0;
        }
        array[index] = 0;
        return array;
    }

    //==================================================================================


    console.log(optimalExpectation([2, 3, 2]));  // correctly returns 4, instead of 3

function computeRob (arr, index, canRob) {
    if(arr.length == index){
        return 0;
    }

    if (canRob == true) {
        var withRob = arr[index] + computeRob(arr, index + 1, false);
        var withoutRob = computeRob(arr, index + 1, true);
        return Math.max(withRob, withoutRob)
    } else {
        return withoutRob = computeRob(arr, index + 1, true);
    }
}

console.log(computeRob([4,3,8,9,2],0,true));