Tipi di parentesi uguali


9

Sulla base di QUESTA domanda.

Dato una stringa, sostituire ogni parentesi ()[]{}<>con una parentesi del tipo appropriato in modo che le parentesi corrispondano e le parentesi nidificate si alternano come segue:

  1. Quelli più esterni lo sono ()
  2. Direttamente all'interno di ()dovrebbe essere[]
  3. Direttamente all'interno di []dovrebbe essere{}
  4. Direttamente all'interno di {}dovrebbe essere<>
  5. Direttamente all'interno di <>sarà di ()nuovo (cicli)

Tutti i caratteri non parentesi devono rimanere esattamente come sono. Le parentesi aperte possono essere sostituite solo con parentesi aperte di qualche tipo e parentesi chiuse con parentesi chiuse.

L'input lo renderà sempre possibile. Questo significa che le sue parentesi corrispondono correttamente se il loro tipo viene ignorato. Quindi, {ab<)c]è un input valido, ma ab)(cdo ab((cdnon lo sono.

Esempi:

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

L'uso della trasformazione nativa dell'input in questo modo (sintassi automatica del linguaggio) non è consentito.

Come sempre: vince il codice più corto.


Non capisco la sfida. Cosa deve essere l'output in termini di input?
xnor

@xnor l'output dovrebbe essere la stessa stringa dell'input, ad eccezione dei quattro tipi di parentesi. Devono essere sostituiti per adattarsi al modello.
Dirk Reichel,

Ah, ora vedo. Non ho capito che i "dovrebbero essere" sono cose che dovresti rendere vere. Modificherò per provare a renderlo più chiaro.
xnor

1
@DirkReichel Non penso che sia qualcosa di cui devi preoccuparti. Non riesco a immaginare che qualsiasi lingua possa fare questa trasformazione specifica in modo nativo, e nell'improbabile eventualità che esista una lingua del genere, tutto ciò significa che le risposte in quella lingua non saranno molto interessanti.
Martin Ender,

2
@DirkReichel che senso ha? Tieni duro con ASCII. L'uso di personaggi diversi non aggiunge nulla alla sfida, a parte le restrizioni inutili sulle lingue solo ASCII.
FlipTack,

Risposte:


2

JavaScript (ES6), 79 byte

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

Casi test


1

Lex, 132 byte

%{
int i,o[4]={40,91,123,60};
%}
%%
[[({<] {putchar(o[i++&3]);}
[])}>] {putchar(o[--i&3]+2-!(i&3));}
%%
yywrap(){}
main(){yylex();}

Puoi salvare 27 byte (lex portatile) o 30 byte (usando flexcome compilatore) eliminando rispettivamente le ultime due o tre righe, al costo di un certo numero di byte (probabilmente 2, 3 o 4; le regole sono in qualche modo poco chiare) nelle penalità per l' -llopzione della riga di comando quando si collega il file C risultante. (Cioè, invece di compilare lex brackets.l; cc lex.yy.c, ti compili con lex brackets.l; cc lex.yy.c -ll.) Questo è sicuramente un compromesso che vale la pena fare in questa situazione.

1

Java, 155 byte

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 che accetta un char[]come singolo argomento. Passiamo attraverso l'array, memorizzandone la posizione nella nostra stringa di parentesi ( s) in una variabile ( k). Controlliamo se si tratta di una parentesi aperta o chiusa ( s.indexAt()) e la sostituiamo con la parentesi appropriata in base al suo livello di annidamento ( s.charAt()), eseguendo il loop in modo appropriato con%4


1

Haskell, 126 byte

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

Provalo su ideone. Uso:

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

Spiegazione

faccetta tre argomenti: una stringa che funziona come stack per la chiusura delle parentesi, un int nper il conteggio della profondità di annidamento e la stringa di input.

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.