Wymień wszystkie możliwe tytuły gier Anno

37

W serii gier wideo Anno jest 6 gier, z których 7 ogłoszono na początku 2019 r. Ich tytuły zawsze mają rok według określonego wzoru:

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

  • Suma cyfrowa wynosi zawsze 9.
  • Lata składają się z czterech cyfr.
  • Zawierają co najmniej jedno zero.

W ramach tych ograniczeń istnieje 109 możliwych tytułów:

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

Twoim celem jest wyświetlenie ich wszystkich w dowolnej rozsądnej formie w jak najmniejszej liczbie bajtów.

code-golf  number  kolmogorov-complexity 
— Laikoni
źródło
Jak elastyczny jest format wyjściowy? Czy to jest dopuszczalne?
— Luis Mendo
1
@LuisMendo Tak, nie mam nic przeciwko.
— Laikoni
Czy dozwolone są listy cyfr ?
— Erik the Outgolfer
1
@aslum Zakładam, że masz na myśli wiele spacji, a nie tylko jedną, prawda? Oznaczanie komentarzy nie pozwala na dobrą reprezentację tego. Zakładam, że jest to dozwolone, biorąc pod uwagę, że powyższy format Luisa jest dozwolony. ;-)
— Erik the Outgolfer
1
@EriktheOutgolfer Powiedziałbym „nie” listom cyfr, ponieważ tak naprawdę nie wyglądają już jak lata.
— Laikoni

Odpowiedzi:

20

R , 59 51 bajtów

Zwraca prawidłowe liczby jako nazwy listy 201. Dlaczego 201? Ponieważ ASCII 0 to 48, a 4 * 48 + 9 to ... tak. Zapisane 6 bajtów przez aliasing ^z Mapi kolejne 2 stosując 1:9e3jako zakres.

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

Wypróbuj online!

Wyjaśnienie

# 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
źródło
3
Ach, grepdlaczego nigdy nie pamiętam, że rzuca na character...
— Giuseppe
9

Galaretka , 11 bajtów

9ȷṢ€æ.ẹ9ṫ19

Wypróbuj online!

Jak to działa

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
źródło
7

PowerShell , 50 49 bajtów

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

Wypróbuj online!

Konstruuje zakres od 999do 10000, a następnie używa wbudowanego -matchjako filtru, aby wyciągnąć te wpisy, z którymi występuje wyrażenie regularne 0. Pozostaje nam 1000, 1001, 1002, etc.to. Następnie wstawiamy to do Where-Objectklauzuli, w której bierzemy bieżącą liczbę jako ciąg "$_", charrzutujemy ją jako tablicę, -jointe znaki razem +i Invoke- pression Ex(podobny do eval), aby uzyskać ich cyfrową sumę. Sprawdzamy, czy jest to -eqcelowe 9, a jeśli tak, to jest przekazywane do rurociągu. Po zakończeniu programu liczby te są pobierane z potoku i domyślnie wyprowadzane.

— AdmBorkBork
źródło
5

JavaScript (ES6), 78 73 bajtów

Zaoszczędzono 2 bajty dzięki @KevinCruijssen

Zwraca ciąg rozdzielony spacjami.

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

Wypróbuj online!

W jaki sposób?

w zakresie z przyrostem , ignorując liczby, które nie mają .[1008..9000]90

Wszystkie te liczby są wielokrotnościami , więc suma ich cyfr jest gwarantowana jako wielokrotność .99

Dlatego ważne numery mają przynajmniej jedną , mają nie więcej niż dwa „s, co oznacza, że suma pozostałych cyfr wynosi co najwyżej . Dlatego wystarczy sprawdzić, czy suma cyfr jest nieparzysta.0918

Stąd test:

(eval([...n + ''].join`+`) & /0/.test(n)
— Arnauld
źródło
Można zapisać bajt zmieniając 1008się 999, ponieważ nie zawierają 0 i tak, i 999+9 = 1008.
— Kevin Cruijssen
Lub nawet 2 bajty, zmieniając go na f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?[n,,]:'')+f(n-9)(zawiera przecinek końcowy, więc f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?n+' ':'')+f(n-9)z ogranicznikiem spacji, w tym spacją końcową, może wyglądać ładniej)
— Kevin Cruijssen
@KevinCruijssen Thanks! Właściwie próbuję to zaktualizować przez jakiś czas, ale mam około 500B / s przepustowości Internetu tam, gdzie jestem dziś wieczorem. : /
— Arnauld
Znam to uczucie. Ostatnio nasz Internet w domu jest z jakiegoś powodu badziewiem. Nie mogę pobrać niczego powyżej 10 MB, a czasami muszę kilkakrotnie odświeżyć filmy lub strony z ponad 10 obrazami, zanim całkowicie się załaduje .. Naprawdę denerwujące kiedy pracuję z domu w poniedziałki / wtorki ..>.> Jutro ktoś przyjdzie to naprawić (i nie zostawiam go, dopóki nie zostanie naprawione xD)
— Kevin Cruijssen
5

JavaScript (Node.js) , 89 bajtów

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

Wypróbuj online!

  • -4 bajty dzięki produktom @ETH

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

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

Wypróbuj online!

Wyjaśnienie

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

Pierwszy raz robię golfa kodu w JavaScript. Nie sądzę, żebym musiał to powiedzieć, ale jeśli robię coś złego, powiadom mnie w komentarzach poniżej.

  • -3 bajty dzięki @Luis felipe De jesus Munoz

  • -6 bajtów dzięki @Kevin Cruijssen

— Lew
źródło
1
[...Array(9e3)]zamiast tego Array(9e3).fill()zapisuje 2 bajty
— Luis Felipe De Jesus Munoz
1
.map(a=>+a)zamiast tego .map(Number)zapisuje kolejny bajt
— Luis Felipe De Jesus Munoz
1
Możesz usunąć miejsce w, (_, i)aby zapisać bajt, i s[0]+s[1]+s[2]+s[3]możesz eval(s.join`+`)zapisać dodatkowe 4 bajty.
— Kevin Cruijssen
1
Jestem też prawie pewien, że ||może to być |w twojej odpowiedzi.
— Kevin Cruijssen
1
Jeśli używasz .map()tylko do generowania zakresu i trzymasz filtrowanie osobno, możesz zapisać 8 bajtów: Wypróbuj online!
— ETHprodukcje
5

Python 2 , 57 bajtów

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

Wypróbuj online!

2 bajty dzięki Dennisowi

Używa execpętli do zliczania nw krokach 9 jako 1008, 1017, ..., 9981, 9990, drukując te, które spełniają warunek.

Tylko wielokrotności 9 mogą mieć sumę cyfr 9, ale wielokrotności 9 w tym zakresie mogą również mieć sumę cyfr 18 i 27. Wykluczamy to z warunkiem int(`n`,11)%10>8. Interpretując nw podstawie 11, jego suma cyfr jest równa liczbie modulo 10, podobnie jak w bazie 10 liczba równa się jej cyfrze modulo 9. Suma cyfr (9, 18, 27) odpowiada (9, 8, 7) modulo 10, więc biorąc te >8prace, aby odfiltrować dziewiątki.

Liczba zawierająca zero jest sprawdzana przy członkostwie w łańcuchach. '0'in`n`. Ten warunek jest łączony z drugim z łańcuchem nierówności, przy użyciu tego języka Python 2 traktuje łańcuchy jako większe niż liczby.

— xnor
źródło
Podoba mi się, jak mocno golfowy Python często ma niezwykle długie autogenerowane pliki wykonywalne ...
— J.Doe
4

sed i grep (i seq), 72 64 63 bajty

seq 9e3|sed s/\\B/+/g|bc|grep -wn 9|sed s/:9//|grep 0|grep ....
— Thor
źródło
Niektóre z nich nie mają czterech cyfr (ale nie jestem pewien, co to grepjest finał , więc może źle go popełniam?)
— Sparhawk
@Sparhawk: Ostatni grep zapewnia, że ​​liczba ma 4 cyfry
— Thor
@Thor Ah racja. Z jakiegoś powodu przeanalizowałem to jako elipsę.
— Sparhawk
4

Haskell , 55 bajtów

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

Dzięki @Laikoni zobacz komentarze.

Czytelny:

import Data.Char (digitToInt)

[i | i <- show <$> [1000..9999]
   , sum (digitToInt <$> i) == 9
   , '0' `elem` i
   ]
— mb21
źródło
2
Witamy w szczególności w PPCG i Haskell! Możesz zaoszczędzić kilka bajtów, upuszczając (-48+)i porównując sumę 201zamiast 9. Nawiasem mówiąc, pozwala to również na użycie 1zamiast 1000zakresu.
— Laikoni
Również twoja poprzednia wersja bez main=printbyła w porządku zgodnie z tym konsensusem w sprawie Meta .
— Laikoni
9999może być 5^6zamiast.
— Laikoni
1
Ha, zawsze jest kolejny bajt do golenia! Dzięki :-)
— mb21
3

R , 82 bajty

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

Wypróbuj online!

Generuje macierz xwszystkich możliwych 4-cyfrowych liczb, wyłączając zera na początku, przechodząc w dół kolumn. Następnie filtry dla sumowych kolumn (cyfrowych) 9 i zawierających zero, tj. Nie allsą niezerowe. writeWydruki w dół kolumny, więc writeto stdouto szerokości 4i separator "".

Outgolfed by J.Doe

— Giuseppe
źródło
Niezła odpowiedź!
— Wpadłem
3

Japt , 20 18 bajtów.

-2 bajty dzięki produktom @Shaggy i @ETH

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

Wypróbuj online!

— Luis Felipe De Jesus Munoz
źródło
To w rzeczywistości 28 bajtów . Zamiast tego użycie dosłownej liczby całkowitej wynosi 22 bajty, ale A³ò9000 f_ìx ¥9©ZsøTsprowadza cię z powrotem do 20.
— Shaggy, 15'18
1
Można zapisać 1 bajt stosując ìzamiast si ¬, co musi być zrobione w filtrze: f_=ì)x ¥9.... Następnie możesz zapisać kolejny, sprawdzając, czy iloczyn Z jest równy zero «Z×: Wypróbuj online!
— ETHproductions
3

Java 8, 128 117 115 bajtów

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 bajtów dzięki @nwellnhof .

Wypróbuj online.

Wyjaśnienie:

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
źródło
1
Co chars().sum()==201?
— nwellnhof
@nwellnhof Ah, oczywiście. Dzięki!
— Kevin Cruijssen
3

R , 85 bajtów

(po prostu rywalizuję o najlepsze nadużycie nawiasów kwadratowych 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='')]]]]

Wypróbuj online!

— digEmAll
źródło
1
Święta dla pętli, Batman!
— BLT
3

05AB1E , 15 13 12 10 bajtów

₄4°ŸεW°ö9Q

-2 bajty dzięki @Emigna
-3 bajty dzięki @Grimy

Wypróbuj online.

Wyjaśnienie:

₄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

— Kevin Cruijssen
źródło
1
₄4°Ÿʒ0å}ʒSO9Q. Filtry
— dzielące
@Emigna Ach, szukałem krótszego sposobu na zasięg, ale zupełnie o tym zapomniałem 4°. Dzięki. I rzeczywiście masz rację, że wiele luźnych filtrów (na końcu) jest krótszych. Dodam go również do jednej z moich wskazówek typu tip. Dzięki za oba bajty!
— Kevin Cruijssen
1
A moim drugim 13-bajtowym (zainspirowanym ord sum == 201 trikiem) jest 4°Lʒ0å}ʒÇOт·-. Zostawiając to tutaj, może ktoś może
— zagrać w
1
₄4°ŸʒD0åôO9Q. Korzystanie z pojedynczego filtra jest zwykle krótsze.
— Grimmy,
1
Nieważne, oto 10:₄4°ŸʒW°ö9Q
— Grimmy
2

Pip , 18 bajtów

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

Użyj flagi w formacie ouput, na przykład, -paby uzyskać czytelny wynik. Wypróbuj 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
źródło
2

Wolfram Language (Mathematica) , 56 55 bajtów

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

Wypróbuj online!

Testujemy zakres od 9 !! = 945 do 9999, ponieważ nie ma wyników między 945 a 999. Może jest też krótszy sposób na zapisanie liczby między 9000 a 10007.

Tr@#==Times@@#+9&stosowane do {a,b,c,d}testów if a+b+c+d == a*b*c*d+9, które ostatecznie są równoważne Warunkowi Anno.

— Misza Ławrow
źródło
Z perspektywy czasu 9 !! nie jest krótszy niż 999 czy coś, ale bije 1000.
— Misha Lavrov
Co to jest 9 !! ? Zgadywanie nie ma związku z silnią.
— Robert Fraser
@RobertFraser Pokój silnia: 9*7*5*3*1.
— Misha Lavrov
2

Ruby , 46 42 41 bajtów

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

Wypróbuj online!

Jak to działa:

  • Iteruj po ciągach znaków od „9” do „9999”
  • Sprawdź, czy suma wartości ASCII wynosi 201
  • Sprawdź, czy łańcuch zawiera zero (bez wyrażenia regularnego, wyrażenie byłoby dłuższe o 1 bajt)

(Dzięki Laikoni za -2 bajty)

— GB
źródło
1
9*3może być po prostu 9, ponieważ sprawdzanie w stosunku do 201 wymaga już 4 cyfr.
— Laikoni
2

Oktawa , 49 bajtów

6 bajtów zapisanych przy użyciu wygodniejszego formatu wyjściowego, jak sugeruje J.Doe .

Dzięki @Laikoni za korektę .

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

Wypróbuj online!

— Luis Mendo
źródło
Nic nie wiem o Octave, ale wygląda na to, że możesz zrezygnować disp...
— J.Doe
@ J.Doe OP potwierdził, że ten format wyjściowy jest akceptowalny. Dzieki za sugestie!
— Luis Mendo
2

Dart ,  103 100  96 bajtów

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

  • -3 bajty poprzez ustawienie wartości w tablicy na łańcuch, co powoduje konwersję raz, a nie dwa razy
  • -4 bajty przy użyciu run zamiast codeUnits

    • Dość oczywiste. generuje listę 9001 (0–9000) komórek z indeksem komórki jako wartością, filtruje te zawierające 0, a następnie tę o sumie ASCII 201 (Wynik, jeśli wszystkie znaki ASCII sumują się do 9). Warunki te domyślnie obejmują, że rok ma 4 cyfry, ponieważ używając 2 liczb ASCII (i 0), nie można osiągnąć 201.

    Wypróbuj na Dartpad!

    — Elcan
    źródło
    Witamy w PPCG. :)
    — Laikoni
    1
    Dzięki ! Czaję się przez chwilę, może w końcu wziąć udział
    — Elcan
    2

    PHP, 69, 87 bajtów 74 bajty

    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;

    Zauważ, że stawia to miejsce dla każdej „nieudanej” liczby, co prowadzi do pewnego rodzaju funky odstępów. Można to zmienić na separację przecinków, ale doda kolejne 4 znaki:?$i.",":""

    Zwiększyłem się, ponieważ nie sprawdzałem 0. Derp. Skrócone o 13 przez Tytusa!

    — azyl
    źródło
    2
    Tak naprawdę nie znam PHP, ale czy ten kod zapewnia, że ​​każdego roku zawiera zero?
    — Laikoni
    Ten kod nie sprawdza zerowej liczby.
    — krzysiej,
    1
    13 bajtów krótszych:for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;
    — Tytus
    Oto kolejny bajt: ?"$i,":""er ... teraz odwrotnie:?"":"$i,"
    — Tytus
    Właściwie @Titus, który dodaje kilka bajtów. Nie potrzebujemy cudzysłowów wokół $ i, chyba że uwzględniamy ciąg znaków w / it.
    — azyl
    2

    Scala ( 76 63 61 56 bajtów)

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

    Wypróbuj online

    • Dzięki Laikoni za sugestie
    • Dwa kolejne bajty zrzucone po zastosowaniu komentarza Jo Kinga
    — Jrook
    źródło
    1
    Witamy w PPCG! Czy masz pomysł, co należy dodać do sekcji nagłówka lub stopki, aby ten kod działał na TIO? Wypróbuj online!
    — Laikoni
    @Laikoni, nie wiedziałem, że mogę uruchomić Scalę w TIO. Naprawione. Dziękuję za komentarz.
    — krzyk
    1
    Wygląda na to, że t.sum==201działa zamiast t.map(_.asDigit).sum==9.
    — Laikoni
    Nasze wskazówki dotyczące gry w golfa w Scali mogą Cię zainteresować. Np wygląda s"$n"może być n+""i s"$t "może być t+" ".
    — Laikoni,
    1
    Ponieważ używasz sumy wynoszącej 201, zasięg nie musi zaczynać się od 999
    — Jo King
    1

    Japt, 16 bajtów

    Zwraca tablicę tablic cyfrowych.

    L²õì l4 k_ת9aZx

    Sprawdź to

    Wyjaśnienie

    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
    — Kudłaty
    źródło
    1
    OP orzekł, że tablice cyfr nie są niestety prawidłowymi danymi wyjściowymi: o (
    — Sok
    1

    APL (NARS), 45 znaków, 90 bajtów

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

    przetestuj po sformatowaniu:

    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

    możliwa alternatywa

    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
    źródło
    1

    Galaretka , 13 bajtów

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

    Wypróbuj online!

    W jaki sposób?

    ȷ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
    źródło
    Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
    Licensed under cc by-sa 3.0 with attribution required.