Rozważ te pięć morskich stworzeń ASCII:

1. Ryby standardowe: ><>lub<><
2. Szybka ryba: >><>lub<><<
3. Solidna ryba: ><>>lub<<><
4. Ryby rozciągliwe: ><<<>lub<>>><
5. Krab: ,<..>,

Napisz program, który akceptuje dowolny ciąg znaków <>,.. Jeśli istnieje sposób na zinterpretowanie całego łańcucha jako serii nienakładających się stworzeń morskich, łańcuch powinien zostać przedrukowany z pojedynczymi spacjami wstawionymi między stworzenia. Jeśli ta interpretacja jest niemożliwa, nic nie powinno być wyprowadzane (program po cichu się kończy).

Na przykład ciąg <><><>może być interpretowany jako dwie standardowe ryby jedna po drugiej. Odpowiednim wyjściem byłoby <>< ><>.

Jako kolejny przykład ciąg ><>><>>zawiera „wystąpienia” ...
^{(nawiasy dodane tylko jako wskaźniki)}

• kilka standardowych ryb: [><>][><>]>
• szybka ryba: ><[>><>]>
• solidna ryba na kilka sposobów: [><>>]<>>i><>[><>>]

jednak tylko parowanie standardowej ryby i mocnej ryby [><>][><>>]obejmuje całą długość sznurka bez znaków dzielących ryby (bez nakładania się). Zatem wyjście odpowiadające ><>><>>jest ><> ><>>.

Jeśli istnieje wiele sposobów interpretacji ciągu, możesz wydrukować dowolny z nich. (I drukować tylko jedną . Z nich) Na przykład, <><<<><może być interpretowany jako standardowy ryb i stabilnej ryb: [<><][<<><]czy jako szybkiego ryb i standardowego ryb: [<><<][<><]. Więc albo <>< <<><czy <><< <><będzie ważne wyjście.

Kraby są po prostu dla zabawy. Ponieważ nie zaczynają się ani nie kończą na <lub >, są o wiele łatwiejsze do zidentyfikowania (przynajmniej wizualnie). Na przykład ciąg

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

wytworzyłby oczywiście wynik

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

Oto kilka przykładów ciągów (po jednym w wierszu), które nie generują danych wyjściowych:

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

Ostatni ciąg tutaj można przeanalizować, jeśli usuniesz wiodące <:

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

^{(Mogą istnieć inne możliwe wyniki.)}

Detale

• Łańcuch wejściowy będzie zawierał tylko znaki <>,..
• Łańcuch wejściowy będzie miał co najmniej jeden znak.
• Pobieraj dane wejściowe w dowolny typowy sposób (linia poleceń, standardowe wejście) i wysyłaj na standardowe wyjście.
• Najkrótszy kod w bajtach wygrywa. ( Handy byte counter. ) Tiebreaker jest wcześniejszym postem.

Pyth, 64 48 50 bajtów

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

Przypadek testowy.

Wersja, która nie zajmuje wieczności ( ) tutaj , w 52 bajtach.O(9n/3)

Jest to podejście brutalnej siły, generuj wszystkie sekwencje i sprawdź, czy jakaś suma na wejściu. Diagramy ryb skompresowane jako znaki, których reprezentacjami binarnymi są >i <. Całość jest owinięta blokiem try-catch, aby nie było żadnych wyników, gdy nie znaleziono żadnych wyników.

To jest rozwiązanie.O(9n)

Niektóre znaki są rozebrane powyżej, ponieważ używane są znaki kontrolne. Są one wiernie odtworzone pod powyższym linkiem.

wyjście 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

Niedeterministyczna maszyna Turinga, 20 stanów, 52 przejścia (może 882 bajty)

Jak przekonwertować to na bajty? Napisałem pliki (absolutnie nie golfa), aby uruchomić tę maszynę za pomocą Alexa Vinokur's Simulator of a Turing Machine ¹ . wc -cwyświetla następujące dane (z wyjątkiem pliku opisu i plików wejściowych):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

Tak czy inaczej, przygotowywałem się do matur komputerowych, więc pomyślałem, że to będzie dobre ćwiczenie (nie wiem, o czym myślałem). Oto definicja:

^{(funkcja przejścia)}

Przepraszam za zły obraz, ale nie przejmowałem się przerysowaniem tego na komputerze. Jeśli naprawdę chcesz odszyfrować reguły przejścia, zalecamy przeczytanie pliku reguł, który podłączyłem powyżej.

Użyłem Xs zamiast spacji, ponieważ spacje są tutaj trudne do wizualizacji, a symulator nie akceptuje spacji w alfabecie.

Koncepcja jest dość prosta - od q1 do q4 są używane do chwytania ryb skierowanych w prawo, od q11 do q14 są używane do chwytania ryb skierowanych w lewo, od q15 do q19 dla krabów, a kropla q5 do q10 służy do wstawiania spacji i przenoszenia wszystkich następujące znaki jeden po prawej stronie.

Jeśli ciąg jest interpretowalny, przyjmuje ciąg, a taśma zawiera ciąg ze wstawionymi spacjami. W przeciwnym razie odrzuca ciąg (myślę, że liczy się to jako brak wyjścia - opróżnienie taśmy byłoby dość łatwe, ale wymagałoby wielu reguł przejścia i nie sądzę, aby ładniejsza była funkcja przejścia).

_{¹ Uwaga: Kompilacja jest trudna. Musiałem edytować src/tape.cppplik i zastąpić LONG_MAXz 1<<30, a następnie przejdź do demokatalogu, edytować Makefile do zastąpienia EXE_BASENAMEz turing.exei wykonania make. Następnie przejdź do katalogu z plikami, które napisałem i uruchomiłem /path/to/turing/download/src/turing.exe meta.}

fish (tak, ta ryba), 437 bajtów

Uderza mnie to jako jedno z zadań programistycznych, w których dokładnie jeden język jest odpowiedni.

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

Poniższa wersja jest wciąż najdłuższą odpowiedzią na wyzwanie,

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]

ale ponieważ zrobiono to głównie dla gry słów (mam nadzieję, że będzie to usprawiedliwienie), lepszym graniem w golfa pozostanie ćwiczenie dla czytelnika.

> <>, 602 bajty

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

Rozwiązanie w Fish, prawdopodobnie bardzo grywalne, ale to mój pierwszy program> <>. Pobiera dane wejściowe ze stosu wejściowego i działa na tłumaczu online> <>.

Jak to działa :

Pętla odczytuje wszystkie dane wejściowe i układa je w stos, odwraca je i umieszcza -1 na dole, co oznacza, że ​​parsowanie jest zakończone (wszystkie znaki pozostają na stosie, dopóki łańcuch nie zostanie uznany za przetwarzalny).
Podczas analizy wykorzystuje się fakt, że wszystkie znaki są różne modulo 5, a wszystkie wzorce są deterministyczne, z wyjątkiem <> << i> <>>. Przetwarzane znaki są umieszczane na dole stosu.
Po zakończeniu wzoru, jeśli -1 jest na górze, wszystkie znaki są drukowane, w przeciwnym razie dodaje się spację i program zapętla się.
W przypadku napotkania <> << lub> <>> rejestr jest zwiększany (0 na początku), a 0 jest umieszczane na stosie przed ostatnim znakiem (tak, że <> <lub> <> pozostaje po wycofaniu) . Jeśli błąd pojawi się później podczas analizowania, rejestr jest zmniejszany, wszystkie znaki po 0 są ponownie umieszczane na wierzchu (z wyjątkiem spacji dzięki testowi% 8 = 0).
Jeśli zostanie wykryty błąd, gdy rejestr ma wartość 0 lub wewnątrz kraba, program natychmiast się kończy.

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

Strategia polega na generowaniu list ryb i porównywaniu ich konkatenacji z łańcuchem wejściowym.

To trwa niemożliwie długo. Jeśli rzeczywiście chcesz zobaczyć wyjście, wymień for _ in ssię for _ in [0]*3, gdzie 3 to górna granica dla liczby ryb. Działa, sponieważ szawiera najwyżej jedną rybę na char.

Dzięki Sp3000 za poprawki błędów i zapisywanie znaków na wejściu.

Stary 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 bajtów

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

Wypróbuj ten kod online.

Ten kod oczekuje danych wejściowych w $_zmiennej; uruchom to za pomocą -nprzełącznika Perla ( liczonego jako +1 bajt ), aby zastosować go do każdej linii wejściowej, np. tak:

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

Ten kod używa silnika wyrażeń regularnych Perla (a zwłaszcza jego funkcji wykonywania kodu osadzonego ) w celu wydajnego wyszukiwania wstecznego śledzenia. Poszczególne znalezione ryby są gromadzone w @atablicy, która jest ryflowana i drukowana, jeśli dopasowanie się powiedzie.

Kod ten korzysta także Perl 5.10+ sayfunkcji, a więc muszą być prowadzone z -Elub -M5.010przełącznika (lub use 5.010;), aby umożliwić takie nowoczesne funkcje. Tradycyjnie takie przełączniki używane wyłącznie w celu włączenia określonej wersji języka nie są uwzględniane w liczbie bajtów.

Alternatywnie, oto wersja 87-bajtowa, która nie wymaga żadnych specjalnych przełączników wiersza polecenia. Odczytuje jedną linię ze standardowego wejścia i wypisuje wynik (jeśli istnieje) na standardowe wyjście, bez końcowego podawania linii:

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

Ps. Jeśli zezwolono na drukowanie dodatkowej spacji na początku danych wyjściowych, mogłem w trywialny sposób zapisać jeszcze dwa bajty za pomocą:

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

Python 3, 196 186 bajtów

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)

Prosta rekurencja. gzwraca listę przeanalizowanych ryb lub Nonełańcuch wejściowy jest nie do rozdzielenia.

Python 2, 234 bajty

Najpierw wypróbowałem rozwiązanie wyrażenia regularnego Python, ale wydaje się, że nie ma sposobu na wyodrębnienie grup po dopasowaniu na wielu wzorach. Poniżej znajduje się wyszukiwanie rekurencyjne, które wydaje się dobrze sprawdzać w przypadkach testowych.

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)

Przykładowy test:

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

I wersja bez golfa:

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 bajtów

To rozwiązanie jest haniebnie proste, prawie nic dla Golfa. Jest to kompletny program, pobiera dane wejściowe z linii STDIN i wysyła wynik do 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"";}}

Po prostu próbuje dopasować każdą rybę do pierwszej pozycji po spacji (lub na początku łańcucha) i dopasowuje do niej każdy rodzaj ryby. Jeśli ryba pasuje, to rekurencyjnie wywołuje solver po wstawieniu spacji za rybą lub po prostu zwraca jej dane wejściowe (z \ n ze względów wyjściowych), jeśli niedopasowany ciąg znaków jest dosłownie rybą (tzn. Znaleźliśmy rozwiązanie) .

Nie podjąłem wiele prób, aby dać ciągowi ryb zwykłe leczenie kolmogorovem, ponieważ nie jest to aż tak długie i nie mogę znaleźć taniego sposobu na odwrócenie ciągu w C # (nie sądzę, że LINQ zapłaci), więc może będzie tam jakaś okazja, ale trochę w to wątpię.

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

jestem trochę pytonem noob, więc zignoruj ​​dziwność: P

Rubinowy, 177 bajtów

Nie najkrótszy, ale pierwszy w rubinie:

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

Próba polega na rekurencyjnym rozszerzeniu wyrażenia regularnego i dopasowaniu go do danych wejściowych.
Jeśli zostanie znalezione dłuższe dopasowanie, r () powtórzy się, jeśli nie, sprawdzi, czy ostatnie dopasowanie zużywa cały ciąg wejściowy, a dopiero potem wyśle ​​go z dodanymi spacjami.

CJam, 111 96 91 (lub 62 bajty)

Powtarzające się chciwe podejście, aby dowiedzieć się, jakie wszystkie kombinacje ryb są możliwe podczas iteracji. Naprawdę nie grałem teraz w golfa.

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

Kod zawiera niektóre niedrukowalne znaki, więc skorzystaj z linku poniżej w celach informacyjnych.

Aktualizacja Zakodowany ciąg

Dodanie wyjaśnienia po zakończeniu gry w golfa

Wypróbuj online tutaj

62 bajty

Wersja super wolna. To w zasadzie tworzy wszystkie kombinacje i kontrole, które są równe wkładowi.

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

Zawiera także znaki niedrukowalne, więc skorzystaj z poniższego linku.

Wypróbuj online tutaj

Haskell, 148 146 bajtów

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

Testowanie:

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

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

<>> <>>

Wyjaśnienie

Na podstawie mojej wcześniejszej odpowiedzi na podobne pytanie. Algorytm działa w czasie wykładniczym.

To czyta od prawej do lewej.

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

Nie spowoduje to wydrukowania łańcucha, który kończy się spacją, nawet jeśli takie łańcuchy również są generowane, ponieważ jego odpowiednik braku spacji jest generowany jako pierwszy.

JavaScript (ES6), 164

Rekurencyjny, pierwszy skan głębokości.
Jako program z I / O przez wyskakujące okienko:

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

Jako funkcja do przetestowania:

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

Pakiet testowy (uruchamiany w konsoli Firefox / FireBug)

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

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

Wynik

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

Ungolfed tylko funkcję 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[]

wykorzystuje to opisy list do iteracji nad rybami, wybiera tych, którzy pasują do początku i kontynuuje rekurencyjnie.

JavaScript (122 135 bajtów)

Nie najbardziej golfowy tutaj, można go trochę rozebrać.

Ten jest oparty na wyrażeniach regularnych i jest trochę trudny do zrozumienia, co się dzieje.

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

Ten jest jednowarstwowy.

Zasadniczo sprawdzam składnię, a następnie dzielę ciąg znaków na podstawie znaków i łączę go razem.
Zgłasza wyjątek, gdy podasz nieprawidłowe dane wejściowe.

Jeśli nie może zgłaszać wyjątków (126 139 bajtów):

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

Oba są jednowarstwowe.
Oba działają w ten sam sposób.

Dziękuję @ edc65 za wykrycie przypadku krawędzi, który nie działał dobrze.

Możesz to przetestować tutaj (dane wyjściowe zostaną zapisane w dokumencie).

Opiera się na wersji, która wprowadza wyjątki po wprowadzeniu nieprawidłowego kodu.

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

(Obecnie występuje błąd we fragmentach stosu, Mam napisanych na metaPytanie zostało już zadane wczoraj. Aby zadziałało, zastąpiłem $go \x24, który ma tę samą moc wyjściową. Możesz przeczytać o błędzie tutaj: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Scala, 299 bajtów

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

Przypadki testowe

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

Wynik

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

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

Java, 288 bajtów

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

Sformatowany:

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

Nie zamierzałem wybierać wielkości, ale tutaj jest łatwy do zrozumienia sposób na zrobienie tego w 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 bajty

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

Rozwiązanie rekurencyjne. Późno na imprezę, ale pomyślałem, że i tak to opublikuję, ponieważ wyprzedza Sp300020 22 bajty bez konieczności brutalnego wymuszania odpowiedzi.