72
\$\begingroup\$

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
\$\endgroup\$
  • 28
    \$\begingroup\$ This is an excellent challenge! The task is extremely easy to understand and verify, but the right approach to use isn't very obvious. And choosing the right approach could make a huge difference in score. +1 :) \$\endgroup\$ – DJMcMayhem Nov 20 '17 at 17:27
  • 1
    \$\begingroup\$ After thinking this up, I remembered a similar, but more simplistic challenge on anarchy golf: yesno! It sparked some amazing C answers. I hope to see one of those soon :) \$\endgroup\$ – Lynn Nov 20 '17 at 17:41
  • \$\begingroup\$ I do not think my C answer qualifies as such, but hopefully it's a starting point for others with a more twisted sense of humor than myself. \$\endgroup\$ – Michael Dorgan Nov 20 '17 at 20:29
  • \$\begingroup\$ I'm pretty sure I've seen this same challenge, but where you're supposed to print the actual number. I'm almost certain it was also posted by, you, Lynn; but I've lost the link, hook me up with it? \$\endgroup\$ – Magic Octopus Urn Nov 20 '17 at 22:21
  • 3
    \$\begingroup\$ @MichaelDorgan (or any other C coders), you may want to have a look at the algorithm I used in my Befunge answer. A straight conversion of that to C got me a 104 byte solution, which I think beats all of the existing C answers. I'm willing to bet that could be improved upon by someone with more C golfing skills. \$\endgroup\$ – James Holderness Nov 21 '17 at 3:06

36 Answers 36

29
\$\begingroup\$

Retina, 20 bytes

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

Try it online!

\$\endgroup\$
17
\$\begingroup\$

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

Try it online!

(89) Credit to gastropner for the XOR hash.
(76) Credit to Toby Speight for the idea of using 1st and 3rd.
(75) Credit to Michael Dorgan for '0'48.
(72) Credit to Michael Dorgan and Lynn for literals with control characters.
(69) Credit to Lynn for 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. */
\$\endgroup\$
11
\$\begingroup\$

Python 2, 50 bytes

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

Try it online!

-3 thanks to Lynn.
-4 thanks to Uriel's answer's regex.

\$\endgroup\$
  • 3
    \$\begingroup\$ Nice! import re;re.compile('…').findall should save a couple of bytes. I did expect this to turn into regex golf :) \$\endgroup\$ – Lynn Nov 20 '17 at 17:11
  • \$\begingroup\$ @Lynn Hold on, wait until I'm done! :-P EDIT: It's 3 bytes, actually. \$\endgroup\$ – Erik the Outgolfer Nov 20 '17 at 17:12
  • \$\begingroup\$ @Lynn Also, you should've turned this to code-golf regular-expression instead. ;) \$\endgroup\$ – Erik the Outgolfer Nov 20 '17 at 17:24
  • \$\begingroup\$ I’m holding out for a C answer, which will be very interesting! \$\endgroup\$ – Lynn Nov 20 '17 at 17:33
9
\$\begingroup\$

Befunge, 87 85 81 76 bytes

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

Try it online!

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.

\$\endgroup\$
  • \$\begingroup\$ Quite honestly, this looks like bakemoji (ばけもじ) to me. Wow. The algorithm description is nice though and I will contemplate it. \$\endgroup\$ – Michael Dorgan Nov 21 '17 at 18:27
  • \$\begingroup\$ ^, I remember seeing the term as mojibake (もじばけ). How did you find those numbers (base 104, mod 3187), @JamesHolderness ? \$\endgroup\$ – Zacharý Nov 22 '17 at 22:31
  • \$\begingroup\$ @Zacharý I wrote a little Python script that tested different base and mod combinations to find the ones that would produce the correct results when run against all the expected inputs. Once I knew which combinations worked, I ran the resulting hash outputs through a Befunge number generator to find out which produced the shortest code. \$\endgroup\$ – James Holderness Nov 23 '17 at 0:32
6
\$\begingroup\$

Java (OpenJDK 8), 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!

edit: Thank you for the welcome and explanation of lambdas!

\$\endgroup\$
  • 3
    \$\begingroup\$ Hi, welcome to PPCG! Great first answer, and it indeed works. Here is the TIO link for it. Lambdas can be created in multiple ways. Here is another TIO with some lambdas with added comments so you can see how to create them yourself. (I suggest copying it to Eclipse so you can see the highlighting of the code.) Also, Tips for golfing in Java and Tips for golfing in all languages might be interesting to read. Enjoy your stay! :) \$\endgroup\$ – Kevin Cruijssen Nov 21 '17 at 10:55
  • \$\begingroup\$ @KevinCruijssen thank you! I am honestly suprised that Java is shorter than JavaScript. Usually when I am reading challenges, JS is a lot shorter. \$\endgroup\$ – Luca H Nov 21 '17 at 11:22
  • \$\begingroup\$ JavaScript should be 2 bytes shorter (g regex suffix instead of All). \$\endgroup\$ – Neil Nov 21 '17 at 13:29
  • \$\begingroup\$ @Neil it is longer here because it is using f=(s)=> instead of s->, which is 4 bytes shorter. \$\endgroup\$ – Luca H Nov 21 '17 at 13:42
  • 1
    \$\begingroup\$ @LucaH - per FrownyFrog's suggestion, you can reduce a few of your two-letter strings to single characters: z|f|s instead of ze|fo|fi|si|se/ \$\endgroup\$ – Forty3 Nov 21 '17 at 14:02
6
\$\begingroup\$

C (gcc), 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!

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!

\$\endgroup\$
  • \$\begingroup\$ We can macro the putchar and such for a few bytes, but in general, still thinking about a better algorithm if possible. \$\endgroup\$ – Michael Dorgan Nov 20 '17 at 20:17
  • \$\begingroup\$ 159 bytes by #defineing putchar and removing a pair of unnecessary brackets. \$\endgroup\$ – Mr. Xcoder Nov 20 '17 at 20:47
  • 2
    \$\begingroup\$ A bit ugly, but 136 bytes by using #define p putchar( instead (note the open parenthesis). \$\endgroup\$ – Tom Carpenter Nov 21 '17 at 9:11
  • 1
    \$\begingroup\$ 109 bytes c,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)));} \$\endgroup\$ – gastropner Nov 21 '17 at 22:21
  • \$\begingroup\$ Ah, the printf trick I saw below plus removal of a couple parenthesis and braces. Master level code golf enabled :) \$\endgroup\$ – Michael Dorgan Nov 21 '17 at 22:47
5
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Does it break if you use two characters and push 'on' to the end? \$\endgroup\$ – FrownyFrog Nov 20 '17 at 23:58
  • \$\begingroup\$ I'm thinking z|tw|th|f|s|ei|ni|on \$\endgroup\$ – FrownyFrog Nov 21 '17 at 0:03
  • 1
    \$\begingroup\$ @FrownyFrog o comes first so it is recognized first. \$\endgroup\$ – Uriel Nov 21 '17 at 0:21
  • 1
    \$\begingroup\$ on|t[wh]|.i|[fsz] (-4 bytes) \$\endgroup\$ – Titus Nov 21 '17 at 15:06
  • 2
    \$\begingroup\$ @Titus - Unfortunately, the on| will match zeronine rendering zer onine \$\endgroup\$ – Forty3 Nov 21 '17 at 15:13
5
\$\begingroup\$

Retina, 24 23 bytes

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

Try it online! Edit: Saved 1 byte thanks to @FrownyFrog.

\$\endgroup\$
  • 1
    \$\begingroup\$ would ..... -> .{5} work? \$\endgroup\$ – FrownyFrog Nov 22 '17 at 22:11
5
\$\begingroup\$

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("");
    }
}
\$\endgroup\$
  • 1
    \$\begingroup\$ Some bytes can be saved by using recursion: tio.run/##XY/… \$\endgroup\$ – jxh Nov 30 '17 at 20:14
4
\$\begingroup\$

J, 37 35 bytes

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

Try it online!

\$\endgroup\$
  • 2
    \$\begingroup\$ Cool alternative solution! I tried f=:[:>'..[eox]|[tse]?....'&rxall and it worked in interpeter, but doesn't work in TIO. \$\endgroup\$ – Galen Ivanov Nov 21 '17 at 10:21
  • \$\begingroup\$ this is really clever, well done \$\endgroup\$ – Jonah Nov 21 '17 at 14:13
  • \$\begingroup\$ @GalenIvanov TIO has the latest release, it could be a regression in J. \$\endgroup\$ – FrownyFrog Nov 21 '17 at 15:50
4
\$\begingroup\$

C (gcc), 106 bytes 104 bytes

-2 bytes thanks to @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);}

Try it online!

XOR is truly our greatest ally.

\$\endgroup\$
  • \$\begingroup\$ Like the s++ trick. Nice hash. \$\endgroup\$ – Michael Dorgan Nov 22 '17 at 0:11
  • 1
    \$\begingroup\$ s[1] will be shorter. \$\endgroup\$ – jxh Nov 22 '17 at 8:28
  • \$\begingroup\$ @jxh Nice one! Updated. \$\endgroup\$ – gastropner Nov 22 '17 at 8:44
3
\$\begingroup\$

Retina, 28 bytes

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

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Pyth, 35 27 23 bytes

Saved a lot of bytes by porting Uriel's approach.

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

Try it here! Initial approach.

\$\endgroup\$
3
\$\begingroup\$

Pip, 27 bytes

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

Takes input as a command-line argument. 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 (with -s flag):

a@`..[eox]|[tse]?....`
\$\endgroup\$
3
\$\begingroup\$

Jelly,  23  21 bytes

ḣ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! (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.
\$\endgroup\$
  • 1
    \$\begingroup\$ I am not sure whether this is allowed. (Seriously, what do you do when two greatly upvoted meta-answers say the opposite of each other?) \$\endgroup\$ – Ørjan Johansen Nov 25 '17 at 18:59
  • \$\begingroup\$ The OP explicitly states "Your output may also optionally have such strings at the beginning or end" and this program actually prints as it goes, so the output is produced prior to any forced termination anyway. \$\endgroup\$ – Jonathan Allan Nov 25 '17 at 19:01
  • \$\begingroup\$ Sure, but I don't think OP considered an infinite end string. And the meta-question is explicitly about the case where the output is printed first. \$\endgroup\$ – Ørjan Johansen Nov 25 '17 at 19:02
  • \$\begingroup\$ I think it fulfils the spirit of the requirement (if it, for example, printed infinite empty strings and then the words I might argue it did not) \$\endgroup\$ – Jonathan Allan Nov 25 '17 at 19:04
  • \$\begingroup\$ So, I guess that puts me into Martin's camp of "if it's a program and can justify..." :) \$\endgroup\$ – Jonathan Allan Nov 25 '17 at 19:08
3
\$\begingroup\$

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

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

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!

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

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;}}
\$\endgroup\$
2
\$\begingroup\$

Jelly, 44 bytes

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

Try it online!

\$\endgroup\$
  • 3
    \$\begingroup\$ Sorry man, you've been outgolfed twice. \$\endgroup\$ – Zacharý Nov 20 '17 at 21:53
2
\$\begingroup\$

Quite long one. You are welcome to golf it down.

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Any way to use unicode characters instead of digits? \$\endgroup\$ – Michael Dorgan Nov 21 '17 at 21:37
  • \$\begingroup\$ Nice application of intToUtf8! 90 bytes would be possible by using a different approach using regexp: function(x,p=paste,z=p("(",p(c("zero",broman::numbers),collapse="|"),")"))gsub(z,"\\1 ",x) \$\endgroup\$ – Michael M Apr 9 '18 at 11:49
2
\$\begingroup\$

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

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
\$\endgroup\$
2
\$\begingroup\$

Python 3 (no regex), 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!

\$\endgroup\$
  • 2
    \$\begingroup\$ Welcome to PPCG! \$\endgroup\$ – Laikoni Nov 23 '17 at 19:10
  • \$\begingroup\$ It's nice, but a full program must include the code to take input. \$\endgroup\$ – Jonathan Allan Nov 25 '17 at 15:24
  • \$\begingroup\$ So, as a full program 104 bytes. However you can save 4 by using while s[i:] and then you can get that down to 93 bytes by submitting a recursive lambda (functions only need to return the output rather than print it themselves). \$\endgroup\$ – Jonathan Allan Nov 25 '17 at 19:13
2
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

Jelly, 40 39 bytes

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

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                
\$\endgroup\$
1
\$\begingroup\$

QuadS, 21 20 bytes

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

Try it online!

This is a port of my retina answer.

\$\endgroup\$
1
\$\begingroup\$

APL (Dyalog Unicode), 25 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Python 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! (suppresses the exceptions to allow multiple runs within the test-suite)

\$\endgroup\$
  • \$\begingroup\$ I'm revisiting this a lot later and realizing this could be 68 bytes: def f(s):h=[4,5,3][ord(s[0])*ord(s[1])%83%7%3];print(s[:h]);f(s[h:]) \$\endgroup\$ – Lynn Apr 8 '18 at 6:34
  • \$\begingroup\$ Oh wow, h(s) and h(s) how did I not notice?! Thanks Lynn! \$\endgroup\$ – Jonathan Allan Apr 9 '18 at 7:11
  • \$\begingroup\$ I'm not sure how I keep coming back to this question and noticing new things, but h=(ord(s[0])*ord(s[1])%83%7+1)%3+3 is 65 bytes! :) \$\endgroup\$ – Lynn Jun 22 '18 at 16:59
  • \$\begingroup\$ Heh, thanks Lynn, that allowed two more bytes to be golfed off too! \$\endgroup\$ – Jonathan Allan Jun 22 '18 at 17:31
0
\$\begingroup\$

Jelly, 36 bytes

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

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.

\$\endgroup\$
0
\$\begingroup\$

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!

TIO outputs an error message about "CountryData"(???)
I don't know why this happens, but eveything works fine on Mathematica

\$\endgroup\$
0
\$\begingroup\$

Perl 6,  42  30 bytes

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

Test it

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

Test it
(Translated from other answers)

\$\endgroup\$
0
\$\begingroup\$

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:

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.