Javascript 如何确定值块是否可以放入数组

给定任意长度的

1

s和

0

s的输入数组，例如：

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

如果大小为

n

0

s的块可以放入输入中，我如何（最有效地）计算新数组的细节

例子 现在的产出意味着什么

• 1==“是的，一个大小为零的块可以放在这里”
• 0=='无法容纳该大小的块'

---

• 块大小=1（

  [0]

  ）：

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

• 块大小=2（

  [0,0]

  ）：

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

• 块大小=3（

  [0,0,0]

  ）：

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

• 块大小=4（

  [0,0,0,0]

  ）：

  [0,0,1,1,1,1,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;
};

const calculateOutput=（输入，chunkSize）=>{
常量输出=输入.map（（值，索引）=>{
设chunkfitsher=false；
const start=（index-（chunkSize）>=0）？index-（chunkSize）：0；
const possibleValues=input.slice（开始，索引+chunkSize）；
可能值。forEach（（pValue，pIndex）=>{
设连续数=0；
for（设i=0；i
您可以使用
array.prototype.some
检查块是否适合输入数组的某个索引。要检查具有实际长度的块是否合适，可以使用
array.prototype.every
：


var输入=[0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0]；
var chunk=[0,0,0]；
var res=input.some（（e，i）=>chunk.every（（c，j）=>input[i+j]==c））；
控制台日志（res）
虽然这些似乎与您的预期输出不完全匹配，但这可能是因为我假设数组中的标志应该标记块的开始（即，您可以从这个位置开始在数组中拟合N个truthy值）

（见下文，其中e=预期结果，n=我的算法输出。）

您可以使用
some
方法，然后如果当前元素为
0
，则可以从当前索引中分割数组的一部分，并检查其是否全部为零


const data=[0,1,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,1,0]
功能检查（arr，n）{
让chunk=Array（n）.fill（0）.join（“”）；
返回arr.some（（e，i）=>e==0&&arr.slice（i，i+n）.join（“”）=chunk）
}
控制台日志（检查（数据，3））
控制台日志（检查（数据，4））
log（检查（数据，5））
您可以通过反转数组来计算连接的空闲位置，并为映射的最后一个返回值设置一个标志

最终映射之前和之后的数组，具体取决于
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


函数块（数组，n）{
返回数组
.slice（）
.reverse（）
.map（（c=>v=>v？c=0:+c）（0））
.reverse（）
.map（（l=>v=>l=v&&（l||v））（0））
.map（v=>+（v>=n））；
}
var数组=[0,1,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,0,1,0]；
log（块（数组，1.join（“”））；
log（块（数组，2.join（“”））；
log（块（数组，3.join（“”））；
log（块（数组，4.join（“”））您可以遍历数组一次，计算零序列的长度。如果足够长，则用相同长度的1系列填充输出

请注意，您可以同时填充不同块长度的输出（填充二维数组行中的块，行索引不超过
zerolen
）

Python代码：

def zerochunks(a, n):
    l = len(a)
    result = [0] * l   #list of l zeros

    zerolen = 0
    for i in range(l + 1):
        ### Short circuit evaluation to shorten code
        if (i==l) or (a[i] != 0):   
            if (zerolen >= n):   #series of zeros is finished here
                for j in range(i - zerolen, i):
                    result[j] = 1
            zerolen  = 0
        else:
            zerolen += 1

    return result

print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 1))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 2))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 3))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 4))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 5))

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

和函数，用于获取maxn范围内具有块的所有数组：

def zerochunksall(a, maxn):
    l = len(a)
    result = [[0] * l for i in range(maxn)]

    zerolen = 0
    for i in range(l + 1):
        if (i==l) or (a[i] != 0):
            for k in range(0, zerolen):
                for j in range(i - zerolen, i):
                    result[k][j] = 1
            zerolen  = 0
        else:
            zerolen += 1

    return result

print(zerochunksall([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 5))
 >>
[[1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1],
 [0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1], 
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0], 
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

请添加区块大小如何影响结果。除此之外，请添加您的代码，您已经尝试过了。我将澄清上述内容，并添加一个适当的示例，说明我很快尝试过的内容-（必须为问题抽象出我的原始问题）感谢这一点-这是最接近的，因为我想根据我的问题示例输出一个数组。不过，我需要在我的问题中澄清一下，因为输出中的1可能意味着“是的，这个插槽可能是块的开始，也可能是可行块的一部分”。这个解决方案很漂亮，它告诉我，
Array.prototype.reverse（）
存在！计数器也非常有助于说明它是如何检查其周围的空格的。感谢这一点-理想情况下，解决方案需要使用JS来帮助其他人。我们将考虑将其移植到JS中，因为算法很有趣！我不知道如何正确组织JS数组/列表，所以决定演示Python的工作代码。希望移植是直接的。
 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

def zerochunks(a, n):
    l = len(a)
    result = [0] * l   #list of l zeros

    zerolen = 0
    for i in range(l + 1):
        ### Short circuit evaluation to shorten code
        if (i==l) or (a[i] != 0):   
            if (zerolen >= n):   #series of zeros is finished here
                for j in range(i - zerolen, i):
                    result[j] = 1
            zerolen  = 0
        else:
            zerolen += 1

    return result

print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 1))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 2))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 3))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 4))
print(zerochunks([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 5))

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

def zerochunksall(a, maxn):
    l = len(a)
    result = [[0] * l for i in range(maxn)]

    zerolen = 0
    for i in range(l + 1):
        if (i==l) or (a[i] != 0):
            for k in range(0, zerolen):
                for j in range(i - zerolen, i):
                    result[k][j] = 1
            zerolen  = 0
        else:
            zerolen += 1

    return result

print(zerochunksall([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0], 5))
 >>
[[1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1],
 [0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1], 
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0], 
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]