这是一个很好的2048板吗？

26

这是我的第一个问题，因此在评论中提出的任何建议将不胜感激！谢谢 ;）

介绍

2048游戏的一种非常普遍的策略是从不失败。这会将所有大数字放在顶部，将较低的数字放在底部。因此，如果正确应用此策略，则您的开发板将始终符合以下模式：

要检查的模式/您的任务

如果董事会可以这样描述，则您的提交应为完整程序或返回真实值的函数：在董事会的每一列中，第一个数字应为该列的最高值，第二个数字应为较小的值等于或等于第一个数字，以此类推。好的2048板定义为最高编号都位于顶部的板。这是code-golf，所以每种语言的最短Code（以字节为单位）获胜。

输入输出

可以以任何适当的方式获取输入，例如4个数组的数组，每个数组包含4个数字，或者16个数组。总的来说，它将始终是16个数字，代表4x4板 。输出应为真实值，输入应为“ 2048良好板”，否则为假值。

例子

真相：

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


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

虚假：

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


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

注意

看一下第二个伪造的测试用例：当某个地方有一个空值（或0），即使它后面跟着一个比最后一个非零数字都高的值，这也应该是伪造的，因为在零将高于0本身，这使其无效。

祝好运！

code-golf  decision-problem  matrix  board-game  sliding-puzzle 
— dv02
source
评论不作进一步讨论；此对话已转移至聊天。
— Martin Ender

Answers:

16

Haskell，21个字节

all$scanr1 max>>=(==)

在线尝试！

接受列列表，空格为0。

— 异或
source
给出错误的输出[[16,8,4,0],[16,0,4,4],[16,4,4,4],[16,4,4,4]]。
— 乔纳森·艾伦
@JonathanAllan它应该返回false，您的第二列是[16,0,4,4]，这不是单调的。还是我错过了什么？
— 我想在
0是你的空单元格，而不是0值占位符
— 乔纳森·艾伦
2
@Iwanttomakegames该注释是为您准备的（用“ the”代替“ your”）。
— 乔纳森·艾伦
@JonathanAllan对所有混乱感到抱歉，但是0代表一个空单元格时，的确应计为值0。空单元格应视为值'0'。
— dv02
9

APL（Dyalog），7 4字节

采用4×4矩阵，其中0表示空白。

⊢≡⌊⍀

在线尝试！

⌊⍀ 是垂直累积最小值

≡ 相同

⊢ 未经修改的论点？

— 亚当
source
神奇的高尔夫！（我希望从为Dyalog工作并且对APL编程很长时间的人那里获得经验）。而且，是的，MY确实有很多APL符号，尽管它们不是APL符号。Alpha，Iota，Omega都是希腊文，而不是APL。在考虑单字符命令时，他们首先想到了。因此，MY的增减是果冻的，因为首先想到的是。（仅通知您，我被暂停了聊天，因此在这里回复。）
— Zacharý17年
7

果冻，4字节

Ṣ€U⁼

在线尝试！

输入为列数组。适用于任意大小的网格。

— 超中微子
source
空单元格的表示是什么？（例如，第二个虚假测试用例的第三个列）-“总共将始终为16个数字”。如果先过滤掉零，它将与零一起工作。
— 乔纳森·艾伦
@JonathanAllan根据规范，我认为这也是有效的
— -HyperNeutrino
但这将使我建议的测试用例返回0而不是失败1。
— 乔纳森·艾伦
@JonathanAllan您如何过滤果冻._。我期望这个工作，但ḟ0不工作
— HyperNeutrino
1
@DirtyDev没关系，我们在这里可以享受挑战，并帮助新用户适应这个地方：)我希望您在享受社区
— HyperNeutrino
6

R（+ pryr），23个字节

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

对功能求值

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

它将矩阵作为输入：

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

给定矩阵后，将diff自动计算行中的差异（令人惊讶的是。直到我对此挑战进行尝试之前，我才知道此功能）。

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

在一个好的板上，这些值都不能为1或更高，因此我们进行测试<1并查看all矩阵的值是否符合要求。

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

[1] TRUE
— 贾德
source
5

JavaScript，37个字节

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

这样称呼它：

|-------------------|
| 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 Shell和Node.js上进行了测试。

— tsh
source
为什么将结果转换为字符串？（''+）
— 扎卡里
@Zacharý sort是可变方法，它将使数组变异。首先转换为字符串将保存数组的副本。转换为字符串还可以使相等操作按（字符串）值而不是引用进行工作。
— tsh
4

C＃（.NET Core），71字节

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

在线尝试！

无聊的方式。期望输入变平为线性数组。

或者，明确禁止的方式：

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

在线尝试！

抛出IndexOutOfBoundsException以表示true，正常结束则表示false。我尝试了一个包含从例外/无例外到true / false的转换的版本，但是它的结束时间与普通版本一样长。

— 卡米尔（Kamil Drakari）
source
4

JavaScript，34，32字节

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

通过传入包含第一列，第二，第三和第四列的单个数组进行调用。

将每列的第一个数字（第一个数字除外）与每个数字进行比较，如果所有条件都为true，则返回true。

测试

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

编辑：由于tsh，保存了2个字节

— Grax32
source
经过布尔转换后：v=>!v.some((x,i)=>i%4&&x>v[i-1])
— tsh
3

Haskell，28个字节

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

还有

all$(==)=<<sort

15字节，但import Data.List仅在使用Prelude时需要。或者，

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

在GHCI中具有25个字节的作品。

— 贝吉
source
3

盖亚，3 6个字节

+3个字节，因为显然我不知道我的语言是如何工作的

ọ¦_ẏ⁇!

这是一个接受列列表并将结果保留在堆栈中的函数。

存在一些其他的6字节解决方案，包括0+¦o¦ẏ和ọ¦_ẏ¦ỵ。

在线尝试！

说明

ọ¦      Deltas of each column
  _     Flatten
   ẏ⁇   Keep only positive numbers
     !  Negate (is it empty?)
— 商务猫
source
不能拒绝投票，但是在挑战发布后使用添加到语言的运算符对我来说似乎不公平。根据此，默认情况下它也是被禁止的。
— Cinaski '17
@Cinaski我们一种从规则搬走了，因为看到这里。无论哪种方式，我的替代解决方案都只使用在挑战之前肯定存在的运算符。
— 商务猫
我只是将其更改为我猜中的另一种
— Business Cat
没关系，我不知道这个新规则。
— Cinaski '17
3

TI-BASIC，25个字节

在Ans中将输入作为4x4矩阵。

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

说明

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.
— calc84疯子
source
2

JavaScript（ES6），42个字节

接受一列列；返回一个（真实的）数字或false。

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

JavaScript（ES6），54 47字节

第一次尝试。接受一列列；返回true或false。

a=>a.every(c=>c.slice(1).every((n,i)=>n<=c[i]))
— 达里里奥
source
对于空单元格，您期望哪个值？
— Arnauld
2

MATL，4个字节

SGX=

在线尝试！

输入为行数组，上下颠倒。

S       % sort columns
GX=     % compare with input
        % true if arrays are numerically equal
        % (implicit) convert to string and display
— 西纳斯基
source
对于应返回truthy具有列元素等之间的零的情况下不起作用此为一例。
— 乔纳森·艾伦
没错，我正在研究解决方案。顺便说一句，我不是唯一一个有空单元问题的人；）
— Cinaski '17
是的，我可以看到。我也建议了一个测试用例。Ping固定后，您会收到我的支持：)
— 乔纳森·艾伦
@JonathanAllan等一下，谁说当列元素之间为零时应该返回真实值？看看我的第二个虚假测试用例，一个空单元格/ 0表示当失败时后面跟着一个更高的值是无效的。
— dv02 '17
@DirtyDev FYI最初给出的措辞及其明智的解释是，您的第二个虚假案例仍然是虚假的；这只是我建议的测试用例是真实的。
— 乔纳森·艾伦
2

Dyalog APL，21 19 15字节

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

在线尝试！（已修改，因此它将在tryapl中运行）

将输入作为2D数组。

怎么样？

  • ⎕ 输入
  • ⍉ 转置
  • ↓ 2D数组=> 1D向量的1D向量
  • { ... }¨将其应用于每个成员（参数⍵）：
    • ⍵[⍒⍵] ⍵ 降序排列
    • ⍵≡ 与...平等 ⍵
  • ∧/是否每个元素都是1。
— 扎查里
source
— 2015年
2

Japt，7个字节

为此尝试了几种不同的方法，但最后，我能想到的最短的方法是tsh的JS解决方案的移植。

将列数组作为输入。0如果该列中没有其他数字，则可以省略或省略空单元格。

P+U¥®n§

测试一下

说明

数组的隐式输入U。

P+U

前置U一个空字符串，将数组转换为字符串。

¥

检查是否相等，也将右边转换为字符串。

®

映射到U。

n§

按排序（n）<=。

隐式输出布尔结果。

— 毛茸茸
source
跳过第二个安排很好U。您也可以nn在最后做;）
— ETHproductions'Aug
令我惊讶的是，U在这种情况下，省略了第二个@ETHproductions。我以为只有变量是左侧的唯一东西，它才会起作用==。我必须记住它以备将来使用。
— 毛茸茸的
1

Java 8，69字节

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

好吧，截至本文撰写之时，它胜过了Swift解决方案，就是这样！完全简单。输入是整数数组的数组，内部数组是木板的列（最上面的正方形）。投放到Function<int[][], Boolean>。

— 雅各布
source
1

MY，66 62 20字节（非竞争）

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

在线尝试！

这是非竞争性的原因是我最近实现了8E (≡)，它等效于APL ≡。

怎么样？

  • ω⍉ 第一个命令行参数转置
  • ω⍉ 第一个命令行参数转置
  • A6ǵ'推chr(0x6A)（⍖在代码页中，按降序排列）
  • ƒ 作为函数，而不是字符串
  • ⇹ 推送一个将弹出的函数映射到每个参数的函数
  • ( 应用
  • E8ǵ'ƒ⇹( 除了chr(0x8E)，这是相同的东西，这是match命令（≡）。
  • Π 产品
  • ← 没有换行符的输出

是的，许多MY的符号与APL的符号完全相同或相似。解释是，当我需要一个1个字符的命令时，便想到了它们。（我不知道为什么我不使用T进行转置）

— 扎查里
source
0

Mathematica，27个字节

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

说明：

  • Thread是一个奇怪的类似于一般转置的操作，在给定矩阵时碰巧进行了转置。
  • t=Thread;让我用t两次而不是Thread两次来节省字节。
  • Sort 对列表进行排序（以递增顺序）。
  • Sort\@将Sort函数分别映射到列表的每个元素；当应用于矩阵时，它将对行进行排序。
  • t@#将移调函数应用于#主函数的输入。
  • - 取所有条目的负数，以便对转置矩阵的行进行排序（原始列）以所需的方式对其进行排序。
  • 外层-t[...]消除了底片和移调，因此我们真正要做的就是按最大到最小对列进行排序。
  • ==# 测试以查看此新的按列排序的矩阵是否等于原始输入。
  • &以#我们定义的输入结束匿名函数。

您可以在Wolfram Cloud沙箱中在线尝试，方法是粘贴以下代码，然后单击Gear->“评估单元格”，或按Shift + Enter或数字键盘Enter：

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

或对于所有测试用例：

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}}}]&
— 分数。
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.