Betrachten Sie diese fünf ASCII-Meerestiere:

1. Standardfisch: ><>oder<><
2. Schneller Fisch: >><>oder<><<
3. Starker Fisch: ><>>oder<<><
4. Dehnbarer Fisch: ><<<>oder<>>><
5. Krabbe: ,<..>,

Schreiben Sie ein Programm, das eine beliebige Zeichenfolge akzeptiert <>,.. Wenn es eine Möglichkeit gibt, die gesamte Zeichenfolge als eine Reihe sich nicht überlappender Meerestiere zu interpretieren , sollte die Zeichenfolge mit einzelnen Leerzeichen zwischen den Kreaturen nachgedruckt werden. Ist diese Interpretation nicht möglich, sollte nichts ausgegeben werden (das Programm endet stillschweigend).

Beispielsweise kann die Zeichenfolge <><><>als zwei Standardfische hintereinander interpretiert werden. Die entsprechende Ausgabe wäre <>< ><>.

Als weiteres Beispiel ><>><>>enthält die Zeichenfolge "Instanzen" von ...
^{(Klammern nur als Indikatoren hinzugefügt)}

• ein paar Standardfische: [><>][><>]>
• ein flotter Fisch: ><[>><>]>
• ein robuster Fisch in mehrfacher Hinsicht: [><>>]<>>und><>[><>>]

Allerdings erstreckt sich nur die Paarung eines Standardfisches und eines robusten Fisches [><>][><>>]über die gesamte Länge der Schnur, ohne dass sich die Zeichen der Fische teilen (keine Überlappungen). Somit ist die Ausgabe an entsprechenden ><>><>>ist ><> ><>>.

Wenn es mehrere Möglichkeiten gibt, die Zeichenfolge zu interpretieren, können Sie eine davon drucken. (Und nur druckt ein . Von ihnen) Zum Beispiel <><<<><kann als Standard Fisch und ein stabilen Fisch interpretiert werden: [<><][<<><]oder als schnellen Fisch und ein Standard - Fisch: [<><<][<><]. Also entweder <>< <<><oder <><< <><wäre eine gültige Ausgabe.

Die Krabben sind nur zum Spaß. Da sie nicht mit beginnen oder enden <oder >, sind sie viel leichter zu (zumindest optisch) zu identifizieren. Zum Beispiel die Zeichenfolge

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

würde natürlich die Ausgabe produzieren

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

Hier einige Beispiele für Zeichenfolgen (eine pro Zeile), die keine Ausgabe erzeugen:

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

Die letzte Zeichenfolge hier kann analysiert werden, wenn Sie das führende Zeichen entfernen <:

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

^{(Möglicherweise gibt es andere mögliche Ausgaben.)}

Einzelheiten

• Die Eingabezeichenfolge enthält nur die Zeichen <>,..
• Die Eingabezeichenfolge muss mindestens ein Zeichen lang sein.
• Übernehmen Sie die Eingabe auf eine übliche Weise (Befehlszeile, stdin) und geben Sie sie an stdout aus.
• Der kürzeste Code in Bytes gewinnt. ( Handy-Byte-Zähler. ) Tiebreaker ist früherer Beitrag.

Pyth, 64 48 50 Bytes

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

Testfall.

Version , die nicht ewig dauern ( ) hier , in 52 Bytes.O(9n/3)

Dies ist der Brute-Force-Ansatz, bei dem alle Sequenzen generiert und geprüft werden, ob eine Summe zur Eingabe gehört. Als Zeichen komprimierte Fischdiagramme, deren binäre Darstellungen das >und sind <. Das Ganze wird in einen Try-Catch-Block eingeschlossen, sodass keine Ausgabe erfolgt, wenn keine Ergebnisse gefunden werden.

Das ist eine Lösung.O(9n)

Einige Zeichen sind oben gestrippt, da Steuerzeichen verwendet werden. Sie werden unter dem obigen Link originalgetreu wiedergegeben.

xxd Ausgabe:

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

Nicht-deterministische Turing-Maschine, 20 Zustände, 52 Übergänge (882 Bytes vielleicht)

Wie konvertiert man das in Bytes? Ich habe die Dateien (absolut nicht golfen) geschrieben, um diese Maschine mit Alex Vinokurs Simulator of a Turing Machine ¹ auszuführen . wc -cgibt Folgendes aus (ohne die Beschreibungsdatei und die Eingabedateien):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

Wie auch immer, ich bereitete mich auf mein Informatik-Abitur vor und dachte, dies wäre eine gute Übung (ich weiß nicht, was ich dachte). Also hier ist die Definition:

^{(die Übergangsfunktion)}

Entschuldigen Sie das schlechte Bild, aber ich konnte es nicht ertragen, dieses Ding auf einem Computer neu zu zeichnen. Wenn Sie die Übergangsregeln tatsächlich entschlüsseln möchten, empfehlen wir Ihnen, die oben verlinkte Regeldatei durchzulesen.

Ich habe Xs anstelle von Leerzeichen verwendet, da Leerzeichen hier schwer zu visualisieren sind und der Simulator keine Leerzeichen im Alphabet akzeptiert.

Das Konzept ist recht einfach: Mit q1 bis q4 werden nach rechts gerichtete Fische gefangen, mit q11 bis q14 werden nach links gerichtete Fische gefangen, mit q15 bis q19 werden Krabben gefangen und mit dem Blob q5 bis q10 wird einfach ein Leerzeichen eingefügt und alles bewegt folgende Zeichen eins rechts.

Wenn die Zeichenfolge interpretierbar ist, akzeptiert sie die Zeichenfolge und das Band enthält die Zeichenfolge mit eingefügten Leerzeichen. Andernfalls wird die Zeichenfolge zurückgewiesen (ich denke, dies gilt als keine Ausgabe - das Leeren des Bandes wäre ziemlich einfach, würde aber viele Übergangsregeln erfordern, und ich denke nicht, dass es die Übergangsfunktion schöner aussehen lassen würde).

_{¹ Hinweis: Es ist schwierig zu kompilieren. Ich musste die bearbeiten src/tape.cppDatei und ersetzen LONG_MAXmit 1<<30und dann auf das gehen demoVerzeichnis, bearbeiten Sie die Makefile zu ersetzen EXE_BASENAMEmit turing.exeund auszuführen make. Dann gehe in das Verzeichnis mit den Dateien, die ich geschrieben habe und führe sie aus /path/to/turing/download/src/turing.exe meta.}

Fisch (ja, dieser Fisch), 437 Bytes

Dies erscheint mir als eine dieser Programmieraufgaben, bei denen genau eine Sprache richtig ist.

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

Die folgende Version ist immer noch die längste Antwort auf die Herausforderung,

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]

aber da dies hauptsächlich für das Wortspiel gemacht wurde (ich hoffe, Sie werden es entschuldigen), bleibt dem Leser besseres Golfen als Übung überlassen.

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

Eine Lösung in Fisch, wahrscheinlich sehr golfen, aber es ist mein erstes> <> Programm. Es bezieht seine Eingabe vom Eingabestapel und wird im Online-Interpreter> <> ausgeführt.

Wie es funktioniert :

Eine Schleife liest alle Eingaben und stapelt sie, kehrt sie um und setzt unten ein -1, was anzeigt, dass die Analyse abgeschlossen ist (alle Zeichen bleiben auf dem Stapel, bis die Zeichenfolge als analysierbar eingestuft wird).
Das Parsen verwendet die Tatsache, dass alle Zeichen unterschiedlich modulo 5 sind und alle Muster mit Ausnahme von <> << und> <>> deterministisch sind. Analysierte Zeichen werden am unteren Rand des Stapels abgelegt.
Wenn ein Muster vollständig ist und -1 oben steht, werden alle Zeichen gedruckt, andernfalls wird ein Leerzeichen hinzugefügt und das Programm wiederholt.
Wenn <> << oder> <>> angetroffen werden, wird das Register inkrementiert (0 am Anfang), und eine 0 wird vor dem letzten Zeichen auf den Stapel gelegt (so dass <> <oder> <> nach dem Zurücksetzen verbleibt). . Wenn später beim Parsen ein Fehler auftritt, wird das Register verkleinert, und alle Zeichen nach der 0 werden wieder an die Spitze gesetzt (mit Ausnahme von Leerzeichen dank eines% 8 = 0-Tests).
Wenn ein Fehler erkannt wird, während das Register 0 ist oder sich in der Krabbe befindet, endet das Programm sofort.

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

Die Strategie besteht darin, Fischlisten zu generieren und ihre Verkettung mit der Eingabezeichenfolge zu vergleichen.

Das dauert unglaublich lange. Wenn Sie tatsächlich eine Ausgabe sehen möchten, ersetzen Sie diese for _ in sdurch for _ in [0]*3, wobei 3 die Obergrenze für die Anzahl der Fische ist. Es funktioniert, sweil es shöchstens einen Fisch pro Saibling enthält.

Danke an Sp3000 für Bugfixes und ein Zeichen, das bei der Eingabe gespart wird.

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

Versuchen Sie diesen Code online.

Dieser Code erwartet die Eingabe in der $_Variablen. Führen Sie dies mit Perls -nSchalter ( gezählt als +1 Byte ) aus, um ihn auf jede Eingabezeile anzuwenden, z. B. wie folgt:

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

Dieser Code verwendet Perls reguläre Ausdrücke (und insbesondere die eingebettete Codeausführungsfunktion ), um eine effiziente Rückverfolgungssuche durchzuführen. Die einzelnen gefundenen Fische werden in dem @aArray gesammelt , das bei erfolgreicher Übereinstimmung stringifiziert und ausgedruckt wird.

Dieser Code verwendet auch das Perl 5.10+ sayFunktion, und so müssen die ausgeführt wird -Eoder -M5.010Schalter (oder use 5.010;) , wie moderne Funktionen zu ermöglichen. Traditionell sind solche Schalter, die nur zum Aktivieren einer bestimmten Version der Sprache verwendet werden, nicht in der Byteanzahl enthalten.

Alternativ ist hier eine 87-Byte-Version, für die überhaupt keine speziellen Befehlszeilenoptionen erforderlich sind. Es liest eine Zeile von stdin und gibt das Ergebnis (falls vorhanden) ohne nachfolgenden Zeilenvorschub in stdout aus:

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

Ps. Wenn das Drucken eines zusätzlichen Speicherplatzes am Anfang der Ausgabe erlaubt wäre, könnte ich zwei weitere Bytes trivial einsparen mit:

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

Einfache Rekursion. Gibt gentweder eine Liste analysierter Fische zurück oder Noneist die Eingabezeichenfolge nicht analysierbar.

Python 2, 234 Bytes

Ich habe zuerst eine Python-Regex-Lösung ausprobiert, aber es scheint keine Möglichkeit zu geben, die Gruppen nach einer Übereinstimmung mit mehreren Mustern zu extrahieren. Das Folgende ist eine rekursive Suche, die in den Testfällen gut zu funktionieren scheint.

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)

Ein Beispieltest:

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

Und die ungolfed version:

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

Diese Lösung ist schändlich einfach, für Golf kaum etwas. Es ist ein vollständiges Programm, nimmt die Eingabe als Zeile von STDIN und gibt das Ergebnis an STDOUT aus.

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

Es wird einfach versucht, jeden Fisch an die erste Position nach einem Leerzeichen (oder am Anfang der Zeichenfolge) zu bringen und jede Fischart damit abzugleichen. Wenn der Fisch passt, ruft er den Löser nach dem Einfügen eines Leerzeichens nach dem Fisch rekursiv auf oder gibt einfach seine Eingabe zurück (mit einem \ n aus Ausgabegründen), wenn die nicht übereinstimmende Zeichenfolge buchstäblich der Fisch ist (dh wir haben eine Lösung gefunden). .

Ich habe nicht viel unternommen, um dem Fisch-String die übliche Kolmogorov-Behandlung zu geben, weil es nicht allzu lange dauert und ich keinen billigen Weg finde, einen String in C # umzukehren (ich glaube nicht, LINQ wird zahlen), also gibt es vielleicht eine Gelegenheit, aber ich bezweifle es etwas.

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

Ich bin ein bisschen wie ein Python Noob, also ignoriere die Verrücktheit: P

Ruby, 177 Bytes

Nicht die kürzeste, sondern die erste in Rubin:

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

Hier wird versucht, einen regulären Ausdruck rekursiv zu erweitern und mit der Eingabe abzugleichen.
Wenn eine längere Übereinstimmung gefunden wird, wird r () wiederkehren, wenn nicht, wird geprüft, ob die letzte Übereinstimmung die gesamte Eingabezeichenfolge belegt und erst dann mit zusätzlichen Leerzeichen ausgegeben.

CJam, 111 96 91 (oder 62 Byte)

Ein iterativer, gieriger Ansatz, um herauszufinden, welche Fischkombinationen bei der Iteration möglich sind. Wirklich nicht gerade Golf gespielt.

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

Der Code enthält einige nicht druckbare Zeichen. Verwenden Sie daher den folgenden Link als Referenz.

Update Codiert die Zeichenfolge

Fügt eine Erklärung hinzu, sobald das Golfen abgeschlossen ist

Probieren Sie es hier online aus

62 Bytes

Super langsame Version. Dies erzeugt im Grunde alle Kombinationen und Prüfungen, die der Eingabe entsprechen.

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

Dies enthält auch nicht druckbare Zeichen. Verlassen Sie sich daher auf den folgenden Link.

Probieren Sie es hier online aus

Haskell, 148 146 Bytes

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

Testen:

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

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

<>> <>>

Erläuterung

Gestützt auf meine frühere Antwort auf eine ähnliche Frage. Der Algorithmus läuft in exponentieller Zeit ab.

Dies liest von rechts nach links.

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

Hiermit wird keine Zeichenfolge gedruckt, die mit einem Leerzeichen endet, auch wenn solche Zeichenfolgen ebenfalls generiert werden, da das Gegenstück ohne Leerzeichen zuerst generiert wird.

JavaScript (ES6), 164

Rekursiver Tiefenscan.
Als Programm mit I / O über Popup:

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

Als testbare Funktion:

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

Testsuite (in Firefox / FireBug-Konsole ausgeführt)

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

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

Ausgabe

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

Ungolfed nur die k-Funktion

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[]

Dabei werden Listenverständnisse verwendet, um den Fisch zu durchlaufen, diejenigen auszuwählen, die dem Start entsprechen, und rekursiv fortzufahren.

Javascript (122 135 Bytes)

Nicht die meisten Golfer hier, könnten ein wenig abgespeckt werden.

Dieses ist Regex-basiert und ein bisschen schwer herauszufinden, was los ist.

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

Dieser ist ein Einzeiler.

Grundsätzlich überprüfe ich die Syntax und teile dann die Zeichenfolge anhand der Zeichen auf und füge sie zusammen.
Es wird eine Ausnahme ausgelöst, wenn Sie eine ungültige Eingabe machen.

Wenn es keine Ausnahmen werfen kann (126 139 Bytes):

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

Beide sind Einzeiler.
Beides funktioniert genauso.

Vielen Dank an @ edc65 , dass Sie den Edge-Fall erkannt haben , der nicht richtig funktioniert hat.

Sie können es hier testen (die Ausgabe wird in das Dokument geschrieben).

Es basiert auf der Version, die Ausnahmen auslöst, wenn Sie ungültigen Code einführen.

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

(Derzeit gibt es einen Fehler in Stack-Snippets, Ich habe auf Meta gepostetEs wurde schon gestern gefragt. Für sie zu arbeiten, habe ich ersetzt $mit \x24, die die gleiche Leistung hat. Sie können über den Fehler hier lesen: 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(" ")))

Testfälle

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

Ausgabe

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

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

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

Formatiert:

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

Ich wollte keine Größe, aber hier ist eine leicht verständliche Methode, um dies in Dart zu tun.

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

Rekursive Lösung. Spät auf der Party, aber ich dachte, ich würde es trotzdem posten, da es Sp3000 übertreffen würde20 22 Bytes, ohne die Antwort brachial erzwingen zu müssen.