Fische interpretieren (nein, nicht dieser Fisch)

69

Betrachten Sie diese fünf ASCII-Meerestiere:

  1. Standardfisch: ><>oder<><
  2. Schneller Fisch: >><>oder<><<
  3. Starker Fisch: ><>>oder<<><
  4. Dehnbarer Fisch: ><<<>oder<>>><
  5. Krabbe: ,<..>,

Schreiben Sie ein Programm, das eine beliebige Zeichenfolge akzeptiert <>,.. Wenn es eine Möglichkeit gibt, die gesamte Zeichenfolge als eine Reihe sich nicht überlappender Meerestiere zu interpretieren , sollte die Zeichenfolge mit einzelnen Leerzeichen zwischen den Kreaturen nachgedruckt werden. Ist diese Interpretation nicht möglich, sollte nichts ausgegeben werden (das Programm endet stillschweigend).

Beispielsweise kann die Zeichenfolge <><><>als zwei Standardfische hintereinander interpretiert werden. Die entsprechende Ausgabe wäre <>< ><>.

Als weiteres Beispiel ><>><>>enthält die Zeichenfolge "Instanzen" von ...
(Klammern nur als Indikatoren hinzugefügt)

  • ein paar Standardfische: [><>][><>]>
  • ein flotter Fisch: ><[>><>]>
  • ein robuster Fisch in mehrfacher Hinsicht: [><>>]<>>und><>[><>>]

Allerdings erstreckt sich nur die Paarung eines Standardfisches und eines robusten Fisches [><>][><>>]über die gesamte Länge der Schnur, ohne dass sich die Zeichen der Fische teilen (keine Überlappungen). Somit ist die Ausgabe an entsprechenden ><>><>>ist ><> ><>>.

Wenn es mehrere Möglichkeiten gibt, die Zeichenfolge zu interpretieren, können Sie eine davon drucken. (Und nur druckt ein . Von ihnen) Zum Beispiel <><<<><kann als Standard Fisch und ein stabilen Fisch interpretiert werden: [<><][<<><]oder als schnellen Fisch und ein Standard - Fisch: [<><<][<><]. Also entweder <>< <<><oder <><< <><wäre eine gültige Ausgabe.


Die Krabben sind nur zum Spaß. Da sie nicht mit beginnen oder enden <oder >, sind sie viel leichter zu (zumindest optisch) zu identifizieren. Zum Beispiel die Zeichenfolge

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

würde natürlich die Ausgabe produzieren

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

Hier einige Beispiele für Zeichenfolgen (eine pro Zeile), die keine Ausgabe erzeugen:

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

Die letzte Zeichenfolge hier kann analysiert werden, wenn Sie das führende Zeichen entfernen <:

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

(Möglicherweise gibt es andere mögliche Ausgaben.)

Einzelheiten

  • Die Eingabezeichenfolge enthält nur die Zeichen <>,..
  • Die Eingabezeichenfolge muss mindestens ein Zeichen lang sein.
  • Übernehmen Sie die Eingabe auf eine übliche Weise (Befehlszeile, stdin) und geben Sie sie an stdout aus.
  • Der kürzeste Code in Bytes gewinnt. ( Handy-Byte-Zähler. ) Tiebreaker ist früherer Beitrag.
Calvins Hobbys
quelle
4
Ich dachte, wir würden Fish 'Texte interpretieren :-(
RemcoGerlich
9
@RemcoGerlich Auch nicht der Fisch
Calvins Hobbys
4
Endlich ein Code-Golf für das RFC 3889 General Fish Transfer Format (Implementierung von RFC3500: Standard Fish Transfer Format)!
Sanchises
11
Bonuspunkte, wenn Sie es mit BrainF *** tun! Und je länger Ihr Programm braucht, um zu erkennen, dass sein eigener Code nicht fischkonform ist, desto besser.
mbomb007
3
Ich sah das und scrollte nach unten, resignierte damit, dass dies @ Calvin'sHobbies und niemand, niemand anderes sein würde.
Soham Chowdhury

Antworten:

21

Pyth, 64 48 50 Bytes

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

Testfall.


Version , die nicht ewig dauern ( ) hier , in 52 Bytes.O(9n/3)


Dies ist der Brute-Force-Ansatz, bei dem alle Sequenzen generiert und geprüft werden, ob eine Summe zur Eingabe gehört. Als Zeichen komprimierte Fischdiagramme, deren binäre Darstellungen das >und sind <. Das Ganze wird in einen Try-Catch-Block eingeschlossen, sodass keine Ausgabe erfolgt, wenn keine Ergebnisse gefunden werden.

Das ist eine Lösung.O(9n)

Einige Zeichen sind oben gestrippt, da Steuerzeichen verwendet werden. Sie werden unter dem obigen Link originalgetreu wiedergegeben.

xxd Ausgabe:

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
isaacg
quelle
Ist der Online-Compiler zu langsam, um ihn für die Beispieleingabe in der Frage auszuführen?
Optimierer
Ja, viel zu langsam / zu kurz. ><>><>>dauert 15 Sekunden auf meinem Computer.
Isaacg
28
O (9 ^ n) , heilige Ineffizienz!
mbomb007
2
@ mbomb007 Über Effizienz sehe ich in den Regeln nichts: P +1!
John Odom
3
@ mbomb007: Vermutlich noch besser als ein C ++ Compiler.
Mark K Cowan
27

Nicht-deterministische Turing-Maschine, 20 Zustände, 52 Übergänge (882 Bytes vielleicht)

Wie konvertiert man das in Bytes? Ich habe die Dateien (absolut nicht golfen) geschrieben, um diese Maschine mit Alex Vinokurs Simulator of a Turing Machine 1 auszuführen . wc -cgibt Folgendes aus (ohne die Beschreibungsdatei und die Eingabedateien):

 12 alphabet
 49 meta
740 rules
 81 states
882 total

Wie auch immer, ich bereitete mich auf mein Informatik-Abitur vor und dachte, dies wäre eine gute Übung (ich weiß nicht, was ich dachte). Also hier ist die Definition:

Definition

Zustände

Alphabet

Ausgangszustand

Leerzeichen

Zustände akzeptieren

Übergangsfunktion

(die Übergangsfunktion)

Entschuldigen Sie das schlechte Bild, aber ich konnte es nicht ertragen, dieses Ding auf einem Computer neu zu zeichnen. Wenn Sie die Übergangsregeln tatsächlich entschlüsseln möchten, empfehlen wir Ihnen, die oben verlinkte Regeldatei durchzulesen.


Ich habe Xs anstelle von Leerzeichen verwendet, da Leerzeichen hier schwer zu visualisieren sind und der Simulator keine Leerzeichen im Alphabet akzeptiert.

Das Konzept ist recht einfach: Mit q1 bis q4 werden nach rechts gerichtete Fische gefangen, mit q11 bis q14 werden nach links gerichtete Fische gefangen, mit q15 bis q19 werden Krabben gefangen und mit dem Blob q5 bis q10 wird einfach ein Leerzeichen eingefügt und alles bewegt folgende Zeichen eins rechts.

Wenn die Zeichenfolge interpretierbar ist, akzeptiert sie die Zeichenfolge und das Band enthält die Zeichenfolge mit eingefügten Leerzeichen. Andernfalls wird die Zeichenfolge zurückgewiesen (ich denke, dies gilt als keine Ausgabe - das Leeren des Bandes wäre ziemlich einfach, würde aber viele Übergangsregeln erfordern, und ich denke nicht, dass es die Übergangsfunktion schöner aussehen lassen würde).


1 Hinweis: Es ist schwierig zu kompilieren. Ich musste die bearbeiten src/tape.cppDatei und ersetzen LONG_MAXmit 1<<30und dann auf das gehen demoVerzeichnis, bearbeiten Sie die Makefile zu ersetzen EXE_BASENAMEmit turing.exeund auszuführen make. Dann gehe in das Verzeichnis mit den Dateien, die ich geschrieben habe und führe sie aus /path/to/turing/download/src/turing.exe meta.

jazzpi
quelle
3
Anscheinend habe ich +1 für Wahnsinn.
Kzqai,
22

Fisch (ja, dieser Fisch), 437 Bytes

Dies erscheint mir als eine dieser Programmieraufgaben, bei denen genau eine Sprache richtig ist.

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

Die folgende Version ist immer noch die längste Antwort auf die Herausforderung,

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]

aber da dies hauptsächlich für das Wortspiel gemacht wurde (ich hoffe, Sie werden es entschuldigen), bleibt dem Leser besseres Golfen als Übung überlassen.

xebtl
quelle
9
Was weißt du, es gibt (mindestens) zwei richtige Sprachen für diesen Job! Jemand (der kein Ich ist) sollte den anderen machen :-)
xebtl
2
Gleiches Programm in 383 Zeichen BASH mit einem BASE64-Blob: printf 'H4sIADSjKlUCA4VPQW6DMBC89xUj5AOocSSOlV1/BHGgjgMrBUPN0kRRHl/jmEg99WBLszM7M7s4BqMw2hQotNHxNy+QkDYJZU7rTJqED/p4NIdCLdFmVOfVW6bJY04DeQGhVteBLg4cVqfYLQxBkD3jQ6HzJwTHa/BRRmf4ibEtBpRfriefXCxKZ4cJghtB7eNqIW2lnqMu9D9N3T7sGtOssDInJCk+982/MlmOHQ+I6rqKRv5UpRxCntN7XSk7eSYfK0f+eR3EmI23qilH3iFCrjIqdyNO8nzJvJH7alMu7jsnlHZafWw5VluD9r/0/c2vQ95+AYBxAwS2AQAA'|base64 --decode|gzip -d>a;fish a
Mark K Cowan
20

> <> 602 Bytes

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

Eine Lösung in Fisch, wahrscheinlich sehr golfen, aber es ist mein erstes> <> Programm. Es bezieht seine Eingabe vom Eingabestapel und wird im Online-Interpreter> <> ausgeführt.

Wie es funktioniert :

Eine Schleife liest alle Eingaben und stapelt sie, kehrt sie um und setzt unten ein -1, was anzeigt, dass die Analyse abgeschlossen ist (alle Zeichen bleiben auf dem Stapel, bis die Zeichenfolge als analysierbar eingestuft wird).
Das Parsen verwendet die Tatsache, dass alle Zeichen unterschiedlich modulo 5 sind und alle Muster mit Ausnahme von <> << und> <>> deterministisch sind. Analysierte Zeichen werden am unteren Rand des Stapels abgelegt.
Wenn ein Muster vollständig ist und -1 oben steht, werden alle Zeichen gedruckt, andernfalls wird ein Leerzeichen hinzugefügt und das Programm wiederholt.
Wenn <> << oder> <>> angetroffen werden, wird das Register inkrementiert (0 am Anfang), und eine 0 wird vor dem letzten Zeichen auf den Stapel gelegt (so dass <> <oder> <> nach dem Zurücksetzen verbleibt). . Wenn später beim Parsen ein Fehler auftritt, wird das Register verkleinert, und alle Zeichen nach der 0 werden wieder an die Spitze gesetzt (mit Ausnahme von Leerzeichen dank eines% 8 = 0-Tests).
Wenn ein Fehler erkannt wird, während das Register 0 ist oder sich in der Krabbe befindet, endet das Programm sofort.

David D
quelle
13

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

Die Strategie besteht darin, Fischlisten zu generieren und ihre Verkettung mit der Eingabezeichenfolge zu vergleichen.

Das dauert unglaublich lange. Wenn Sie tatsächlich eine Ausgabe sehen möchten, ersetzen Sie diese for _ in sdurch for _ in [0]*3, wobei 3 die Obergrenze für die Anzahl der Fische ist. Es funktioniert, sweil es shöchstens einen Fisch pro Saibling enthält.

Danke an Sp3000 für Bugfixes und ein Zeichen, das bei der Eingabe gespart wird.

Alter 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])
xnor
quelle
@ Sp3000 Guter Fang, ich glaube ich kenne das Problem.
Xnor
@ Sp3000 ich denke es sollte jetzt funktionieren. Dies war ein Fall, in dem der Ternär a and b or ceinen falschen Wert bangab, wenn er möglicherweise falsch war . Ich habe auf if/else2 Zeichen zurückgegriffen, aber es könnte eine Möglichkeit geben, die ternäre Arbeit zu machen.
Xnor
Da Sie bereits in Python 3 sind, können Sie es auch (ab) verwenden: P*l,s=[],input()
Sp3000
Sie haben vergessen, die Byteanzahl zu verringern, als Sie das taten
undergroundmonorail
12

Perl, 81 + 1 Bytes

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

Versuchen Sie diesen Code online.

Dieser Code erwartet die Eingabe in der $_Variablen. Führen Sie dies mit Perls -nSchalter ( gezählt als +1 Byte ) aus, um ihn auf jede Eingabezeile anzuwenden, z. B. wie folgt:

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

Dieser Code verwendet Perls reguläre Ausdrücke (und insbesondere die eingebettete Codeausführungsfunktion ), um eine effiziente Rückverfolgungssuche durchzuführen. Die einzelnen gefundenen Fische werden in dem @aArray gesammelt , das bei erfolgreicher Übereinstimmung stringifiziert und ausgedruckt wird.

Dieser Code verwendet auch das Perl 5.10+ sayFunktion, und so müssen die ausgeführt wird -Eoder -M5.010Schalter (oder use 5.010;) , wie moderne Funktionen zu ermöglichen. Traditionell sind solche Schalter, die nur zum Aktivieren einer bestimmten Version der Sprache verwendet werden, nicht in der Byteanzahl enthalten.

Alternativ ist hier eine 87-Byte-Version, für die überhaupt keine speziellen Befehlszeilenoptionen erforderlich sind. Es liest eine Zeile von stdin und gibt das Ergebnis (falls vorhanden) ohne nachfolgenden Zeilenvorschub in stdout aus:

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

Ps. Wenn das Drucken eines zusätzlichen Speicherplatzes am Anfang der Ausgabe erlaubt wäre, könnte ich zwei weitere Bytes trivial einsparen mit:

/^((>><>|><(|>|<<)>|<><<|<(|<|>>)><|,<\.\.>,)(?{local$a="$a $2"}))*$(?{say$a})/
Ilmari Karonen
quelle
Sie können ein paar Bytes ><(>|<<)>
wegwerfen,
@ Sp3000: Danke! Das spart ein Byte für jede Fischrichtung.
Ilmari Karonen
6

Python 3, 196 186 Bytes

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)

Einfache Rekursion. Gibt gentweder eine Liste analysierter Fische zurück oder Noneist die Eingabezeichenfolge nicht analysierbar.

Sp3000
quelle
6

Python 2, 234 Bytes

Ich habe zuerst eine Python-Regex-Lösung ausprobiert, aber es scheint keine Möglichkeit zu geben, die Gruppen nach einer Übereinstimmung mit mehreren Mustern zu extrahieren. Das Folgende ist eine rekursive Suche, die in den Testfällen gut zu funktionieren scheint.

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)

Ein Beispieltest:

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

Und die ungolfed version:

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)
Logik-Ritter
quelle
3
Ich denke, Ihr allerletzter ifkann in einer einzigen Zeile stehen (wie Sie es anderswo getan haben). Anstatt if p<len(t)ich denke, können Sie auch tun if t[p:], um ein paar Bytes zu sparen.
Mathmandan
4

C # - 319 Bytes

Diese Lösung ist schändlich einfach, für Golf kaum etwas. Es ist ein vollständiges Programm, nimmt die Eingabe als Zeile von STDIN und gibt das Ergebnis an STDOUT aus.

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

Es wird einfach versucht, jeden Fisch an die erste Position nach einem Leerzeichen (oder am Anfang der Zeichenfolge) zu bringen und jede Fischart damit abzugleichen. Wenn der Fisch passt, ruft er den Löser nach dem Einfügen eines Leerzeichens nach dem Fisch rekursiv auf oder gibt einfach seine Eingabe zurück (mit einem \ n aus Ausgabegründen), wenn die nicht übereinstimmende Zeichenfolge buchstäblich der Fisch ist (dh wir haben eine Lösung gefunden). .

Ich habe nicht viel unternommen, um dem Fisch-String die übliche Kolmogorov-Behandlung zu geben, weil es nicht allzu lange dauert und ich keinen billigen Weg finde, einen String in C # umzukehren (ich glaube nicht, LINQ wird zahlen), also gibt es vielleicht eine Gelegenheit, aber ich bezweifle es etwas.

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"";
    }
}
VisualMelon
quelle
Oh, du hast mich erwischt. Ich habe nicht gesehen, dass es sich um eine Mehrfachdefinition handelt. Kommentar entfernt, um Rauschen zu reduzieren.
Kroltan,
3

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)()""
Swish
quelle
2
Dies gibt eine Fehlermeldung aus, wenn die Eingabe nicht geteilt werden kann, anstatt im Hintergrund fehlzuschlagen.
Zgarb
2
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);

Ich bin ein bisschen wie ein Python Noob, also ignoriere die Verrücktheit: P

ehrlich gesagt
quelle
3
Willkommen bei PPCG. Dies ist eine Code-Golf-Herausforderung, dh Sie sollten versuchen, den Code mit so wenig Zeichen wie möglich zu schreiben. Zunächst können Sie Variablen mit einem Buchstaben verwenden (z. B. manstelle von msg, sanstelle von start, ...) und nur 1 Leerzeichen pro Inkrement verwenden. Und bitte posten Sie die Anzahl der Zeichen Ihres Programms (Sie können sie hier zählen ).
Jakube,
Danke @Jakube, ich wusste nicht, dass es auch eine Golf-Herausforderung ist. Danke für die Tipps.
Franklynd
2

Ruby, 177 Bytes

Nicht die kürzeste, sondern die erste in Rubin:

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

Hier wird versucht, einen regulären Ausdruck rekursiv zu erweitern und mit der Eingabe abzugleichen.
Wenn eine längere Übereinstimmung gefunden wird, wird r () wiederkehren, wenn nicht, wird geprüft, ob die letzte Übereinstimmung die gesamte Eingabezeichenfolge belegt und erst dann mit zusätzlichen Leerzeichen ausgegeben.

Shirkrin
quelle
1

CJam, 111 96 91 (oder 62 Byte)

Ein iterativer, gieriger Ansatz, um herauszufinden, welche Fischkombinationen bei der Iteration möglich sind. Wirklich nicht gerade Golf gespielt.

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

Der Code enthält einige nicht druckbare Zeichen. Verwenden Sie daher den folgenden Link als Referenz.

Update Codiert die Zeichenfolge

Fügt eine Erklärung hinzu, sobald das Golfen abgeschlossen ist

Probieren Sie es hier online aus


62 Bytes

Super langsame Version. Dies erzeugt im Grunde alle Kombinationen und Prüfungen, die der Eingabe entsprechen.

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

Dies enthält auch nicht druckbare Zeichen. Verlassen Sie sich daher auf den folgenden Link.

Probieren Sie es hier online aus

Optimierer
quelle
1

Haskell, 148 146 Bytes

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

Testen:

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

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

<>> <>>

Erläuterung

Gestützt auf meine frühere Antwort auf eine ähnliche Frage. Der Algorithmus läuft in exponentieller Zeit ab.

Dies liest von rechts nach links.

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

Hiermit wird keine Zeichenfolge gedruckt, die mit einem Leerzeichen endet, auch wenn solche Zeichenfolgen ebenfalls generiert werden, da das Gegenstück ohne Leerzeichen zuerst generiert wird.

Zgarb
quelle
1

JavaScript (ES6), 164

Rekursiver Tiefenscan.
Als Programm mit I / O über 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()))

Als testbare Funktion:

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

Testsuite (in Firefox / FireBug-Konsole ausgeführt)

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

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

Ausgabe

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

Ungolfed nur die k-Funktion

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 ''
}
edc65
quelle
0

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

Dabei werden Listenverständnisse verwendet, um den Fisch zu durchlaufen, diejenigen auszuwählen, die dem Start entsprechen, und rekursiv fortzufahren.

stolzer haskeller
quelle
3
Die Herausforderung fordert explizit ein vollständiges Programm, das seine Ausgabe druckt, im Gegensatz zu einer Funktion.
Zgarb,
0

Javascript (122 135 Bytes)

Nicht die meisten Golfer hier, könnten ein wenig abgespeckt werden.

Dieses ist Regex-basiert und ein bisschen schwer herauszufinden, was los ist.

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

Dieser ist ein Einzeiler.

Grundsätzlich überprüfe ich die Syntax und teile dann die Zeichenfolge anhand der Zeichen auf und füge sie zusammen.
Es wird eine Ausnahme ausgelöst, wenn Sie eine ungültige Eingabe machen.

Wenn es keine Ausnahmen werfen kann (126 139 Bytes):

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

Beide sind Einzeiler.
Beides funktioniert genauso.


Vielen Dank an @ edc65 , dass Sie den Edge-Fall erkannt haben , der nicht richtig funktioniert hat.


Sie können es hier testen (die Ausgabe wird in das Dokument geschrieben).

Es basiert auf der Version, die Ausnahmen auslöst, wenn Sie ungültigen Code einführen.

(Derzeit gibt es einen Fehler in Stack-Snippets, Ich habe auf Meta gepostetEs wurde schon gestern gefragt. Für sie zu arbeiten, habe ich ersetzt $mit \x24, die die gleiche Leistung hat. Sie können über den Fehler hier lesen: http://meta.codegolf.stackexchange.com/questions/5043/stack-snippets-messing-with-js )

Ismael Miguel
quelle
Scheitern Sie mit Beispiel ><>><>>. Ich denke, dass dies mit Regexp nicht so einfach gelöst werden kann, Sie brauchen einen Lookahead oder Backtrak oder was auch immer ...
edc65
@ edc65 VERDAMMT! Im Moment habe ich keine Lösung. Ich versuche es später zu beheben
Ismael Miguel
0

Scala, 299 Bytes

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

Testfälle

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

Ausgabe

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

<<>< ><<<> >><> ><> ><> <>< <>>>< >><> >><> >><> ><>> <<>< 
Dave Swartz
quelle
0

Java, 288 Bytes

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

Formatiert:

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

Ich wollte keine Größe, aber hier ist eine leicht verständliche Methode, um dies in Dart zu tun.

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

Python 3, 166 164 Bytes

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

Rekursive Lösung. Spät auf der Party, aber ich dachte, ich würde es trotzdem posten, da es Sp3000 übertreffen würde20 22 Bytes, ohne die Antwort brachial erzwingen zu müssen.

Alexander Revo
quelle