Мета цього завдання полягає в тому, щоб визначити, чи можна колекцію одновимірних фрагментів викласти плиткою, щоб утворити кінцевий безперервний шматок.

Частина є непустою, кінцева послідовність нулів і одиниць , які починаються і закінчуються в одному. Деякі можливі шматки 1, 101, 1111, 1100101.

Черепиця означає розташування шматочків таким чином, щоб утворився єдиний суміжний блок з них. Один з одного шматка може займати місце нуля, але не одного, з іншого шматка.

Як рівно, якщо ми розглядаємо один як "твердий матеріал", а нуль - як "отвір", шматки повинні підходити так, щоб утворювати єдину ділянку, не залишаючи жодних отворів.

Щоб утворити плитку, шматки можна переміщувати лише вздовж їх одномірного простору. (Вони не можуть бути розбиті або відображені). Кожен шматок використовується рівно один раз.

Приклади

Три частини 101, 11, 101може бути черепичні , як показано в наступному, де кожна частина представлена з необхідним зсувом:

  101
11
   101

тому отримана плитка є

111111

Як другий приклад, шматки 11011та 1001101їх не можна викладати плиткою. Зокрема, зсув

 11011
1001101

не вірно, оскільки стикаються дві; і

11011
  1001101

не вірно, оскільки результат міститиме нуль.

Додаткові правила

Введення являє собою набір з однієї або декількох частин. Дозволений будь-який розумний формат; наприклад:

• Список рядків, де кожен рядок може містити два різних послідовні символи;
• Кілька масивів, де кожен масив містить положення одиниць на шматок;
• Список (непарних) цілих чисел, таких як двійкове представлення кожного числа, визначає фрагмент.

Вихід повинен бути значенням truthy , якщо плиткові можна і falsy значення в іншому випадку. Вихідні значення не повинні відповідати; тобто вони можуть бути різними для різних входів.

Програми або функції дозволені на будь- якій мові програмування . Стандартні лазівки заборонені.

Виграє найкоротший код у байтах.

Тестові справи

Кожен вхід знаходиться в іншому рядку

Truthy

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

Бере список індексів і повертає додатне ціле число (truthy) або 0 (false).

Спробуйте в Інтернеті! або перевірити більшість тестових випадків .

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 байт із перевернутими значеннями truthy / falesy:

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(truthy), або 0(falsey).

Спробуйте в Інтернеті! або перегляньте тестовий набір (скорочено - перші 6 помилок, а потім перші вісім істин, оскільки довжина чотирьох задовга, щоб включити їх через використання декартового продукту).

Як?

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

Я розробив це повністю незалежно від Джонатана Аллана, але зараз дивлячись на його точно так само:

J , 74 байти

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

Я можу спробувати зробити це мовчазним пізніше, але поки це явне дієслово. Я поясню не вершину версію. Він займає список цілих чисел у 1вікні та повертає (truthy) або 0(falsy).

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 

Спробуйте в Інтернеті!