创建低于50,000的蛇行列表

24

偷袭数字挑战

我想知道在1到50,000之间有多少个蛇行数字？

诺基亚蛇

在此游戏中，蛇行数字是指可以通过向上，向下，向左或向右移动一个键在传统数字键盘（下面的格式）上键入的数字。

7 8 9
4 5 6
1 2 3
 0

例如，如果您以数字5开头，则可以选择4、6、8或2作为下一个有效动作-但是，由于7、3、9和1与当前键成对角线，因此它们是禁止进入的。因此，如果您有5个，然后是2个，则下一个可行的键选择又是0、1、3或5。

在此Code Golf练习中，您将输出一个列表，其中包含1到50k之间的所有正数，以及所有符合条件的数的最终计数。

规则

  1. 数字不能以零开头。
  2. 数字必须是整个正整数。
  3. 从左到右读取的每个连续数字必须在数字键盘周围“蛇行”。
  4. 蛇不能斜跨钥匙穿过
  5. 可以从数字1和2访问数字0
  6. 数字不能配对（例如：22）

有效的蛇行号码示例：

12369
45201
1254
10102
1
12
987

无效数字的例子

1238 - 8 is not connected
0001 - multiple leading 0s
0101 - leading 0
159  - snake cannot travel diagonally
4556 - duplicate 5

按照普通的Code Golf，目标是最少字节！

根据我的数学和规则，您的列表中应该有670个有效的蛇行编号，最后一个数字是670个本身。

code-golf 
— MightBeAlon
source
2
输出应该排序吗？还是以任何顺序允许它？
— tsh
2
看到您要我们输出一组固定且有限的整数时，我建议在规范中包括完整列表。
— 毛茸茸的
— Arnauld
4
这是A215009的子集。
— bigyihsuan
首先打印670可以吗？
— dana

Answers:

14

K（ngn / k），60 57字节

(x;#x:{*/1=3!5&+/x*x:+1_-':(+0 1,'2*!3 3)@10\x}#1+!50000)

在线尝试！

!500000.. 清单49999

1+ 加1

{ }# 使用以下功能过滤 { }

10\x 参数的十进制数字

( )@ 在...中用作索引

  • !3 3 一对清单： (0 0 0 1 1 1 2 2 2;0 1 2 0 1 2 0 1 2)

  • 2* 全部乘以2

  • 0 1,'预先考虑0到第一个列表，1到第二

  • +转置（列表对->列表对）。这给了我们大约按钮的坐标。

-':从每对中减去前一对。使用0 0如之前所述第一假想元件。

1_ 掉头

+ 转置

x*x:平方（分配给x并乘以x）。这x是一对列表-∆xs和∆ys

+/ 对两个列表求和（逐个元素）

5& 5分钟

3! Mod 3

1= 等于1的布尔值列表

*/ 产品（布尔“和”）

(x;#x: )将结果与结果的长度（#）配对

— ngn
source
9

果冻， 24  23 字节

5ȷ4µDo1.’d3ZIASĊ’ẸµÐḟṄL

一个完整的程序，打印所有结果的列表，然后打印结果数。

在线尝试！

怎么样？

5ȷ4µDo1.’d3ZIASĊ’ẸµÐḟṄL - Main Link: no arguments
5ȷ4                     - 5*10^4 = 50000
   µ              µÐḟ   - filter discard those for which this is truthy:
                        -                  e.g.: 8520        ... or           4559 
    D                   -   decimal digits       [8,5,2,0]                    [4,5,5,9]
      1.                -   literal 1.5
     o                  -   logical OR           [8,5,2,1.5]                  [4,5,5,9]
        ’               -   decrement            [7,4,1,0.5]                  [3,4,4,8]
         d3             -   div-mod by 3         [[2,1],[1,1],[0,1],[0,0.5]]  [[1,0],[1,1],[1,1],[2,2]]
           Z            -   transpose            [[2,1,0,0],[1,1,1,0.5]]      [[1,1,1,2],[0,1,1,2]]
            I           -   deltas               [[-1,-1,0],[0,0,-0.5]]       [[0,0,1],[1,0,1]]
             A          -   absolute value       [[1,1,0],[0,0,0.5]]          [[0,0,1],[1,0,1]]
              S         -   sum (vectorises)     [1,1,0.5]                    [1,0,2]
               Ċ        -   ceiling              [1,1,1]                      [1,0,2]
                ’       -   decrement            [0,0,0]                      [0,-1,1]
                 Ẹ      -   any?                 0 (i.e. keep)                1 (i.e. discard)
                     Ṅ  - print and yield
                      L - length
                        - implicit print
— 乔纳森·艾伦
source
我很想知道这是怎么工作的。您有机会细分吗？
— MightBeAlon
1
@MightBeAlon稍后会做...
— 乔纳森·艾伦
我很好奇，如何1.评价1.5？
— 无知的体现
@EmbodimentofIgnorance在将句点后的字面值解析为缺失数字期间被视为5。请参阅interpreter.py中parse_literal的最后else子句
— Jonathan Allan，
7

Python 3，140个字节

f=lambda s:''==s[1:]or s[1]in'10021234562216565878 43 749 9   5  8'[int(s[0])::10]and f(s[1:])
print(*filter(f,map(str,range(1,50000))),670)

在线尝试！

我肯定有人可以使用表达式而不是查找字符串来完成此操作。

— 吉特
source
7

Python 2，101字节

print[n for n in range(1,50000)if all(`n`[i:i+2]in`0x20b33ec8bc49a10589e76b15`for i in range(4))],670

在线尝试！

十六进制数是十进制10120214525632365878969854741，它编码可能彼此相邻出现的每一对有序数字。

— 负七
source
5

JavaScript（V8）， 112106104 字节

@NahuelFouilleul节省了2个字节

完整的程序。

for(n=0;++n<5e4;)[...n+''].every(x=>'6589632145201478'.match(x+p+'|'+p+(p=x)),p='')&&print(n)
print(670)

在线尝试！

或96字节，如果我们可以输出以相反的顺序的数字：

for(n=5e4;n--;)[...n+''].every(x=>'6589632145201478'.match(x+p+'|'+p+(p=x)),p='')&&print(n||670)

在线尝试！

— Arnauld
source
作品还删除了最后一个3也许是因为36已经在字符串中了
— Nahuel Fouilleul
@NahuelFouilleul好收获。谢谢！
— Arnauld
1
还要6589632145201478短一个字节
— Nahuel Fouilleul
4

Stax，37 35 字节

ü╞╡~▄ⁿ♪eµïê◙ü╔ï▼ΔJr¥æ≤PH╟♀I♣Δz8─¶Γ╞Ç▓

在staxlang.xyz上运行和调试它！

太好了，很短，直到不是。

解压缩（42个字节）和说明

49999{E2B{{om"#qYY>!(AFI"%A|E2B{{om-C_Qf%p
49999{                                 f      Filter range [1..49999]:
      E2B                                       All adjacent pairs of digits
         {{om                                   Each sorted
             "#qYY>!(AFI"%A|                    Literal 2012365478963258741
                            E2B{{om             Pairs of digits, each sorted
                                   -            Set difference
                                    C           Cancel block execution if any remain
                                     _Q         Print current value
                                        %p    Print length

2012365478963258741对小键盘进行编码。查看成对的相邻数字。也许如果我能得到一个不错的短替代品，并且每对都双向交易，那么我可以削减8个字节。{{om。

没有该结尾的670，一个简单的过滤器就足够了：f..!代替{..C_Qf%p。可能会有更好的方法来处理这种不规则性。在任何一种情况下，此过滤器范围行为均未记录。

— 库尔德拉西斯·纳巴里亚
source
抱歉文档差距。FWIW，它将在下一版本1.1.7中发布。您可以在stax.tomtheisen.com上看到预览，但这是个秘密，所以不要告诉任何人。;）
— 递归
3

PHP，145字节

for(;$i++<5e4;$f&&print$i._)for($f=1,$l=b;''<$d=("$i")[$$i++];$l=$d)$f&=$l>a||strstr([12,240,1053,26,157,2468,359,48,579,68][$l],$d)>'';echo 670;

在线尝试！

对于从1到50,000的每个数字，从左到右检查该数字的每个数字。如果所有数字都在前一位数字的有效数字列表中，则会打印该数字。最后打印一个硬编码的670，因为它占用的字节数少于实际计数的字节数。

— 晚2
source
3

05AB1E，23个字节

ŽÅKLʒSÌYX;:3‰üαï€OP}=g=

在线尝试！

乔纳森·艾伦港口的果冻答案。

— 严厉的
source
1
嗯，只压缩3个字节的50000很聪明。我正在使用₄50*或4°5*稍早尝试时。刚开始我感到困惑，为什么会有€OP而不是正义OP，但是我意识到一位数字（在后面是空列表üα）将会[] → 0 → 0代替[] → [] → 1。:)
— 凯文·克鲁伊森
1
@KevinCruijssen为什么4°5*可以5°;？我更喜欢ZAK。是的，那种单数数字的极端情况令人痛苦。
— Grimmy
3

的JavaScript（SpiderMonkey的），179个 173 151 129字节

[12,240,1350,26,157,2468,359,48,579,68].map((_,i,l)=>i&&(f=(v,t)=>print(v)|v<5e3&&[...l[t]+''].map(k=>f(v+k,k)))(i,i)),print(670)

在线尝试！

-22字节感谢Arnauld -22字节感谢dana

说明：

[12,240,1350,26,157,2468,359,48,579,68] 
// an array where keys are current position and values, the possible destinations
.map((_,i,l)=>                    // loop over it
    i&&(                          // if key is not 0
        f=(v,t)=>                 // create a function
                 print(v)|        // which print the value
                          v<5e3&& // and if the limit is not attained
                                 [...l[t]+''].map(k=>f(v+k,k)) 
                    // recurcively call itself with for each destinations
                                                              )(i,i)),
                    // make the first call with each digit
print(670) // finally print 670

如果我们可以先打印670，则@dana还提供了123字节的解决方案

[21,420,5310,62,751,8642,953,84,975,86].map((_,i,a)=>(f=(v,t)=>print(i?v:640)|i&v<5e3&&[...a[t]+''].map(k=>f(v+k,k)))(i,i))
— 乔纳特贾诺
source
@ Arnauld谢谢我忘记了这个规则
— jonatjano
— Arnauld
129？
— dana
如果可以先打印640，则为123。
— dana
2

Stax，28 26 字节

Δh┤♣É╦&·é╝n$K»à¶▲v═NÆ;↨m≥8

运行并调试

拆开包装，松开包装并进行评论，看起来像这样。

G               Call to unbalanced trailing '}', then resume here
670P            Print 670
}               Call target
219J            219 squared (47961)
f               Filter 1-based range by the rest of the program; implicitly output
  $2B           Convert to string and get adjacent pairs; e.g. 213 -> ["21", "13"]
  O             Push 1 under list of pairs
  F             Iterate over pairs, using the rest of the program
    o           Order each pair; e.g. "21" -> "12"
    "{<f:[/T8Z" string literal with code points [123 60 102 58 91 47 84 56 90]
    $           concate as string i.e. "12360102589147845690"
    s#          How many times does the current pair appear in the constant string?
    *           Multiply this by running total.  Any zero will cause the result to be zero.

运行这个

秘密调味料在字串中"{<f:[/T8Z"。将所有代码点合并在一起后，您会得到12360102589147845690。此字符串中的升序对是有效的蛇移动。

— 递归的
source
1
15JJ而不是219J也可以，但是我认为除非有1个字节的常数，否则您不能从那里打高尔夫球15。
— Arnauld
2

Haskell，118个字节

(filter(and.(zipWith elem.tail<*>map f).show)[1..50000],670)
f c=words"12 024 0135 26 157 2468 359 48 579 68"!!read[c]

在线尝试！

第一遍；我不擅长压缩。

在s=不计，因为我们实际上并不需要的结果绑定。

取消代码。

— 油菜
source
1

木炭，42字节

≔ΦＩ…·¹×⁵⁰φ⬤ι№”)¶∧XRτ_ΠＧêＲ⁵m⎇λ”✂ιμ⁺²μ¹θθＩＬθ

在线尝试！链接是详细版本的代码。说明：

≔ΦＩ…·¹×⁵⁰φ

处理包括在内的范围，从1转换50,000为字符串。

⬤ι№”)¶∧XRτ_ΠＧêＲ⁵m⎇λ”✂ιμ⁺²μ¹θ

过滤掉那些没有包含在压缩字符串中的数字对01478963202125458565236987410。

θＩＬθ

输出剩余的数组及其长度。

— 尼尔
source
1

Perl 6、64字节

{670,grep {[+&](:36<12HGX91H8VCL3MG0FDVQ>X+>m:ov/../)%2},1..5e4}

在线尝试！

说明

{670,grep {...},1..5e4}  # Meet questionable output requirements

# Actual decision problem

     :36<12HGX91H8VCL3MG0FDVQ>  # Bit field of allowed transitions
                                # encoded in base 36
                                 m:ov/../  # All 2-digit substrings
                              X+>  # Right shift by each substring
                                   # (implicitly converted to an integer)
[+&](                                    )  # Binary and
                                          %2  # Modulo 2
— 恩韦恩霍夫
source
可惜的~>是尚未实现，否则您可以只用字符串运算符就可以做到这一点，而位字段是字符串
— Jo King
1

Pyth，68 65 45字节

l
f.Am}dCtB+J`65874589632012541_PJCtB`TS50000

在线尝试！

Khuldraeseth na'Barya的Stax答案对修改查找过程的启发，请给他们投票！

编辑2：重写以保存一堆字节，以前的版本： 

l
f.Am}ed@c"12 024 0135 26 157 2468 359 48 579 68";shdCtB`TS50000

编辑：通过使用字符串查找，以前的版本打了3个字节：

l
f.Am}ed@sMMc"12 024 0135 26 157 2468 359 48 579 68";hdCtBjT;S50000
— ok
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.