Ecco una sequenza ragionevolmente banale che non si trova nell'Enciclopedia online delle sequenze di numeri interi .

Inizia con una sequenza vuota, quindi definisci ogni termine come il numero di caratteri richiesti per scrivere, in inglese, tutte le cifre della sequenza finora senza spazi. *

Per riferimento, il numero di caratteri di tutte le cifre (base dieci) in inglese sono:

zero   one    two    three  four   five   six    seven  eight  nine
4      3      3      5      4      4      3      5      5      4

(Che è l'inizio di A52360 e A5589 .)

Questo rende la prima voce $a(0) = 0$ poiché nella sequenza vuota sono presenti zero cifre.

Questo rende la seconda voce $a(1) = 4$ quanto sono necessari quattro caratteri per scrivere "zero", l'unica cifra presente finora.

Questo rende la terza voce $a(2) = 8$ quanto sono necessari altri quattro caratteri per scrivere i "quattro" per un totale di otto per scrivere "zerofour".

Questo rende la quarta voce $a(3) = 13$ quanto sono necessari altri cinque caratteri per scrivere "otto" per un totale di tredici per scrivere "zerofoureight".

Questo rende la quinta voce $a(4) = 21$ quanto sono necessari altri otto caratteri per scrivere "onethree" per un totale di ventuno per scrivere "zerofoureightonethree".

...e così via. Ecco le prime 100 voci:

0, 4, 8, 13, 21, 27, 35, 44, 52, 59, 67, 75, 84, 93, 102, 112, 121, 130, 142, 152, 162, 171, 182, 193, 205, 216, 225, 235, 247, 259, 270, 282, 293, 305, 318, 331, 344, 357, 371, 384, 398, 412, 422, 432, 444, 456, 467, 479, 492, 503, 516, 526, 536, 548, 561, 571, 583, 597, 610, 620, 630, 642, 652, 662, 671, 682, 693, 705, 718, 731, 744, 757, 771, 784, 798, 812, 823, 836, 849, 862, 873, 888, 903, 916, 926, 936, 948, 961, 971, 983, 997, 1010, 1024, 1038, 1055, 1070, 1086, 1101, 1114, 1127

_{* Potremmo definirlo per altre lingue e / o altre basi o con spazi ovviamente}

La sfida

Dato $n$ output, nel minor numero di byte di codice possibile, uno di:

• I primi $n$ termini della sequenza (dovrebbe funzionare per numeri interi non negativi)
• Il valore di $a(n)$ (dovrebbe funzionare per numeri interi non negativi)
• Il $n$ ^° termine della successione (dovrebbe funzionare per gli interi positivi - cioè il valore di $a(n-1)$ )

Questo è code-golf, quindi vince la risposta più breve in byte per ogni lingua e vince la risposta più breve in byte. Non lasciare che le lingue del golf ti impediscano di entrare nella tua lingua preferita, sia essa pratica o esoterica!

Perl 6 , 45 byte

{({[+] @_.join.uninames>>.comb X-6}...*)[$_]}

Provalo online!

Non è necessario un modulo di fantasia quando puoi ottenere direttamente il nome della cifra! Blocco di codice anonimo che restituisce l'ennesimo valore della sequenza oppure è possibile passare un intervallo per ottenere un elenco di valori

Spiegazione:

{(                                     )[$_]}  # Index input into:
  {                               }...*        # An infinite sequence
                                               # Where each element is
   [+]   # The sum of
       @_.join  # All previous elements joined together
              .uninames  # The unicode names for each character
                         # These are names in the form "DIGIT ONE"
                       >>.comb  # Split each to lists of characters
                               X-6  # Subtract 6 from each

JavaScript (ES6), 69 68 61 58 byte

Restituisce $a(n)$ .

f=(n,s=0)=>n?f(n-1,[...s+''].map(d=>s+=(d+10)%23%3+3)|s):s

Provalo online!

Come?

Una cifra $d$ viene convertita in un numero $n$ di lettere con:

 d | *100 | +10 | MOD 23 | MOD 3 | +3 | word
---+------+-----+--------+-------+----+-------
 0 |    0 |  10 |   10   |   1   |  4 | zero
 1 |  100 | 110 |   18   |   0   |  3 | one
 2 |  200 | 210 |    3   |   0   |  3 | two
 3 |  300 | 310 |   11   |   2   |  5 | three
 4 |  400 | 410 |   19   |   1   |  4 | four
 5 |  500 | 510 |    4   |   1   |  4 | five
 6 |  600 | 610 |   12   |   0   |  3 | six
 7 |  700 | 710 |   20   |   2   |  5 | seven
 8 |  800 | 810 |    5   |   2   |  5 | eight
 9 |  900 | 910 |   13   |   1   |  4 | nine

Poiché il numero è diviso in caratteri numerici, possiamo elaborare $d\times 100+10$ semplicemente aggiungendo$10$ (come concatenazione di stringhe).

Stax , 14 13 byte

┴♥7[╘⌂←─üTJ‼√

Esegui ed esegui il debug

L'intuizione chiave qui è che la cifra drichiede ((4 - 2 * d) // 3) % 3 + 3lettere per scrivere. (Questa è la divisione intera di Python e il modulo non negativo in stile Python)

Pip , 21 byte

Lai+:$+4335443554@^Pi

Prende input $n$ come argomento della riga di comando e genera il primo $n$ termini. Provalo online!

Spiegazione

Lai+:$+4335443554@^Pi
                       a is 1st cmdline arg; i is 0 (implicit)
La                     Loop (a) times:
                   Pi   Print i
                  ^     Split it into a list of characters (i.e. digits)
       4335443554@      Use each digit to index into this number, giving the length of the
                        name of the digit (0 -> 4, 1 -> 3, etc.)
     $+                 Sum the results
  i+:                   Increment i by that amount

Wolfram Language (Mathematica) , 57 byte

Nest[#+Tr@StringLength@IntegerName@IntegerDigits@#&,0,#]&

Provalo online!

Tr@StringLength@IntegerName@IntegerDigits@#& elenca le cifre di # , le converte in un nome inglese, conta la lunghezza e somma i risultati. Molte cose passano in rassegna le liste, è molto eccitante. Quindi applichiamo solo iterativamente la definizione.

TIO si lamenta di non avere una connessione Internet, ma non sono sicuro del perché, perché trova comunque la risposta giusta. Forse sta cercando aggiornamenti per i nomi di numeri interi?

$a(n)$$a(0), a(1), \dots, a(n)$NestNestList

Pulito , 82 byte

import StdEnv,Text
$a=iter a(\n=n+sum[3+indexOf{c}" 9810324765"rem 3\\c<-:""<+n])0

Provalo online!

05AB1E , 15 14 byte

ÎFD•16\|/•sSèOO

Provalo online!

Spiegazione

Î                # initialize stack with 0 and input
 F               # input times do:
  D              # duplicate the current number
         sSè     # and use one copy to index into
   •Qb₁ñ•        # 433544355
            OO   # sum digits and sum the stack

APL (Dyalog Unicode) , 29 28 byte

{{⍵++/3+3|⌊3÷⍨4-2×⍎¨⍕⍵}⍣⍵⊢0}

Provalo online!

$f(input)$

Grazie ai ragazzi @The APL Orchard per l'aiuto con questo:

@ngn per 2 byte; @ H.PWiz per 3 4 byte.

Ora usando la formula di @ recursive.

Come:

{{⍵++/3+3|⌊3÷⍨4-2×⍎¨⍕⍵}⍣⍵⊢0} ⍝ Main fn

 {                     }⍣⍵⊢0 ⍝ Starting with 0, repeat (⍣) the inner fn input times
      3+3|⌊3÷⍨4-2×⍎¨⍕⍵      ⍝ @recursive's formula
  ⍵++/                       ⍝ Sum with the input.

Python 2 , 61 byte

n=0
exec"for c in`n`:n+=(4-2*int(c))/3%3+3\n"*input()
print n

Provalo online!

Utilizza la mappatura del conteggio delle cifre ricorsiva .

Python 2 , 63 byte

f=lambda n:n and f(n-1)+sum((4-2*int(c))/3%3+3for c in`f(n-1)`)

Provalo online!

Una versione con funzione ricorsiva. Ci vuole tempo esponenziale per eseguire perché ha due chiamate ricorsive a f(n-1).

Python 2 , 71 byte

f=lambda n,k=0:n and f(n-1,k+sum(632179420>>3*int(d)&7for d in`k`))or k

Provalo online!

MathGolf , 17 byte

0\{_▒♀*♂+L%3%3+Σ+

Provalo online!

Questo utilizza il metodo di Arnauld . Emette l'ennesimo elemento della sequenza. Se la stringa vuota va bene per a(0), allora potremmo rimuovere il0\ all'inizio.

Spiegazione:

0\                 Setup 0 as the counter
  {                Loop input times
   _▒              Duplicate counter and split to list of digits
     ♀*            Multiply each element by 100
       ♂+          Add 10
         L%        Modulo by 23
           3%      Modulo by 3
             3+    Add 3
               Σ   Sum list
                +  And add to counter

Pyth , 21 byte

u+Gs@L+L3jC\᯻3jGTQ0

Provalo online qui .

u+Gs@L+L3jC\᯻3jGTQ0   Implicit: Q=eval(input()), T=10

u                Q0   Starting at 0, repeat the following Q times, with current value as G:
          C\᯻           Get character code 7163
         j   3          Convert the above to base 3, yields [1, 0, 0, 2, 1, 1, 0, 2, 2]
      +L3               Add 3 to each to generate digit length dictionary
              jGT       Get digits of G (convert to base 10)
    @L                  Lookup each value in the above in the dictionary, modular indexing
   s                    Take the sum
 +G                     Add G to the above

Rubino , 54 byte

->n{s=0;n.times{s+=s.digits.sum{|d|4+392[d]-70[d]}};s}

Provalo online!

Java (JDK) , 95 byte

n->{int l=0;while(n-->0)l+=(""+l).chars().map(x->"4335443554".charAt(x-48)-48).sum();return l;}

Provalo online!

JavaScript (Node.js) , 82 byte

f=(a,b=1,s=4)=>a?b<a?f(a,++b,s+=[...s+''].reduce((q,w)=>+'4335443554'[w]+q,0)):s:0

Provalo online!

Gelatina , 13 byte

ṃ“vẋç’ḃ5¤S+Ɗ¡

Provalo online!

0-indicizzati.

Programma completo; accetta input da STDIN.

Rosso , 99 95 byte

func[n][d:"4335443554"s: 0 repeat i n[print s foreach c form s[s: s - 48 + do d/(-47 + do c)]]]

Provalo online!

Solo una soluzione semplice.

J , 37 byte

(+1#.|(3+3|23|10+100*]),.&.":)@]^:[&0

Provalo online!

Usa il metodo di Arnauld

Spiegazione:

L'argomento è n

                                 ^:    - apply the verb on the left hand site
                                   [   - n times
                                    &0 - to a starting value 0
 (                             )@]     - calculate for the current value of the argument
                         ,.&.":        - convert to string and then each char to digit
        (3+3|23|10+100*])              - map each digit to its word length
       |                               - a filler for the fork
    1#.                                - sum the lengths 
   +                                   - add them to the current value

Modificato dopo il 1 ° commento.

Stampa tutti i termini

Scala, 76 byte

def^(n:Int)=(1 to n).scanLeft(0)((y,_)=>y+(y+"").map(x=>(x*9+1)%13%3+3).sum)

Provalo online!

Stampe n ^° termine

Scala, 72 byte

def^(n:Int)=Stream.iterate(0)(x=>x+(x+"").map(x=>(x*9+1)%13%3+3).sum)(n)

Scala, 69 byte

def^(n:Int)=(0/:(1 to n))((y,_)=>y+(y+"").map(x=>(x*9+1)%13%3+3).sum)

Scala, 67 byte

def s(b:Int):Stream[Int]=b#::s(b+(b+"").map(x=>(x*9+1)%13%3+3).sum)

Scala, 67 byte

val s:Stream[Int]=0#::s.map(x=>x+(x+"").map(x=>(x*9+1)%13%3+3).sum)

Provalo online!