Considere estas cinco criaturas marinas de arte ASCII:

1. Pescado estándar: ><>o<><
2. Pez veloz: >><>o<><<
3. Pescado robusto: ><>>o<<><
4. Pescado elástico: ><<<>o<>>><
5. Cangrejo: ,<..>,

Escriba un programa que acepte una cadena arbitraria de los caracteres <>,.. Si hay una manera de interpretar la cadena completa como una serie de criaturas marinas que no se superponen, entonces la cadena debe reimprimirse con espacios individuales insertados entre las criaturas. Si esta interpretación es imposible, no se generará nada (el programa finaliza en silencio).

Por ejemplo, la cadena <><><>se puede interpretar como dos peces estándar consecutivos. La salida correspondiente sería <>< ><>.

Como otro ejemplo, la cadena ><>><>>contiene "instancias" de ...
^{(los corchetes solo se agregan como indicadores)}

• un par de peces estándar: [><>][><>]>
• un pez veloz: ><[>><>]>
• un pez robusto de dos maneras: [><>>]<>>y><>[><>>]

sin embargo, solo el emparejamiento de un pez estándar y un pez resistente [><>][><>>]abarca toda la longitud de la cadena sin caracteres de intercambio de peces (sin superposiciones). Por lo tanto, la salida correspondiente a ><>><>>es ><> ><>>.

Si hay varias formas de interpretar la cadena, puede imprimir cualquiera de ellas. (Y sólo imprimir una . De ellas) Por ejemplo, <><<<><puede ser interpretado como un pez estándar y un pez robusto: [<><][<<><], o como un pez rápido y un pez estándar: [<><<][<><]. Entonces, <>< <<><o <><< <><sería una salida válida.

Los cangrejos son solo por diversión. Como no comienzan o terminan con <o >, son mucho más fáciles de identificar (al menos visualmente). Por ejemplo, la cadena

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

obviamente produciría la salida

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

Aquí hay algunos ejemplos de cadenas (una por línea) que no producen salida:

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

La última cadena aquí se puede analizar si elimina el inicio <:

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

^{(Puede haber otras salidas posibles).}

Detalles

• La cadena de entrada solo contendrá los caracteres <>,..
• La cadena de entrada tendrá al menos un carácter de longitud.
• Tome la entrada de cualquier manera común (línea de comando, stdin) y la salida a stdout.
• El código más corto en bytes gana. ( Práctico contador de bytes ) . Tiebreaker es una publicación anterior.

Pyth, 64 48 50 bytes

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

Caso de prueba.

Versión que no tarda para siempre ( ) aquí , en 52 bytes.O(9n/3)

Este es el enfoque de fuerza bruta, genera todas las secuencias y verifica si hay alguna suma en la entrada. Diagramas de peces comprimidos como caracteres, cuyas representaciones binarias son las >y <. Todo está envuelto en un bloque try-catch para que no se produzca salida cuando no se encuentran resultados.

Esta es una solución.O(9n)

Algunos caracteres se eliminan arriba porque se usan caracteres de control. Se reproducen fielmente en el enlace de arriba.

salida 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 no determinista, 20 estados, 52 transiciones (882 bytes tal vez)

¿Cómo se convierte esto a bytes? He escrito los archivos (absolutamente sin golf) para ejecutar esta máquina con el Simulador de una máquina de Turing de Alex Vinokur ¹ . wc -cgenera lo siguiente (excluyendo el archivo de descripción y los archivos de entrada):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

De todos modos, me estaba preparando para mis A-Levels de informática, así que pensé que sería un buen ejercicio (no sé lo que estaba pensando). Así que aquí está la definición:

^{(la función de transición)}

Disculpe la mala imagen, pero no podría molestarme en volver a dibujar esta cosa en una computadora. Si realmente desea descifrar las reglas de transición, le recomiendo que lea el archivo de reglas que he vinculado anteriormente.

He usado Xs en lugar de espacios porque los espacios son difíciles de visualizar aquí y el simulador no acepta espacios en el alfabeto.

El concepto es bastante simple: q1 a q4 se usan para atrapar peces orientados a la derecha, q11 a q14 se utilizan para atrapar peces orientados a la izquierda, q15 a q19 para cangrejos y la mancha de q5 a q10 es simplemente para insertar un espacio y mover todo siguientes personajes uno a la derecha.

Si la cadena es interpretable, acepta la cadena y la cinta contiene la cadena con espacios insertados. De lo contrario, rechaza la cadena (supongo que esto no cuenta como salida; vaciar la cinta sería bastante fácil, pero requeriría muchas reglas de transición y no creo que haga que la función de transición sea más bonita de ver).

_{¹ Nota: es difícil de compilar. Tuve que editar el src/tape.cpparchivo y reemplazar LONG_MAXcon 1<<30y luego ir al demodirectorio, editar el Makefile para reemplazar EXE_BASENAMEcon turing.exey ejecutar make. Luego ve al directorio con los archivos que he escrito y ejecuto /path/to/turing/download/src/turing.exe meta.}

pez (sí, ese pez), 437 bytes

Esto me parece una de esas tareas de programación donde exactamente un lenguaje es correcto.

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

La siguiente versión sigue siendo la respuesta más larga al desafío,

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]

pero dado que esto se hizo principalmente para el juego de palabras (perdón, espero), el mejor golf se deja como un ejercicio para el lector.

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

Una solución en Fish, probablemente muy golfable pero es mi primer programa> <>. Toma su entrada de la pila de entrada y se ejecuta en el intérprete en línea> <>.

Cómo funciona :

Un bucle lee toda la entrada y la apila, invierte y coloca un -1 en la parte inferior que marcará que el análisis se ha completado (todos los caracteres permanecen en la pila hasta que la cadena se considere analizable).
El análisis utiliza el hecho de que todos los caracteres son diferentes módulo 5, y todos los patrones son deterministas excepto <> << y> <>>. Los personajes analizados se colocan en la parte inferior de la pila.
Cuando se completa un patrón, si -1 está en la parte superior, se imprimen todos los caracteres; de lo contrario, se agrega un espacio y el programa se repite.
Si se encuentran <> << o> <>>, el registro se incrementa (0 al comienzo) y se coloca un 0 en la pila antes del último carácter (de modo que <> <o> <> permanezca después de la reversión) . Si después aparece un error durante el análisis, el registro disminuye, todos los caracteres después del 0 se vuelven a colocar en la parte superior (excepto los espacios gracias a una prueba% 8 = 0).
Si se detecta un error mientras el registro es 0, o dentro del cangrejo, el programa acaba inmediatamente.

Pitó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

La estrategia es generar listas de peces y comparar su concatenación con la cadena de entrada.

Esto lleva imposiblemente largo. Si realmente desea ver una salida, reemplace for _ in scon for _ in [0]*3, donde 3 es el límite superior para el número de peces. Funciona para usar sporque scontiene como máximo un pez por carbón.

Gracias a Sp3000 por la corrección de errores y un ahorro de caracteres en la entrada.

Viejo 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"})/

Prueba este código en línea.

Este código espera la entrada en la $_variable; ejecute esto con el -ninterruptor de Perl ( contado como +1 byte ) para aplicarlo a cada línea de entrada, por ejemplo, así:

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

Este código utiliza el motor regexp de Perl (y específicamente su función de ejecución de código incrustada ) para realizar una búsqueda de retroceso eficiente. Los peces individuales encontrados se recopilan en la @amatriz, que se stringifica e imprime si la coincidencia es exitosa.

Este código también utiliza el Perl 5.10+ sayfunción, por lo que se debe ejecutar con el -Eo -M5.010interruptor (o use 5.010;) para permitir que tales características modernas. Por tradición, estos interruptores utilizados únicamente para habilitar una versión particular del idioma no se incluyen en el recuento de bytes.

Alternativamente, aquí hay una versión de 87 bytes que no requiere modificadores especiales de línea de comandos. Lee una línea de stdin e imprime el resultado (si lo hay) en stdout, sin ningún avance de línea final:

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

PD. Si se permitiera imprimir un espacio extra al comienzo de la salida, podría guardar trivialmente dos bytes más con:

/^((>><>|><(|>|<<)>|<><<|<(|<|>>)><|,<\.\.>,)(?{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)

Recurrencia simple gdevuelve una lista de peces analizados o Nonesi la cadena de entrada no se puede analizar.

Python 2, 234 bytes

Primero probé una solución de expresión regular de Python, pero parece que no hay forma de extraer los grupos después de una coincidencia en múltiples patrones. La siguiente es una búsqueda recursiva que parece funcionar bien en los casos de prueba.

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)

Un ejemplo de prueba:

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

Y la versión sin golf:

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 solución es vergonzosamente simple, casi nada para Golf. Es un programa completo, toma la entrada como una línea de STDIN y envía el resultado a 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"";}}

Simplemente intenta hacer coincidir cada pez con la primera posición después de un espacio (o al comienzo de la secuencia), y hace coincidir cada tipo de pez con él. Si el pez encaja, llama recursivamente al solucionador después de insertar un espacio después del pez, o simplemente devuelve su entrada (con un \ n por razones de salida) si la cadena no coincidente es literalmente el pez (es decir, hemos encontrado una solución) .

No he hecho un gran intento de darle a la cuerda de pescado el tratamiento habitual de kolmogorov, porque no es tan largo y no puedo encontrar una forma barata de invertir una cuerda en C # (no creo que LINQ pagará), por lo que puede haber alguna oportunidad allí, pero dudo un poco.

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

Soy un poco un novato de Python, así que ignora la rareza: P

Rubí, 177 bytes

No es el más corto sino el primero en rubí:

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

El intento aquí es extender recursivamente una expresión regular y compararla con la entrada.
Si se encuentra una coincidencia más larga, r () se repetirá, de lo contrario comprobará si la última coincidencia consume toda la cadena de entrada y solo luego la generará con espacios añadidos.

CJam, 111 96 91 (o 62 bytes)

Un enfoque codicioso iterativo para seguir descubriendo qué son posibles todas las combinaciones de peces a medida que itera. Realmente no golf en este momento.

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

El código contiene algunos caracteres no imprimibles, por lo tanto, utilice el siguiente enlace como referencia.

Actualizar codificado la cadena

Agregará explicación una vez que termine de jugar al golf

Pruébalo en línea aquí

62 bytes

Versión super lenta. Básicamente, esto crea todas las combinaciones y comprobaciones que son iguales a la entrada.

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

Esto también contiene caracteres no imprimibles, así que confíe en el siguiente enlace.

Pruébalo en línea aquí

Haskell, 148146 bytes

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

Pruebas:

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

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

<>> <>>

Explicación

Basado en mi respuesta anterior a una pregunta similar. El algoritmo se ejecuta en tiempo exponencial.

Esto se lee de derecha a izquierda.

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

Esto no imprimirá una cadena que termine con un espacio, aunque dichas cadenas también se generan, porque su contraparte sin espacio se genera primero.

JavaScript (ES6), 164

Recursivo, primer escaneo profundo.
Como un programa con E / S a través de una ventana emergente:

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 una función comprobable:

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 pruebas (ejecutar en la consola Firefox / FireBug)

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

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

Salida

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

Ungolfed solo la función 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[]

esto usa las comprensiones de la lista para iterar sobre los peces, elegir los que coinciden con el inicio y continuar recursivamente.

Javascript (122 135 bytes)

No es el más golfizado aquí, podría despojarse un poco.

Este está basado en expresiones regulares, y es un poco difícil de entender qué está pasando.

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

Este es un trazador de líneas.

Básicamente, verifico la sintaxis y luego divido la cadena en función de los caracteres y la unimos.
Lanza una excepción cuando le da una entrada no válida.

Si no puede lanzar excepciones (126 139 bytes):

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

Ambos son de una sola línea.
Ambos funcionan de la misma manera.

Gracias @ edc65 por detectar el caso límite que no funcionaba bien.

Puede probarlo aquí (la salida se escribirá en el documento).

Se basa en la versión que arroja excepciones cuando introduce código no vá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);}

(Actualmente, hay un error en los fragmentos de pila, He publicado en metaYa se le preguntó ayer. Para que funcione, lo reemplacé $con \x24, que tiene la misma salida. Puede leer sobre el error aquí: 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 prueba

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

Salida

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

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

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

Formateado:

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

No iba por el tamaño, pero aquí hay una manera fácil de entender de 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())

Solución recursiva. Tarde a la fiesta, pero pensé en publicarlo de todos modos ya que supera a Sp3000 por20 22 bytes sin tener que forzar la respuesta por fuerza bruta.