Ini adalah pertanyaan pertama saya di sini, jadi saran apa pun di komentar akan dihargai! Terima kasih;)

pengantar

Salah satu strategi yang sangat umum untuk game 2048 adalah tidak pernah menggesek . Ini menempatkan semua angka besar di atas, dan yang lebih rendah di bawah. Jadi, jika Anda menerapkan strategi ini dengan benar, papan Anda akan selalu cocok dengan pola berikut:

Pola untuk memeriksa / Tugas Anda

Kiriman Anda harus berupa program penuh atau fungsi yang mengembalikan nilai kebenaran jika papan dapat digambarkan seperti ini: Turun setiap kolom papan, angka pertama harus yang tertinggi dari kolom, angka kedua harus kurang dari atau sama dengan angka pertama, dll. Papan 2048 yang baik didefinisikan sebagai papan di mana angka tertinggi semuanya ada di atas. Ini adalah kode-golf , sehingga Kode terpendek per bahasa (dalam byte) menang.

I / O

Input dapat diambil dengan cara apa pun yang sesuai, misalnya array 4 array, masing-masing berisi 4 angka, atau array 16 angka. Secara total, itu akan selalu 16 angka, mewakili papan 4x4 Output harus nilai kebenaran input adalah "papan 2048 baik", dan nilai palsu sebaliknya.

Contohnya

Benar:

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

Catatan

Lihatlah kasus uji falsy ke-2: Ketika ada nilai kosong (atau 0) di suatu tempat dan bahkan ketika itu diikuti oleh nilai yang lebih tinggi dari angka bukan nol terakhir, ini harus palsu, karena nilai berikutnya setelah nol akan lebih tinggi dari 0 itu sendiri, yang membuatnya tidak valid.

Semoga berhasil!

Haskell , 21 byte

all$scanr1 max>>=(==)

Cobalah online!

Mengambil daftar kolom, dengan spasi kosong 0.

05AB1E , 4 byte

€{íQ

Cobalah online!

Sama seperti dua jawaban saya yang lain. Saya berjanji ini yang terakhir sampai yang lain menjawab :)

APL (Dyalog) , 7 4 byte

Mengambil 4-by-4 matrix, menggunakan 0 untuk blank, sebagai argumen.

⊢≡⌊⍀

Cobalah online!

⌊⍀ adalah minimum kumulatif vertikal

≡ sama dengan

⊢ argumen yang tidak dimodifikasi?

Jelly , 4 byte

Ṣ€U⁼

Cobalah online!

Input sebagai array kolom. Bekerja dengan kisi berukuran sewenang-wenang.

R (+ pryr), 23 byte

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

Yang mengevaluasi fungsi

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

Yang mengambil matriks sebagai input:

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

Ketika diberi matriks, diffsecara otomatis menghitung perbedaan dalam baris (yang mengejutkan. Saya tidak tahu fitur ini sampai saya mencobanya untuk tantangan ini).

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

Tidak satu pun dari nilai-nilai ini bisa 1 atau lebih tinggi di papan yang baik, jadi kami menguji <1dan melihat apakah allnilai-nilai matriks sesuai.

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

[1] TRUE

JavaScript, 37 byte

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

Sebut saja seperti ini:

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

Diuji pada Firefox, Chrome, JavaScript Shell, dan, Node.js.

Python 3 , 42 byte

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

Cobalah online!

Algoritma yang sama dengan jawaban Jelly saya

C # (.NET Core) , 71 byte

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

Cobalah online!

Cara BORING. Diharapkan input diratakan menjadi array linier.

Cara lain yang dilarang secara eksplisit:

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

Cobalah online!

Melempar IndexOutOfBoundsException untuk menunjukkan true, berakhir secara normal untuk menunjukkan false. Saya mencoba versi yang menyertakan konversi dari pengecualian / tidak terkecuali ke true / false, tetapi berakhir selama versi biasa.

JavaScript, 34 , 32 byte

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

Panggil dengan memasukkan larik tunggal yang berisi kolom pertama, diikuti oleh ke-2, ke-3, dan ke-4.

Membandingkan setiap angka dengan angka sebelumnya kecuali untuk angka pertama dari setiap kolom dan mengembalikan true jika semuanya benar.

Uji

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

Sunting: disimpan 2 byte berkat tsh

Haskell , 28 byte

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

Ada juga

all$(==)=<<sort

dengan 15 byte tetapi membutuhkan import Data.Listsaat bekerja dengan Prelude saja. Kalau tidak,

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

dengan 25 byte bekerja di GHCI.

Gaia , 3 6 byte

^{+3 byte karena ternyata saya tidak tahu bagaimana bahasa saya berfungsi}

ọ¦_ẏ⁇!

Ini adalah fungsi yang menerima daftar kolom dan meninggalkan hasilnya di tumpukan.

Beberapa solusi 6 byte lainnya ada termasuk 0+¦o¦ẏdan ọ¦_ẏ¦ỵ.

Cobalah online!

Penjelasan

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

TI-BASIC, 25 byte

Mengambil input sebagai matriks 4x4 di Ans.

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

Penjelasan

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 byte

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

Cobalah online!

Menentukan fungsi point-free all f, di mana fmenentukan apakah daftar diurutkan.

JavaScript (ES6), 42 byte

Mengambil array kolom; mengembalikan nomor (kebenaran) atau false.

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

JavaScript (ES6), 54 47 byte

Percobaan pertama. Mengambil array kolom; mengembalikan trueatau false.

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

MATL , 4 byte

SGX=

Cobalah online!

Input sebagai array baris, terbalik.

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

Swift 4 , 84 77 byte

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

Cobalah online!

Dyalog APL, 21 19 15 byte

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

Cobalah online! (dimodifikasi sehingga akan berjalan di tryapl)

Mengambil input sebagai array 2D.

Bagaimana?

• ⎕ memasukkan
• ⍉ mengubah urutan
• ↓ 2D array => 1D vektor 1D vektor
• { ... }¨terapkan ini untuk setiap anggota (argumen ⍵):
  • ⍵[⍒⍵] ⍵ diurutkan menurun
  • ⍵≡ kesetaraan dengan ⍵
• ∧/apakah setiap elemen 1.

Japt , 7 byte

Mencoba beberapa metode yang berbeda untuk yang satu ini tetapi, pada akhirnya, yang terpendek yang dapat saya hasilkan akhirnya menjadi port dari solusi JS tsh.

Mengambil array kolom sebagai input. Sel kosong dapat 0atau dihilangkan jika tidak ada angka lain dalam kolom.

P+U¥®n§

Menguji

Penjelasan

Input array secara implisit U.

P+U

Prepend Udengan string kosong, mengonversi array menjadi string.

¥

Periksa kesetaraan, yang melemparkan sisi kanan ke string juga.

®

Peta berakhir U.

n§

Sortir ( n) berdasarkan <=.

Keluarkan hasil boolean secara tersirat.

Clojure, 30 byte

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

coba online

Java 8, 69 byte

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

Nah, pada tulisan ini, ini mengalahkan solusi Swift, jadi begitulah! Benar-benar mudah. Input adalah array array integer, array dalam menjadi kolom papan (kuadrat atas terlebih dahulu). Diputar ke Function<int[][], Boolean>.

MY , 66 62 20 byte (tidak bersaing)

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

Cobalah online!

Alasan ini tidak bersaing adalah karena saya baru-baru ini menerapkan 8E (≡), yang setara dengan APL ≡.

Bagaimana?

• ω⍉ Argumen baris perintah pertama ditransformasikan
• ω⍉ Argumen baris perintah pertama ditransformasikan
• A6ǵ'push chr(0x6A)( ⍖dalam codepage, yang jenisnya turun)
• ƒ sebagai fungsi, bukan string
• ⇹ dorong fungsi yang memetakan fungsi yang muncul di setiap argumen
• ( menerapkan
• E8ǵ'ƒ⇹( hal yang sama, kecuali dengan chr(0x8E), yang merupakan perintah pertandingan ( ≡).
• Π produk
• ← output tanpa baris baru

Ya, banyak simbol MY persis sama atau mirip dengan APL. Penjelasannya adalah bahwa mereka datang ke pikiran ketika saya menginginkan perintah 1 karakter. (Saya tidak tahu mengapa saya tidak menggunakan ^T untuk merefleksikan)

Mathematica, 27 byte

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

Penjelasan:

• Threadadalah operasi umum seperti-transpose aneh yang terjadi untuk mengambil transpose ketika diberi matriks .
• t=Thread;izinkan saya menggunakan tdua kali alih-alih Threaddua kali untuk menghemat byte.
• Sort mengurutkan daftar (dalam urutan meningkat).
• Sort\@memetakan Sortfungsi ke setiap elemen daftar secara individual; ketika diterapkan pada sebuah matriks, itu mengurutkan baris.
• t@#menerapkan fungsi transpos ke input #fungsi utama.
• - mengambil yang negatif dari semua entri sehingga menyortir baris dari matriks yang ditransformasikan (kolom aslinya) mengurutkannya dengan cara yang diinginkan.
• Bagian luar -t[...]membatalkan yang negatif dan yang transpos, sehingga yang benar-benar kami lakukan adalah mengurutkan kolom terbesar ke terkecil.
• ==# menguji untuk melihat apakah matriks yang diurutkan kolom ini sama dengan input asli.
• &mengakhiri fungsi anonim dengan input yang #kami tentukan.

Anda dapat mencobanya secara online di kotak pasir Wolfram Cloud dengan menempelkan kode seperti berikut ini dan mengeklik Gear -> "Evaluate cell" atau menekan Shift + Enter atau numpad Enter:

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

Atau untuk semua kasus uji:

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