Bu zorluğun amacı bir tek boyutlu parçaların bir koleksiyonunun sınırlı bir sürekli yığın oluşturmak için döşenip döşenemeyeceğini belirlemektir.

Bir parça , boş olmayan, sonlu bir sıfırlar dizisidir ve bunlarla başlar ve biter. Bazı olası parçalarıdır 1, 101, 1111, 1100101.

Fayans , parçaları tek bir bitişik blok oluşacak şekilde düzenlemek anlamına gelir. Bir parçadan bir tanesi, sıfır yerine, birini değil de başka bir parçadan geçebilir.

Aynı şekilde, birini "katı malzeme" olarak ve sıfırı "delik" olarak görürsek, parçaların herhangi bir delik bırakmadan tek bir gerdirme oluşturacak şekilde sığması gerekir.

Bir döşeme oluşturmak için, parçalar sadece bir boyutlu boşlukları boyunca kaydırılabilir . (Bölünemezler veya yansıtılamazlar). Her parça tam bir kez kullanılır.

Örnekler

Üç adet 101, 11, 101her parça gerekli kaymasıyla temsil edilir aşağıda gösterildiği gibi kiremitli olabilir:

  101
11
   101

Böylece elde edilen döşeme

111111

İkinci bir örnek olarak, parçalar 11011ve 1001101döşenemez. Özellikle, kayma

 11011
1001101

geçerli değil çünkü iki çarpışan var; ve

11011
  1001101

geçerli değil çünkü sonuç sıfır içerecek.

Ek kurallar

Giriş , bir veya daha fazla parçadan oluşur. Herhangi bir makul formata izin verilir; Örneğin:

• Her dizenin iki farklı, tutarlı karakter içerebileceği bir dizge listesi;
• Her dizinin bir parça için olanların pozisyonlarını içerdiği birkaç dizi;
• Her sayının ikili gösterimi gibi (tek) tamsayıların listesi bir parçayı tanımlar.

Çıkış bir döşeme mümkündür ve bir falsy değeri, aksi takdirde bir truthy değer olmalıdır. Çıktı değerlerinin tutarlı olması gerekmez; yani, farklı girdiler için farklı olabilirler.

Herhangi bir programlama dilinde programlara veya fonksiyonlara izin verilir . Standart boşluklar yasaktır.

Bayt cinsinden en kısa kod kazanır.

Test durumları

Her giriş farklı bir satırda

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

Falsy

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

Jöle , 15 bayt

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

Endekslerin bir listesini alır ve pozitif bir tamsayı (truthy) veya 0 (falsy) döndürür.

Çevrimiçi deneyin! veya çoğu test vakasını doğrulayın .

JavaScript (ES6), 74 73 70 bayt

Girdiyi 32 bit tam sayı dizisi olarak alır. Bir boole döndürür.

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

Veya ters truthy / falsy değerleri olan 66 bayt :

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

Test durumları

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

Nasıl?

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

Kabuğu , 16 bayt

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

1 tabanlı endekslerin listesini alır. Çevrimiçi deneyin!

açıklama

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

Jöle , 16 bayt

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

1(Truthy) veya 0( falsey) döndürenlerin ve sıfırların listesini içeren monadik bir bağlantı .

Çevrimiçi deneyin! veya bir test odasına bakın (kısaltılmış - ilk 6 falsey, ardından ilk sekiz doğruluktan sonra dördüncü uzunluk, Kartezyen ürününün kullanımına bağlı olması çok uzun sürdüğü için) görün.

Nasıl?

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 bayt

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)

Çevrimiçi deneyin!

Jöle , 16 bayt

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

Çevrimiçi deneyin!

Bay Xcoder sayesinde -1 bayt

Bunu tamamen Jonathan Allan'dan bağımsız olarak geliştirdim, ama şimdi ona bakmak tamamen aynı:

J , 74 bayt

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

Bunu daha sonra taciz etmeye çalışabilirim, ama şimdilik açık bir fiil. Ungolfed versiyonunu açıklayacağım. Kutulu tam sayıların bir listesini alır ve 1(truthy) veya 0(falsy) ile döner .

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 

Çevrimiçi deneyin!