[Question]
  [
# Task
Given a string of English names of digits “collapsed” together, like this:
```
zeronineoneoneeighttwoseventhreesixfourtwofive
```
Split the string back into digits:
```
zero nine one one eight two seven three six four two five
```
# Rules
* The input is always a string. It always consists of one or more lowercase English digit names, collapsed together, and nothing else.
	+ The English digit names are `zero one two three four five six seven eight nine`.
* The output may be a list of strings, or a new string where the digits are delimited by non-alphabetic, non-empty strings. (Your output may also *optionally* have such strings at the beginning or end, and the delimiters need not be consistent. So even something like `{{ zero0one$$two );` is a valid (if absurd) answer for `zeroonetwo`.)
* The shortest answer in bytes wins.
# Test cases
```
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
```
  
[Answer]
# [Retina](https://github.com/m-ender/retina), 20 bytes
```
!`..[eox]|[tse]?....
```
[Try it online!](https://tio.run/##HYxRDoAgDEPP4gW4ggchJPpRZD8sgYnEePe50eyn7esahOqpuh0hRPBMX5SOtAeT6ovGlSp4HegqIg93DFQpDeg0M9/NskwDThtmbpXeeGzQWqy5f/sB "Retina – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~89 80 76 75 72 71 70~~ 69 bytes
```
f(char*s){*s&&f(s+printf(" %.*s",""[(*s^s[2])%12],s)-1);}
```
[Try it online!](https://tio.run/##XY/RisIwEEWRti9@RYgoSbfK6quLPyIuSDsxA5pIJ9Wi@O3dJN1CaSCZZGbuuZNyfSnLboGmvDYVsB9yFdqNPnRKlPpc5yTfOa1WStDXvUbjlOBsucmJFzydZUmaZWk6SxJ@FDn90nF3ksvt7lSQXG/l/tPdzmiEfM8XFSg0wDxHssrGWNwbR4JzuWdPjVcQ33LO/PIWTtcAvjC8AS/aEbajlMIHKNvUBA8wo7zxNlHu26eY2I9tpLmnDYgJMSrCZVAHnDUQXXyM0pGmdwrF/sA2CIYdQGOz4RtRNUW9oLbewbf2Q/hZ/weJ6NgeoEHy6f4A "C (gcc) – Try It Online")
(89) Credit to [gastropner](https://codegolf.stackexchange.com/a/148776/31443) for the XOR hash.  
(76) Credit to [Toby Speight](https://codegolf.stackexchange.com/a/148827/31443) for the idea of using 1st and 3rd.  
(75) Credit to [Michael Dorgan](https://codegolf.stackexchange.com/questions/148676/uncollapse-digits#comment363811_148826) for `'0'` → `48`.  
(72) Credit to [Michael Dorgan](https://codegolf.stackexchange.com/questions/148676/uncollapse-digits#comment363815_148826) and [Lynn](https://codegolf.stackexchange.com/questions/148676/uncollapse-digits#comment363897_148826) for literals with control characters.  
(69) Credit to [Lynn](https://codegolf.stackexchange.com/questions/148676/uncollapse-digits#comment364246_148826) for `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. */
```
[Answer]
# [Python 2](https://docs.python.org/2/), 50 bytes
```
import re
re.compile('..[eox]|[tse]?....').findall
```
[Try it online!](https://tio.run/##jUzBCsIwFLvvKwIeuh3swauIZ09@wNyh6Kt70L2W9rkp@O9zKHo2kJBAkvTQPspmnnlIMSsyVZnsOQ6JA9XG2pbivXu2Wqjb2wWmsZ7l4kKY/e70dxkrHAUOQhMCC6FEaO8UrKaAXGHK0IiU40g4mAEpuAfLFd5xttiumyplFoWvWdJN66aZjfaZqNBI8hG@y/L9peeRiK@96hR/fum8V@9gXg "Python 2 – Try It Online")
-3 thanks to [Lynn](https://codegolf.stackexchange.com/users/3852/lynn).  
-4 thanks to [Uriel](https://codegolf.stackexchange.com/a/148683/41024)'s [answer](https://codegolf.stackexchange.com/a/148683/41024)'s regex.
[Answer]
# Befunge, ~~87~~ ~~85~~ ~~81~~ 76 bytes
```
<*"h"%*:"h"$_02g-v1$,*<v%*93,:_@#`0:~
"@{&ruX;\"00^ !: _>_48^>+:"yp!"*+%02p0
```
[Try it online!](http://befunge.tryitonline.net/#code=PCoiaCIlKjoiaCIkXzAyZy12MSQsKjx2JSo5Myw6X0AjYDA6fgoiQHsmcnVYO1wiMDBeICE6IF8+XzQ4Xj4rOiJ5cCEiKislMDJwMA&input=dGhyZWVzZXZlbnNldmVuc2l4bmluZW5pbmVuaW5lZml2ZWVpZ2h0dHdvZml2ZWVpZ2h0c2l4dGhyZWVlaWdodA)
Befunge doesn't have any string manipulation instructions, so what we do is create a kind of hash of the last three characters encountered, as we're processing them.
This hash is essentially a three digit, base-104 number. Every time a new character is read, we mod the hash with 1042 to get rid of the oldest character, multiply it by 104 to make space for the new character, then add the ASCII value of the new character mod 27 (to make sure it doesn't overflow).
For comparison purposes, we take this value mod 3817, write it into memory (thus truncating it to 8 bits), which results in smaller numbers that are easier for Befunge to handle. The hashes we then have to compare against are 0, 38, 59, 64, 88, 92, 114, 117, and 123. If it matches any of those, we know we've encountered a character sequence that marks the end of a number, so we output an additional space and reset the hash to zero.
If you're wondering why base 104, or why mod 3817, those values were carefully chosen so that the hash list we needed to compare against could be represented in as few bytes as possible.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~55~~ ~~46~~ 43 bytes
*Saving 9 bytes thanks to Forty3/FrownyFrog*
*Saving 3 bytes thanks to Titus*
```
s->s.replaceAll("one|tw|th|f|z|s|.i"," $0")
```
[Try it online!](https://tio.run/##jZC/boMwEId3nuJkdQCpQd2jVuoDNEvGqoNLzsGpYyPbEJrCs9OzMVKXCgb8j7vv99kX3vGdaVBfTl9Tpbhz8Mal/skApPZoBa8QDmELcPRW6jOIPC1csafzMaPBee5lBQfQ8AyT27240mKjqPlVqZwZjYO/Db4exHAf3FBK9sjg4YkV0z60N@2novZE6Yw8wZUsUtD7B/AiKXw7j9fStL5s6JdXOtelyJmvLSIrotD/VSjPtXeyXy0UskNhWuuwQ71araXGKEDobSKRLfvo428mxG1yivSwWJJCND1u9KQ5AldJs2tomQfZB8zyBfxfseXRYte2gDtaQzYEmIXptkk6BkZIiAp1YU7AMRunXw "Java (OpenJDK 8) – Try It Online")
edit: Thank you for the welcome and explanation of lambdas! 
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~179~~ ~~159~~ ~~146~~ ~~139~~ ~~137~~ ~~116~~ ~~107~~ ~~103~~ 102 bytes
**Edit 1:**
(Added suggestions from **Mr. Xcoder** - thanks! - My macro version was same size as yours, but I like yours better.) 
**Edit 2:**
Changed char individual compares to calls to `strchr()`
**Edit 3:**
K&R's the var declarations (Eww!)
**Edit 4:**
When 1 macro is not enough...
**Edit 5:**
Redone with new algorithm suggested above. Thanks to **James Holderness** for this great idea!
**Edit 6:**
Removed 0 set as it seems to go there automatically - Master level code golf techniques used (commas, printf trick, etc.) - thanks **gastropner**!
**Edit 7:**
Use memchr and fixed a bug pointed out by **James Holderness**.
**Edit 7:**
Use `&&` on final check to replace `?` - thanks **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);}
```
[Try it online!](https://tio.run/##NYtLCoMwFAD3nkIEJdEUjJZqCUKP0YUbeTz7AjWWxE@pePb0A53NwMDA4QbgPQhSPQPqbOr4tpK@I4MmdVnGH/P07Qy4oIZimdfylMr8mEFcVGLAAciyKFGXa9vaeYsExWUtK3HmSfJ/qSkLrnavzRQOnTaMb0H4oWeR00@HC5rR4LSOvV7whfZnow1GXAW7fwM "C (gcc) – Try It Online")
Non-golfed (Which is still very golfy honestly...)
```
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;
}
```
Old, straight forward grep-esqe solution:
```
#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(' ');}}
```
Old, cleaner 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(' ');
    }
}
```
[Try it online!](https://tio.run/##PYtLDsIgEIb3PQXiokNbT0B6mGYchEQpAVQSwtkRjHU2/@sbvNwQaz1fSRlLzDH3jKg3P@CSpIJupyDyW5s7Aa5TmGeRHaCQaQ3Ro/bAYyC@tMbBd276A6VRcDoo2lOn@vd/TOIIxcHIxqalGhvZYzMWRB5YOwU8mBToRXa3xIUcSv0A "C (gcc) – Try It Online")
[Answer]
# JavaScript, 66 57 52 44 41 bytes
`s=>s.replace(/one|t[wh]|.i|[fsz]/g," $&")`
Pretty naive, but it works.
Nice catch by FrownyFrog to use 2 chars .. except for "one" which a pure 2 char check might mess up zeronine. Edit: the single `f` and `s` were good catches by FrownyFrog that I overlooked my first two golfs.
Thanks, Neil, for the suggestion of an unnamed lambda and being able to use a single char for `z` gets down to 52.
Titus comes up with a smaller RegEx. I feel we are heading toward Uriel's regex eventually.
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~24~~ 23 bytes
```
!`..[eox]|[fnz]...|.{5}
```
[Try it online!](https://tio.run/##HcjBDYAgDAXQWVygN6chJHr4SC9tAhUJ4uzVmLzTKzCW3X3ZiAK0xxmSjEhEk@71cR8oKizQH/jIZpdWNIjlAlTuSc/yXeKGFw "Retina – Try It Online") Edit: Saved 1 byte thanks to @FrownyFrog.
[Answer]
# 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);}
```
This works for any character encoding (including awkward ones like EBCDIC), because it doesn't use the numeric value of the input characters. Instead, it locates the first and third letters in a magic string. The distance between these indicates how many letters to advance with each print.
## Test program
```
#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}
```
[Answer]
# [J](http://jsoftware.com/), ~~37~~ 35 bytes
```
rplc'twthsiseeinionzef'(;LF&,)\~_2:
```
[Try it online!](https://tio.run/##XZDBDsIgDIbvPgUn0cR48Kjx6slHMNlhKVJjwABuyw6@OtJuzZQECC3///UPj5zNea/C69nq1CcbMQKgQ@9GMHpzul7Wu@3t0xyOGVrrlVF6hOAdOvC8AO82pd5H6MAlGwAiDsa/Q@kZ7ECvxMePS8nGol06BBVCJSZg6cqwfzBVrKeLeOeEHEtiVln4bTpwIL1s4vyOkqjsqkj0G4VflFOEEnSOwWRWE1PnLw)
[Answer]
# Z80 Assembly, 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
```
(It was fun to adapt the Uriel's cool regex to a regex-unfriendly environment).
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~106 bytes~~ ~~104~~ 102 bytes
-2 bytes thanks to @jxh
-2 bytes thanks to ceilingcat
```
c;f(char*s){for(char*t=" $&=B*,29/?";*s;)for(c=4+(index(t,(*s^s[1])+35)-t)/4;c--;)putchar(c?*s++:32);}
```
[Try it online!](https://tio.run/##dY/dagMhEEavm6dYpBR1s4Tm56KVJdDXKAkEO2bnIhrUJEtCnn2rs11o2eZCHRzP@UZd7bXuOq0M183OyyBuxvm@jjUrnl/qDzmdv83WTMmgBDXrZcnRfkHL45TLsA2frxtRLlaiimK2VLqqlDieYpZwvZahLN8Xc6HuHdpYHHZouZjcJk@Gs9h4ACZUkZ4HzlJF14D7JgZsxx2DZzDu5AOcwY7bFi2QM8EP3ERjSxHx4rLw/xjiczG4stxZoOh0kmGM9vH5Tb9hm7lhZd/v6OGnRD0wXsG7lJeIfqT0gZ@xKIGo7P5L3rtv "C (gcc) – Try It Online")
XOR is truly our greatest ally.
[Answer]
# [Retina](https://github.com/m-ender/retina), 28 bytes
```
t[ewh]|[zfs]|(ni|o)ne|ei
 $&
```
[Try it online!](https://tio.run/##DcqxDYAwDATAnikoEIKZUAqKD3HzlhKTIOTdDVdfhQnPCDswSvLjzS35RnHdCYdM87JGKGFDrVQg612zdDR5GjoIuYpR/gB@ "Retina – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~35 27~~ 23 bytes
Saved a lot of bytes by porting [Uriel's approach](https://codegolf.stackexchange.com/a/148683/59487).
```
:Q"..[eox]|[tse]?...."1
```
[Try it here!](https://pyth.herokuapp.com/?code=%3AQ%22..%5Beox%5D%7C%5Btse%5D%3F....%221&input=%22ninethreesixthree%22&debug=0) [Initial approach.](https://pyth.herokuapp.com/?code=%3AQ%22one%7Ctwo%7Cthree%7Csix%7Cseven%7Ce%3F....%221&input=%22ninethreesixthree%22&debug=0)
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 27 bytes
```
aR`[zfs]|one|[ent][iwh]`s._
```
Takes input as a command-line argument. [Try it online!](https://tio.run/##bVG7coMwEOz9FTeuQmH/SZq0DBNcHEaNYIDYjI2/Xb5dPUhmUlg@3e3trpbRjaE@yHHpJ9WjiHywqqyl7tovs1vZ5UXshknnbtoNP9OsN/UcoyNoCXsAeeeVXLa0s6MrvIJMihjp3EqZ5T6ALxKT05DRgI0Es@yC@yiyCPgHr3Rh/9zaHUZhlkVdaMmw0TorrlU5Fvbj4Vag8w9Evx3nxLi1S6fnkj2dJk7Z/aCpv4@UEnpyWmw9dBrMpwFjABZSCoH8xIGV8gDzVeBNCSDVEkP0FMWwVR0a@ZRnuHy19aObm82Wt1r90tTu3jftfP4OrxBOPvzz1d4 "Pip – Try It Online")
Simple regex replacement, inserts a space before each match of `[zfs]|one|[ent][iwh]`.
---
Jumping on the bandwagon of ~~stealing~~ borrowing Uriel's regex gives **[23 bytes](https://tio.run/##bVE7boUwEOw5xYoqFI8rJBdIlRIhkWIJbjACwkP5nN3ZGX9IpCBh9jszHha3hK6Sep9W1VpEHhg1VlL3Nu2bO1llIpahM7pDR/@@bnrozDYqgpKwhqHZzUosW7rQURWmAJNCRjh3kma/e@BFYGLaZBRgLUEvq@A@gkwCfD8rVdiXW5fCSMywsAsl2WyUzohrTbaF9Xi4E9P5BdBvxdkxbl3U6bpET6eRk/Y6KOrvJaWYnpQWWR@6etNpg9EAMymZQHzOAZX0GOatgJscgKvFhqgpkmGrqXp5ls/w@jS0baf@7L@6fdP@sbVnCN8h3F7CPz/sBw "Pip – Try It Online")** (with `-s` flag):
```
a@`..[eox]|[tse]?....`
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~23~~ 21 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ
```
A full program printing line-feed separated output. Note: once it's done it repeatedly prints empty lines "forever" (until a huge recursion limit or a seg-fault)
**[Try it online!](https://tio.run/##y0rNyan8///hjsXG/gGqlqbGquaqxtrGJycDRR7ubDmx/OHO1Q93dB1u////f1VqUX5eZl5qPhilZqZnlJSU5xenlqXmlWQUpaYWZ1ak5ZcWAcXSMstSAQ "Jelly – Try It Online")** (TIO output is accumulated, a local implementation will print line by line)
### How?
Starting with a list of characters, the program repeatedly:
1. finds the length of the first word of the list of characters using some ordinal mathematics;
2. prints the word plus a linefeed; and
3. removes the word from the head of the list of characters
The length of the first word is decided by inspecting the first three characters of the current list of characters (necessarily part of the first word). The program converts these to ordinals, multiplies them together, modulos the result by 953, modulos that by seven, modulos that by three and adds three:
```
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.
```
[Answer]
# C ~~168~~ ,~~145~~,~~144~~,141 bytes
EDIT: Tried init 'i' to 1 like so
> 
> a,b;main(i)
> 
> 
> 
To get rid of leading whitespace,  
but it breaks on input starting with three, seven or eight
**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;}
```
[Try it online](https://tio.run/##LU5dD4IwDHz3V6AGwwQTEEQSnP9lzE774GY2ROLXX8cyfLm2d9dr5eYs5TAsT6BQQ@DeIszSNOV8JhKsrwJ11LCXMjaqv04KraJFKBfJqmH1zaJuaQ6IiOdzTBqWiDdvwnx7OOzWGMcMVYTHYsrkvMoDF2R5NWJWElZZQViWW8JiXzHBkaf1ZxgcdKDbiwX6qgOHve81fWg0eJEq4PnSesEzE2CvzN1SmdSHGQO8yRNPsIZWiZ/Syfu/4Ne9ZzzzAw)
**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;}
```
[Try it online](https://tio.run/##LU5dD4IwDHz3V6AGwwQTEEQSnP9lzE774GY2ROLXX8cyfLm2d9dr5eYs5TAsT6BQQ@DeIszSNOV8JhKsrwJ11LCXMjaqv04KraJFKBfJqmH1zaJuaQ6IiOdzTBqWiDdvwnx7OOzWGMcMVYTHYsrkvMoDF2R5NWJWElZZQViWW8JiXzHBkaf1ZxgcdKDbiwX6qgOHve81fWg0eJEq4PnSesEzE2CvzN1SmdSHGQO8yRNPsIZWiZ/Syfu/4Ne9ZzzzAw)
**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;}
```
[Try it online!](https://tio.run/##PU3bbsMgDP2VtdKmsGQSSQCDUvYvBEHrh8FE0ou2br@eEVLtxT4@N9u3o7XLgo0ZPgyGaiTfPqZq@J2sCb7aP9t98zKS4TNhmPP9lIl6t8NmJI256/FwkK9Y1wR9he/sbrRupVAgJOVyvYRgwCisEHrKKYjiUR3tlJR8SwDtOq4oKxpI1fYtfwgt9AyEIEajpsPPsni8uPmUnFvBhLeCAwYXg5vcxYW8HR5PcxEKsw28@XhOeW3qNf43FeLLpZijmd/as/fxocSLZ33zBw)
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 constants gets unnecessary large by shifting a<<8  
but in case you can compare to strings somehow it should be the most natural
**146** Using string comparison
```
#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;}
```
[Using String comparison](https://tio.run/##LU5LDsIgEN17iooxgbYmLlyYVLwLxaGdhWAAP/F39TpD3cwb3m@wm8HaaVqdwKGHKr2N1rVEn2u1MG3fnQ16ierlQpTdV/Z6gGxHE6VS3SWSz0lRra1olktse9Wat@4Ph32NTaPQSTzuqiSeEINIInigme@8u3CNDHhjLuGDpqcfCGU06m33mSbWOJnHCMAPcpWdfdSV4AaeEHAYcxEKMw988AWCWb0HLiimQnAvRYmf28n7v1DixcNnfg)
Obfuscated
```
#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;}}
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 44 bytes
```
Ṛ¹Ƥz⁶ZUwÐ€“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳ¤$€Ẏḟ1Ṭœṗ
```
[Try it online!](https://tio.run/##y0rNyan8///hzlmHdh5bUvWocVtUaPnhCY@a1jxqmHNo0aElx2Ycm/SocZdZ1qGd1ke6dB/u2PZwZ/PRPUAi/SSQnHFsYujDXf3Vh3Y/3LHp0BIVoMaHu/oe7phv@HDnmqOTH@6c/v9w@9FJQIX//5dkFKWmFqeWpeZBiMyKvMy8VBhOyyxLTc1MzygpKc@Hs4FqwLrAHAA "Jelly – Try It Online")
[Answer]
Quite long one. You are welcome to golf it down.
# [R](https://www.r-project.org/), 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)}
```
[Try it online!](https://tio.run/##PY3BCsIwEER/JRQKG4xQ0qRUtNeA9/oBUhK7lw3EbS2I315jRQ9v2ZmdYdMaYhSnvVjDRANjJFhkiAlQIImJQ9vHM3E25dN1bofH4cqAxH285COgVBjAlUjlALXWqjZVplFGZ4zJtMrqg7J1o6yxUrqukq/PVyh4TN7f/ezpO3AhJP8j4Ow93kbmR/zvObO1NlHI9Q0 "R – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 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
```
[Try it online!](https://tio.run/##PYtBCoMwEEX3PcUQBBXbC0hzii66EBdSJ52hdpRk1CK9exos7eJ9/of/qAsPHIYYXXNrbeLgCqq1tE0O@TucT@vo@2A2GAVBV1ACBwGQQdgcO@mzjacrKxXWliFLaltVVDvQ@OxYwMI060U9ZMkzSh4x4ILyDX4JC/5wvCDynVTX8d/TZ7f2YeIH "Haskell – Try It Online")
**Explanation:**
```
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
```
[Answer]
# [Python 3 (no regex)](https://docs.python.org/3/), 85 bytes
```
i=3
while i<len(s):
	if s[i-3:i]in'ineiveroneghtwoureesixven':s=s[:i]+' '+s[i:]
	i+=1
```
[Try it online!](https://tio.run/##PYy9DsMgDAbn5inYSIQ6VGyoPEmU0SmfFBkE5O/pqZuqHWzZ0t2ls4bIthUPTmvthwZvuz1gIYXnQtyXwXU3zKqMuFuHCazBhI1yZHqFusc1ExUcG7F2xZdRIKOVNmK4SVzjHy1lcJVWq@FDk8DfhYMl95tZugSpSvZ/C3NZ1/MG "Python 3 – Try It Online")
[Answer]
# 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")
```
Places a space in front of: `z`, `on`, `tw`, `th`, `f`, `s`, `ei`, `ni`
[Answer]
# [Python 3](https://docs.python.org/3/), no regex, ~~83 68 65~~ 63 bytes
-15 thanks to Lynn (refactor into a single function)  
-3 more thanks to Lynn (avoid indexing into a list with more arithmetic)  
...leading to another save of 2 bytes (avoiding parenthesis with negative modulos) :)
```
def f(s):h=ord(s[0])*ord(s[1])%83%-7%-3+5;print(s[:h]);f(s[h:])
```
A function which prints the words separated by newlines and then raises an `IndexError`.
**[Try it online!](https://tio.run/##bZDRasMgFIavk6cQITRuLWyEsmHZk5Rcrcd5bjToaZfu5Z0eGygkgSTq8fv@o9OdrHdDShcwwvRRafvlw6WP57dRvdTR@6i6z6E7fHSH4fV4mgI6ysvajuqUkbPVo0rGB0EQSaATvSQbAOS@Fc@PBPyxFHFeFQzewPhriHADt6o6dMDCjG6LmcWZ/fTri24zg@kyWExF7R1wbv6zYEXW7LKlfnAu2PIW3XPwckimtoV/EHxOy0BtKHf/aIoDGCpqqXTb1OuW6KYrabnnS1ZtQ@Gei43pH3OYv2GislSB3U6l9A8 "Python 3 – Try It Online")** (suppresses the exceptions to allow multiple runs within the test-suite)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~40~~ 39 bytes
```
“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5xDiw4tOTbj2KRHjbvMsg7ttD7Spftwx7aHO5uP7gES6SeB5IxjE0Mf7uqvPrT74Y5NqY@a1gCRw9FJD3dOe7hrAZAd8nDHooe7u8Ei3v///1fKz0stKc9XAgA "Jelly – Try It Online")
## How it works
```
“¢¤Ƙƒ⁺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                
```
[Answer]
# [QuadS](https://github.com/abrudz/QuadRS), ~~21~~ 20 bytes
```
..[eox]|[tse]?....
&
```
[Try it online!](https://tio.run/##HYw7DoAwDEN3DsLYK3CQigEJl2ZpRH9UiLuHpFYW28@523EWEec8eOyfrwX75lTLKvIic6IEnge6Yq0PF3SkGjNQaARuWbNAHUYrpm6W1lis0FzMuX37AQ)
This is a port of [my retina answer](https://codegolf.stackexchange.com/a/148683/65326).
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 25 [bytes](https://github.com/abrudz/SBCS)
```
'..[eox]|[tse]?....'⎕S'&'
```
[Try it online!](https://tio.run/##fY49TgMxEIX7PcVoCwyS2QOkoaKgAArSRSmcZJy1tNjRerw//LSpCIKCkp4LUCNxlL3IYnsT2ApLtsfj9755YlOcrlpRmHXfsyyboWnmDzOyOD/L/GLd89sNO2J93@3e4VIoDdLpJSmj4di6xa2y1tcnSSKh277AP4gkCYgpWsLyF5Ik5BvRet/tPjmbMN5tX3n39MWA8e8P6buPf1ZYCot2eF9dT88ncCGhNQ5qoQnIgEUEyhFKUXNw66LlsHAElSjUCoyjjSMOJW4KsURIw/AUakU5pDLNhjSM8hKRDTWqdU5WNfunVBVK40qLFep9TyuN0eJlY2vUqSYSqDbBOqJEZSgOroAxGiPZ39HGRoHix3CoJogPO0DGQw6Ro2uMucPSeLKXDcN9vn2AiI3SAGQ/ "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 36 bytes
```
œṣj⁶;$}
W;“€ɗİẒmṫṃ¦¦ạỊɦ⁼Fḷeṭḷa»s2¤ç/
```
[Try it online!](https://tio.run/##JZA9TsNAGER7zkGPRJueK1BTbIijxJYcE34kJAIdZShoaBDIFASJCnBCZaDIMdYXWeaNJe/3ZnfnbeFxmEzOU/q7i83TuFt8DHYvdw4H3dVDd73a3v@@x/VyGpvX2Ny0dVvH9WPc3G7rbvF9EL8@Q2zehKN2M9tvn39e9lJKF6EsWEUeQHXqXTUqg/fD4qQ0s7n3s@zMCPOQE0J2PKoIeZaHwp@eYPKCyANAviCdiS1aFnFl8WGJWECWIIuJJdoSbbnPsOGAQ8Ay7ZF6k4SL4SUBqm9QJ7hNcJmSFiXgkkJfUqCkSz7uRF@JvvEZoz8lce6dBzsW//If "Jelly – Try It Online")
Algorithm:
```
for x in ['ze', 'ni', 'on', 'tw', 'th', ...]:
    replace x in input by space+x
```
I bet we can do even better.
[Answer]
# 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]])&
```
  
[Try it online!](https://tio.run/##PUzLCsIwEPyXCKJY0XqTEOlBBEHEF3gIOSyyTYI2lWSpnvLrsbTqYYYZ5lEBGayA7A1SKdIoiAG/GvtAeSZvnd6h02SKsFpkJHIOgrFvvvGIR7l1hBr9HiqcFfN4AqcxLjNQGYgQ@48L3DHSZKL4obVUAA@iT9a@fsqQ0TRXajxMpWRk2tuADbqe7NtZhz@UtkG02hC96r9uO92qM0ylDw "Wolfram Language (Mathematica) – Try It Online") 
TIO outputs an error message about "CountryData"(???)  
I don't know why this happens, but eveything works fine on Mathematica
[Answer]
# [Perl 6](https://perl6.org), ~~42~~ 30 bytes
```
*.comb(/<{(0..9).Str.uninames.lc.words}>/)
```
[Test it](https://tio.run/##VVNNT8MwDL3nV/iA0MpYymkSlE07wA0hIThyGa3HInVN1WRfTPtl3PhjxXbSFqQ2Sh2/9/wct8amnLZbh7Cb6jxTmyNc5rZAmLVXOrebj1F6fxrdaH2b6Fff6G1lquUGnS5zvbdN4c7zNGkFt/DoPMzg5c7b9PH5IdWlqdD9fEee9/04TTL1hY0lErTyoPlce7@3DndY@XWD6MxhZbcNxVZmhzCZAyOAIWDjKyigFBAcCBAICQyVAwarECcK2SiBcRZFAgV9KM5kWKCiI9EVIgkplu5K6xmlnkE3CAiNOXSmOgOBi7KGuqU8XgTIm4489kakuwb1VQVB2faqQ2uCg75Bwb4Ew2IOnNq9zPK30q47guplo0VhjisJi@SwSEH/zQ0NjhShJL5LKpCygnHqTDQv5JIklN29sxvmjM65k739UE8QYpCiqVOKh/mNRjFTdbmsYCxzmdHdNHFEiXp0Yap666/haoGHGnOPRQInBWDcpECsyyPwXxDTEv1kHCX3ufE7nGbq3P4C "Perl 6 – Try It Online")
```
{m:g/..<[eox]>||<[tse]>?..../}
```
[Test it](https://tio.run/##VVLBUsIwEL3nK/bgOCDS3jhQQA56c5xx9IYetCyQmdJ0mgBF4Mu8@WN1d5O22mkz6Wbfe/s2W2CZjeqdRdiPojRR2yNcp2aJMK1P2/E6jqLJAk31PjufJwtn8X12F9ETX2rJnTu0DqbwPHYmfni6j6NM52h/vqPUbD978dthEPcT9YWlyenAyIt6vXHuYCzuMXebEtHqamV2JcVWeo8wnAEjgCFgwicooBQQHAgQCAkMlQMGKx8nCtkogXEWRTwF/SjOZJinoiPRFSIJKZZuSmsZpZ5O1wsIja4aU40Bz0VZXd1SHi8C5E1DHnoj0k2D2qq8oGxb1a413kHbIG9fgn7RFac2H7P8rbTpjqBa2WBRmMNKwiLZLVLQf3NdgwOFL4nvkgqkLG@cOhPMC7kkCWVz7@yGOYNz7mRr39fjhRikaOqU4gF@pVFMVJF95DCQuUzobsowokTdu9J5sXO3cDPHqsDU4bIPJwWg7XCJWGRH4MkPaX2a4RdXRo/aEqRFhH@fk6hL/Qs "Perl 6 – Try It Online")  
(Translated from other answers)
[Answer]
# q/kdb+, ~~59~~ 51 bytes
**Solution:**
```
{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}
```
**Example:**
```
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"
```
**Explanation:**
Quick solution, probably better and more golfable approaches.
```
{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
```
**Notes:**
46 bytes with some simple golfing, replacing q calls with k ones, but still a hefty solution. 
`asc[(,/)x ss/:($)`z`one`tw`th`f`s`ei`ni]cut x:`
]