Est-ce une bonne planche 2048?

26

Ceci est ma première question ici, donc toute suggestion dans les commentaires serait appréciée! Merci ;)

introduction

Une stratégie très courante pour le jeu 2048 n'est jamais de glisser vers le bas . Cela positionne tous les grands nombres en haut et les plus bas en bas. Donc, si vous appliquez correctement cette stratégie, votre tableau correspondra toujours au modèle suivant:

Le modèle à vérifier / Votre tâche

Votre soumission doit être soit un programme complet soit une fonction qui retourne une valeur véridique si le tableau peut être décrit comme ceci: En descendant dans chaque colonne du tableau, le premier nombre doit être le plus élevé de la colonne, le deuxième nombre doit être inférieur supérieur ou égal au premier nombre, etc. Une bonne carte 2048 est définie comme une carte où les nombres les plus élevés sont tous sur le dessus. C'est le code-golf , donc le code le plus court par langue (en octets) l'emporte.

E / S

L'entrée peut être prise de n'importe quelle manière appropriée, par exemple un tableau de 4 tableaux, chacun contenant 4 numéros, ou un tableau de 16 numéros. Au total, ce sera toujours 16 chiffres, représentant la carte 4x4 La sortie doit être une valeur véridique de l'entrée est une "bonne carte 2048", et une valeur fausse sinon.

Exemples

Vérité:

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


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

Faux:

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


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

Remarque

Regardez le 2ème cas de test de falsification: quand il y a une valeur vide (ou un 0) quelque part et même lorsqu'elle est suivie d'une valeur qui est supérieure au dernier nombre non nul, cela devrait être faux, car la valeur suivante après la zéro serait supérieur au 0 lui-même, ce qui le rend invalide.

Bonne chance!

code-golf decision-problem matrix board-game sliding-puzzle dv02
la source
Les commentaires ne sont pas pour une discussion approfondie; cette conversation a été déplacée vers le chat .
Martin Ender

Réponses:

16

Haskell , 21 octets

all$scanr1 max>>=(==)

Essayez-le en ligne!

Prend une liste de colonnes, avec des espaces vides comme 0.

xnor
la source
Donne la mauvaise sortie pour [[16,8,4,0],[16,0,4,4],[16,4,4,4],[16,4,4,4]].
Jonathan Allan
@JonathanAllan Il retourne faux comme il se doit, votre 2ème colonne est [16,0,4,4] qui n'est pas monotone. Ou est-ce que je manque quelque chose?
Je veux faire des jeux
0 est votre espace réservé pour une cellule vide, pas une valeur de 0.
Jonathan Allan
2
@Iwanttomakegames ce commentaire était fait pour vous (remplacez "votre" par "le").
Jonathan Allan
@JonathanAllan Je suis désolé pour toute la confusion, mais 0 devrait en effet, tout en représentant une cellule vide, compter comme la valeur 0. Les cellules vides doivent être traitées comme la valeur '0'.
dv02
10

05AB1E , 4 octets

€{íQ

Essayez-le en ligne!

Identique à mes deux autres réponses. Je promets que c'est mon dernier jusqu'à ce que les autres aient répondu :)

HyperNeutrino
la source
9

APL (Dyalog) , 7 4 octets

Prend la matrice 4 x 4, en utilisant 0 pour les blancs, comme argument.

⊢≡⌊⍀

Essayez-le en ligne!

⌊⍀ est le minimum cumulatif vertical

≡ identique à

⊢ l'argument non modifié?

Adam
la source
Golf incroyable! (Je m'attendais à ça de quelqu'un qui travaille pour Dyalog et qui a programmé APL depuis longtemps). Et, oui, MY a beaucoup de symboles APL, bien qu'ils ne soient pas des symboles APL. Alpha, Iota, Omega sont tous grecs, pas APL techniquement. Ils sont venus à l'esprit en premier en pensant aux commandes à un caractère. Par conséquent, l'augmentation et la diminution de MY sont celles de Jelly, car cela m'est venu à l'esprit en premier. (Juste pour vous informer, je suis suspendu du chat, d'où la réponse ici.)
Zacharý
7

Gelée , 4 octets

Ṣ€U⁼

Essayez-le en ligne!

Saisissez un tableau de colonnes. Fonctionne avec des grilles de taille arbitraire.

HyperNeutrino
la source
Quelle est la représentation d'une cellule vide? (par exemple 3ème col du 2ème cas de test de falsey) - "au total, ce sera toujours 16 chiffres". Cela fonctionnerait avec des zéros si vous les filtriez d'abord.
Jonathan Allan
@JonathanAllan Selon les spécifications, je pense que cela est également valable
HyperNeutrino
Pourtant, cela échouera maintenant mon cas de test suggéré de retour 0plutôt que 1.
Jonathan Allan
@JonathanAllan Comment filtrez-vous dans Jelly ._. Je m'attends à ce que cela fonctionne, mais ḟ0ne fonctionne pas
HyperNeutrino
1
@DirtyDev Ça va, nous sommes ici pour profiter des défis et aider les nouveaux utilisateurs à s'habituer à cet endroit :) J'espère que vous appréciez la communauté
HyperNeutrino
6

R (+ pryr), 23 octets

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

Qui évalue à la fonction

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

Ce qui prend une matrice en entrée:

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

Lorsqu'on leur donne une matrice, diff calcule automatiquement les différences au sein des lignes (étonnamment. Je ne connaissais pas cette fonctionnalité jusqu'à ce que je l'essaie pour ce défi).

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

Aucune de ces valeurs ne peut être supérieure ou égale à 1 dans une bonne planche, donc nous testons <1et voyons si les allvaleurs de la matrice sont conformes.

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

[1] TRUE
JAD
la source
5

JavaScript, 37 octets

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

Appelez ça comme ceci:

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

Testé sur Firefox, Chrome, JavaScript Shell et Node.js.

tsh
la source
Pourquoi transformez-vous le résultat en chaîne? ( ''+)
Zacharý
@ Zacharý sortest une méthode mutable qui mute le tableau. La première conversion en chaîne enregistrera une copie du tableau. la conversion en chaîne permet également de faire fonctionner l'opération par valeur (chaîne) au lieu de référence.
tsh
4

C # (.NET Core) , 71 octets

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

Essayez-le en ligne!

La façon ennuyeuse. Attend une entrée aplatie dans un tableau linéaire.

Alternativement, la manière explicitement interdite:

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

Essayez-le en ligne!

Lève une exception IndexOutOfBoundsException pour indiquer vrai, se termine normalement pour indiquer faux. J'ai essayé une version qui incluait la conversion d'exception / pas d'exception en vrai / faux, mais elle a fini aussi longtemps que la version régulière.

Kamil Drakari
la source
4

JavaScript, 34 , 32 octets

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

Appelez en passant dans un seul tableau contenant la première colonne, suivi des 2e, 3e et 4e.

Compare chaque numéro au numéro précédent à l'exception du premier numéro de chaque colonne et renvoie vrai si tous sont vrais.

Tester

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: sauvé 2 octets grâce à tsh

Grax32
la source
après quelques transformations booléennes:v=>!v.some((x,i)=>i%4&&x>v[i-1])
tsh
3

Haskell , 28 octets

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

Il y a aussi

all$(==)=<<sort

avec 15 octets, mais il ne nécessite que import Data.Listlorsque vous travaillez avec le Prelude. Alternativement,

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

avec 25 octets fonctionne dans GHCI.

Bergi
la source
3

Gaia , 3 6 octets

+3 octets car apparemment je ne savais pas comment ma langue fonctionnait

ọ¦_ẏ⁇!

Il s'agit d'une fonction acceptant une liste de colonnes et laissant le résultat sur la pile.

Il existe quelques autres solutions de 6 octets, notamment 0+¦o¦ẏet ọ¦_ẏ¦ỵ.

Essayez-le en ligne!

Explication

ọ¦      Deltas of each column
  _     Flatten
   ẏ⁇   Keep only positive numbers
     !  Negate (is it empty?)
Chat d'affaires
la source
Je ne peux pas rétrograder, mais l'utilisation d'un opérateur ajouté à la langue après la publication du défi ne me semble pas juste. De plus, cela semble interdit par défaut en fonction de cela .
Cinaski
@Cinaski Nous avons en quelque sorte abandonné cette règle, comme on le voit ici . Quoi qu'il en soit, mes solutions alternatives n'utilisent que des opérateurs qui existaient définitivement avant le défi.
Business Cat
Je vais juste le changer pour l'un des autres, je suppose
Business Cat
Peu importe, je n'étais pas au courant de cette nouvelle règle.
Cinaski
3

TI-BASIC, 25 octets

Prend l'entrée comme une matrice 4x4 dans Ans.

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

Explication

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.
calc84maniac
la source
2

Haskell , 41 octets

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

Essayez-le en ligne!

Définit la fonction sans point all f, où fdétermine si une liste est triée.

Assistant de blé
la source
Darn, cela bat Python par 1 octet; P
HyperNeutrino
@HyperNeutrino Eh bien, le xnor bat python par 21: P
Wheat Wizard
Vous pouvez également définir fcommef(a:b:c)=a>=b&&f(b:c)
Cristian Lupascu
2

JavaScript (ES6), 42 octets

Prend un tableau de colonnes; renvoie un nombre (véridique) ou false.

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

JavaScript (ES6), 54 47 octets

Premier essai. Prend un tableau de colonnes; renvoie trueou false.

a=>a.every(c=>c.slice(1).every((n,i)=>n<=c[i]))
darrylyeo
la source
Quelle valeur attendez-vous pour des cellules vides?
Arnauld
2

MATL , 4 octets

SGX=

Essayez-le en ligne!

Entrez sous forme de tableau de lignes, à l'envers.

S       % sort columns
GX=     % compare with input
        % true if arrays are numerically equal
        % (implicit) convert to string and display
Cinaski
la source
Ne fonctionne pas pour les cas qui doivent renvoyer truey qui ont des zéros entre les éléments de colonne comme celui-ci par exemple.
Jonathan Allan
Tu as raison, je travaille sur une solution. BTW je ne suis pas le seul à avoir des problèmes avec les cellules vides;)
Cinaski
Ouais, je peux voir ça. J'ai également suggéré un cas de test pour cela. Ping une fois corrigé et vous obtiendrez un vote positif de ma part :)
Jonathan Allan
@JonathanAllan attendez, qui a dit que cela devrait être vrai lorsqu'il y a des zéros entre les éléments de la colonne? Regardez mon deuxième test de falsification, une cellule vide / un 0 suivi d'une valeur plus élevée lors de la descente n'est pas valide.
dv02
@DirtyDev FYI avec le libellé initialement donné et son interprétation sensée, votre deuxième cas de falsey serait toujours falsey; c'est juste mon cas de test suggéré serait véridique.
Jonathan Allan
2

Swift 4 , 84 77 octets

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

Essayez-le en ligne!

M. Xcoder
la source
2

Dyalog APL, 21 19 15 octets

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

Essayez-le en ligne! (modifié pour qu'il fonctionne dans tryapl)

Prend l'entrée comme un tableau 2D.

Comment?

  • ⎕ contribution
  • ⍉ transposer
  • ↓ Tableau 2D => vecteur 1D de vecteurs 1D
  • { ... }¨appliquer ceci à chaque membre (argument ⍵):
    • ⍵[⍒⍵] ⍵ tri décroissant
    • ⍵≡ égalité avec ⍵
  • ∧/si chaque élément l'est 1.
Zacharý
la source
Dépassé de 73%!
Adám
2

Japt , 7 octets

J'ai essayé quelques méthodes différentes pour celui-ci mais, au final, le plus court que j'ai pu trouver a fini par être un portage de la solution JS de tsh.

Prend un tableau de colonnes en entrée. Les cellules vides peuvent être 0ou omises s'il n'y a pas d'autres nombres dans la colonne.

P+U¥®n§

Essaye-le

Explication

Entrée implicite du tableau U.

P+U

Ajoutez Uune chaîne vide et convertissez le tableau en chaîne.

¥

Vérifiez l'égalité, qui transforme également le côté droit en chaîne.

®

Carte terminée U.

n§

Trier ( n) par <=.

Sortie implicite du résultat booléen.

Hirsute
la source
Joli arrangement pour sauter la seconde U. Vous pourriez aussi faire nnà la fin;)
ETHproductions
J'ai été surpris de constater que l'omission du second a Ufonctionné dans ce cas, @ETHproductions; Je pensais que cela ne fonctionnerait que si la variable était la seule chose à gauche de la ==. Je vais devoir m'en souvenir pour une utilisation future.
Shaggy
1

Java 8, 69 octets

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

Eh bien, à ce jour, cela bat la solution Swift, donc il y a ça! Tout à fait simple. L'entrée est un tableau de tableaux entiers, les tableaux intérieurs étant des colonnes de la carte (les carrés supérieurs en premier). Cast to Function<int[][], Boolean>.

Jakob
la source
1

MY , 66 62 20 octets (sans concurrence)

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

Essayez-le en ligne!

La raison pour laquelle cela n'est pas en concurrence est que j'ai récemment implémenté 8E (≡), ce qui équivaut à APL ≡.

Comment?

  • ω⍉ Le premier argument de ligne de commande transposé
  • ω⍉ Le premier argument de ligne de commande transposé
  • A6ǵ'push chr(0x6A)( ⍖dans la page de code, qui trie en ordre décroissant)
  • ƒ comme une fonction, plutôt qu'une chaîne
  • ⇹ pousser une fonction qui mappe une fonction sautée sur chaque argument
  • ( appliquer
  • E8ǵ'ƒ⇹( la même chose, sauf avec chr(0x8E), qui est la commande match ( ≡).
  • Π produit
  • ← sortie sans nouvelle ligne

Oui, beaucoup de symboles de MY sont exactement identiques ou similaires à ceux d'APL. L'explication est qu'ils me sont venus à l'esprit quand je voulais une commande à 1 caractère. (Je ne sais pas pourquoi je n'ai pas utilisé T pour la transposition)

Zacharý
la source
0

Mathematica, 27 octets

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

Explication:

  • Threadest une opération générale de type transposition bizarre qui arrive à prendre la transposition quand on lui donne une matrice .
  • t=Thread;me permet d'utiliser tdeux fois au lieu de Threaddeux pour économiser des octets.
  • Sort trie une liste (dans l'ordre croissant).
  • Sort\@mappe la Sortfonction à chaque élément d'une liste individuellement; lorsqu'il est appliqué à une matrice, il trie les lignes.
  • t@#applique la fonction de transposition à l'entrée #de la fonction principale.
  • - prend le négatif de toutes les entrées de sorte que le tri des lignes de la matrice transposée (les colonnes de l'original) les trie de la manière souhaitée.
  • L'extérieur -t[...]défait le négatif et la transposition, donc tout ce que nous avons vraiment fait était de trier les colonnes du plus grand au plus petit.
  • ==# teste pour voir si cette nouvelle matrice triée par colonne est égale à l'entrée d'origine.
  • &termine la fonction anonyme avec l'entrée que #nous avons définie.

Vous pouvez l' essayer en ligne dans le sandbox Wolfram Cloud en collant du code comme celui-ci et en cliquant sur Gear -> "Evaluer la cellule" ou en appuyant sur Maj + Entrée ou sur le pavé numérique Entrée:

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

Ou pour tous les cas de test:

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}}}]&
Des notes.
la source