Dies ist meine erste Frage hier, daher würden wir uns über Vorschläge in den Kommentaren freuen! Vielen Dank ;)

Einführung

Eine sehr verbreitete Strategie für das Spiel 2048 ist es, niemals nach unten zu streichen . Dies positioniert alle großen Zahlen oben und die unteren unten. Wenn Sie diese Strategie richtig anwenden, entspricht Ihr Board immer dem folgenden Muster:

Das zu überprüfende Muster / Ihre Aufgabe

Ihre Einsendung sollte entweder ein vollständiges Programm oder eine Funktion sein, die einen Wahrheitswert zurückgibt, wenn die Tafel wie folgt beschrieben werden kann: In jeder Spalte der Tafel sollte die erste Zahl die höchste der Spalte sein, die zweite die niedrigere als oder gleich der ersten Zahl usw. Ein gutes 2048-Board ist definiert als ein Board, bei dem die höchsten Zahlen alle oben liegen. Das ist Code-Golf , also gewinnt der kürzeste Code pro Sprache (in Bytes).

I / O

Die Eingabe kann auf jede geeignete Weise erfolgen, z. B. als Array von 4 Arrays mit jeweils 4 Zahlen oder als Array von 16 Zahlen. Insgesamt werden es immer 16 Zahlen sein, die die 4x4- Karte darstellen. Die Ausgabe sollte ein wahrer Wert sein, die Eingabe ist eine "gute 2048-Karte" und ansonsten ein falscher Wert.

Beispiele

Wahrheit:

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


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

Falsch:

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


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

Hinweis

Schauen Sie sich den zweiten falschen Testfall an: Wenn irgendwo ein leerer Wert (oder eine 0) vorhanden ist und selbst dann, wenn auf ihn ein Wert folgt, der höher ist als die letzte Zahl ungleich Null, sollte dies falsch sein, da der nächste Wert nach dem Null wäre höher als die 0 selbst, was es ungültig macht.

Viel Glück!

Haskell , 21 Bytes

all$scanr1 max>>=(==)

Probieren Sie es online!

Nimmt eine Liste von Spalten mit Leerzeichen als 0.

05AB1E , 4 Bytes

€{íQ

Probieren Sie es online!

Gleich wie meine beiden anderen Antworten. Ich verspreche, dies ist meine letzte, bis andere geantwortet haben :)

APL (Dyalog) , 7 4 Bytes

Nimmt eine 4-mal-4-Matrix, wobei 0 für Leerzeichen als Argument verwendet wird.

⊢≡⌊⍀

Probieren Sie es online!

⌊⍀ ist das vertikale kumulative Minimum

≡ identisch mit

⊢ das unveränderte argument?

Gelee , 4 Bytes

Ṣ€U⁼

Probieren Sie es online!

Eingabe als Array von Spalten. Funktioniert mit Gittern beliebiger Größe.

R (+ Pryr), 23 Bytes

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

Welches zur Funktion auswertet

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

Welche nimmt eine Matrix als Eingabe:

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

diffBerechnet bei Angabe einer Matrix automatisch die Unterschiede innerhalb von Zeilen (überraschenderweise kannte ich diese Funktion erst, als ich sie für diese Herausforderung ausprobierte).

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

Keiner dieser Werte kann in einer guten Platine 1 oder höher sein, daher prüfen wir, <1ob die allWerte der Matrix übereinstimmen.

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

Nenne es so:

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

Getestet unter Firefox, Chrome, JavaScript Shell und Node.js.

Python 3 , 42 Bytes

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

Probieren Sie es online!

Gleicher Algorithmus wie meine Jelly-Antwort

C # (.NET Core) , 71 Byte

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

Probieren Sie es online!

Der langweilige Weg. Erwartet eine in ein lineares Array abgeflachte Eingabe.

Alternativ der ausdrücklich verbotene Weg:

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

Probieren Sie es online!

Löst eine IndexOutOfBoundsException aus, um true anzugeben, endet normalerweise, um false anzugeben. Ich habe eine Version ausprobiert, die die Konvertierung von Ausnahme / keine Ausnahme nach Wahr / Falsch beinhaltete, aber sie endete genauso lange wie die reguläre Version.

JavaScript, 34 , 32 Bytes

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

Rufen Sie auf, indem Sie ein einzelnes Array mit der ersten Spalte gefolgt von der zweiten, dritten und vierten Spalte übergeben.

Vergleicht jede Zahl mit der vorherigen Zahl mit Ausnahme der ersten Zahl jeder Spalte und gibt true zurück, wenn alle true sind.

Prüfung

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

Bearbeiten: 2 Bytes dank TSH gespeichert

Haskell , 28 Bytes

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

Es gibt auch

all$(==)=<<sort

mit 15 bytes wird es aber nur import Data.Listbeim arbeiten mit dem prelude benötigt. Alternative,

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

mit 25 Bytes arbeitet in GHCI.

Gaia , 3 6 Bytes

^{+3 Bytes, weil ich anscheinend nicht wusste, wie meine Sprache funktioniert}

ọ¦_ẏ⁇!

Dies ist eine Funktion, die eine Liste von Spalten akzeptiert und das Ergebnis auf dem Stapel belässt.

Es gibt einige andere 6-Byte-Lösungen, einschließlich 0+¦o¦ẏund ọ¦_ẏ¦ỵ.

Probieren Sie es online!

Erläuterung

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

TI-BASIC, 25 Byte

Übernimmt die Eingabe als 4x4-Matrix in Ans.

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

Erläuterung

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

Probieren Sie es online!

Definiert die punktfreie Funktion all f, mit der ffestgelegt wird, ob eine Liste sortiert wird.

JavaScript (ES6), 42 Byte

Nimmt ein Array von Spalten; gibt eine (wahrheitsgemäße) Zahl zurück oder false.

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

JavaScript (ES6), 54 Byte

Erster Versuch. Nimmt ein Array von Spalten; zurück trueoder false.

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

MATL , 4 Bytes

SGX=

Probieren Sie es online!

Eingabe als Array von Zeilen mit dem Kopf nach oben.

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

Probieren Sie es online!

Dyalog APL, 21 19 15 Bytes

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

Probieren Sie es online! (so geändert, dass es in tryapl läuft)

Übernimmt die Eingabe als 2D-Array.

Wie?

• ⎕ Eingang
• ⍉ transponieren
• ↓ 2D-Array => 1D-Vektor von 1D-Vektoren
• { ... }¨Wende dies auf jedes Mitglied an (Argument ⍵):
  • ⍵[⍒⍵] ⍵ absteigend sortiert
  • ⍵≡ Gleichheit mit ⍵
• ∧/ob jedes Element ist 1.

Japt , 7 Bytes

Versuchte ein paar verschiedene Methoden für diese, aber am Ende war die kürzeste, die ich finden konnte, eine Portierung der JS-Lösung von tsh.

Nimmt ein Array von Spalten als Eingabe. Leere Zellen können ein- 0oder ausgeblendet werden, wenn die Spalte keine anderen Zahlen enthält.

P+U¥®n§

Probier es aus

Erläuterung

Implizite Eingabe eines Arrays U.

P+U

Stellen Sie Ueine leere Zeichenfolge voran und konvertieren Sie das Array in eine Zeichenfolge.

¥

Überprüfen Sie die Gleichheit, wodurch auch die rechte Seite in eine Zeichenfolge umgewandelt wird.

®

Karte über U.

n§

Sortieren ( n) nach <=.

Boolesches Ergebnis implizit ausgeben.

Clojure, 30 Bytes

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

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

Nun, zum jetzigen Zeitpunkt schlägt dies die Swift-Lösung, also gibt es das! Ganz einfach. Input ist ein Array von Integer-Arrays, wobei die inneren Arrays Spalten des Boards sind (obere Quadrate zuerst). Besetzung für Function<int[][], Boolean>.

MY , 66 62 20 Bytes (nicht konkurrierend)

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

Probieren Sie es online!

Der Grund, warum dies nicht konkurriert, ist, dass ich vor kurzem implementiert habe 8E (≡), was äquivalent zu APL ist≡ .

Wie?

• ω⍉ Das erste Befehlszeilenargument wurde umgesetzt
• ω⍉ Das erste Befehlszeilenargument wurde umgesetzt
• A6ǵ'push chr(0x6A)( ⍖in der Codepage, die absteigend sortiert)
• ƒ als Funktion und nicht als Zeichenfolge
• ⇹ Schieben Sie eine Funktion, die eine POP-Funktion auf jedes Argument abbildet
• ( sich bewerben
• E8ǵ'ƒ⇹( das Gleiche, außer mit chr(0x8E), das der Match-Befehl ist (≡ ).
• Π Produkt
• ← Ausgabe ohne Zeilenumbruch

Ja, viele MY-Symbole sind genau gleich oder ähnlich zu APLs. Die Erklärung ist, dass sie mir einfielen, als ich einen 1-Zeichen-Befehl wollte. (Ich weiß nicht, warum ich ^{T nicht} für die Transponierung verwendet habe)

Mathematica, 27 Bytes

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

Erläuterung:

• Threadist eine seltsame allgemeine transponierungsähnliche Operation, bei der die Transponierung ausgeführt wird, wenn eine Matrix angegeben wird .
• t=Thread;Lässt mich tzweimal statt Threadzweimal verwenden, um Bytes zu speichern.
• Sort sortiert eine Liste (in aufsteigender Reihenfolge).
• Sort\@ordnet die SortFunktion jedem Element einer Liste einzeln zu; Bei Anwendung auf eine Matrix werden die Zeilen sortiert.
• t@#Wendet die Transponierungsfunktion auf den Eingang #der Hauptfunktion an.
• - Nimmt das Negativ aller Einträge, damit die Zeilen der transponierten Matrix (die Spalten des Originals) in der gewünschten Weise sortiert werden.
• Das äußere -t[...]macht das Negative und die Transponierung rückgängig, sodass wir wirklich nur die Spalten vom größten zum kleinsten sortieren mussten.
• ==# Überprüft, ob diese neue spaltensortierte Matrix der ursprünglichen Eingabe entspricht.
• &Beendet die anonyme Funktion mit der von #uns definierten Eingabe .

Sie können es online in der Wolfram Cloud-Sandbox versuchen, indem Sie folgenden Code einfügen und auf Zahnrad -> "Zelle auswerten" klicken oder Umschalt + Eingabetaste oder die Zifferntaste drücken:

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

Oder für alle Testfälle:

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