Tor

Schreiben Sie ein Programm oder eine Funktion, die eine numerische Telefonnummer in einen Text übersetzt, der das Sprechen erleichtert. Wenn Ziffern wiederholt werden, sollten sie als "double n" oder "triple n" gelesen werden.

Bedarf

Eingang

Eine Folge von Ziffern.

• Angenommen, alle Zeichen sind Ziffern von 0 bis 9.
• Angenommen, die Zeichenfolge enthält mindestens ein Zeichen.

Ausgabe

Durch Leerzeichen getrennte Wörter, wie diese Ziffern laut vorgelesen werden können.

• Ziffern in Wörter übersetzen:

  0 "oh"
  1 "eins"
  2 "zwei"
  3 "drei"
  4 "vier"
  5 "fünf"
  6 "sechs"
  7 "sieben"
  8 "acht"
  9 "neun"

• Wenn dieselbe Ziffer zweimal hintereinander wiederholt wird, geben Sie "double number " ein.

• Wenn die gleiche Ziffer dreimal hintereinander wiederholt wird, schreiben Sie "dreifache Zahl ".
• Wenn die gleiche Ziffer vier oder mehr Mal wiederholt wird, schreiben Sie für die ersten beiden Ziffern "double number " und werten Sie den Rest der Zeichenfolge aus.
• Zwischen jedem Wort befindet sich genau ein Leerzeichen. Ein einzelnes vorangestelltes oder nachfolgendes Leerzeichen ist zulässig.
• Bei der Ausgabe wird nicht zwischen Groß- und Kleinschreibung unterschieden.

Wertung

Quellcode mit den wenigsten Bytes.

Testfälle

input        output
-------------------
0123         oh one two three
4554554      four double five four double five four
000          triple oh
00000        double oh triple oh
66667888     double six double six seven triple eight
19999999179  one double nine double nine triple nine one seven nine

05AB1E , 53 52 51 50 49 Bytes

γε€T2äθ¬MÊi¨₃1ǝR]˜“Šç€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‹¶½¿“#s踻

Probieren Sie es online!

Erläuterung:

γ                      # split input in groups of consecutive equal digits
 ε              ]      # for each group
  €T                   #  add a 10 before each digit (66 -> [10, 6, 10, 6])
    2äθ                #  keep only the second half of that list
       ¬MÊi     ]      #  if the first element is not the maximum
           ¨           #   drop the last element
            ₃1ǝ        #   replace the second element with 95
               R       #   reverse the list
˜                      # flatten
 “...“                 # compressed string: "oh one two ... nine double triple"
      #                # split on spaces
       sè              # index (wraps around, so 95 yields "triple")
         ¸»            # join with spaces

8088 Assembly, IBM PC DOS, 164 159 156 155 Bytes

Binär:

00000000: d1ee 8a0c 03f1 53fd ac3a d075 0343 e2f7  ......S..:.u.C..
00000010: 85db 741c 5f8a d043 f6c3 0174 0a57 bd64  ..t._..C...t.W.d
00000020: 0155 83eb 0374 0957 bd5d 0155 4b4b 75f7  .U...t.W.].UKKu.
00000030: 8ad0 2c2f 7213 518a f0b0 24b1 31bf 6a01  ..,/r.Q...$.1.j.
00000040: fcf2 aefe ce75 fa59 57e2 bc5a 85d2 740c  .....u.YW..Z..t.
00000050: b409 cd21 b220 b402 cd21 ebef c364 6f75  ...!. ...!...dou
00000060: 626c 6524 7472 6970 6c65 246f 6824 6f6e  ble$triple$oh$on
00000070: 6524 7477 6f24 7468 7265 6524 666f 7572  e$two$three$four
00000080: 2466 6976 6524 7369 7824 7365 7665 6e24  $five$six$seven$
00000090: 6569 6768 7424 6e69 6e65 24              eight$nine$

Erstellen und testen Sie die ausführbare Datei xxd -rvon oben oder laden Sie PHONE.COM herunter .

Zerlegte Auflistung:

D1 EE       SHR  SI, 1              ; point SI to DOS PSP (80H) for input string
8A 0C       MOV  CL, BYTE PTR[SI]   ; load input string length into CX
03 F1       ADD  SI, CX             ; move SI to end of input 
53          PUSH BX                 ; push a 0 to signal end of output stack 
        CHAR_LOOP:
FD          STD                     ; set LODS direction to reverse 
AC          LODSB                   ; load next char from [SI] into AL, advance SI 
3A D0       CMP  DL, AL             ; is it same as previous char? 
75 03       JNZ  NEW_CHAR           ; if not, it's a different char 
43          INC  BX                 ; otherwise it's a run, so increment run length
E2 F7       LOOP CHAR_LOOP          ; move on to next char 
        NEW_CHAR: 
85 DB       TEST BX, BX             ; is there a run greater than 0? 
74 1C       JZ   GET_WORD           ; if not, look up digit name 
5F          POP  DI                 ; get name for the current digit 
8A D0       MOV  DL, AL             ; save current char in DL 
43          INC  BX                 ; adjust run count (BX=1 means run of 2, etc)
F6 C3 01    TEST BL, 1              ; is odd? if so, it's a triple
74 0A       JZ   IS_DBL             ; is even, so is a double 
57          PUSH DI                 ; push number string ("one", etc) to stack
BD 0164     MOV  BP, OFFSET T       ; load "triple" string 
55          PUSH BP                 ; push to stack 
83 EB 03    SUB  BX, 3              ; decrement run count by 3 
74 09       JZ   GET_WORD           ; if end of run, move to next input char 
        IS_DBL: 
57          PUSH DI                 ; push number string to stack
BD 015D     MOV  BP, OFFSET D       ; load "double" string 
55          PUSH BP                 ; push to stack 
4B          DEC  BX                 ; decrement by 2
4B          DEC  BX
75 F7       JNZ  IS_DBL             ; if not end of run, loop double again 
        GET_WORD: 
8A D0       MOV  DL, AL             ; save current char into DL
2C 2F       SUB  AL, '0'-1          ; convert ASCII char to 1-based index 
72 13       JB   NOT_FOUND          ; if not a valid char, move to next
51          PUSH CX                 ; save outer loop counter 
8A F0       MOV  DH, AL             ; DH is the index to find, use as scan loop counter
B0 24       MOV  AL, '$'            ; word string is $ delimited
B1 31       MOV  CL, 031H           ; search through length of word data (49 bytes)
BF 016A     MOV  DI, OFFSET W       ; reset word data pointer to beginning
FC          CLD                     ; set DF to scan forward for SCAS 
        SCAN_LOOP: 
F2/ AE      REPNZ SCASB             ; search until delimiter '$' is found in [DI]
FE CE       DEC  DH                 ; delimiter found, decrement counter 
75 FA       JNZ  SCAN_LOOP          ; if counter reached 0, index has been found 
59          POP  CX                 ; restore outer loop position
57          PUSH DI                 ; push string on stack 
        NOT_FOUND:
E2 BC       LOOP CHAR_LOOP          ; move to next char in input 
        OUTPUT_STACK: 
5A          POP  DX                 ; get string from top of stack 
85 D2       TEST DX, DX             ; it is the last? 
74 0C       JZ   EXIT               ; if so, exit 
B4 09       MOV  AH, 09H            ; DOS display string function 
CD 21       INT  21H                ; write string to console 
B2 20       MOV  DL, ' '            ; load space delimiter 
B4 02       MOV  AH, 02H            ; DOS display char function 
CD 21       INT  21H                ; write char to console 
EB EF       JMP  OUTPUT_STACK       ; continue looping 
        EXIT: 
C3          RET                     ; return to DOS 

D   DB "double$" 
T   DB "triple"
W   DB "$oh$","one$","two$","three$","four$","five$","six$","seven$","eight$","nine$" 

TL; DR:

Die Eingabezeichenfolge wird von rechts nach links gelesen, um das Auffinden eines Tripels zu erleichtern. Die Ausgabe wird auf den x86-Stapel geschoben , um das Umkehren der Anzeigereihenfolge und das Neuanordnen der Wörter "double" und "triple" vor dem Ziffernnamen zu vereinfachen.

Wenn sich die nächste Ziffer von der letzten unterscheidet, wird der Name in der Wortliste nachgeschlagen und auf den Stapel verschoben. Da es kein formales Konzept für ein "indiziertes Array von Zeichenfolgen variabler Länge" im Maschinencode gibt, wird die Liste der Wörter i(der Wortindex) so oft gescannt, bis der Zeichenfolgenbegrenzer ( $) das entsprechende Wort gefunden hat. Hilfreich ist, dass x86 ein paar kurze Anweisungen hat ( REPNZ SCASBähnlich wie memchr()in C), die dies vereinfachen (danke CISC !).

Wenn die Ziffer mit der vorherigen identisch ist, wird der Zähler für die Länge eines "Laufs" inkrementiert und die Schleife am Eingang nach links fortgesetzt. Sobald der Lauf beendet ist, wird der Name der Ziffer vom Stapel genommen, da er für jede Gruppierung nach dem "Doppel" oder "Dreifach" gesetzt werden muss. Wenn die Lauflänge ungerade ist (und die Lauflänge ungerade ist > 1), wird der Name der Ziffer, gefolgt von der Zeichenfolge "Triple", in den Stapel verschoben und die Lauflänge um 3 verringert. Da die Lauflänge jetzt gerade ist, ist der Schritt wird für "double" wiederholt, bis die Lauflänge 0 ist.

Wenn die Eingabezeichenfolge das Ende erreicht hat, wird der Stapel ausgegeben, wobei jede gespeicherte Zeichenfolge in umgekehrter Reihenfolge auf den Bildschirm geschrieben wird.

I / O:

Eine eigenständige ausführbare PC-DOS-Datei, die über die Befehlszeilenausgabe an die Konsole eingegeben wird.

Laden Sie PHONE.COM herunter und testen Sie es .

05AB1E , 61 56 53 52 51 Bytes

γvyDg;LàäRv… ‹¶½¿#yg蓊瀵‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“#yè])áðý

-9 Bytes dank @Grimy .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

γ               # Split the (implicit) input into substrings of equal adjacent characters
                #  i.e. "199999991779" → ["1","9999999","1","77","9"]
 v              # Loop over each substring `y`:
   Dg           #  Get the length of a copy of the substring
     ;          #  Halve it
      L         #  Create a list in the range [1, length/2], where odd lengths are
                #  automatically truncated/floored
                #   i.e. "1" (length=1) → 0.5 → [1,0]
                #   i.e. "9999999" (length=7) → 3.5 → [1,2,3]
       à        #  Pop and push the maximum of this list
  y     ä       #  Divide the string into that many parts
                #   → ["1"]
                #   → ["999","99","99"]
         R      #  Reverse the list
                #   → ["99","99","999"]
  v             # Inner loop over each item `y`:
   … ‹¶½¿       #  Push dictionary word: "  double triple"
         #      #  Split it on spaces: ["","","double","triple"]
          yg    #  Get the length of the current item `y`
            è   #  And use it to (0-based) index into the list
   “Šç€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“
                #  Push dictionary string "oh two three four five six seven eight nine"
     #          #  Split it on spaces: ["oh","two","three",...,"nine"]
      yè        #  Use `y` to index into the string-list (with automatic wrap-around,
                #  so since there are 10 words, it basically indexes with a single digit
                #  due to an implicit modulo-10)
                #   i.e. "77" → "seven"
 ]              # Close both loops
  )             # Wrap all values on the stack into a list
   á            # Only keep letters, which removes the empty strings from the list
    ðý          # And join the list on spaces
                # (after which the result is output implicitly)

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie verwende ich das Wörterbuch? ) An, um zu verstehen, warum es … ‹¶½¿ist " double triple"und “Šç€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“ist "oh two three four five six seven eight nine".

QuadR , 137 Byte ^SBCS

Titeletui mit einem führenden Leerzeichen.

∊¯2↑¨@(∊∘⎕A)⍵
(.)\1*
{⍺←(,¨⎕D)⎕R('OhOneTwoThreeFourFiveSixSevenEightNine'(∊⊂⊣)⎕A)⋄' '∊w←⍺,⊃⍵:⍬⋄1=≢⍵:⍺⍵⋄3=≢⍵:'Triple',w⋄'Double',w,∇2↓⍵}⍵M

Probieren Sie es online!

∊ ϵ nlist (flatten)
¯2↑¨ nimm die letzten zwei Zeichen (links mit einem Leerzeichen aufgefüllt ) von jedem Zeichen
@ an Positionen, an denen
(∊∘⎕A) Zeichen Mitglieder des Großbuchstaben A lphabet sind,
⍵ als Ergebnis der folgenden PCRE-Ersetzungsoperation…

(.) Jedes Zeichen,
\1 dem
* null oder mehrmals ein Zeichen folgt , wird durch das folgende Ergebnis ersetzt:

{…}⍵M "dfn"; ⍵ist der M atch des obigen Musters

 ('OhOneTwoThreeFourFiveSixSevenEightNine'(... )⎕A) die folgende anonyme stillschweigende Funktion mit der langen Schnur und die Groß gelten A lphabet als linke Argumente:

 ∊ Mitgliedschaft (von Buchstaben in der langen Zeichenkette in Großbuchstaben)

 ⊂ Partitionen (mit einer neuen Partition, die beginnt, wenn sie Mitglied ist

 ⊣ das linke Argument (dh die lange Zeichenkette)

(... )⎕R PCRE R eplace folgende Muster mit diesen Worten:

 ⎕D die Ziffern 0 bis 9

 ,¨ Behandle jedes als ein separates Muster

⍺←Weisen Sie  diese Ersatzfunktion zu ⍺(für ein Lphabetise)

⋄ dann,

⊃⍵ das erste Zeichen des Spiels

, als Zeichenfolge

⍺ anwenden , ⍺um es

w← ordne dies zu w(für Wort )

' '∊… : Wenn Space Mitglied ist (dh wenn das Match leer war):

 ⍬ nichts zurückgeben (wird zur leeren Zeichenkette)

⋄ sonst,

1=≢⍵: Wenn man der Anzahl der Zeichen in der Übereinstimmung entspricht (dh der Länge):

 ⍺⍵ Alphabetisieren Sie diese Ziffer

⋄ sonst,

3=≢⍵: wenn drei gleich der Anzahl der Zeichen in der Übereinstimmung ist (dh ihre Länge):

 'Triple',w prepend "Triple" , um die w ord

⋄ sonst,

2↓⍵ fallen auf Ziffern aus dem Match

∇ darauf zurückgreifen

w, das Wort voranstellen

'Double', "Double" voranstellen

JavaScript (ES6),  161 160 152  144 Byte

Die Ausgabe enthält ein einzelnes führendes Leerzeichen.

s=>[n=>' '+'oh/one/two/three/four/five/six/seven/eight/nine'.split`/`[n],'$1 double$2','triple$2'].map(r=>s=s.replace(/(\S*)( \S+)\2|\d/g,r))&&s

Probieren Sie es online!

oder Siehe den formatierten Quellcode

Wie?

Die Konvertierung erfolgt in drei Schritten:

1. Ersetzen Sie jede Ziffer durch das entsprechende englische Wort, dem ein Leerzeichen vorausgeht
2. Ersetzen Sie jedes Muster "X X"durch"double X"
3. Ersetzen Sie jedes Muster "double X X"durch"triple X"

Um Bytes zu sparen, verwenden wir für alle Schritte den gleichen regulären Ausdruck:

/(\S*)( \S+)\2|\d/g

was wie folgt funktioniert:

(\S*)  -> 1st capturing group: any word, or nothing at all
( \S+) -> 2nd capturing group: a space, followed by a word
\2     -> a copy of the 2nd capturing group
|\d    -> or try to capture a digit instead (for step 1)

In Schritt 1 verwenden wir eine Rückruffunktion, die das richtige Wort aus einer Nachschlagetabelle auswählt:

• "799999" → " seven nine nine nine nine nine"

In Schritt 2 ersetzen wir durch "$1 double$2":

• " (seven)( nine)( nine)" → " seven double nine"
• "( nine)( nine) nine" → " double nine nine"

In Schritt 3 ersetzen wir durch "triple$2":

• " (double)( nine)( nine)" → " triple nine"

Wolfram-Sprache (Mathematica) , 115 Bytes

{Switch[L=Tr[1^{##}],1," ",3," triple ",_," double "],If[#<1,"oh",IntegerName@#],If[L>3,#0@##3,""]}&@@@Split@#<>""&

Probieren Sie es online!

Nimmt eine Ziffernliste als Eingabe. Die Ausgabe enthält ein führendes Leerzeichen.

Stax , 56 Bytes

ÇÖ◘⌡¿╒ô╞Γ▓8m☻t7♦3├(Ä⌂≤(┬Ω☻9▲ç╕C╞⌡òσ╗─╣╥─☻╪▼⌡5■ÿ,(┬¥?☺÷•±

Führen Sie es aus und debuggen Sie es

Python 2 , 171 169 168 Bytes

s=input()
while s:c=s[0];n=(s[1:2]==c)+(s[:3]==c*3!=s[1:4]);print'   eellpbiurotd'[-n:0:-2]+'oh one two three four five six seven eight nine'.split()[int(c)],;s=s[1+n:]

Probieren Sie es online!

_{-1 Byte, danke an Jitse}

Perl 5 -p , 111 Bytes

s/(\d)\1/ double$1/g;s/\w+(\d)\1/triple$1/g;s/\d/' '.qw(oh one two three four five six seven eigth nine)[$&]/ge

Probieren Sie es online!

Erläuterung:

s/(\d)\1/ double$1/g; # Replace non-overlapping double digits with " double<digit>"
s/\w+(\d)\1/triple$1/g; # Replace remaining double digits preceded by "double" with "triple<digit>"
s/\d/' '.qw(oh one two three four five six seven eigth nine)[$&]/ge # Replace digits with " <word>"

Scala , 213 Bytes

Ich habs. Irgendwie war die rekursive Version, die ich zu erstellen versuchte, viel ausführlicher als diese (immer noch rekursiv, aber nur in einem Fall). Die Funktion fnimmt die Telefonnummer als Eingabezeichenfolge und gibt ihre Phonetik mit einem nachgestellten Leerzeichen aus.

var u="oh one two three four five six seven eight nine" split " "
"(.)\\1*".r.replaceAllIn(s,x=>{var o=x.matched
var k=u(o(0)-48)+" "
o.length match{case 3=>"triple "+k
case 1=>k
case _=>"double "+k+f(o drop 2)}})

Probieren Sie es online!
Edit : -8b dank DrY Wit!

Scala , 215 Bytes

Und hier kommt die führende Whitespace-Version, die aus irgendeinem Grund zwei Bytes länger ist (auch bei massivem Refactoring).

var u="oh one two three four five six seven eight nine" split " "
"(.)\\1*".r.replaceAllIn(s,x=>{var o=x.matched
var k=u(o(0)-48)
" , double , triple ".split(",")(if(o.length>3){k+=f(o drop 2);1}else o.length-1)+k})

Probieren Sie es online!

PHP , 174 169 166 159 Bytes

for(;$s=strspn($argn,$d=$argn[$i],$i++);$s==3?($i+=2)+print'triple ':$s<2?:++$i+print'double ',print[oh,one,two,three,four,five,six,seven,eight,nine][$d].' ');

Probieren Sie es online!

Für jede Ziffer bei Index $iab 0:

• Wenn die Spanne der gleichen Ziffer ab Position von $igleich 3 ist, wird gedruckt 'triple 'und zu 2 addiert, $isodass bei der nächsten Iteration 2 Stellen übersprungen werden.
• Wenn die Spanne der gleichen Ziffer ab Position von $imindestens 2, aber nicht 3 beträgt, wird 1 gedruckt 'double 'und zur $inächsten Iteration hinzugefügt, sodass 1 Ziffer übersprungen wird.
• Gibt ein Wort für die Ziffer und ein Leerzeichen aus.
• $i++.

Retina 0,8,2 , 105 Bytes

+`(.)\1
=$1
.
 $&
= =
triple
=
double
9
nine
8
eight
7
seven
6
six
5
five
4
four
3
three
2
two
1
one
0
oh

Probieren Sie es online! Gibt ein führendes Leerzeichen aus. Erklärung: Ich habe ursprünglich versucht, eine Regex zu verwenden, die automatisch mit 2 oder 3 Ziffern übereinstimmt, aber der Ansatz von @ Arnauld erwies sich als golferisch. Erläuterung:

+`(.)\1
=$1

Ordnen Sie identische Ziffernpaare zu und ersetzen Sie die erste durch a =. Dann wiederholen, so dass bei einer ungeraden Zahl auch die vorletzte Ziffer durch a ersetzt wird =.

.
 $&

Leert die Ziffern (und =s) aus.

= =
triple

Behandeln Sie den Fall von drei identischen Ziffern.

=
double
9
nine
8
eight
7
seven
6
six
5
five
4
four
3
three
2
two
1
one
0
oh

Ersetzen Sie alle verbleibenden Zeichen durch Wörter.

Jelly , 59 Bytes

⁵;`,0;$Ɗ€Ẏ;`Ø0ṭ;-œṣjƭƒV€‘$ị“¡ıc⁴Ṛ⁽]@ɱ2¦Ż©Ẉḷ$Æ!)ɗ[ı8ɱḃ%ċ»Ḳ¤K

Probieren Sie es online!

Eine monadische Verknüpfung, die eine Zeichenfolge aus Ziffern als Argument verwendet und eine Jelly-Zeichenfolge aus durch Leerzeichen getrennten Wörtern zurückgibt. Beim Aufruf als Vollprogramm erfolgt die Ausgabe implizit.

T-SQL 2017, 238 Byte

Einige Zeilenumbrüche hinzugefügt, um die Lesbarkeit zu verbessern

WHILE''<left(@,1)SELECT @=stuff(@,1,iif(p<4,p,2),'')+
iif(p=1,' ',iif(p=3,' triple ',' double '))
+trim(substring('oh  one  two  threefour five six  seveneightnine',left(@,1)*5,5))
FROM(SELECT~-patindex('%[^'+left(@,1)+']%'+'^',@)p)z
PRINT @

Probieren Sie es online aus

C ++, 382 Bytes

Es ist kein Superclever, aber jemand musste eine C ++ - Version schreiben. Die rekursive Funktion R durchläuft die Eingabezeichenfolge und zählt die wiederholten Werte. Wenn es mehr als 3 Wiederholungen gibt, wird so getan, als ob es 2 Wiederholungen gäbe, dann wird zurückgespult und es wird erneut versucht.

Ein paar weitere Quell-Zeichen könnten wahrscheinlich mit #defineMajor herausgedrückt werden, aber ich bin sicher, dass ein besserer Algo mehr herausdrücken könnte.

#include <iostream>
#include <sstream>
using namespace std;
char*n[]={"oh","one","two","three","four","five","six","seven","eight","nine"};
void R(ostream& s,const char*r,char p='x',int c=0){if(*r==p)R(s,r+1,p,c+1);else
{if(c>1){if(c>= 4){s<<"double ";r-=(c-2);}else if(c==3)s<< "triple ";else if(c==2)s<< "double ";
}if(c >0)s<<n[p-'0']<<" ";if(!*r)return;R(s,r+1,*r,1);}}

void check(const char* in, const char* out)
{
    std::stringstream ss;
    R(ss,in);
    if (out == ss.str()) std::cout << "PASS: "; else std::cout << "FAIL! ";
    std::cout << in << "\n< " << out << "\n> " << ss.str() << std::endl;
}

int main(int c,char**argv)
{
    if (argv[1] == std::string("test"))
    {
        check("0123"         ,"oh one two three ");
        check("4554554"      ,"four double five four double five four ");
        check("000"          ,"triple oh ");
        check("00000"        ,"double oh triple oh ");
        check("66667888"     ,"double six double six seven triple eight ");
        check("19999999179"  ,"one double nine double nine triple nine one seven nine ");
    }
    else
    {
        char* v = argv[1];
        R(std::cout,v);
        std::cout << std::endl;
    }
}

und Verifikation von Testfällen:

pa-dev01$ ./a.out test
PASS: 0123
< oh one two three
> oh one two three
PASS: 4554554
< four double five four double five four
> four double five four double five four
PASS: 000
< triple oh
> triple oh
PASS: 00000
< double oh triple oh
> double oh triple oh
PASS: 66667888
< double six double six seven triple eight
> double six double six seven triple eight
PASS: 19999999179
< one double nine double nine triple nine one seven nine
> one double nine double nine triple nine one seven nine

Perl 6 , 96 93 Bytes

{S:g/(.)$0?[$0{}<!$0>]?/{(<triple double>X$)[3-$/.comb]}{+$/??uniname(~$0).words[1]!!'oh'} /}

Probieren Sie es online!

Dies ist ein anonymer Codeblock, der eine Zahl akzeptiert und eine Zeichenfolge mit den Zahlen in Großbuchstaben zurückgibt, z. B. 0123 => oh ONE TWO THREEmit einem einzelnen nachgestellten Leerzeichen.

Dies wurde für eine Weile gelöscht, bis ich herausfand, wie man Captures in einem Lookahead verwendet, aber es sollte jetzt behoben werden.

rot , 242 Bytes

func[s][b:[copy t skip t]parse s[any[change[b t ahead not t](rejoin["triple "t])|
change b(rejoin["double "t])| skip]]foreach c s[prin either i:
find"0123456789"c[rejoin[pick[:oh:one:two:three:four:five:six:seven:eight:nine]index? i" "]][c]]]

Probieren Sie es online!

Scala , 253 Bytes

def g(s:String):String={val t="oh one two three four five six seven eight nine".split(" ")(s(0)-48)
s.length match{case 3=>"triple "+t;case 2=>"double "+t;case 1=>t;case _=>"double "+t+" "+g(s drop 2)}}
s=>"(.)\\1*".r.findAllIn(s).map(g(_)) mkString " "

Probieren Sie es online!

Oracle SQL, 578 Bytes (in formatierter Form)

Die Lösung ist in keiner Weise präzise, ​​so dass sie in formatierter Form veröffentlicht wird.

with r(s) as
(select x from t
  union all
 select case
           when length(regexp_substr(s, '(.)(\1)+')) = 3 
           then regexp_replace(s, '^...')
           else regexp_replace(s, '^(.)\1|^.')
        end
   from r
  where s is not null)
select listagg(decode(length(r),  2, 'double ',  3, 'triple ') ||
               decode(substr(r, 1, 1), 0, 'oh', to_char(to_date(substr(r, 1, 1), 'j'), 'jsp')), ' ')
               within group (order by rownum)
  from (select regexp_replace(s, lag(s) over (order by length(s)) || '$') r
          from r order by length(s) desc);

Testen Sie in SQL * Plus

SQL> create table t(x) as select /*'45547777777774'*/ '1999999910079' from dual;

Table created.

SQL> set pages 0
SQL> with r(s) as
  2  (select x from t
  3    union all
  4   select case
  5             when length(regexp_substr(s, '(.)(\1)+')) = 3
  6             then regexp_replace(s, '^...')
  7             else regexp_replace(s, '^(.)\1|^.')
  8          end
  9     from r
 10    where s is not null)
 11  select listagg(decode(length(r),  2, 'double ',  3, 'triple ') ||
 12                 decode(substr(r, 1, 1), 0, 'oh', to_char(to_date(substr(r, 1, 1), 'j'), 'jsp')), ' ')
 13                 within group (order by rownum)
 14    from (select regexp_replace(s, lag(s) over (order by length(s)) || '$') r
 15            from r order by length(s) desc);
one double nine double nine triple nine one double oh seven nine

Der Haupttrick besteht darin, dass Ziffern, die mithilfe von Oracle-Formatmodellen in Wörter umgewandelt wurden, anstelle von hartcodierten Literalen "eins" ... "neun".

JavaScript, 142 Bytes

s=>s.replace(/(.)(\1\1(?!\1)|\1|)/g,t=>(t[2]?' triple ':t[1]?' double ':' ')+'oh one two three four five six seven eight nine'.split` `[t[0]])

Probieren Sie es online!

(Roblox) Lua 5.1 , 166 Bytes

for I,N in('111 triple 11 double 1 '):gmatch'(%d+)(%D+)'do for i,n in('0oh1one2two3three4four5five6six7seven8eight9nine'):gmatch'(.)(%l+)'do s=s:gsub(i*I,N..n)end end

Stellen Sie sicher, dass ses sich um einen vordefinierten Zeichenfolgenwert handelt, der nur mit Ziffern gefüllt ist. Das ist die Variable, die geändert werden soll. Das Ergebnis enthält ein führendes Leerzeichen [\u20] .