Bu beş ASCII sanat deniz canlısını göz önünde bulundurun:

1. Standart balık: ><>veya<><
2. Hızlı balık: >><>veya<><<
3. Sağlam balık: ><>>veya<<><
4. Sıkı balık: ><<<>veya<>>><
5. Yengeç: ,<..>,

Karakterlerin rastgele bir dizesini kabul eden bir program yazın <>,.. Dizinin tamamını üst üste gelmeyen deniz canlıları dizisi olarak yorumlamanın bir yolu varsa , dize, yaratıklar arasına yerleştirilmiş tek boşluklarla yeniden basılmalıdır. Bu yorum mümkün değilse, hiçbir şey çıkmamalıdır (program sessizce sona erer).

Örneğin, dize <><><>arka arkaya iki standart balık olarak yorumlanabilir. Karşılık gelen çıktı olacaktır <>< ><>.

Başka bir örnek olarak, dize ><>><>>... ⁽ "örnekleri") içerir
^{(yalnızca göstergeler olarak eklenen parantezler)}

• birkaç standart balık: [><>][><>]>
• hızlı bir balık: ><[>><>]>
• birkaç şekilde sağlam bir balık: [><>>]<>>ve><>[><>>]

bununla birlikte, yalnızca standart bir balığın ve sağlam bir balığın eşleştirilmesi [><>][><>>], ipin tüm uzunluğunu, balık paylaşım karakterleri olmadan (örtüşmeden) kapsar. Böylece tekabül eden çıkış ><>><>>olup ><> ><>>.

Dizenin yorumlanmasının birden fazla yolu varsa, bunlardan herhangi birini yazdırabilirsiniz. (Ve ancak baskı tane . Bunlardan) Örneğin, <><<<><standart bir balık ve sağlam balık olarak yorumlanabilir: [<><][<<><]ya hızlı bir balık ve bir standart balık olarak: [<><<][<><]. Yani ya <>< <<><ya <><< <><geçerli çıkış olacaktır.

Yengeçler sadece eğlence için. Onlar başlatmak veya sona olmadığından <ya >, onlar (en azından görsel olarak) tespit etmek çok daha kolay. Örneğin, dize

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

Açıkçası çıktı üretmek

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

Çıktı üretmeyen bazı karakter dizileri (satır başına bir tane):

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

Baştakileri kaldırırsanız buradaki son dize ayrıştırılabilir <:

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

^{(Başka olası çıktılar olabilir.)}

ayrıntılar

• Giriş dizesi sadece karakterleri içerecektir <>,..
• Giriş dizesi en az bir karakter uzunluğunda olacaktır.
• Ortak bir yoldan giriş yapın (komut satırı, stdin) ve stdout'a çıktı alın.
• Bayt cinsinden en kısa kod kazanır. ( Kullanışlı bayt sayacı. ) Tiebreaker daha önce yayınlandı.

Pyth, 64 48 50 bayt

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

Test durumu.

(Sonsuza almaz Versiyon ) burada 52 bayt.O(9n/3)

Bu kaba kuvvet yaklaşımıdır, tüm dizileri oluşturur ve girdiyle ilgili toplam olup olmadığını kontrol edin. Kimin ikili simgeleridir karakterler olarak sıkıştırılmış Balık diyagramlar >ve <. Her şey bir try-catch bloğuna sarılıdır, böylece hiçbir sonuç bulunmadığında çıktı alınmaz.

Bu bir çözümdür.O(9n)

Kontrol karakterleri kullanıldığı için bazı karakterler üstünden sıyrılıyor. Yukarıdaki bağlantıda sadık bir şekilde çoğaltılırlar.

xxd çıkışı:

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

Deterministik olmayan Turing Makinesi, 20 eyalet, 52 geçiş (belki 882 bayt)

Bunu baytlara nasıl dönüştürürsünüz? Bu makineyi Alex Vinokur'un Turing Machine ¹ Simülatörü ile çalıştırmak için dosyaları yazdım (kesinlikle golf oynamıyorum) . aşağıdakini çıktılar (açıklama dosyası ve giriş dosyaları hariç):wc -c

 12 alphabet
 49 meta
740 rules
 81 states
882 total

Her neyse, Bilgisayar Bilimleri A Düzeylerime hazırlanıyordum, bu yüzden bunun iyi bir egzersiz olacağını düşündüm (ne düşündüğümü bilmiyorum). İşte tanımı:

^{(geçiş işlevi)}

Kötü görüntü affedersiniz, ama bu şeyi bilgisayarda yeniden çizmekten rahatsız olamazdım. Geçiş kurallarını gerçekten deşifre etmek istiyorsanız, yukarıda bağladığım kurallar dosyasını okumanızı öneririm.

Kullandığım Xmekanlar burada görselleştirmek için zor olduğundan yerine boşluk s ve simülatör alfabesinde boşluk kabul etmez.

Konsept oldukça basittir - sağa dönük balıkları yakalamak için q1 ila q4, sola bakan balıkları yakalamak için q11 ila q14, yengeçler için q15 ila q19 ve q5 ila q10 blobu bir boşluk yerleştirmek ve tüm hareket etmek için kullanılır. karakterleri sağa doğru takip edin.

Dize yorumlanabilirse, dizeyi kabul eder ve bant, eklenmiş boşluk içeren dizeyi içerir. Aksi halde dizgiyi reddeder (sanırım bu çıktı olarak sayılmaz - bandı boşaltmak oldukça kolay olur, ancak çok sayıda geçiş kuralı gerektirir ve geçiş işlevine bakmayı daha da güzelleştireceğini sanmıyorum).

_{¹ Not: Derlemek zor. Ben düzenlemek zorunda src/tape.cppdosyayı ve değiştirme LONG_MAXile 1<<30ve ardından gidin demo, dizine yerine Makefile'a girin EXE_BASENAMEile turing.exeve yürütmek make. Sonra yazdığım ve yürüttüğüm dosyaları içeren dizine gidin /path/to/turing/download/src/turing.exe meta.}

balık (evet, o balık), 437 bayt

Bu, beni tam olarak bir dilin doğru olduğu programlama görevlerinden biri olarak etkiliyor.

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

Aşağıdaki sürüm hala mücadelenin en uzun cevabı.

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]

ancak bu daha çok oyun için yapıldığından (afedersiniz, umarım), okuyucunun alıştırması olarak daha iyi golf oynamaya devam edilir.

> <>, 602 bayt

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'te bir çözüm, muhtemelen çok golf oynuyor ama benim ilk> <> programım. Giriş yığınından girişini alır ve çevrimiçi> <> yorumlayıcısında çalışır.

Nasıl çalışır :

Bir döngü tüm girişi okur ve istifler, tersine çevirir ve ayrıştırma işleminin tamamlanacağını işaretleyen altta bir -1 koyun (tüm karakterler karakter dizisi ayrılabilir olarak kabul edilene kadar yığında kalır).
Ayrıştırma, tüm karakterlerin farklı modulo 5 olduğu ve <> << ve> <>> hariç tüm kalıpların deterministik olduğu gerçeğini kullanır. Ayrıştırılmış karakterler yığının altına yerleştirilir.
Bir desen tamamlandığında, -1 üstte ise, tüm karakterler yazdırılır, aksi takdirde bir boşluk eklenir ve program döngüye girer.
<> << veya> <>> ile karşılaşılırsa, kayıt defteri artırılır (başlangıçta 0) ve yığına en son karakterden önce 0 yerleştirilir (böylece <> <veya> <> geridönmeden sonra kalır) . Ayrıştırma sırasında daha sonra bir hata görülürse, kayıt azaltılır, 0'dan sonraki tüm karakterler tekrar üste yerleştirilir (% 8 = 0 testi sayesinde boşluklar hariç).
Kayıt 0 iken veya yengeç içerisinde bir hata tespit edilirse, program hemen sona erer.

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

Strateji, balık listeleri oluşturmak ve bunların birleşimini giriş dizgisiyle karşılaştırmaktır.

Bu imkansız derecede uzun sürüyor. Gerçekten bir çıktı görmek istiyorsanız , balık sayısı için üst sınırın 3 olduğu yer for _ in sile değiştirin for _ in [0]*3. Kullanmak için çalışır sçünkü skömür başına en fazla bir balık içerir.

Hata düzeltmeleri için Sp3000 ve girişte tasarruf sağlayan bir karakter.

Eski 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 bayt

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

Bu kodu çevrimiçi olarak deneyin.

Bu kod $_değişkende girişi bekler ; Bunu her giriş satırına uygulamak için Perl'in -nanahtarıyla ( +1 bayt sayılır ) çalıştırın, örneğin:

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

Bu kod, verimli bir geri izleme araması yapmak için Perl'in regexp motorunu (ve özellikle de gömülü kod yürütme özelliğini) kullanır. Bulunan bireysel balıklar, @adizilimde toplanır , ki maç başarılı olursa dizelir ve yazdırılır.

Bu kod Perl 5.10+ sayözelliğini de kullanır ve bu nedenle bu modern özellikleri etkinleştirmek için -Eveya ile -M5.010(veya use 5.010;) çalıştırılmalıdır . Gelenek olarak, yalnızca dilin belirli bir sürümünü etkinleştirmek için kullanılan bu tür anahtarlar bayt sayısına dahil edilmez.

Alternatif olarak, burada hiçbir özel komut satırı anahtarı gerektirmeyen 87 baytlık bir sürüm. Stdin'den bir satır okur ve izleyen satır besleme olmadan sonucu (varsa) stdout'a yazdırır:

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

Ps. Çıktının başına fazladan bir alanın yazdırılmasına izin verilirse, iki bayt ile önemsiz şekilde tasarruf edebilirim:

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

Python 3, 196 186 bayt

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)

Basit özyineleme. gya ayrıştırılmış balıkların listesini döndürür ya Noneda giriş dizgisi kararsızsa.

Python 2,234 bayt

Önce bir Python regex çözümü denedim, ancak çoklu modellerdeki bir maçtan sonra grupları çıkarmanın bir yolu yok gibi görünüyor. Aşağıdaki, test durumlarında iyi göründüğü yinelemeli bir araştırmadır.

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)

Örnek bir test:

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

Ve ungolfed versiyonu:

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 bayt

Bu çözüm utanç verici bir şekilde basittir, Golf için neredeyse hiçbir şey. Bu tam bir programdır, girişi STDIN'den bir satır olarak alır ve sonucu STDOUT'a çıkarır.

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

Basitçe, her bir balığın bir boşluktan sonra (ya da ipin başlangıcında) ilk pozisyonu ile eşleşmeye çalışır ve her bir balığın türü ile eşleşir. Balık uyuyorsa, balıktan sonra bir boşluk ekledikten sonra özyinelemeli olarak çözücü çağırır veya eşleşmeyen dize kelimenin tam anlamıyla balıksa (yani, bir çözüm bulduysak), girişini (çıkış nedenlerinden dolayı \ n ile) döndürür .

Balık teline normal kolmogorov tedavisi vermek için çok fazla çaba harcamamıştım, çünkü o kadar uzun sürmüyor ve C # 'da bir ipi ters çevirmenin ucuz bir yolunu bulamıyorum (LINQ sanmıyorum. ödeyecek), bu yüzden orada bir fırsat olabilir, ama biraz şüpheliyim.

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

ben bir piton noob biraz im çok garip görmezden: P

Ruby, 177 bayt

Yakut değil, yakutta ilk olan:

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

Buradaki girişim, bir regexp'i yinelemeli olarak genişletip girdiyle eşleştirmektir.
Eğer daha uzun bir eşleşme bulunursa, r () tekrarlanacaktır, eğer son eşleşmenin tüm girdi dizgisini tüketip tüketmediğini kontrol edecek ve sadece sonradan boşluk eklenmiş olarak çıkacaktır.

CJam, 111 96 91 (veya 62 bayt)

Siz yinelendikçe tüm balık kombinasyonlarının mümkün olduğunu anlamaya devam etmek için yinelemeli açgözlü bir yaklaşım. Şu an gerçekten golf oynamam.

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

Kod bazı yazdırılamayan karakterler içeriyor, bu nedenle referans için aşağıdaki bağlantıyı kullanın.

Güncelle Dize Kodlandı

Golf bittikten sonra açıklama katacak

Burada çevrimiçi deneyin

62 bayt

Süper yavaş versiyon. Bu, temel olarak, girişe eşit olan tüm kombinasyonları ve kontrolleri yaratır.

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

Bu aynı zamanda yazdırılamayan karakterler içeriyor, bu nedenle aşağıdaki bağlantıya güvenin.

Burada çevrimiçi deneyin

Haskell, 148 146 bayt

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

Test yapmak:

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

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

<>> <>>

açıklama

Benzer bir soruya verdiğim önceki cevaba dayanarak . Algoritma üstel bir zamanda çalışır.

Bu sağdan sola okur.

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

Bu, boşluksuz muadili ilk önce üretildiğinden, bu tür dizeler de üretilse bile boşlukla biten bir dize yazdırmaz.

JavaScript (ES6), 164

Özyinelemeli, derinlik ilk tarama.
Pop-up üzerinden G / Ç içeren bir program olarak:

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

Test edilebilir bir fonksiyon olarak:

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 paketi (Firefox / FireBug konsolunda çalıştırma)

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

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

Çıktı

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

Ungolfed sadece k fonksiyonu

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[]

Bu, balık üzerinde yineleme yapmak, başlangıca uyanları seçmek ve tekrarlı bir şekilde devam etmek için liste kavramalarını kullanır.

Javascript (122 135 bayt)

Buradaki en çok golf oynamak değil, biraz sıyrılabilir.

Bu, regex tabanlı ve neler olduğunu anlamak biraz zor.

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

Bu bir tek astar.

Temel olarak, sözdizimini kontrol ediyorum ve ardından karakterleri temel alarak dizgeyi bölüp birleştiriyorum.
Geçersiz bir giriş yaptığınızda bir istisna atar.

İstisna alamazsa (126 139 bayt):

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

Her ikisi de tek gömlek.
Her ikisi de aynı şekilde çalışır.

İyi çalışmayan kenar kasasını tespit ettiğiniz için teşekkür ederiz @ edc65 .

Burada test edebilirsiniz (çıktı belgeye yazılacaktır).

Geçersiz kod girdiğinizde istisnalar atan sürüme dayanır.

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

(Şu anda, yığın snippet'lerinde bir hata var, Metada yayınladımDün zaten istendi. O çalışması için, ben yerine ettik $ile \x24aynı çıkışı olan. Burada hata hakkında bilgi edinebilirsiniz: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Scala, 299 Bayt

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

Test Kılıfları

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

Çıktı

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

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

Java, 288 bayt

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

biçimlendirilmiş:

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

Boyut için gitmiyordum, ama Dart'da bunu yapmanın kolay bir yolu var.

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 bayt

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

Özyinelemeli çözüm. Partiye geç kaldım, ama yine de Sp3000’leri yendikten sonra gönderirim diye düşündüm.20 Cevabı kaba bir şekilde zorlamak zorunda kalmadan 22 byte.