32

Lo scopo di questa sfida è determinare se una collezione di pezzi monodimensionali può essere piastrellata per formare un pezzo continuo finito.

Un pezzo è una sequenza finita non vuota di zeri e quelli che iniziano e finiscono con uno. Alcuni pezzi sono possibili 1, 101, 1111, 1100101.

Piastrellare significa disporre i pezzi in modo da formare un singolo blocco contiguo di quelli. Uno da un pezzo può occupare il posto di uno zero, ma non di uno, da un altro pezzo.

Allo stesso modo, se consideriamo uno come "materiale solido" e uno zero come un "foro", i pezzi dovrebbero adattarsi in modo da formare un singolo tratto, senza lasciare alcun foro.

Per formare una piastrellatura, i pezzi possono essere spostati solo lungo il loro spazio unidimensionale. (Non possono essere divisi o riflessi). Ogni pezzo viene usato esattamente una volta.

Esempi

I tre pezzi 101, 11, 101possono essere affiancate come illustrato nel seguito, in cui ogni pezzo è rappresentato con lo spostamento richiesto:

  101
11
   101

quindi la piastrellatura ottenuta è

Come secondo esempio, i pezzi 11011e 1001101non possono essere piastrellati. In particolare, il turno

 11011
1001101

non è valido perché ce ne sono due che si scontrano; e

11011
  1001101

non è valido perché il risultato conterrebbe uno zero.

Regole aggiuntive

L' input è una raccolta di uno o più pezzi. È consentito qualsiasi formato ragionevole; per esempio:

Un elenco di stringhe, in cui ogni stringa può contenere due caratteri diversi e coerenti;
Diversi array, in cui ogni array contiene le posizioni di quelli per un pezzo;
Un elenco di numeri interi (dispari) come la rappresentazione binaria di ciascun numero definisce un pezzo.

L' output dovrebbe essere un valore veritiero se è possibile una piastrellatura e un valore errato in caso contrario. I valori di output non devono essere coerenti; cioè, possono essere diversi per input diversi.

Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .

Vince il codice più breve in byte.

Casi test

Ogni input è su una riga diversa

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

— Luis Mendo
fonte

1

Correlati

— Mago del grano

3

Anche la versione infinita di questo problema potrebbe essere interessante (ovvero se un set di tessere può riempire completamente la linea 1D senza sovrapposizioni). Quindi cose del genere 101101sarebbero veritiere, anche se nessun numero finito di esse risulta in un blocco contiguo.

— Martin Ender,

4

Gelatina , 15 byte

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

Prende un elenco di indici e restituisce un numero intero positivo (verità) o 0 (falsa).

Provalo online! o verifica la maggior parte dei casi di test .

— Dennis
fonte

8

JavaScript (ES6), 74 73 70 byte

Accetta l'input come una matrice di numeri interi a 32 bit. Restituisce un valore booleano.

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

O 66 byte con valori di verità / falsità invertiti:

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

Casi test

Mostra snippet di codice

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

Espandi frammento

Come?

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

— Arnauld
fonte

4

Buccia , 16 byte

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

Accetta un elenco di elenchi di indici basati su 1. Provalo online!

Spiegazione

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

— Zgarb
fonte

3

Gelatina , 16 byte

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

Un collegamento monadico che prende un elenco di elenchi di uno e zeri che ritornano 1(verità) o 0(falsità).

Provalo online! oppure vedere una suite di test (abbreviata: i primi 6 falsi seguiti dai primi otto verità poiché la lunghezza di quattro richiede troppo tempo per essere inclusa a causa dell'uso del prodotto cartesiano).

Come?

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)

— Jonathan Allan
fonte

2

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)

Provalo online!

— Halvard Hummel
fonte

1

153 byte

— ovs

2

Gelatina , 16 byte

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

Provalo online!

-1 byte grazie a Mr. Xcoder

L'ho sviluppato completamente indipendentemente da Jonathan Allan ma ora guardare il suo è esattamente lo stesso:

— HyperNeutrino
fonte

1

J , 74 byte

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

Potrei provare a renderlo tacito in seguito, ma per ora è un verbo esplicito. Spiegherò la versione non golfata. Prende un elenco di numeri interi restituiti 1(verità) o 0(falsa).

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

Provalo online!

— Galen Ivanov
fonte

Tetti finiti in una dimensione

Esempi

Regole aggiuntive

Casi test

Truthy

Falsy

Gelatina , 15 byte

JavaScript (ES6), 74 73 70 byte

Casi test

Come?

Buccia , 16 byte

Spiegazione

Gelatina , 16 byte

Come?

Python 2 , 159 byte

Gelatina , 16 byte

J , 74 byte