Considere estas cinco criaturas marinhas de arte ASCII:

1. Peixe normal: ><>ou<><
2. Peixe rápido: >><>ou<><<
3. Peixe resistente: ><>>ou<<><
4. Peixe elástico: ><<<>ou<>>><
5. Caranguejo: ,<..>,

Escreva um programa que aceite uma sequência arbitrária de caracteres <>,.. Se houver uma maneira de interpretar a sequência inteira como uma série de criaturas marinhas não sobrepostas, a sequência deverá ser reimpressa com espaços únicos inseridos entre as criaturas. Se essa interpretação for impossível, nada deve ser produzido (o programa termina silenciosamente).

Por exemplo, a cadeia <><><>pode ser interpretada como dois peixes padrão consecutivos. A saída correspondente seria <>< ><>.

Como outro exemplo, a cadeia ><>><>>contém "instâncias" de ...
^{(colchetes adicionados apenas como indicadores)}

• alguns peixes comuns: [><>][><>]>
• um peixe veloz: ><[>><>]>
• um peixe robusto de duas maneiras: [><>>]<>>e><>[><>>]

no entanto, apenas o emparelhamento de um peixe padrão e um peixe robusto [><>][><>>]abrange todo o comprimento da sequência, sem caracteres de compartilhamento de peixes (sem sobreposições). Assim, a saída correspondente a ><>><>>é ><> ><>>.

Se houver várias maneiras de interpretar a sequência, você pode imprimir qualquer uma delas. (E só imprimir uma . Delas) Por exemplo, <><<<><pode ser interpretado como um peixe padrão e um peixe resistente: [<><][<<><]ou como um peixe rápido e um peixe padrão: [<><<][<><]. Então, <>< <<><ou <><< <><seria uma saída válida.

Os caranguejos são apenas para diversão. Como eles não começam ou terminam com <ou >, eles são muito mais fáceis de identificar (pelo menos visualmente). Por exemplo, a sequência

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

obviamente produziria a saída

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

Aqui estão alguns exemplos de cadeias (uma por linha) que não produzem saída:

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

A última string aqui pode ser analisada se você remover a principal <:

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

^{(Pode haver outras saídas possíveis.)}

Detalhes

• A sequência de entrada conterá apenas os caracteres <>,..
• A sequência de entrada terá pelo menos um caractere.
• Pegue a entrada de qualquer maneira comum (linha de comando, stdin) e faça a saída para stdout.
• O código mais curto em bytes vence. ( Contador de bytes à mão. ) O desempatador é uma postagem anterior.

Pitão, 64 48 50 bytes

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

Caso de teste.

Versão que não demora para sempre ( ) aqui , em 52 bytes.O(9n/3)

Essa é a abordagem da força bruta, gera todas as seqüências e verifica se há alguma soma na entrada. Diagramas de peixes compactados como caracteres, cujas representações binárias são >e <. A coisa toda é agrupada em um bloco try-catch para que nenhuma saída ocorra quando nenhum resultado for encontrado.

Esta é uma solução.O(9n)

Alguns caracteres são removidos acima, porque caracteres de controle são usados. Eles são reproduzidos fielmente no link acima.

saída 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áquina de Turing não determinística, 20 estados, 52 transições (talvez 882 bytes)

Como você converte isso em bytes? Eu escrevi os arquivos (absolutamente sem golfe) para executar esta máquina com o Simulator of a Turing Machine ^{1 de} Alex Vinokur . wc -cgera o seguinte (excluindo o arquivo de descrição e os arquivos de entrada):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

De qualquer forma, eu estava me preparando para meus Níveis A de Ciência da Computação, então pensei que seria um bom exercício (não sei o que estava pensando). Então aqui está a definição:

^{(a função de transição)}

Desculpe a imagem ruim, mas não me incomodei em redesenhar essa coisa em um computador. Se você realmente deseja decifrar as regras de transição, recomendo que você leia o arquivo de regras vinculado acima.

Eu usei Xs em vez de espaços, porque os espaços são difíceis de visualizar aqui e o simulador não aceita espaços no alfabeto.

O conceito é bastante simples - q1 a q4 são usados ​​para capturar peixes virados para a direita, q11 a q14 são usados ​​para capturar peixes virados para a esquerda, q15 a q19 para caranguejos e o blob de q5 a q10 é simplesmente para inserir um espaço e mover tudo seguintes caracteres um para a direita.

Se a sequência for interpretável, ela será aceita e a fita conterá a sequência com os espaços inseridos. Caso contrário, ele rejeita a string (acho que isso não conta como saída - esvaziar a fita seria muito fácil, mas exigiria muitas regras de transição e não acho que tornaria a função de transição mais bonita de se olhar).

_{¹ Nota: É difícil compilar. Eu tive que editar o src/tape.cpparquivo e substituir LONG_MAXcom 1<<30e depois ir para o demodiretório, edite o Makefile para substituir EXE_BASENAMEcom turing.exee executar make. Em seguida, vá para o diretório com os arquivos que escrevi e executei /path/to/turing/download/src/turing.exe meta.}

peixe (sim, esse peixe), 437 bytes

Isso me parece uma daquelas tarefas de programação em que exatamente um idioma está certo.

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

A versão a seguir ainda é a resposta mais longa para o desafio,

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]

mas, como isso foi feito principalmente pelo trocadilho (desculpe, espero), o golfe é deixado como um exercício para o leitor.

> <>, 602 bytes

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

Uma solução em Fish, provavelmente muito jogável, mas é o meu primeiro> <> programa. Ele recebe sua entrada da pilha de entradas e é executado no intérprete online <>.

Como funciona :

Um loop lê todas as entradas e as empilha, inverte-as e coloca -1 na parte inferior, o que marcará que a análise está concluída (todos os caracteres permanecem na pilha até que a cadeia seja considerada analisável).
A análise usa o fato de que todos os caracteres são diferentes no módulo 5 e todos os padrões são determinísticos, exceto <> << e> <>>. Caracteres analisados ​​são colocados na parte inferior da pilha.
Quando um padrão é concluído, se -1 estiver no topo, todos os caracteres são impressos; caso contrário, um espaço é adicionado e o programa faz um loop.
Se <> << ou> <>> forem encontrados, o registro será incrementado (0 no início) e um 0 será colocado na pilha antes do último caractere (para que <> <ou> <> permaneça após a reversão) . Se um erro aparecer posteriormente durante a análise, o registro será diminuído, todos os caracteres após o 0 serão recolocados no topo (exceto espaços graças a um teste de% 8 = 0).
Se um erro for detectado enquanto o registro é 0 ou dentro do caranguejo, o programa termina imediatamente.

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

A estratégia é gerar listas de peixes e comparar sua concatenação com a sequência de entrada.

Isso leva impossivelmente tempo. Se você realmente deseja ver uma saída, substitua for _ in spor for _ in [0]*3, onde 3 é o limite superior para o número de peixes. Ele funciona, spois scontém no máximo um peixe por caractere.

Obrigado ao Sp3000 por correções de erros e um salvamento de caracteres na entrada.

Antigo 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 bytes

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

Experimente este código online.

Este código espera a entrada na $_variável; execute isso com o -nswitch do Perl ( contado como +1 byte ) para aplicá-lo a cada linha de entrada, por exemplo:

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

Esse código usa o mecanismo regexp do Perl (e especificamente seu recurso de execução de código incorporado ) para executar uma pesquisa de retorno eficiente. Os peixes individuais encontrados são coletados na @amatriz, que é codificada e impressa se a correspondência for bem-sucedida.

Este código também utiliza o Perl 5.10+ sayrecurso, e assim deve ser executado com o -Eou -M5.010switch (ou use 5.010;) para permitir que tais características modernas. Por tradição, essas opções usadas apenas para habilitar uma versão específica do idioma não são incluídas na contagem de bytes.

Como alternativa, aqui está uma versão de 87 bytes que não requer nenhuma opção especial de linha de comando. Ele lê uma linha de stdin e imprime o resultado (se houver) em stdout, sem nenhum avanço de linha final:

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

Ps. Se a impressão de um espaço extra no início da saída fosse permitida, eu poderia salvar trivialmente mais dois bytes com:

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

Python 3, 196 186 bytes

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)

Recursão simples. gou retorna uma lista de peixes analisados ​​ou Nonese a sequência de entrada não puder ser analisada.

Python 2, 234 bytes

Tentei primeiro uma solução regex Python, mas parece não haver maneira de extrair os grupos após uma correspondência em vários padrões. A seguir, é apresentada uma pesquisa recursiva que parece se sair bem nos casos de teste.

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)

Um exemplo de teste:

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

E a versão não destruída:

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 bytes

Esta solução é vergonhosamente simples, quase nada para o Golf. É um programa completo, recebe a entrada como uma linha do STDIN e envia o resultado para o 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"";}}

Ele simplesmente tenta corresponder cada peixe à primeira posição após um espaço (ou no início da corda) e combina cada tipo de peixe com ele. Se o peixe se encaixa, ele recursivamente chama o solucionador após inserir um espaço após o peixe, ou simplesmente retorna sua entrada (com a \ n por motivos de saída) se a string não correspondida for literalmente o peixe (ou seja, encontramos uma solução) .

Não fiz muita tentativa de fornecer à cadeia de peixes o tratamento usual de kolmogorov, porque não é tão longo e não consigo encontrar uma maneira barata de reverter uma cadeia de caracteres em c # (não acho que o LINQ pagará), então pode haver alguma oportunidade lá, mas duvido um pouco.

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

eu sou um pouco de um python noob, então ignore a estranheza: P

Ruby, 177 bytes

Não é o mais curto, mas o primeiro em rubi:

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

A tentativa aqui é estender recursivamente uma regexp e compará-la com a entrada.
Se uma correspondência mais longa for encontrada, r () será recursivo; caso contrário, ele verificará se a última correspondência consome toda a cadeia de entrada e somente a gera com espaços adicionados.

CJam, 111 96 91 (ou 62 bytes)

Uma abordagem gananciosa iterativa para descobrir o que todas as combinações de peixes são possíveis à medida que você itera. Realmente não jogou golfe agora.

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

O código contém alguns caracteres não imprimíveis, portanto, use o link abaixo para referência.

Atualização codificada a sequência

Acrescentará explicação uma vez feito o golfe

Experimente online aqui

62 bytes

Versão super lenta. Isso basicamente cria todas as combinações e verificações iguais à entrada.

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

Isso também contém caracteres não imprimíveis, portanto, confie no link abaixo.

Experimente online aqui

Haskell, 148 146 bytes

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

Testando:

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

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

<>> <>>

Explicação

Com base na minha resposta anterior a uma pergunta semelhante. O algoritmo é executado em tempo exponencial.

Isso lê da direita para a esquerda.

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

Isso não imprimirá uma sequência que termina com um espaço, mesmo que essas cadeias também sejam geradas, porque sua contraparte sem espaço é gerada primeiro.

JavaScript (ES6), 164

Primeira varredura recursiva e profunda.
Como um programa com E / S via pop-up:

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

Como uma função testável:

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

Conjunto de teste (executado no console Firefox / FireBug)

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

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

Resultado

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

Ungolfed apenas a função 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[]

isso usa a compreensão da lista para iterar sobre os peixes, escolher aqueles que correspondem ao início e continuar recursivamente.

Javascript (122 135 bytes)

Não é o mais jogado aqui, pode ser despojado um pouco.

Este é baseado em regex, e um pouco difícil de descobrir o que está acontecendo.

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

Este é um one-liner.

Basicamente, verifico a sintaxe e, em seguida, divido a string com base nos caracteres e a uno.
Emite uma exceção quando você fornece uma entrada inválida.

Se não puder lançar exceções (126 139 bytes):

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

Ambos são one-liners.
Ambos funcionam da mesma maneira.

Obrigado @ edc65 por detectar o case de borda que não estava funcionando bem.

Você pode testá-lo aqui (a saída será gravada no documento).

É baseado na versão que lança exceções quando você introduz um código inválido.

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

(Atualmente, há um erro nos snippets de pilha, Eu publiquei na metaJá foi perguntado ontem. Para que funcione, substituí $por \x24, que tem a mesma saída. Você pode ler sobre o bug aqui: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Scala, 299 bytes

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

Casos de teste

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

Resultado

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

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

Java, 288 bytes

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

Formatado:

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

Eu não estava gostando do tamanho, mas aqui está uma maneira fácil de entender isso no 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 bytes

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

Solução recursiva. Tarde para a festa, mas pensei em publicá-la de qualquer maneira, já que ela supera o Sp3000 por20 22 bytes sem precisar forçar a resposta com força bruta.