Aquí hay una secuencia razonablemente trivial que no está en la Enciclopedia en línea de secuencias enteras .

Comience con una secuencia vacía y luego defina cada término como la cantidad de caracteres necesarios para escribir, en inglés, todos los dígitos de la secuencia hasta ahora sin espacios. *

Como referencia, el número de caracteres de todos los dígitos (base diez) en inglés son:

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

(Que es el comienzo de A52360 y A5589 ).

Esto hace que la primera entrada $a(0) = 0$ ya que hay cero dígitos presentes en la secuencia vacía.

Esto hace que la segunda entrada sea ya que se necesitan cuatro caracteres para escribir "cero", el único dígito presente hasta ahora.$a(1) = 4$

Esto hace que la tercera entrada sea ya que se necesitan cuatro caracteres más para escribir los "cuatro" para un total de ocho para escribir "zerofour".$a(2) = 8$

Esto hace que la cuarta entrada sea ya que se necesitan cinco caracteres más para escribir "ocho" para un total de trece para escribir "zerofoureight".$a(3) = 13$

Esto hace que la quinta entrada sea ya que se necesitan ocho caracteres más para escribir "onethree" para un total de veintiuno para escribir "zerofoureightonethree".$a(4) = 21$

...y así. Aquí están las primeras 100 entradas:

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

_{* Podríamos definirlo para otros idiomas y / u otras bases o con espacios, por supuesto.}

El reto

Dada salida, en la menor cantidad de bytes de código posible, cualquiera de:$n$

• Los primeros términos de la secuencia (deberían funcionar para enteros no negativos)$n$
• El valor de (debería funcionar para enteros no negativos)$a(n)$
• El ^º término de la secuencia (debería funcionar para números enteros positivos - es decir, valor de un ( n - 1 ) )$n$$a(n-1)$

Este es el código de golf, por lo que la respuesta más corta en bytes gana para cada idioma, y ​​la respuesta más corta en bytes gana. ¡No permita que los idiomas de golf le impidan ingresar a su idioma favorito, ya sea práctico o esotérico!

Perl 6 , 45 bytes

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

Pruébalo en línea!

¡No es necesario realizar una modulación elegante cuando puede obtener el nombre del dígito directamente! Bloque de código anónimo que devuelve el enésimo valor de la secuencia, o puede pasar en un rango para obtener una lista de valores

Explicación:

{(                                     )[$_]}  # 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 bytes

Devuelve $a(n)$ .

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

Pruébalo en línea!

¿Cómo?

Un dígito $d$ se convierte en un número $n$ de letras 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

Debido a que el número se divide en caracteres de dígitos, podemos procesar $d\times 100+10$ simplemente agregando $10$ (como una concatenación de cadenas).

Stax , 14 13 bytes

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

Ejecutar y depurarlo

La idea clave aquí es que el dígito drequiere ((4 - 2 * d) // 3) % 3 + 3letras para deletrear. (Esa es la división de enteros de Python y el módulo no negativo de estilo Python)

Pip , 21 bytes

Lai+:$+4335443554@^Pi

$n$$n$

Explicación

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 bytes

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

Pruébalo en línea!

Tr@StringLength@IntegerName@IntegerDigits@#&enumera los dígitos de #, convierte cada uno de ellos en un nombre en inglés, cuenta la longitud y suma los resultados. Muchas cosas pasan por las listas, es muy emocionante. Luego solo aplicamos iterativamente la definición.

TIO se queja de que no tiene conexión a Internet, pero no estoy seguro de por qué, porque de todos modos descubre la respuesta correcta. ¿Quizás está buscando actualizaciones para los nombres de los enteros?

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

Limpio , 82 bytes

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

Pruébalo en línea!

05AB1E , 15 14 bytes

ÎFD•16\|/•sSèOO

Pruébalo en línea!

Explicación

Î                # 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 bytes

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

Pruébalo en línea!

$f(input)$

Gracias a los muchachos @The APL Orchard por ayudar con este:

@ngn para 2 bytes; @ H.PWiz para 3 4 bytes.

Ahora usando la fórmula de @ recursive.

Cómo:

{{⍵++/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 bytes

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

Pruébalo en línea!

Utiliza el mapeo recursivo de recuento de dígitos .

Python 2 , 63 bytes

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

Pruébalo en línea!

Una versión de función recursiva. Se tarda un tiempo exponencial en ejecutarse porque tiene dos llamadas recursivas a f(n-1).

Python 2 , 71 bytes

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

Pruébalo en línea!

MathGolf , 17 bytes

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

Pruébalo en línea!

Esto usa el método de Arnauld . Emite el enésimo elemento de la secuencia. Si la cadena vacía está bien a(0), entonces podríamos eliminar el0\ al principio.

Explicación:

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 bytes

u+Gs@L+L3jC\᯻3jGTQ0

Pruébelo en línea aquí .

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

Ruby , 54 bytes

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

Pruébalo en línea!

Java (JDK) , 95 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 82 bytes

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

Pruébalo en línea!

Jalea , 13 bytes

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

Pruébalo en línea!

0 indexado.

Programa completo; toma entrada de STDIN.

Rojo , 99 95 bytes

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

Pruébalo en línea!

Solo una solución sencilla.

J , 37 bytes

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

Pruébalo en línea!

Utiliza el método de Arnauld

Explicación:

El argumento es 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

Editado después del primer comentario.

Imprime todos los términos

Scala, 76 bytes

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

Pruébalo en línea!

Impresiones n ^th término

Scala, 72 bytes

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

Scala, 69 bytes

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

Scala, 67 bytes

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

Scala, 67 bytes

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

Pruébalo en línea!