Buradaki ilk sorum bu, yorumlarda herhangi bir öneriniz memnuniyetle karşılanacaktır! Teşekkürler ;)

Giriş

One çok yaygın bir strateji 2048 oyun olduğunu asla hiç aşağı kaydırarak . Bu, tüm büyük sayıları üstte ve alttakileri de altta konumlandırır. Dolayısıyla, bu stratejiyi doğru uygularsanız, kartınız her zaman aşağıdaki desenle eşleşecektir:

Kontrol edilecek kalıp / Göreviniz

Gönderiminiz, tam bir program veya pano böyle tanımlanabiliyorsa, gerçek bir değer döndüren bir işlev olmalıdır: Kurulun her bir sütunundan aşağıya inerken, ilk sayı sütunun en yüksek, ikinci sayı daha az olmalıdır ilk sayıya eşit veya ondan daha fazladır. İyi bir 2048 kartı , en yüksek sayıların hepsinin üstünde olduğu bir kart olarak tanımlanır. Bu kod golf , yani dil başına en kısa Kod (bayt cinsinden) kazanır.

I / O

Giriş, her biri 4 sayı içeren bir 4 dizi dizisi veya 16 sayı dizisi gibi herhangi bir uygun şekilde alınabilir. Toplamda, her zaman 16 sayı olacaktır, 4x4 kartını temsil eder Çıktı, girişin gerçek değeri olmalı, "iyi 2048 kart" ve aksi takdirde sahte bir değer olmalıdır.

Örnekler

Truthy:

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

Not

2. sahte test durumuna bakın: Bir yerde boş bir değer (veya 0) olduğunda ve onu en son sıfır olmayan sayıdan daha yüksek bir değer izliyorsa bile, bu hatalı olmalı, çünkü sonraki değer sonraki sıfır, 0 değerinden yüksek olur; bu da geçersiz kılar.

İyi şanslar!

Haskell , 21 bayt

all$scanr1 max>>=(==)

Çevrimiçi deneyin!

Boş alanların 0 olarak göründüğü sütunların bir listesini alır.

05AB1E , 4 bayt

€{íQ

Çevrimiçi deneyin!

Diğer iki cevabımla aynı. Söz veriyorum, diğerleri cevap verene kadar bu benim sonuncum :)

APL (Dyalog) , 7 4 bayt

Argüman olarak boşluklar için 0 kullanarak 4'e 4 matris alır.

⊢≡⌊⍀

Çevrimiçi deneyin!

⌊⍀ düşey kümülatif minimum

≡ aynı

⊢ değiştirilmemiş tartışma?

Jöle , 4 bayt

Ṣ€U⁼

Çevrimiçi deneyin!

Bir sütun dizisi olarak giriş yapın. Keyfi boyutlu ızgaralarla çalışır.

R (+ pryr), 23 bayt

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

İşleve değer veren

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

Hangi girdi olarak bir matris alır:

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

Bir matris verildiğinde, diffsatırlar arasındaki farkları otomatik olarak hesaplar (şaşırtıcı bir şekilde. Bu özelliği denemeden önce bu özelliği bilmiyordum).

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

Bu değerlerin hiçbiri iyi bir panoda 1 veya daha yüksek olamaz, bu nedenle matrisin değerlerinin uyup uymadığını test ederiz <1ve görürüz all.

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

[1] TRUE

JavaScript, 37 bayt

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

Buna şöyle diyoruz:

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

Firefox, Chrome, JavaScript Kabuğu ve Node.js. üzerinde test edilmiştir

Python 3 , 42 bayt

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

Çevrimiçi deneyin!

Jelly cevabımla aynı algoritma

C # (.NET Çekirdeği) , 71 bayt

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

Çevrimiçi deneyin!

BORLAMA yolu. Doğrusal bir diziye düzleştirilmiş girdi bekler.

Alternatif olarak açıkça yasak yol:

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

Çevrimiçi deneyin!

Doğru olduğunu belirtmek için bir IndexOutOfBoundsException atar, yanlış belirtmek için normalde biter. İstisnadan / istisnadan doğru / yanlışa dönüşüm içeren bir sürümü denedim, ancak normal sürüm olduğu sürece bitti.

JavaScript, 34 , 32 bayt

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

İlk sütunu içeren tek bir diziyi geçip ardından 2., 3. ve 4. numarayı arayarak arayın.

Her sütunun ilk sayısı hariç her sayıyı önceki sayı ile karşılaştırır ve hepsi doğruysa true değerini döndürür.

Ölçek

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

Düzenleme: tsh sayesinde 2 bayt kaydedildi

Haskell , 28 bayt

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

Ayrıca

all$(==)=<<sort

15 bayt ile ancak import Data.Listyalnızca Prelude ile çalışırken gerektirir . Alternatif olarak,

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

25 bayt ile GHCI'da çalışır.

Gaia , 3 6 bayt

^{+3 bayt çünkü görünüşe göre dilimin nasıl çalıştığını bilmiyordum}

ọ¦_ẏ⁇!

Bu, bir sütun listesini kabul eden ve sonucu yığında bırakan bir işlevdir.

0+¦o¦ẏVe dahil olmak üzere birkaç diğer 6 byte çözüm vardır ọ¦_ẏ¦ỵ.

Çevrimiçi deneyin!

açıklama

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

TI-BASIC, 25 bayt

Ans'de girişi 4x4'lük bir matris olarak alır.

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

açıklama

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 bayt

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

Çevrimiçi deneyin!

Nokta içermeyen fonksiyonu tanımlar all f, fbir liste sıralanır belirler.

JavaScript (ES6), 42 bayt

Bir dizi sütunu alır; bir (truthy) sayı döndürür veya false.

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

JavaScript (ES6), 54 47 bayt

İlk girişim. Bir dizi sütunu alır; trueveya döndürür false.

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

Matl , 4 bayt

SGX=

Çevrimiçi deneyin!

Baş aşağı bir satır dizisi olarak giriş yapın.

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

Swift 4 , 84 77 bayt

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

Çevrimiçi deneyin!

Dyalog APL, 21 19 15 bayt

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

Çevrimiçi deneyin! (tryapl'de çalışacak şekilde değiştirildi)

2B dizi olarak giriş yapar.

Nasıl?

• ⎕ giriş
• ⍉ devrik
• ↓ 2D dizi => 1D vektörlerin 1D vektörü
• { ... }¨bunu her üyeye uygula (argüman ⍵):
  • ⍵[⍒⍵] ⍵ azalan sıralama
  • ⍵≡ eşitlik ⍵
• ∧/Her elemanın olup olmadığı 1.

Japt , 7 bayt

Bunun için birkaç farklı yöntem denedim, fakat sonunda bulabildiğim en kısa sürede tsh'in JS çözümünün limanı oldu.

Giriş olarak bir dizi sütunu alır. 0Sütunda başka numaralar yoksa, boş hücreler atlanabilir veya atlanabilir.

P+U¥®n§

Dene

açıklama

Dizinin örtük girişi U.

P+U

Diziyi Udizgeye dönüştüren boş bir dizgiye bağımlı .

¥

Aynı zamanda sağ tarafı da bir dizgeye çeviren eşitliği kontrol edin.

®

Harita üzerinde U.

n§

Sırala ( n) ile sırala <=.

Örtülü çıktı boolean sonucu.

Clojure, 30 bayt

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

çevrimiçi dene

Java 8, 69 bayt

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

Bu yazı itibariyle bu Swift çözümünü yeniyor, işte bu var! Son derece basit. Girdi, bir tam sayı dizisi dizisidir, iç diziler panelin sütunlarıdır (önce üst kareler). İçin attı Function<int[][], Boolean>.

MY , 66 62 20 bayt (rekabetçi değil)

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

Çevrimiçi deneyin!

Bunun rekabet etmemesinin nedeni, son zamanlarda uyguladığım 8E (≡)APL'ye eşdeğerdir ≡.

Nasıl?

• ω⍉ İlk komut satırı argümanı devredildi
• ω⍉ İlk komut satırı argümanı devredildi
• A6ǵ'push chr(0x6A)( ⍖azalan sıralamadaki kod sayfasında)
• ƒ bir dize yerine bir işlev olarak
• ⇹ Her argüman üzerinde atlamalı bir işlevi eşleyen bir işlevi it
• ( uygulamak
• E8ǵ'ƒ⇹( Aynı şey, chr(0x8E)eşleşme komutu olan ( ≡) hariç .
• Π ürün
• ← newline olmayan çıktı

Evet, birçok MY sembolü APL'lerle tamamen aynı veya benzer. Açıklama, 1 karakterlik bir komut istediğimde aklıma geldiler. (Neden devrik için ^T kullanmadığımı bilmiyorum )

Mathematica, 27 bayt

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

Açıklama:

• Threadbir matris verildiğinde transpozisyonu alan tuhaf bir genel transpoze benzeri işlemdir .
• t=Thread;Bayt kaydetmek için tiki kez yerine Threadiki kez kullanmama izin verir .
• Sort bir listeyi sıralar (artan sırada).
• Sort\@Sortişlevi, listenin her bir öğesine ayrı ayrı eşler ; bir matrise uygulandığında satırları sıralar.
• t@#Transpoze fonksiyonunu #ana fonksiyonun girişine uygular .
• - tüm girişlerin negatifini alır, böylece aktarılan matrisin (orijinalin sütunları) satırlarını sıralamak onları istenen şekilde sıralar.
• Dış -t[...]negatifi ve devrik olanı geri alır, bu yüzden gerçekten yaptığımız tüm sütunları en küçüğünden en küçüğe sıralamaktı.
• ==# Bu yeni sütun sıralama matrisinin orijinal girişe eşit olup olmadığını görmek için testler.
• &anonim işlevi #tanımladığımız girdiyle sonlandırır .

Şunları yapabilirsiniz çevrimiçi denemek içinde Wolfram Bulut kum havuzu :> "hücreyi değerlendirin" veya Shift + Enter isabet veya sayısal tuş takımı girin - Gear aşağıdaki gibi bir kodu yapıştırıp tıklayarak

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

Veya tüm test durumları için:

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