列出安诺游戏的所有可能标题

37

在Anno视频游戏系列中，有6款游戏宣布将于2019年初发布第7款游戏。它们的游戏总以特定的模式展示一年：

Anno 1602, Anno 1503, Anno 1701, Anno 1404, Anno 2070, Anno 2205, Anno 1800

  • 数字总和始终为9。
  • 年是四位数长。
  • 它们包含至少一个零。

在这些限制中，存在109种可能的标题：

[1008,1017,1026,1035,1044,1053,1062,1071,1080,1107,1170,1206,1260,1305,1350,1404,1440,1503,1530,1602,1620,1701,1710,1800,2007,2016,2025,2034,2043,2052,2061,2070,2106,2160,2205,2250,2304,2340,2403,2430,2502,2520,2601,2610,2700,3006,3015,3024,3033,3042,3051,3060,3105,3150,3204,3240,3303,3330,3402,3420,3501,3510,3600,4005,4014,4023,4032,4041,4050,4104,4140,4203,4230,4302,4320,4401,4410,4500,5004,5013,5022,5031,5040,5103,5130,5202,5220,5301,5310,5400,6003,6012,6021,6030,6102,6120,6201,6210,6300,7002,7011,7020,7101,7110,7200,8001,8010,8100,9000]

您的目标是以任何合理的形式以最少的字节数列出它们。

code-golf  number  kolmogorov-complexity 
— 莱科尼
source
输出格式的灵活性如何？是该接受吗？
— 路易斯·门多
1
@LuisMendo是的，我很好。
— Laikoni '18
是否允许数字列表？
— 暴民埃里克（Erik the Outgolfer）'18年
1
@aslum我假设您的意思是很多空格，而不仅仅是空格，对吗？评论减价不能很好地体现这一点。鉴于上面的Luis格式是允许的，所以我认为这是允许的。;-)
— 暴民埃里克（Erik the Outgolfer）
1
@EriktheOutgolfer我想对数字列表说不，因为它们真的看起来不再像几年了。
— Laikoni '18

Answers:

20

R，59 51字节

输出有效数字作为201列表的名称。为什么是201？因为ASCII 0是48，而4 * 48 + 9是...是的。由混叠保存6个字节^以Map通过使用与另一2 1:9e3为范围。

"^"=Map;x=sum^utf8ToInt^grep(0,1:9e3,,,T);x[x==201]

在线尝试！

说明

# Create list of sums of ASCII char values of numbers,
# with the original numbers as the names of the list
x <- Map(sum,
  # Create a list from the strings where each element is the string split 
  # into ASCII char values
  Map(utf8ToInt,
      # Find all numbers between 1 and 9e3 that contain a zero
      # Return the matched values as a vector of strings (6th T arg)
      grep(pattern=0,x=1:9000,value=TRUE)
  )
)
# Pick out elements with value 201 (i.e. 4-digits that sum to 9)
# This implicitly only picks out elements with 4 digits, since 3-digit 
# sums to 9 won't have this ASCII sum, letting us use the 1:9e3 range
x[x==201]
— 多伊
source
3
啊，grep为什么我永远不记得它会变成character...
— 朱塞佩
9

果冻，11字节

9ȷṢ€æ.ẹ9ṫ19

在线尝试！

这个怎么运作

9ȷṢ€æ.ẹ9ṫ19  Main link. No arguments.

9ȷ           Set the left argument and the return value to 9000.
  Ṣ€         Sort the digits of each integer in [1, ..., 9000].
    æ.       Perform the dot product of each digit list and the left argument,
             which gets promoted from 9000 to [9000].
             Overflowing digits get summed without multiplying, so we essentially
             map the digit list [a, b, c, d] to (9000a + b + c + d).
      ẹ9     Find all 1-based indices of 9.
             Note that 9000a + b + c + d == 9 iff a == 0 and b + c + d == 9.
        ṫ19  Tail 19; discard the first 18 indices.
— 丹尼斯
source
7

PowerShell，50 49字节

999..1e4-match0|?{([char[]]"$_"-join'+'|iex)-eq9}

在线尝试！

构造一个从999到的范围10000，然后使用内联-match作为过滤器以提取与regex匹配的那些条目0。剩下的就是我们，1000, 1001, 1002, etc.然后将其传送到一个Where-Object子句中，在该子句中，我们将当前数字作为字符串"$_"，将其转换为-array char，-join这些字符与+和Invoke-pression Ex（类似于eval）一起得出其数字总和。我们检查这是否与-equal相同9，如果是，则将其传递到管道中。程序完成时，将从管道中提取这些数字并隐式输出。

— AdmBorkBork
source
5

JavaScript（ES6），78 73字节

@KevinCruijssen节省了2个字节

返回以空格分隔的字符串。

f=(n=9e3)=>n>999?f(n-9)+(eval([...n+''].join`+`)&/0/.test(n)?n+' ':''):''

在线尝试！

怎么样？

我们遍历范围用的增量，忽略不具有数字。[1008..9000]90

所有这些数字都是倍数，因此它们的数字总和也应保证是的倍数。99

由于有效数字至少具有1个，因此它们的总数不超过2个，这意味着其余数字的总和最多为。因此，足以测试数字总和是否为奇数。0918

因此测试：

(eval([...n + ''].join`+`) & /0/.test(n)
— Arnauld
source
您可以保存一个字节，将1008to 更改为999，因为它无论如何都不包含0 999+9 = 1008。
— 凯文·克鲁伊森
甚至将其更改为2个字节f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?[n,,]:'')+f(n-9)（尽管确实包含尾随逗号，所以f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?n+' ':'')+f(n-9)使用空格分隔符（包括尾随空格可能看起来更漂亮））
— Kevin Cruijssen
@KevinCruijssen谢谢！我实际上正在尝试更新一段时间，但是今晚我有500B / s的Internet带宽。：/
— Arnauld
我知道这种感觉。.最近由于某种原因，我们家里的互联网很糟糕。.无法下载超过10 MB的内容，有时必须刷新几次具有10幅以上图像的视频或页面，然后才能完全加载。当我在星期一/星期二在家上班时..>。>明天有人来修复它（直到xD修复后我才离开他）
— Kevin Cruijssen
5

JavaScript（Node.js），89字节

[...Array(9e3)].map(_=>i++,i=1e3).filter(a=>(s=[...a+""]).sort()[0]<1&eval(s.join`+`)==9)

在线尝试！

  • @ETHproductions --4个字节

的JavaScript（Node.js的），129 127 126 124 115 114 111 110 105 97 93 92 90个字节

[...Array(9e3)].map(f=(_,i)=>eval(s=[...(i+=1e3)+""].sort().join`+`)-9|s[0]?0:i).filter(f)

在线尝试！

说明

[...Array(9e3)].map(f=(_,i)=>eval(s=[...(i+=1e3)+""].sort().join`+`)-9|s[0]?0:i).filter(f)
[...Array(9e3)].map(f=(_,i)=>                                                  )           // Create a 9000-length array and loop over it; store the loop body
                                    [...(i+=1e3)+""]                                       // Add 1000 to the index and split it into an array of characters (17 -> ["1", "0", "1", "7"])
                                                    .sort()                                // Sort the array of characters in ascending order by their code points ("0" will always be first) (["1", "0", "1", "7"] -> ["0", "1", "1", "7"])
                                  s=                       .join`+`                        // Join them together with "+" as the separator (["0", "1", "1", "7"] -> "0+0+2+9"); store the result
                             eval(                                 )-9                     // Evaluate and test if it's different than 9
                                                                       s[0]                // Take the first character of the string and implicitly test if it's different than "0"
                                                                      |    ?0              // If either of those tests succeeded, then the number doesn't meet challenge criteria - return a falsey value
                                                                             :i            // Otherwise, return the index
                                                                                .filter(f) // Filter out falsey values by reusing the loop body

第一次使用JavaScript打高尔夫球。我认为我不需要说这句话，但是如果我做错了什么，请在下面的评论中通知我。

  • -3个字节，感谢@Luis felipe De jesus Munoz

  • -6个字节，感谢@Kevin Cruijssen

— 一只狮子
source
1
[...Array(9e3)]而是Array(9e3).fill()节省2个字节
— Luis felipe De jesus Munoz
1
.map(a=>+a)而是.map(Number)保存另一个字节
— 路易斯·菲利佩·德·耶稣·穆诺兹
1
您可以删除处的空间(_, i)以保存一个字节，s[0]+s[1]+s[2]+s[3]也可以eval(s.join`+`)保存另外的4个字节。
— 凯文·克鲁伊森
1
另外，我很确定||可以|在您的答案中。
— 凯文·克鲁伊森
1
如果.map()仅用于生成范围，并使过滤分开进行，则可以节省8个字节：在线尝试！
— ETHproductions '18 -10-15
5

Python 2，57字节

n=999
exec"n+=9\nif'0'in`n`>int(`n`,11)%10>8:print n\n"*n

在线尝试！

2个字节感谢丹尼斯

使用exec循环以n9为步长递增计数为1008、1017，...，9981、9990，打印满足条件的循环。

只有9的倍数可以具有9的数字总和，但是在此范围内的9的倍数也可以具有18和27的数字总和。我们用条件排除了这些int(`n`,11)%10>8。解释n在基数11中，其数字和等于模数10，就像在基数10中，数字等于其数字和模9。（9，18，27）的数字和对应于（9，8，7）以10为模，因此采用这些方法>8可以滤除9。

包含零的数字是带有字符串成员身份的校验。'0'in`n`。此条件与不等式连锁的另一个条件结合在一起，因为Python 2将字符串视为大于数字的字符串。

— 异或
source
我喜欢打高尔夫球的Python似乎经常具有非常长的自动生成的可执行文件...
— J.Doe
4

sed和grep（和seq），72 64 63字节

seq 9e3|sed s/\\B/+/g|bc|grep -wn 9|sed s/:9//|grep 0|grep ....
— 雷神
source
其中一些不是四位数长的（但是我不确定决赛grep是什么，所以也许我说错了吗？）
— Sparhawk
@Sparhawk：最后一个grep确保该数字为4位数字
— Thor
@Thor Ah对。由于某种原因，我将其解析为省略号。
— Sparhawk
4

Haskell，55个字节

[i|i<-show<$>[1..5^6],201==sum(fromEnum<$>i),elem '0'i]

感谢@Laikoni，请参阅评论。

可读性：

import Data.Char (digitToInt)

[i | i <- show <$> [1000..9999]
   , sum (digitToInt <$> i) == 9
   , '0' `elem` i
   ]
— mb21
source
2
欢迎来到PPCG，尤其是Haskell高尔夫！您可以删除(-48+)总和，201而不是比较它们，从而节省一些字节9。顺便说一句，这也允许您使用1而不是1000该范围。
— Laikoni '18
根据Meta上的共识，您以前的版本也没有，main=print也很好。
— Laikoni '18
9999可以5^6代替。
— Laikoni '18
1
哈，总要刮一个字节！谢谢:-)
— mb21
3

R，82字节

write((x=t(expand.grid(1:9,0:9,0:9,0:9)))[,colSums(x)==9&!apply(x,2,all)],1,4,,"")

在线尝试！

生成x所有可能的4位数字（不包括前导零）在列中向下移动的矩阵。然后，过滤列（数字）总和为9且包含零（即all非零）的过滤器。write向下打印列，因此我们write以stdout的宽度4和的分隔符为""。

远超J.Doe

— 朱塞佩
source
好答案！我想出了一条不同的路线……
— J.Doe
3

Japt，20个 18字节。

-2个字节，感谢@Shaggy和@ETHproductions

A³òL² f_=ì)x ¥9«Z×

A³òL² f_=ì)x ¥9«Z×  Full program
A³òL²               Range [1000, 10000]
      f_            Filter by : 
        =ì)         Convert to array 
           x ¥9     Sum equal to 9?
               «    And 
                Z×  Product not 0

在线尝试！

— 路易斯·费利佩·德·耶稣·穆诺兹
source
这实际上是28个字节。相反，使用文字整数是22个字节，但A³ò9000 f_ìx ¥9©ZsøT会让您回到20 个字节
— 。– Shaggy
1
您可以使用ì代替s和来保存1个字节¬，这必须在过滤器中完成：f_=ì)x ¥9...。然后，您可以使用以下方法检查Z的乘积是否为零来保存另一个«Z×：在线尝试！
— ETHproductions '18 -10-15
3

爪哇8，128个 117 115字节

v->{int i=109,r[]=new int[i],n=i;for(;i>0;n++)if((n+"").chars().sum()==201&(n+"").contains("0"))r[--i]=n;return r;}

-11个字节，感谢@nwellnhof。

在线尝试。

说明：

v->{                              // Method with empty unused parameter & int-array return
  int i=109,                      //  Index-integer, starting at 109
      r[]=new int[i],             //  Result-array of size 109
      n=i;                        //  Number integer, starting at 109
   for(;i>0;                      //  Loop as long as `i` is not 0 yet:
       n++)                       //    After every iteration, increase `n` by 1
     if((n+"").chars().sum()==201 //   If the sum of the unicode values of `n` is 201,
                                  //   this means there are four digits, with digit-sum = 9
        &(n+"").contains("0"))    //   and `n` contains a 0:
       r[--i                      //    Decrease `i` by 1 first
            ]=n;                  //    And put `n` in the array at index `i`
  return r;}                      //  Return the array as result
— 凯文·克鲁伊森
source
1
那chars().sum()==201呢
— nwellnhof '18 -10-15
@nwellnhof啊，当然。谢谢！
— 凯文·克鲁伊森
3

R，85字节

（只是为了争夺R方括号的最佳滥用...：P）

`[`=`for`;i[a<-0:9,j[a,k[a,w[a,if(sum(s<-c(i,j,k,w))==9&any(!s)&i)write(s,1,s='')]]]]

在线尝试！

— 数字化
source
1
蝙蝠侠真是好戏，蝙蝠侠！
— BLT
3

05AB1E，15 13 12 10 字节

₄4°ŸεW°ö9Q

-2字节由于@Emigna
-3字节由于@Grimy

在线尝试。

说明：

₄4°Ÿ        # Create a list in the range [1000,10000]
    ʒ       # Filter this list by:
     W      #  Get the smallest digit in the number (without popping the number itself)
      °     #  Take 10 to the power this digit
       ö    #  Convert the number from this base to an integer (in base-10)
        9Q  #  Check if it's equal to 9
  • d=0110d°ö
  • d=11010d°ö
  • d=210010d°ö023452030405
  • d=3100010d°ö0034563004005006
  • d=[4,9]d=2d=3d−10

>0[1000,10000]°ö[1111,9000000009000000009000000009]999Qd=0°ö9

— 凯文·克鲁伊森
source
1
₄4°Ÿʒ0å}ʒSO9Q。分离过滤器通常较短
— Emigna
@Emigna啊，我正在寻找范围更短的方法，但完全忘记了4°。谢谢。而且，您确实很对，多个松散的过滤器（末尾）较短。还将其添加到我的提示答案之一。感谢两个字节！
— 凯文·克鲁伊森
1
而我的其他13位乘员（受ord sum == 201技巧的启发）是4°Lʒ0å}ʒÇOт·-。离开这里，也许有人可以进一步打高尔夫
— Xcoder先生18年
1
₄4°ŸʒD0åôO9Q。通常使用单个过滤器更短。
— 格林尼治标准
1
没关系，这里是10点：₄4°ŸʒW°ö9Q
— 肮脏的
2

点，18字节

{0Na&$+a=9}FIm,t*m

使用输出格式标志，例如-p以获取可读的输出。在线尝试！

{0Na&$+a=9}FIm,t*m
             m,t*m  Range from 1000 to 10*1000
{         }FI       Filter on this function:
 0Na                 There is at least one 0 in the argument
    &                and
     $+a             The sum of the argument
        =9           equals 9
— DLosc
source
2

Wolfram语言（Mathematica），56 55字节

Select[9!!~Range~9999,Tr@#==Times@@#+9&@*IntegerDigits]

在线尝试！

我们测试范围从9！= 945到9999，因为在945到999之间没有结果。也许还有一种更短的方法来写9000到10007之间的数字。

Tr@#==Times@@#+9&应用于{a,b,c,d}测试if a+b+c+d == a*b*c*d+9，最终等于Anno条件。

— 米莎·拉夫罗夫（Misha Lavrov）
source
回想起来，九！并不比999或短的东西，但它打败1000
— 米莎拉夫罗夫
什么是9！？在猜测中，它与阶乘无关。
— 罗伯特·弗雷泽
@RobertFraser双阶乘：9*7*5*3*1。
— 米莎·拉夫罗夫
2

红宝石，46 42 41字节

?9.upto(?9*4){|x|x.sum==201&&x[?0]&&p(x)}

在线尝试！

这个怎么运作：

  • 迭代范围从'9'到'9999'的字符串
  • 检查ASCII值的总和是否为201
  • 检查字符串是否包含零（没有正则表达式，则正则表达式将长1个字节）

（感谢Laikoni -2个字节）

— 国标
source
1
9*3可以是9，因为针对201进行检查已经需要4位数字。
— Laikoni '18
2

飞镖， 10310096 字节

f()=>List.generate(9001,(i)=>'$i').where((i)=>i.contains('0')&&i.runes.fold(0,(p,e)=>p+e)==201);

  • 通过将数组中的值设置为字符串，可以得到-3个字节，从而进行一次转换而不是两次转换
  • 通过使用符文而不是codeUnits达到-4字节

    • 很不言自明。生成一个以该单元格的索引作为值的9001（0-9000）个单元格列表，过滤包含0的单元格，然后过滤ASCII总和为201的单元格（如果所有ASCII字符总和为9，则结果）。这些条件隐含地包括年份为4位数字，因为使用2个ASCII数字（和0）不能达到201。

    在Dartpad上尝试！

    — 埃尔坎
    source
    欢迎来到PPCG。:)
    — Laikoni '18
    1
    谢谢 ！潜伏了一段时间，最终可以参加
    — Elcan，
    2

    PHP，69，87字节 74字节

    for($i=999;$i<9001;$i++){echo((array_sum(str_split($i))==9&strpos($i,"0")!=0)?$i:" ");} for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;

    请注意，这会为每个“失败”的数字放置一个空格，从而导致某种时髦的间距。可以将其更改为逗号分隔，但将添加另外4个字符：?$i.",":""

    变大了，因为我没有检查0。Titus缩短了13位！

    — 贫民窟
    source
    2
    我不是很了解PHP，但是这段代码能确保每年包含零吗？
    — Laikoni '18
    此代码不检查数字是否为零。
    — krzysiej
    1
    短13个字节：for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;
    — Titus
    这是另一个字节：?"$i,":""er ...现在反过来：?"":"$i,"
    — Titus
    实际上@Titus会增加几个字节。除非我们包含带w /的字符串，否则不需要$ i引号。
    — 阿伦（aslum）18-10-22
    2

    Scala（76 63 61 56字节）

    for(n<-0 to 9000;t=n+""if t.sum==201&t.min<49)println(t)

    在线尝试

    • 感谢Laikoni的建议
    • 应用Jo King的评论后，又减少了两个字节
    — r
    source
    1
    欢迎来到PPCG！您有什么想法需要添加到页眉或页脚部分，以使此代码在TIO上运行？在线尝试！
    — Laikoni '18
    @Laikoni，不知道我可以在TIO中运行Scala。固定它。感谢您的评论。
    — jrook
    1
    看起来像t.sum==201作品而不是作品t.map(_.asDigit).sum==9。
    — Laikoni '18 -10-18
    您可能会发现我们在Scala打高尔夫球的技巧很有趣。例如，看起来s"$n"可以n+""而且s"$t "可以t+" "。
    — Laikoni '18
    1
    由于您使用的总和201招，范围不需要在999开始
    — 乔金
    1

    Japt，16个字节

    返回一个数字数组。

    L²õì l4 k_ת9aZx

    测试一下

    说明

    L                    :100
 ²                   :Squared
  õ                  :Range [1,L²]
   ì                 :Convert each to a digit array
     l4              :Filter elements of length 4
        k_           :Remove each Z that returns truthy (not 0)
          ×          :  When reduced by multiplication
           ª         :  OR
              Zx     :  When reduced by addition
            9a       :   And subtracted from 9
    — 毛茸茸
    source
    1
    OP不幸地裁定，数字数组不是有效的输出：o（
    — Sok
    1

    APL（NARS），45个字符，90个字节

    f←{⍵×⍳(0∊x)∧9=+/x←⍎¨⍕⍵}⋄f¨1e3..5e3⋄f¨5e3..9e3

    再测试一些格式：

    1008  1017  1026  1035  1044  1053  1062  1071  1080  1107  1170  1206  1260  
  1305  1350  1404  1440  1503  1530  1602  1620  1701  1710  1800  2007  2016  
  2025  2034  2043  2052  2061  2070  2106  2160  2205  2250  2304  2340  
  2403  2430  2502  2520  2601  2610  2700  3006  3015  3024  3033  3042  3051  
  3060  3105  3150  3204  3240  3303  3330  3402  3420  3501  3510  3600  
  4005  4014  4023  4032  4041  4050  4104  4140  4203  4230  4302  4320  4401  
  4410  4500 
5004  5013  5022  5031  5040  5103  5130  5202  5220  5301  5310  5400  6003  
  6012  6021  6030  6102  6120  6201  6210  6300  7002  7011  7020  7101  7110  
  7200  8001  8010  8100  9000

    可能的选择

    r←f;i;x
   r←⍬⋄i←1e3⋄→B
A: r←r,i
B: i+←1⋄→A×⍳(0∊x)∧9=+/x←⍎¨⍕i⋄→B×⍳i≤9e3
    — 罗斯鲁普
    source
    1

    果冻，13 个字节

    ȷ4µṢÄm3Ḍ)ẹ9ṫ4

    在线尝试！

    怎么样？

    ȷ4µṢÄm3Ḍ)ẹ9ṫ4 - Link: no arguments
ȷ4            - literal 10^4 = 10000
  µ     )     - for each in range (1,2,3,...,10000): e.g. 3042       or  5211
   Ṣ          -   sort (given an integer makes digits)    [0,2,3,4]      [1,1,2,5]
    Ä         -   cumulative addition                     [0,2,5,9]      [1,2,4,9]
     m3       -   modulo 3 slice (1st,4th,7th...)         [0,9]          [1,9]
       Ḍ      -   convert from decimal digits             9              19
         ẹ9   - 1-based indices equal to nine             [9,99,999,1008,1017,...,8100,9000]
           ṫ4 - tail from the 4th index                   [1008,1017,...,8100,9000]
    — 乔纳森·艾伦
    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.