Voici une séquence assez banale qui ne figure pas dans l' Encyclopédie en ligne des séquences entières .

Commencez avec une séquence vide, puis définissez chaque terme comme le nombre de caractères requis pour écrire, en anglais, tous les chiffres de la séquence jusqu'à présent sans espaces. *

Pour référence, le nombre de caractères de tous les (base dix) chiffres en anglais est:

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

(Qui est le début des deux A52360 et A5589 .)

Cela rend la première entrée $a(0) = 0$ car il n'y a aucun chiffre présent dans la séquence vide.

Cela rend la deuxième entrée$a(1) = 4$ car il faut quatre caractères pour écrire "zéro", le seul chiffre présent jusqu'à présent.

Cela fait la troisième entrée car il faut quatre caractères supplémentaires pour écrire le "quatre" pour un total de huit pour écrire "zerofour".$a(2) = 8$

Cela fait la quatrième entrée car il faut cinq caractères supplémentaires pour écrire "huit" pour un total de treize pour écrire "zerofoureight".$a(3) = 13$

Cela rend la cinquième entrée car il faut huit caractères supplémentaires pour écrire "onethree" pour un total de vingt et un pour écrire "zerofoureightonethree".$a(4) = 21$

...etc. Voici les 100 premières entrées:

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

_{* Nous pourrions le définir pour d'autres langues et / ou d'autres bases ou avec des espaces bien sûr}

Le défi

Étant donné sortie, dans le moins d'octets de code possible, l'un des éléments suivants:$n$

• Le premier$n$ termes de la séquence (devraient fonctionner pour les entiers non négatifs)
• La valeur de (devrait fonctionner pour les entiers non négatifs)$a(n)$
• Le ^ème terme de la séquence (devrait fonctionner pour les entiers positifs - c'est-à-dire la valeur de )$n$$a(n-1)$

Il s'agit de code-golf, donc la réponse la plus courte en octets gagne pour chaque langue, et la réponse la plus courte en octets gagne. Ne laissez pas les langues de golf vous empêcher d'entrer dans votre langue préférée, qu'elle soit pratique ou ésotérique!

Perl 6 , 45 octets

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

Essayez-le en ligne!

Pas besoin de modulo fantaisie lorsque vous pouvez obtenir le nom du chiffre directement! Bloc de code anonyme qui renvoie la nième valeur de la séquence, ou vous pouvez passer dans une plage pour obtenir une liste de valeurs

Explication:

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

Renvoie $a(n)$ .

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

Essayez-le en ligne!

Comment?

Un chiffre $d$ est converti en un nombre $n$ de lettres avec:

 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

Parce que le nombre est divisé en caractères numériques, nous pouvons traiter $d\times 100+10$ en ajoutant simplement $10$ (sous forme de concaténation de chaîne).

Stax , 14 13 octets

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

Exécuter et déboguer

L'aperçu clé ici est que le chiffre dnécessite l' ((4 - 2 * d) // 3) % 3 + 3orthographe des lettres. (C'est la division entière en python et le module non négatif de style python)

Pip , 21 octets

Lai+:$+4335443554@^Pi

Prend l'entrée $n$ comme argument de ligne de commande et sort les $n$ premiers termes. Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Tr@StringLength@IntegerName@IntegerDigits@#& répertorie les chiffres de # , convertit chacun d'eux en un nom anglais, compte la longueur et additionne les résultats. Beaucoup de choses défilent sur les listes, c'est très excitant. Ensuite, nous appliquons simplement la définition de manière itérative.

TIO se plaint de ne pas avoir de connexion Internet, mais je ne sais pas pourquoi, car elle trouve quand même la bonne réponse. Peut-être qu'il vérifie les mises à jour des noms d'entiers?

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

Nettoyer , 82 octets

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

Essayez-le en ligne!

05AB1E , 15 14 octets

ÎFD•16\|/•sSèOO

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

$f(input)$

Merci aux gars @The APL Orchard pour avoir aidé avec celui-ci:

@ngn pour 2 octets; @ H.PWiz pour 3 4 octets.

Maintenant, en utilisant la formule de @ recursive.

Comment:

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

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

Essayez-le en ligne!

Utilise le mappage du nombre de chiffres récursif .

Python 2 , 63 octets

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

Essayez-le en ligne!

Une version de fonction récursive. Il faut un temps exponentiel pour s'exécuter car il a deux appels récursifs vers f(n-1).

Python 2 , 71 octets

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

Essayez-le en ligne!

MathGolf , 17 octets

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

Essayez-le en ligne!

Cela utilise la méthode d'Arnauld . Sort le nième élément de la séquence. Si la chaîne vide est correcte a(0), alors nous pourrions supprimer le 0\au début.

Explication:

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 octets

u+Gs@L+L3jC\᯻3jGTQ0

Essayez-le en ligne ici .

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

Rubis , 54 octets

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

Essayez-le en ligne!

Java (JDK) , 95 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 82 octets

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

Essayez-le en ligne!

Gelée , 13 octets

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

Essayez-le en ligne!

0 indexé.

Programme complet; prend l'entrée de STDIN.

Rouge , 99 95 octets

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

Essayez-le en ligne!

Juste une solution simple.

J , 37 octets

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

Essayez-le en ligne!

Utilise la méthode d'Arnauld

Explication:

L'argument est 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

Modifié après le 1er commentaire.

Imprime tous les termes

Scala, 76 octets

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

Essayez-le en ligne!

Imprime n ^e terme

Scala, 72 octets

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

Scala, 69 octets

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

Scala, 67 octets

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

Scala, 67 octets

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

Essayez-le en ligne!