该挑战的目的是确定是否可以平铺一维块的集合以形成有限的连续块。

阿片是零和一的一个非空的，有限序列的开始和结束与一个。一些可能的作品是1，101，1111，1100101。

平铺是指将小块排列成一个连续的块。一件中的一个可以占据零的位置，但另一件中的一个不能占据零的位置。

同样地，如果我们将一个视为“实心材料”，将零视为“孔”，则这些零件应适合于形成单一拉伸，而不会留下任何孔。

要形成平铺，只能沿着其一维空间移动碎片。（它们不能拆分或反映）。每件仅使用一次。

例子

三块101，11，101可以平铺如示于下，其中每个片与所需的移位表示：

  101
11
   101

所以获得的拼贴是

111111

作为第二个示例，片段11011和1001101不能平铺。特别是转变

 11011
1001101

无效，因为有两个会发生冲突；和

11011
  1001101

无效，因为结果将包含零。

附加规则

该输入是一个或多个片段的集合。允许使用任何合理的格式；例如：

• 字符串列表，其中每个字符串可以包含两个不同的一致字符；
• 几个数组，其中每个数组包含一块的位置；
• 一列（奇数）整数，例如每个数字的二进制表示形式定义了一个片段。

的输出应该是一个truthy值，如果平铺是可能的，和一个falsy值否则。输出值不必保持一致；也就是说，对于不同的输入，它们可以不同。

允许使用任何编程语言编写程序或功能。禁止出现标准漏洞。

以字节为单位的最短代码获胜。

测试用例

每个输入在不同的行上

特鲁西

1
111
1, 1
11, 111, 1111
101, 11, 1
101, 11, 101
10001, 11001, 10001
100001, 1001, 1011
10010001, 1001, 1001, 101
10110101, 11001, 100001, 1
110111, 100001, 11, 101
1001101, 110111, 1, 11, 1

虚假

101
101, 11
1, 1001
1011, 1011
11011, 1001101
1001, 11011, 1000001
1001, 11011, 1000001, 10101

果冻，15字节

+"FṢIP
FSṗLç€ċ1

获取索引列表，并返回正整数（真）或0（伪）。

在线尝试！或验证大多数测试用例。

JavaScript（ES6），74 73 70字节

将输入作为32位整数数组。返回一个布尔值。

f=([n,...a],x)=>n?[...f+''].some(_=>n&&!(x&n)&f(a,x|n,n<<=1)):!(x&-~x)

或66个字节的真实/错误值反转：

f=([n,...a],x)=>n?[...Array(32)].every(_=>x&n|f(a,x|n,n*=2)):x&-~x

测试用例

f=([n,...a],x)=>n?[...f+''].some(_=>n&&!(x&n)&f(a,x|n,n<<=1)):!(x&-~x)

console.log('[Truthy]')
console.log(f([0b1]))
console.log(f([0b111]))
console.log(f([0b1,0b1]))
console.log(f([0b11,0b111,0b1111]))
console.log(f([0b101,0b11,0b1]))
console.log(f([0b101,0b11,0b101]))
console.log(f([0b10001,0b11001,0b10001]))
console.log(f([0b100001,0b1001,0b1011]))
console.log(f([0b10010001,0b1001,0b1001,0b101]))
console.log(f([0b10110101,0b11001,0b100001,0b1]))
console.log(f([0b110111,0b100001,0b11,0b101]))
console.log(f([0b1001101,0b110111,0b1,0b11,0b1]))

console.log('[Falsy]')
console.log(f([0b101]))
console.log(f([0b101,0b11]))
console.log(f([0b1,0b1001]))
console.log(f([0b1011,0b1011]))
console.log(f([0b11011,0b1001101]))
console.log(f([0b1001,0b11011,0b1000001]))
console.log(f([0b1001,0b11011,0b1000001,0b10101]))

怎么样？

f = (                       // f = recursive function taking:
  [n, ...a],                //   n = next integer, a = array of remaining integers
  x                         //   x = solution bitmask, initially undefined
) =>                        //
  n ?                       // if n is defined:
    [... f + ''].some(_ =>  //   iterate 32+ times:
      n &&                  //     if n is not zero:
        !(x & n)            //       if x and n have some bits in common,
        &                   //       force invalidation of the following result
        f(                  //       do a recursive call with:
          a,                //         the remaining integers
          x | n,            //         the updated bitmask
          n <<= 1           //         and update n for the next iteration
        )                   //       end of recursive call
    )                       //   end of some()
  :                         // else (all integers have been processed):
    !(x & -~x)              //   check that x is a continuous chunk of 1's

外壳，16字节

V§=OŀF×+ṠṀṪ+oŀṁ▲

获取基于1的索引的列表。 在线尝试！

说明

V§=OŀF×+ṠṀṪ+oŀṁ▲  Implicit input, say x=[[1,3],[1]]
              ṁ▲  Sum of maxima: 4
            oŀ    Lowered range: r=[0,1,2,3]
        ṠṀ        For each list in x,
          Ṫ+      create addition table with r: [[[1,3],[2,4],[3,5],[4,6]],
                                                 [[1],[2],[3],[4]]]
     F×+          Reduce by concatenating all combinations: [[1,3,1],[1,3,2],...,[4,6,4]]
V                 1-based index of first list y
    ŀ             whose list of 1-based indices [1,2,...,length(y)]
 §=               is equal to
   O              y sorted: 2

果冻，16 字节

FLḶ0ẋ;þ⁸ŒpS€P€1e

一个单子链接，该列表获取返回“ 1真”或“ 0假”的一和零的列表。

在线尝试！或查看测试套件（缩短了-前6个虚假，后8个真实，因为使用笛卡尔乘积的时间太长，无法包括在内）。

怎么样？

FLḶ0ẋ;þ⁸ŒpS€P€1e - Link: list of lists, tiles
F                - flatten (the list of tiles into a single list)
 L               - length (gets the total number of 1s and zeros in the tiles)
  Ḷ              - lowered range = [0,1,2,...,that-1] (how many zeros to try to prepend)
   0             - literal zero
    ẋ            - repeat = [[],[0],[0,0],...[0,0,...,0]] (the zeros to prepend)
       ⁸         - chain's left argument, tiles
      þ          - outer product with:
     ;           -   concatenation (make a list of all of the zero-prepended versions)

        Œp       - Cartesian product (all ways that could be chosen, including man
                 -   redundant ones like prepending n-1 zeros to every tile)
          S€     - sum €ach (good yielding list of only ones)
            P€   - product of €ach (good yielding 1, others yielding 0 or >1)
              1  - literal one
               e - exists in that? (1 if so 0 if not)

Python 2，159个字节

lambda x:g([0]*sum(map(sum,x)),x)
g=lambda z,x:x and any(g([a|x[0][j-l]if-1<j-l<len(x[0])else a for j,a in enumerate(z)],x[1:])for l in range(len(z)))or all(z)

在线尝试！

果冻，16字节

FLḶ0ẋ;þµŒpSP$€1e

在线尝试！

-1字节感谢Xcoder先生

我完全独立于乔纳森·艾伦（Jonathan Allan）进行了开发，但现在看看他是完全一样的：

J，74字节

f=:3 :'*+/1=*/"1+/"2(l{."1 b)|.~"1 0"_ 1>,{($,y)#<i.l=:+/+/b=:>,.&.":&.>y'

稍后我可能会使其默认，但现在它是一个显式动词。我将解释非高尔夫版本。它需要装箱的整数列表，并返回1（真）或0（伪）。

This will be my test case, a list of boxed integers:
   ]a=:100001; 1001; 1011                
┌──────┬────┬────┐
│100001│1001│1011│
└──────┴────┴────┘
b is the rectangular array from the input, binary digits. Shorter numbers are padded
with trailing zeroes:
   ]b =: > ,. &. ": &.> a   NB. Unbox each number, convert it to a list of digits 
1 0 0 0 0 1
1 0 0 1 0 0
1 0 1 1 0 0

l is the total number of 1s in the array: 
   ]l=: +/ +/ b             NB. add up all rows, find the sum of the resulting row)
7

r contains all possible offsets needed for rotations of each row: 
   r=: > , { ($,a) # < i.l  NB. a catalogue of all triplets (in this case, the list
has 3 items) containing the offsets from 0 to l:
0 0 0
0 0 1
0 0 2
0 0 3
0 0 4
 ...
6 6 3
6 6 4
6 6 5
6 6 6

m is the array after all possible rotations of the rows of b by the offsets in r. 
But I first extend each row of b to the total length l:
   m=: r |."0 1"1 _ (l {."1 b)  NB. rotate the extended rows of b with offsets in r,
ranks adjusted

For example 14-th row of the offsets array applied to b:
    13{r
0 1 6
   13{m
1 0 0 0 0 1 0
0 0 1 0 0 0 1
0 1 0 1 1 0 0

Finally I add the rows for each permutation, take the product to check if it's all 1, and
check if there is any 1 in each permuted array.
   * +/ 1= */"1 +/"2 m
1 

在线尝试！