考虑以下五个ASCII艺术海洋生物：

1. 标准鱼：><>或<><
2. 快速鱼：>><>或<><<
3. 健壮的鱼：><>>或<<><
4. 弹力鱼：><<<>或<>>><
5. 螃蟹： ,<..>,

编写一个接受任意字符字符串的程序<>,.。如果有一种方法可以将整个字符串解释为一系列不重叠的海洋生物，则应重新打印该字符串，并在生物之间插入单个空格。如果无法解释，则不输出任何内容（程序静默结束）。

例如，字符串<><><>可以解释为两个标准的鱼背对背。相应的输出为<>< ><>。

作为另一个示例，该字符串><>><>>包含...的“实例”
^{（仅将括号添加为指示符）}

• 几个标准鱼： [><>][><>]>
• 一条快鱼： ><[>><>]>
• 一个坚固的鱼在几个方面：[><>>]<>>和><>[><>>]

但是，只有标准鱼和坚固鱼的配对[><>][><>>]跨越了整个字符串，没有鱼共享字符（没有重叠）。因此，对应于的输出><>><>>为><> ><>>。

如果可以通过多种方式解释字符串，则可以打印其中任何一种。（并且仅打印其中之一。）例如，<><<<><可以解释为标准鱼和结实的鱼：[<><][<<><]，或者解释为快速鱼和标准鱼：[<><<][<><]。因此，<>< <<><或者<><< <><将是有效的输出。

螃蟹只是为了好玩。由于它们不是以<或开头或结尾>，因此更容易识别（至少在视觉上）。例如，字符串

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

显然会产生输出

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

以下是一些不产生任何输出的字符串示例（每行一个）：

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

如果删除开头，则可以解析这里的最后一个字符串<：

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

^{（可能还有其他可能的输出。）}

细节

• 输入字符串将仅包含字符<>,.。
• 输入字符串的长度至少为一个字符。
• 以任何常用方式（命令行，stdin）输入并输出到stdout。
• 以字节为单位的最短代码获胜。（方便的字节计数器。）抢劫犯是较早的帖子。

Pyth，64 48 50字节

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

测试用例。

此处不会永久使用（）的版本，以52个字节为单位。O(9n/3)

这是蛮力方法，生成所有序列并检查输入是否有任何和。鱼图压缩为字符，其二进制表示形式为>和<。整个内容都包装在一个try-catch块中，这样在找不到结果时就不会有输出。

这是一个解决方案。O(9n)

由于使用了控制字符，因此上面去除了一些字符。在上面的链接中忠实地复制了它们。

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

非确定性图灵机，20个状态，52个转换（可能为882字节）

您如何将其转换为字节？我已经写了文件（绝对不打高尔夫球）以使用Alex Vinokur的图灵机模拟器¹来执行该机器。wc -c输出以下内容（不包括描述文件和输入文件）：

 12 alphabet
 49 meta
740 rules
 81 states
882 total

无论如何，我正在为我的计算机科学A级课程做准备，所以我认为这是一个很好的练习（我不知道自己在想什么）。所以这是定义：

^{（过渡功能）}

不好意思，但是我不会在计算机上重画这个东西。如果您确实想解密转换规则，建议您通读我上面链接的规则文件。

我用Xs代替了空格，因为在这里很难看到空格，并且模拟器不接受字母中的空格。

这个概念非常简单-q1至q4用于捕捉向右的鱼，q11至q14用于捕捉向左的鱼，q15至q19用于捕蟹，而q5至q10斑点仅用于插入空间并移动所有对象右边的一个字符。

如果字符串是可解释的，则它接受该字符串，并且磁带包含该字符串并插入空格。否则，它会拒绝字符串（我想这算作没有输出-清空磁带很简单，但需要很多转换规则，而且我认为它不会使转换函数更漂亮）。

_{¹注意：很难编译。我必须编辑src/tape.cpp文件并替换LONG_MAX为1<<30，然后转到demo目录，编辑Makefile替换EXE_BASENAME为turing.exe并执行make。然后转到包含我编写的文件的目录并执行/path/to/turing/download/src/turing.exe meta。}

鱼（是的，那条鱼），437字节

这使我印象深刻，因为其中一种编程语言恰好是正确的编程任务之一。

#!/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]

以下版本仍然是挑战的最长答案，

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]

但是由于这主要是针对双关语的操作（我希望您会找借口），因此，更好的打高尔夫球留给读者练习。

> <>，​​602个字节

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:                                          <       <

Fish的解决方案，可能非常适合打高尔夫，但这是我的第一个> <>程序。它从输入堆栈中获取输入，并在在线> <>解释器上运行。

这个怎么运作 ：

循环读取所有输入并将其堆叠，将其反转并在其最底端的-1上放置-1，这将表示分析已完成（所有字符都保留在堆栈上，直到该字符串被视为可分析的为止）。
解析使用以下事实：所有字符的模数都不相同5，除了<> <<和> <>>之外，所有模式都是确定性的。解析的字符放在堆栈的底部。
图案完成后，如果在顶部为-1，则将打印所有字符，否则将添加空格并循环程序。
如果遇到<> <<或> <>>，则寄存器递增（开始时为0），并且在最后一个字符之前将0放置在堆栈上（以便<> <或> <>在回滚后保留） 。如果在解析过程中之后出现错误，则减少寄存器，将0之后的所有字符放回顶部（由于％8 = 0测试，空格除外）。
如果在寄存器为0时或在螃蟹内部检测到错误，程序将立即结束。

Python 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

该策略是生成鱼的列表，并将它们的连接与输入字符串进行比较。

这不可能花很长时间。如果您确实想查看输出，请替换for _ in s为for _ in [0]*3，其中3是鱼的数量的上限。它可以使用，s因为s每个字符最多包含一条鱼。

感谢Sp3000的错误修复和输入字符的保存。

旧版165：

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字节

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

在线尝试此代码。

这段代码需要输入$_变量。使用Perl的-n开关（计数为+1个字节）运行此命令，以将其应用于每个输入行，例如：

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

该代码使用Perl的regexp引擎（特别是其嵌入式代码执行功能）来执行有效的回溯搜索。找到的单个鱼被收集在@a阵列中，如果匹配成功，则将其分类并打印。

该代码还使用了Perl 5.10+ say功能，因此必须使用-E或-M5.010开关（或use 5.010;）运行以启用此类现代功能。 传统上，仅用于启用特定语言版本的此类开关不包括在字节数中。

另外，这是一个87字节的版本，根本不需要特殊的命令行开关。它从stdin读取一行，并将结果（如果有的话）打印到stdout，而没有任何尾随换行符：

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

附言 如果允许在输出的开头打印额外的空间，我可以使用以下方法节省另外两个字节：

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

Python 3中，196个 186字节

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)

简单递归。g或者返回已解析的鱼的列表，或者None输入字符串不可解析。

Python 2，234字节

我首先尝试了Python正则表达式解决方案，但在多种模式匹配后似乎无法提取组。下面是一个递归搜索，似乎在测试用例上做得很好。

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)

测试示例：

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

和非高尔夫版本：

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字节

该解决方案非常简单，对于Golf几乎没有任何帮助。这是一个完整的程序，将输入从STDIN作为行，并将结果输出到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表示输出） 。

我没有做太多的尝试来给鱼串做普通的kolmogorov处理，因为它还不够长，而且我找不到在C＃中反转字符串的便宜方法（我不认为LINQ将支付），因此那里可能会有一些机会，但我对此有些怀疑。

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（秒差距）-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);

我有点蟒蛇菜鸟，所以忽略怪异：P

Ruby，177字节

不是最短的，而是第一个红宝石：

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(' ')

此处的尝试是递归扩展正则表达式并将其与输入匹配。
如果找到更长的匹配项，则r（）将递归，否则将检查最后一个匹配项是否消耗了整个输入字符串，然后才输出带有附加空格的字符串。

CJam，111 96 91（或62个字节）

一种迭代式贪婪方法，可在迭代过程中不断弄清所有鱼类的组合是可行的。现在真的不打高尔夫球。

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

该代码包含一些不可打印的字符，因此请使用下面的链接作为参考。

更新编码的字符串

打完高尔夫球将添加解释

在这里在线尝试

62个字节

超级慢版本。基本上，这将创建所有等于输入的组合和检查。

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

它还包含不可打印的字符，因此请依赖以下链接。

在这里在线尝试

Haskell，148 146字节

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

测试：

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

$ echo“> <>> <>>” | runhaskell fishes.hs

<>> <>>

说明

基于我之前对类似问题的回答。该算法以指数时间运行。

这从右到左读取。

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

即使也生成了这样的字符串，这也不会打印以空格结尾的字符串，因为首先会生成无空格的字符串。

JavaScript（ES6），164

递归，深度优先扫描。
通过弹出窗口作为具有I / O的程序：

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

作为可测试的功能：

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:''

测试套件（在Firefox / FireBug控制台中运行）

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

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

输出量

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

取消 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 ''
}

哈斯克尔，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[]

这使用列表理解来遍历鱼，选择与起点匹配的鱼，然后递归继续。

Javascript（122 135个字节）

这里不是打高尔夫球最多的人，可以将其剥离一些。

这是基于正则表达式的，并且很难弄清楚到底发生了什么。

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

这是一线。

基本上，我检查语法，然后根据char拆分字符串并将其连接在一起。
输入无效的输入会引发异常。

如果无法抛出异常（126 139个字节）：

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

两者都是一线。
两者的工作方式相同。

感谢@ edc65检测到无法正常工作的边缘情况。

您可以在此处进行测试（输出将被写入文档）。

它基于引入无效代码时会引发异常的版本。

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

（当前，堆栈摘要中存在一个错误， 我有 张贴在meta上昨天已经有人问过了。为了使其正常工作，我用替换$了\x24，后者具有相同的输出。您可以在此处阅读有关该错误的信息：http : //meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js）

Scala，299字节

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

测试用例

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

输出量

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

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

Java，288个字节

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

格式：

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

我并没有想要大小，但这是在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(",<..>,><<<>,<..>,><>,<..>,<>>><,<..>,><>>,<..>,<<><,<..>,<><,<..>,>><>"));
}

Python 3， 166 164字节

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

递归解决方案。派对晚了，但我认为我还是会发布它，因为它击败了Sp300020 22个字节，而无需蛮力回答。