To jest moje pierwsze pytanie tutaj, więc wszelkie sugestie w komentarzach będą mile widziane! Dzięki ;)

Wprowadzenie

Jednym z bardzo wspólna strategia dla 2048 gry jest nigdy przesuwając w dół . To umieszcza wszystkie duże liczby na górze, a dolne na dole. Tak więc, jeśli zastosujesz tę strategię poprawnie, twoja plansza zawsze będzie pasować do następującego wzoru:

Wzór do sprawdzenia / Twoje zadanie

Twoje zgłoszenie powinno być albo pełnym programem, albo funkcją, która zwraca prawdziwą wartość, jeśli tablica może być opisana w następujący sposób: schodząc w dół każdej kolumny tablicy, pierwsza liczba powinna być najwyższa z kolumny, druga liczba powinna być mniejsza równa lub równa pierwszej liczbie itp. Dobra plansza 2048 jest definiowana jako plansza, na której najwyższe liczby znajdują się na górze. To jest golf golfowy , więc wygrywa najkrótszy kod na język (w bajtach).

I / O

Dane wejściowe można pobierać w dowolny odpowiedni sposób, na przykład tablicę 4 tablic, z których każda zawiera 4 liczby lub tablicę 16 liczb. W sumie zawsze będzie to 16 liczb, reprezentujących tablicę 4x4 . Wyjście powinno być prawdziwą wartością wejściową jest „dobra tablica 2048”, a w przeciwnym razie wartość fałsz.

Przykłady

Prawda:

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

Uwaga

Spójrz na drugi przypadek testu fałszowania: gdy gdzieś jest pusta wartość (lub zero), a nawet jeśli po niej następuje wartość wyższa niż ostatnia niezerowa liczba, powinno to być fałszowanie, ponieważ następna wartość po zero byłoby wyższe niż samo zero, co powoduje, że jest ono nieprawidłowe.

Powodzenia!

Haskell , 21 bajtów

all$scanr1 max>>=(==)

Wypróbuj online!

Pobiera listę kolumn, z pustymi spacjami jako 0.

05AB1E , 4 bajty

€{íQ

Wypróbuj online!

Tak samo jak moje pozostałe dwie odpowiedzi. Obiecuję, że to mój ostatni, dopóki inni nie odpowiedzą :)

APL (Dyalog) , 7 4 bajtów

Przyjmuje macierz 4 na 4, używając 0 jako spacji jako argumentu.

⊢≡⌊⍀

Wypróbuj online!

⌊⍀ to pionowe skumulowane minimum

≡ identyczny z

⊢ niezmodyfikowany argument?

Galaretka , 4 bajty

Ṣ€U⁼

Wypróbuj online!

Dane wejściowe jako tablica kolumn. Współpracuje z siatkami o dowolnej wielkości.

R (+ pryr), 23 bajty

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

Który ocenia się na funkcję

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

Który przyjmuje macierz jako dane wejściowe:

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

Po otrzymaniu matrycy diffautomatycznie oblicza różnice w wierszach (zaskakujące. Nie znałem tej funkcji, dopóki nie wypróbowałem jej w tym wyzwaniu).

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

Żadna z tych wartości nie może wynosić 1 lub więcej na dobrej płycie, więc testujemy <1i sprawdzamy, czy allwartości macierzy są zgodne.

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

[1] TRUE

JavaScript, 37 bajtów

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

Nazwij to tak:

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

Testowane na Firefox, Chrome, JavaScript Shell i Node.js.

Python 3 , 42 bajty

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

Wypróbuj online!

Ten sam algorytm jak moja odpowiedź na galaretkę

C # (.NET Core) , 71 bajtów

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

Wypróbuj online!

NUDNY sposób. Oczekuje, że dane wejściowe zostaną spłaszczone do tablicy liniowej.

Alternatywnie wyraźnie zabroniony sposób:

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

Wypróbuj online!

Zgłasza wyjątek IndexOutOfBoundsException, aby wskazać wartość true, kończy się normalnie, wskazując wartość false. Próbowałem wersji zawierającej konwersję z wyjątku / brak wyjątku na prawda / fałsz, ale skończyło się tak długo, jak zwykła wersja.

JavaScript, 34 , 32 bajty

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

Wywołaj, przekazując jedną tablicę zawierającą pierwszą kolumnę, a następnie drugą, trzecią i czwartą.

Porównuje każdą liczbę z poprzednim numerem z wyjątkiem pierwszej liczby w każdej kolumnie i zwraca true, jeśli wszystkie są prawdziwe.

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

Edycja: zapisane 2 bajty dzięki tsh

Haskell , 28 bajtów

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

Jest także

all$(==)=<<sort

15 bajtów, ale wymaga import Data.Listto tylko pracy z Preludium. Alternatywnie,

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

z 25 bajtami działa w GHCI.

Gaia , 3 6 bajtów

^{+3 bajty, ponieważ najwyraźniej nie wiedziałem, jak działa mój język}

ọ¦_ẏ⁇!

Jest to funkcja przyjmująca listę kolumn i pozostawiająca wynik na stosie.

Istnieje kilka innych 6-bajtowych rozwiązań, w tym 0+¦o¦ẏi ọ¦_ẏ¦ỵ.

Wypróbuj online!

Wyjaśnienie

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

TI-BASIC, 25 bajtów

Pobiera dane wejściowe jako macierz 4x4 w Ans.

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

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Definiuje funkcję bez punktów all f, w której fokreśla, czy lista jest sortowana.

JavaScript (ES6), 42 bajty

Pobiera tablicę kolumn; zwraca (prawdę) liczbę lub false.

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

JavaScript (ES6), 54 47 bajtów

Pierwsze podejscie. Pobiera tablicę kolumn; zwraca truelub false.

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

MATL , 4 bajty

SGX=

Wypróbuj online!

Dane wejściowe jako tablica wierszy do góry nogami.

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

Swift 4 , 84 77 bajtów

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

Wypróbuj online!

Dyalog APL, 21 19 15 bajtów

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

Wypróbuj online! (zmodyfikowany, aby działał w tryapl)

Pobiera dane wejściowe jako tablicę 2D.

W jaki sposób?

• ⎕ wkład
• ⍉ transponować
• ↓ Tablica 2D => wektor 1D wektorów 1D
• { ... }¨zastosuj to do każdego członka (argumentu ⍵):
  • ⍵[⍒⍵] ⍵ posortowane malejąco
  • ⍵≡ równość z ⍵
• ∧/czy każdy element jest 1.

Japt , 7 bajtów

Wypróbowałem kilka różnych metod dla tego, ale ostatecznie najkrótsza, jaką mogłem wymyślić, okazała się być portem rozwiązania JS tsh.

Pobiera tablicę kolumn jako dane wejściowe. Puste komórki można 0pominąć, jeśli w kolumnie nie ma innych liczb.

P+U¥®n§

Sprawdź to

Wyjaśnienie

Domniemane wejście tablicy U.

P+U

Przygotuj Uz pustym ciągiem, konwertując tablicę na ciąg.

¥

Sprawdź równość, która również rzutuje prawą stronę na sznurek.

®

Mapa nad U.

n§

Sortuj ( n) według <=.

Wynik niejawnie wyprowadza wynik boolowski.

Clojure, 30 bajtów

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

spróbuj online

Java 8, 69 bajtów

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

Cóż, w chwili pisania tego bije to rozwiązanie Swift, więc jest! Zupełnie proste. Dane wejściowe to tablica tablic liczb całkowitych, przy czym tablice wewnętrzne to kolumny tablicy (najpierw górne kwadraty). Przesyłaj do Function<int[][], Boolean>.

MY , 66 62 20 bajtów (niekonkurencyjny)

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

Wypróbuj online!

Powodem, dla którego nie jest konkurencyjny, jest to, że niedawno wdrożyłem 8E (≡), co jest równoważne APL ≡.

W jaki sposób?

• ω⍉ Transponowano pierwszy argument wiersza poleceń
• ω⍉ Transponowano pierwszy argument wiersza poleceń
• A6ǵ'push chr(0x6A)( ⍖na stronie kodowej, która sortuje malejąco)
• ƒ jako funkcja, a nie ciąg
• ⇹ przesuń funkcję, która mapuje wyskakującą funkcję nad każdym argumentem
• ( zastosować
• E8ǵ'ƒ⇹( to samo, z wyjątkiem with chr(0x8E), czyli komendy match ( ≡).
• Π produkt
• ← wyjście bez nowej linii

Tak, wiele symboli MY jest dokładnie takich samych lub podobnych do APL-ów. Wyjaśnienie jest takie, że przyszło im na myśl, gdy chciałem polecenia 1-znakowego. (Nie wiem, dlaczego nie użyłem ^T do transpozycji)

Mathematica, 27 bajtów

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

Wyjaśnienie:

• Threadjest dziwną ogólną operacją podobną do transpozycji, która akceptuje transpozycję po otrzymaniu matrycy .
• t=Thread;pozwala mi użyć tdwa razy zamiast Threaddwa razy, aby zapisać bajty.
• Sort sortuje listę (w kolejności rosnącej).
• Sort\@mapuje Sortfunkcję do każdego elementu listy indywidualnie; po zastosowaniu do matrycy sortuje wiersze.
• t@#stosuje funkcję transpozycji na wejściu #funkcji głównej.
• - przyjmuje negatyw wszystkich wpisów, dzięki czemu sortowanie wierszy transponowanej macierzy (kolumny oryginału) sortuje je w pożądany sposób.
• Zewnętrzne -t[...]cofa negację i transpozycję, więc wszystko, co naprawdę zrobiliśmy, to posortowanie kolumn od największych do najmniejszych.
• ==# sprawdza, czy ta nowa macierz posortowana według kolumn jest równa oryginalnej wartości wejściowej.
• &kończy anonimową funkcję #zdefiniowanym przez nas wejściem .

Możesz wypróbować go online w piaskownicy Wolfram Cloud , wklejając poniższy kod i klikając Gear -> „Oceń komórkę” lub naciskając Shift + Enter lub Enter na klawiaturze numerycznej:

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

Lub dla wszystkich przypadków testowych:

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