Hier ist eine einigermaßen triviale Sequenz, die nicht in der Online Encyclopedia of Integer Sequences enthalten ist .

Beginnen Sie mit einer leeren Sequenz und definieren Sie dann jeden Begriff als die Anzahl der Zeichen, die erforderlich sind, um auf Englisch alle Ziffern der Sequenz ohne Leerzeichen zu schreiben. *

Als Referenz ist die Anzahl der Zeichen aller (zehn Basis-) Ziffern in Englisch wie folgt:

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

( Dies ist der Start von A52360 und A5589 .)

Dies macht den ersten Eintrag zu $a(0) = 0$ da in der leeren Sequenz null Stellen vorhanden sind.

Dies macht den zweiten Eintrag zu $a(1) = 4$ da es vier Zeichen braucht, um "Null" zu schreiben, die einzige bisher vorhandene Ziffer.

Dies macht den dritten Eintrag zu $a(2) = 8$ da vier weitere Zeichen erforderlich sind, um die "Vier" zu schreiben, während insgesamt acht Zeichen erforderlich sind, um "Null" zu schreiben.

Dies macht den vierten Eintrag zu $a(3) = 13$ da fünf weitere Zeichen erforderlich sind, um "acht" zu schreiben, während insgesamt dreizehn Zeichen erforderlich sind, um "null - acht" zu schreiben.

Dies macht den fünften Eintrag zu $a(4) = 21$ da acht weitere Zeichen erforderlich sind, um "eins" zu schreiben, während insgesamt einundzwanzig Zeichen erforderlich sind, um "null - acht - drei" zu schreiben.

...und so weiter. Hier sind die ersten 100 Einträge:

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

_{* Wir könnten es für andere Sprachen und / oder andere Basen oder natürlich mit Leerzeichen definieren}

Die Herausforderung

Wenn $n$ ausgegeben wird, kann in so wenigen Byte Code wie möglich Folgendes ausgeführt werden:

• Die ersten $n$ Terme der Sequenz (sollten für nicht negative ganze Zahlen funktionieren)
• Der Wert von $a(n)$ (sollte für nicht negative ganze Zahlen funktionieren)
• Der $n$ ^te Term der Sequenz (sollte für positive ganze Zahlen funktionieren - dh Wert von $a(n-1)$ )

Dies ist Codegolf, also gewinnt die kürzeste Antwort in Bytes für jede Sprache und die kürzeste Antwort in Bytes. Lassen Sie sich nicht von Golfsprachen davon abhalten, in Ihre Lieblingssprache einzutreten, sei es eine praktische oder eine esoterische!

Perl 6 , 45 Bytes

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

Probieren Sie es online!

Es ist kein ausgefallenes Modulieren erforderlich, wenn Sie den Namen der Ziffer direkt abrufen können! Anonymer Codeblock, der den n-ten Wert der Sequenz zurückgibt, oder Sie können einen Bereich übergeben, um eine Werteliste abzurufen

Erläuterung:

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

Gibt $a(n)$ .

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

Probieren Sie es online!

Wie?

Eine Ziffer $d$ wird in eine Anzahl $n$ von Buchstaben umgewandelt mit:

 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

Da die Zahl in Ziffern aufgeteilt ist, können wir $d\times 100+10$ indem wir einfach $10$ addieren (als Zeichenfolgenverkettung).

Stax , 14 13 Bytes

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

Führen Sie es aus und debuggen Sie es

Die wichtigste Erkenntnis hier ist, dass für die Eingabe dvon Ziffern ((4 - 2 * d) // 3) % 3 + 3Buchstaben erforderlich sind . (Das ist Python-Ganzzahl-Division und nicht-negativer Modul im Python-Stil.)

Pip , 21 Bytes

Lai+:$+4335443554@^Pi

$n$$n$

Erläuterung

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

Probieren Sie es online!

Tr@StringLength@IntegerName@IntegerDigits@#&listet die Ziffern von auf #, konvertiert sie in einen englischen Namen, zählt die Länge und summiert die Ergebnisse. Viele Dinge laufen über Listen, es ist sehr aufregend. Dann wenden wir die Definition einfach iterativ an.

TIO beschwert sich, dass es keine Internetverbindung gibt, aber ich weiß nicht warum, weil es sowieso die richtige Antwort findet. Vielleicht wird nach Updates für die Namen von ganzen Zahlen gesucht?

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

Sauber , 82 Bytes

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

Probieren Sie es online!

05AB1E , 15 14 Bytes

ÎFD•16\|/•sSèOO

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Dfn. Druckt$f(input)$

Vielen Dank an die Jungs von The APL Orchard für ihre Hilfe:

@ngn für 2 Bytes; @ H.PWiz für 3 4 Bytes.

Verwenden Sie jetzt die Formel von @ recursive.

Wie:

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

Probieren Sie es online!

Verwendet die rekursive Ziffernanzahlzuordnung .

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

Probieren Sie es online!

Eine rekursive Funktionsversion. Die Ausführung nimmt exponentiell viel Zeit in Anspruch, da es zwei rekursive Aufrufe von gibt 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

Probieren Sie es online!

MathGolf , 17 Bytes

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

Probieren Sie es online!

Dies verwendet die Methode von Arnauld . Gibt das n-te Element der Sequenz aus. Ist die leere Zeichenfolge in Ordnung füra(0) , können wir den 0\am Anfang entfernen .

Erläuterung:

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

Probieren Sie es hier online aus .

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}

Probieren Sie es 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;}

Probieren Sie es 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

Probieren Sie es online!

Jelly , 13 Bytes

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

Probieren Sie es online!

0-indiziert.

Volles Programm; Nimmt Eingaben von STDIN entgegen.

Rot , 99 bis 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)]]]

Probieren Sie es online!

Nur eine einfache Lösung.

J , 37 Bytes

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

Probieren Sie es online!

Wendet die Methode von Arnauld an

Erläuterung:

Das Argument ist 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

Bearbeitet nach dem 1. Kommentar.

Druckt alle Begriffe

Scala, 76 Bytes

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

Probieren Sie es online!

Drucke n ^th Ausdruck aus

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)

Probieren Sie es online!