Lista todos los títulos posibles para los juegos de Anno

37

En la serie de videojuegos Anno hay 6 juegos con un séptimo anunciado para principios de 2019. Sus títulos siempre cuentan con un año en un patrón específico:

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

  • La suma digital es siempre 9.
  • Los años son cuatro dígitos de largo.
  • Contienen al menos un cero.

Dentro de estas restricciones existen 109 títulos posibles:

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

Su objetivo es enumerarlos a todos en cualquier forma razonable en la menor cantidad de bytes.

Laikoni
fuente
¿Qué tan flexible es el formato de salida? ¿Es esto aceptable?
Luis Mendo
1
@LuisMendo Sí, eso está bien para mí.
Laikoni
¿Se permiten listas de dígitos ?
Erik the Outgolfer
1
@aslum Supongo que te refieres a muchos espacios, no solo uno, ¿verdad? La reducción de comentarios no permite una buena representación de eso. Y supongo que está permitido, dado que el formato de Luis anterior está permitido. ;-)
Erik the Outgolfer
1
@EriktheOutgolfer Yo diría que no a las listas de dígitos porque realmente ya no parecen años.
Laikoni

Respuestas:

20

R , 59 51 bytes

Emite los números válidos como los nombres de una lista de 201. ¿Por qué 201? Porque ASCII 0 es 48, y 4 * 48 + 9 es ... sí. Guardado 6 bytes por aliasing ^a Mapy otro 2 utilizando 1:9e3como gama.

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

Pruébalo en línea!

Explicación

# 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
fuente
3
ah, grep¿por qué nunca recuerdo que se lanza a character...
Giuseppe
9

Python 2 , 67 66 64 bytes

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

Pruébalo en línea!


Salvado:

  • -1 byte, gracias a Luis felipe De jesus Munoz
  • -2 bytes, gracias a Kevin Cruijssen
TFeld
fuente
64 bytes usando el ord sum == 201truco de otras respuestas.
Kevin Cruijssen
9

Jalea , 11 bytes

9ȷṢ€æ.ẹ9ṫ19

Pruébalo en línea!

Cómo 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
fuente
7

PowerShell , 50 49 bytes

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

Pruébalo en línea!

Construye un rango de 999a 10000, luego usa en línea -matchcomo filtro para extraer aquellas entradas con las que coinciden las expresiones regulares 0. Esto nos deja con 1000, 1001, 1002, etc.Luego lo canalizamos en una Where-Objectcláusula donde tomamos el número actual como una cadena "$_", lo convertimos en unchar matriz, -joinesos caracteres junto con +y Invoke- Expresión (similar a eval) para obtener su suma de dígitos. Verificamos si eso es -equal 9, y si es así, se pasa a la tubería. Al finalizar el programa, esos números se recogen de la tubería y se envían implícitamente.

AdmBorkBork
fuente
5

JavaScript (ES6), 78 73 bytes

Guardado 2 bytes gracias a @KevinCruijssen

Devuelve una cadena separada por espacios.

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

Pruébalo en línea!

¿Cómo?

Repetimos el rango [1008..9000] con un incremento de 9 , ignorando los números que no tienen un 0 .

Todos estos números son múltiplos de 9 , por lo que la suma de sus dígitos es un múltiplo de 9 .

Como los números válidos tienen al menos un 0 , no tienen más de dos 9 , lo que significa que la suma de los dígitos restantes es como máximo 18 . Por lo tanto, es suficiente para probar si la suma de los dígitos es impar.

De ahí la prueba:

(eval([...n + ''].join`+`) & /0/.test(n)
Arnauld
fuente
Puede guardar un byte cambiando el 1008a 999, ya que de todos modos no contiene un 0, y 999+9 = 1008.
Kevin Cruijssen
O incluso 2 bytes cambiándolo a f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?[n,,]:'')+f(n-9)(sin embargo, contiene una coma final, por lo f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?n+' ':'')+f(n-9)que el delimitador de espacio, incluido el espacio final, puede parecer más bonito)
Kevin Cruijssen
@KevinCruijssen ¡Gracias! Realmente estoy tratando de actualizar esto por un tiempo, pero tengo como 500B / s de ancho de banda de Internet donde estoy esta noche. : /
Arnauld
Conozco la sensación ... Últimamente, nuestro Internet en casa es una mierda por alguna razón ... No puedo descargar nada por encima de 10 MB, y a veces tengo que actualizar videos o páginas con más de 10 imágenes varias veces antes de que se cargue por completo ... Realmente molesto cuando trabajo desde casa los lunes / martes ..>.> Mañana alguien viene a arreglarlo (y no lo
dejaré
5

JavaScript (Node.js) , 89 bytes

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

Pruébalo en línea!

  • -4 bytes gracias 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)

Pruébalo en línea!

Explicación

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

Primera vez haciendo código golf en JavaScript. No creo que deba decirlo, pero si estoy haciendo algo mal, notifíqueme en los comentarios a continuación.

  • -3 bytes gracias a @Luis felipe De jesus Munoz

  • -6 bytes gracias a @Kevin Cruijssen

Un leon
fuente
1
[...Array(9e3)]en cambio Array(9e3).fill()ahorra 2 bytes
Luis felipe De jesus Munoz
1
.map(a=>+a)en cambio .map(Number)guarda otro byte
Luis felipe De jesus Munoz
1
Puede eliminar el espacio en (_, i)para guardar un byte, y s[0]+s[1]+s[2]+s[3]puede ser eval(s.join`+`)para guardar 4 bytes adicionales.
Kevin Cruijssen
1
Además, estoy bastante seguro de que ||puede estar |en su respuesta.
Kevin Cruijssen
1
Si .map()solo usa para generar el rango y mantiene el filtrado por separado, puede guardar 8 bytes: ¡ Pruébelo en línea!
ETHproductions
5

Python 2 , 57 bytes

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

Pruébalo en línea!

2 bytes gracias a Dennis

Utiliza un execbucle para contarn en pasos de 9 como 1008, 1017, ..., 9981, 9990, imprimiendo los que cumplen la condición.

Solo los múltiplos de 9 pueden tener una suma de dígitos 9, pero los múltiplos de 9 en este rango también pueden tener una suma de dígitos de 18 y 27. Los descartamos con la condición int(`n`,11)%10>8. Interpretando nen la base 11, su suma de dígitos es igual al número módulo 10, al igual que en la base 10 un número es igual a su suma de dígitos módulo 9. La suma de dígitos de (9, 18, 27) corresponde a (9, 8, 7) módulo 10, por lo que tomar esos >8trabajos para filtrar nueves.

El número que contiene un cero es cheque con membresía de cadena. '0'in`n`. Esta condición se une con la otra con una desigualdad encadenada, usando que Python 2 trata las cadenas como mayores que los números.

xnor
fuente
Me gusta lo mucho que parece que Python tenga muchos ejecutables autogenerados enormemente largos ...
J.Doe
4

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

seq 9e3|sed s/\\B/+/g|bc|grep -wn 9|sed s/:9//|grep 0|grep ....
Thor
fuente
Algunos de estos no tienen cuatro dígitos (pero no estoy seguro de cuál es la final grep, ¿así que tal vez lo estoy ejecutando mal?)
Sparhawk
@Sparhawk: el último grep asegura que el número tenga 4 dígitos de largo
Thor
@Thor Ah cierto. Por alguna razón, lo analicé como una elipsis.
Sparhawk
4

Haskell , 55 bytes

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

Gracias a @Laikoni, mira los comentarios.

Legible:

import Data.Char (digitToInt)

[i | i <- show <$> [1000..9999]
   , sum (digitToInt <$> i) == 9
   , '0' `elem` i
   ]
mb21
fuente
2
¡Bienvenido a PPCG y Haskell golf en particular! Puede guardar algunos bytes colocando (-48+)y comparando la suma en 201lugar de 9. Por cierto, esto también le permite usar en 1lugar de 1000para el rango.
Laikoni
Además, su versión anterior sin main=printestaba bien según este consenso sobre Meta .
Laikoni
9999puede ser 5^6en su lugar.
Laikoni
1
¡Ja, siempre hay otro byte para afeitarse! Gracias :-)
mb21
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,,"")

Pruébalo en línea!

Genera una matriz xde todos los números posibles de 4 dígitos, excluyendo los ceros a la izquierda, bajando las columnas. Luego, los filtros para sumas de columnas (digitales) de 9 y que contienen cero, es decir, no allson distintos de cero. writeimpresiones de las columnas, por lo que writea stdoutcon una anchura de 4y un separador de "".

Superado por J.Doe

Giuseppe
fuente
¡Buena respuesta! Se me ocurrió una ruta diferente ...
J.Doe
3

Japt , 20 18 bytes.

-2 bytes gracias a @Shaggy y @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

Pruébalo en línea!

Luis felipe De jesus Munoz
fuente
Esto es en realidad 28 bytes . El uso de un entero literal en su lugar es de 22 bytes, pero A³ò9000 f_ìx ¥9©ZsøTlo vuelve a bajar a 20.
Shaggy
1
Puede guardar 1 byte utilizando ìen lugar de sy ¬, que se tiene que hacer en el filtro: f_=ì)x ¥9.... Luego puede guardar otro comprobando si el producto de Z es cero con «Z×: ¡ Pruébelo en línea!
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 gracias a @nwellnhof .

Pruébalo en línea.

Explicación:

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
fuente
1
¿Qué hay de chars().sum()==201?
nwellnhof
@nwellnhof Ah, por supuesto. ¡Gracias!
Kevin Cruijssen
3

R , 85 bytes

(solo compitiendo por el mejor abuso de los corchetes 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='')]]]]

Pruébalo en línea!

digEmAll
fuente
1
¡Santo cielo, Batman!
BLT
3

05AB1E , 15 13 12 10 bytes

₄4°ŸεW°ö9Q

-2 bytes gracias a @Emigna
-3 bytes gracias a @Grimy

Pruébalo en línea.

Explicación:

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
  • Si el dígito más pequeño es re=0 0 Se convertirá 1 con el 10re( °) Y el número en base-1 convertido a un entero en base-10 (ö ) actuaría como una suma de dígitos.
  • Si el dígito más pequeño es re=1 Se convertirá 10 con el 10re( °) Y ö, por supuesto, el número en base 10 convertido a un entero en base 10 ( ) seguirá siendo el mismo.
  • Si el dígito más pequeño es re=2 Se convertirá 100 con el 10re( °) Y el número en base-100 convertido a un entero en base-10 ( ö) actuaría como una unión 0en este caso (es decir, se 2345convierte en 2030405).
  • Si el dígito más pequeño es re=3 Se convertirá 1000 con el 10re( °) Y el número en base-100 convertido a un entero en base-10 ( ö) actuaría como una unión 00en este caso (es decir, se 3456convierte en 3004005006).
  • ... etc. Los dígitos más pequeños re=[4 4,9 9] actuaría igual que re=2 y re=3 arriba, con re-1cantidad de 0s en la 'unión'.

Si el dígito más pequeño es >0 0 con el rango dado [1000,10000], el número resultante después °öestaría dentro del rango[1111,9000000009000000009000000009], por lo que nunca puede ser igual a 9 9. Si el resultado es igual a9 9( 9Q) significaría que el dígito más pequeño esre=0 0, resultando en una base-1 con °ö; y la suma de los dígitos era9 9.

Kevin Cruijssen
fuente
1
₄4°Ÿʒ0å}ʒSO9Q. Los filtros de división suelen ser más cortos
Emigna
@Emigna Ah, estaba buscando un camino más corto para el rango, pero me olvidé por completo . Gracias. Y de hecho tiene razón en que múltiples filtros sueltos (al final) son más cortos. También lo agregaré a una de mis respuestas de consejos. Gracias por los dos bytes!
Kevin Cruijssen
1
Y mi otro 13 byter (inspirado en el ord sum == 201 truco) es 4°Lʒ0å}ʒÇOт·-. Dejando esto aquí, tal vez alguien pueda seguir
jugando
1
₄4°ŸʒD0åôO9Q. El uso de un solo filtro suele ser más corto.
Grimmy
1
No importa, aquí hay un 10:₄4°ŸʒW°ö9Q
Grimmy
2

Pip , 18 bytes

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

Use un indicador de formato de -psalida como para obtener una salida legible. Pruébalo en línea!

{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
fuente
2

Wolfram Language (Mathematica) , 56 55 bytes

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

Pruébalo en línea!

Probamos el rango de 9 !! = 945 a 9999, ya que no hay resultados entre 945 y 999. Quizás también haya una forma más corta de escribir un número entre 9000 y 10007.

Tr@#==Times@@#+9&aplicado a las {a,b,c,d}pruebas if a+b+c+d == a*b*c*d+9, que termina siendo equivalente a The Anno Condition.

Misha Lavrov
fuente
En retrospectiva, 9 !! no es más corto que 999 o algo así, pero supera los 1000.
Misha Lavrov
¿Qué es el 9! ? Al adivinar no está relacionado con los factoriales.
Robert Fraser
@RobertFraser factorial doble: 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)}

Pruébalo en línea!

Cómo funciona:

  • Iterar en cadenas que van del '9' al '9999'
  • Compruebe que la suma de los valores ASCII es 201
  • Compruebe si la cadena contiene un cero (sin expresión regular, una expresión regular sería 1 byte más)

(Gracias Laikoni por -2 bytes)

GB
fuente
1
9*3puede ser justo 9, porque verificar contra 201 ya requiere números de 4 dígitos.
Laikoni
2

Octava , 49 bytes

6 bytes guardados usando un formato de salida más conveniente como lo sugiere J.Doe .

Gracias a @Laikoni por una corrección .

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

Pruébalo en línea!

Luis Mendo
fuente
No sé nada sobre Octave, pero parece que puedes dejarlo dispfuera ...
J.Doe
@ J.Doe OP ha confirmado que ese formato de salida es aceptable. ¡Gracias por la sugerencia!
Luis Mendo
2

Dart ,  103100  96 bytes

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

  • -3 bytes estableciendo el valor en la matriz en cadena, haciendo la conversión una vez y no dos
  • -4 bytes usando runas en lugar de codeUnits
  • Bastante autoexplicativo. genera una lista de celdas 9001 (0-9000) con el índice de la celda como valor, filtra las que contienen un 0 y luego la que tiene una suma ASCII de 201 (El resultado si todos los caracteres ASCII suman 9). Estas condiciones incluyen implícitamente que el año tiene 4 dígitos porque al usar 2 números ASCII (y el 0), no puede llegar a 201.

    Pruébalo en Dartpad!

    Elcan
    fuente
    Bienvenido a PPCG. :)
    Laikoni
    1
    Gracias !
    He
    2

    Bash (con seq, grep), 39 bytes

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

    Pruébalo en línea!

    tsh
    fuente
    @xobzoo sugirió seq 0 9 1e4|awk '/([0-4].*){3}/&&/0/'guardar dos bytes.
    Timtech
    2

    K (ngn / k) , 22 bytes

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

    Pruébalo en línea!

    ngn
    fuente
    ¡Agradable! 55_&9=+/y*|/'~y:!4#10por 21?
    streetter
    1
    @streetster gracias :) la 'en |/'apariencia equivocada. el resultado incluye 1116, 1125, 1134, etc, que no se supone que debe estar allí
    NGN
    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;

    Tenga en cuenta que esto pone un espacio para cada número "fallido", lo que lleva a algún tipo de espaciado funky. Esto se puede cambiar a separación por coma, pero agregará otros 4 caracteres:?$i.",":""

    Se hizo más grande porque no estaba buscando 0. Derp. ¡Acortado por 13 por Tito!

    un barrio pobre
    fuente
    2
    Realmente no conozco PHP, pero ¿este código garantiza que cada año contenga un cero?
    Laikoni
    Este código no verifica cero en el número.
    krzysiej
    1
    13 bytes más corto:for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;
    Titus
    Aquí hay otro byte: ?"$i,":""er ... ahora al revés:?"":"$i,"
    Titus
    En realidad @Titus que agrega un par de bytes. No necesitamos cotizaciones alrededor de $ i a menos que estemos incluyendo una cadena w / it.
    aslum
    2

    Scala ( 76 63 61 56 bytes)

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

    Pruébalo en línea

    • Gracias a Laikoni por las sugerencias.
    • Dos bytes más arrojados después de aplicar el comentario de Jo King
    jrook
    fuente
    1
    Bienvenido a PPCG! ¿Tiene una idea de lo que debe agregarse a la sección de encabezado o pie de página para que este código se ejecute en TIO? Pruébalo en línea!
    Laikoni
    @Laikoni, no sabía que podía ejecutar Scala en TIO. Arreglado. Gracias por el comentario.
    jrook
    1
    Parece que t.sum==201funciona en lugar de t.map(_.asDigit).sum==9.
    Laikoni
    Puede encontrar interesantes nuestros consejos para practicar golf en Scala . Por ejemplo, parece que s"$n"puede ser n+""y s"$t "puede ser t+" ".
    Laikoni
    1
    Como estás usando la suma del truco 201, el rango no necesita comenzar en 999
    Jo King
    1

    Japt, 16 bytes

    Devuelve una matriz de matrices de dígitos.

    L²õì l4 k_ת9aZx
    

    Pruébalo


    Explicación

    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
    
    Lanudo
    fuente
    1
    OP ha dictaminado que desafortunadamente las matrices de dígitos no son salidas válidas: o (
    Sok
    1

    APL (NARS), 45 caracteres, 90 bytes

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

    prueba después de algún formato:

    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 
    

    posible alternativa

    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
    fuente
    1

    Jalea , 13 bytes

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

    Pruébalo en línea!

    ¿Cómo?

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