Diese Herausforderung basiert auf diesem Video . Ich empfehle, dass Sie es sehen, bevor Sie diese Herausforderung versuchen.

Zuerst definieren wir eine Funktion. Diese Funktion ( OEIS ) nimmt eine ganze Zahl n als Eingabe und gibt die Anzahl der Buchstaben in der englischen Darstellung von n aus (ohne Leerzeichen oder Bindestriche). Zum Beispiel "drei" hat 5 Buchstaben, also 3 Karten zu 5.

Wie im Video gezeigt, wird aus dem Wiederholen einer beliebigen Zahl schließlich eine Vier, die sich für immer auf sich selbst überträgt.

Hier ist eine grobe gerichtete Grafik, die die Umlaufbahnen der Zahlen unter 16 zeigt:

  12 11
    \|      
15 2 6 1 10 14 13
  \ \|/ /  /  /
   7 3-/  8--/
    \|   /
 9 0 5--/
  \ \|
   \-4

Ihre Herausforderung besteht darin, die Anzahl der Schritte zu bestimmen, die eine Zahl ausführen wird (oder wie oft diese Funktion auf eine Zahl angewendet werden muss), bevor Sie vier erreichen (dh die Stufe in der abgebildeten Grafik).

Englisch Zahlen bilden

Hier ist eine kurze Erklärung, wie man englische Wörter für diese Herausforderung bilden sollte:

Die Nummern eins bis neunzehn sind:

eins, zwei, drei, vier, fünf, sechs, sieben, acht, neun, zehn, elf, zwölf, dreizehn, vierzehn, fünfzehn, sechzehn, siebzehn, achtzehn, neunzehn

Für Zahlen größer als neunzehn ist der Prozess wie folgt:

Wenn die Zahl eine Hunderterstelle hat, beginnen Sie mit dem Namen der Ziffer in der Hunderterstelle und "Hundert".

z.B

100 -> "onehundred"

Wenn der Rest weniger als zwanzig beträgt, fügen Sie die englische Darstellung des Restes hinzu.

z.B

714 -> "sevenhundredfourteen"

Andernfalls, wenn die Zehnerstelle nicht Null ist, fügen Sie die richtige Darstellung hinzu:

2-> twenty
3-> thirty
4-> forty
5-> fifty
6-> sixty
7-> seventy
8-> eighty
9-> ninety

z.B

470 -> "fourhundredseventy"

Schließlich, wenn es eine eigene Ziffer gibt, wird deren Darstellung angehängt

z.B

681 -> "sixhundredeightyone"

Weitere Bestimmungen

• Bei Zahlen größer als einhundert sollten Sie das "und" weglassen, wenn Sie die Anzahl der Buchstaben zählen. Zum Beispiel ist 577 "fünfhundertseventyseven", das 23 Buchstaben hat.

• Ihr Programm muss alle Ganzzahlen größer als 0 und kleiner als 1.000 als Eingabe über Standardmethoden akzeptieren.

• Ihr Programm muss die Anzahl der Schritte ausgeben, die für Standardausgabemethoden erforderlich sind.

• Das ist Codegolf, also gewinnt die Lösung mit den wenigsten Bytes.

Testfälle

1 -> 3
4 -> 0
7 -> 2
23 -> 5
577 -> 6
600 -> 4 

JavaScript (ES6), 106 Byte

f=(n,a="03354435543668877998")=>n-4&&1+f(7*(n>99)-(-a[n/100|0]-(a[n%=100]||a[n%10])-"0066555766"[n/10|0]))

Strings scheinen der beste Weg zu sein, um die Länge zu kodieren, trotz des Overheads bei der numerischen Konvertierung.

Python mit num2words, 97 113 115 94 93 92 Bytes

+16 Bytes (die hyphenation vergessen , dass num2words gilt , die nicht tatsächlich , die Ergebnisse von den Testfälle ändern, obwohl 23und 577jeweils einen Bindestrich)
+2 Bytes (vergessen umfassen , f=obwohl rekursiv)
-20 Bytes (Verwendung re)
-8 Bytes dank @Wheat Wizard (verwenden ~, ersetzen n!=4durch n-4und ... einzeiliger Import> _ <)
-1 Bytes dank @Cyoce (Leerzeichen von 4 and)

import re,num2words as w
f=lambda n:n-4and-~f(len(re.sub('\W|and','',w.num2words(n))))

Zählt nur die Anzahl der Schritte auf; funktioniert auch für große und negative ganze Zahlen ( \Wfindet die Leerzeichen, Kommas und Bindestriche im Ergebnis von num2words):

>>> for test in (1,4,7,23,577,600,-1*2**96,3**96):
...     print('test: {0}  ->  {1}'.format(test, f(test)))
...
test: 1  ->  3
test: 4  ->  0
test: 7  ->  2
test: 23  ->  5
test: 577  ->  6
test: 600  ->  4
test: -79228162514264337593543950336  ->  4
test: 6362685441135942358474828762538534230890216321  ->  5

Hier ist der letzte Fall, Schritt für Schritt:

sixquattuordecillionthreehundredsixtytwotredecillionsixhundredeightyfiveduodecillionfourhundredfortyoneundecilliononehundredthirtyfivedecillionninehundredfortytwononillionthreehundredfiftyeightoctillionfourhundredseventyfourseptillioneighthundredtwentyeightsextillionsevenhundredsixtytwoquintillionfivehundredthirtyeightquadrillionfivehundredthirtyfourtrilliontwohundredthirtybillioneighthundredninetymilliontwohundredsixteenthousthreehundredtwentyone
fourhundredfiftyone
nineteen
eight
five

Pyth - 54 Bytes

Wird versuchen, umzugestalten.

KjC"Y©åláóê¤"Ttl.u?<NyT@KNs+V@LKJ_jNT[Z@jC"Ckg"ThtJ7

Test Suite .

Mathematica, 89 Bytes

Length@FixedPointList[StringLength@StringReplace[IntegerName@#,{" "->"","-"->""}]&,#]-2&

Typisches Mathematica: eingebaute Funktionen gut, lange Funktionsnamen schlecht. FixedPointListWendet das erste Argument (eine Funktion) wiederholt auf das zweite Argument an, bis sich die Antwort nicht mehr ändert, und listet alle Ergebnisse auf. Die Ergebnisse enthalten die ursprüngliche Eingabe und zwei Kopien der wiederholten Ausgabe, daher die-2 am Ende. Die eingebaute Mathematica IntegerNameenthält Leerzeichen und Bindestriche, daher müssen wir diese von Hand entfernen.

Ärgerlicherweise IntegerNameenthält die Ausgabe des Dokuments das Zeichen "-" (Unicode # 8208) und keine normalen Bindestriche. Aus diesem Grund hat diese Übermittlung statt 88 nur 89 Byte. (Und ich konnte dem obigen Code keine vier Leerzeichen voranstellen und das Unicode-Zeichen akzeptieren - eine Hilfe? -, sodass der obige Code nicht genau richtig funktioniert, wenn er ausgeschnitten und eingefügt wird .)

Python 2.7, 344 216 208 Bytes:

x=`input()`;c=0;y=lambda v:dict(zip(range(0,10),[0]+v));l=[3,3,5,4,4,3,5,5,4];d=y(l);e=y([3,6,6,6,5,5,7,7,6]);f=y([i+7for i in l])
while x!='4':x=`sum([q[int(r)]for q,r in zip([d,e,f],x[::-1])])`;c+=1
print c

Verwendet im Gegensatz zu anderen Python-Antworten keine externen Bibliotheken. Nimmt Ein- stdinund Ausgänge auf stdout.

Repl.it mit allen Testfällen!

Erläuterung

Zunächst werden 3 Wörterbücher erstellt, wobei jedes die Länge der englischen Wortrepräsentationen jeder Zahl mit der Zahl paart, die es in dem geschlossenen Intervall [1,9]an den Stellen Eins, Zehn bzw. Hundert darstellt. Zum Beispiel kann der erste Eintrag im Wörterbuch dist 1:3wie 1geschrieben ist onein Englisch und hat 3Buchstaben.

Dann wird jede Ziffernstelle in einer Zeichenfolgeeingabe xihrem entsprechenden Wörterbuch zugewiesen, wonach jede Zahl an jeder Stelle mit ihrem Wert im entsprechenden Wörterbuch abgeglichen wird. Angenommen, die eingegebene Nummer war 23. Die Stelle 20an der Zehnerstelle würde mit dem Wörterbuch gepaart, mit edem es abgeglichen wird 6, und die Stelle 3an der Einerstelle würde mit dem Wörterbuch gepaart, mit ddem es abgeglichen wird 5. Diese übereinstimmenden Ziffern werden dann addiert, um die Länge der englischen Darstellung der Nummer darzustellen, die xals Zeichenfolge zugewiesen ist, und, solange x!='4'die while-Schleife fortgesetzt wird, inkrementiert cum1jedes Mal, um die Anzahl der bisher durchgeführten Schritte darzustellen. Daher 23würde entsprechen 11, was wiederum entsprechen 6würde, sich zu wenden 3und dann zu 5und schließlich zu 4, was zu 5Gesamtschritten führen würde.

Schließlich wird, sobald die Schleife beendet cist, ausgegeben, stdoutum den "Abstand zu vier" darzustellen, der in diesem Fall sein würde 5.

Java, 556 295 Bytes

Vielen Dank an @KevinCruijssen für das Speichern von 261 Bytes

  void int(n) {int s[]={0,3,3,5,4,4,3,5,5,4,3,6,6,8,8,7,7,9,9,8,6,9,9,11,10,6,6,5,5,7,7,6};int c=0,t=(int)Math.pow(10,(int)Math.log10(n)),v=1;while(n>0){if(n/100>0)c+=(s[n/100]+7);else {if(n>0&n<25){c+=s[n];break;}else{c+=s[(n/10)+22];}}n=n%t;t=t/10;}while(c!=4){v++;c=s[c];}System.out.print(v);}

Ungolfed:

  void int(n) {

    int s[]={0,3,3,5,4,4,3,5,5,4,3,6,6,8,8,7,7,9,9,8,6,9,9,11,10,6,6,5,5,7,7,6};
     int c=0,t=(int)Math.pow(10,(int)Math.log10(n)),v=1;
         while(n>0){
            if(n/100>0)
                c+=(s[n/100]+7);
            else {if(n>0&n<25){
                c+=s[n];
            break;
            }
            else{
                c+=s[(n/10)+22];

            }
            }
            n=n%t;
            t=t/10;
        }

        while(c!=4)
        {
            v++;
        c=s[c];
        }
System.out.print(v);
}