Sfida segreta di impilamento ">": classificazione
sfondo
Tetris Grand Master 3 ha un sistema di classificazione nascosto basato sulla forma della pila alla fine del gioco, chiamato Secret ">" Stacking Challenge . Consiste nel riempire interamente le righe più basse ad eccezione del motivo a zigzag che inizia dalla cella in basso a sinistra e si estende per l'intera larghezza:
#
.#########
#.########
##.#######
###.######
####.#####
#####.####
######.###
#######.##
########.#
#########.
########.#
#######.##
######.###
#####.####
####.#####
###.######
##.#######
#.########
.#########
Il tabellone viene valutato in base al numero di linee che seguono questo schema esatto dalla linea di fondo. Notare che il foro più in alto nel modello deve essere bloccato da un pezzo di blocco in più. Se consideri la se #la .s come modello obbligatorio (gli spazi possono essere qualsiasi cosa), puoi ottenere il punteggio di 19 solo se il modello esatto sopra è abbinato dalla riga inferiore. Allo stesso modo, se la scacchiera corrisponde a questo modello
#
###.######
##.#######
#.########
.#########
ma no
#
####.#####
###.######
##.#######
#.########
.#########
allora il punteggio è 4.
Per questa sfida, considera una scheda di dimensioni arbitrarie (diversa da 20 celle di altezza e 10 celle di larghezza). Possiamo classificare la tavola per lo stesso schema: ad esempio, se la tavola ha larghezza 4, questo è il modello per il punteggio 3:
#
##.#
#.##
.###
e questo è lo schema per il punteggio 10:
#
###.
##.#
#.##
.###
#.##
##.#
###.
##.#
#.##
.###
Sfida
Dato lo stato finale della scheda Tetris di dimensioni arbitrarie, valutare la scheda utilizzando il sistema sopra.
Puoi prendere la lavagna utilizzando qualsiasi formato ragionevole per una matrice rettangolare, in cui ogni cella contiene uno dei due valori distinti (rispettivamente per vuoto e riempito). Puoi presumere che la griglia sia una bacheca Tetris valida (nessuna riga è interamente riempita). Inoltre, la larghezza della griglia è almeno 2.
Si applicano le regole standard del golf da codice . Il codice più breve in byte vince.
Casi test
Per evitare possibili confusioni, i casi di test qui usano Oper i blocchi e .per gli spazi vuoti.
Input:
..O.O
OOOO.
OOO..
OO.OO
O.OOO
.OOOO
Output: 3
Input:
..
O.
.O
.O
O.
.O
O.
.O
Output: 4
Input:
.OOO
O.OO
OO.O
OO.O
OO.O
O.OO
.OOO
Output: 2 (any lines above the first non-conforming line are ignored;
doesn't get 3 because 3rd line's hole is not capped)
Input:
OOO.
.OOO
O.OO
OO.O
OOO.
OO.O
O.OO
Output: 0 (Wrong starting hole)
Input:
.OOO
O.OO
OO.O
OOO.
Output: 0 (Wrong starting hole)
Input:
.OOO
.OOO
Output: 0 (Hole is not covered)
Input:
OOO...O..O
.OOOOOOOOO
O.OOOOOOOO
OO.OOOOOOO
OOO.OOOOOO
OOOO.OOOOO
OOOOO.OOOO
OOOOOO.OOO
OOOOOOO.OO
OOOOOOOO.O
OOOOOOOOO.
OOOOOOOO.O
OOOOOOO.OO
OOOOOO.OOO
OOOOO.OOOO
OOOO.OOOOO
OOO.OOOOOO
OO.OOOOOOO
O.OOOOOOOO
.OOOOOOOOO
Output: 19
Risposte
JavaScript (ES6), 84 byte
Si aspetta un elenco di stringhe, con 1spazi vuoti e 0blocchi.
f=(a,i=j=1<<a[k=0].length)=>(v='0b'+a.pop()+0)^i?v&i/k&&-1:1+f(a,i*=k=i&j?.5:i&2||k)
Provalo online!
Come?
Ogni stringa nell'array di input viene riempita con un extra 0e interpretata come un numero binario. La variabile jviene inizializzata a 2**W, dove Wè la larghezza della scheda. Usiamo una maschera di bit iinizializzata per jtenere traccia della posizione prevista del foro nel modello.
Dopo ogni iterazione, iviene moltiplicato per k. Aggiorniamo il valore di kogni volta (i & j) != 0(rimbalzo sul lato più a sinistra) o (i & 2) != 0(rimbalzo sul lato più a destra).
Esempio per W = 5:
j = 0b100000
i = 0b100000 // -> set k to 1/2
i = 0b010000 // \
i = 0b001000 // }-> leave k unchanged
i = 0b000100 // /
i = 0b000010 // -> set k to 2
i = 0b000100 // \
i = 0b001000 // }-> leave k unchanged
i = 0b010000 // /
i = 0b100000 // -> set k to 1/2
...
Commentato
f = ( // f is a recursive function taking:
a, // a[] = input array
i = j = // i = hole bit mask, initialized to ...
1 << a[k = 0] // ... j = 2 ** W, where W is the width of the board
.length // k = bit mask multiplier, initialized to 0
) => //
( v = // pop the last value from a[], append a '0' and interpret
'0b' + a.pop() + 0 // it as a binary number saved in v
) ^ i ? // if v is not equal to i:
v & i / k // use the previous bit mask i / k to test whether there's
&& -1 // a hole in v above the last hole of the pattern, in
// which case we subtract 1 from the final result
: // else:
1 + // add 1 to the final result
f( // do a recursive call:
a, // pass a[] unchanged
i *= // multiply i by:
k = // the new value of k:
i & j ? // if we've reached the leftmost side:
.5 // set k to 1/2
: // else:
i & 2 // set k to 2 if we've reached the rightmost side,
|| k // or leave k unchanged otherwise
) // end of recursive call
Husk , 18 byte
Lδ↑€…¢ŀT¹↑εΨ↑-↔m¥0
Provalo online!
Accetta una matrice 0-1.
Spiegazione
Ci sono tre occorrenze di ↑in questo programma e funzionano tutte in modo diverso grazie alle funzioni di modifica δe Ψ. Per impostazione predefinita, si ↑αaspetta αdi essere una funzione unaria, prende una lista e restituisce il prefisso più lungo di elementi per i quali αrestituisce un valore vero. Ψ↑αsi aspetta αdi essere binario e restituisce il prefisso più lungo di elementi xper cui α x yè true, dove si ytrova l'elemento successivo. δ↑αsi aspetta αdi essere binario e prende due elenchi invece di uno. Restituisce il prefisso più lungo della seconda lista i cui elementi ysoddisfano α x y, dove xè l'elemento corrispondente della prima lista.
Input is a list of lists of integers.
Example: [[0,1,1],[1,0,1],[1,1,0],[1,0,1],[1,1,0],[0,0,1],[0,1,1]]
m Map
¥0 indices where 0 occurs:
[[1],[1,2],[3],[2],[3],[2],[1]]
↔ Reverse:
[[1],[2],[3],[2],[3],[1,2],[1]]
↑ Take while
Ψ this element and the next
- have nonempty set difference:
[[1],[2],[3],[2],[3],[1,2]]
↑ Take while
ε this element is a singleton:
[[1],[2],[3],[2],[3]]
Call this list X.
ŀT¹ Indices of input transposed:
[1,2,3]
¢ Cycle infinitely:
[1,2,3,1,2,3,..]
… Rangify:
[1,2,3,2,1,2,3,2,1,..]
↑ Take from X while
δ the corresponding integer in this list
€ is an element of it:
[[1],[2],[3],[2]]
L Length: 4
Carboncino , 52 byte
ＷＳ⊞υι≔⮌υυＰ⪫υ¶Ｗ∧⁼.O⪫ＫＤ²↓ω⁼¹№§υⅉ.Ｍ✳⁻⁷⊗÷﹪ⅉ⊗⊖Ｌθ⊖Ｌθ≔ⅉθ⎚Ｉθ
Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta l'input come un elenco di stringhe di .e Ocaratteri terminato da una nuova riga . Spiegazione:
ＷＳ⊞υι
Inserisci l'elenco.
≔⮌υυ
Inverti l'elenco.
Ｐ⪫υ¶
Stampa l'elenco senza spostare il cursore.
Ｗ∧
Ripeti mentre entrambi ...
⁼.O⪫ＫＤ²↓ω
... il carattere sotto il cursore è a .e il carattere sotto (perché l'elenco è stato invertito) è un O, e ...
⁼¹№§υⅉ.
... la riga della lista corrente ne contiene esattamente uno .:
Ｍ✳⁻⁷⊗÷﹪ⅉ⊗⊖Ｌθ⊖Ｌθ
Spostare il cursore in diagonale verso il basso e verso destra o verso sinistra a seconda della riga.
≔ⅉθ⎚Ｉθ
Cattura il primo indice di riga non valido (indicizzato 0, quindi uguale al numero di righe valide), cancella l'area di disegno e stampalo come una stringa.
J , 57 42 byte
Accetta 0 per bloccato, 1 per vuoto.
[:#.~(|.@$2^|@}:@i:@<:)/@$=2#.[*[+_1|.!.2]
Provalo online!
Come funziona
[*[+_1|.!.2]
Sposta il tabellone verso il basso di uno (2 viene inserito in alto per assicurarsi che i primi posti non contino.) Quindi si aggiunge al tabellone originale e si moltiplica con se stesso. Questo fondamentalmente si riduce a: un punto aperto valido rimane 1, mentre quelli non validi diventano 2.
(|.@$2^|@}:@i:@<:)/@$
Date le dimensioni, ottieni l'intervallo esclusivo -x … x - 1per la larghezza, ad esempio 4:, _3 _2 _1 0 1 2e ottieni i loro valori assoluti 3 2 1 0 1 2. Ridimensiona l'elenco all'altezza del tabellone, ruotalo in modo che i 3 iniziali siano allineati all'ultima riga e 2^xl'elenco:8 4 2 1 2 4 8 4 2…
=2#.
Interpreta le righe come un numero in base 2 e confrontalo con l'elenco a zig-zag.
[:#.~
E mediante conversione di base riflessiva possiamo contare gli 1 iniziali, quindi le righe iniziali valide.
Gelatina , 25 byte
ZJŒḄṖṁLW€⁻"ⱮṚT€,Ḋ$ƊZḄCTḢ’
Un collegamento monadico che accetta un elenco di righe in cui ogni riga è un elenco di 1s (vuoto) e 0s (pieno) che restituisce un numero intero non negativo (il punteggio).
Provalo online! Oppure guarda la suite di test .
Come?
Crea un elenco degli indici vuoti previsti per ciascuna riga dal basso e lo confronta con ciascuno dei due elenchi, (a) gli indici vuoti effettivi e (b) gli indici vuoti effettivi rimossi dalla coda. I risultati di questo confronto vengono quindi elaborati per trovare il punteggio.
ZJŒḄṖṁLW€⁻"ⱮṚT€,Ḋ$ƊZḄCTḢ’ - Link: list of lines, A
Z - transpose
J - range of length -> [1,2,...,w=#Columns]
ŒḄ - bounce -> [1,2,...,w-1,w,w-1,...,2,1]
Ṗ - pop -> [1,2,...,w-1,w,w-1,...,2]
L - length (A) -> h=#Lines
ṁ - mould like (repeat Ṗ result such that it is length h)
W€ - wrap each of these integers in a list (call this x)
Ɗ - last three links as a monad - i.e. f(A):
Ṛ - reverse (A)
T€ - for each (line) get the list of truthy ("empty") indices
$ - last two links as a monad - i.e. f(z=that):
Ḋ - dequeue (drop the leftmost)
, - (z) pair (that)
Ɱ - map across (the two results of f(A)) applying:
" - (x) zip with (result) applying:
⁻ - not equal?
Z - transpose - now we have leading [0,1]'s for valid rows
from the bottom up
Ḅ - convert from binary - now leading 1s for valid rows
C - complement (subtract (each) from one)
T - truthy indices
Ḣ - head
’ - decrement
05AB1E , 32 byte
R©εDgݨû¨NèDU._ƶO®N>èX.__н*Θ}γнO
Immettere come matrice di 1 e 0, dove 1 sono spazi vuoti e 0 sono celle piene.
Provalo online. o verifica tutti i casi di test .
Spiegazione:
R # Reverse the rows of the (implicit) input-matrix
© # Store it in variable `®` (without popping)
ε # Map over each row:
Dg # Get the width of the matrix
Ý # Push a list in the range [0,width]
¨ # Remove the last element to change the range to [0,width-1]
û # Palindromize it: [0,1,2,...,w-2,w-1,w-2,...,2,1,0]
¨ # Remove the last value: [0,1,2,...,w-2,w-1,w-2,...,2,1]
Nè # Index the map-index into this list
DU # Store a copy in variable `X`
._ # Rotate the current row that many times to the left
ƶ # Multiply each value by its 1-based index
O # And sum this list
® # Push the reversed input-matrix again from variable `®`
N>è # Index the map-index + 1 into this to get the next row
X._ # Also rotate it `X` amount of times towards the left
_ # Invert all booleans (1s becomes 0s, and vice-versa)
н # And only leave the first value
* # Multiply both together
Θ # And check that it's equal to 1 (1 if 1; 0 otherwise)
}γ # After the map: split the list into groups of adjacent equivalent values
н # Only leave the first group
O # And take the sum of that
# (after which it is output implicitly as result)