Розглянемо наступні п'ять арт-морських істот ASCII:

1. Стандартна риба: ><>або<><
2. Швидка риба: >><>або<><<
3. Міцна риба: ><>>або<<><
4. Еластична риба: ><<<>або<>>><
5. Краб: ,<..>,

Напишіть програму, яка приймає довільну рядок символів <>,.. Якщо є спосіб інтерпретувати всю струну як серію непересічних морських істот, то рядок слід передрукувати з окремими пробілами, вставленими між істотами. Якщо ця інтерпретація неможлива, нічого не повинно виходити (програма мовчки закінчується).

Наприклад, рядок <><><>можна інтерпретувати як дві стандартні риби спиною до спини. Відповідний вихід був би <>< ><>.

Як інший приклад, рядок ><>><>>містить "екземпляри" з ...
^{(дужки додані лише як індикатори)}

• пара стандартних риб: [><>][><>]>
• швидка риба: ><[>><>]>
• міцна риба двома способами: [><>>]<>>і><>[><>>]

однак лише спарювання стандартної риби та міцної риби [><>][><>>]охоплює всю довжину струни без символів спільного використання риб (без перекриттів). Таким чином, вихідний сигнал , відповідний ><>><>>це ><> ><>>.

Якщо існує декілька способів інтерпретації рядка, ви можете надрукувати будь-який з них. (І друкувати тільки один . З них) , наприклад, <><<<><може бути витлумачена як стандартна риба і міцна риба: [<><][<<><]або як невідкладне риби і стандартна риба: [<><<][<><]. Отже, <>< <<><або <><< <><був би дійсний вихід.

Краби просто для розваги. Оскільки вони не починаються або не закінчуються <або >, їх значно простіше визначити (принаймні візуально). Наприклад, рядок

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

Очевидно, це дасть вихід

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

Ось кілька прикладів рядків (по одному на рядок), які не дають результатів:

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

Останній рядок тут можна проаналізувати, якщо ви видалите ведучий <:

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

^{(Можуть бути й інші можливі виходи.)}

Деталі

• Рядок введення міститиме лише символи <>,..
• Вхідний рядок буде принаймні одним символом.
• Візьміть введення будь-яким загальним способом (командний рядок, stdin) та виведіть у stdout.
• Виграє найкоротший код у байтах. ( Зручний байтовий лічильник. ) Tiebreaker - це раніше повідомлення.

Pyth, 64 48 50 байт

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

Тестовий випадок.

Версія, яка не бере назавжди ( ) тут , у 52 байти.O(9n/3)

Це підхід грубої сили, генерувати всі послідовності та перевірити, чи є якась сума на вхід. Діаграми риб стиснуті як символи, двійкові уявлення яких є >і <. Вся справа загорнута у блок пробного захоплення, щоб не було результатів, коли не знайдено результатів.

Це рішення.O(9n)

Деякі символи знімаються вище, оскільки використовуються контрольні символи. Вони відтворюються вірно за посиланням вище.

xxd вихід:

0000000: 236a 6468 6671 7a73 5473 6d5e 2b6d 7358  #jdhfqzsTsm^+msX
0000010: 746a 436b 3255 3222 3c3e 2222 0a5c 7212  tjCk2U2"<>"".\r.
0000020: 141b 1d2e 3122 222c 3c2e 2e3e 2c22 646c  ....1"",<..>,"dl
0000030: 7a42                                     zB

Недетермінована машина Тьюрінга, 20 станів, 52 переходи (можливо, 882 байти)

Як перетворити це в байти? Я написав файли (абсолютно не гольф), щоб виконати цю машину за допомогою симулятора Алекса Вінокура з машини Тюрінга ¹ . wc -cвиводить наступне (виключаючи файл опису та вхідні файли):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

У будь-якому разі я готувався до рівня A-Levels з інформатики, тому думав, що це буде гарною вправою (не знаю, про що я думав). Отже ось визначення:

^{(функція переходу)}

Вибачте, поганий образ, але я не міг заважати переробляти цю річ на комп’ютері. Якщо ви дійсно хочете розшифрувати правила переходу, рекомендую ознайомитися з файлом правил, який я пов’язував вище.

Я використовував Xs замість пробілів, оскільки пробіли тут важко уявити, а тренажер не приймає пробіли в алфавіті.

Концепція досить проста - q1 до q4 використовуються для лову риб, що виходять правою стороною, q11 - q14 використовуються для лову лівих риб, q15 - q19 для крабів, а q5 до q10 - просто для вставки місця та переміщення всіх наступні символи - праворуч.

Якщо рядок є інтерпретаційною, вона приймає рядок, і стрічка містить рядок із вставленими пробілами. Інакше він відкидає рядок (я думаю, це вважається відсутнім результатом - спорожнення стрічки було б досить просто, але вимагало б безлічі правил переходу, і я не думаю, що це зробить функцію переходу гарнішою для перегляду).

_{¹ Примітка: складно скласти. Я повинен був змінити src/tape.cppфайл і замінити LONG_MAXз , 1<<30а потім перейти в demoкаталог, відредагувати Makefile , щоб замінити EXE_BASENAMEз turing.exeі виконувати make. Потім перейдіть до каталогу з записаними та виконаними файлами /path/to/turing/download/src/turing.exe meta.}

риба (так, та риба), 437 байт

Це вважає мене одним із тих завдань програмування, де саме одна мова потрібна.

#!/usr/bin/fish

set the_fishes "><>" "<><" ">><>" "<><<" "><>>" "<<><" "><<<>" "<>>><" ",<..>,"
set my_fishes

function startswith
        set -l c (echo -n $argv[2]|wc -c)
        echo $argv[1]|cut -c(math $c+1)-
        test $argv[2] = (echo $argv[1]|cut -c-$c)
end

function pickafish
        set -l fix 1
            while true
                if test $fix -gt (count $the_fishes); return 1; end

                if not set rest (startswith $argv[1] $the_fishes[$fix])
                            set fix (math $fix+1)
                        continue
                end    
                set my_fishes $my_fishes $the_fishes[$fix]
                    if test -z $rest
                        echo $my_fishes
                            exit
                    end
                    if not pickafish $rest
                    set my_fishes $my_fishes[(seq (math (count $my_fishes) - 1))]
                    set fix (math $fix+1)
                        continue
                end
        end
end

pickafish $argv[1]

Наступна версія як і раніше є найдовшою відповіддю на виклик,

set t "><>" "<><" ">><>" "<><<" "><>>" "<<><" "><<<>" "<>>><" ",<..>,";set m;function p;set -l i 1;while true;test $i -gt 9; and return 1;if not set r (begin;set c (echo $t[$i]|wc -c);echo $argv[1]|cut -c$c-;test $t[$i] = (echo $argv[1]|cut -c-(math $c-1));end);set i (math $i+1);continue;end;set m $m $t[$i];if test -z $r;echo $m;exit;end;if not p $r;set m $m[(seq (math (count $m)-1))];set i (math $i+1);continue;end;end;end;p $argv[1]

але оскільки це було зроблено здебільшого для каламбура (вибачте, я сподіваюся), кращий гольф залишається читачем як вправа.

> <>, 602 байти

0&>i:0)?vr>:5%4-?v}:5%?;}:5%1-?;}:5%1-?;}:5%2-?;}:5%4-?;}&~0& v
  \     /        >:5%2-?v}:5%2-?v}:5%?v}:5%2-?v}              v
 &:?v;>*} ^      v      <       >:5% ?v}:5%?v} :5% ?v}:5%2-?v}v
v&-1< ^48<                                  >: 5%2-?v}:5%2-  ?v&1+&0}}v
>    :?v~^       >:5%?v}:5%?v}:5%2-  ?v}:5%  ?v}              v
^~v?%8:<                    >:5%2-?v}: 5%2-?v} :5%2- ?v}:5%?v}v
^{<        >0>=?;:v                         >: 5%    ?v}:5%  ?v&1+&0}}v
           ^lo~<  <   >            >  >       >     > >     >  02.
          \}*48^?=i:                                          <       <

Рішення в Рибі, ймовірно, дуже пограбоване, але це моя перша> <> програма. Він бере свій вхід із стека вводу та працює на онлайн-перекладачі.

Як це працює :

Цикл зчитує весь вхід і укладає його, повертає його назад і ставить -1 на нижній частині, що означатиме, що синтаксичний аналіз завершений (усі символи залишаються на стеку, поки рядок не буде визнано пробірним).
Для аналізу використовується факт, що всі символи відрізняються модулем 5, і всі шаблони є детермінованими, за винятком <> << і> <>>. Розділені символи ставляться в нижній частині стека.
Коли шаблон завершено, якщо -1 знаходиться зверху, всі символи друкуються, інакше додається пробіл і цикл програми.
Якщо зустрічаються <> << або> <>>, реєстр збільшується (0 на початку), а 0 - кладеться на стек перед останнім символом (так що <> <або> <> залишається після відкату) . Якщо після розбору з'являється помилка, реєстр зменшується, всі символи після 0 повертаються зверху (крім пробілів завдяки тесту% 8 = 0).
Якщо помилка виявлена ​​під час реєстрації 0 або всередині краба, програма просто закінчується негайно.

Пітон 3, 156

*l,s=[],input()
for _ in s:l+=[y+[x]for x in"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,".split()for y in l]
for y in l:
 if"".join(y)==s:print(*y);break

Стратегія полягає у формуванні списків риб та порівнянні їх конкатенації з вхідним рядком.

Це триває неможливо довго. Якщо ви дійсно хочете , щоб побачити вихід, замінити for _ in sз for _ in [0]*3, де 3 верхньою межею для числа риб. Він працює для використання, sоскільки sмістить щонайменше одну рибу на чагарник.

Завдяки Sp3000 за помилки та заощадження на вході.

Старий 165:

f=lambda s:[[x]+y for x in"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,".split()for y in f(s[len(x):])if s[:len(x)]==x]if s else[[]]
y=f(input())
if y:print(*y[0])

Perl, 81 + 1 байт

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

Спробуйте цей код в Інтернеті.

Цей код очікує введення в $_змінну; запустіть це за допомогою -nперемикача Perl ( рахується як +1 байт ), щоб застосувати його до кожного вхідного рядка, наприклад, наприклад:

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

Цей код використовує механізм regexp Perl (а саме його вбудовану функцію виконання коду ) для ефективного пошуку зворотного відстеження. Знайдені окремі риби збираються у @aмасиві, який впорядковується та друкується, якщо збіг пройшов успішно.

Цей код також використовує Perl 5.10+ sayфункцію, і тому повинен бути запущений з -Eабо -M5.010перемикачем (або use 5.010;) , щоб включити такі сучасні функції. За традицією такі комутатори, що використовуються виключно для включення певної версії мови, не включаються до складу байтів.

Крім того, ось 87-байтна версія, яка взагалі не вимагає спеціальних комутаторів командного рядка. Він зчитує один рядок зі stdin та друкує результат (якщо такий є) у stdout, без будь-якого зворотного підводного рядка:

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

Пс. Якщо було дозволено надрукувати додатковий пробіл на початку виводу, я міг би тривіально зберегти ще два байти за допомогою:

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

Пітон 3, 196 186 байт

F="><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,".split()
def g(s):
 if s in F:return[s]
 for f in F:
  i=len(f)
  if f==s[:i]and g(s[i:]):return[f]+g(s[i:])
R=g(input())
if R:print(*R)

Проста рекурсія. gабо повертає список проаналізованої риби, або Noneякщо рядок введення не піддається аналізу.

Python 2, 234 байт

Спершу я спробував рішення з регексу Python, але, здається, немає можливості витягти групи після відповідності за кількома шаблонами. Далі йде рекурсивний пошук, який, здається, добре справляється з тестовими кейсами.

a='><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,'.split()
def d(t,p=0):
 if p<len(t):
  for e in a:
   z=p+len(e)
   if e==t[p:z]:
    if z==len(t):return[e]
    c=d(t,z)
    if c:return[e]+c
c=d(raw_input())
if c:
 print' '.join(c)

Приклад тесту:

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

І незворушена версія:

fishtypes = '><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,'.split()

def getfish(t, p=0):
    if p < len(t):
        for afish in fishtypes:
            z = p+len(afish)
            if afish == t[p:z]:
                if z == len(t) :
                    return [afish]
                fishlist = getfish(t, z)
                if fishlist :
                    return [afish]+fishlist

fishlist = getfish(raw_input())
if fishlist:
    print ' '.join(fishlist)

C # - 319 байт

Це рішення - ганебно просте, навряд чи щось для Гольфу. Це повна програма, приймає дані як рядок від STDIN і виводить результат на STDOUT.

using C=System.Console;class P{static void Main(){C.Write(S(C.ReadLine()));}static string S(string c){int i=c.LastIndexOf(' ')+1;foreach(var o in"<>< ><> <<>< ><>> >><> <><< ><<<> <>>>< ,<..>,".Split()){string k=c+"\n",m=c.Substring(i);if(m==o||m.StartsWith(o)&&(k=S(c.Insert(i+o.Length," ")))!="")return k;}return"";}}

Він просто намагається зіставити кожну рибу на першу позицію після пробілу (або на початку рядка), і поєднує з нею кожен тип риби. Якщо риба підходить, вона рекурсивно викликає розв'язувач після вставки пробілу після риби, або просто повертає його вхід (з \ n з причини виводу), якщо невідповідна рядок буквально є рибою (тобто ми знайшли рішення) .

Я не робив великої спроби дати риб'ячій струні звичайне лікування колгогоров, тому що це не так довго, і я не можу знайти дешевий спосіб перевернути рядок у C # (я не думаю, що LINQ заплачу), тож там може бути якась можливість, але я дещо сумніваюся в цьому.

using C=System.Console;

class P
{
    static void Main()
    {    
        C.Write(S(C.ReadLine())); // read, solve, write (no \n)
    }

    static string S(string c)
    {
        int i=c.LastIndexOf(' ')+1; // find start of un-matched string

        // match each fish
        foreach(var o in"<>< ><> <<>< ><>> >><> <><< ><<<> <>>>< ,<..>,".Split())
        {
            string k=c+"\n", // set up k for return if we have finished
            m=c.Substring(i); // cut off stuff before space
            if(m==o|| // perfect match, return straight away
               m.StartsWith(o)&& // fish matches the start
               (k=S(c.Insert(i+o.Length," "))) // insert a space after the fish, solve, assign to k
               !="") // check the solution isn't empty
                return k;
        }

        // no fish match
        return"";
    }
}

Хаскелл (Парсек) - 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);

я трохи python noob, тому ігноруйте дивацтво: P

Рубін, 177 байт

Не найкоротший, але перший у рубіні:

def r(e,p,m)t='';p.each{|n|t=e.join;return r(e<<n,p,m)if m=~/^#{t+n}/};(m==t)?e:[];end
puts r([],%w(><<<> <>>>< ><>> <<>< >><> <><< ><> <>< ,<..>,),gets.strip).join(' ')

Спроба тут полягає в тому, щоб рекурсивно розширити регулярне вираження і співставити його з вхідним.
Якщо буде знайдено довший збіг, r () буде повторюватися, якщо ні, він перевірить, чи останній збіг споживає весь вхідний рядок, і лише потім виведе його з доданими пробілами.

CJam, 111 96 91 (або 62 байти)

Ітеративний жадібний підхід, щоб зрозуміти, які всі рибні комбінації можливі під час ітерації. Дійсно зараз не гольфувати.

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

Код містить кілька недрукованих символів, тому використовуйте посилання нижче для посилання.

Оновлення Зашифровано рядок

Додамо пояснення після того, як зробили гольф

Спробуйте його онлайн тут

62 байти

Супер повільна версія. Це в основному створює всі комбінації та перевірки, які дорівнюють вхідному.

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

Це також містить символи, що не можна друкувати, тому покладайтесь на посилання нижче.

Спробуйте його онлайн тут

Haskell, 148 146 байт

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

Тестування:

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

$ echo "> <>> <>>" | runhaskell риби.hs

<>> <>>

Пояснення

На основі моєї попередньої відповіді на подібне запитання. Алгоритм працює в експоненціальному часі.

Це читається справа наліво.

=<<getLine              -- Read a line from STDIN.
mapM(\a->[[a],a:" "])   -- Replace each letter 'a' by "a" or "a " in
                        -- all possible ways, collect results to a list.
map concat              -- Concatenate those lists-of-strings into strings.
filter(all(...).words)  -- Keep those whose words are correct fish.
take 1                  -- Discard all but the first one.
mapM_ putStr            -- Print each string in that 1- or 0-element list.
main=                   -- That is the main function.

Це не надрукує рядок, який закінчується пробілом, навіть якщо такі рядки також генеруються, тому що його аналог без пробілу генерується першим.

JavaScript (ES6), 164

Рекурсивне, глибинне перше сканування.
Як програма з I / O через спливаюче вікно:

alert((k=(s,r)=>'><>0<><0>><>0<><<0><>>0<<><0><<<>0<>>><0,<..>,'.split(0)
.some(w=>s==w?r=w:s.slice(0,l=w.length)==w&&(t=k(s.slice(l)))?r=w+' '+t:0)?r:'')
(prompt()))

Як перевірена функція:

k=(s,r)=>'><>0<><0>><>0<><<0><>>0<<><0><<<>0<>>><0,<..>,'.split(0)
.some(w=>s==w?r=w:s.slice(0,l=w.length)==w&&(t=k(s.slice(l)))?r=w+' '+t:0)?r:''

Тестовий набір (запуск у консолі Firefox / FireBug)

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

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

Вихід

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

Невикористаний лише функція k

function k(s)
{
  var f='><>0<><0>><>0<><<0><>>0<<><0><<<>0<>>><0,<..>,'.split(0) 
  var i, w, l, t

  for (w of f)
  {
    if (s == w)
    {
      return w
    } 
    l = w.length
    if (s.slice(0,l) == w && (t = k(s.slice(l))))
    {
      return w + ' ' + t
    }
  }
  return ''
}

Хаскелл, 148 142

p[]=[[]]
p s=[i:j|i<-words"><> >><> ><>> ><<<> <>< <><< <<>< <>>>< ,<..>,",i==map fst(zip s i),j<-p$drop(length i)s]
    g s=unwords$head$p s++p[]

для цього використовується розуміння списку, щоб повторити рибу, вибрати ті, які відповідають початку та продовжувати рекурсивно.

Javascript (122 135 байт)

Тут не самий гольф, його можна було б трохи позбавити.

Цей заснований на регулярному вираженні, і важко зрозуміти, що відбувається.

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

Цей - однолінійний.

В основному я перевіряю синтаксис, а потім розбиваю рядок на основі символів і з'єдную його.
Він видає виняток, коли ви даєте йому недійсний вхід.

Якщо він не може кинути винятки (126 139 байт):

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

Обидва є одноводними.
Обидва працюють однаково.

Дякуємо @ edc65 за виявлення кращого випадку, який не працював добре.

Ви можете перевірити його тут (вихід буде записаний у документ).

Він заснований на версії, яка викидає винятки, коли ви вводите недійсний код.

var alert=console.log=function(s){document.write(s)+'<br>';};
try{
alert(prompt(R=RegExp,r='(<<?><|><>>?|,<\.\.>,|>><>|><<<>|<><<|<>>><)').match(R('^'+r+'+\x24'))[0].split(R(r+'(?=[>,]|\x24)','g')).join(' '));
}catch(e){console.log(e);}

(Наразі помилка в фрагментах стеку, Я повідомлення про метаПро це вже вчора просили. Для того , щоб працювати, я замінив $з \x24, який має той же результат. Про помилку ви можете прочитати тут: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Скала, 299 байт

type S=String
type L[T]=List[T]
def c(s:S):L[L[S]]={val f=List("><>","<><",">><>","<><<","><>>","<<><","><<<>","<>>><",",<..>,").filter(s.startsWith);if(f.isEmpty)List(List(s)) else f.flatMap(i => c(s.drop(i.size)).map(i::_))}
def p(s:S)=println(c(s).find(_.last.isEmpty).fold("")(_.mkString(" ")))

Випробування

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

Вихід

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

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

Java, 288 байт

public class F{public static void main(String[]q){d("",q[0]);}static System y;static void d(String a,String b){if(b.isEmpty()){y.out.println(a);y.exit(0);}for (String s : "><> <>< >><> <><< ><>> <<>< ><<<> <>>>< ,<..>,".split(" "))if(b.startsWith(s))d(a+" "+s,b.substring(s.length()));}}

Відформатовано:

public class F {
    public static void main(String[] q) {
        d("", q[0]);
    }

    static System y;

    static void d(String a, String b) {
        if (b.isEmpty()) {
            y.out.println(a);
            y.exit(0);
        }
        for (String s : "><> <>< >><> <><< ><>> <<>< ><<<> <>>>< ,<..>,".split(" "))
            if (b.startsWith(s)) d(a + " " + s, b.substring(s.length()));
    }
}

Я не збирався на розмір, але ось легкий для розуміння спосіб зробити це в Дарті.

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

Пітон 3, 166 164 байти

def z(s,p=''):[z(s[len(f):],p+' '+s[:len(f)])for f in'<>< <><< <<>< <>>>< ><> >><> ><>> ><<<> ,<..>,'.split(' ')if s.startswith(f)]if s else print(p[1:])
z(input())

Рекурсивне рішення. Запізнився на вечірку, але я подумав, що все одно опублікую її, оскільки вона б'є Sp300020 22 байти, не вимагаючи жорстокої відповіді.