Anexa ou Anexa? Depende

23

Brain-flak faz um ano amanhã! Em homenagem ao seu aniversário, estamos tendo uma festa de aniversário no estilo PPCG, na qual vários usuários postam perguntas relacionadas ao cérebro! Ajude-nos a celebrar! :)


Brain-flak é uma linguagem esotérica que escrevi, onde todos os comandos são colchetes e todos os colchetes devem ser totalmente compatíveis. Para emprestar minha própria definição :

  • Para o propósito deste desafio, um "suporte" é qualquer um desses caracteres: ()[]{}<>.

  • Um par de colchetes é considerado "correspondente" se os colchetes de abertura e fechamento estiverem na ordem correta e não tiverem caracteres dentro deles, como

    ()
    []{}
    

    Ou se todos os subelementos dentro dele também corresponderem.

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

    Os subelementos também podem ser aninhados com várias camadas de profundidade.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • Uma cadeia é considerada "Totalmente compatível" se e somente se:

    1. Cada caractere é um colchete,

    2. Cada par de suportes possui o suporte de abertura e fechamento correto e na ordem correta

Em comemoração ao primeiro aniversário do brain-flak, o desafio de hoje é pegar um conjunto desequilibrado de parênteses e determinar que tipos de operações são necessárias para torná-lo válido.

  • Por exemplo, ((não é um código de quebra-cabeça válido, mas se acrescentamos ))a ele, ele se torna (())totalmente equilibrado e, portanto, válido. Isso torna essa entrada anexável .

  • Da mesma forma, >}não é válido, mas podemos acrescentar {<a ele o make {<>}, que é válido. Isso torna essa entrada pré-selecionável .

  • Algumas entradas são um pouco mais complicadas. Por exemplo, )][({não é possível validar puramente anexando ou anexando. Mas isso pode ser validado [(acrescentando e acrescentando })]. Portanto, essa entrada é tanto prependable e appendable .

  • Por fim, algumas entradas nunca podem ser tornadas válidas como uma combinação de anexos ou anexos. Por exemplo, (>nunca pode ser válido. (Anexar <cria <(>e anexa )cria (>), nenhuma das quais é válida) Portanto, essa entrada não é nem anexável nem pré-selecionável.

Para o desafio de hoje, você deve escrever um programa ou função que use uma sequência de colchetes e determine se a sequência é

appendable
prependable
both
neither

Você pode escolher quais valores você usa para representar para cada caso. Por exemplo, saída 1, 2, 3, 4, ou 'a', 'p', 'b', 'n', ou 1, 'foo', 3.1415, -17, ou o que estiver bom. Contanto que cada saída seja distinta e consistente , tudo bem. No entanto, você deve especificar claramente qual saída corresponde a qual caso.

Você pode retornar esse valor no formato que for mais conveniente (por exemplo, retornar de uma função, imprimir em STDOUT, modificar argumentos, gravar em um arquivo etc.).

Você pode supor que a entrada nunca será válida e não funcionará.

Exemplos

As seguintes entradas são todas pré - selecionáveis :

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

Estes são todos anexáveis :

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

Estes são todos os dois :

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

E estes são todos nem :

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

Como de costume, isso é , então as brechas padrão se aplicam e a resposta mais curta em bytes vence!


Esse desafio é particularmente difícil no cérebro, então o máximo de brownie aponta para toda e qualquer resposta escrita no cérebro. :)

DJMcMayhem
fonte
1
maximum brownie pointsEu acho que a oferta de pontos e brownies máximos encorajaria esse desafio mais do que apenas pontos brownie, já que eu não acho que seja trivial em nenhum idioma, muito menos no Brain-Flak. : P
Erik the Outgolfer
FYI: Todos os dois testes terminam com colchetes abertos, nem todos os testes terminam com colchetes fechados.
Jonathan Allan
2
Eu diria que 'ambos' é o termo errado. Uma string como não][ é anexável, pois nada que você possa anexar pode torná-la válida. Da mesma forma, não é pré-aplicável. É ... 'inserível'! Você pode inseri-lo em uma string para tornar todo o Brainflak válido.
orlp
As cordas já balanceadas já são ou não?
Assistente de trigo
@wheatwizard Seqüências de caracteres balanceadas não serão fornecidas como entrada. You can assume that the input will never be valid brain-flak or empty.
DJMcMayhem

Respostas:

6

Geléia , 33 32 37 35 34 bytes

bug encontrado, correção horrível +5 bytes, melhor correção - 2 bytes, usando um truque de Adnan que eu vi aqui por -1 a mais.

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

Valores de retorno:

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

(Entrada inválida retorna resultados espúrios, embora válido Brain-flack, retorna [].)

Experimente online! - um conjunto de testes (gravuras mushed representações, então20para[2,0], e ignora as linhas contendo qualquer-).

Jonathan Allan
fonte
5

Retina , 41 40 41 bytes

1 byte salvo graças a @MartinEnder

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

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

Experimente online!

  • Prependível é 1
  • Anexável é 0
  • Ambos é 10
  • Nenhuma é 01

Edições

  • Obteve 1 byte para corrigir o erro observado por @Neil
Kritixi Lithos
fonte
[]})>]salva um byte.
Martin Ender
@MartinEnder Ah, é porque os conjuntos de caracteres não podem estar vazios, obrigado!
precisa saber é o seguinte
Isso não funciona para todas as entradas não anexáveis, por exemplo (][). Eu acho que pode ser corrigido ao custo de um byte, alterando 101para ...+.
Neil
@Neil Obrigado por perceber o erro, gostaria de saber se existem tais casos com Bothbem
Kritixi Lithos
Não, acho que 10é a única combinação válida para Both.
Neil
3

Lote, 337 bytes

@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%

Saídas ]para pré-anexar, [para anexar, ][para ambos, []para nenhum.

Neil
fonte
3

Haskell , 115 108 bytes

EDITAR:

  • -7 bytes: use mais guardas.
(""#)
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

Experimente online!

Use como (""#) "))". Os resultados são apresentados como:

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

Como funciona

  • A codificação de saída é escolhida de forma que a necessidade de prefixar seja sinalizada, descartando o segundo elemento do resultado para o restante, se houver, enquanto uma incompatibilidade completa é sinalizada, eliminando todos eles.
  • s#danalisa uma sequência restante d, considerando uma sequência / pilha sde colchetes esperados.
    • A s#""linha verifica se todos os colchetes de fechamento foram encontrados no final da cadeia, caso contrário é necessário anexar.
    • A primeira ramificação de s#(c:d)verificações se o próximo caractere cé um colchete de abertura e, se houver, deixa o colchete de fechamento correspondente na pilha para a recursão.
    • Caso contrário, se a pilha contiver colchetes de fechamento, a segunda ramificação verificará se a primeira corresponde ao próximo caractere e, se não, retorna uma lista vazia em vez de repetir.
    • Por fim, na última ramificação, a pilha está vazia e temos um colchete de fechamento incomparável, que pode ser corrigido com uma pré-inserção, antes da repetição.
Ørjan Johansen
fonte
2

Japonês , 44 bytes

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

Saídas 1para prependable, 3para appendable, 13para ambos, e 31para nenhum.

Teste online! ou Verifique todos os casos de teste de uma só vez.

Como funciona

 =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
fonte
2

PHP, 137 bytes

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

1 => anexável,

2 => prependível,

12 => ambos,

0 => nenhum

Casos de teste

Jörg Hülsermann
fonte
"Desde que cada saída seja distinta e consistente, tudo bem". Isso não parece ter um valor consistente para nenhum dos dois.
precisa saber é
@Cyoce Agora está corrigido
Jörg Hülsermann 4/17