Mục đích của thử thách này là để xác định xem một tập hợp các mảnh một chiều có thể được lát gạch để tạo thành một khối liên tục hữu hạn hay không.

Một mảnh là một chuỗi không trống, hữu hạn của các số 0 và các số bắt đầu và kết thúc bằng một số. Một số mảnh có thể là 1, 101, 1111, 1100101.

Ốp lát có nghĩa là sắp xếp các mảnh sao cho một khối liền kề duy nhất được hình thành. Một từ một mảnh có thể chiếm vị trí của số 0, nhưng không phải từ một mảnh, từ một mảnh khác.

Tương tự, nếu chúng ta xem một cái là "vật liệu rắn" và số 0 là "lỗ", các mảnh sẽ khớp với nhau để tạo thành một đoạn duy nhất, không để lại bất kỳ lỗ nào.

Để tạo thành một lát, các mảnh chỉ có thể được dịch chuyển dọc theo không gian một chiều của chúng. (Chúng không thể được phân chia, hoặc phản ánh). Mỗi mảnh được sử dụng chính xác một lần.

Ví dụ

Ba mảnh 101, 11, 101có thể được lát gạch như thể hiện trong những điều sau đây, trong đó mỗi mảnh được đại diện với sự thay đổi cần thiết:

  101
11
   101

vì vậy ốp lát thu được là

111111

Như một ví dụ thứ hai, các mảnh 11011và 1001101không thể được lát gạch. Đặc biệt, sự thay đổi

 11011
1001101

không hợp lệ vì có hai cái va chạm; và

11011
  1001101

không hợp lệ vì kết quả sẽ chứa số không.

Quy tắc bổ sung

Đầu vào là một tập hợp của một hoặc nhiều mảnh. Bất kỳ định dạng hợp lý đều được cho phép; ví dụ:

• Một danh sách các chuỗi, trong đó mỗi chuỗi có thể chứa hai ký tự nhất quán, khác nhau;
• Một số mảng, trong đó mỗi mảng chứa vị trí của các mảng cho một mảnh;
• Một danh sách các số nguyên (lẻ) như biểu diễn nhị phân của mỗi số xác định một mảnh.

Đầu ra phải là một giá trị trung thực nếu có thể ốp lát và ngược lại là một giá trị giả. Giá trị đầu ra không nhất quán; đó là, chúng có thể khác nhau cho các đầu vào khác nhau.

Các chương trình hoặc chức năng được cho phép, trong bất kỳ ngôn ngữ lập trình . Sơ hở tiêu chuẩn bị cấm.

Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

Mỗi đầu vào nằm trên một dòng khác nhau

Sự thật

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

Giả

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

Thạch , 15 byte

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

Lấy danh sách các chỉ số và trả về số nguyên dương (trung thực) hoặc 0 (giả).

Hãy thử trực tuyến! hoặc xác minh hầu hết các trường hợp thử nghiệm .

JavaScript (ES6), 74 73 70 byte

Lấy đầu vào là một mảng các số nguyên 32 bit. Trả về một boolean.

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

Hoặc 66 byte với các giá trị trung thực / sai lệch ngược:

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

Các trường hợp thử nghiệm

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]))

Làm sao?

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

Husk , 16 byte

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

Đưa ra một danh sách các danh sách các chỉ số dựa trên 1. Hãy thử trực tuyến!

Giải trình

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

Thạch , 16 byte

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

Một liên kết đơn âm lấy một danh sách các danh sách của những người và số không trở về 1(trung thực) hoặc 0(falsey).

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm (rút ngắn - 6 sai đầu tiên theo sau là tám chân lý đầu tiên vì bốn chiều dài mất quá nhiều thời gian để sử dụng do sử dụng sản phẩm của Cartesian).

Làm sao?

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 byte

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)

Hãy thử trực tuyến!

Thạch , 16 byte

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

Hãy thử trực tuyến!

-1 byte nhờ ông Xcoder

Tôi đã phát triển điều này hoàn toàn độc lập với Jonathan Allan nhưng bây giờ nhìn vào anh ta hoàn toàn giống nhau:

J , 74 byte

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

Tôi có thể cố gắng làm cho nó ngầm sau, nhưng bây giờ nó là một động từ rõ ràng. Tôi sẽ giải thích phiên bản không có bản quyền. Nó nhận một danh sách các số nguyên đóng hộp và trả về 1(trung thực) hoặc 0(giả).

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 

Hãy thử trực tuyến!