Na série de videogames Anno, existem 6 jogos com o 7º anunciado para o início de 2019. Seus títulos sempre apresentam um ano em um padrão específico:

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

• A soma digital é sempre 9.
• Os anos têm quatro dígitos.
• Eles contêm pelo menos um zero.

Dentro dessas restrições, existem 109 títulos possíveis:

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

Seu objetivo é listar todos eles de qualquer forma razoável no menor número de bytes.

R , 59 51 bytes

Emite os números válidos como os nomes de uma lista de 201's. Por que 201? Porque ASCII 0 é 48 e 4 * 48 + 9 é ... sim. Salva 6 bytes fazendo alias ^para Mape outros 2 usando 1:9e3como intervalo.

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

Experimente online!

Explicação

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

-2 bytes graças a Jo King

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

Experimente online!

Python 2 , 67 66 64 bytes

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

Experimente online!

Salvou:

• -1 byte, graças a Luis felipe De jesus Munoz
• -2 bytes, graças a Kevin Cruijssen

Gelatina , 11 bytes

9ȷṢ€æ.ẹ9ṫ19

Experimente online!

Como funciona

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 bytes

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

Experimente online!

Constrói um intervalo de 999a e 10000, em seguida, usa inline -matchcomo um filtro para extrair as entradas com as quais a expressão regular corresponde 0. Isso nos deixa em 1000, 1001, 1002, etc.seguida. Nós colocamos isso em uma Where-Objectcláusula em que pegamos o número atual como uma string "$_", o charcolocamos como uma matriz, -joinesses caracteres juntamente com +e Invoke- Expression (semelhante a eval) para gerar sua soma de dígitos. Verificamos se isso é -eqnecessário 9e, se for o caso, é passado no pipeline. Na conclusão do programa, esses números são capturados no pipeline e gerados implicitamente.

JavaScript (ES6), 78 73 bytes

Guardado 2 bytes graças a @KevinCruijssen

Retorna uma string separada por espaço.

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

Experimente online!

Quão?

Nós iteramos no intervalo $[1008..9000]$ com um incremento de $9$ , ignorando números que não possuem um $0$ .

Como todos esses números são múltiplos de $9$ , é garantido que a soma de seus dígitos também seja um múltiplo de $9$ .

Como os números válidos têm pelo menos um $0$ , eles não têm mais que dois $9$ 's, o que significa que a soma dos dígitos restantes é no máximo $18$ . Portanto, basta testar se a soma dos dígitos é ímpar.

Daí o teste:

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

JavaScript (Node.js) , 89 bytes

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

Experimente online!

• -4 bytes graças a @ETHproductions

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

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

Experimente online!

Explicação

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

Primeira vez fazendo código de golfe em JavaScript. Acho que não preciso dizer, mas se estiver fazendo algo errado, notifique-me nos comentários abaixo.

• -3 bytes graças a @Luis felipe De jesus Munoz

• -6 bytes graças a @Kevin Cruijssen

Python 2 , 57 bytes

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

Experimente online!

2 bytes graças a Dennis

Usa um exec loop para contar nem etapas de 9 como 1008, 1017, ..., 9981, 9990, imprimindo aqueles que atendem à condição.

Somente múltiplos de 9 podem ter a soma dos dígitos 9, mas múltiplos de 9 nesse intervalo também podem ter a soma dos dígitos de 18 e 27. Nós descartamos isso com a condição int(`n`,11)%10>8. Interpretaçãon na base 11, sua soma de dígitos é igual ao número módulo 10, assim como na base 10 um número é igual a sua soma de dígitos módulo 9. A soma dos dígitos de (9, 18, 27) corresponde a (9, 8, 7) módulo 10, de modo a realizar essas >8obras para filtrar nove.

O número que contém zero é verificado com a associação da string. '0'in`n`. Essa condição é associada à outra com uma desigualdade encadeada, usando que o Python 2 trata as strings como maiores que os números.

sed e grep (e 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]

Graças a @Laikoni, veja os comentários.

Legível:

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,,"")

Experimente online!

Gera uma matriz xde todos os possíveis números de 4 dígitos, excluindo zeros à esquerda, descendo colunas. Em seguida, os filtros para as somas da coluna (digital) de 9 e contendo zero, ou seja, não allsão diferentes de zero. writeimprime as colunas, então nóswrite a stdoutcom uma largura de 4e um separador de"" .

Superado por J.Doe

Japt , 20 18 bytes.

-2 bytes graças a @Shaggy e @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

Experimente 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 graças a @nwellnhof .

Experimente online.

Explicação:

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

(apenas competindo pelo melhor abuso de colchetes 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='')]]]]

Experimente online!

05AB1E , 15 13 12 10 bytes

₄4°ŸεW°ö9Q

-2 bytes graças a @Emigna
-3 bytes graças a @Grimy

Experimente online.

Explicação:

₄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=0$$1$$10^d$°ö ) atuaria como uma soma de dígitos.
• $d=1$$10$$10^d$°ö
• $d=2$$100$$10^d$°ö023452030405 ).
• $d=3$$1000$$10^d$°ö0034563004005006
• $d=[4,9]$$d=2$$d=3$$d-1$0

$>0$$[1000,10000]$°ö$[1111,9000000009000000009000000009]$$9$$9$9Q$d=0$°ö$9$

Pip , 18 bytes

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

Use um sinalizador no formato de saída, -ppara obter uma saída legível. Experimente 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]

Experimente online!

Testamos o intervalo de 9 !! = 945 a 9999, já que não há resultados entre 945 e 999. Talvez haja uma maneira mais curta de escrever um número entre 9000 e 10007 também.

Tr@#==Times@@#+9&aplicado a {a,b,c,d}testes if a+b+c+d == a*b*c*d+9, que acaba sendo equivalente ao The Anno Condition.

Ruby , 46 42 41 bytes

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

Experimente online!

Como funciona:

• Iterar em cadeias que variam de '9' a '9999'
• Verifique se a soma dos valores ASCII é 201
• Verifique se a string contém um zero (sem regex, um regex teria 1 byte a mais)

(Obrigado Laikoni por -2 bytes)

Oitava , 49 bytes

6 bytes salvos usando um formato de saída mais conveniente, conforme sugerido por J.Doe .

Obrigado a @Laikoni por uma correção .

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

Experimente online!

Dardo ,  103 100  96 bytes

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

Bastante auto-explicativo. gera uma lista de 9001 (0-9000) células com o índice da célula como valor, filtra as que contêm um 0 e a que possui uma soma ASCII de 201 (o resultado se todos os caracteres ASCII somarem 9). Essas condições incluem implicitamente que o ano tem 4 dígitos porque, usando 2 números ASCII (e 0), você não pode alcançar 201.

Experimente no Dartpad!

Bash (com seq, grep), 39 bytes

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

Experimente online!

K (ngn / k) , 22 bytes

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

Experimente online!

APL (Dyalog Unicode) , 23 bytes

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

Experimente 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;

Observe que isso coloca um espaço para cada número "com falha", levando a algum tipo de espaçamento descolado. Isso pode ser alterado para separação por vírgula, mas adicionará outros 4 caracteres:?$i.",":""

Aumentou porque eu não estava checando 0. Derp. Encurtado por 13 por Titus!

APL (Dyalog), 33 29 bytes

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

-4 bytes graças a @Adam

Experimente online!

Scala ( 76 63 61 56 bytes)

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

Experimente online

• Obrigado a Laikoni pelas sugestões
• Mais dois bytes perdidos após a aplicação do comentário de Jo King

Tcl , 77 bytes

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

Experimente online!

Japonês, 16 bytes

Retorna uma matriz de matrizes de dígitos.

L²õì l4 k_ת9aZx

Teste-o

Explicação

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 caracteres, 90 bytes

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

teste depois de alguma formatação:

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 

alternativa possível

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

Gelatina , 13 bytes

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

Experimente online!

Quão?

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