JavaScript 挑战 - Sherlock 和数组

Question

我在面试中遇到了以下挑战，但有一些限制。

Watson 给 Sherlock 一个长度为 N 的数组 A。然后他要求他确定数组中是否存在一个元素，使得其左侧元素的总和等于其右侧元素的总和。如果左/右没有元素，则总和被认为为零。正式地，找到一个i，这样， A1+A2...A(i−1)=A(i+1)+A(i+2)...AN.

输入格式

第一行包含T，测试用例的数量。对于每个测试用例，第一行包含N，即数组A 中的元素数。每个测试用例的第二行包含N 空格分隔的整数，表示数组A。

输出格式

对于每个测试用例，如果数组中存在一个元素，则打印YES，使得其左侧元素之和等于其右侧元素之和；否则打印NO。

约束

1≤T≤10

1≤N≤10^5

1≤Ai≤2×10^4

1≤i≤N

我已经解决了，但在某些测试用例中失败了，我想知道我编码的陷阱。我已经花了将近 4-5 个小时，但无法解决。

我的解决方案是-

function processData(input) {
    input = input.split('\n');
    var counter=0;
    var sum = function(n){
        var r=[];
        for(var k=0;k<n.length;k++){
            if(!isNaN(n[k])) {
                if(n[k] >= 1 && n[k] <= (2 * Math.pow(10,4))){
                    r.push(n[k].trim());
                }
            } 
        }
        return r.reduce(function(a, b) { return Number(a) + Number(b); }, 0);
    }
    for(var i=2;i<=input.length;i+=2){
        var ret='NO';
        if(counter<=10){
            input[i] = input[i].split(' ');
            if(input[i].length <= Math.pow(10,5) &&   input[i-1] <= input[i].length && input[i-1] >= 1){
                for(var j=0;j<input[i].length;j++){
                    if(sum(input[i].slice(0,j)) ===  sum(input[i].slice(j+1,input[i].length))){
                        ret = 'YES';
                        break;
                    }
                }
            }
        }
        counter++;
        console.log(ret);
    };

} 

process.stdin.resume();
process.stdin.setEncoding("ascii");
_input = "";
process.stdin.on("data", function (input) {
    _input += input;
});

process.stdin.on("end", function () {
   processData(_input);
});

挑战链接 - https://www.hackerrank.com/challenges/sherlock-and-array

Answer 1

我无法在手机上轻松编写代码，但这是我的解决方案的想法。我会在键盘上进行适当的编辑。

让我们承认输入文件的解析是微不足道的。然后你只需要为单个数组编写一个返回是或否的函数。

第 1 步：减少数组以获得其元素的总和：TotalSim

第2步：循环数组并保持元素的部分和：LeftSum

第 3 步：如果 LeftSum === TotalSum - LeftSum 返回是

第 4 步：数组结束：返回 false

请不要让 javascript 中的整数在 2^53 -1 之前都是精确的，这意味着您的约束保证不会发生溢出

Answer 2

遍历案例，然后在每个案例中查找第一个元素，无论它是否符合 - 在元素的每一侧运行 reduce 并比较结果，直到找到匹配项或元素用完。

这应该可行：

let test = input => input
     .map(line => line
         .some((el, index) => line.slice(0, index).reduce((p, c) => p + c, 0)
           === line.slice(index - line.length + 1).reduce((p, c) => p + c, 0)))
     .map(result => result ? 'YES' : 'NO');

test(cases); // outputs array of YESs and NOs

Answer 3

这是最佳解决方案：

function balancedSums(arr) {
    // Write your code here
    let sum = arr.reduce((acc, val) => acc+val);
    let leftSum = 0;
    for(let i = 0; i < arr.length; i++){
        sum -= arr[i];
        if(sum === leftSum){
            return 'YES';
        };
        leftSum += arr[i];
    };
    return 'NO';
}