이 과제의 목적은 1 차원 조각 모음이 타일링되어 유한 연속 청크를 형성 할 수 있는지 여부를 결정하는 것입니다.

조각은 0과 1의 비어 있지 않은, 유한 순서 인 하나 시작 및 종료가. 몇 가지 가능한 조각이 1, 101, 1111, 1100101.

타일링 은 하나의 인접한 블록이 형성되도록 피스를 배열하는 것을 의미한다. 한 조각에서 하나는 다른 조각에서 0이 아닌 0의 자리를 차지할 수 있습니다.

동등하게, 우리가 하나를 "고체 재료"로 간주하고 0을 "구멍"으로 간주한다면, 조각들은 구멍을 남기지 않고 단일 스트레치를 형성하도록 맞아야한다.

타일링을 형성하기 위해 조각 만 할 수 있습니다 이동 자신의 1 차원을 따라. (분할하거나 반영 할 수 없습니다). 각 조각은 정확히 한 번 사용됩니다.

예

세 조각을 101, 11, 101각 부분이 원하는 시프트 표현 다음에 도시 된 바와 같이 바둑판 될 수있다 :

  101
11
   101

얻은 타일은

111111

두 번째 예로서, 작품 11011과는 1001101바둑판 수 없다. 특히, 교대

 11011
1001101

충돌하는 두 가지가 있기 때문에 유효하지 않습니다. 과

11011
  1001101

결과에 0이 포함되므로 유효하지 않습니다.

추가 규칙

입력은 하나 이상의 피스들의 집합이다. 합리적인 형식이 허용됩니다. 예를 들면 다음과 같습니다.

• 각 문자열이 서로 다른 두 개의 일관된 문자를 포함 할 수있는 문자열 목록.
• 각 배열은 한 조각에 대한 위치를 포함하는 여러 배열입니다.
• 각 숫자의 이진 표현과 같은 (홀수) 정수 목록은 조각을 정의합니다.

출력 타일링이 가능하고 falsy 값 그렇지 않으면 truthy 값이어야한다. 출력 값이 일치 할 필요는 없습니다. 즉, 입력에 따라 다를 수 있습니다.

모든 프로그래밍 언어의 프로그램 또는 기능 이 허용 됩니다 . 표준 허점 은 금지되어 있습니다.

바이트 단위의 최단 코드가 이깁니다.

테스트 사례

각 입력은 다른 라인에 있습니다

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

인덱스 목록을 가져와 양의 정수 (거짓) 또는 0 (거짓)을 반환합니다 .

온라인으로 사용해보십시오! 또는 대부분의 테스트 사례를 확인하십시오 .

자바 스크립트 (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(truthy) 또는 0(falsey)를 반환하는 1과 0의 목록을 가져 오는 모나드 링크 .

온라인으로 사용해보십시오! 또는 테스트 슈트를 참조하십시오(단축-처음 6 개의 거짓 다음에 처음 8 개의 진리가 뒤 따르기 때문에, 길이가 4 개는 데카르트 제품의 사용으로 인해 포함되기에 너무 오래 걸리기 때문입니다).

방법?

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)

파이썬 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

온라인으로 사용해보십시오!

Mr. Xcoder 덕분에 -1 바이트

나는 Jonathan Allan과는 완전히 독립적으로 이것을 개발했지만 이제 그의 것을 보는 것은 똑같습니다.

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 

온라인으로 사용해보십시오!