È una buona tavola 2048?

26

Questa è la mia prima domanda qui, quindi qualsiasi suggerimento nei commenti sarebbe apprezzato! Grazie ;)

introduzione

Una strategia molto comune per il gioco del 2048 non è mai scorrere verso il basso . Questo posiziona tutti i grandi numeri in alto e quelli inferiori in basso. Quindi, se applichi correttamente questa strategia, la tua scheda corrisponderà sempre al seguente schema:

Il modello da verificare per / Il tuo compito

La tua proposta dovrebbe essere un programma completo o una funzione che restituisca un valore di verità se la scheda può essere descritta in questo modo: scendendo ogni colonna della scheda, il primo numero dovrebbe essere il più alto della colonna, il secondo numero dovrebbe essere inferiore uguale o uguale al primo numero, ecc. Una buona scheda 2048 è definita come una scheda in cui i numeri più alti sono tutti in cima. Questo è code-golf , quindi vince il codice più breve per lingua (in byte).

I / O

L'input può essere preso in qualsiasi modo appropriato, ad esempio un array di 4 array, ciascuno contenente 4 numeri, o un array di 16 numeri. In totale, saranno sempre 16 numeri, che rappresentano la scheda 4x4 L'output dovrebbe essere un valore veritiero dell'input è una "buona scheda 2048" e un valore falso altrimenti.

Esempi

Truthy:

|-------------------|
| 16 |    | 64 |  8 |
|-------------------|
|  8 |    | 32 |  8 |
|-------------------|
|  4 |    | 32 |  2 |
|-------------------|
|  2 |    |    |    |
|-------------------|


|-------------------|
| 16 | 128| 64 | 32 |
|-------------------|
|  8 | 128| 32 |  8 |
|-------------------|
|  4 | 16 |  8 |  2 |
|-------------------|
|  4 |    |    |    |
|-------------------|

Falsy:

|-------------------|
| 16 |    | 64 |  8 |
|-------------------|
|  8 |    | 32 | 16 |
|-------------------|
| 32 |    | 128|  2 |
|-------------------|
|  2 |    |    |    |
|-------------------|


|-------------------|
| 16 | 128| 64 | 32 |
|-------------------|
|  8 |  32|    |  8 |
|-------------------|
|  4 | 16 |  8 |  2 |
|-------------------|
|  4 |    |    |    |
|-------------------|

Nota

Guarda il 2 ° caso di test di falsa: quando c'è un valore vuoto (o uno 0) da qualche parte e anche quando è seguito da un valore che è superiore all'ultimo numero diverso da zero, questo dovrebbe essere falso, perché il valore successivo dopo il zero sarebbe maggiore dello 0 stesso, il che lo rende non valido.

In bocca al lupo!

code-golf  decision-problem  matrix  board-game  sliding-puzzle 
— dv02
fonte
I commenti non sono per una discussione estesa; questa conversazione è stata spostata in chat .
— Martin Ender,

Risposte:

16

Haskell , 21 byte

all$scanr1 max>>=(==)

Provalo online!

Prende un elenco di colonne, con spazi vuoti come 0.

— XNOR
fonte
Fornisce un output errato per [[16,8,4,0],[16,0,4,4],[16,4,4,4],[16,4,4,4]].
— Jonathan Allan,
@JonathanAllan Restituisce falso come dovrebbe, la tua seconda colonna è [16,0,4,4] che non è monotona. Oppure mi sfugge qualcosa?
— Voglio fare giochi il
0 è il tuo segnaposto per una cella vuota, non un valore di 0.
— Jonathan Allan
2
@Iwanttomakegames quel commento è stato pensato per te (sostituisci "tuo" con "il").
— Jonathan Allan,
@JonathanAllan Mi dispiace per tutta la confusione, ma in effetti 0, pur rappresentando una cella vuota, conta come il valore 0. Le celle vuote devono essere trattate come il valore '0'.
— DV02
9

APL (Dyalog) , 7 4 byte

Accetta la matrice 4 per 4, usando 0 per gli spazi vuoti, come argomento.

⊢≡⌊⍀

Provalo online!

⌊⍀ è il minimo cumulativo verticale

≡ uguale a

⊢ l'argomento non modificato?

— Adamo
fonte
Incredibile golf! (Me l'aspettavo da qualcuno che lavora per Dyalog e ha programmato APL per molto tempo). E sì, MY ha molti simboli APL, anche se non sono simboli APL. Alpha, Iota, Omega sono tutti greci, non tecnicamente APL. Sono venuti in mente per primi quando hanno pensato ai comandi di un personaggio. Quindi l'incremento e il decremento di MY sono quelli di Jelly, perché mi sono venuti in mente per primi. (Solo per avvisarti, sono sospeso dalla chat, quindi la risposta qui.)
— Zacharý
7

Gelatina , 4 byte

Ṣ€U⁼

Provalo online!

Input come una matrice di colonne. Funziona con griglie di dimensioni arbitrarie.

— HyperNeutrino
fonte
Qual è la rappresentazione di una cella vuota? (ad es. 3a colonna del secondo caso di prova del falso) - "in totale saranno sempre 16 numeri". Funzionerebbe con gli zeri se li filtrassi prima.
— Jonathan Allan,
@JonathanAllan Secondo le specifiche, penso che anche questo sia valido
— HyperNeutrino
Tuttavia, ciò non riuscirà a restituire il mio caso di test suggerito0 anziché 1.
— Jonathan Allan,
@JonathanAllan Come si filtra in Jelly ._. Mi aspetto questo di lavoro, ma ḟ0non funziona
— HyperNeutrino
1
@DirtyDev Va bene, siamo qui per goderci le sfide e aiutare i nuovi utenti ad abituarsi a questo posto :) Spero che ti stia godendo la community
— HyperNeutrino
6

R (+ pryr), 23 byte

pryr::f(all(diff(x))<1)

Che valuta la funzione

function (x) 
all(diff(x)) < 1

Che accetta una matrice come input:

     [,1] [,2] [,3] [,4]
[1,]   16    0   64    8
[2,]    8    0   32    8
[3,]    4    0   32    2
[4,]    2    0    0    0

Quando viene data una matrice, diffcalcola automaticamente le differenze all'interno delle righe (sorprendentemente. Non conoscevo questa funzione fino a quando non l'ho provata per questa sfida).

     [,1] [,2] [,3] [,4]
[1,]   -8    0  -32    0
[2,]   -4    0    0   -6
[3,]   -2    0  -32   -2

Nessuno di questi valori può essere 1 o superiore in una buona scheda, quindi testiamo <1e vediamo se i allvalori della matrice sono conformi.

     [,1] [,2] [,3] [,4]
[1,] TRUE TRUE TRUE TRUE
[2,] TRUE TRUE TRUE TRUE
[3,] TRUE TRUE TRUE TRUE

[1] TRUE
— JAD
fonte
5

JavaScript, 37 byte

x=>''+x==x.map(v=>v.sort((x,y)=>y-x))

Chiamalo così:

|-------------------|
| 16 |    | 64 |  8 |
|-------------------|
|  8 |    | 32 |  8 |
|-------------------|
|  4 |    | 32 |  2 |
|-------------------|
|  2 |    |    |    |
|-------------------|

f([[8,8,2,0],[64,32,32,0],[0,0,0,0],[16,8,4,2]])

Testato su Firefox, Chrome, JavaScript Shell e, Node.js.

— tsh
fonte
Perché trasformi il risultato in una stringa? ( ''+)
— Zacharý,
@ Zacharý sortè un metodo mutabile, che modificherà l'array. la prima conversione in stringa salverà una copia dell'array. la conversione in stringa fa anche in modo che l'operazione uguale funzioni per valore (stringa) anziché per riferimento.
— TSH
4

C # (.NET Core) , 71 byte

i=>{for(int n=3;++n<i.Length;)if(i[n]>i[n-4])return false;return true;}

Provalo online!

Il modo noioso. Si aspetta input appiattito in un array lineare.

In alternativa, il modo esplicitamente vietato:

i=>{for(int n=3;i[++n]<=i[n-4];);}

Provalo online!

Genera IndexOutOfBoundsException per indicare true, termina normalmente per indicare false. Ho provato una versione che includeva la conversione da eccezione / nessuna eccezione a vero / falso, ma è finita tanto quanto la versione normale.

— Kamil Drakari
fonte
4

JavaScript, 34 , 32 byte

v=>!v.some((x,i)=>i%4&&x>v[i-1])

Chiamare passando in un singolo array contenente la prima colonna, seguito dal 2 °, 3 ° e 4 °.

Confronta ogni numero con il numero precedente tranne il primo numero di ogni colonna e restituisce true se tutti sono true.

Test

f=v=>!v.some((x,i)=>i%4&&x>v[i-1])

f([16,8,4,2,0,0,0,0,64,32,32,0,8,8,2,0])
f([16,8,4,4,128,128,16,0,64,32,8,0,32,8,2,0])
f([16,8,32,2,0,0,0,0,64,32,128,0,8,16,2,0])
f([16,8,4,4,128,32,16,0,64,0,8,0,32,8,2,0])

Modifica: salvato 2 byte grazie a tsh

— Grax32
fonte
dopo qualche booleana trasformare:v=>!v.some((x,i)=>i%4&&x>v[i-1])
— TSH
3

Haskell , 28 byte

all$and.(zipWith(>=)=<<tail)

C'è anche

all$(==)=<<sort

con 15 byte ma richiede solo import Data.Listquando si lavora con Prelude. In alternativa,

all$(==)=<<Data.List.sort

con 25 byte funziona in GHCI.

— Bergi
fonte
3

Gaia , 3 6 byte

+3 byte perché apparentemente non sapevo come funzionasse la mia lingua

ọ¦_ẏ⁇!

Questa è una funzione che accetta un elenco di colonne e lascia il risultato in pila.

Esistono alcune altre soluzioni a 6 byte tra cui 0+¦o¦ẏe ọ¦_ẏ¦ỵ.

Provalo online!

Spiegazione

ọ¦      Deltas of each column
  _     Flatten
   ẏ⁇   Keep only positive numbers
     !  Negate (is it empty?)
— Gatto di affari
fonte
Non posso sottovalutare, ma usare un operatore aggiunto alla lingua dopo che la sfida è stata pubblicata non mi sembra giusto, ma sembra essere proibito di default in base a questo .
— Cinaski,
@Cinaski Ci siamo allontanati da questa regola, come visto qui . Ad ogni modo, le mie soluzioni alternative utilizzano solo operatori che esistevano sicuramente prima della sfida.
— Business Cat
Lo cambierò semplicemente con uno degli altri, credo
— Business Cat,
Non importa, non ero a conoscenza di quella nuova regola.
— Cinaski,
3

TI-BASIC, 25 byte

Accetta input come matrice 4x4 in Ans.

For(R,1,3
*row+(-1,Ans,R+1,R
End
Ans=abs(Ans

Spiegazione

For(R,1,3             Loop from row 1 to 3.

*row+(-1,Ans,R+1,R    Multiply row R+1 by -1 and add it to row R in-place.
                      Effectively, this subtracts row R+1 from row R.

End                   Now the first 3 rows contain the row differences,
                      and the 4th row is non-negative assuming valid input.

Ans=abs(Ans           Check whether every element in the matrix is equal to its
                      absolute value, or in other words, contains no negative values.
— calc84maniac
fonte
2

JavaScript (ES6), 42 byte

Accetta una matrice di colonne; restituisce un numero (veritiero) o false.

a=>a.every(c=>c.reduce((r,n)=>r&&n<=r&&n))

JavaScript (ES6), 54 47 byte

Primo tentativo. Accetta una matrice di colonne; ritorna trueo false.

a=>a.every(c=>c.slice(1).every((n,i)=>n<=c[i]))
— darrylyeo
fonte
Quale valore ti aspetti dalle celle vuote?
— Arnauld
2

MATL , 4 byte

SGX=

Provalo online!

Input come una matrice di righe, sottosopra.

S       % sort columns
GX=     % compare with input
        % true if arrays are numerically equal
        % (implicit) convert to string and display
— Cinaski
fonte
Non funziona per i casi che dovrebbero restituire la verità, ad esempio con zeri tra elementi di colonna come questo .
— Jonathan Allan,
Hai ragione, sto lavorando a una soluzione. A proposito, non sono l'unico ad avere problemi con le celle vuote;)
— Cinaski
Sì, posso vederlo. Ho suggerito un caso di prova anche per questo. Effettua il ping quando viene risolto e otterrai un voto da parte mia :)
— Jonathan Allan il
@JonathanAllan aspetta, chi ha detto che dovrebbe restituire la verità quando ci sono zeri tra gli elementi della colonna? Guarda il mio secondo caso di falsa prova, una cella vuota / uno 0 seguita da un valore più alto quando si scende non è valida.
— DV02
@DirtyDev FYI con la formulazione originariamente fornita e la sua interpretazione ragionevole, il tuo secondo caso di falsità sarebbe ancora falso; è solo il mio caso di prova suggerito sarebbe vero.
— Jonathan Allan,
2

Dyalog APL, 21 19 15 byte

∧/{⍵≡⍵[⍒⍵]}¨↓⍉⎕

Provalo online! (modificato in modo che venga eseguito in tryapl)

Accetta input come un array 2D.

Come?

  • ⎕ ingresso
  • ⍉ trasporre
  • ↓ Matrice 2D => vettore 1D di vettori 1D
  • { ... }¨applicare questo a ciascun membro (argomento ⍵):
    • ⍵[⍒⍵] ⍵ in ordine decrescente
    • ⍵≡ uguaglianza con ⍵
  • ∧/se ogni elemento lo è 1.
— Zaccaria
fonte
— Adám,
2

Japt , 7 byte

Ho provato alcuni metodi diversi per questo, ma, alla fine, il più breve che ho potuto trovare è diventato un porto della soluzione JS di tsh.

Accetta una matrice di colonne come input. Le celle vuote possono essere 0o omesse se non ci sono altri numeri nella colonna.

P+U¥®n§

Provalo

Spiegazione

Input implicito di array U.

P+U

Prependi Ucon una stringa vuota, convertendo l'array in una stringa.

¥

Controlla l'uguaglianza, che getta anche il lato destro in una stringa.

®

Mappa sopra U.

n§

Ordina ( n) per <=.

Emette implicitamente un risultato booleano.

— ispido
fonte
Bella disposizione per saltare il secondo U. Potresti anche fare nnalla fine;)
— ETHproductions
Sono stato sorpreso di scoprire che omettere il secondo ha Ufunzionato in questo caso, @ETHproductions; Ho pensato che avrebbe funzionato solo se la variabile fosse l' unica cosa a sinistra di ==. Dovrò ricordarlo per un uso futuro.
— Shaggy
1

Java 8, 69 byte

b->{for(int[]c:b)for(int i=0,f=1;i<3;)if(c[i]<c[++i])f=0;return f>0;}

Bene, al momento della stesura di questo, batte la soluzione Swift, quindi c'è! Assolutamente semplice. L'input è una matrice di matrici intere, le matrici interne sono colonne della scheda (prima i quadrati superiori). Cast to Function<int[][], Boolean>.

— Jakob
fonte
1

MY , 66 62 20 byte (non competitivo)

ω⍉ω⍉A6ǵ'ƒ⇹(E8ǵ'ƒ⇹(Π←

Provalo online!

Il motivo per cui non è in competizione è che di recente ho implementato 8E (≡), che è equivalente a APL ≡.

Come?

  • ω⍉ Trasposto il primo argomento della riga di comando
  • ω⍉ Trasposto il primo argomento della riga di comando
  • A6ǵ'push chr(0x6A)( ⍖nella tabella codici, che ordina in ordine decrescente)
  • ƒ come una funzione, piuttosto che una stringa
  • ⇹ spingere una funzione che mappa una funzione saltata su ogni argomento
  • ( applicare
  • E8ǵ'ƒ⇹( la stessa cosa, tranne con chr(0x8E), che è il comando match ( ≡).
  • Π Prodotto
  • ← uscita senza newline

Sì, molti dei simboli MY sono esattamente uguali o simili a quelli di APL. La spiegazione è che mi sono venuti in mente quando volevo un comando di 1 carattere. (Non so perché non ho usato T per trasporre)

— Zaccaria
fonte
0

Mathematica, 27 byte

t=Thread;-t[Sort/@-t@#]==#&

Spiegazione:

  • Threadè una strana operazione generale di trasposizione che capita di prendere la trasposizione quando viene data una matrice .
  • t=Thread;mi consente di utilizzare tdue volte anziché due Threadvolte per salvare byte.
  • Sort ordina un elenco (in ordine crescente).
  • Sort\@associa la Sortfunzione a ciascun elemento di un elenco singolarmente; quando applicato a una matrice, ordina le righe.
  • t@#applica la funzione di trasposizione all'ingresso #della funzione principale.
  • - prende il negativo di tutte le voci in modo che l'ordinamento delle righe della matrice trasposta (le colonne dell'originale) le ordina nel modo desiderato.
  • L'esterno -t[...]annulla il negativo e il recepimento, quindi tutto ciò che abbiamo fatto è stato ordinare le colonne dal più grande al più piccolo.
  • ==# verifica se questa nuova matrice ordinata per colonna è uguale all'input originale.
  • &termina la funzione anonima con l'input che #abbiamo definito.

Puoi provarlo online nella sandbox di Wolfram Cloud incollando il codice come il seguente e facendo clic su Gear -> "Valuta cella" o premendo Maiusc + Invio o il tastierino numerico Invio:

t=Thread;-t[Sort/@-t@#]==#&@{{16,128,64,32},{8,32,0,8},{4,16,8,2},{4,0,0,0}}

O per tutti i casi di test:

t=Thread;-t[Sort/@-t@#]==#&//Map[#,{{{16,0,64,8},{8,0,32,8},{4,0,32,2},{2,0,0,0}},{{16,128,64,32},{8,128,32,8},{4,16,8,2},{4,0,0,0}},{{16,0,64,8},{8,0,32,16},{32,0,128,2},{2,0,0,0}},{{16,128,64,32},{8,32,0,8},{4,16,8,2},{4,0,0,0}}}]&
— Mark S.
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.