Elenca tutti i titoli possibili per i giochi Anno


37

Nella serie di videogiochi Anno ci sono 6 giochi con un 7 annunciato per l'inizio del 2019. I loro titoli presentano sempre un anno secondo uno schema specifico:

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

  • La somma digitale è sempre 9.
  • Gli anni sono lunghi quattro cifre.
  • Contengono almeno uno zero.

All'interno di questi vincoli esistono 109 possibili titoli:

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

Il tuo obiettivo è elencarli tutti in qualsiasi forma ragionevole nel minor numero di byte.


Quanto è flessibile il formato di output? È questo accettabile?
Luis Mendo,

1
@LuisMendo Sì, va bene con me.
Laikoni,


1
@aslum suppongo che intendi molti spazi, non solo uno, giusto? Il markdown dei commenti non consente una buona rappresentazione di ciò. E suppongo che sia permesso, dato che il formato di Luis sopra è permesso. ;-)
Erik the Outgolfer,

1
@EriktheOutgolfer Direi di no agli elenchi di cifre perché in realtà non sembrano più anni.
Laikoni,

Risposte:


20

R , 59 51 byte

Emette i numeri validi come nomi di un elenco di 201. Perché 201 Perché ASCII 0 è 48 e 4 * 48 + 9 è ... sì. 6 byte salvati aliasing ^in Mape altri 2 utilizzando 1:9e3come intervallo.

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

Provalo online!

Spiegazione

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

3
ah, grepperché non ricordo mai che lancia a character...
Giuseppe,



9

Gelatina , 11 byte

9ȷṢ€æ.ẹ9ṫ19

Provalo online!

Come funziona

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.

7

PowerShell , 50 49 byte

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

Provalo online!

Crea un intervallo da 999a 10000, quindi utilizza inline -matchcome filtro per estrarre quelle voci a cui regex corrisponde 0. Questo ci lascia con 1000, 1001, 1002, etc.We poi lo Where-Objectinseriamo in una clausola in cui prendiamo il numero corrente come stringa "$_", lo charlanciamo come un array, -joinquei caratteri insieme +e Invoke- Expression (simile a eval) per ottenere la loro somma delle cifre. Controlliamo se è -eqnormale 9e in tal caso viene passato alla pipeline. Al completamento del programma, quei numeri vengono prelevati dalla pipeline e implicitamente emessi.


5

JavaScript (ES6), 78 73 byte

Salvato 2 byte grazie a @KevinCruijssen

Restituisce una stringa separata da spazio.

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

Provalo online!

Come?

Esaminiamo l'intervallo [1008..9000] con un incremento di 9 , ignorando i numeri che non hanno uno 0 .

Tutti questi numeri sono multipli di 9 , quindi anche la somma delle loro cifre sarà un multiplo di 9 .

Poiché i numeri validi hanno almeno uno 0 , non hanno più di due 9 , il che significa che la somma delle cifre rimanenti è al massimo 18 . Pertanto, è sufficiente verificare se la somma delle cifre è dispari.

Da qui il test:

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

È possibile salvare un byte modificando 1008in 999, poiché non contiene comunque uno 0 e 999+9 = 1008.
Kevin Cruijssen,

O anche 2 byte modificandolo in f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?[n,,]:'')+f(n-9)(contiene comunque una virgola finale, quindi f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?n+' ':'')+f(n-9)con il delimitatore di spazio incluso lo spazio finale potrebbe sembrare più bello)
Kevin Cruijssen

@KevinCruijssen Grazie! In realtà sto provando ad aggiornare questo per un po ', ma ho circa 500 B / s di larghezza di banda Internet dove sono stasera. : /
Arnauld,

Conosco la sensazione .. Ultimamente la nostra Internet a casa è una schifezza per qualche motivo .. Non riesco a scaricare nulla sopra i 10 MB e a volte devo aggiornare video o pagine con più di 10 immagini alcune volte prima che si carichi completamente .. Davvero fastidioso quando lavoro da casa il lunedì / martedì ..>.> Domani qualcuno viene a sistemarlo (e non lo
lascerò

5

JavaScript (Node.js) , 89 byte

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

Provalo online!

  • -4 byte grazie a @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)

Provalo online!

Spiegazione

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

Prima volta facendo il golf del codice in JavaScript. Non credo di doverlo dire, ma se sto facendo qualcosa di sbagliato, per favore avvisami nei commenti qui sotto.

  • -3 byte grazie a @Luis felipe De jesus Munoz

  • -6 byte grazie a @Kevin Cruijssen


1
[...Array(9e3)]invece Array(9e3).fill()salva 2 byte
Luis felipe De jesus Munoz il

1
.map(a=>+a)invece .map(Number)salva un altro byte
Luis felipe De jesus Munoz,

1
Puoi rimuovere lo spazio in (_, i)per salvare un byte e s[0]+s[1]+s[2]+s[3]può essere eval(s.join`+`)per salvare altri 4 byte.
Kevin Cruijssen,

1
Inoltre, sono abbastanza sicuro che ||possa essere |nella tua risposta.
Kevin Cruijssen,

1
Se si utilizza .map()solo per generare l'intervallo e mantenere separato il filtro, è possibile salvare 8 byte: provalo online!
ETHproductions

5

Python 2 , 57 byte

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

Provalo online!

2 byte grazie a Dennis

Usa un execciclo per contare nin passi di 9 come 1008, 1017, ..., 9981, 9990, stampando quelli che soddisfano la condizione.

Solo i multipli di 9 possono avere la somma delle cifre 9, ma i multipli di 9 in questo intervallo possono avere anche la somma delle cifre di 18 e 27. Escludiamo questi con la condizione int(`n`,11)%10>8. Interpretando nnella base 11, la somma delle cifre è uguale al numero modulo 10, proprio come nella base 10 un numero è uguale alla somma delle cifre modulo 9. La somma delle cifre di (9, 18, 27) corrisponde a (9, 8, 7) modulo 10, quindi prendendo quei >8lavori per filtrare nove.

Il numero che contiene uno zero è controllare con l'appartenenza alla stringa. '0'in`n`. Questa condizione è unita all'altra con una disuguaglianza concatenata, usando Python 2 che considera le stringhe maggiori dei numeri.


Mi piace quanto Python abbia un golf molto pesante e spesso abbia eseguibili autogenerati enormemente lunghi ...
J.Doe,

4

sed e grep (e seq), 72 64 63 byte

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

Alcune di queste non sono lunghe quattro cifre (ma non sono sicuro di quale sia la finale grep, quindi forse sto sbagliando?)
Sparhawk,

@Sparhawk: l'ultimo grep assicura che il numero sia lungo 4 cifre
Thor

@Thor Ah giusto. Per qualche motivo l'ho analizzato come un puntino di sospensione.
Sparhawk,

4

Haskell , 55 byte

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

Grazie a @Laikoni, vedi i commenti.

Leggibile:

import Data.Char (digitToInt)

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

2
Benvenuti in particolare al golf PPCG e Haskell! È possibile salvare alcuni byte rilasciando (-48+)e confrontando la somma con 201invece di 9. Per inciso, ciò consente anche di utilizzare 1invece che 1000per l'intervallo.
Laikoni,

Anche la tua versione precedente senza main=printandava bene secondo questo consenso su Meta .
Laikoni,

9999può essere 5^6invece.
Laikoni,

1
Ah, c'è sempre un altro byte da radere! Grazie :-)
mb21

3

R , 82 byte

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

Provalo online!

Genera una matrice xdi tutti i possibili numeri di 4 cifre, esclusi gli zeri iniziali, scendendo le colonne. Quindi i filtri per le somme di colonna (digitali) di 9 e contenenti zero, ovvero non allsono zero. writestampe scorrimento delle colonne, in modo da writea stdoutcon una larghezza di 4e un separatore di "".

Superato da J.Doe


Bella risposta! Mi è venuta in mente una strada diversa ...
J.Doe,

3

Japt , 20 18 byte.

-2 byte grazie 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

Provalo online!


Questo è in realtà 28 byte . L'uso di un numero intero letterale invece è di 22 byte ma A³ò9000 f_ìx ¥9©ZsøTti riporta a 20
Shaggy,

1
You can save 1 byte by using ì instead of s and ¬, which has to be done in the filter: f_=ì)x ¥9.... Then you can save another by checking if the product of Z is zero with «Z×: Try it 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 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

1
What about chars().sum()==201?
nwellnhof

@nwellnhof Ah, of course. Thanks!
Kevin Cruijssen

3

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!


1
Holy for loops, Batman!
BLT

3

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 10d (°). 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 10d (°). 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 10d (°). 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 10d (°). 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 d1 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.


1
₄4°Ÿʒ0å}ʒSO9Q. Splitting filters are usually shorter
Emigna

@Emigna Ah, I was looking for a shorter way for the range, but completely forgot about . Thanks. And you're indeed right that multiple loose filters (at the end) are shorter. Will also add it to one of my tip answers. Thanks for both bytes!
Kevin Cruijssen

1
And my other 13-byter (inspired by the ord sum == 201 trick) is 4°Lʒ0å}ʒÇOт·-. Leaving this here, maybe someone can golf it further
Mr. Xcoder

1
₄4°ŸʒD0åôO9Q. Using a single filter is usually shorter.
Grimmy

1
Nevermind, here's a 10: ₄4°ŸʒW°ö9Q
Grimmy

2

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

2

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.


In retrospect, 9!! isn't any shorter than 999 or something, but it beats 1000.
Misha Lavrov

What is 9!! ? In guessing it isnt related to factorials.
Robert Fraser

@RobertFraser Double 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)}

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)


1
9*3 can be just 9, because checking against 201 already requires 4 digit numbers.
Laikoni

2

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!


I don't know anything about Octave, but it looks like you can leave the disp off...
J.Doe

@J.Doe OP has confirmed that that output format is acceptable. Thanks for the suggestion!
Luis Mendo

2

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

  • -3 bytes by setting the value in the array to string, making the conversion once and not twice
  • -4 bytes by using runes instead of codeUnits
  • 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!


    Welcome to PPCG. :)
    Laikoni

    1
    Thanks ! Been lurking for a while, can finally participate
    Elcan

    2

    Bash (with seq, grep), 39 bytes

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

    Try it online!


    @xobzoo suggested seq 0 9 1e4|awk '/([0-4].*){3}/&&/0/' to save two bytes.
    Timtech

    2

    K (ngn/k), 22 bytes

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

    Try it online!


    Nice! 55_&9=+/y*|/'~y:!4#10 for 21?
    streetster

    1
    @streetster thanks :) the ' in |/' looks wrong. the result includes 1116, 1125, 1134, etc which are not supposed to be there
    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;

    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!


    2
    I don't really know PHP, but does this code ensure that each year contains a zero?
    Laikoni

    This code does not check for zero in the number.
    krzysiej

    1
    13 bytes shorter: for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;
    Titus

    Here´s another byte: ?"$i,":"" er ... now the other way round: ?"":"$i,"
    Titus

    Actually @Titus that adds a couple bytes. We don't need quotes around $i unless we're including a string 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)
    

    Try it online

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

    1
    Welcome to PPCG! Do you have an idea what needs to be added to the header or footer section to get this code to run on TIO? Try it online!
    Laikoni

    @Laikoni, didn't know I could run Scala in TIO. Fixed it. Thanks for the comment.
    jrook

    1
    It looks like t.sum==201 works instead of t.map(_.asDigit).sum==9.
    Laikoni

    You may find our tips for golfing in Scala interesting. E.g. it looks like s"$n" can be n+"" and s"$t " can be t+" ".
    Laikoni

    1
    Since you're using the sum is 201 trick, the range doesn't need to start at 999
    Jo King


    1

    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
    

    1
    OP has ruled that digit arrays aren't valid output unfortunately :o(
    Sok

    1

    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
    

    1

    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]
    
    Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
    Licensed under cc by-sa 3.0 with attribution required.