태스크

다음과 같이 일련의 영어 숫자 자릿수가 "축소"되었습니다.

zeronineoneoneeighttwoseventhreesixfourtwofive

문자열을 숫자로 다시 나누십시오.

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

규칙

• 입력은 항상 문자열입니다. 항상 하나 이상의 소문자 영문 숫자 이름으로 구성되며 함께 축소되며 다른 것은 없습니다.

  • 영어 숫자 이름은 zero one two three four five six seven eight nine입니다.

• 출력은 문자열 목록이거나 숫자가 영숫자가 아닌 문자열로 구분되는 새 문자열 일 수 있습니다. (출력 의 시작 부분이나 끝 부분에 선택적으로 그러한 문자열이 있을 수 있으며 구분 기호는 일관되지 않아도됩니다. 따라서 {{ zero0one$$two );(거짓이 아닌 경우)에 대한 올바른 대답입니다 zeroonetwo.)

• 바이트 단위의 최단 답변이 이깁니다.

테스트 사례

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

레티 나 , 20 바이트

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

온라인으로 사용해보십시오!

C (gcc) , 89 80 76 75 72 71 70 69 바이트

f(char*s){*s&&f(s+printf(" %.*s",""[(*s^s[2])%12],s)-1);}

온라인으로 사용해보십시오!

(89) XOR 해시에 대한 가스 트로프 너의 기여 .
(76) 1과 3을 사용하는 아이디어에 대한 Toby Speight의 공로 .
로 (75) 신용 마이클 Dorgan 에 대한 '0'→ 48.
(72) 제어 문자가있는 리터럴에 대해서는 Michael Dorgan 및 Lynn 에게 감사 합니다.
(69) Lynn에 대한 크레딧 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. */

파이썬 2 , 50 바이트

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

온라인으로 사용해보십시오!

Lynn 덕분에 -3 . Uriel 의 답변 정규식
덕분에 -4 감사합니다 .

베 펀지, 87 85 81 76 바이트

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

온라인으로 사용해보십시오!

Befunge에는 문자열 조작 명령어가 없으므로 처리하는 동안 마지막 3 개의 문자를 일종의 해시로 만듭니다.

이 해시는 기본적으로 3 자리, 기본 -104 숫자입니다. 새 문자를 읽을 때마다 가장 오래된 문자를 제거하기 위해 104 ² 로 해시를 수정하고 새 문자를위한 공간을 만들기 위해 104를 곱한 다음 새 문자 mod 27의 ASCII 값을 추가합니다 (확인하기 위해) 넘치지 않습니다).

비교 목적으로, 우리는이 모드 mod 3817을 메모리에 쓰고 (따라서 8 비트로 자름), Befunge가 다루기가 더 쉬운 작은 숫자를 만듭니다. 그런 다음 비교해야 할 해시는 0, 38, 59, 64, 88, 92, 114, 117 및 123입니다.이 중 하나와 일치하면 문자 시퀀스가 ​​발생했음을 알 수 있습니다. 추가 공간을 출력하고 해시를 0으로 재설정합니다.

왜 base 104 또는 mod 3817인지 궁금하다면, 그 값을 신중하게 선택하여 비교해야 할 해시 목록을 가능한 한 적은 바이트로 표시 할 수 있습니다.

Java (OpenJDK 8) , 55 46 43 바이트

Forty3 / FrownyFrog 덕분에 9 바이트 절약

Titus 덕분에 3 바이트 절약

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

온라인으로 사용해보십시오!

편집 : 람다의 환영과 설명에 감사드립니다!

C (GCC) , 179 (159) 146 139 137 116 107 103 102 바이트

편집 1 : ( Xcoder 씨의 제안 추가 -감사합니다!-내 매크로 버전은 귀하의 크기와 동일하지만 더 좋습니다.)

편집 2 : 변경된 char 개별과 통화 비교strchr()

편집 3 : K & R의 var 선언 (Eww!)

편집 4 : 매크로가 충분하지 않은 경우 ...

편집 5 : 위에서 제안한 새로운 알고리즘으로 다시 실행하십시오. 이 훌륭한 아이디어에 대해 James Holderness 에게 감사드립니다 !

편집 6 : 자동으로 이동하는 것처럼 0 세트가 제거되었습니다-마스터 레벨 코드 골프 기술 (쉼표, printf 트릭 등)-고마워 gastropner !

편집 7 : memchr을 사용하고 James Holderness가 지적한 버그를 수정했습니다 .

7 편집 : 사용 &&대체하기 위해 최종 점검에 ?- 감사 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);}

온라인으로 사용해보십시오!

골프가 아닌 사람 (정직하게 골프를 치는 사람은 ...)

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

오래되고 곧은 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(' ');}}

오래되고 깨끗한 버전.

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

온라인으로 사용해보십시오!

자바 스크립트, 66 57 52 44 41 바이트

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

꽤 순진하지만 작동합니다.

FrownyFrog에 의해 2 문자를 사용하는 좋은 캐치 .. 순수한 2 문자 확인이 0을 엉망으로 만들 수있는 "하나"를 제외하고. 편집 : 싱글 f과 sFrownyFrog에 의해 좋은 캐치 내가 처음 두 골프를 간과했다.

명명되지 않은 람다를 제안하고 단일 문자를 사용할 수있는 z52 세로 감사 합니다.

Titus는 더 작은 RegEx를 제공합니다. 우리는 우리 엘레 (Uriel)의 정규 표현식으로 향하고 있다고 생각합니다.

레티 나 , 24 23 바이트

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

온라인으로 사용해보십시오! 편집 : @FrownyFrog 덕분에 1 바이트가 절약되었습니다.

C, 103 99 바이트

char*r="f.tzuonresn.xgv";f(char*s){*s&&f(s+printf("%.*s ",(strrchr(r,s[2])-strchr(r,*s))%10,s)-1);}

이것은 입력 문자의 숫자 값을 사용하지 않기 때문에 모든 문자 인코딩 (EBCDIC와 같은 어색한 문자 포함)에서 작동합니다. 대신, 마법의 문자열에서 첫 번째와 세 번째 문자를 찾습니다. 이 사이의 거리는 각 인쇄시 몇 개의 글자가 진행되는지 나타냅니다.

테스트 프로그램

#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}

J , 37 35 바이트

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

온라인으로 사용해보십시오!

C (gcc) , 106 바이트 104 바이트

@jxh 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

XOR은 진정으로 우리의 가장 위대한 동맹입니다.

레티 나 , 28 바이트

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

온라인으로 사용해보십시오!

Pyth , 35 27 23 바이트

Uriel의 접근 방식 을 이식하여 많은 바이트를 절약했습니다 .

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

여기 사용해보십시오! 초기 접근.

핍 , 27 바이트

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

입력을 명령 행 인수로 사용합니다. 온라인으로 사용해보십시오!

간단한 정규식 교체는의 각 일치 앞에 공백을 삽입합니다 [zfs]|one|[ent][iwh].

Uriel의 정규 표현식을 빌리 는 훔치기 의 악대를 뛰어 넘다가 23 바이트 ( -s플래그 포함)를 제공합니다.

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

젤리 ,  23  21 바이트

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

전체 프로그램 인쇄 라인 피드 분리 출력. 참고 : 일단 완료되면 빈 줄을 "영원히"반복적으로 인쇄합니다 (큰 재귀 한계 또는 세그 결함이있을 때까지)

온라인으로 사용해보십시오! (TIO 출력이 누적되고 로컬 구현은 라인별로 인쇄됩니다)

어떻게?

문자 목록으로 시작하여 프로그램은 다음을 반복적으로 수행합니다.

1. 일부 서수 수학을 사용하여 문자 목록에서 첫 번째 단어의 길이를 찾습니다.
2. 단어와 줄 바꿈을 인쇄합니다. 과
3. 문자 목록의 머리에서 단어를 제거합니다

첫 번째 단어의 길이는 현재 문자 목록의 첫 세 문자 (필수적으로 첫 번째 단어의 일부)를 검사하여 결정됩니다. 프로그램은 이들을 서수로 변환하고, 그것들을 곱하고, 결과를 953, 모듈로를 7로, 모듈로를 3으로, 3을 더합니다 :

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.

씨 168 ,145,144, 141 바이트

편집 : init 'i'를 1로 시도했습니다.

a, b; 메인 (i)

선행 공백을 제거하려면
3, 7, 8로 시작하는 입력에서 중단됩니다.

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

온라인으로 사용해보십시오

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

온라인으로 사용해보십시오

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

온라인으로 사용해보십시오!

언 골프

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 상수는 a << 8을 이동하여 불필요하게 커지지
만 문자열과 비교할 수있는 경우 가장 자연 스럽습니다.

146 문자열 비교를 사용하여

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

문자열 비교 사용

난독 화

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

젤리 , 44 바이트

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

온라인으로 사용해보십시오!

꽤 긴 것입니다. 당신은 그것을 골프에 오신 것을 환영합니다.

R , 109 바이트

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

온라인으로 사용해보십시오!

하스켈 , 81 바이트

f[c]=[c]
f(h:t)=[' '|s<-words"z one tw th f s ei ni",and$zipWith(==)s$h:t]++h:f t

온라인으로 사용해보십시오!

설명:

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

파이썬 3 (정규식 없음) , 85 바이트

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

온라인으로 사용해보십시오!

Excel, 181 바이트

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

앞에 공간을 배치합니다 : z, on, tw, th, f, s, ei,ni

Z80 어셈블리, 46 45 바이트

; 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

(우리엘의 멋진 정규식을 정규식이 아닌 환경에 적응시키는 것이 재미있었습니다).

젤리 , 40 39 바이트

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

온라인으로 사용해보십시오!

작동 원리

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

쿼드 , 21 20 바이트

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

온라인으로 사용해보십시오!

이것은 나의 망막 답변 의 포트입니다 .

APL (Dyalog Unicode) , 25 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 정규 표현식 없음,  83 68 65  63 바이트

Lynn 덕분에 -15 (단일 함수로 리팩터링)
-Lynn 덕분에 -3 더 산술 (더 많은 산술로 목록에 인덱싱하지 않음)
... 2 바이트의 또 다른 저장으로 이어짐 (음수 모듈로 괄호 피하기) :)

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

줄 바꿈으로 구분 된 단어를 인쇄 한 다음을 발생시키는 함수입니다 IndexError.

온라인으로 사용해보십시오! (테스트 스위트 내에서 다중 실행을 허용하도록 예외를 억제 함)

젤리 , 36 바이트

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

온라인으로 사용해보십시오!

연산:

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

더 잘할 수있을 것입니다.

Mathematica, 125 바이트

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

온라인으로 사용해보십시오!

TIO가 "CountryData"(???)에 대한 오류 메시지를 출력합니다.
왜 이런 일이 발생하는지 모르겠지만 Mathematica에서 eveything이 제대로 작동합니다.

펄 6 ,  42  30 바이트

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

그것을 테스트

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

그것을 테스트하십시오
(다른 답변에서 번역됨)

q / kdb +, 59 51 바이트

해결책:

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

예:

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"

설명:

빠른 솔루션, 더 좋고 더 골프 가능한 접근법.

{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

노트:

간단한 골프로 46 바이트, q 호출을 k로 대체하지만 여전히 무거운 솔루션입니다.

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