Aufgabe

Ausgehend von einer Folge von englischen Ziffernnamen, die wie folgt „zusammengebrochen“ sind:

zeronineoneoneeighttwoseventhreesixfourtwofive

Teilen Sie die Zeichenfolge wieder in Ziffern auf:

zero nine one one eight two seven three six four two five

Regeln

• Die Eingabe ist immer eine Zeichenfolge. Es besteht immer aus einem oder mehreren zusammengeklappten englischen Ziffernnamen in Kleinbuchstaben und sonst nichts.

  • Die englischen Ziffernnamen sind zero one two three four five six seven eight nine.

• Die Ausgabe kann eine Liste von Zeichenfolgen oder eine neue Zeichenfolge sein, bei der die Ziffern durch nicht alphabetische, nicht leere Zeichenfolgen begrenzt sind. (Ihre Ausgabe kann optional auch solche Zeichenfolgen am Anfang oder Ende enthalten, und die Begrenzer müssen nicht konsistent sein. Daher ist auch so etwas {{ zero0one$$two );eine gültige (wenn auch absurde) Antwort für zeroonetwo.)

• Die kürzeste Antwort in Bytes gewinnt.

Testfälle

three -> three
eightsix -> eight six
fivefourseven -> five four seven
ninethreesixthree -> nine three six three
foursixeighttwofive -> four six eight two five
fivethreefivesixthreenineonesevenoneeight -> five three five six three nine one seven one eight
threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight -> three seven seven six nine nine nine five eight two five eight six three eight
zeroonetwothreefourfivesixseveneightnine -> zero one two three four five six seven eight nine

Netzhaut , 20 Bytes

!`..[eox]|[tse]?....

Probieren Sie es online!

C (GCC) , 89 80 76 75 72 71 70 69 Bytes

f(char*s){*s&&f(s+printf(" %.*s",""[(*s^s[2])%12],s)-1);}

Probieren Sie es online!

(89) Gutschrift an gastropner für den XOR-Hash.
(76) Toby Speight für die Idee, den 1. und 3. zu verwenden.
(75) Dank an Michael Dorgan für '0'→ 48.
(72) Dank an Michael Dorgan und Lynn für Literale mit Steuerzeichen.
(69) Dank an Lynn für x?y:0→x&&y

f (char *s) {        /* K&R style implicit return type. s is the input. */
    *s&&f(           /* Recurse while there is input. */
        s+printf(    /* printf returns the number of characters emitted. */
            " %.*s", /* Prefix each digit string with a space. Limit
                      * how many bytes from the string to print out. */
            ""
                     /* Magic hash table, where the value represents
                      * the length of the digit string. The string
                      * is logically equivalent to
                      * "\04\01\05\03\04\05\05\04\04\01\03\03" */
            [(*s^s[2])%12],
                     /* The XOR hash (mod 12) */
            s)       /* The current digit. */
            -1);}    /* Subtract 1 for the space. */

Python 2 , 50 Bytes

import re
re.compile('..[eox]|[tse]?....').findall

Probieren Sie es online!

-3 danke an Lynn .
-4 dank Uriel 's Antwort ist regex.

Befunge, 87 85 81 76 Bytes

<*"h"%*:"h"$_02g-v1$,*<v%*93,:_@#`0:~
"@{&ruX;\"00^ !: _>_48^>+:"yp!"*+%02p0

Probieren Sie es online!

Befunge verfügt über keine Anweisungen zur Manipulation von Zeichenfolgen. Wir erstellen also eine Art Hash der letzten drei Zeichen, während wir sie verarbeiten.

Dieser Hash ist im Wesentlichen eine dreistellige Basis-104-Zahl. Jedes Mal, wenn ein neues Zeichen gelesen wird, modifizieren wir den Hash mit 104 ² , um das älteste Zeichen zu entfernen, multiplizieren ihn mit 104, um Platz für das neue Zeichen zu schaffen, und fügen dann den ASCII - Wert des neuen Zeichens Mod 27 hinzu (um sicherzugehen) es läuft nicht über).

Zu Vergleichszwecken nehmen wir diesen Wert mod 3817, schreiben ihn in den Speicher (kürzen ihn also auf 8 Bit), was zu kleineren Zahlen führt, die für Befunge leichter zu handhaben sind. Die Hashes, mit denen wir dann vergleichen müssen, sind 0, 38, 59, 64, 88, 92, 114, 117 und 123. Wenn einer dieser Hashes übereinstimmt, haben wir eine Zeichenfolge gefunden, die das Ende von markiert Zahl, also geben wir ein zusätzliches Leerzeichen aus und setzen den Hash auf Null zurück.

Wenn Sie sich fragen, warum Base 104 oder warum Mod 3817? Diese Werte wurden sorgfältig ausgewählt, damit die zu vergleichende Hash-Liste in möglichst wenigen Bytes dargestellt werden kann.

Java (OpenJDK 8) , 55 46 43 Bytes

9 Bytes sparen dank Forty3 / FrownyFrog

3 Bytes sparen dank Titus

s->s.replaceAll("one|tw|th|f|z|s|.i"," $0")

Probieren Sie es online!

edit: Danke für die Begrüßung und Erklärung von Lambdas!

C (GCC) , 179 159 146 139 137 116 107 103 102 Bytes

Edit 1: (Vorschläge von Mr. Xcoder hinzugefügt - danke! - Meine Makroversion hatte dieselbe Größe wie Ihre, aber ich mag Ihre besser.)

Edit 2: Geänderte Charaktereigenschaften im Vergleich zu Anrufen mitstrchr()

Edit 3: K & R's die var Deklarationen (Eww!)

Edit 4: Wenn 1 Makro nicht ausreicht ...

Edit 5: Neu gemacht mit dem oben vorgeschlagenen neuen Algorithmus. Vielen Dank an James Holderness für diese großartige Idee!

Edit 6: 0-Set entfernt, da es automatisch dorthin zu gehen scheint - Verwendete Master-Level-Code- Golftechniken (Kommas, Printf-Trick usw.) - Danke Gastropner !

Edit 7: Benutze memchr und behebe einen Fehler, auf den James Holderness hingewiesen hat .

Edit 7: Verwenden Sie &&bei der Endabnahme zu ersetzen ?- danke jxh .

c,h;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,memchr("&;@X\\ru{",h%3817,9)&&putchar(h=32);}

Probieren Sie es online!

Nicht golfen (was ehrlich gesagt immer noch sehr golfen ist ...)

int c;
int h;
void f(char*s)
{
    while(c=*s++)
        putchar(c),
        h=h%10816*104+c%27,
        memchr("&;@X\\ru{",h%3817,9)?putchar(h=32):1;
}

Alte, einfache grep-esqe-Lösung:

#define p putchar
#define q c=*s++
c,x;f(char*s){while(q){p(c);x=strchr("tse",c);p(q);p(q);if(!strchr("eox",c)){p(q);if(x)p(q);}p(' ');}}

Alte, sauberere Version.

// Above code makes a macro of putchar() call.

void f(char *s)
{
    char c;
    while(c = *s++)
    {
        putchar(c);
        int x = strchr("tse", c);

        putchar(*s++);
        putchar(c=*s++);

        if(!strchr("eox", c))
        {
            putchar(*s++);
            if(x)
            {
                putchar(*s++);
            }
        }       
        putchar(' ');
    }
}

Probieren Sie es online!

JavaScript, 66 57 52 44 41 Bytes

s=>s.replace(/one|t[wh]|.i|[fsz]/g," $&")

Ziemlich naiv, aber es funktioniert.

Schöner Fang von FrownyFrog, um 2 Zeichen zu verwenden. Mit Ausnahme von "eins", bei dem ein reiner 2-Zeichen-Check die Null durcheinander bringen könnte. Edit: Die Single fund swaren gute Fänge von FrownyFrog, die ich bei meinen ersten beiden Golfspielen übersehen habe.

Vielen Dank, Neil, für den Vorschlag eines unbenannten Lambdas und die Möglichkeit, mit einem einzigen Char z52 zu erreichen.

Titus wartet mit einem kleineren RegEx auf. Ich habe das Gefühl, dass wir uns irgendwann Uriels Regex nähern.

Retina , 24 23 Bytes

!`..[eox]|[fnz]...|.{5}

Probieren Sie es online! Bearbeiten: 1 Byte dank @FrownyFrog gespeichert.

C 103 99 Bytes

char*r="f.tzuonresn.xgv";f(char*s){*s&&f(s+printf("%.*s ",(strrchr(r,s[2])-strchr(r,*s))%10,s)-1);}

Dies funktioniert für jede Zeichenkodierung (einschließlich umständlicher Zeichen wie EBCDIC), da der numerische Wert der eingegebenen Zeichen nicht verwendet wird. Stattdessen werden der erste und der dritte Buchstabe in einer magischen Zeichenfolge lokalisiert. Der Abstand zwischen diesen gibt an, wie viele Buchstaben bei jedem Ausdruck vorgeschoben werden müssen.

Testprogramm

#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}

J , 37-35 Bytes

rplc'twthsiseeinionzef'(;LF&,)\~_2:

Probieren Sie es online!

C (gcc) , 106 Bytes, 104 Bytes

-2 Bytes dank @jxh

c;f(char*s){char*t=" $&=B*,29/?";while(*s)for(c=4+(strchr(t,(*s^s[1])+35)-t)/4;c--;)putchar(c?*s++:32);}

Probieren Sie es online!

XOR ist wirklich unser größter Verbündeter.

Retina , 28 Bytes

t[ewh]|[zfs]|(ni|o)ne|ei
 $&

Probieren Sie es online!

Pyth , 35 27 23 Bytes

Durch die Portierung von Uriels Ansatz wurden viele Bytes gespart .

:Q"..[eox]|[tse]?...."1

Probieren Sie es hier aus! Anfänglicher Ansatz.

Pip , 27 Bytes

aR`[zfs]|one|[ent][iwh]`s._

Übernimmt die Eingabe als Befehlszeilenargument. Probieren Sie es online!

Einfacher Regex-Austausch, fügt vor jedem Treffer ein Leerzeichen ein [zfs]|one|[ent][iwh].

Das Springen auf den Zug des Diebstahls von Uriels Regex ergibt 23 Bytes (mit -sFlagge):

a@`..[eox]|[tse]?....`

Jelly ,  23  21 Bytes

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ

Ein vollständiges Programm, das zeilenweise getrennte Ausgaben druckt. Hinweis: Sobald dies erledigt ist, werden wiederholt leere Zeilen "für immer" ausgegeben (bis zu einer riesigen Rekursionsgrenze oder einem Seg-Fehler).

Probieren Sie es online! (TIO-Ausgabe wird akkumuliert, eine lokale Implementierung wird zeilenweise gedruckt.)

Wie?

Beginnend mit einer Liste von Zeichen wiederholt das Programm:

1. Ermittelt die Länge des ersten Wortes in der Liste der Zeichen unter Verwendung von Ordinalmathematik.
2. druckt das Wort plus Zeilenvorschub; und
3. Entfernt das Wort aus dem Kopf der Zeichenliste

Die Länge des ersten Wortes wird bestimmt, indem die ersten drei Zeichen der aktuellen Zeichenliste (notwendigerweise Teil des ersten Wortes) überprüft werden. Das Programm konvertiert diese in Ordnungszahlen, multipliziert sie miteinander, moduliert das Ergebnis mit 953, moduliert das Ergebnis mit sieben, moduliert das Ergebnis mit drei und addiert drei:

word   head3  ordinals       product  %953  %7  %3  +3 (=len(word))
zero   zer    [122,101,114]  1404708   939   1   1   4
two    two    [111,110,101]  1233210    28   0   0   3
one    one    [116,119,111]  1532244   773   3   0   3
three  thr    [116,104,114]  1375296   117   5   2   5
four   fou    [102,111,117]  1324674     4   4   1   4
five   fiv    [102,105,118]  1263780   102   4   1   4
six    six    [115,105,120]  1449000   440   6   0   3
seven  sev    [115,101,118]  1370570   156   2   2   5
eight  eig    [101,105,103]  1092315   177   2   2   5
nine   nin    [110,105,110]  1270500   151   4   1   4

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ - Main link, list of characters           e.g. "fiveeight..."
ḣ3              - head to index three                                "fiv"
  O             - ordinals                                           [102,105,118]
   P            - product                                            1263780
    %953        - modulo by 953                                      102
        %7      - modulo by seven                                    4
          %3    - modulo by three                                    1
            +3  - add three                                          4

              ɓ - dyadic chain separation swapping arguments...
... ḣṄȧṫḊÇ ...
    ḣ         - head to index                                        "five"
     Ṅ        - print the result plus a line-feed and yield the result
       ṫ      - tail from index                                      "eeight..."
      ȧ       - and (non-vectorising)                                "eeight..."
        Ḋ     - dequeue                                               "eight..."
         Ç    - call the last link (Main*) as a monad with this as input
              -       * since it's the only link and link indexing is modular.

C 168 ,145,144141 Bytes

EDIT: Versucht init 'i' zu 1 wie so

a, b; main (i)

Um führende Whitespaces loszuwerden,
die bei Eingaben ab drei, sieben oder acht unterbrochen werden

141

#define s|a%1000==
a,i;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b%32<<5*i++)if(i>4|a%100==83 s 138 s 116 s 814 s 662 s 478)a=i=0;}

Probieren Sie es online aus

144

a,i;main(b){for(;~(b=getchar());printf(" %c"+!!i,b),a=a*21+b-100,++i)if(i>4|a==204488|a==5062|a==7466|a==23744|a==21106|a==6740|a==95026)a=i=0;}

Probieren Sie es online aus

168

i,a;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4|a==1869768058|a==6647407|a==7305076|a==1920298854|a==1702259046|a==7891315|a==1701734766)a=i=0;}

Probieren Sie es online!

Ungolfed

i,a;main(b){
for(;~scanf("%c",&b); // for every char of input
printf(" %c"+!!i,b), // print whitespace if i==0 , + char
a|=b<<8*i++ // add char to a for test
)
if(
i>4| // three seven eight
a==1869768058|      // zero
a==6647407|        // one
a==7305076|       // two
a==1920298854|   //four
a==1702259046|  //five
a==7891315|    //six
a==1701734766 //nine
) a=i=0; //reset i and a
}

int-Konstanten werden durch Verschieben von << 8 unnötig groß,
aber wenn Sie sich mit Strings vergleichen können, sollte dies die natürlichste sein

146 Stringvergleich verwenden

#define s|a==*(int*)
a,b;main(i){for(;~(b=getchar());printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4 s"zero"s"one"s"two"s"four"s"five"s"six"s"nine")a=i=0;}

Verwenden des Zeichenfolgenvergleichs

Verschleiert

#define F(x)if(scanf(#x+B,&A)>0){printf(#x,&A);continue;}
B;A;main(i){for(;i;){B=1;F(\40e%4s)F(\40th%3s)F(\40se%3s)F(\40o%2s)B=2;F(\40tw%1s)F(\40si%1s)B=1;F(\40%4s)i=0;}}

Jelly , 44 Bytes

Ṛ¹Ƥz⁶ZUwЀ“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳ¤$€Ẏḟ1Ṭœṗ

Probieren Sie es online!

Ganz schön lang. Sie können gerne Golf spielen.

R 109 Bytes

function(x)for(i in utf8ToInt(x)){F=F+i;cat(intToUtf8(i),if(F%in%c(322,340,346,426,444,448,529,536,545))F=0)}

Probieren Sie es online!

Haskell , 81 Bytes

f[c]=[c]
f(h:t)=[' '|s<-words"z one tw th f s ei ni",and$zipWith(==)s$h:t]++h:f t

Probieren Sie es online!

Erläuterung:

f(h:t)=                      h:f t -- recurse over input string
   [' '|s<-               ]++      -- and add a space for each string s
      words"z one tw th f s ei ni" -- from the list ["z","one","tw","th","f","s","ei","ni"]
      ,and$zipWith(==)s$h:t        -- which is a prefix of the current string

Python 3 (kein regulärer Ausdruck) , 85 Byte

i=3
while i<len(s):
	if s[i-3:i]in'ineiveroneghtwoureesixven':s=s[:i]+' '+s[i:]
	i+=1

Probieren Sie es online!

Excel, 181 Bytes

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"z"," z"),"on"," on"),"tw"," tw"),"th"," th"),"f"," f"),"s"," s"),"ei"," ei"),"ni"," ni")

Platziert einen Raum vor: z, on, tw, th, f, s, ei,ni

Z80-Assembly, 46 - 45 Byte

; HL is the address of a zero-terminated input string
; DE is the address of the output buffer

Match5: ldi                                 ; copy remaining characters
Match4: ldi
Match3: ld a,32 : ld (de),a : inc de        ; and add space after a matched word.

Uncollapse:

        ld a,(hl) : ldi : or a : ret z      ; copy first byte (finish if it was zero)
        ex af,af'                           ; and save its value for later.

        ldi : ld a,(hl) : ldi               ; copy second and third bytes

        cp 'e' : jr z,Match3                ; is the third letter 'e' or 'o' or 'x'?
        cp 'o' : jr z,Match3
        cp 'x' : jr z,Match3

        ex af,af'                           ; now look at the first letter

        cp 'e' : jr z,Match5                ; is it 't' or 's' or 'e'?
        sub 's' : jr z,Match5
        dec a : jr z,Match5
        jr Match4

(Es hat Spaß gemacht, den kühlen Regex des Uriel an eine regex-unfreundliche Umgebung anzupassen).

Jelly , 40 bis 39 Bytes

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK

Probieren Sie es online!

Wie es funktioniert

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK
“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»                 = the compressed string of the digit names
                        Ḳ                = split at spaces
                         e€€@ŒṖ          = check whether each member of each partition of the argument is a digit.
                               Ạ€        = A function that checks whether all values of an array are true, applied to each element.
                                 T       = Finds the index of each truthy element 
                                  Ḣ      = Grab the first element, since we have a singleton array
                                    ịŒṖ  = The previous command gives us the index, partition that splits the input into digits. This undoes it and gives us the partition.
                                       K = Join the array of digits with spaces                

QuadS , 21 bis 20 Bytes

..[eox]|[tse]?....
&

Probieren Sie es online!

Dies ist ein Port meiner Retina-Antwort .

APL (Dyalog Unicode) , 25 Byte

'..[eox]|[tse]?....'⎕S'&'

Probieren Sie es online!

Python 3 , kein regulärer Ausdruck,  83 68 65  63 Bytes

-15 danke an Lynn (Refaktor in eine einzelne Funktion)
-3 mehr danke an Lynn (vermeide das Indizieren in eine Liste mit mehr Arithmetik)
... was zu einer weiteren Einsparung von 2 Bytes führt (vermeide Klammern mit negativen Modulos) :)

def f(s):h=ord(s[0])*ord(s[1])%83%-7%-3+5;print(s[:h]);f(s[h:])

Eine Funktion, die die durch Zeilenumbrüche getrennten Wörter druckt und dann ein auslöst IndexError.

Probieren Sie es online! (unterdrückt die Ausnahmen, um mehrere Läufe innerhalb der Testsuite zuzulassen)

Gelee , 36 Bytes

œṣj⁶;$}
W;“€ɗİẒmṫṃ¦¦ạỊɦ⁼Fḷeṭḷa»s2¤ç/

Probieren Sie es online!

Algorithmus:

for x in ['ze', 'ni', 'on', 'tw', 'th', ...]:
    replace x in input by space+x

Ich wette, wir können es noch besser machen.

Mathematica, 125 Bytes

(s=#;While[StringLength@s>2,t=1;a="";While[FreeQ[IntegerName/@0~Range~9,a],a=s~StringTake~t++];Print@a;s=StringDrop[s,t-1]])&

Probieren Sie es online!

TIO gibt eine Fehlermeldung über "CountryData" (???) aus.
Ich weiß nicht, warum dies passiert, aber auf Mathematica funktioniert alles einwandfrei

Perl 6 ,  42  30 Bytes

*.comb(/<{(0..9).Str.uninames.lc.words}>/)

Probier es aus

{m:g/..<[eox]>||<[tse]>?..../}

Testen Sie es
(Übersetzt aus anderen Antworten)

q / kdb + 59 51 Bytes

Lösung:

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}

Beispiel:

q){asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}"threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight"
"three"
"seven"
"seven"
"six"
"nine"
"nine"
"nine"
"five"
"eight"
"two"
"five"
"eight"
"six"
"three"
"eight"

Erläuterung:

Schnelle Lösung, wahrscheinlich bessere und golffähigere Ansätze.

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x} / ungolfed solution
{                                                 } / lambda with implicit x as input
                                             cut x  / cut x at indices given by left
 asc[                                       ]       / sort ascending
                string`z`one`tw`th`f`s`ei`ni        / string list ("z","one",...)
          x ss/:                                    / string-search left with each right
     raze                                           / reduce down list

Anmerkungen:

46 Bytes mit etwas einfachem Golfen, wobei q-Calls durch k-Calls ersetzt werden, aber immer noch eine gewaltige Lösung.

asc[(,/)x ss/:($)`z`one`tw`th`f`s`ei`ni]cut x: