Tarea

Dada una cadena de nombres en inglés de dígitos "colapsados" juntos, así:

zeronineoneoneeighttwoseventhreesixfourtwofive

Divide la cadena de nuevo en dígitos:

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

Reglas

• La entrada siempre es una cadena. Siempre consta de uno o más nombres de dígitos en minúscula en inglés, contraídos, y nada más.

  • Los nombres de dígitos en inglés son zero one two three four five six seven eight nine.

• La salida puede ser una lista de cadenas o una nueva cadena donde los dígitos están delimitados por cadenas no alfabéticas y no vacías. (Su salida también puede tener opcionalmente tales cadenas al principio o al final, y los delimitadores no necesitan ser consistentes. Por lo tanto, incluso algo así {{ zero0one$$two );es una respuesta válida (si es absurda) zeroonetwo).

• La respuesta más corta en bytes gana.

Casos de prueba

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]?....

Pruébalo en línea!

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

Pruébalo en línea!

(89) Crédito al gastropner por el hash XOR.
(76) Crédito a Toby Speight por la idea de usar 1st y 3rd.
(75) Crédito a Michael Dorgan por '0'→ 48.
(72) Crédito a Michael Dorgan y Lynn por literales con caracteres de control.
(69) Crédito a 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

Pruébalo en línea!

-3 gracias a Lynn .
-4 gracias a Uriel 's respuesta expresiones regulares' s.

Befunge, 87 85 81 76 bytes

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

Pruébalo en línea!

Befunge no tiene instrucciones de manipulación de cadenas, así que lo que hacemos es crear una especie de hash de los últimos tres caracteres encontrados, ya que los estamos procesando.

Este hash es esencialmente un número de tres dígitos, base 104. Cada vez que se lee un nuevo personaje, modificamos el hash con 104 ² para deshacernos del personaje más antiguo, lo multiplicamos por 104 para hacer espacio para el nuevo personaje, luego agregamos el valor ASCII del nuevo carácter 27 (para asegurarnos no se desborda).

Para fines de comparación, tomamos este valor mod 3817, lo escribimos en la memoria (truncando así a 8 bits), lo que da como resultado números más pequeños que son más fáciles de manejar para Befunge. Los hashes con los que tenemos que comparar son 0, 38, 59, 64, 88, 92, 114, 117 y 123. Si coincide con alguno de ellos, sabemos que hemos encontrado una secuencia de caracteres que marca el final de un número, por lo que generamos un espacio adicional y restablecemos el hash a cero.

Si se pregunta por qué la base 104, o por qué mod 3817, esos valores fueron elegidos cuidadosamente para que la lista de hash con la que necesitáramos comparar pudiera representarse en la menor cantidad de bytes posible.

Java (OpenJDK 8) , 55 46 43 bytes

Ahorro de 9 bytes gracias a Forty3 / FrownyFrog

Ahorrando 3 bytes gracias a Titus

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

Pruébalo en línea!

editar: ¡Gracias por la bienvenida y la explicación de lambdas!

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

Edición 1: (Sugerencias agregadas del Sr. Xcoder - ¡gracias! - Mi versión macro era del mismo tamaño que la tuya, pero me gusta más la tuya).

Edición 2: el carácter cambiado de char se compara con las llamadas astrchr()

Edición 3: K & R's las declaraciones var (¡Eww!)

Edición 4: cuando 1 macro no es suficiente ...

Edición 5: rehecho con el nuevo algoritmo sugerido anteriormente. ¡Gracias a James Holderness por esta gran idea!

Edición 6: Se eliminó el conjunto 0, ya que parece ir allí automáticamente. Se utilizaron técnicas de golf de código de nivel maestro (comas, truco printf, etc.). ¡Gracias gastropner !

Edición 7: Usa memchr y reparó un error señalado por James Holderness .

Edición 7: Usar &&en la verificación final para reemplazar ?- gracias 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);}

Pruébalo en línea!

No golf (que honestamente sigue siendo muy golfista ...)

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

Vieja y sencilla solución 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(' ');}}

Versión antigua y más limpia.

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

Pruébalo en línea!

JavaScript 66 57 52 44 41 bytes

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

Bastante ingenuo, pero funciona.

Buena captura de FrownyFrog para usar 2 caracteres ... a excepción de "uno" que un cheque puro de 2 caracteres podría estropear zeronine. Editar: el sencillo fy sfueron buenas capturas de FrownyFrog que pasé por alto mis dos primeros campos de golf.

Gracias, Neil, por la sugerencia de una lambda sin nombre y poder usar un solo carácter para zllegar a 52.

Titus viene con un RegEx más pequeño. Siento que finalmente nos dirigimos hacia la expresión regular de Uriel.

Retina , 24 23 bytes

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

Pruébalo en línea! Editar: guardado 1 byte gracias 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);}

Esto funciona para cualquier codificación de caracteres (incluidos los incómodos como EBCDIC), ya que no utiliza el valor numérico de los caracteres de entrada. En cambio, localiza la primera y la tercera letra en una cadena mágica. La distancia entre estos indica cuántas letras avanzar con cada impresión.

Programa de prueba

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

Pruébalo en línea!

C (gcc) , 106 bytes 104 bytes

-2 bytes gracias 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);}

Pruébalo en línea!

XOR es verdaderamente nuestro mayor aliado.

Retina , 28 bytes

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

Pruébalo en línea!

Pyth , 35 27 23 bytes

Ahorró muchos bytes al portar el enfoque de Uriel .

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

Pruébalo aquí! Acercamiento inicial.

Pip , 27 bytes

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

Toma entrada como argumento de línea de comando. Pruébalo en línea!

Reemplazo simple de expresiones regulares, inserta un espacio antes de cada partido de [zfs]|one|[ent][iwh].

Saltar al carro de robar prestado La expresión regular de Uriel da 23 bytes (con -sbandera):

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

Jalea ,  23  21 bytes

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

Un programa completo que imprime la salida separada del avance de línea. Nota: una vez hecho, imprime repetidamente líneas vacías "para siempre" (hasta un límite de recursión enorme o una falla seg)

Pruébalo en línea! (La salida TIO se acumula, una implementación local imprimirá línea por línea)

¿Cómo?

Comenzando con una lista de caracteres, el programa repetidamente:

1. encuentra la longitud de la primera palabra de la lista de caracteres usando algunas matemáticas ordinales;
2. imprime la palabra más un salto de línea; y
3. elimina la palabra del encabezado de la lista de caracteres

La longitud de la primera palabra se decide inspeccionando los primeros tres caracteres de la lista actual de caracteres (necesariamente parte de la primera palabra). El programa los convierte en ordinales, los multiplica, modula el resultado por 953, modulos que por siete, modulos que por tres y agrega tres:

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

EDITAR: Intenté init 'i' a 1 así

a, b; principal (i)

Para deshacerse del espacio en blanco
inicial , pero se rompe en la entrada comenzando con tres, siete u ocho

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

Pruébalo en línea

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

Pruébalo en línea

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

Pruébalo en línea!

Sin golf

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 constantes se vuelve innecesariamente grande cambiando un << 8
pero en caso de que pueda compararse con las cadenas de alguna manera, debería ser lo más natural

146 Uso de la comparación de cadenas

#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 la comparación de cadenas

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

Jalea , 44 bytes

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

Pruébalo en línea!

Una muy larga. Eres bienvenido a jugar golf.

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

Pruébalo en línea!

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

Pruébalo en línea!

Explicación:

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 (sin expresiones regulares) , 85 bytes

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

Pruébalo en línea!

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 un espacio frente a: z, on, tw, th, f, s, ei,ni

Conjunto 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

(Fue divertido adaptar la expresión regular fría de Uriel a un entorno poco amigable con la expresión regular).

Jalea , 40 39 bytes

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

Pruébalo en línea!

Cómo 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]?....
&

Pruébalo en línea!

Este es un puerto de mi respuesta de retina .

APL (Dyalog Unicode) , 25 bytes

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

Pruébalo en línea!

Python 3 , sin expresiones regulares,  83 68 65  63 bytes

-15 gracias a Lynn (refactorizar en una sola función)
-3 más gracias a Lynn (evitar indexar en una lista con más aritmética)
... lo que lleva a otro ahorro de 2 bytes (evitando paréntesis con módulos negativos) :)

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

Una función que imprime las palabras separadas por nuevas líneas y luego genera un IndexError .

Pruébalo en línea! (suprime las excepciones para permitir múltiples ejecuciones dentro del conjunto de pruebas)

Jalea , 36 bytes

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

Pruébalo en línea!

Algoritmo:

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

Apuesto a que podemos hacerlo aún mejor.

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

Pruébalo en línea!

TIO genera un mensaje de error sobre "CountryData" (???)
No sé por qué sucede esto, pero todo funciona bien en Mathematica

Perl 6 ,  42  30 bytes

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

Pruébalo

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

Pruébelo
(Traducido de otras respuestas)

q / kdb +, 59 51 bytes

Solución:

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

Ejemplo:

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"

Explicación:

Solución rápida, probablemente enfoques mejores y más golfables.

{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 con un juego de golf simple, reemplazando q llamadas por k unas, pero sigue siendo una solución considerable.

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