Tarefa

Dada uma sequência de nomes em inglês de dígitos "recolhidos" juntos, assim:

zeronineoneoneeighttwoseventhreesixfourtwofive

Divida a sequência novamente em dígitos:

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

Regras

• A entrada é sempre uma string. Ele sempre consiste em um ou mais nomes de dígitos em inglês em minúsculas, recolhidos juntos e nada mais.

  • Os nomes dos dígitos em inglês são zero one two three four five six seven eight nine.

• A saída pode ser uma lista de cadeias ou uma nova cadeia na qual os dígitos são delimitados por cadeias não alfabéticas e não vazias. (Sua saída também pode, opcionalmente, ter essas seqüências no início ou no final, e os delimitadores não precisam ser consistentes. Portanto, mesmo algo como {{ zero0one$$two );é uma resposta válida (se absurda) zeroonetwo.)

• A resposta mais curta em bytes vence.

Casos de teste

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

Retina , 20 bytes

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

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

Experimente online!

(89) Crédito ao gastropner pelo hash XOR.
(76) Agradecemos a Toby Speight pela idéia de usar o 1º e o 3º.
(75) Crédito para Michael Dorgan por '0'→ 48.
(72) Agradecemos a Michael Dorgan e Lynn por literais com caracteres de controle.
(69) Crédito para Lynn por 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

Experimente online!

-3 graças a Lynn .
-4 graças a Uriel 's resposta regex' s.

Befunge, 87 85 81 76 bytes

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

Experimente online!

O Befunge não possui instruções de manipulação de strings; portanto, o que fazemos é criar um tipo de hash dos três últimos caracteres encontrados, enquanto os estamos processando.

Esse hash é essencialmente um número base 104 de três dígitos. Toda vez que um novo caractere é lido, modificamos o hash com 104 ² para se livrar do caractere mais antigo, multiplicamos por 104 para criar espaço para o novo caractere e adicionamos o valor ASCII do novo mod 27 (para garantir não transborda).

Para fins de comparação, pegamos esse valor mod 3817, escrevemos na memória (truncando-o para 8 bits), o que resulta em números menores que são mais fáceis de manusear pelo Befunge. Os hashes com os quais devemos comparar são 0, 38, 59, 64, 88, 92, 114, 117 e 123. Se corresponder a algum desses, sabemos que encontramos uma sequência de caracteres que marca o final de um número, então produzimos um espaço adicional e redefinimos o hash para zero.

Se você está se perguntando por que a base 104 ou o mod 3817, esses valores foram cuidadosamente escolhidos para que a lista de hash com a qual precisávamos comparar pudesse ser representada no menor número possível de bytes.

Java (OpenJDK 8) , 55 46 43 bytes

Salvando 9 bytes graças ao Forty3 / FrownyFrog

Economizando 3 bytes graças ao Titus

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

Experimente online!

editar: Obrigado pela recepção e explicação das lambdas!

C (gcc) , 179 159 146 139 137 116 107 103 102 bytes

Edit 1: (Adicionado sugestões do Sr. Xcoder - obrigado! - Minha versão macro era do mesmo tamanho que a sua, mas eu gosto mais da sua.)

Edição 2: o indivíduo de caracteres alterado é comparado às chamadas parastrchr()

Edit 3: K & R's as declarações var (Eww!)

Edit 4: Quando uma macro não é suficiente ...

Edit 5: Refeito com o novo algoritmo sugerido acima. Agradecemos a James Holderness por essa ótima idéia!

Edit 6: Removido o set 0, pois parece ir para lá automaticamente - Técnicas de golfe com código de nível mestre usadas (vírgulas, truque printf, etc.) - obrigado gastropner !

Edit 7: Use memchr e corrigiu um bug apontado por James Holderness .

Edit 7: Use &&na verificação final para substituir ?- obrigado 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);}

Experimente online!

Não-golfista (que ainda é muito golfista honestamente ...)

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

Solução grep-esqe antiga e direta:

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

Versão antiga e limpa.

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

Experimente online!

JavaScript, 66 57 52 44 41 bytes

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

Muito ingênuo, mas funciona.

Boa captura pelo FrownyFrog para usar 2 caracteres .. exceto "one", em que uma verificação pura de 2 caracteres pode atrapalhar a zeronina. Edit: o single fe sforam boas capturas por FrownyFrog que eu negligenciei meus dois primeiros golfe.

Obrigado, Neil, pela sugestão de uma lambda sem nome e por poder usar um único caractere para zdescer para 52.

Titus vem com um RegEx menor. Sinto que estamos indo em direção à regex de Uriel eventualmente.

Retina , 24 23 bytes

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

Experimente online! Editar: salvou 1 byte graças a @FrownyFrog.

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

Isso funciona para qualquer codificação de caracteres (incluindo caracteres estranhos como EBCDIC), porque não usa o valor numérico dos caracteres de entrada. Em vez disso, localiza a primeira e a terceira letras em uma sequência mágica. A distância entre eles indica quantas letras devem avançar com cada impressão.

Programa de teste

#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:

Experimente online!

C (gcc) , 106 bytes 104 bytes

-2 bytes graças a @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);}

Experimente online!

XOR é verdadeiramente nosso maior aliado.

Retina , 28 bytes

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

Experimente online!

Pitão , 35 27 23 bytes

Economizou muitos bytes portando a abordagem de Uriel .

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

Experimente aqui! Abordagem inicial.

Pip , 27 bytes

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

Recebe entrada como um argumento de linha de comando. Experimente online!

Substituição simples de regex, insere um espaço antes de cada correspondência de [zfs]|one|[ent][iwh].

Pulando na onda de roubar empréstimos, a expressão regular de Uriel fornece 23 bytes (com -ssinalizador):

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

Geléia ,  23  21 bytes

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

Um programa completo imprimindo saída separada por alimentação de linha. Nota: uma vez feito, ele imprime repetidamente linhas vazias "para sempre" (até um enorme limite de recursão ou uma falha seg)

Experimente online! (A saída TIO é acumulada, uma implementação local imprimirá linha por linha)

Quão?

Começando com uma lista de caracteres, o programa repetidamente:

1. encontra o comprimento da primeira palavra da lista de caracteres usando alguma matemática ordinal;
2. imprime a palavra mais um avanço de linha; e
3. remove a palavra do cabeçalho da lista de caracteres

O comprimento da primeira palavra é decidido pela inspeção dos três primeiros caracteres da lista atual de caracteres (necessariamente parte da primeira palavra). O programa os converte em ordinais, multiplica-os, modula o resultado em 953, modula em sete, modula em três e adiciona três:

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,144, 141 bytes

EDIT: Tentei init 'i' para 1 como assim

a, b; principal (i)

Para se livrar do espaço em branco à esquerda,
mas ele interrompe a entrada começando com três, sete ou oito

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

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

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

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

As constantes int tornam-se desnecessárias em grandes deslocando um << 8,
mas no caso de você poder comparar com as strings de alguma forma, deve ser a mais natural

146 Usando comparação de strings

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

Usando comparação de String

Ofuscado

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

Geléia , 44 bytes

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

Experimente online!

Bastante longo. Você é bem-vindo a jogar golfe.

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

Experimente 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

Experimente online!

Explicação:

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 (sem regex) , 85 bytes

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

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

Coloca um espaço em frente: z, on, tw, th, f, s, ei,ni

Montagem Z80, 46 45 bytes

; 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

(Foi divertido adaptar o regex legal do Uriel a um ambiente hostil ao regex).

Geléia , 40 39 bytes

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

Experimente online!

Como funciona

“¢¤Ƙƒ⁺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 bytes

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

Experimente online!

Esta é uma porta da minha resposta da retina .

APL (Dyalog Unicode) , 25 bytes

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

Experimente online!

Python 3 , sem regex,  83 68 65  63 bytes

-15 graças a Lynn (refatorar em uma única função)
-3 mais graças a Lynn (evite indexar em uma lista com mais aritmética)
... levando a outro salvamento de 2 bytes (evitando parênteses com módulos negativos) :)

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

Uma função que imprime as palavras separadas por novas linhas e depois gera um IndexError.

Experimente online! (suprime as exceções para permitir várias execuções no conjunto de testes)

Gelatina , 36 bytes

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

Experimente online!

Algoritmo:

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

Aposto que podemos fazer ainda melhor.

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

Experimente online!

O TIO envia uma mensagem de erro sobre "CountryData" (???)
Não sei por que isso acontece, mas tudo funciona bem no Mathematica

Perl 6 ,  42  30 bytes

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

Teste-o

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

Teste
(Traduzido de outras respostas)

q / kdb +, 59 51 bytes

Solução:

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

Exemplo:

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"

Explicação:

Solução rápida, provavelmente melhores e mais abordagens de golfe.

{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

Notas:

46 bytes com alguns jogos simples, substituindo q chamadas por k ones, mas ainda assim uma solução robusta.

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