Ajoute ou ajoute? Dépend

23

Brain-flak a un an demain! En l'honneur de son anniversaire, nous organisons une fête d'anniversaire de style PPCG, où plusieurs utilisateurs publient des questions liées au brain-flak! Aidez-nous à célébrer! :)


Brain-flak est un langage ésotérique que j'ai écrit où toutes les commandes sont des crochets et tous les crochets doivent être entièrement mis en correspondance. Pour emprunter ma propre définition :

  • Aux fins de ce défi, un « support » est l' un de ces caractères: ()[]{}<>.

  • Une paire de crochets est considérée comme "assortie" si les crochets d'ouverture et de fermeture sont dans le bon ordre et ne contiennent aucun caractère, comme

    ()
    []{}
    

    Ou si chaque sous-élément à l'intérieur est également mis en correspondance.

    [()()()()]
    {<[]>}
    (()())
    

    Les sous-éléments peuvent également être imbriqués plusieurs couches en profondeur.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • Une chaîne est considérée comme "entièrement mise en correspondance" si et seulement si:

    1. Chaque caractère est une parenthèse,

    2. Chaque paire de supports a le support d'ouverture et de fermeture correct et dans le bon ordre

Pour célébrer le premier anniversaire de brain-flak, le défi d'aujourd'hui consiste à prendre un ensemble de supports déséquilibré et à déterminer les types d'opérations nécessaires pour le rendre valide.

  • Par exemple, ((n'est pas un code de flak de cerveau valide, mais si nous y ajoutons )), il devient (()), qui est entièrement équilibré, et donc un flak de cerveau valide. Cela rend cette entrée annexable .

  • De même, >}n'est pas valide, mais nous pouvons lui ajouter {<à faire {<>}, ce qui est valide. Cela rend cette entrée pré-disponible .

  • Certaines entrées sont légèrement plus compliquées. Par exemple, )][({ne peut pas être rendu valide uniquement en ajoutant ou en ajoutant. Mais il peut être validé en ajoutant [(et en ajoutant })]. Par conséquent, cette entrée peut être ajoutée et ajoutée à la fois .

  • Enfin, certaines entrées ne peuvent jamais être rendues valides comme un flak de cerveau par n'importe quelle combinaison d'ajout ou de pré-ajout. Par exemple, (>ne peut jamais être rendu valide. (La <création de préfixe <(>et la )création de création (>)ne sont valides ni l'une ni l'autre). Par conséquent, cette entrée n'est ni modifiable ni modifiable.

Pour le défi d'aujourd'hui, vous devez écrire un programme ou une fonction qui prend une chaîne de crochets et détermine si la chaîne est

appendable
prependable
both
neither

Vous pouvez choisir les valeurs que vous utilisez pour représenter pour chaque cas. Par exemple, la sortie 1, 2, 3, 4, ou 'a', 'p', 'b', 'n', ou 1, 'foo', 3.1415, -17, ou tout ce qui est bien. Tant que chaque sortie est distincte et cohérente , c'est bien. Vous devez cependant spécifier clairement quelle sortie correspond à quel cas.

Vous pouvez renvoyer cette valeur dans le format le plus pratique (par exemple, retour d'une fonction, impression vers STDOUT, modification des arguments, écriture dans un fichier, etc.).

Vous pouvez supposer que l'entrée ne sera jamais valide ou vide.

Exemples

Les entrées suivantes peuvent toutes être ajoutées :

))
(((()()())))}
)>}]
()[]{}<>)

Ce sont tous annexables :

(({}{})
((((
([]()())(
{<<{

Ce sont tous les deux :

))((
>()[(()){
>{

Et ce ne sont ni l'un ni l'autre :

)(}
{(((()()()))>
[}
((((((((((>
((((((((((<>()]

Comme d'habitude, il s'agit de , donc les failles standard s'appliquent et la réponse la plus courte en octets gagne!


Ce défi est particulièrement difficile en brain-flak, donc le maximum de brownie pointe vers toutes les réponses écrites en brain-flak. :)

DJMcMayhem
la source
1
maximum brownie pointsJe pense qu'offrir à la place un maximum de points de brownie et de cookies encouragerait Brain-Flaking ce défi plus que de simples points de brownie, car je ne pense pas que ce soit trivial du tout dans n'importe quelle langue, sans parler de Brain-Flak. : P
Erik the Outgolfer
FYI: Tous les deux tests se terminent par des crochets ouverts, tous les tests ne se terminent pas par des crochets fermés.
Jonathan Allan
2
Je dirais que «les deux» est le mauvais terme. Une chaîne comme ][est pas inscriptible, comme rien que vous pouvez ajouter peut la rendre valide. De même, ce n'est pas disponible. C'est ... 'insérable'! Vous pouvez l'insérer dans une chaîne pour rendre l'ensemble Brainflak valide.
orlp
Les cordes sont-elles déjà équilibrées les deux ou aucune?
Wheat Wizard
@wheatwizard Les chaînes équilibrées ne seront pas fournies en entrée. You can assume that the input will never be valid brain-flak or empty.
DJMcMayhem

Réponses:

6

Gelée , 33 32 37 35 34 octets

bug trouvé, horrible correction +5 octets, meilleure correction - 2 octets, en utilisant une astuce d'Adnan que j'ai vue ici pour -1 de plus.

“({[<“)}]>”Z;@WœṣF¥/µÐLO‘&2µIṀ>0ȯQ

Valeurs de retour:

prepends [2]
 appends [0]
    both [2,0]
 neither 1

(Une entrée non valide renvoie des résultats erronés, bien que Brain-flack valide, retourne [].)

Essayez-le en ligne! - une suite de tests (imprime des représentations musclées, donc20pour[2,0], et ignore les lignes qui en contiennent-).

Jonathan Allan
la source
5

Rétine , 41 40 41 octets

1 octet enregistré grâce à @MartinEnder

+`\(\)|\[]|{}|<>

[]})>]+
1
\W+
0
...+
01

Essayez-le en ligne!

  • Prependable est 1
  • Appendable est 0
  • Les deux sont 10
  • Aucun n'est 01

Modifications

  • Obtention d'un octet pour corriger un bug remarqué par @Neil
Kritixi Lithos
la source
[]})>]enregistre un octet.
Martin Ender
@MartinEnder Ah, c'est parce que les jeux de caractères ne peuvent pas être vides, merci!
Kritixi Lithos
Cela ne fonctionne pas pour toutes les entrées qui ne peuvent pas être ajoutées, par exemple (][). Je pense qu'il peut être fixé à un coût d'un octet en changeant 101en ...+.
Neil
@Neil Merci d'avoir remarqué le bug, je me demande s'il y a de tels cas , avec Bothaussi bien
Kritixi Lithos
Non, je pense que 10c'est la seule combinaison valable pour Both.
Neil
3

Lot, 337 octets

@echo off
set/ps=
:g
set "t=%s:<>=%
set "t=%t:()=%
set "t=%t:[]=%
set "t=%t:{}=%
if not "%t%"=="%s%" set "s=%t%"&goto g
set "s=%s:<=[%
set s=%s:>=]%
set s=%s:(=[%
set s=%s:)=]%
set s=%s:{=[%
set s=%s:}=]%
:l
if %s:~,2%==]] set s=%s:~1%&goto l
:r
if %s:~-2%==[[ set s=%s:~,-1%&goto l
if not _%s:~2%==_ set s=[]
echo %s%

Sorties ]pour pré- [ajouter , pour ajouter, ][pour les deux, []pour aucun.

Neil
la source
3

Haskell , 115 108 octets

MODIFIER:

  • -7 octets: utilisez plus de gardes.
(""#)
s#""=[s>"",1>0]
s#(c:d)|Just a<-lookup c$zip"([{<"")]}>"=(a:s)#d|(a:b)<-s=[1|a==c]>>b#d|0<1=take 1$s#d

Essayez-le en ligne!

Utilisez comme (""#) "))". Les résultats sont donnés comme suit:

[False,True]: needs nothing
[False]: prependable
[True,True]: appendable
[True]: both
[]: neither

Comment ça marche

  • Le codage de sortie est choisi de telle sorte qu'un besoin de préfixation soit signalé en supprimant le deuxième élément du résultat pour le reste, le cas échéant, tandis qu'une incompatibilité complète est signalée en les supprimant tous.
  • s#danalyse une chaîne restante d, étant donné une chaîne / pile sde crochets de fermeture attendus.
    • La s#""ligne vérifie si tous les crochets de fermeture ont été trouvés à la fin de la chaîne, sinon un ajout est nécessaire.
    • La première branche de s#(c:d)vérifications si le caractère suivantc est une parenthèse ouvrante, et si tel est le cas, laisse la parenthèse fermante correspondante sur la pile pour la récursivité.
    • Sinon, si la pile contient des parenthèses fermantes, la deuxième branche vérifie si la première correspond au caractère suivant, et sinon, renvoie une liste vide au lieu de se reproduire.
    • Enfin, dans la dernière branche, la pile est vide, et nous avons une parenthèse de fermeture inégalée qui peut être fixée par pré-ajout, avant de se reproduire.
Ørjan Johansen
la source
2

Japt , 44 octets

=Ue"%(%)|%[]|\{}|<>" ®c -1&2|1})f31 |UfD |Ug

Sorties 1pour pré-ajoutable, 3pour appendice, 13pour les deux et31 pour aucun.

Testez-le en ligne! ou Vérifiez tous les cas de test à la fois.

Comment ça marche

 =Ue"%(%)|%[]|\{}|<>" ®   c -1&2|1})f31 |UfD |Ug
U=Ue"%(%)|%[]|\{}|<>" mZ{Zc -1&2|1})f31 |UfD |Ug

                    // "(((()()())))}"  "([({}{})"    ">()[(()){"  "((((<>()]"
Ue"%(%)|%[]|\{}|<>" // Recursively remove all instances of "()", "[]", "{}", and "<>" from U.
                    // "}"              "(["          ">[{"        "((((]"
mZ{Zc -1&2|1}       // Replace each char Z with (Z.charCodeAt() - 1) & 2 | 1.
                    // "1"              "33"          "133"        "33331"
U=                  // Save the result in U.
f31 |UfD |Ug        // Match all instances of "31" and "13" (D = 13) and bitwise-OR the results with the first char.
                    // null|null|1      null|null|3   null|13|1    31|null|3
                    // 1                3             13           31
                    // Implicit: output result of last expression
ETHproductions
la source
2

PHP, 137 octets

for($c=1;$c;)$a=preg_replace("#<>|\(\)|\[\]|\{\}#","",$a=&$argn,-1,$c);echo($a=preg_replace(["#[]})>]+#","#[[{(<]+#"],[1,2],$a))<13?$a:0;

1 => annexable,

2 => disponible,

12 => les deux,

0 => ni

Cas de test

Jörg Hülsermann
la source
"Tant que chaque sortie est distincte et cohérente, c'est bien". Cela ne semble pas avoir de valeur cohérente pour ni l'un ni l'autre.
Cyoce
@Cyoce C'est maintenant
résolu