Listar todos os títulos possíveis para os jogos Anno

37

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.

code-golf  number  kolmogorov-complexity 
— Laikoni
fonte
Quão flexível é o formato de saída? É isso aceitável?
— Luis Mendo
11
@LuisMendo Sim, tudo bem para mim.
— Laikoni
São permitidas listas de dígitos ?
— Erik the Outgolfer
11
@ aslum Suponho que você queira dizer muitos espaços, não apenas um, certo? A marcação de comentários não permite uma boa representação disso. E eu diria que é permitido, dado que o formato de Luis acima é permitido. ;-)
— Erik the Outgolfer
11
@EriktheOutgolfer Eu diria não às listas de dígitos porque eles realmente não parecem mais anos.
— Laikoni 15/10/19

Respostas:

20

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]
— J.Doe
fonte
3
ah, grep, por que eu nunca me lembro que ele lança para character...
— Giuseppe
9

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.
— Dennis
fonte
7

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.

— AdmBorkBork
fonte
5

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 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 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)
— Arnauld
fonte
Você pode salvar um byte alterando 1008para 999, já que ele não contém um 0 e 999+9 = 1008.
— Kevin Cruijssen 15/10
Ou até mesmo 2 bytes por alterá-lo para f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?[n,,]:'')+f(n-9)(contém uma vírgula no final, porém, assim f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?n+' ':'')+f(n-9)com espaço delimitador incluindo espaço à direita pode parecer mais bonita)
— Kevin Cruijssen
@KevinCruijssen Thanks! Na verdade, estou tentando atualizar isso por um tempo, mas tenho 500B / s de largura de banda da Internet onde estou hoje à noite. : /
— Arnauld 15/10
Conheço o sentimento. Ultimamente, nossa internet em casa é uma porcaria, por algum motivo. Não é possível baixar nada acima de 10 MB e, às vezes, é necessário atualizar vídeos ou páginas com mais de 10 imagens algumas vezes antes de carregar completamente. Realmente irritante quando estou a trabalhar a partir de casa em segundas-feiras / terças-feiras ..>> Amanhã alguém vem para corrigi-lo (e eu não vou deixá-lo até que ele é fixo xD).
— Kevin Cruijssen
5

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

— Um leão
fonte
11
[...Array(9e3)]em vez disso, Array(9e3).fill()salva 2 bytes
— Luis felipe De jesus Munoz
11
.map(a=>+a)em vez disso, .map(Number)salva outro byte
— Luis felipe De jesus Munoz
11
Você pode remover o espaço em (_, i)para salvar um byte, e s[0]+s[1]+s[2]+s[3]pode ser eval(s.join`+`)para salvar um adicional de 4 bytes.
— Kevin Cruijssen 15/10
11
Além disso, tenho certeza de que isso ||pode estar |na sua resposta.
— Kevin Cruijssen 15/10
11
Se você usar .map()apenas para gerar o intervalo e manter a filtragem separada, poderá salvar 8 bytes: Experimente online!
— ETHproductions
5

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.

— xnor
fonte
I como Python como fortemente golfed parece muitas vezes ter enormemente longo executáveis gerada automaticamente ...
— J.Doe
4

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 ....
— Thor
fonte
Alguns deles não têm quatro dígitos (mas não tenho certeza qual é a final grep, então talvez eu esteja errado?)
— Sparhawk
@ Sparhawk: O último grep garante que o número tenha 4 dígitos
— Thor
@ Ah Ah certo. Por alguma razão, analisei isso como uma elipse.
— Sparhawk
4

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
   ]
— mb21
fonte
2
Bem-vindo ao PPCG e Haskell, em particular! Você pode salvar alguns bytes largando (-48+)e comparando a soma em 201vez de 9. Aliás, isso também permite que você use em 1vez do 1000intervalo.
— Laikoni
Além disso, a sua versão anterior main=printfoi boa de acordo com este consenso no Meta .
— Laikoni
9999pode ser em 5^6vez disso.
— Laikoni
11
Ha, sempre há outro byte para fazer a barba! Obrigado :-)
— mb21 16/10
3

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

— Giuseppe
fonte
Boa resposta! Eu vim com uma rota diferente ...
— J.Doe 15/10
3

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!

— Luis felipe De jesus Munoz
fonte
Na verdade, são 28 bytes . Usando um número inteiro literal vez é de 22 bytes, mas A³ò9000 f_ìx ¥9©ZsøTvocê recebe de volta para baixo para 20.
— Shaggy
11
Você pode salvar 1 byte usando ìem vez de se ¬, o que tem que ser feito no filtro: f_=ì)x ¥9.... Em seguida, você pode salvar outro, verificando se o produto de Z é zero com «Z×: Experimente online!
— ETHproductions
3

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
— Kevin Cruijssen
fonte
11
Que tal chars().sum()==201?
— Nwellnhof 15/10/19
@nwellnhof Ah, claro. Obrigado!
— Kevin Cruijssen 15/10
3

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!

— digEmAll
fonte
11
Santo para loops, Batman!
— BLT
3

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 01 110d°ö ) atuaria como uma soma de dígitos.
  • d=1 11010d°ö
  • d=210010d°ö023452030405 ).
  • d=3100010d°ö0034563004005006
  • d=[4,9]d=2d=3d-1 10

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

— Kevin Cruijssen
fonte
11
₄4°Ÿʒ0å}ʒSO9Q. Filtros de divisão são geralmente mais curto
— Emigna
@ Emigna Ah, eu estava procurando um caminho mais curto para o alcance, mas esqueci completamente 4°. Obrigado. E você está certo de que vários filtros soltos (no final) são mais curtos. Também o adicionarei a uma das minhas respostas de dicas. Obrigado por ambos os bytes!
— Kevin Cruijssen 15/10
11
E meu outro jogador de 13 bytes (inspirado no truque ord sum == 201) é 4°Lʒ0å}ʒÇOт·-. Deixando esta aqui, talvez golf Alguém pode-lo ainda mais
— Mr. Xcoder
11
₄4°ŸʒD0åôO9Q. Usar um único filtro geralmente é mais curto.
— Grimmy
11
Não importa, aqui está um 10:₄4°ŸʒW°ö9Q
— Grimmy
2

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
— DLosc
fonte
2

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.

— Misha Lavrov
fonte
Em retrospecto, 9 !! não é menor que 999 ou algo assim, mas supera 1000.
— Misha Lavrov
O que é 9 !! ? Ao adivinhar, isso não está relacionado aos fatoriais.
— Robert Fraser
@RobertFraser Duplo factorial: 9*7*5*3*1.
— Misha Lavrov
2

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)

— GB
fonte
11
9*3pode ser justo 9, porque verificar 201 já exige números de 4 dígitos.
— Laikoni 16/10/19
2

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!

— Luis Mendo
fonte
Eu não sei nada sobre Octave, mas parece que você pode deixar o dispoff ...
— J.Doe
@ A J.Doe OP confirmou que esse formato de saída é aceitável. Obrigado pela sugestão!
— Luis Mendo
2

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

  • -3 bytes, definindo o valor na matriz como string, fazendo a conversão uma vez e não duas
  • -4 bytes usando runas em vez de codeUnits

    • 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!

    — Elcan
    fonte
    Bem-vindo ao PPCG. :)
    — Laikoni
    11
    Obrigado ! Espreitando por um tempo, pode finalmente participar
    — Elcan 16/10
    2

    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!

    — aslum
    fonte
    2
    Eu realmente não sei PHP, mas esse código garante que a cada ano contenha um zero?
    — Laikoni
    Este código não verifica zero no número.
    — krzysiej
    11
    13 bytes mais curtos:for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;
    — Titus
    Aqui está outro byte: ?"$i,":""er ... agora o contrário:?"":"$i,"
    — Titus
    Na verdade, @Titus que adiciona alguns bytes. Não precisamos de cotações em torno de $ i, a menos que incluamos uma string com ele.
    — Aslum
    2

    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
    — jrook
    fonte
    11
    Bem-vindo ao PPCG! Você tem uma idéia do que precisa ser adicionado à seção de cabeçalho ou rodapé para que esse código seja executado no TIO? Experimente online!
    — Laikoni 18/10/19
    @Laikoni, não sabia que eu poderia executar o Scala no TIO. Corrigido. Obrigado pelo comentário.
    — jrook
    11
    Parece que t.sum==201funciona em vez de t.map(_.asDigit).sum==9.
    — Laikoni
    Você pode achar interessantes as nossas dicas para jogar golfe em Scala . Por exemplo, parece que s"$n"pode ser n+""e s"$t "pode ser t+" ".
    — Laikoni
    11
    Como você está usando o truque da soma é 201, o intervalo não precisa começar em 999
    — Jo King
    1

    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
    — Shaggy
    fonte
    11
    O OP decidiu que as matrizes de dígitos não são válidas para a saída infelizmente: o (
    — Sok
    1

    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
    — RosLuP
    fonte
    1

    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]
    — Jonathan Allan
    fonte
    Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
    Licensed under cc by-sa 3.0 with attribution required.