¿Es una buena placa 2048?


26

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!


Los comentarios no son para discusión extendida; Esta conversación se ha movido al chat .
Martin Ender

Respuestas:


16

Haskell , 21 bytes

all$scanr1 max>>=(==)

Pruébalo en línea!

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


Da la salida incorrecta para [[16,8,4,0],[16,0,4,4],[16,4,4,4],[16,4,4,4]].
Jonathan Allan

@JonathanAllan Devuelve falso como debería, su segunda columna es [16,0,4,4] que no es monotónica. ¿O me estoy perdiendo algo?
Quiero hacer juegos el

0 es su marcador de posición para una celda vacía, no un valor de 0.
Jonathan Allan

2
@Iwanttomakegames ese comentario fue para ti (reemplaza "tu" con "el").
Jonathan Allan

@JonathanAllan Lamento toda la confusión, pero 0 debería, al representar una celda vacía, contar como el valor 0. Las celdas vacías deben tratarse como el valor '0'.
dv02


9

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?


¡Golf increíble! (Lo esperaba de alguien que trabaja para Dyalog y que ha programado APL durante mucho tiempo). Y sí, MY tiene muchos símbolos APL, aunque no son símbolos APL. Alpha, Iota, Omega son todos griegos, no APL técnicamente. Primero vinieron a la mente al pensar en comandos de un personaje. Por lo tanto, el incremento y la disminución de MY son los de Jelly, porque eso vino a mi mente primero. (Solo para notificarlo, estoy suspendido del chat, de ahí la respuesta aquí.)
Zacharý

7

Jalea , 4 bytes

Ṣ€U⁼

Pruébalo en línea!

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


¿Cuál es la representación de una celda vacía? (p. ej., tercera columna del segundo caso de prueba de falsey) - "en total siempre serán 16 números" Funcionaría con ceros si los filtra primero.
Jonathan Allan

@JonathanAllan Según las especificaciones, creo que esto también es válido
HyperNeutrino

Sin embargo, ahora que se producirá un error de mi caso de prueba sugerido regresar 0en lugar de 1.
Jonathan Allan

@JonathanAllan ¿Cómo se filtra en Jelly ._. Espero que esto funcione, pero ḟ0no funciona
HyperNeutrino

1
@DirtyDev Está bien, estamos aquí para disfrutar de los desafíos y ayudar a los nuevos usuarios a acostumbrarse a este lugar :) Espero que estén disfrutando de la comunidad
HyperNeutrino

6

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

5

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.


¿Por qué conviertes el resultado en una cadena? ( ''+)
Zacharý

@ Zacharý sortes un método mutable, que mutará la matriz. primero convertir a cadena guardará una copia de la matriz. la conversión a cadena también hace que la operación igual funcione por (cadena) en lugar de referencia
tsh


4

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.


4

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


después de una transformación booleana:v=>!v.some((x,i)=>i%4&&x>v[i-1])
tsh

3

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.


3

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

No puedo votar en contra, pero usar un operador agregado al idioma después de que se publicó el desafío no me parece justo. También parece estar prohibido de manera predeterminada de acuerdo con esto .
Cinaski el

@Cinaski Nos hemos alejado de esa regla, como se ve aquí . De cualquier manera, mis soluciones alternativas solo usan operadores que definitivamente existieron antes del desafío.
Business Cat

Voy a cambiar a uno de los otros supongo
Business Cat

No importa, no estaba al tanto de esa nueva regla.
Cinaski

3

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.


2

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

¿Qué valor esperas para las celdas vacías?
Arnauld

2

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

No funciona para casos que deberían devolver la verdad que tienen ceros entre elementos de columna como este, por ejemplo.
Jonathan Allan

Tienes razón, estoy trabajando en una solución. Por cierto, no soy el único que tiene problemas con las celdas vacías;)
Cinaski

Sí, puedo ver eso. También sugerí un caso de prueba. Haga ping cuando esté arreglado y recibirá un voto positivo de mí :)
Jonathan Allan

@JonathanAllan espera, ¿quién dijo que debería devolver la verdad cuando hay ceros entre los elementos de la columna? Mire mi segundo caso de prueba falsa, una celda vacía / a 0 seguida de un valor más alto cuando baja no es válida.
dv02

@DirtyDev FYI con la redacción dada originalmente, y su interpretación sensata, su segundo caso de falsey aún sería falsey; es solo que mi caso de prueba sugerido sería verdadero.
Jonathan Allan


2

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.


2

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.

Ordenar ( n) por <=.

Salida implícita del resultado booleano.


Buen arreglo para saltear el segundo U. También podría hacerlo nnal final;)
ETHproductions

Me sorprendió descubrir que omitir el segundo Ufuncionó en este caso, @ETHproductions; Pensé que solo funcionaría si la variable fuera lo único a la izquierda del ==. Tendré que recordarlo para usarlo en el futuro.
Shaggy


1

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


1

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)


0

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}}}]&
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.