Bài tập, nhiệm vụ

Đưa ra một chuỗi tên tiếng Anh của các chữ số, sập xuống cùng nhau, như thế này:

zeronineoneoneeighttwoseventhreesixfourtwofive

Chia chuỗi lại thành các chữ số:

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

Quy tắc

• Đầu vào luôn là một chuỗi. Nó luôn bao gồm một hoặc nhiều tên chữ số tiếng Anh viết thường, được thu gọn lại với nhau và không có gì khác.

  • Tên chữ số tiếng Anh là zero one two three four five six seven eight nine.

• Đầu ra có thể là một danh sách các chuỗi hoặc một chuỗi mới trong đó các chữ số được phân tách bằng các chuỗi không phải là chữ cái, không trống. (Đầu ra của bạn cũng có thể tùy ý có các chuỗi như vậy ở đầu hoặc cuối và các dấu phân cách không cần phải nhất quán. Vì vậy, ngay cả một cái gì đó giống như {{ zero0one$$two );là một câu trả lời hợp lệ (nếu vô lý) cho zeroonetwo.)

• Câu trả lời ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

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

Võng mạc , 20 byte

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

Hãy thử trực tuyến!

C (gcc) , 89 80 76 75 72 71 70 69 byte

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

Hãy thử trực tuyến!

(89) Tín dụng cho người ăn uống cho băm XOR.
(76) Tín dụng cho Toby Speight cho ý tưởng sử dụng thứ 1 và thứ 3.
(75) Tín dụng cho Michael Dorgan cho '0'→ 48.
(72) Tín dụng cho Michael Dorgan và Lynn cho các chữ có ký tự điều khiển.
(69) Tín dụng cho Lynn cho x?y:0→x&&y

f (char *s) {        /* K&R style implicit return type. s is the input. */
    *s&&f(           /* Recurse while there is input. */
        s+printf(    /* printf returns the number of characters emitted. */
            " %.*s", /* Prefix each digit string with a space. Limit
                      * how many bytes from the string to print out. */
            ""
                     /* Magic hash table, where the value represents
                      * the length of the digit string. The string
                      * is logically equivalent to
                      * "\04\01\05\03\04\05\05\04\04\01\03\03" */
            [(*s^s[2])%12],
                     /* The XOR hash (mod 12) */
            s)       /* The current digit. */
            -1);}    /* Subtract 1 for the space. */

Python 2 , 50 byte

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

Hãy thử trực tuyến!

-3 cảm ơn Lynn .
-4 cảm ơn regex của câu trả lời của Uriel .

Befunge, 87 85 81 76 byte

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

Hãy thử trực tuyến!

Befunge không có bất kỳ hướng dẫn thao tác chuỗi nào, vì vậy những gì chúng tôi làm là tạo ra một loại hàm băm của ba ký tự cuối cùng gặp phải, khi chúng tôi xử lý chúng.

Băm này về cơ bản là một số có ba chữ số, số cơ sở 104. Mỗi khi đọc một ký tự mới, chúng tôi sửa đổi hàm băm với 104 ² để loại bỏ ký tự cũ nhất, nhân nó với 104 để tạo khoảng trống cho ký tự mới, sau đó thêm giá trị ASCII của ký tự mới mod 27 (để đảm bảo nó không tràn).

Để so sánh, chúng tôi lấy giá trị này mod7, ghi nó vào bộ nhớ (do đó cắt nó thành 8 bit), điều này dẫn đến số lượng nhỏ hơn dễ dàng hơn để Befunge xử lý. Các giá trị băm mà sau đó chúng ta phải so sánh là 0, 38, 59, 64, 88, 92, 114, 117 và 123. Nếu nó khớp với bất kỳ trong số đó, chúng ta biết rằng chúng ta đã gặp một chuỗi ký tự đánh dấu sự kết thúc của một số, vì vậy chúng tôi xuất ra một không gian bổ sung và đặt lại hàm băm về không.

Nếu bạn đang tự hỏi tại sao cơ sở 104 hoặc tại sao mod 3817, các giá trị đó được chọn cẩn thận để danh sách băm mà chúng ta cần so sánh có thể được biểu thị bằng càng ít byte càng tốt.

Java (OpenJDK 8) , 55 46 43 byte

Tiết kiệm 9 byte nhờ Forty3 / FrownyFrog

Tiết kiệm 3 byte nhờ Tít

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

Hãy thử trực tuyến!

chỉnh sửa: Cảm ơn bạn đã chào đón và giải thích về lambdas!

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

Chỉnh sửa 1: (Đã thêm đề xuất từ Mr. Xcoder - cảm ơn! - Phiên bản macro của tôi có cùng kích thước với bạn, nhưng tôi thích của bạn hơn.)

Chỉnh sửa 2: Thay đổi char cá nhân so sánh với các cuộc gọi đếnstrchr()

Chỉnh sửa 3: K & R là khai báo var (Eww!)

Chỉnh sửa 4: Khi 1 macro không đủ ...

Chỉnh sửa 5: Làm lại với thuật toán mới được đề xuất ở trên. Cảm ơn James Holdiness vì ý tưởng tuyệt vời này!

Chỉnh sửa 6: Đã xóa 0 bộ vì nó dường như tự động đến đó - Các kỹ thuật chơi gôn mã cấp độ chính được sử dụng (dấu phẩy, thủ thuật printf, v.v.) - cảm ơn người ăn uống !

Chỉnh sửa 7: Sử dụng memchr và sửa một lỗi được chỉ ra bởi James Holdiness .

Chỉnh sửa 7: Sử dụng &&trên kiểm tra cuối cùng để thay thế ?- cảm ơn 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);}

Hãy thử trực tuyến!

Không chơi gôn (mà vẫn rất trung thực ...)

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

Giải pháp grep-esqe cũ, thẳng về phía trước:

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

Phiên bản cũ, sạch hơn.

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

Hãy thử trực tuyến!

JavaScript, 66 57 52 44 41 byte

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

Khá ngây thơ, nhưng nó hoạt động.

FrownyFrog rất hay sử dụng 2 ký tự .. ngoại trừ "một" mà kiểm tra 2 char thuần có thể làm hỏng zeronine. Chỉnh sửa: đĩa đơn fvà sđược bắt tốt bởi FrownyFrog mà tôi đã bỏ qua hai sân golf đầu tiên của mình.

Cảm ơn, Neil, vì gợi ý về một lambda chưa được đặt tên và có thể sử dụng một char duy nhất để zgiảm xuống còn 52.

Titus đưa ra một RegEx nhỏ hơn. Tôi cảm thấy cuối cùng chúng ta đang hướng tới regex của Uriel.

Võng mạc , 24 23 byte

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

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 1 byte nhờ @FrownyFrog.

C, 103 99 byte

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

Điều này hoạt động cho bất kỳ mã hóa ký tự nào (bao gồm cả mã hóa vụng về như EBCDIC), vì nó không sử dụng giá trị số của các ký tự đầu vào. Thay vào đó, nó định vị các chữ cái đầu tiên và thứ ba trong một chuỗi ma thuật. Khoảng cách giữa chúng cho biết có bao nhiêu chữ cái để tiến lên với mỗi bản in.

Chương trình kiểm tra

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

J , 37 35 byte

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

Hãy thử trực tuyến!

C (gcc) , 106 byte 104 byte

-2 byte nhờ @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);}

Hãy thử trực tuyến!

XOR thực sự là đồng minh lớn nhất của chúng tôi.

Võng mạc , 28 byte

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

Hãy thử trực tuyến!

Pyth , 35 27 23 byte

Đã lưu rất nhiều byte bằng cách chuyển cách tiếp cận của Uriel .

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

Hãy thử nó ở đây! Tiếp cận ban đầu.

Pip , 27 byte

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

Đưa đầu vào làm đối số dòng lệnh. Hãy thử trực tuyến!

Thay thế regex đơn giản, chèn một khoảng trắng trước mỗi trận đấu [zfs]|one|[ent][iwh].

Nhảy vào nhóm cướp ăn cắp regex của Uriel cho 23 byte (có -scờ):

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

Thạch ,  23  21 byte

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

Một chương trình in đầy đủ đầu ra tách dòng thức ăn. Lưu ý: một khi đã xong, nó liên tục in các dòng trống "mãi mãi" (cho đến khi giới hạn đệ quy rất lớn hoặc lỗi seg)

Hãy thử trực tuyến! (Đầu ra TIO được tích lũy, triển khai cục bộ sẽ in từng dòng)

Làm sao?

Bắt đầu với một danh sách các nhân vật, chương trình lặp đi lặp lại:

1. tìm độ dài của từ đầu tiên của danh sách các ký tự sử dụng một số toán học thứ tự;
2. in từ cộng với một dòng cho ăn; và
3. xóa từ khỏi đầu danh sách các ký tự

Độ dài của từ đầu tiên được quyết định bằng cách kiểm tra ba ký tự đầu tiên của danh sách các ký tự hiện tại (nhất thiết phải là một phần của từ đầu tiên). Chương trình chuyển đổi những thứ này thành các số thứ tự, nhân chúng lại với nhau, điều chỉnh kết quả bằng 953, điều chỉnh theo bảy, thay đổi số đó thành ba và cộng ba:

word   head3  ordinals       product  %953  %7  %3  +3 (=len(word))
zero   zer    [122,101,114]  1404708   939   1   1   4
two    two    [111,110,101]  1233210    28   0   0   3
one    one    [116,119,111]  1532244   773   3   0   3
three  thr    [116,104,114]  1375296   117   5   2   5
four   fou    [102,111,117]  1324674     4   4   1   4
five   fiv    [102,105,118]  1263780   102   4   1   4
six    six    [115,105,120]  1449000   440   6   0   3
seven  sev    [115,101,118]  1370570   156   2   2   5
eight  eig    [101,105,103]  1092315   177   2   2   5
nine   nin    [110,105,110]  1270500   151   4   1   4

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ - Main link, list of characters           e.g. "fiveeight..."
ḣ3              - head to index three                                "fiv"
  O             - ordinals                                           [102,105,118]
   P            - product                                            1263780
    %953        - modulo by 953                                      102
        %7      - modulo by seven                                    4
          %3    - modulo by three                                    1
            +3  - add three                                          4

              ɓ - dyadic chain separation swapping arguments...
... ḣṄȧṫḊÇ ...
    ḣ         - head to index                                        "five"
     Ṅ        - print the result plus a line-feed and yield the result
       ṫ      - tail from index                                      "eeight..."
      ȧ       - and (non-vectorising)                                "eeight..."
        Ḋ     - dequeue                                               "eight..."
         Ç    - call the last link (Main*) as a monad with this as input
              -       * since it's the only link and link indexing is modular.

C 168 ,145,144, 141 byte

EDIT: Đã thử init 'i' thành 1 like

a, b; chính (i)

Để thoát khỏi khoảng trắng hàng đầu,
nhưng nó phá vỡ đầu vào bắt đầu bằng ba, bảy hoặc tám

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

Dùng thử trực tuyến

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

Dùng thử trực tuyến

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

Hãy thử trực tuyến!

Ung dung

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
}

Các hằng số int trở nên lớn không cần thiết bằng cách thay đổi << 8
nhưng trong trường hợp bạn có thể so sánh với các chuỗi bằng cách nào đó thì nó sẽ tự nhiên nhất

146 Sử dụng so sánh chuỗi

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

Sử dụng so sánh chuỗi

Bị xáo trộn

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

Thạch , 44 byte

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

Hãy thử trực tuyến!

Khá dài. Bạn được chào đón để chơi nó xuống.

R , 109 byte

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

Hãy thử trực tuyến!

Haskell , 81 byte

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

Hãy thử trực tuyến!

Giải trình:

f(h:t)=                      h:f t -- recurse over input string
   [' '|s<-               ]++      -- and add a space for each string s
      words"z one tw th f s ei ni" -- from the list ["z","one","tw","th","f","s","ei","ni"]
      ,and$zipWith(==)s$h:t        -- which is a prefix of the current string

Python 3 (không có regex) , 85 byte

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

Hãy thử trực tuyến!

Excel, 181 byte

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

Đặt một không gian trước nhà: z, on, tw, th, f, s, ei,ni

Hội Z80, 46 45 byte

; 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

(Thật thú vị khi điều chỉnh regex tuyệt vời của Uriel sang môi trường không thân thiện với regex).

Thạch , 40 39 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK
“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»                 = the compressed string of the digit names
                        Ḳ                = split at spaces
                         e€€@ŒṖ          = check whether each member of each partition of the argument is a digit.
                               Ạ€        = A function that checks whether all values of an array are true, applied to each element.
                                 T       = Finds the index of each truthy element 
                                  Ḣ      = Grab the first element, since we have a singleton array
                                    ịŒṖ  = The previous command gives us the index, partition that splits the input into digits. This undoes it and gives us the partition.
                                       K = Join the array of digits with spaces                

QuadS , 21 20 byte

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

Hãy thử trực tuyến!

Đây là một cổng của câu trả lời võng mạc của tôi .

APL (Dyalog Unicode) , 25 byte

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

Hãy thử trực tuyến!

Python 3 , không có regex,  83 68 65  63 byte

-15 cảm ơn Lynn (tái cấu trúc thành một hàm duy nhất)
-3 nhờ vào Lynn (tránh lập chỉ mục vào danh sách có nhiều số học hơn)
... dẫn đến việc tiết kiệm thêm 2 byte (tránh dấu ngoặc đơn với modul âm) :)

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

Một chức năng in các từ được phân tách bằng dòng mới và sau đó tăng một IndexError.

Hãy thử trực tuyến! (loại bỏ các ngoại lệ để cho phép nhiều lần chạy trong bộ thử nghiệm)

Thạch , 36 byte

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

Hãy thử trực tuyến!

Thuật toán:

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

Tôi cá là chúng ta có thể làm tốt hơn nữa.

Toán học, 125 byte

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

Hãy thử trực tuyến!

TIO đưa ra một thông báo lỗi về "CountryData" (???)
Tôi không biết tại sao điều này xảy ra, nhưng việc truyền tải hoạt động tốt trên Mathematica

Perl 6 ,  42  30 byte

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

Kiểm tra nó

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

Kiểm tra nó
(Dịch từ các câu trả lời khác)

q / kdb +, 59 51 byte

Giải pháp:

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

Thí dụ:

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"

Giải trình:

Giải pháp nhanh chóng, có lẽ là cách tiếp cận tốt hơn và có thể chơi gôn hơn.

{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

Ghi chú:

46 byte với một số cách chơi golf đơn giản, thay thế các cuộc gọi q bằng k, nhưng vẫn là một giải pháp lớn.

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