Stack Cats è un linguaggio reversibile e basato su stack. La sua natura reversibile crea anelli piuttosto strani. Questa sfida riguarda il ciclo condizionale (...). Quando questi loop sono nidificati in determinati modi, è possibile trasformare il codice per ridurre la profondità di annidamento. Ecco le regole (dove AeB rappresentano uno snippet arbitrario):

1. Quando un loop inizia con un altro loop, possiamo estrarre il loop interno in primo piano: ((A)B) diventa (A)(B).
2. Quando un loop termina con un altro loop, possiamo estrarre il loop interno fino alla fine: (B(A)) diventa (B)(A).
3. I loop vuoti (), possono essere completamente rimossi dal programma. Come corollario (in combinato disposto con le altre regole),((A)) equivale a (A).

Gli unici loop nidificati che rimarranno sono della forma (A(B)C), dove A,B e Csono non vuoti.

La sfida

Ti viene dato un programma Stack Cats valido e il tuo compito è ridurre il livello di annidamento dei loop il più possibile, senza lasciare loop vuoti, utilizzando le trasformazioni di cui sopra.

Un programma Stack Cats valido ...

• ... consiste solo dei personaggi ()/\<>[]{}!"*+-:=ITX^_| .
• ... ha una simmetria speculare (ad es. \(]{}!{}[)/è un programma valido, ma/|/ non lo è).
• ... è abbinato correttamente e annidati ()e {}( [], <>e \/non devono necessariamente essere accompagnato come al solito, anche se appariranno a coppie a causa del requisito simmetria speculare).

Puoi prendere una stringa o un elenco di caratteri come input, ma l'output deve essere presentato nello stesso formato.

È possibile scrivere un programma o una funzione e utilizzare uno qualsiasi dei nostri metodi standard per ricevere input e fornire output. Si noti che queste lacune sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

I casi di test sono due righe ciascuno (input e output), separati da righe vuote. Si noti che un output è vuoto. È inoltre necessario supportare l'input vuoto (che dovrebbe risultare in output vuoto).

(((=+|+=)))
(=+|+=)

({(=+|+=)})
({(=+|+=)})

((\)/)I(\(/))
(\)(/)I(\)(/)

(()()(())()())


((<|>((X((T)))[_]))\^/(([_](((T))X))<|>))
(<|>)(X)(T)([_])(\^/)([_])(T)(X)(<|>)

Retina 0.8.2 , 113 107 67 66 byte

+`\(\)|(\()?(\(((\()|(?<-4>\))|[^()])*(?(4)@)\))(?(1)|(\)))
$5$2$1

Provalo online! Include un risparmio di 3 4 byte grazie a @MartinEnder. Spiegazione:

+`

Applica ripetutamente la sostituzione fino a quando non ci sono partite.

\(\)|

Abbina un loop vuoto (nel qual caso non viene catturato nulla, quindi la sostituzione lo elimina semplicemente) o:

(\()?

Opzionalmente abbinare a (. Questo viene catturato nel gruppo 1 se corrisponde, ma non in caso contrario.

(\(

Cattura il corpo principale della partita nel gruppo 2 e abbina a (.

(
 (\()
|
 (<-4>\))
|
 [^()]
)*

Abbina ripetutamente o a (, catturandolo nel gruppo 4, o a ), rimuovendo una cattura dal gruppo 4 (fallendo se non ce n'è uno) o qualcos'altro.

(?(4)@)

Assicurarsi che non siano presenti acquisizioni di riserva nel gruppo 4.

\))

Termina il gruppo di acquisizione 2 con un altro ).

(?(1)|(\)))

Se il gruppo di acquisizione 1 era vuoto, quindi acquisire un )gruppo di acquisizione 5. (Quindi esattamente uno di questi due gruppi avrà un'acquisizione).

$5$2$1

Spostare la parentesi catturata nel gruppo 1 o nel gruppo 5 dall'altro lato del gruppo 2. Ciò ha l'effetto di spostare il circuito interno in avanti o alla fine del circuito esterno a seconda del lato corrispondente.

Stax v1.0.3 +, 76 65 64 62 58 byte ^CP437

îÜ•$o,Γ{í]Üf╒9♦╛üΣóç*\$ñ₧└ΦJ♠¥c╥jóu≥3E.╘ⁿ◄◘W₧<¶┼7úê╟┴zç↨aG

70 byte quando decompresso,

{{.((:/Yc{Z{40=+_41=-c^Ci~^Fdy,,\32&jEa:{a:{a4l$c}Md}X!:Rx!:Rc.()z:rgp

Esegui ed esegui il debug online!

Spiegazione

{.((:/Yc{Z{40=+_41=-c^Ci~^Fdy,,\32&jEa:{a:{a4l$c}Mdè un blocco che si separa A((B)C)Din quattro parti e lo converte inA(B)(C)D .

X!:Rx!:Resegue il blocco sulla stringa di input (passaggio 1), quindi riflette la stringa (il riflesso della stringa in Stax si riferisce all'inversione della stringa più la sostituzione (traduzione) (<[{/con (a) \}]>)) ed esegue il blocco sulla stringa ottenuta, quindi riflette nuovamente (passo 2). Il passaggio 2 si sta essenzialmente convertendo (A(B))in(A)(B) .

c.()z:r rimuovere tutti gli anelli vuoti (passaggio 3).

gpè un generatore che trova il punto fisso di un'iterazione. In questo caso la stringa viene ripetuta con il processo in 3 passaggi fino a quando non cambia più.

Uscita implicita.

Python 3 , 226 223 212 206 byte

Ok, ecco un tentativo di risolverlo in un linguaggio che non supporta la regex ricorsiva.

lambda s:g(g(s,*'()'),*')(').replace('()','')
def g(s,t,u):
 m,*a={},;i=v=0
 for c in s:
  i+=1;a+=[i]*(c==t)
  if c==u:*a,x=a;m[x]=i;v=m.get(x+1)
  if v:return g(s[:x]+s[x+1:v]+t+s[v:],t,u)
 return s[::-1]

Provalo online!

modifiche:

• Rifattorizzato [::-1]per salvare 6 byte, grazie a Mr.Xcoder.

La gfunzione è il blocco predefinito di base, che trova un'occorrenza di ((A)B), la modifica in(A)(B) , quindi si applica al risultato fino a quando non è più possibile alcuna trasformazione.

I passaggi principali sono:

• Applicare gnormalmente all'ingresso.
• Applica gall'ingresso capovolto. Questa esecuzione trova la presenza di ))A(B(nell'input invertito, che gestisce efficacemente (A(B)).
• Rimuovere qualsiasi occorrenza di ().

Il problema è che gha una struttura di controllo così cattiva che provare a una linea lo ha gonfiato gravemente, quindi non credo che un grande miglioramento sia possibile sulla base di questa soluzione.