Tipos de parênteses iguais

9

Baseado em ESTE questão.

Dada uma sequência, substitua cada suporte ()[]{}<>por um suporte do tipo apropriado para que os colchetes correspondam e os colchetes aninhados alternem da seguinte maneira:

  1. Os ultraperiféricos são ()
  2. Diretamente dentro de ()deve ser[]
  3. Diretamente dentro de []deve ser{}
  4. Diretamente dentro de {}deve ser<>
  5. Diretamente dentro de <>será ()novamente (ciclos)

Todos os caracteres sem colchetes devem permanecer exatamente como estão. Os colchetes abertos só podem ser substituídos por colchetes abertos de algum tipo e os colchetes fechados por colchetes fechados.

A entrada sempre tornará isso possível. Isso significa que seus colchetes corresponderam corretamente se seu tipo for ignorado. Então, {ab<)c]é uma entrada válida, mas ab)(cdou ab((cdnão são.

Exemplos:

2#jd {¤>. = 2#jd (¤).
abcdef    = abcdef
(3×5+(4-1)) = (3×5+[4-1])
<<<>><<>><<<<<<>>>>>>> = ([{}][{}][{<([{}])>}])

O uso da transformação nativa de entrada dessa maneira (sintaxe automática do idioma) não é permitido.

Como sempre: o código mais curto vence.

code-golf string balanced-string Dirk Reichel
fonte
Eu não entendo o desafio. Qual deve ser a saída em termos de entrada?
Xnor
@xnou a saída deve ser a mesma string que a entrada, exceto pelos quatro tipos de colchetes. Eles precisam ser substituídos para corresponder ao padrão.
Dirk Reichel
Ah, agora eu vejo. Eu não entendi que o "deveria ser" são coisas que você deveria tornar verdade. Vou editar para tentar torná-lo mais claro.
Xnor
11
@DirkReichel Eu não acho que seja algo com que você precise se preocupar. Não consigo imaginar que qualquer idioma possa fazer essa transformação específica de forma nativa, e no improvável evento de que exista essa linguagem, tudo o que isso significa é que as respostas nessa linguagem não serão muito interessantes.
Martin Ender
2
@DirkReichel Qual é o objetivo? Basta ficar com o ASCII. O uso de caracteres diferentes não adiciona nada ao desafio, além de restrições desnecessárias em idiomas somente ASCII.
FlipTack

Respostas:

2

JavaScript (ES6), 79 bytes

s=>s.replace(/./g,c=>~(p=l.indexOf(c))?l[p&4?--k&3|4:k++&3]:c,l='([{<)]}>',k=0)

Casos de teste

Mostrar snippet de código

Arnauld
fonte
1

Lex, 132 bytes

%{
int i,o[4]={40,91,123,60};
%}
%%
[[({<] {putchar(o[i++&3]);}
[])}>] {putchar(o[--i&3]+2-!(i&3));}
%%
yywrap(){}
main(){yylex();}
Rainer P.
fonte
Você pode salvar 27 bytes (lex portátil) ou 30 bytes (usando flexcomo compilador) excluindo as duas ou três últimas linhas, respectivamente, a um custo de um número de bytes (provavelmente 2, 3 ou 4; as regras não são claras) nas penalidades para a -llopção de linha de comando ao vincular o arquivo C. resultante. (Ou seja, em vez de compilar lex brackets.l; cc lex.yy.c, você compila lex brackets.l; cc lex.yy.c -ll.) Definitivamente, é uma troca que vale a pena fazer nessa situação.
1

Java, 155 bytes

a->{String s="([{<)]}>";for(int i=0,j=0,k;i<a.length;i++){k=s.indexOf(a[i]);if(k>3){a[i]=s.charAt(--j%4+4);}else if(k>-1){a[i]=s.charAt(j++%4);}}return a;}

Lambda que leva um char[]argumento único. Nós percorremos o array, armazenando sua posição em nossa cadeia de colchetes ( s) em uma variável ( k). Verificamos se é um suporte de abertura ou fechamento ( s.indexAt()) e o substituímos pelo suporte apropriado com base no nível de aninhamento ( s.charAt()), fazendo um loop apropriado com%4

Xanderhall
fonte
1

Haskell, 126 bytes

b="([{<"
d=")]}>"
y=cycle
(!)=elem
f(e:c)n(x:r)|x!b=y b!!n:f(y d!!n:e:c)(n+1)r|x!d=e:f c(n-1)r|1<3=x:f(e:c)n r
f c n s=s
f" "0

Experimente em ideone. Uso:

*Main> f" "0 "<<<>><<>><<<<<<>>>>>>>"
"([{}][{}][{<([{}])>}])"

Explicação

futiliza três argumentos: Uma sequência que funciona como pilha para fechar colchetes, uma int npara contar a profundidade de aninhamento e a sequência de entrada.

f c n "" = ""                            -- base case for recursion: input string is empty
f (e:c) n (x:r)                          -- for the current char x
   | elem x "([{<" =                     -- check if it is an opening bracket
       (cycle "([{<")!!n :               --   if so, replace it with a bracket of the current nesting depth
           f ((cycle ")]}>")!!n : e : c) --   push the matching closing bracket on the stack
               (n+1) r                   --   increase depth level and check the next char
   | elem x ")]}>" =                     -- if x is a closing bracket
       e :                               --   replace it by the closing bracket from on top of the stack
           f c (n-1) r                   --   decrement depth level and check the next char
   | otherwise     = x : f (e:c) n r     -- otherwise keep x and check the next char
Laikoni
fonte