Esta é a minha primeira pergunta aqui, então qualquer sugestão nos comentários seria apreciada! Obrigado ;)

Introdução

Uma estratégia muito comum para o jogo de 2048 nunca é derrubada . Isso posiciona todos os grandes números no topo e os mais baixos no fundo. Portanto, se você aplicar essa estratégia corretamente, seu quadro sempre corresponderá ao seguinte padrão:

O padrão a ser verificado / Sua tarefa

Sua submissão deve ser um programa completo ou uma função que retorne um valor verdadeiro se o quadro puder ser descrito desta maneira: Descendo cada coluna do quadro, o primeiro número deve ser o mais alto da coluna, o segundo número deve ser menor igual ou igual ao primeiro número, etc. Uma boa placa de 2048 é definida como uma placa em que os números mais altos estão todos no topo. Isso é código-golfe , então o código mais curto por idioma (em bytes) vence.

I / O

A entrada pode ser obtida de qualquer maneira apropriada, por exemplo, uma matriz de 4 matrizes, cada uma contendo 4 números ou uma matriz de 16 números. No total, sempre haverá 16 números, representando a placa 4x4. A saída deve ser um valor verdadeiro da entrada: uma "boa placa 2048" e, caso contrário, um valor falso.

Exemplos

Verdade:

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

Veja o segundo caso de teste falso: quando houver um valor vazio (ou 0) em algum lugar e mesmo quando for seguido por um valor maior que o último número diferente de zero, isso deve ser falso, porque o próximo valor após o zero seria maior que o próprio 0, o que o torna inválido.

Boa sorte!

Haskell , 21 bytes

all$scanr1 max>>=(==)

Experimente online!

Leva uma lista de colunas, com espaços vazios como 0.

05AB1E , 4 bytes

€{íQ

Experimente online!

O mesmo que as minhas outras duas respostas. Eu prometo que este é o meu último até que outros tenham respondido :)

APL (Dyalog) , 7 4 bytes

Assume a matriz 4 por 4, usando 0 para espaços em branco, como argumento.

⊢≡⌊⍀

Experimente online!

⌊⍀ é o mínimo cumulativo vertical

≡ idêntico a

⊢ o argumento não modificado?

Gelatina , 4 bytes

Ṣ€U⁼

Experimente online!

Entrada como uma matriz de colunas. Funciona com grades de tamanho arbitrário.

R (+ pryr), 23 bytes

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

Que avalia a função

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

O que leva uma 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

Quando é fornecida uma matriz, diffcalcula automaticamente as diferenças nas linhas (surpreendentemente. Eu não conhecia esse recurso até tentar esse desafio).

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

Nenhum desses valores pode ser 1 ou superior em um bom quadro; portanto, testamos <1e verificamos se os allvalores da matriz estão em conformidade.

     [,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))

Chame assim:

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

Testado no Firefox, Chrome, JavaScript Shell e Node.js.

Python 3 , 42 bytes

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

Experimente online!

Mesmo algoritmo que minha resposta Jelly

C # (.NET Core) , 71 bytes

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

Experimente online!

O caminho chato. Espera entrada achatada em uma matriz linear.

Alternativamente, a maneira proibida explicitamente:

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

Experimente online!

Lança uma IndexOutOfBoundsException para indicar true, termina normalmente para indicar false. Eu tentei uma versão que incluía a conversão de exceção / nenhuma exceção para true / false, mas acabou como a versão regular.

JavaScript, 34 , 32 bytes

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

Ligue passando uma única matriz contendo a primeira coluna, seguida pela 2ª, 3ª e 4ª.

Compara cada número com o número anterior, exceto o primeiro número de cada coluna e retorna true se tudo for verdadeiro.

Teste

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

Edit: salvou 2 bytes graças ao tsh

Haskell , 28 bytes

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

Há também

all$(==)=<<sort

com 15 bytes, mas é necessário import Data.Listao trabalhar apenas com o Prelude. Alternativamente,

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

com 25 bytes funciona em GHCI.

Gaia , 3 6 bytes

^{+3 bytes, porque aparentemente eu não sabia como minha linguagem funcionava}

ọ¦_ẏ⁇!

Esta é uma função que aceita uma lista de colunas e deixa o resultado na pilha.

Existem algumas outras soluções de 6 bytes, incluindo 0+¦o¦ẏe ọ¦_ẏ¦ỵ.

Experimente online!

Explicação

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

TI-BASIC, 25 bytes

Recebe entrada como uma matriz 4x4 em Ans.

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

Explicação

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

Experimente online!

Define a função sem ponto all f, onde fdetermina se uma lista é classificada.

JavaScript (ES6), 42 bytes

Toma uma matriz de colunas; retorna um número (verdade) ou false.

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

JavaScript (ES6), 54 47 bytes

Primeira tentativa. Toma uma matriz de colunas; retorna trueou false.

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

MATL , 4 bytes

SGX=

Experimente online!

Entrada como uma matriz de linhas, de cabeça para baixo.

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

Experimente online!

Dyalog APL, 21 19 15 bytes

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

Experimente online! (modificado para que seja executado em tryapl)

Recebe a entrada como uma matriz 2D.

Quão?

• ⎕ entrada
• ⍉ transpor
• ↓ Array 2D => vetor 1D de vetores 1D
• { ... }¨aplique isso a cada membro (argumento ⍵):
  • ⍵[⍒⍵] ⍵ ordenado decrescente
  • ⍵≡ igualdade com ⍵
• ∧/se todo elemento é 1.

Japonês , 7 bytes

Tentei alguns métodos diferentes para este, mas, no final, o mais curto que eu pude acabou sendo uma porta da solução JS do tsh.

Toma uma matriz de colunas como entrada. As células vazias podem ser 0ou omitidas se não houver outros números na coluna.

P+U¥®n§

Teste-o

Explicação

Entrada implícita da matriz U.

P+U

Anexar Ucom uma sequência vazia, convertendo a matriz em uma sequência.

¥

Verifique a igualdade, que também projeta o lado direito de uma corda.

®

Mapa sobre U.

n§

Classificar ( n) por <=.

Resultado implícito de saída booleana.

Clojure, 30 bytes

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

experimente online

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

Bem, no momento da redação deste artigo, supera a solução Swift, então é isso! Totalmente direto. A entrada é uma matriz de matrizes inteiras, as matrizes internas sendo colunas da placa (primeiro os quadrados superiores). Transmitir para Function<int[][], Boolean>.

MY , 66 62 20 bytes (não competitivo)

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

Experimente online!

A razão pela qual isso não é concorrente é que eu implementei recentemente 8E (≡), o que é equivalente ao APL ≡.

Quão?

• ω⍉ O primeiro argumento da linha de comando transposto
• ω⍉ O primeiro argumento da linha de comando transposto
• A6ǵ'push chr(0x6A)( ⍖na página de códigos, que classifica como decrescente)
• ƒ como uma função, em vez de uma string
• ⇹ empurre uma função que mapeia uma função exibida sobre cada argumento
• ( Aplique
• E8ǵ'ƒ⇹( a mesma coisa, exceto com chr(0x8E), que é o comando match ( ≡).
• Π produtos
• ← saída sem nova linha

Sim, muitos símbolos do MY são exatamente iguais ou semelhantes aos do APL. A explicação é que eles vieram à mente quando eu queria um comando de 1 caractere. (Não sei por que não usei ^T para transpor)

Mathematica, 27 bytes

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

Explicação:

• Threadé uma operação estranha, semelhante à transposição, que ocorre quando a matriz é dada .
• t=Thread;permite-me usar tduas vezes em vez de Threadduas vezes para salvar bytes.
• Sort classifica uma lista (em ordem crescente).
• Sort\@mapeia a Sortfunção para cada elemento de uma lista individualmente; quando aplicado a uma matriz, classifica as linhas.
• t@#aplica a função de transposição à entrada #da função principal.
• - recebe o negativo de todas as entradas para que a classificação das linhas da matriz transposta (as colunas do original) as classifique da maneira desejada.
• O externo -t[...]desfaz o negativo e a transposição, então tudo o que fizemos foi classificar as colunas da maior para a menor.
• ==# testa para ver se essa nova matriz classificada em coluna é igual à entrada original.
• &finaliza a função anônima com a entrada #que definimos.

Você pode experimentá-lo online na caixa de proteção Wolfram Cloud colando código como o seguinte e clicando em Equipamento -> "Avaliar célula" ou pressionando Shift + Enter ou o 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}}

Ou para todos os casos de teste:

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