Question

我的代码通过了，没问题。但是我希望你们对我的代码可以有所改进的意见。不必要的事情，技巧，做同一件事的更好方法，更快的方法，我确实可以接受任何形式的反馈。最近，我只想专注于提高解决问题的速度，而这个过程花了我近5个小时。此代码来自2D阵列HourGlass。我的思考过程是对自己想要的模型进行建模，而不是循环遍历行和行，这就是我得出此结果的方式。此外，我想从代码应该做什么（而不是如何）方面进行改进。很难，但是任何提示我都会很感激。由于我只编码前端的东西，因此我的解决问题实际上就是狗屎。
谢谢！

function hourglassSum(arr) {

        let newInput = arr
        let arrAnswer = []

        for(let line in newInput){
            for (let row in newInput){
                let newRow = parseInt(row)
                let newLine = parseInt(line)
                if(newLine < 4){
                    let a =newInput[newLine +0][newRow]
                    let b =newInput[newLine +0][newRow+1]
                    let c =newInput[newLine +0][newRow+2]
                    let d =newInput[newLine +1][newRow+1]
                    let e =newInput[newLine +2][newRow]
                    let f =newInput[newLine +2][newRow+1]
                    let g =newInput[newLine +2][newRow+2]
                    if(a,b,c,d,e,f,g == undefined){
                        break
                    }
                    arrAnswer.push([a,b,c,d,e,f,g].reduce((item1,item2)=> item1 + item2, 0))
                }
            }
        }

        let answer = arrAnswer.reduce((item1, item2) => (item1 > item2 ) ? item1: item2 )

        return answer 

    }

Answer 1

if(a,b,c,d,e,f,g == undefined)是否要检查这7个值是否未定义？

基于comma operator specs，我相信它只是在检查g == undefined。

逗号运算符评估每个操作数（从左到右），并返回最后一个操作数的值。

如果您真的想检查任何空值，这是您可以采用的一种方法

if([a,b,c,d,e,f,g].indexOf(undefined)>=0) ...

Answer 2

您的代码有很多冗余：

let newInput = arr

不必要。

let answer = arrAnswer.reduce((...

将其填充到var中是不必要的，因为您只需在下一行将其返回即可。

据我所知，您的整个代码可以更改为以下内容：

const hourglassSum = input => {
  return input
    .map((a, i, arr) => { // NEVER use for..in with arrays. Use .map or for..of
      return arr.map(b => {
        const idx1 = parseInt(a, 10); // always use radix
        const idx2 = parseInt(b, 10);

        // Use boolean short-circuiting, we'll filter later.
        // Your original code had potentially error throw here
        // if the first access resulted in undefined.
        const intermediate = input[idx1] !== undefined &&
          input[idx1 + 1] !== undefined &&
          input[idx1 + 2] !== undefined &&
          [
            input[idx1][idx2],
            input[idx1][idx2 + 1],
            input[idx1][idx2 + 2],
            input[idx1 + 1][idx2 + 1],
            input[idx1 + 2][idx2],
            input[idx1 + 2][idx2 + 1],
            input[idx1 + 2][idx2 + 2],
          ];

        // boolean again, check to make sure we don't pollute the
        // arithmetic 
        return intermediate &&
          intermediate.every(x => x !== undefined) &&
          intermediate;
      })
      .filter(x => x) // weed out falses
      .reduce((a, b) => a + b, 0); // sum to int
    })
    .reduce((a, b) => Math.max(a, b)); // Math.max replaces ternary
};

这可以说是更具可读性，绝对，更容易出错，并且更短一些，可以更好地利用Math.max之类的内置函数和数组方法。也是一致的，而不是将功能样式与循环混合在一起。一件事不是更快，但您首先要使其正确，然后再使其快速。

代码重构。试图改善我的代码

2 个答案: