Interprétation de poisson (non, pas que poisson)

69

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.
Les passe-temps de Calvin
la source
4
Je pensais que nous allions interpréter les paroles de Fish :-(
RemcoGerlich le
9
@RemcoGerlich Pas que du poisson non plus
Calvin's Hobbies
4
Enfin, un code-golf pour le format de transfert de poisson général RFC 3889 (mettant en œuvre la norme RFC3500: format de transfert de poisson standard)!
Sanchises
11
Points bonus si vous utilisez BrainF ***! Et plus votre programme met longtemps à réaliser son propre code qui n'est pas compatible avec les règles de pêche, mieux c'est.
mbomb007
3
J'ai vu cela et ai fait défiler l'écran vers le bas, résigné au fait que ce serait @ Calvin'sHobbies et personne, personne d'autre.
Soham Chowdhury

Réponses:

21

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
isaacg
la source
Le compilateur en ligne est-il trop lent pour l'exécuter sur l'exemple fourni dans la question?
Optimiseur
Oui, beaucoup trop lent / trop court. ><>><>>prend 15 secondes sur ma machine.
Isaac
28
O (9 ^ n) , sainte inefficacité!
mbomb007
2
@ mbomb007 Je ne vois rien en matière d'efficacité dans les règles: P +1!
John Odom
3
@ mbomb007: Probablement encore meilleur qu'un compilateur C ++.
Mark K Cowan
27

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

Définition

États

Alphabet

Etat initial

Caractère vide

États acceptants

Fonction de transition

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


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

jazzpi
la source
3
Apparemment, je +1 pour la folie.
Kzqai
22

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.

xebtl
la source
9
Que savez-vous, il y a (au moins) deux bonnes langues pour ce travail! Quelqu'un (qui n'est pas moi) devrait faire l'autre :-)
xebtl
2
Même programme dans 383 caractères de BASH avec un blob BASE64 inclus: 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 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.

David D
la source
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

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])
Xnor
la source
@ Sp3000 Bonne prise, je pense connaître le problème.
xnor
@ Sp3000 Je pense que cela devrait fonctionner maintenant. C'était un cas de la ternairea and b or c donnait une valeur fausse alors que bpourrait être Falsey. Je suis revenu à if/else2 caractères, mais il y aurait peut-être un moyen de faire fonctionner le ternaire.
xnor
Puisque vous êtes déjà dans Python 3, vous pourriez aussi bien (ab) l’utiliser: P *l,s=[],input()
Sp3000 le
vous avez oublié de diminuer le nombre d'octets quand vous avez fait ^ that
undergroundmonorail
12

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})/
Ilmari Karonen
la source
Vous pouvez ><(>|<<)>
supprimer
@ Sp3000: Merci! Cela économise un octet pour chaque direction du poisson.
Ilmari Karonen
6

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.

Sp3000
la source
6

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)
Logic Knight
la source
3
Je pense que votre tout dernier ifpeut être sur une seule ligne (comme vous l'avez fait ailleurs). Aussi, au lieu de if p<len(t)je pense que vous pouvez faire if t[p:]pour économiser quelques octets.
mathmandan
4

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"";
    }
}
VisualMelon
la source
Oh, tu m'as eu. Je n'ai pas vu que c'était une définition multiple. Commentaire supprimé pour réduire le bruit.
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)()""
bruissement
la source
2
Ceci affiche un message d'erreur si l'entrée ne peut pas être scindée, par opposition à un échec en mode silencieux.
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);

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

franchement
la source
3
Bienvenue chez PPCG. Il s’agit d’un défi code-golf, ce qui signifie que vous devez essayer d’écrire le code avec le moins de caractères possible. Pour commencer, vous pouvez utiliser des variables d’une seule lettre (par exemple, mau lieu de msg, sau lieu destart , ...) et utiliser un seul espace par incrément. Et s'il vous plaît, ajoutez le nombre de caractères de votre programme (vous pouvez les compter ici ).
Jakube
Merci @Jakube, je ne savais pas que c'était aussi un défi de golf. Merci pour les conseils.
Franchlynd
2

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.

Shirkrin
la source
1

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

Optimiseur
la source
1

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.

Zgarb
la source
1

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 ''
}
edc65
la source
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[]

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.

fier haskeller
la source
3
Le défi demande explicitement un programme complet qui imprime sa sortie, par opposition à une fonction.
Zgarb
0

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.

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

Ismael Miguel
la source
Échec avec exemple ><>><>>. Je pense que cela ne peut pas être résolu aussi facilement avec Regexp, vous avez besoin d'un peu de look, de backtrak ou de quoi que ce soit ...
edc65
@ edc65 DAMN! Pour l'instant, je n'ai pas de solution. Je vais essayer de réparer plus tard
Ismael Miguel
0

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

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

<<>< ><<<> >><> ><> ><> <>< <>>>< >><> >><> >><> ><>> <<>< 
Dave Swartz
la source
0

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

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

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.

Alexander Revo
la source