Considérez ces cinq créatures marines de l'art ASCII:

1. Poisson standard: ><>ou<><
2. Poisson rapide: >><>ou<><<
3. Poisson robuste: ><>>ou<<><
4. Poisson extensible: ><<<>ou<>>><
5. Crabe: ,<..>,

Ecrivez un programme qui accepte une chaîne arbitraire de caractères <>,.. S'il existe un moyen d'interpréter la chaîne entière comme une série de créatures marines ne se chevauchant pas, la chaîne doit alors être réimprimée avec des espaces simples insérés entre les créatures. Si cette interprétation est impossible, rien ne doit être sorti (le programme se termine en silence).

Par exemple, la chaîne <><><>peut être interprétée comme deux poissons standard dos à dos. La sortie correspondante serait <>< ><>.

Autre exemple, la chaîne ><>><>>contient des "instances" de ...
^{(les crochets sont uniquement ajoutés en tant qu'indicateurs)}

• un couple de poissons standard: [><>][><>]>
• un poisson rapide: ><[>><>]>
• un poisson robuste de deux manières: [><>>]<>>et><>[><>>]

cependant, seuls l'appariement d'un poisson standard et d'un poisson robuste [><>][><>>]s'étend sur toute la longueur de la chaîne sans caractères de partage du poisson (sans chevauchement). Ainsi, la sortie correspondant à ><>><>>est ><> ><>>.

Si la chaîne peut être interprétée de plusieurs manières, vous pouvez en imprimer une quelconque. (Et seulement imprimer un . D'entre eux), par exemple, <><<<><peut être interprété comme un poisson standard et un poisson solide: [<><][<<><], ou comme un poisson rapide et un poisson standard: [<><<][<><]. Donc, <>< <<><ou <><< <><serait une sortie valide.

Les crabes sont juste pour s'amuser. Comme ils ne commencent ni ne finissent avec <ou >, ils sont beaucoup plus faciles à identifier (au moins visuellement). Par exemple, la chaîne

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

produirait évidemment la sortie

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

Voici quelques exemples de chaînes (une par ligne) qui ne produisent aucune sortie:

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

La dernière chaîne ici peut être analysée si vous supprimez le début <:

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

^{(Il peut y avoir d'autres sorties possibles.)}

Détails

• La chaîne de saisie ne contiendra que les caractères <>,..
• La chaîne en entrée aura au moins un caractère.
• Prenez les entrées de n'importe quelle manière courante (ligne de commande, stdin) et exportez-les vers stdout.
• Le code le plus court en octets gagne. ( Compteur d'octets pratique. ) Tiebreaker est une publication antérieure.

Pyth, 64 48 50 octets

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

Cas de test.

Version qui ne prend pas éternellement ( ) ici , en 52 octets.O(9n/3)

C'est l'approche de la force brute, génère toutes les séquences et vérifie si une somme quelconque est entrée. Diagrammes de poisson compressés sous forme de caractères, dont les représentations binaires sont le >et <. Le tout est encapsulé dans un bloc try-catch afin qu'aucune sortie ne se produise si aucun résultat n'est trouvé.

C'est une solution.O(9n)

Certains caractères sont supprimés ci-dessus, car les caractères de contrôle sont utilisés. Ils sont reproduits fidèlement sur le lien ci-dessus.

xxd sortie:

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

Machine de Turing non déterministe, 20 états, 52 transitions (peut-être 882 octets)

Comment convertissez-vous cela en octets? J'ai écrit les fichiers (absolument pas golfés) pour exécuter cette machine avec le simulateur d'une machine de Turing d'Alex Vinokur ¹ . wc -cgénère les éléments suivants (à l’exclusion du fichier de description et des fichiers d’entrée):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

Quoi qu'il en soit, je préparais mon bac en informatique, alors j’ai pensé que ce serait un bon exercice (je ne sais pas à quoi je pensais). Alors voici la définition:

^{(la fonction de transition)}

Excusez la mauvaise image, mais je ne pouvais pas être dérangé pour redessiner cette chose sur un ordinateur. Si vous voulez réellement déchiffrer les règles de transition, je vous recommande de lire le fichier de règles que j'ai lié ci-dessus.

J'ai utilisé Xs au lieu d'espaces, car les espaces sont difficiles à visualiser ici et le simulateur n'accepte pas les espaces dans l'alphabet.

Le concept est assez simple - les q1 à q4 sont utilisés pour capturer les poissons orientés vers la droite, les q11 à q14 sont utilisés pour capturer les poissons orientés vers la gauche, q15 à q19 pour les crabes et les blob de q5 à q10 servent simplement à insérer un espace et à les déplacer. caractères suivants un à droite.

Si la chaîne est interprétable, elle accepte la chaîne et la bande contient la chaîne avec des espaces insérés. Sinon, il rejette la chaîne (je suppose que cela compte comme aucune sortie - vider la bande serait assez facile mais exigerait beaucoup de règles de transition et je ne pense pas que cela rendrait la fonction de transition plus jolie à regarder).

_{¹ Note: C'est difficile à compiler. Je devais éditer le src/tape.cppfichier et le remplacer LONG_MAXpar 1<<30puis aller dans le demorépertoire, éditer le Makefile pour le remplacer EXE_BASENAMEpar turing.exeet exécuter make. Ensuite, allez dans le répertoire avec les fichiers que j'ai écrits et exécutez-les /path/to/turing/download/src/turing.exe meta.}

poisson (oui, ce poisson), 437 octets

Cela me semble être l’une de ces tâches de programmation où exactement une langue est correcte.

#!/usr/bin/fish

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

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

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

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

pickafish $argv[1]

La version suivante reste la réponse la plus longue au défi,

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]

mais comme cela a été fait principalement pour le jeu de mots (excusez-moi, j'espère), le meilleur golf est laissé au lecteur comme un exercice.

> <>, 602 octets

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

Une solution dans Fish, probablement très golfable mais c’est mon premier> <> programme. Il tire son entrée de la pile d’entrée et s’exécute sur l’interprète en ligne> <>.

Comment ça fonctionne :

Une boucle lit toutes les entrées et les empile, les inverse et place un -1 qui marque que l'analyse est terminée (tous les caractères restent sur la pile jusqu'à ce que la chaîne soit considérée comme analysable).
L'analyse utilise le fait que tous les caractères sont différents de modulo 5 et que tous les modèles sont déterministes à l'exception de <> << et> <>>. Les caractères analysés sont placés au bas de la pile.
Lorsqu'un motif est terminé, si -1 est placé en haut, tous les caractères sont imprimés, sinon un espace est ajouté et le programme est mis en boucle.
Si <> << ou> <>> sont rencontrés, le registre est incrémenté (0 au début) et un 0 est placé sur la pile avant le dernier caractère (de sorte que <> <ou> <> reste après l'annulation). . Si une erreur apparaît par la suite lors de l'analyse, le registre est diminué, tous les caractères après le 0 sont remis en haut (à l'exception des espaces grâce au test% 8 = 0).
Si une erreur est détectée alors que le registre est à 0 ou à l'intérieur du crabe, le programme se termine immédiatement.

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

La stratégie consiste à générer des listes de poissons et à comparer leur concaténation à la chaîne d'entrée.

Cela prend énormément de temps. Si vous voulez réellement voir une sortie, remplacez for _ in spar for _ in [0]*3, où 3 est la limite supérieure du nombre de poissons. Il fonctionne bien scar scontient au plus un poisson par omble.

Merci à Sp3000 pour les corrections de bugs et une sauvegarde de caractère sur entrée.

Vieux 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 octets

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

Essayez ce code en ligne.

Ce code attend l'entrée dans la $_variable. exécutez ceci avec le -ncommutateur de Perl ( compté comme +1 octet ) pour l'appliquer à chaque ligne d'entrée, par exemple comme ceci:

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

Ce code utilise le moteur de regexp de Perl (et plus particulièrement sa fonction d' exécution de code intégrée) pour effectuer une recherche de retour en arrière efficace. Les différents poissons trouvés sont rassemblés dans le @atableau, qui est structuré et imprimé si la correspondance est réussie.

Ce code utilise également du Perl sayla fonction, et doit donc être exécuté avec le -Eou -M5.010commutateur (ou use 5.010;) pour permettre à ces caractéristiques modernes. Traditionnellement, de tels commutateurs utilisés uniquement pour activer une version particulière du langage ne sont pas inclus dans le nombre d'octets.

Vous pouvez également utiliser une version de 87 octets ne nécessitant aucun commutateur de ligne de commande spécial. Il lit une ligne de stdin et affiche le résultat (le cas échéant) sur stdout, sans saut de ligne final:

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

Ps. Si l'impression d'un espace supplémentaire au début de la sortie était autorisée, je pourrais sauvegarder de manière triviale deux octets supplémentaires avec:

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

Python 3, 196 186 octets

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)

Récursion simple. grenvoie une liste de poissons analysés, ou Nonesi la chaîne d'entrée est non analysable.

Python 2, 234 octets

J'ai d'abord essayé une solution d'expression rationnelle Python, mais il ne semble pas y avoir de moyen d'extraire les groupes après une correspondance sur plusieurs motifs. Ce qui suit est une recherche récursive qui semble bien fonctionner sur les cas tests.

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

Un exemple de test:

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

Et la version non-golfée:

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 octets

Cette solution est d'une simplicité honteuse, presque rien en Golf. Il s’agit d’un programme complet, qui prend en entrée une ligne de STDIN et envoie le résultat à 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"";}}

Il essaie simplement de faire correspondre chaque poisson à la première position après un espace (ou au début de la chaîne), et en fait correspondre chaque type de poisson. Si le poisson convient, il appelle alors le solutionneur après avoir inséré un espace après le poisson, ou renvoie simplement son entrée (avec un \ n pour des raisons de sortie) si la chaîne non appariée est littéralement le poisson (c'est-à-dire que nous avons trouvé une solution) .

Je n'ai pas beaucoup essayé de donner à la chaîne de poisson le traitement habituel de kolmogorov, car elle n'était pas si longue et je ne peux pas trouver un moyen peu coûteux d'inverser une chaîne en C # (je ne pense pas que LINQ va payer), donc il peut y avoir une chance là-bas, mais je doute un peu.

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

Im un peu d'un noob python alors ignorer l'étrangeté: P

Ruby, 177 octets

Pas le plus court mais le premier en rubis:

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

Il s'agit ici d'étendre de manière récursive une expression rationnelle et de la faire correspondre à l'entrée.
Si une correspondance plus longue est trouvée, r () recurse, sinon, il vérifiera si la dernière correspondance utilise toute la chaîne en entrée et ne la restituera qu'avec des espaces ajoutés.

CJam, 111 96 91 (ou 62 octets)

Une approche itérative gourmande pour continuer à déterminer toutes les combinaisons de poissons possibles en itérant. Vraiment pas joué au golf en ce moment.

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

Le code contient des caractères non imprimables, utilisez donc le lien ci-dessous pour référence.

Mise à jour de la chaîne encodée

Ajoutera une explication une fois le golf terminé

Essayez-le en ligne ici

62 octets

Version super lente. Cela crée essentiellement toutes les combinaisons et vérifications qui sont égales à l'entrée.

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

Cela contient également des caractères non imprimables, alors utilisez le lien ci-dessous.

Essayez-le en ligne ici

Haskell, 148 146 octets

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

Essai:

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

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

<>> <>>

Explication

Basé sur ma réponse précédente à une question similaire. L'algorithme s'exécute dans le temps exponentiel.

Cela se lit de droite à gauche.

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

Cela n'imprimera pas une chaîne qui se termine par un espace, même si de telles chaînes sont également générées, car sa contrepartie sans espace est générée en premier.

JavaScript (ES6), 164

Récursif, première analyse en profondeur.
En tant que programme avec E / S via 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()))

En tant que fonction testable:

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

Suite de tests (exécutée dans la console Firefox / FireBug)

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

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

Sortie

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

Ungolfed juste la fonction 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[]

cela utilise les compréhensions de liste pour parcourir le poisson, choisir ceux qui correspondent au début et continuer de manière récursive.

Javascript (122 135 octets)

Pas le plus golfé ici, pourrait être dépouillé un peu.

Celui-ci est basé sur les regex, et un peu difficile à comprendre ce qui se passe.

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

Celui-ci est un one-line.

En gros, je vérifie la syntaxe, puis je scissionne la chaîne en fonction des caractères et je la joint.
Il lève une exception lorsque vous lui donnez une entrée invalide.

S'il ne peut pas lancer d'exceptions (126 139 octets):

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

Les deux sont one-liners.
Les deux fonctionnent de la même manière.

Merci @ edc65 pour avoir détecté le cas de bord qui ne fonctionnait pas bien.

Vous pouvez le tester ici (la sortie sera écrite dans le document).

Il est basé sur la version qui lève des exceptions lorsque vous introduisez un code non valide.

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

(Actuellement, il y a un bug sur les extraits de pile, J'ai posté dans metaC'était déjà demandé hier. Pour que cela fonctionne, j'ai remplacé $par \x24, qui a la même sortie. Vous pouvez lire sur le bogue ici: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Scala, 299 octets

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

Cas de test

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

Sortie

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

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

Java, 288 octets

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

Formaté:

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

Je ne cherchais pas la taille, mais voici une façon facile de comprendre cela dans 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 octets

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

Solution récursive En retard à la fête, mais je pensais le poster de toute façon car il bat Sp3000 par20 22 octets sans avoir à forcer la réponse brutalement.