Considera queste cinque creature marine ASCII art:

1. Pesce standard: ><>o<><
2. Pesce veloce: >><>o<><<
3. Pesce robusto: ><>>o<<><
4. Pesce elastico: ><<<>o<>>><
5. Granchio: ,<..>,

Scrivi un programma che accetta una stringa arbitraria di caratteri <>,.. Se c'è un modo di interpretare l' intera stringa come una serie di creature marine non sovrapposte, allora la stringa dovrebbe essere ristampata con spazi singoli inseriti tra le creature. Se questa interpretazione è impossibile, non dovrebbe essere emesso nulla (il programma termina silenziosamente).

Ad esempio, la stringa <><><>può essere interpretata come due pesci standard back-to-back. L'output corrispondente sarebbe <>< ><>.

Come altro esempio, la stringa ><>><>>contiene "istanze" di ...
^{(parentesi aggiunte solo come indicatori)}

• un paio di pesci standard: [><>][><>]>
• un pesce veloce: ><[>><>]>
• un pesce robusto in un paio di modi: [><>>]<>>e><>[><>>]

tuttavia, solo l'abbinamento di un pesce standard e un pesce robusto [><>][><>>]copre l'intera lunghezza della corda senza caratteri di condivisione del pesce (senza sovrapposizioni). Quindi l'uscita corrispondente a ><>><>>è ><> ><>>.

Se la stringa può essere interpretata in diversi modi, è possibile stamparne una qualsiasi. (E solo stampare uno . Di loro), ad esempio, <><<<><può essere interpretato come un pesce di serie e un pesce robusta: [<><][<<><]o come un pesce veloce e un pesce di serie: [<><<][<><]. Quindi uno <>< <<><o <><< <><sarebbe un output valido.

I granchi sono solo per divertimento. Dal momento che non iniziano o finiscono con <o >, sono molto più facili da identificare (almeno visivamente). Ad esempio, la stringa

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

produrrebbe ovviamente l'output

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

Ecco alcuni esempi di stringhe (una per riga) che non producono output:

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

L'ultima stringa qui può essere analizzata se rimuovi il comando iniziale <:

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

^{(Potrebbero esserci altre uscite possibili.)}

Dettagli

• La stringa di input conterrà solo i caratteri <>,..
• La stringa di input sarà lunga almeno un carattere.
• Prendi l'input in modo comune (riga di comando, stdin) e l'output su stdout.
• Vince il codice più breve in byte. ( Handy byte counter. ) Tiebreaker è post precedente.

Pyth, 64 48 50 byte

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

Caso di prova.

Versione che non richiede sempre ( ) qui , in 52 byte.O(9n/3)

Questo è l'approccio della forza bruta, genera tutte le sequenze e controlla se c'è una somma nell'input. Diagrammi di pesce compressi come caratteri, le cui rappresentazioni binarie sono >e <. Il tutto è racchiuso in un blocco try-catch in modo che non si verifichi alcun output quando non viene trovato alcun risultato.

Questa è una soluzioneO(9n)

Alcuni personaggi sono eliminati sopra, perché vengono usati i personaggi di controllo. Sono riprodotti fedelmente al link sopra.

uscita 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

Turing Machine non deterministica, 20 stati, 52 transizioni (forse 882 byte)

Come si converte questo in byte? Ho scritto i file (assolutamente non giocati a golf) per eseguire questa macchina con Simulator of a Turing Machine ^{1 di} Alex Vinokur . wc -cgenera quanto segue (esclusi il file di descrizione e i file di input):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

Ad ogni modo, mi stavo preparando per i miei A-Levels di Informatica, quindi ho pensato che sarebbe stato un buon esercizio (non so cosa stavo pensando). Quindi, ecco la definizione:

^{(la funzione di transizione)}

Scusa la cattiva immagine, ma non potevo preoccuparmi di ridisegnare questa cosa su un computer. Se vuoi davvero decifrare le regole di transizione, ti consiglio di leggere il file delle regole che ho linkato sopra.

Ho usato Xs invece di spazi perché gli spazi sono difficili da visualizzare qui e il simulatore non accetta spazi nell'alfabeto.

Il concetto è abbastanza semplice: da q1 a q4 vengono utilizzati per catturare pesci rivolti a destra, da q11 a q14 vengono utilizzati per catturare pesci rivolti a sinistra, da q15 a q19 per i granchi e la chiazza da q5 a q10 serve semplicemente per inserire uno spazio e spostare tutto caratteri seguenti uno a destra.

Se la stringa è interpretabile, accetta la stringa e il nastro contiene la stringa con spazi inseriti. Altrimenti rifiuta la stringa (suppongo che questo non contenga alcun output: svuotare il nastro sarebbe piuttosto semplice ma richiederebbe molte regole di transizione e non penso che renderebbe la funzione di transizione più bella da guardare).

_{¹ Nota: è difficile compilare. Ho dovuto modificare il src/tape.cppfile e sostituirlo LONG_MAXcon, 1<<30quindi andare alla demodirectory, modificare il Makefile per sostituirlo EXE_BASENAMEcon turing.exeed eseguirlo make. Quindi vai alla directory con i file che ho scritto ed eseguo /path/to/turing/download/src/turing.exe meta.}

pesce (sì, quel pesce), 437 byte

Questo mi sembra uno di quei compiti di programmazione in cui esattamente una lingua è giusta.

#!/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 seguente versione è ancora la risposta più lunga alla sfida,

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]

ma dato che questo è stato fatto principalmente per il gioco di parole (mi scusi, spero), il golf migliore è lasciato come esercizio al lettore.

> <>, 602 byte

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

Una soluzione in Fish, probabilmente molto giocabile ma è il mio primo programma <>. Prende il suo input dallo stack di input ed esegue l'interprete online> <>.

Come funziona :

Un ciclo legge tutto l'input e lo impila, lo inverte e mette un -1 sul fondo che segnerà che l'analisi è completa (tutti i caratteri rimangono nello stack fino a quando la stringa non viene considerata analizzabile).
L'analisi utilizza il fatto che tutti i caratteri sono diversi modulo 5 e tutti i modelli sono deterministici tranne <> << e> <>>. I personaggi analizzati vengono messi in fondo alla pila.
Quando un motivo è completo, se -1 è in cima, vengono stampati tutti i caratteri, altrimenti viene aggiunto uno spazio e il programma scorre.
Se vengono rilevati <> << o> <>>, il registro viene incrementato (0 all'inizio) e uno 0 viene inserito nella pila prima dell'ultimo carattere (in modo che <> <o> <> rimanga dopo il rollback) . Se in seguito viene visualizzato un errore durante l'analisi, il registro viene ridotto, tutti i caratteri dopo lo 0 vengono rimessi in cima (tranne gli spazi grazie a un test% 8 = 0).
Se viene rilevato un errore mentre il registro è 0 o all'interno del granchio, il programma termina immediatamente.

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 strategia è generare elenchi di pesci e confrontare la loro concatenazione con la stringa di input.

Questo richiede incredibilmente tempo. Se vuoi effettivamente vedere un risultato, sostituiscilo for _ in scon for _ in [0]*3, dove 3 è il limite superiore per il numero di pesci. Funziona da usare sperché scontiene al massimo un pesce per salmerino.

Grazie a Sp3000 per correzioni di bug e un salvataggio dei caratteri sull'input.

Vecchio 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 byte

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

Prova questo codice online.

Questo codice prevede l'input nella $_variabile; eseguilo con l' -ninterruttore Perl ( conteggiato come +1 byte ) per applicarlo a ciascuna linea di input, ad esempio in questo modo:

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

Questo codice utilizza il motore regexp di Perl (e in particolare la sua funzione di esecuzione del codice incorporato ) per eseguire un'efficace ricerca di backtracking. I singoli pesci trovati vengono raccolti nella @amatrice, che viene rigorosamente stampata e stampata se la partita ha esito positivo.

Questo codice utilizza anche la sayfunzione Perl 5.10+ e quindi deve essere eseguito con l' opzione -Eo -M5.010(o use 5.010;) per abilitare tali funzionalità moderne. Per tradizione, tali switch utilizzati esclusivamente per abilitare una versione particolare della lingua non sono inclusi nel conteggio dei byte.

In alternativa, ecco una versione da 87 byte che non richiede affatto opzioni speciali da riga di comando. Legge una riga da stdin e stampa il risultato (se presente) su stdout, senza alcun avanzamento riga finale:

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

Ps. Se fosse consentita la stampa di uno spazio aggiuntivo all'inizio dell'output, potrei banalmente salvare altri due byte con:

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

Python 3, 196 186 byte

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)

Ricorsione semplice. grestituisce un elenco di pesci analizzati o Nonese la stringa di input non è analizzabile.

Python 2, 234 byte

Ho provato prima una soluzione regex di Python, ma sembra che non ci sia modo di estrarre i gruppi dopo una partita su più pattern. Quella che segue è una ricerca ricorsiva che sembra fare bene sui casi di test.

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 esempio di test:

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

E la versione non golfata:

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 byte

Questa soluzione è vergognosamente semplice, quasi nulla per il golf. È un programma completo, accetta input come linea da STDIN e invia il risultato a 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"";}}

Tenta semplicemente di abbinare ciascun pesce alla prima posizione dopo uno spazio (o all'inizio della stringa) e abbina ogni tipo di pesce con esso. Se il pesce si adatta, chiama in modo ricorsivo il solutore dopo aver inserito uno spazio dopo il pesce, oppure restituisce semplicemente il suo input (con un \ n per motivi di output) se la stringa senza pari è letteralmente il pesce (cioè abbiamo trovato una soluzione) .

Non ho fatto molto del tentativo di dare al filo di pesce il solito trattamento con kolmogorov, perché non è poi così lungo, e non riesco a trovare un modo economico per invertire un filo in C # (non credo LINQ pagherà), quindi potrebbe esserci qualche opportunità lì, ma ne dubito in qualche modo.

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

Sono un po 'un noob pitone quindi ignora la stranezza: P

Rubino, 177 byte

Non il più corto ma il primo in rubino:

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 tentativo qui è di estendere ricorsivamente un regexp e confrontarlo con l'input.
Se viene trovata una corrispondenza più lunga, verrà r r), in caso contrario verificherà se l'ultima corrispondenza consuma l'intera stringa di input e solo successivamente la restituisce con spazi aggiunti.

CJam, 111 96 91 (o 62 byte)

Un approccio avido iterativo per continuare a capire cosa sono possibili tutte le combinazioni di pesci mentre iteri. Davvero non ho giocato a golf in questo momento.

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

Il codice contiene alcuni caratteri non stampabili, quindi usa il link qui sotto come riferimento.

Aggiorna Codifica della stringa

Aggiungerà spiegazione una volta fatto il golf

Provalo online qui

62 byte

Versione super slow. Questo fondamentalmente crea tutte le combinazioni e i controlli che sono uguali all'input.

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

Questo contiene anche caratteri non stampabili, quindi fai affidamento sul seguente link.

Provalo online qui

Haskell, 148 146 byte

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

test:

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

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

<>> <>>

Spiegazione

Basato sulla mia precedente risposta a una domanda simile. L'algoritmo viene eseguito in tempo esponenziale.

Questo legge da destra a sinistra.

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

Questo non stamperà una stringa che termina con uno spazio, anche se vengono generate anche tali stringhe, poiché viene generata per prima la sua controparte senza spazio.

JavaScript (ES6), 164

Prima scansione ricorsiva e approfondita.
Come programma con I / O tramite 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()))

Come funzione testabile:

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

Test suite (eseguito nella console Firefox / FireBug)

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

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

Produzione

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

Non più solo la funzione 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[]

questo utilizza la comprensione dell'elenco per scorrere il pesce, selezionare quelli che corrispondono all'inizio e continuare in modo ricorsivo.

Javascript (122 135 byte)

Non il più golfato qui, potrebbe essere ridotto un po '.

Questo è basato su regex e un po 'difficile capire cosa sta succedendo.

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

Questo è un one-liner.

Fondamentalmente, controllo la sintassi e poi divido la stringa in base ai caratteri e la unisco insieme.
Genera un'eccezione quando gli dai un input non valido.

Se non può generare eccezioni (126 139 byte):

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

Entrambi sono a linea singola.
Entrambi funzionano allo stesso modo.

Grazie @ edc65 per aver rilevato la custodia per bordi che non funzionava bene.

Puoi provarlo qui (l'output verrà scritto nel documento).

Si basa sulla versione che genera eccezioni quando si introduce un codice non valido.

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

(Attualmente, c'è un bug negli snippet dello stack, Ho postato su metaÈ stato già chiesto ieri. Per farlo funzionare, ho sostituito $con \x24, che ha lo stesso output. Puoi leggere il bug qui: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Scala, 299 byte

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

Casi test

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

Produzione

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

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

Java, 288 byte

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

formattato:

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

Non stavo andando per dimensioni, ma ecco un modo facile da capire per farlo in 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 byte

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

Soluzione ricorsiva. In ritardo alla festa, ma ho pensato di pubblicarlo comunque dato che batte Sp3000 di20 22 byte senza dovere forzare la risposta.