Hãy xem xét năm sinh vật biển nghệ thuật ASCII này:

1. Cá tiêu chuẩn: ><>hoặc<><
2. Cá tốc độ: >><>hay<><<
3. Cá khỏe: ><>>hoặc<<><
4. Cá co giãn: ><<<>hoặc<>>><
5. Cua: ,<..>,

Viết chương trình chấp nhận một chuỗi ký tự tùy ý <>,.. Nếu có một cách để diễn giải toàn bộ chuỗi là một loạt các sinh vật biển không chồng chéo, thì chuỗi đó phải được in lại với các khoảng trống được chèn giữa các sinh vật. Nếu giải thích này là không thể, không có gì nên được xuất ra (chương trình âm thầm kết thúc).

Ví dụ, chuỗi <><><>có thể được hiểu là hai cá ngược tiêu chuẩn. Đầu ra tương ứng sẽ là <>< ><>.

Một ví dụ khác, chuỗi ><>><>>chứa "phiên bản" của ...
^{(dấu ngoặc chỉ được thêm dưới dạng chỉ báo)}

• một vài con cá tiêu chuẩn: [><>][><>]>
• một con cá nhanh nhẹn: ><[>><>]>
• một con cá mạnh mẽ theo một vài cách: [><>>]<>>và><>[><>>]

tuy nhiên, chỉ ghép cặp một con cá tiêu chuẩn và một con cá mạnh mẽ [><>][><>>]kéo dài toàn bộ chuỗi không có ký tự chia sẻ cá (không có sự chồng chéo). Do đó, đầu ra tương ứng ><>><>>là ><> ><>>.

Nếu có nhiều cách chuỗi có thể được diễn giải, bạn có thể in bất kỳ một trong số chúng. (Và chỉ in một trong số chúng.) Ví dụ, <><<<><có thể được hiểu là một con cá tiêu chuẩn và một con cá mạnh mẽ: [<><][<<><]hoặc là một con cá tốc độ và một con cá tiêu chuẩn : [<><<][<><]. Vì vậy, <>< <<><hoặc <><< <><là đầu ra hợp lệ.

Cua chỉ để cho vui. Vì chúng không bắt đầu hoặc kết thúc bằng <hoặc >, chúng dễ xác định hơn nhiều (ít nhất là về mặt trực quan). Ví dụ: chuỗi

,<..>,><<<>,<..>,><>,<..>,<>>><,<..>,><>>,<..>,<<><,<..>,<><,<..>,>><>

rõ ràng sẽ tạo ra đầu ra

,<..>, ><<<> ,<..>, ><> ,<..>, <>>>< ,<..>, ><>> ,<..>, <<>< ,<..>, <>< ,<..>, >><>

Dưới đây là một số ví dụ về chuỗi (một trên mỗi dòng) không tạo ra đầu ra:

<><>
,<..>,<..>,
>>><>
><<<<>
,
><><>
,<><>,
<<<><><<<>>><>><>><><><<>>><>><>>><>>><>><>><<><

Chuỗi cuối cùng ở đây có thể được phân tích cú pháp nếu bạn loại bỏ hàng đầu <:

<<>< ><<<> >><> ><> ><> <>< <>>>< >><> >><> >><> ><>> <<><

^{(Có thể có các đầu ra khác có thể.)}

Chi tiết

• Chuỗi đầu vào sẽ chỉ chứa các ký tự <>,..
• Chuỗi đầu vào sẽ dài ít nhất một ký tự.
• Lấy đầu vào theo bất kỳ cách phổ biến nào (dòng lệnh, stdin) và xuất ra thiết bị xuất chuẩn.
• Mã ngắn nhất tính bằng byte thắng. ( Bộ đếm byte tiện dụng. ) Tiebreaker là bài trước.

Bình thường, 64 48 50 byte

#jdhfqzsTsm^+msXtjCk2U2"<>""
\r.1"",<..>,"dlzB

Trường hợp thử nghiệm.

Phiên bản không mất mãi mãi ( ) ở đây , với 52 byte.O(9n/3)

Đây là cách tiếp cận vũ phu, tạo ra tất cả các chuỗi và kiểm tra xem có bất kỳ tổng nào cho đầu vào không. Biểu đồ cá được nén dưới dạng ký tự, có biểu diễn nhị phân là >và <. Toàn bộ điều được gói trong một khối thử bắt để không có đầu ra xảy ra khi không tìm thấy kết quả.

Đây là một giải pháp.O(9n)

Một số ký tự bị tước ở trên, vì các ký tự điều khiển được sử dụng. Chúng được sao chép một cách trung thực tại liên kết trên.

đầu ra xxd:

0000000: 236a 6468 6671 7a73 5473 6d5e 2b6d 7358  #jdhfqzsTsm^+msX
0000010: 746a 436b 3255 3222 3c3e 2222 0a5c 7212  tjCk2U2"<>"".\r.
0000020: 141b 1d2e 3122 222c 3c2e 2e3e 2c22 646c  ....1"",<..>,"dl
0000030: 7a42                                     zB

Máy Turing không xác định, 20 trạng thái, 52 lần chuyển đổi (có thể là 882 byte)

Làm thế nào để bạn chuyển đổi này thành byte? Tôi đã viết các tệp (hoàn toàn không được đánh gôn) để thực thi cỗ máy này với Trình mô phỏng máy Turing ^{1 của} Alex Vinokur . wc -cxuất ra các mục sau (không bao gồm tệp mô tả và các tệp đầu vào):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

Dù sao, tôi đang chuẩn bị cho A-Levels về Khoa học Máy tính, vì vậy tôi nghĩ đây sẽ là một bài tập tốt (tôi không biết mình đang nghĩ gì). Vì vậy, đây là định nghĩa:

^{(chức năng chuyển đổi)}

Xin lỗi vì hình ảnh xấu, nhưng tôi không thể bận tâm với việc vẽ lại thứ này trên máy tính. Nếu bạn thực sự muốn giải mã các quy tắc chuyển đổi, tôi khuyên bạn nên đọc qua tệp quy tắc tôi đã liên kết ở trên.

Tôi đã sử dụng Xs thay vì khoảng trắng vì không gian khó hình dung ở đây và trình giả lập không chấp nhận khoảng trắng trong bảng chữ cái.

Khái niệm này khá đơn giản - q1 đến q4 được sử dụng để bắt cá mặt phải, q11 đến q14 được sử dụng để bắt cá mặt trái, q15 đến q19 cho cua và blob q5 đến q10 chỉ đơn giản là chèn một khoảng trống và di chuyển tất cả theo sau các ký tự bên phải.

Nếu chuỗi có thể hiểu được, nó chấp nhận chuỗi và băng chứa chuỗi có khoảng trắng được chèn. Mặt khác, nó từ chối chuỗi (tôi đoán điều này được coi là không có đầu ra - làm trống băng sẽ khá dễ dàng nhưng sẽ đòi hỏi nhiều quy tắc chuyển đổi và tôi không nghĩ rằng nó sẽ làm cho chức năng chuyển đổi đẹp hơn để xem xét).

_{¹ Lưu ý: Thật khó để biên dịch. Tôi đã phải chỉnh sửa các src/tape.cpptập tin và thay thế LONG_MAXvới 1<<30và sau đó đi đến demothư mục, chỉnh sửa các Makefile để thay thế EXE_BASENAMEvới turing.exevà thực hiện make. Sau đó vào thư mục chứa các tệp tôi đã viết và thực thi /path/to/turing/download/src/turing.exe meta.}

cá (vâng, cá đó), 437 byte

Điều này gây ấn tượng với tôi như một trong những nhiệm vụ lập trình trong đó chính xác một ngôn ngữ là đúng.

#!/usr/bin/fish

set the_fishes "><>" "<><" ">><>" "<><<" "><>>" "<<><" "><<<>" "<>>><" ",<..>,"
set my_fishes

function startswith
        set -l c (echo -n $argv[2]|wc -c)
        echo $argv[1]|cut -c(math $c+1)-
        test $argv[2] = (echo $argv[1]|cut -c-$c)
end

function pickafish
        set -l fix 1
            while true
                if test $fix -gt (count $the_fishes); return 1; end

                if not set rest (startswith $argv[1] $the_fishes[$fix])
                            set fix (math $fix+1)
                        continue
                end    
                set my_fishes $my_fishes $the_fishes[$fix]
                    if test -z $rest
                        echo $my_fishes
                            exit
                    end
                    if not pickafish $rest
                    set my_fishes $my_fishes[(seq (math (count $my_fishes) - 1))]
                    set fix (math $fix+1)
                        continue
                end
        end
end

pickafish $argv[1]

Phiên bản sau đây vẫn là câu trả lời dài nhất cho thử thách,

set t "><>" "<><" ">><>" "<><<" "><>>" "<<><" "><<<>" "<>>><" ",<..>,";set m;function p;set -l i 1;while true;test $i -gt 9; and return 1;if not set r (begin;set c (echo $t[$i]|wc -c);echo $argv[1]|cut -c$c-;test $t[$i] = (echo $argv[1]|cut -c-(math $c-1));end);set i (math $i+1);continue;end;set m $m $t[$i];if test -z $r;echo $m;exit;end;if not p $r;set m $m[(seq (math (count $m)-1))];set i (math $i+1);continue;end;end;end;p $argv[1]

nhưng vì điều này được thực hiện chủ yếu cho trò chơi chữ (bạn sẽ xin lỗi, tôi hy vọng), chơi golf tốt hơn là một bài tập cho người đọc.

> <>, 602 byte

0&>i:0)?vr>:5%4-?v}:5%?;}:5%1-?;}:5%1-?;}:5%2-?;}:5%4-?;}&~0& v
  \     /        >:5%2-?v}:5%2-?v}:5%?v}:5%2-?v}              v
 &:?v;>*} ^      v      <       >:5% ?v}:5%?v} :5% ?v}:5%2-?v}v
v&-1< ^48<                                  >: 5%2-?v}:5%2-  ?v&1+&0}}v
>    :?v~^       >:5%?v}:5%?v}:5%2-  ?v}:5%  ?v}              v
^~v?%8:<                    >:5%2-?v}: 5%2-?v} :5%2- ?v}:5%?v}v
^{<        >0>=?;:v                         >: 5%    ?v}:5%  ?v&1+&0}}v
           ^lo~<  <   >            >  >       >     > >     >  02.
          \}*48^?=i:                                          <       <

Một giải pháp trong Fish, có lẽ rất có thể chơi được nhưng đó là chương trình> <> đầu tiên của tôi. Nó lấy đầu vào từ ngăn xếp đầu vào và chạy trên trình thông dịch> <> trực tuyến.

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

Một vòng lặp đọc tất cả các đầu vào và sắp xếp nó, đảo ngược nó và đặt -1 ở dưới cùng sẽ đánh dấu việc phân tích cú pháp hoàn tất (tất cả các ký tự nằm trên ngăn xếp cho đến khi chuỗi được coi là có thể phân tích cú pháp).
Việc phân tích cú pháp sử dụng thực tế tất cả các ký tự là modulo 5 khác nhau và tất cả các mẫu đều mang tính xác định ngoại trừ <> << và> <>>. Các ký tự phân tích được đặt ở dưới cùng của ngăn xếp.
Khi một mẫu hoàn thành, nếu -1 ở trên cùng, tất cả các ký tự được in, nếu không, một khoảng trắng được thêm vào và các vòng lặp chương trình.
Nếu gặp phải <> << hoặc> <>>, thanh ghi được tăng lên (0 khi bắt đầu) và 0 được đặt trên ngăn xếp trước ký tự cuối cùng (sao cho <> <hoặc> <> ở lại sau khi quay lại) . Nếu một lỗi xuất hiện sau đó trong quá trình phân tích cú pháp, thanh ghi bị giảm, tất cả các ký tự sau 0 được đặt trở lại trên cùng (ngoại trừ khoảng trắng nhờ kiểm tra% 8 = 0).
Nếu một lỗi được phát hiện trong khi thanh ghi bằng 0 hoặc bên trong cua, chương trình sẽ kết thúc ngay lập tức.

Con trăn 3, 156

*l,s=[],input()
for _ in s:l+=[y+[x]for x in"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,".split()for y in l]
for y in l:
 if"".join(y)==s:print(*y);break

Chiến lược là tạo ra danh sách các loài cá và so sánh sự kết hợp của chúng với chuỗi đầu vào.

Điều này mất nhiều thời gian. Nếu bạn thực sự muốn thấy một đầu ra, thay thế for _ in sbằng for _ in [0]*3, trong đó 3 là giới hạn trên của số lượng cá. Nó hoạt động để sử dụng svì schứa nhiều nhất một con cá trên mỗi char.

Cảm ơn Sp3000 cho các lỗi và lưu char vào đầu vào.

165 cũ:

f=lambda s:[[x]+y for x in"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,".split()for y in f(s[len(x):])if s[:len(x)]==x]if s else[[]]
y=f(input())
if y:print(*y[0])

Perl, 81 + 1 byte

/^((>><>|><(|>|<<)>|<><<|<(|<|>>)><|,<\.\.>,)(?{local@a=(@a,$2)}))*$(?{say"@a"})/

Hãy thử mã này trực tuyến.

Mã này mong đợi đầu vào trong $_ biến; chạy cái này với -ncông tắc của Perl ( được tính là 1 byte ) để áp dụng nó cho từng dòng đầu vào, ví dụ như thế này:

perl -nE '/^((>><>|><(|>|<<)>|<><<|<(|<|>>)><|,<\.\.>,)(?{local@a=(@a,$2)}))*$(?{say"@a"})/'

Mã này sử dụng công cụ regrec của Perl (và cụ thể là tính năng thực thi mã nhúng của nó ) để thực hiện tìm kiếm quay lui hiệu quả. Các cá riêng lẻ được tìm thấy được thu thập trong @amảng, được xâu chuỗi và in nếu trận đấu thành công.

Mã này cũng sử dụng saytính năng Perl 5.10+ và do đó phải được chạy bằng -Ehoặc -M5.010chuyển đổi (hoặc use 5.010;) để bật các tính năng hiện đại như vậy. Theo truyền thống, các công tắc như vậy chỉ được sử dụng để kích hoạt một phiên bản ngôn ngữ cụ thể không được bao gồm trong số byte.

Ngoài ra, đây là phiên bản 87 byte không yêu cầu chuyển đổi dòng lệnh đặc biệt nào cả. Nó đọc một dòng từ stdin và in kết quả (nếu có) sang thiết bị xuất chuẩn, mà không có bất kỳ dòng cấp dữ liệu nào:

<>=~/^((>><>|><(|>|<<)>|<><<|<(|<|>>)><|,<\.\.>,)(?{local@a=(@a,$2)}))*$(?{print"@a"})/

Thi thiên Nếu việc in thêm một khoảng trống ở đầu ra được cho phép, tôi có thể tiết kiệm đáng kể hai byte nữa bằng:

/^((>><>|><(|>|<<)>|<><<|<(|<|>>)><|,<\.\.>,)(?{local$a="$a $2"}))*$(?{say$a})/

Python 3, 196 186 byte

F="><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,".split()
def g(s):
 if s in F:return[s]
 for f in F:
  i=len(f)
  if f==s[:i]and g(s[i:]):return[f]+g(s[i:])
R=g(input())
if R:print(*R)

Đệ quy đơn giản. ghoặc trả về một danh sách các con cá được phân tích cú pháp, hoặc Nonenếu chuỗi đầu vào không thể nhìn thấy được.

Python 2, 234 byte

Tôi đã thử một giải pháp regex Python trước, nhưng dường như không có cách nào để trích xuất các nhóm sau một trận đấu trên nhiều mẫu. Sau đây là một tìm kiếm đệ quy dường như làm tốt trên các trường hợp thử nghiệm.

a='><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,'.split()
def d(t,p=0):
 if p<len(t):
  for e in a:
   z=p+len(e)
   if e==t[p:z]:
    if z==len(t):return[e]
    c=d(t,z)
    if c:return[e]+c
c=d(raw_input())
if c:
 print' '.join(c)

Một bài kiểm tra ví dụ:

$ echo ",<..>,><<<>,<..>,><>,<..>,<>>><,<..>,><>>,<..>,<<><,<..>,<><,<..>,>><>" | python soln.py 
,<..>, ><<<> ,<..>, ><> ,<..>, <>>>< ,<..>, ><>> ,<..>, <<>< ,<..>, <>< ,<..>, >><>

Và phiên bản vô văn hóa:

fishtypes = '><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,'.split()

def getfish(t, p=0):
    if p < len(t):
        for afish in fishtypes:
            z = p+len(afish)
            if afish == t[p:z]:
                if z == len(t) :
                    return [afish]
                fishlist = getfish(t, z)
                if fishlist :
                    return [afish]+fishlist

fishlist = getfish(raw_input())
if fishlist:
    print ' '.join(fishlist)

C # - 319 byte

Giải pháp này rất đơn giản, hầu như không có gì để chơi Golf. Đây là một chương trình hoàn chỉnh, lấy đầu vào là một dòng từ STDIN và đưa kết quả ra STDOUT.

using C=System.Console;class P{static void Main(){C.Write(S(C.ReadLine()));}static string S(string c){int i=c.LastIndexOf(' ')+1;foreach(var o in"<>< ><> <<>< ><>> >><> <><< ><<<> <>>>< ,<..>,".Split()){string k=c+"\n",m=c.Substring(i);if(m==o||m.StartsWith(o)&&(k=S(c.Insert(i+o.Length," ")))!="")return k;}return"";}}

Nó chỉ đơn giản là cố gắng khớp từng con cá đến vị trí đầu tiên sau một khoảng trắng (hoặc ở đầu chuỗi) và khớp với từng loại cá với nó. Nếu con cá vừa vặn, thì nó gọi đệ quy bộ giải sau khi chèn khoảng trắng sau con cá, hoặc đơn giản trả về đầu vào của nó (với \ n vì lý do đầu ra) nếu chuỗi không khớp là nghĩa đen của cá (nghĩa là chúng ta đã tìm ra giải pháp) .

Tôi đã không thực hiện nhiều nỗ lực để cung cấp cho chuỗi cá cách xử lý kolmogorov thông thường, bởi vì nó không dài lắm và tôi không thể tìm ra cách rẻ tiền để đảo ngược chuỗi trong C # (Tôi không nghĩ LINQ sẽ trả tiền), vì vậy có thể có một số cơ hội ở đó, nhưng tôi hơi nghi ngờ điều đó.

using C=System.Console;

class P
{
    static void Main()
    {    
        C.Write(S(C.ReadLine())); // read, solve, write (no \n)
    }

    static string S(string c)
    {
        int i=c.LastIndexOf(' ')+1; // find start of un-matched string

        // match each fish
        foreach(var o in"<>< ><> <<>< ><>> >><> <><< ><<<> <>>>< ,<..>,".Split())
        {
            string k=c+"\n", // set up k for return if we have finished
            m=c.Substring(i); // cut off stuff before space
            if(m==o|| // perfect match, return straight away
               m.StartsWith(o)&& // fish matches the start
               (k=S(c.Insert(i+o.Length," "))) // insert a space after the fish, solve, assign to k
               !="") // check the solution isn't empty
                return k;
        }

        // no fish match
        return"";
    }
}

Haskell (Parsec) - 262

import Text.Parsec
c=words"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,"
p c d=choice[eof>>return[],lookAhead(choice$map(try.string)d)>>=(\s->try(string s>>p c c>>=(\ss->return$s:ss))<|>p c(filter(/=s)c))]
main=interact$either show unwords.runParser(p c c)()""

import sys

def unfish(msg,dict,start):
    if(len(msg[start:])<3):
        return "";
    for i in range(3,6):
        if (msg[start:start+i] in dict):
            if(start+i==len(msg)):
                return msg[start:start+i];
            else:
                ret = unfish(msg,dict,start+i);
                if ret != "":
                    return msg[start:start+i]+" "+ret;
    return ""

dict = {'><>':1,'<><':1,'>><>':1,'<><<':1,'><>>':1,'<<><':1,'><<<>':1,'<>>><':1,',<..>,':1};

print unfish(sys.argv[1],dict,0);

tôi là một chút của một con trăn noob vì vậy bỏ qua sự kỳ lạ: P

Ruby, 177 byte

Không phải là ngắn nhất nhưng là người đầu tiên trong ruby:

def r(e,p,m)t='';p.each{|n|t=e.join;return r(e<<n,p,m)if m=~/^#{t+n}/};(m==t)?e:[];end
puts r([],%w(><<<> <>>>< ><>> <<>< >><> <><< ><> <>< ,<..>,),gets.strip).join(' ')

Nỗ lực ở đây là để mở rộng đệ quy một biểu thức chính quy và khớp nó với đầu vào.
Nếu một kết quả khớp dài hơn được tìm thấy r () sẽ lặp lại, nếu không nó sẽ kiểm tra xem trận đấu cuối cùng có tiêu thụ toàn bộ chuỗi đầu vào hay không và sau đó chỉ xuất nó với các khoảng trắng được thêm vào.

CJam, 111 96 91 (hoặc 62 byte)

Một cách tiếp cận tham lam lặp đi lặp lại để tiếp tục tìm ra những gì tất cả các kết hợp cá có thể có khi bạn lặp đi lặp lại. Thực sự không chơi golf ngay bây giờ.

q_aa\,{{" È÷®µãÑø"255b5b" ><,."f=S/\f{)_3$#{;;;}{2$,>:P@a\a++}?PR+!{S:R*W<o}*}~}%}*];

Mã này chứa một số ký tự không thể in được, vì vậy hãy sử dụng liên kết dưới đây để tham khảo.

Cập nhật mã hóa chuỗi

Sẽ thêm lời giải thích sau khi chơi golf

Dùng thử trực tuyến tại đây

62 byte

Phiên bản siêu chậm. Điều này về cơ bản tạo ra tất cả các kết hợp và kiểm tra bằng với đầu vào.

L"¬ééãLù:9$"255b6b5," ><,."erS/aq:Q,*{m*}*{sQ=}=`"[]\""-

Điều này cũng chứa các ký tự không thể in được, vì vậy hãy dựa vào liên kết dưới đây.

Dùng thử trực tuyến tại đây

Haskell, 148 146 byte

main=mapM_ putStr.take 1.filter(all(`elem`words"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,").words).map concat.mapM(\a->[[a],a:" "])=<<getLine

Kiểm tra:

$ echo "><>><>>>" | runhaskell fishes.hs

$ echo "> <>> <>>" | cá runhaskell.hs

<>> <>>

Giải trình

Dựa trên câu trả lời trước đó của tôi cho một câu hỏi tương tự. Thuật toán chạy trong thời gian theo cấp số nhân.

Điều này đọc từ phải sang trái.

=<<getLine              -- Read a line from STDIN.
mapM(\a->[[a],a:" "])   -- Replace each letter 'a' by "a" or "a " in
                        -- all possible ways, collect results to a list.
map concat              -- Concatenate those lists-of-strings into strings.
filter(all(...).words)  -- Keep those whose words are correct fish.
take 1                  -- Discard all but the first one.
mapM_ putStr            -- Print each string in that 1- or 0-element list.
main=                   -- That is the main function.

Điều này sẽ không in một chuỗi kết thúc bằng một khoảng trắng, mặc dù các chuỗi như vậy cũng được tạo ra, bởi vì đối tác không có không gian của nó được tạo trước.

JavaScript (ES6), 164

Đệ quy, quét sâu đầu tiên.
Là một chương trình với I / O qua cửa sổ bật lên:

alert((k=(s,r)=>'><>0<><0>><>0<><<0><>>0<<><0><<<>0<>>><0,<..>,'.split(0)
.some(w=>s==w?r=w:s.slice(0,l=w.length)==w&&(t=k(s.slice(l)))?r=w+' '+t:0)?r:'')
(prompt()))

Là một chức năng có thể kiểm tra:

k=(s,r)=>'><>0<><0>><>0<><<0><>>0<<><0><<<>0<>>><0,<..>,'.split(0)
.some(w=>s==w?r=w:s.slice(0,l=w.length)==w&&(t=k(s.slice(l)))?r=w+' '+t:0)?r:''

Bộ kiểm tra (chạy trong bảng điều khiển Firefox / FireBug)

t=['<><><>', '><>><>>', '<><<<><',',<..>,><<<>,<..>,><>,<..>,<>>><,<..>,><>>,<..>,<<><,<..>,<><,<..>,>><>',
'<><>',',<..>,<..>,','>>><>','><<<<>',',','><><>',',<><>,',
'<<<><><<<>>><>><>><><><<>>><>><>>><>>><>><>><<><','<<><><<<>>><>><>><><><<>>><>><>>><>>><>><>><<><']

t.forEach(t=>console.log(t + ': ' +k(t)))

Đầu ra

<><><>: <>< ><>
><>><>>: ><> ><>>
<><<<><: <>< <<><
,<..>,><<<>,<..>,><>,<..>,<>>><,<..>,><>>,<..>,<<><,<..>,<><,<..>,>><>: ,<..>, ><<<> ,<..>, ><> ,<..>, <>>>< ,<..>, ><>> ,<..>, <<>< ,<..>, <>< ,<..>, >><>
<><>: 
,<..>,<..>,: 
>>><>: 
><<<<>: 
,: 
><><>: 
,<><>,: 
<<<><><<<>>><>><>><><><<>>><>><>>><>>><>><>><<><: 
<<><><<<>>><>><>><><><<>>><>><>>><>>><>><>><<><: <<>< ><<<> >><> ><> ><> <>< <>>>< >><> >><> >><> ><>> <<><

Ungolfed chỉ là chức năng k

function k(s)
{
  var f='><>0<><0>><>0<><<0><>>0<<><0><<<>0<>>><0,<..>,'.split(0) 
  var i, w, l, t

  for (w of f)
  {
    if (s == w)
    {
      return w
    } 
    l = w.length
    if (s.slice(0,l) == w && (t = k(s.slice(l))))
    {
      return w + ' ' + t
    }
  }
  return ''
}

Haskell, 148 142

p[]=[[]]
p s=[i:j|i<-words"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,",i==map fst(zip s i),j<-p$drop(length i)s]
    g s=unwords$head$p s++p[]

cái này sử dụng sự hiểu biết danh sách để lặp đi lặp lại trên con cá, chọn những con khớp với điểm bắt đầu và tiếp tục đệ quy.

Javascript (122 135 byte)

Không phải là golf nhất ở đây, có thể bị tước xuống một chút.

Đây là một regex dựa trên, và một chút khó khăn để tìm hiểu những gì đang xảy ra.

alert(prompt(R=RegExp,r='(<<?><|><>>?|,<\.\.>,|>><>|><<<>|<><<|<>>><)').match(R('^'+r+'+$'))[0].split(R(r+'(?=[>,]|$)','g')).join(' '))

Đây là một lót.

Về cơ bản, tôi kiểm tra cú pháp và sau đó tôi tách chuỗi dựa trên ký tự và nối nó lại với nhau.
Nó ném một ngoại lệ khi bạn cung cấp cho nó một đầu vào không hợp lệ.

Nếu nó không thể ném ngoại lệ (126 139 byte):

(i=prompt(R=RegExp,r='(<<?><|><>>?|,<\.\.>,|>><>|><<<>|<><<|<>>><)')).match(R('^'+r+'+$'))&&alert(i.split(R(r+'(?=[>,]|$)','g')).join(' '))

Cả hai đều là một lớp lót.
Cả hai đều làm việc theo cùng một cách.

Cảm ơn bạn @ edc65 vì đã phát hiện trường hợp cạnh không hoạt động tốt.

Bạn có thể kiểm tra nó ở đây (đầu ra sẽ được ghi vào tài liệu).

Nó dựa trên phiên bản đưa ra các ngoại lệ khi bạn giới thiệu mã không hợp lệ.

var alert=console.log=function(s){document.write(s)+'<br>';};
try{
alert(prompt(R=RegExp,r='(<<?><|><>>?|,<\.\.>,|>><>|><<<>|<><<|<>>><)').match(R('^'+r+'+\x24'))[0].split(R(r+'(?=[>,]|\x24)','g')).join(' '));
}catch(e){console.log(e);}

(Hiện tại, có một lỗi trên stack snippets, Tôi đã đăng trên metaNó đã được hỏi ngày hôm qua. Để nó hoạt động, tôi đã thay thế $bằng \x24, có cùng một đầu ra. Bạn có thể đọc về lỗi tại đây: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Scala, 299 byte

type S=String
type L[T]=List[T]
def c(s:S):L[L[S]]={val f=List("><>","<><",">><>","<><<","><>>","<<><","><<<>","<>>><",",<..>,").filter(s.startsWith);if(f.isEmpty)List(List(s)) else f.flatMap(i => c(s.drop(i.size)).map(i::_))}
def p(s:S)=println(c(s).find(_.last.isEmpty).fold("")(_.mkString(" ")))

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

val tests = Seq("><>", "<><", ">><>", "<><<", ">><>", "<><<", "><<<>", "<>>><", ",<..>,", "><>><>", "><><><", ",<..>,<><", "<<<><><<<>>><>><>><><><<>>><>><>>><>>><>><>><<><", "<<><><<<>>><>><>><><><<>>><>><>>><>>><>><>><<><")
tests.foreach(p)

Đầu ra

><> 
<>< 
>><> 
<><< 
>><> 
<><< 
><<<> 
<>>>< 
,<..>, 
><> ><> 
><> <>< 
,<..>, <>< 

<<>< ><<<> >><> ><> ><> <>< <>>>< >><> >><> >><> ><>> <<>< 

Java, 288 byte

public class F{public static void main(String[]q){d("",q[0]);}static System y;static void d(String a,String b){if(b.isEmpty()){y.out.println(a);y.exit(0);}for (String s : "><> <>< >><> <><< ><>> <<>< ><<<> <>>>< ,<..>,".split(" "))if(b.startsWith(s))d(a+" "+s,b.substring(s.length()));}}

Định dạng:

public class F {
    public static void main(String[] q) {
        d("", q[0]);
    }

    static System y;

    static void d(String a, String b) {
        if (b.isEmpty()) {
            y.out.println(a);
            y.exit(0);
        }
        for (String s : "><> <>< >><> <><< ><>> <<>< ><<<> <>>>< ,<..>,".split(" "))
            if (b.startsWith(s)) d(a + " " + s, b.substring(s.length()));
    }
}

Tôi đã không đi theo kích thước, nhưng đây là một cách dễ hiểu để làm điều này trong Dart.

const List<String> fish = const [
  "><>",
  "<><",
  ">><>",
  "<><<",
  "><>>",
  "<<><",
  "><<<>",
  "<>>><",
  ",<..>,"
];

String fishy(String input) {
  var chars = input.split("");
  if (chars.isEmpty || !chars.every((it) => [">", "<", ",", "."].contains(it))) {
    throw new Exception("Invalid Input");
  }

  var result = [];
  var i = 0;
  var buff = "";
  while (i < chars.length) {
    buff += chars[i];

    if (fish.contains(buff)) {
      result.add(buff);
      buff = "";
    } else if (chars.length == 6) {
      return "";
    }

    i++;
  }

  return result.join(" ");
}

void main() {
  print(fishy(",<..>,><<<>,<..>,><>,<..>,<>>><,<..>,><>>,<..>,<<><,<..>,<><,<..>,>><>"));
}

Con trăn 3 166 164 byte

def z(s,p=''):[z(s[len(f):],p+' '+s[:len(f)])for f in'<>< <><< <<>< <>>>< ><> >><> ><>> ><<<> ,<..>,'.split(' ')if s.startswith(f)]if s else print(p[1:])
z(input())

Giải pháp đệ quy. Đến bữa tiệc muộn, nhưng tôi nghĩ dù sao tôi cũng sẽ đăng nó vì nó đánh bại Sp300020 22 byte mà không cần phải bắt buộc trả lời.