Рассмотрим эти пять ASCII художественных морских существ:

1. Стандартная рыба: ><>или<><
2. Быстрая рыба: >><>или<><<
3. Крепкая рыба: ><>>или<<><
4. Эластичная рыба: ><<<>или<>>><
5. Краб: ,<..>,

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

Например, строку <><><>можно интерпретировать как две стандартные рыбы подряд. Соответствующий вывод будет <>< ><>.

В качестве другого примера, строка ><>><>>содержит «экземпляры» of ...
^{(скобки добавляются только в качестве индикаторов)}

• пара стандартных рыб: [><>][><>]>
• быстрая рыба: ><[>><>]>
• крепкая рыба в двух направлениях: [><>>]<>>и><>[><>>]

однако только спаривание стандартной рыбы и крепкой рыбы [><>][><>>]охватывает всю длину струны без каких-либо символов, разделяющих рыбу (без наложений). Таким образом, выходной сигнал , соответствующий ><>><>>это ><> ><>>.

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

Раки просто для удовольствия. Поскольку они не начинаются и не заканчиваются на <или >, их гораздо легче идентифицировать (по крайней мере, визуально). Например, строка

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

очевидно, будет производить вывод

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

Вот несколько примеров строк (по одной на строку), которые не выводят:

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

Последняя строка здесь может быть проанализирована, если вы удалите ведущую <:

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

^{(Могут быть и другие возможные результаты.)}

подробности

• Входная строка будет содержать только символы <>,..
• Длина входной строки будет не менее одного символа.
• Принимайте входные данные любым обычным способом (командная строка, стандартный ввод) и выводите в стандартный вывод.
• Самый короткий код в байтах побеждает. ( Удобный счетчик байтов. ) Tiebreaker - более ранний пост.

Pyth, 64 48 50 байт

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

Прецедент.

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

Это подход грубой силы, генерирует все последовательности и проверяет, есть ли какая-либо сумма на входе. Диаграммы рыбы сжаты как символы, двоичные представления которых - >и <. Все это заключено в блок try-catch, поэтому при отсутствии результатов вывод не происходит.

Это решение.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:                                          <       <

Решение в Fish, вероятно, очень пригодное для игры в гольф, но это моя первая> <> программа. Он берет свои данные из стека ввода и запускает онлайн-интерпретатор> <>.

Как это устроено :

Цикл считывает все входные данные и суммирует их, переворачивает и помещает -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"})/'

Этот код использует движок регулярных выражений Perl (и, в частности, его встроенную функцию выполнения кода ), чтобы выполнить эффективный поиск в обратном направлении. Найденные отдельные рыбы собираются в @aмассив, который сортируется и распечатывается в случае успешного совпадения.

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

Кроме того, вот 87-байтовая версия, которая вообще не требует специальных ключей командной строки. Он читает одну строку из стандартного ввода и выводит результат (если есть) в стандартный вывод без какого-либо завершающего перевода строки:

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

Ps. Если было разрешено печатать лишний пробел в начале вывода, я мог бы тривиально сохранить еще два байта с помощью:

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

Python 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 байт

Это решение позорно простое, вряд ли что-нибудь для Golf. Это полная программа, которая принимает данные в виде строки из 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);

Я немного Noob Python, так что игнорируйте странности: 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 fishes.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()));
    }
}

Я не собирался за размер, но вот простой способ сделать это в 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 байта

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 байта без грубого ответа.