Descolgar dígitos

72

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
Lynn
fuente
28
Este es un excelente desafío! La tarea es extremadamente fácil de entender y verificar, pero el enfoque correcto para usar no es muy obvio. Y elegir el enfoque correcto podría marcar una gran diferencia en la puntuación. +1 :)
DJMcMayhem
1
Después de pensar esto, recordé un desafío similar pero más simplista en el golf de anarquía: ¡ sí, no ! Provocó algunas sorprendentes respuestas de C. Espero ver uno de esos pronto :)
Lynn
No creo que mi respuesta C califique como tal, pero espero que sea un punto de partida para otros con un sentido del humor más retorcido que yo.
Michael Dorgan
Estoy bastante seguro de que he visto este mismo desafío, pero donde se supone que debes imprimir el número real. Estoy casi seguro de que también fue publicado por usted, Lynn; pero he perdido el enlace, ¿me conectas?
Magic Octopus Urn
3
@MichaelDorgan (o cualquier otro codificador C), es posible que desee echar un vistazo al algoritmo que utilicé en mi respuesta Befunge. Una conversión directa de eso a C me dio una solución de 104 bytes, que creo que supera todas las respuestas de C existentes. Estoy dispuesto a apostar que alguien con más habilidades de golf C podría mejorar.
James Holderness

Respuestas:

17

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:0x&&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. */
jxh
fuente
11

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.

Erik el Outgolfer
fuente
3
¡Agradable! import re;re.compile('…').findalldebería guardar un par de bytes. Esperaba que esto se convirtiera en regex golf :)
Lynn
@ Lynn ¡Espera, espera hasta que termine! :-P EDIT: son 3 bytes, en realidad.
Erik the Outgolfer
@ Lynn Además, deberías haber convertido esto en expresión regular de código de golf . ;)
Erik the Outgolfer
Estoy esperando una respuesta C, ¡lo cual será muy interesante!
Lynn
9

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 2 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.

James Holderness
fuente
Honestamente, esto me parece bakemoji (ば け も じ). Guau. Sin embargo, la descripción del algoritmo es agradable y la contemplaré.
Michael Dorgan
^, Recuerdo haber visto el término como mojibake (も じ ば け). ¿Cómo encontraste esos números (base 104, mod 3187), @JamesHolderness?
Zacharý
@ Zacharý Escribí un pequeño script de Python que probó diferentes combinaciones de base y mod para encontrar las que producirían los resultados correctos cuando se ejecutaran contra todas las entradas esperadas. Una vez que supe qué combinaciones funcionaban, ejecuté las salidas de hash resultantes a través de un generador de números Befunge para averiguar cuál producía el código más corto.
James Holderness
6

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!

Luca H
fuente
3
Hola, bienvenido a PPCG! Gran primera respuesta, y de hecho funciona. Aquí está el enlace TIO para ello. Las lambdas se pueden crear de múltiples maneras. Aquí hay otro TIO con algunas lambdas con comentarios agregados para que pueda ver cómo crearlos usted mismo. (Sugiero copiarlo en Eclipse para que pueda ver el resaltado del código). Además, los consejos para jugar golf en Java y los consejos para jugar golf en todos los idiomas pueden ser interesantes de leer. ¡Disfruta tu estancia! :)
Kevin Cruijssen
@KevinCruijssen gracias! Sinceramente, me sorprende que Java sea más corto que JavaScript. Por lo general, cuando estoy leyendo desafíos, JS es mucho más corto.
Luca H
JavaScript debe ser 2 bytes más corto ( gsufijo regex en lugar de All).
Neil
@Neil es más largo aquí porque está usando en f=(s)=>lugar de s->, que es 4 bytes más corto.
Luca H
1
@LucaH: según la sugerencia de FrownyFrog, puede reducir algunas de sus cadenas de dos letras a caracteres individuales: z | f | s en lugar de ze | fo | fi | si | se /
Cuarenta
6

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!

Michael Dorgan
fuente
Podemos macro el putchar y tal por unos pocos bytes, pero en general, todavía pensando en un mejor algoritmo si es posible.
Michael Dorgan
159 bytes por #defineing putchary la eliminación de un par de soportes innecesarios.
Sr. Xcoder
2
Un poco feo, pero 136 bytes usando en su #define p putchar(lugar (tenga en cuenta el paréntesis abierto).
Tom Carpenter
1
109 bytesc,h=0;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,c=h%3817,printf(" "+!(c&&strchr("&;@X\\ru{",c)));}
gastropner
Ah, el truco printf que vi a continuación más la eliminación de un par de paréntesis y llaves. Código de nivel maestro de golf habilitado :)
Michael Dorgan
5

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.

Cuarenta3
fuente
¿Se rompe si usa dos caracteres y presiona 'hasta' hasta el final?
FrownyFrog el
Estoy pensandoz|tw|th|f|s|ei|ni|on
FrownyFrog
1
@FrownyFrog o es lo primero, por lo que se reconoce primero.
Uriel
1
on|t[wh]|.i|[fsz](-4 bytes)
Tito el
2
@Titus - Desafortunadamente, el renderizado on|coincidirázeroninezer onine
Cuarenta
5

Retina , 24 23 bytes

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

Pruébalo en línea! Editar: guardado 1 byte gracias a @FrownyFrog.

Neil
fuente
1
sería .....-> .{5}trabajar?
FrownyFrog
5

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("");
    }
}
Toby Speight
fuente
1
Algunos bytes se pueden guardar mediante la recursividad: tio.run/##XY/…
jxh
4

J , 37 35 bytes

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

Pruébalo en línea!

FrownyFrog
fuente
2
¡Una solución alternativa genial! Lo intenté f=:[:>'..[eox]|[tse]?....'&rxally funcionó en interpeter, pero no funciona en TIO.
Galen Ivanov
esto es realmente inteligente, bien hecho
Jonás
@GalenIvanov TIO tiene la última versión, podría ser una regresión en J.
FrownyFrog
4

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.

gastropner
fuente
Como el truco de s ++. Buen hash
Michael Dorgan
1
s[1]Será más corto.
jxh
@jxh ¡Buena! Actualizado.
Gastropner
102 bytes
ceilingcat
3

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]?....`
DLosc
fuente
Puedes usar una expresión regular más corta .
Erik the Outgolfer
3

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.
Jonathan Allan
fuente
1
No estoy seguro de si esto está permitido . (En serio, ¿qué haces cuando dos meta-respuestas muy votadas dicen lo opuesto?)
Ørjan Johansen
El OP indica explícitamente "Su salida también puede tener opcionalmente tales cadenas al principio o al final" y este programa realmente imprime a medida que avanza, por lo que la salida se produce antes de cualquier terminación forzada de todos modos.
Jonathan Allan
Claro, pero no creo que OP haya considerado una cadena final infinita. Y la meta-pregunta es explícitamente sobre el caso en el que la salida se imprime primero.
Ørjan Johansen
Creo que cumple con el espíritu del requisito (si, por ejemplo, imprime infinitas cadenas vacías y luego las palabras que podría argumentar que no)
Jonathan Allan
Entonces, supongo que eso me pone en el campo de Martin de "si es un programa y puede justificar ..." :)
Jonathan Allan
3

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;}}
PrincePolka
fuente
2

Jalea , 44 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
3
Lo siento, te han superado dos veces.
Zacharý
2

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!

djhurio
fuente
¿Alguna forma de usar caracteres unicode en lugar de dígitos?
Michael Dorgan
Buena aplicación de intToUtf8! Sería posible 90 bytes utilizando un enfoque diferente utilizando regexp:function(x,p=paste,z=p("(",p(c("zero",broman::numbers),collapse="|"),")"))gsub(z,"\\1 ",x)
Michael M
2

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
Laikoni
fuente
2

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!

Alex
fuente
2
Bienvenido a PPCG!
Laikoni
Es bueno, pero un programa completo debe incluir el código para tomar entrada.
Jonathan Allan
Entonces, como un programa completo 104 bytes . Sin embargo, puede guardar 4 usando while s[i:]y luego puede reducirlo a 93 bytes enviando un recursivo lambda(las funciones solo necesitan devolver el resultado en lugar de imprimirlo ellos mismos).
Jonathan Allan el
2

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

Wernisch
fuente
2

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

introspec
fuente
1

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                
Zacharý
fuente
1

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)

Jonathan Allan
fuente
Estoy revisando esto mucho más tarde y me doy cuenta de que esto podría ser de 68 bytes:def f(s):h=[4,5,3][ord(s[0])*ord(s[1])%83%7%3];print(s[:h]);f(s[h:])
Lynn
Oh wow, ¿ h(s)y h(s)cómo no me di cuenta? Gracias Lynn!
Jonathan Allan
No estoy seguro de cómo sigo volviendo a esta pregunta y notando cosas nuevas, ¡pero h=(ord(s[0])*ord(s[1])%83%7+1)%3+3son 65 bytes! :)
Lynn
Je, gracias Lynn, ¡eso permitió que se jugaran dos bytes más también!
Jonathan Allan
0

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.

Lynn
fuente
0

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

J42161217
fuente
0

Perl 6 ,  42  30 bytes

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

Pruébalo

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

Pruébelo
(Traducido de otras respuestas)

Brad Gilbert b2gills
fuente
0

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:

callejero
fuente