Esta es mi primera pregunta aquí, por lo que cualquier sugerencia en los comentarios sería apreciada. Gracias ;)

Introducción

Una estrategia muy común para el juego 2048 es nunca deslizar hacia abajo . Esto coloca todos los números grandes en la parte superior y los más bajos en la parte inferior. Entonces, si aplica esta estrategia correctamente, su tablero siempre coincidirá con el siguiente patrón:

El patrón para verificar / Su tarea

Su envío debe ser un programa completo o una función que devuelva un valor verdadero si el tablero se puede describir así: bajando cada columna del tablero, el primer número debe ser el más alto de la columna, el segundo número debe ser menor igual o igual que el primer número, etc. Un buen tablero de 2048 se define como un tablero donde los números más altos están todos en la parte superior. Este es el código de golf , por lo que gana el código más corto por idioma (en bytes).

I / O

La entrada se puede tomar de cualquier manera apropiada, por ejemplo, una matriz de 4 matrices, cada una con 4 números, o una matriz de 16 números. En total, siempre serán 16 números, que representan la placa 4x4. La salida debe ser un valor verdadero de la entrada es una "placa 2048 buena", y un valor falso de lo contrario.

Ejemplos

Verdad:

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

Mire el segundo caso de prueba de falsedad: cuando hay un valor vacío (o un 0) en algún lugar e incluso cuando es seguido por un valor que es más alto que el último número distinto de cero, esto debería ser falso, porque el siguiente valor después de cero sería más alto que el 0 en sí mismo, lo que lo hace inválido.

¡Buena suerte!

Haskell , 21 bytes

all$scanr1 max>>=(==)

Pruébalo en línea!

Toma una lista de columnas, con espacios vacíos como 0.

05AB1E , 4 bytes

€{íQ

Pruébalo en línea!

Igual que mis otras dos respuestas. Prometo que este es el último hasta que otros hayan respondido :)

APL (Dyalog) , 7 4 bytes

Toma una matriz de 4 por 4, usando 0 para espacios en blanco, como argumento.

⊢≡⌊⍀

Pruébalo en línea!

⌊⍀ es el mínimo acumulativo vertical

≡ idéntico a

⊢ el argumento sin modificar?

Jalea , 4 bytes

Ṣ€U⁼

Pruébalo en línea!

Entrada como una matriz de columnas. Funciona con cuadrículas de tamaño arbitrario.

R (+ pryr), 23 bytes

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

Que evalúa la función

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

Que toma una matriz como entrada:

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

Cuando se le da una matriz, diffcalcula automáticamente las diferencias dentro de las filas (sorprendentemente. No conocía esta característica hasta que la probé para este desafío).

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

Ninguno de estos valores puede ser 1 o superior en una buena tabla, por lo que probamos <1y vemos si los allvalores de la matriz cumplen.

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

[1] TRUE

JavaScript, 37 bytes

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

Llámalo así:

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

Probado en Firefox, Chrome, JavaScript Shell y Node.js.

Python 3 , 42 bytes

lambda l:all(x==sorted(x)[::-1]for x in l)

Pruébalo en línea!

Mismo algoritmo que mi respuesta Jelly

C # (.NET Core) , 71 bytes

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

Pruébalo en línea!

La forma aburrida. Espera entrada aplanada en una matriz lineal.

Alternativamente, la forma explícitamente prohibida:

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

Pruébalo en línea!

Lanza una IndexOutOfBoundsException para indicar verdadero, termina normalmente para indicar falso. Probé una versión que incluía la conversión de excepción / no excepción a verdadero / falso, pero terminó tan larga como la versión normal.

JavaScript, 34 , 32 bytes

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

Llame pasando una sola matriz que contenga la primera columna, seguida de la 2da, 3ra y 4ta.

Compara cada número con el número anterior, excepto el primer número de cada columna y devuelve verdadero si todos son verdaderos.

Prueba

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

Editar: guardado 2 bytes gracias a tsh

Haskell , 28 bytes

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

También hay

all$(==)=<<sort

con 15 bytes, pero se requiere import Data.Listcuando se trabaja solo con Prelude. Alternativamente,

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

con 25 bytes funciona en GHCI.

Gaia , 3 6 bytes

^{+3 bytes porque aparentemente no sabía cómo funcionaba mi idioma}

ọ¦_ẏ⁇!

Esta es una función que acepta una lista de columnas y deja el resultado en la pila.

Existen algunas otras soluciones de 6 bytes que incluyen 0+¦o¦ẏy ọ¦_ẏ¦ỵ.

Pruébalo en línea!

Explicación

ọ¦      Deltas of each column
  _     Flatten
   ẏ⁇   Keep only positive numbers
     !  Negate (is it empty?)

TI-BASIC, 25 bytes

Toma la entrada como una matriz 4x4 en Ans.

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

Explicación

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.

Haskell , 41 bytes

f[x]=1>0
f(a:b:c)|a<b=1<0|1>0=f$b:c
all f

Pruébalo en línea!

Define la función sin puntos all f, donde fdetermina si una lista está ordenada.

JavaScript (ES6), 42 bytes

Toma una gran variedad de columnas; devuelve un número (verdadero) o false.

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

JavaScript (ES6), 54 47 bytes

Primer intento. Toma una gran variedad de columnas; vuelve trueo false.

a=>a.every(c=>c.slice(1).every((n,i)=>n<=c[i]))

MATL , 4 bytes

SGX=

Pruébalo en línea!

Ingrese como un conjunto de filas, al revés.

S       % sort columns
GX=     % compare with input
        % true if arrays are numerically equal
        % (implicit) convert to string and display

Swift 4 , 84 77 bytes

func f(l:[[Int]]){print(l.filter{$0.reversed()==$0.sorted()}.count==l.count)}

Pruébalo en línea!

Dyalog APL, 21 19 15 bytes

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

Pruébalo en línea! (modificado para que se ejecute en tryapl)

Toma la entrada como una matriz 2D.

¿Cómo?

• ⎕ entrada
• ⍉ transponer
• ↓ Matriz 2D => vector 1D de vectores 1D
• { ... }¨aplique esto a cada miembro (argumento ⍵):
  • ⍵[⍒⍵] ⍵ ordenado descendente
  • ⍵≡ igualdad con ⍵
• ∧/si cada elemento es 1.

Japt , 7 bytes

Probé algunos métodos diferentes para este, pero, al final, el más corto que pude encontrar terminó siendo un puerto de la solución JS de tsh.

Toma una matriz de columnas como entrada. Las celdas vacías se pueden 0omitir si no hay otros números en la columna.

P+U¥®n§

Pruébalo

Explicación

Entrada implícita de matriz U.

P+U

Anteponga Uuna cadena vacía, convirtiendo la matriz en una cadena.

¥

Verifique la igualdad, que también arroja el lado derecho a una cuerda.

®

Mapa terminado U.

n§

Ordenar ( n) por <=.

Salida implícita del resultado booleano.

Clojure, 30 bytes

(partial every? #(apply >= %))

pruébalo en línea

Java 8, 69 bytes

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

Bueno, al momento de escribir esto, esto supera a la solución Swift, ¡así que eso es todo! Completamente directo. La entrada es una matriz de matrices enteras, las matrices internas son columnas de la placa (primero los cuadrados superiores). Fundido aFunction<int[][], Boolean> .

MY , 66 62 20 bytes (sin competencia)

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

Pruébalo en línea!

La razón por la cual esto no compite es que recientemente implementé 8E (≡) , lo que equivale a APL ≡.

¿Cómo?

• ω⍉ El primer argumento de línea de comando transpuesto
• ω⍉ El primer argumento de línea de comando transpuesto
• A6ǵ'empujar chr(0x6A)(⍖ en la página de códigos, que se ordena descendente)
• ƒ como una función, en lugar de una cadena
• ⇹ empujar una función que mapea una función emergente sobre cada argumento
• ( aplicar
• E8ǵ'ƒ⇹( lo mismo, excepto con chr(0x8E), que es el comando match ( ≡).
• Π producto
• ← salida sin nueva línea

Sí, muchos de los símbolos de MY son exactamente iguales o similares a los de APL. La explicación es que me vinieron a la mente cuando quería un comando de 1 carácter. (No sé por qué no usé ^T para transponer)

Mathematica, 27 bytes

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

Explicación:

• Threades una extraña operación de transposición general que sucede que toma la transposición cuando se le da una matriz .
• t=Thread;me permite usar tdos veces en lugar de Threaddos veces para guardar bytes.
• Sort ordena una lista (en orden creciente).
• Sort\@asigna la Sortfunción a cada elemento de una lista individualmente; cuando se aplica a una matriz, ordena las filas.
• t@#aplica la función de transposición a la entrada #de la función principal.
• - toma el negativo de todas las entradas para que al ordenar las filas de la matriz transpuesta (las columnas del original) las clasifique de la manera deseada.
• Lo externo -t[...]deshace lo negativo y la transposición, por lo que todo lo que realmente hicimos fue ordenar las columnas de mayor a menor.
• ==# prueba para ver si esta nueva matriz ordenada por columnas es igual a la entrada original.
• &finaliza la función anónima con la entrada #que definimos.

Puede probarlo en línea en el sandbox de Wolfram Cloud pegando código como el siguiente y haciendo clic en Gear -> "Evaluar celda" o presionando Shift + Enter o el teclado numérico Enter:

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

O para todos los casos de prueba:

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}}}]&