如何确定值的块是否适合数组

Question

给定一个任意长度的1s和0s 的输入数组,例如:

[0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0]

我怎样才能(最有效地)计算一个新的数组,详细说明大小为n 0s的块是否适合输入？

例子

输出现在意味着什么

• 1 =='是一个零块,大小可以到这里'
• 0 =='无法放入那么大的块

---

• 块大小= 1([0]):[1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1]
• 块大小= 2([0,0]):[0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1]
• 块大小= 3([0,0,0]):[0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0]
• 块大小= 4([0,0,0,0]):[0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

我正在使用ES6,所以任何语言功能都很好.

编辑:

输出不应该只是'是'/'不',大小'n'的大块可以放在这个数组中.更具体地说,它需要是一个长度相同的数组,其中'1'/'true'数组值代表:

• 是的,一大块'n'可以开始并适合这里,或者
• 是的,这个插槽可能包含一个在它之前开始的大小'n'的块

在第二点,这将意味着块大小3:

input = [1, 0, 0, 0, 0, 1];

output = [0, 1, 1, 1, 1, 0];

编辑2:

这是我提出的功能但似乎非常低效:

const calculateOutput = (input, chunkSize) => {
  const output = input.map((value, index) => {
    let chunkFitsHere = false;

    const start = (index - (chunkSize) >= 0) ? index - (chunkSize) : 0;
    const possibleValues = input.slice(start, index + chunkSize);
    possibleValues.forEach((pValue, pIndex) => {
      let consecutives = 0;
      for (let i = 0; i < possibleValues.length - 1; i += 1) {
        if (consecutives === chunkSize) {
          break;
        }
        if (possibleValues[i+1] === 0) {
          consecutives += 1;
        } else {
          consecutives = 0;
        }
      }
      if (consecutives === chunkSize) {
        chunkFitsHere = true;
      }
    });
    return chunkFitsHere ? 1 : 0;
  });
  return output;
};

Answer 1

您可以通过反转数组来计算连接的空闲位置，并为映射的最后一个返回值获取一个标志。

最终映射之前和之后的数组，具体取决于n

 1  0  4  3  2  1  0  0  2  1  0  0  0  3  2  1  0  2  1  array with counter
 1  0  4  4  4  4  0  0  2  2  0  0  0  3  3  3  0  2  2  array same counter
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --  ------------------
 1  0  1  1  1  1  0  0  1  1  0  0  0  1  1  1  0  1  1  n = 1
 0  0  1  1  1  1  0  0  1  1  0  0  0  1  1  1  0  1  1  n = 2
 0  0  1  1  1  1  0  0  0  0  0  0  0  1  1  1  0  0  0  n = 3
 0  0  1  1  1  1  0  0  0  0  0  0  0  0  0  0  0  0  0  n = 4

 1  0  4  3  2  1  0  0  2  1  0  0  0  3  2  1  0  2  1  array with counter
 1  0  4  4  4  4  0  0  2  2  0  0  0  3  3  3  0  2  2  array same counter
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --  ------------------
 1  0  1  1  1  1  0  0  1  1  0  0  0  1  1  1  0  1  1  n = 1
 0  0  1  1  1  1  0  0  1  1  0  0  0  1  1  1  0  1  1  n = 2
 0  0  1  1  1  1  0  0  0  0  0  0  0  1  1  1  0  0  0  n = 3
 0  0  1  1  1  1  0  0  0  0  0  0  0  0  0  0  0  0  0  n = 4

如果您只喜欢最后一个映射，请删除最后两个map并使用

.map((l => v => l = +(v && (v >= n || l)))(0));

用于最终映射。