Dalam seri video game Anno ada 6 game dengan yang 7 diumumkan untuk awal 2019. Judul mereka selalu menampilkan setahun dalam pola tertentu:

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

• Jumlah digital selalu 9.
• Panjangnya empat digit.
• Mereka mengandung setidaknya satu nol.

Dalam batasan-batasan ini terdapat 109 judul yang mungkin:

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

Tujuan Anda adalah membuat daftar semuanya dalam bentuk wajar apa pun dalam jumlah byte paling sedikit.

R , 59 51 byte

Menghasilkan angka yang valid sebagai nama daftar tahun 201-an. Mengapa 201? Karena ASCII 0 adalah 48, dan 4 * 48 + 9 adalah ... ya. Disimpan 6 byte dengan aliasing ^ke Mapdan 2 lainnya dengan menggunakan 1:9e3rentang.

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

Cobalah online!

Penjelasan

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

Perl 6 , 35 33 byte

-2 byte terima kasih kepada Jo King

{grep {.ords.sum==201&&/0/},^1e4}

Cobalah online!

Python 2 , 67 66 64 byte

print[y for y in range(9001)if('0'in`y`)*sum(map(ord,`y`))==201]

Cobalah online!

Disimpan:

• -1 byte, terima kasih kepada Luis felipe De jesus Munoz
• -2 byte, terima kasih kepada Kevin Cruijssen

Jelly , 11 byte

9ȷṢ€æ.ẹ9ṫ19

Cobalah online!

Bagaimana itu bekerja

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.

PowerShell , 50 49 byte

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

Cobalah online!

Buat rentang dari 999hingga 10000, lalu gunakan sebaris -matchsebagai filter untuk menarik entri yang cocok dengan regex 0. Ini membuat kita dengan 1000, 1001, 1002, etc.Kami kemudian pipa itu ke Where-Objectklausa di mana kita mengambil nomor saat ini sebagai string "$_", melemparkannya sebagai char-array, -joinkarakter-karakter bersama-sama dengan +dan Invoke- Expression (mirip dengan eval) untuk datang dengan jumlah digit mereka. Kami memeriksa apakah yang -eqUAL untuk 9, dan jika demikian itu diteruskan pipa. Pada penyelesaian program, angka-angka itu diambil dari pipa dan secara implisit menghasilkan.

JavaScript (ES6), 78 73 byte

Disimpan 2 byte berkat @KevinCruijssen

Mengembalikan string yang dipisahkan ruang.

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

Cobalah online!

Bagaimana?

Kami beralih pada kisaran $[1008..9000]$ dengan selisih $9$ , mengabaikan angka yang tidak memiliki $0$ .

Semua angka ini adalah kelipatan dari $9$ , sehingga jumlah digit mereka dijamin kelipatan dari $9$ juga.

Karena angka yang valid memiliki setidaknya satu $0$ , mereka tidak memiliki lebih dari dua angka $9$ , yang berarti bahwa jumlah digit yang tersisa paling banyak $18$ . Oleh karena itu, cukup untuk menguji apakah jumlah digitnya ganjil.

Karenanya tes:

(eval([...n + ''].join`+`) & /0/.test(n)

JavaScript (Node.js) , 89 byte

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

Cobalah online!

• -4 byte terima kasih kepada @ETHproductions

JavaScript (Node.js), 129 127 126 124 115 114 111 110 105 97 93 92 90 byte

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

Cobalah online!

Penjelasan

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

Pertama kali melakukan golf kode dalam JavaScript. Saya pikir saya tidak perlu mengatakannya, tetapi jika saya melakukan sesuatu yang salah, tolong beri tahu saya di komentar di bawah.

• -3 byte berkat @Luis felipe De jesus Munoz

• -6 byte terima kasih kepada @Kevin Cruijssen

Python 2 , 57 byte

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

Cobalah online!

2 byte berkat Dennis

Menggunakan execloop untuk menghitungn dalam langkah 9 sebagai 1008, 1017, ..., 9981, 9990, mencetak yang memenuhi syarat.

Hanya kelipatan 9 yang dapat memiliki jumlah digit 9, tetapi kelipatan 9 dalam kisaran ini juga dapat memiliki jumlah digit 18 dan 27. Kami mengesampingkannya dengan ketentuan ini int(`n`,11)%10>8. Menafsirkan ndalam basis 11, jumlah digitnya sama dengan angka modulo 10, sama seperti pada basis 10 angka sama dengan jumlah modulo digitnya 9. Jumlah digit dari (9, 18, 27) sesuai dengan (9, 8, 7) modulo 10, jadi ambil itu>8 karya karya itu untuk menyaring sembilan.

Angka yang mengandung nol diperiksa dengan keanggotaan string. '0'in`n`. Kondisi ini bergabung dengan yang lain dengan ketimpangan dirantai, menggunakan bahwa Python 2 memperlakukan string lebih besar daripada angka.

sed and grep (and seq), 72 64 63 bytes

seq 9e3|sed s/\\B/+/g|bc|grep -wn 9|sed s/:9//|grep 0|grep ....

Haskell, 55 bytes

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

Thanks to @Laikoni, see the comments.

Readable:

import Data.Char (digitToInt)

[i | i <- show <$> [1000..9999]
   , sum (digitToInt <$> i) == 9
   , '0' `elem` i
   ]

R, 82 bytes

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

Try it online!

Generates a matrix x of all possible 4-digit numbers, excluding leading zeros, going down columns. Then filters for column (digital) sums of 9 and containing zero, i.e., not all are nonzero. write prints down the columns, so we write to stdout with a width of 4 and a separator of "".

Outgolfed by J.Doe

Japt, 20 18 bytes.

-2 bytes thanks to @Shaggy and @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

Try it online!

Java 8, 128 117 115 bytes

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 bytes thanks to @nwellnhof.

Try it online.

Explanation:

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

R, 85 bytes

(just competing for the best abuse of R square brackets ... :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='')]]]]

Try it online!

05AB1E, 15 13 12 10 bytes

₄4°ŸεW°ö9Q

-2 bytes thanks to @Emigna
-3 bytes thanks to @Grimy

Try it online.

Explanation:

₄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

• If the smallest digit is $d=0$ it will become $1$ with the $10^d$ (°). And the number in base-1 converted to an integer in base-10 (ö) would act like a sum of digits.
• If the smallest digit is $d=1$ it will become $10$ with the $10^d$ (°). And the number in base-10 converted to an integer in base-10 (ö) will of course remain the same.
• If the smallest digit is $d=2$ it will become $100$ with the $10^d$ (°). And the number in base-100 convert to an integer in base-10 (ö) would act like a join with 0 in this case (i.e. 2345 becomes 2030405).
• If the smallest digit is $d=3$ it will become $1000$ with the $10^d$ (°). And the number in base-100 convert to an integer in base-10 (ö) would act like a join with 00 in this case (i.e. 3456 becomes 3004005006).
• ... etc. Smallest digits $d=[4,9]$ would act the same as $d=2$ and $d=3$ above, with $d-1$ amount of 0s in the 'join'.

If the smallest digit is $>0$ with the given range $[1000,10000]$, the resulting number after °ö would then be within the range $[1111,9000000009000000009000000009]$, so can never be equal to $9$. If the result is equal to $9$ (9Q) it would mean the smallest digit is $d=0$, resulting in a base-1 with °ö; and the sum of the digits was $9$.

Pip, 18 bytes

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

Use an ouput-format flag such as -p to get readable output. Try it online!

{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

Wolfram Language (Mathematica), 56 55 bytes

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

Try it online!

We test the range from 9!! = 945 to 9999, since there are no results between 945 and 999. Maybe there's a shorter way to write a number between 9000 and 10007, as well.

Tr@#==Times@@#+9& applied to {a,b,c,d} tests if a+b+c+d == a*b*c*d+9, which ends up being equivalent to The Anno Condition.

Ruby, 46 42 41 bytes

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

Try it online!

How it works:

• Iterate on strings ranging from '9' to '9999'
• Check that sum of ASCII values is 201
• Check if string contains a zero (without regex, a regex would be 1 byte longer)

(Thanks Laikoni for -2 bytes)

Octave, 49 bytes

6 bytes saved using a more convenient output format as suggested by J.Doe.

Thanks to @Laikoni for a correction.

y=dec2base(x=1e3:9999,10)'-48;x(sum(y)==9>all(y))

Try it online!

Dart,  103 100  96 bytes

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

Pretty self-explanatory. generates a list of 9001 (0-9000) cells with the cell's index as value, filters the ones containing a 0 then the one having an ASCII sum of 201 (The result if all the ASCII characters sum to 9). These conditions implictly include that the year is 4 digits long because using 2 ASCII numbers (and the 0), you cannot reach 201.

Try it on Dartpad!

Bash (with seq, grep), 39 bytes

seq 0 9 1e4|egrep '([0-4].*){3}'|grep 0

Try it online!

K (ngn/k), 22 bytes

55_&(|/~a)&9=+/a:!4#10

Try it online!

APL (Dyalog Unicode), 23 bytes

55↓⍸(×⌿<9=+⌿)10⊥⍣¯1⍳9e3

Try it online!

PHP, 69, 87 bytes 74 bytes

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;

Note this puts a space for every "failed" number, leading to some kind of funky spacing. This can be changed to comma separation, but will add another 4 characters: ?$i.",":""

Got bigger because I wasn't checking for 0. Derp. Shortened by 13 by Titus!

APL(Dyalog), 33 29 bytes

1e3+⍸(0∘∊∧9=+/)¨⍎¨∘⍕¨1e3+⍳9e3

-4 bytes thanks to @Adam

Try it online!

Scala (76 63 61 56 bytes)

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

Try it online

• Thanks to Laikoni for the suggestions
• Two more bytes shed after applying Jo King's comment

Tcl, 77 bytes

time {if [incr i]>1e3&[regexp 0 $i]&9==[join [split $i ""] +] {puts $i}} 9999

Try it online!

Japt, 16 bytes

Returns an array of digit arrays.

L²õì l4 k_ת9aZx

Test it

Explanation

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

APL(NARS), 45 chars, 90 bytes

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

test afther some formatting:

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 

possible alternative

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

Jelly, 13 bytes

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

Try it online!

How?

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