Zadanie

Biorąc pod uwagę ciąg angielskich nazw cyfr „zwiniętych” razem, podobnie jak to:

zeronineoneoneeighttwoseventhreesixfourtwofive

Podziel ciąg z powrotem na cyfry:

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

Zasady

• Dane wejściowe są zawsze ciągiem. Zawsze składa się z jednej lub więcej małych liter alfabetu angielskiego, zwiniętych razem i nic więcej.

  • Angielskie nazwy cyfr to zero one two three four five six seven eight nine.

• Wyjściem może być lista ciągów lub nowy ciąg, w którym cyfry są rozdzielane nie alfabetycznymi, niepustymi łańcuchami. (Twój wynik może opcjonalnie zawierać takie ciągi na początku lub na końcu, a separatory nie muszą być spójne. Więc nawet coś takiego {{ zero0one$$two );jest poprawną (jeśli absurdalną) odpowiedzią zeroonetwo).

• Najkrótsza odpowiedź w bajtach wygrywa.

Przypadki testowe

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

Siatkówka , 20 bajtów

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

Wypróbuj online!

C (gcc) , 89 80 76 75 72 71 70 69 bajtów

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

Wypróbuj online!

(89) Kredyt dla gastropnera dla skrótu XOR.
(76) Podziękowania dla Toby Speighta za pomysł użycia 1. i 3. miejsca.
(75) Podziękowania dla Michaela Dorgana za '0'→ 48.
(72) Podziękowania dla Michaela Dorgana i Lynna za literały z postaciami kontrolnymi.
(69) Kredyt dla Lynn za 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 bajtów

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

Wypróbuj online!

-3 dzięki Lynn .
-4 dzięki Uriel 's odpowiedzi regex' s.

Befunge, 87 85 81 76 bajtów

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

Wypróbuj online!

Befunge nie ma żadnych instrukcji dotyczących manipulacji ciągami, więc tworzymy rodzaj skrótu trzech ostatnich napotkanych znaków podczas ich przetwarzania.

Ten skrót jest zasadniczo trzycyfrową liczbą base-104. Za każdym razem, gdy czytana jest nowa postać, modyfikujemy skrót za pomocą 104 ^2, aby pozbyć się najstarszej postaci, mnożymy ją przez 104, aby zrobić miejsce dla nowej postaci, a następnie dodajemy wartość ASCII nowego znaku mod 27 (aby upewnić się nie przepełnia się).

Dla celów porównawczych bierzemy tę wartość mod 3817, zapisujemy ją w pamięci (w ten sposób skracamy do 8 bitów), co skutkuje mniejszymi liczbami, które są łatwiejsze w obsłudze dla Befunge. Skróty, z którymi musimy porównać, to 0, 38, 59, 64, 88, 92, 114, 117 i 123. Jeśli pasuje do któregokolwiek z nich, wiemy, że napotkaliśmy sekwencję znaków, która oznacza koniec liczba, więc wypisujemy dodatkową spację i resetujemy skrót do zera.

Jeśli zastanawiasz się, dlaczego podstawa 104 lub dlaczego mod 3817, te wartości zostały starannie wybrane, aby lista skrótów, którą musieliśmy porównać, mogła być reprezentowana w jak najmniejszej liczbie bajtów.

Java (OpenJDK 8) , 55 46 43 bajtów

Oszczędność 9 bajtów dzięki Forty3 / FrownyFrog

Oszczędność 3 bajtów dzięki Titusowi

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

Wypróbuj online!

edytuj: Dziękujemy za powitanie i wyjaśnienie lambdas!

C (gcc) , 179 159 146 139 137 116 107 103 102 102 bajtów

Edycja 1: (Dodano sugestie pana Xcodera - dziękuję! - Moja wersja makr była tego samego rozmiaru co twoja, ale bardziej lubię twoją.)

Edycja 2: Zmieniono charakterystykę osobowości w porównaniu do połączeń zstrchr()

Edycja 3: Deklaracje var K&R (Eww!)

Edycja 4: Gdy 1 makro nie wystarczy ...

Edycja 5: Wykonaj ponownie z nowym algorytmem zasugerowanym powyżej. Dzięki Jamesowi Holdernessowi za ten świetny pomysł!

Edycja 6: Usunięto 0 zestawów, ponieważ wydaje się, że automatycznie tam trafia - Użyto technik golfowych z kodem mistrzowskim (przecinki, sztuczka printf itp.) - dzięki gastropner !

Edycja 7: Użyj memchr i naprawiono błąd wskazany przez Jamesa Holderness'a .

Edycja 7: Użyj &&do sprawdzenia końcowego, aby zastąpić ?- dzięki 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);}

Wypróbuj online!

Nie grał w golfa (co wciąż jest bardzo golfowe ...)

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;
}

Stare, proste rozwiązanie grep-esqe:

#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(' ');}}

Stara, czystsza wersja.

// 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(' ');
    }
}

Wypróbuj online!

JavaScript, 66 57 52 44 41 bajtów

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

Dość naiwny, ale działa.

Fajny chwyt FrownyFrog, aby użyć 2 znaków .. oprócz „jednego”, który czysty 2 znak może zepsuć zero. Edycja: singiel fi sdobre wyniki FrownyFrog, które przeoczyłem podczas pierwszych dwóch golfów.

Dzięki, Neil, za sugestię nienazwanej lambdy i możliwości użycia pojedynczego znaku dla, zspada do 52.

Titus proponuje mniejszy RegEx. Czuję, że w końcu zmierzamy w kierunku wyrażenia regularnego Uriela.

Siatkówka , 24 23 bajty

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

Wypróbuj online! Edycja: Zapisano 1 bajt dzięki @FrownyFrog.

C, 103 99 bajtów

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

Działa to w przypadku dowolnego kodowania znaków (w tym niezręcznych, takich jak EBCDIC), ponieważ nie używa wartości liczbowej znaków wejściowych. Zamiast tego lokalizuje pierwszą i trzecią literę w magicznym ciągu. Odległość między nimi wskazuje liczbę liter, które należy przesunąć przy każdym wydruku.

Program testowy

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

J , 37 35 bajtów

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

Wypróbuj online!

C (gcc) , 106 bajtów 104 bajty

-2 bajty dzięki @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);}

Wypróbuj online!

XOR jest naprawdę naszym największym sojusznikiem.

Siatkówka , 28 bajtów

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

Wypróbuj online!

Pyth , 35 27 23 bajtów

Zaoszczędził wiele bajtów, przenosząc podejście Uriela .

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

Wypróbuj tutaj! Wstępne podejście.

Pypeć , 27 bajtów

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

Pobiera dane wejściowe jako argument wiersza polecenia. Wypróbuj online!

Prosta zamiana wyrażeń regularnych, wstawia spację przed każdym dopasowaniem [zfs]|one|[ent][iwh] .

Przeskakiwanie po modzie kradzieży pożyczonego wyrażenia Uriela daje 23 bajty (z -sflagą):

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

Galaretka ,  23  21 bajtów

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

Pełny program drukujący oddzielne wyjście liniowe. Uwaga: gdy to zrobi, wielokrotnie drukuje puste linie „na zawsze” (aż do ogromnego limitu rekurencji lub błędu seg)

Wypróbuj online!(Dane wyjściowe TIO są kumulowane, lokalna implementacja drukuje wiersz po wierszu)

W jaki sposób?

Począwszy od listy znaków, program wielokrotnie:

1. znajduje długość pierwszego słowa listy znaków przy użyciu matematyki porządkowej;
2. wypisuje słowo plus kreskę; i
3. usuwa słowo z nagłówka listy znaków

Długość pierwszego słowa jest ustalana przez sprawdzenie pierwszych trzech znaków z bieżącej listy znaków (koniecznie część pierwszego słowa). Program konwertuje je na liczby porządkowe, mnoży je razem, modulos wynik przez 953, modulos który przez siedem, modulos ten przez trzy i dodaje trzy:

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.

do 168 ,145,144, 141 bajtów

EDYCJA: Próbowałem init 'i' do 1 lubię to

a, b; main (i)

Aby pozbyć się wiodących białych znaków,
ale psuje się na wejściu zaczynając od trzech, siedmiu lub ośmiu

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;}

Wypróbuj online

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;}

Wypróbuj online

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;}

Wypróbuj online!

Nie golfił

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
}

stałe int stają się niepotrzebne duże, przesuwając << 8,
ale w przypadku, gdy można porównać do ciągów znaków, powinno to być jak najbardziej naturalne

146 Używanie porównania ciągów

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

Korzystanie z porównania ciągów

Zaciemnione

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

Galaretka , 44 bajty

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

Wypróbuj online!

Dość długi. Możesz zagrać w golfa w dół.

R , 109 bajtów

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

Wypróbuj online!

Haskell , 81 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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 (bez wyrażenia regularnego) , 85 bajtów

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

Wypróbuj online!

Excel, 181 bajtów

=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")

Umieszcza spację przed: z, on, tw, th, f, s, ei,ni

Zespół Z80, 46 45 bajtów

; 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

(Fajnie było przystosować fajne wyrażenie regularne Uriela do nieprzyjaznego wyrażenia regularnego środowiska).

Galaretka , 40 39 bajtów

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

Wypróbuj online!

Jak to działa

“¢¤Ƙƒ⁺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 20 bajtów

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

Wypróbuj online!

To jest port mojej odpowiedzi siatkówki .

APL (Dyalog Unicode) , 25 bajtów

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

Wypróbuj online!

Python 3 , bez wyrażenia regularnego,  83 68 65  63 bajtów

-15 dzięki Lynn (przekształcenie w pojedynczą funkcję)
-3 więcej dzięki Lynn (unikanie indeksowania do listy z większą arytmetyką)
... co prowadzi do kolejnego zapisu 2 bajtów (unikanie nawiasów z ujemnymi modułami) :)

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

Funkcja, która drukuje słowa oddzielone znakami nowej linii, a następnie podnosi IndexError.

Wypróbuj online! (pomija wyjątki, aby umożliwić wiele uruchomień w zestawie testów)

Galareta , 36 bajtów

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

Wypróbuj online!

Algorytm:

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

Założę się, że możemy zrobić jeszcze lepiej.

Mathematica, 125 bajtów

(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]])&

Wypróbuj online!

TIO wyświetla komunikat o błędzie dotyczący „CountryData” (???)
Nie wiem, dlaczego tak się dzieje, ale wszystko działa dobrze na Mathematica

Perl 6 ,  42  30 bajtów

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

Sprawdź to

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

Przetestuj
(Przetłumaczone z innych odpowiedzi)

q / kdb +, 59 51 bajtów

Rozwiązanie:

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

Przykład:

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"

Wyjaśnienie:

Szybkie rozwiązanie, prawdopodobnie lepsze i bardziej golfowe podejście.

{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

Uwagi:

46 bajtów z kilkoma prostymi golfami, zastępując q wywołań k-ami, ale nadal jest to spore rozwiązanie.

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