Stack Cats es un lenguaje reversible basado en pila. Su naturaleza reversible crea bucles algo extraños. Este desafío es sobre el ciclo condicional (...)
. Cuando estos bucles se anidan de ciertas maneras, es posible transformar el código para reducir la profundidad de anidación. Estas son las reglas (dónde A
y B
representan fragmentos arbitrarios):
- Cuando un ciclo comienza con otro ciclo, podemos extraer el ciclo interno al frente: se
((A)B)
convierte(A)(B)
. - Cuando un ciclo termina con otro ciclo, podemos extraer el ciclo interno hasta el final: se
(B(A))
convierte(B)(A)
. - Los bucles vacíos
()
, se pueden eliminar del programa por completo. Como corolario (en conjunción con las otras reglas),((A))
es equivalente a(A)
.
Los bucles anidados única que permanecerán son de la forma (A(B)C)
, donde A
, B
y C
son no vacío.
El reto
Se le proporciona un programa válido de Stack Cats y su tarea es reducir el nivel de anidamiento de los bucles tanto como sea posible, sin dejar bucles vacíos, utilizando las transformaciones anteriores.
Un programa válido de Stack Cats ...
- ... consta solo de los personajes
()/\<>[]{}!"*+-:=ITX^_|
. - ... tiene simetría de espejo (por ejemplo,
\(]{}!{}[)/
es un programa válido, pero/|/
no lo es). - ... ha emparejado correctamente y anidado
()
y{}
([]
,<>
y\/
no necesariamente tienen que ser igualado como de costumbre, a pesar de que aparecerán en parejas debido al requisito de simetría de espejo).
Puede tomar una cadena o una lista de caracteres como entrada, pero la salida debe presentarse en el mismo formato.
Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas. Tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.
Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .
Casos de prueba
Los casos de prueba son dos líneas cada uno (entrada y salida), separados por líneas vacías. Tenga en cuenta que una salida está vacía. También debe admitir la entrada vacía (que debería dar como resultado una salida vacía).
(((=+|+=)))
(=+|+=)
({(=+|+=)})
({(=+|+=)})
((\)/)I(\(/))
(\)(/)I(\)(/)
(()()(())()())
((<|>((X((T)))[_]))\^/(([_](((T))X))<|>))
(<|>)(X)(T)([_])(\^/)([_])(T)(X)(<|>)
fuente
()
, por lo que una entrada{{A}B}
permanecerá como está y no se extraerá{A}{B}
también.(...)
bucles de tipo.\^/
dentro del paréntesis?(<|>((X((T)))[_]))
y(([_](((T))X))<|>)
.((A)B(C))
se volverá(A)(B)(C)
debido a las reglas 1 y 2 posteriormente:((A)B(C))
→(A)(B(C))
(regla 1) →(A)(B)(C)
(regla 2).Respuestas:
Retina 0.8.2 ,
1131076766 bytesPruébalo en línea! Incluye
34 bytes de ahorro gracias a @MartinEnder. Explicación:Aplica la sustitución repetidamente hasta que no haya coincidencias.
Haga coincidir un bucle vacío (en cuyo caso no se captura nada, por lo que la sustitución simplemente lo elimina) o:
Opcionalmente coincida con a
(
. Esto se captura en el grupo 1 si coincide, pero no si no coincide.Captura el cuerpo principal del partido en el grupo 2 y combina a
(
.Haga coincidir repetidamente a
(
, capturándolo en el grupo 4, o a)
, eliminando una captura del grupo 4 (si no hay una), o algo más.Asegúrese de que no queden capturas de repuesto en el grupo 4.
Finalice la captura del grupo 2 con otro
)
.Si el grupo de captura 1 estaba vacío, capture un
)
grupo de captura 5. (entonces exactamente uno de esos dos grupos tendrá una captura).Mueva el soporte capturado en el grupo 1 o en el grupo 5 al otro lado del grupo 2. Esto tiene el efecto de mover el bucle interno hacia el frente o el final del bucle externo dependiendo de qué lado coincida.
fuente
Stax v1.0.3 +,
7665646258 bytes CP43770 bytes cuando está desempaquetado,
¡Ejecute y depure en línea!
Explicación
{.((:/Yc{Z{40=+_41=-c^Ci~^Fdy,,\32&jEa:{a:{a4l$c}Md
es un bloque que se separaA((B)C)D
en cuatro partes y lo convierte enA(B)(C)D
.X!:Rx!:R
ejecuta el bloque en la cadena de entrada (paso 1), luego refleja la cadena (la reflexión de la cadena en Stax se refiere a invertir la cadena más reemplazar (traducir)(<[{/
con (a)\}]>)
) y ejecutar el bloque en la cadena obtenida, y luego reflejarlo de nuevo (paso 2). El paso 2 se está convirtiendo esencialmente(A(B))
en(A)(B)
.c.()z:r
elimine todos los bucles vacíos (paso 3).gp
es un generador que encuentra el punto fijo de una iteración. En este caso, la cadena se repite con el proceso de 3 pasos hasta que ya no cambie.Salida implícita.
fuente
Python 3 ,
226223212206 bytesBien, aquí hay un intento de resolver esto en un lenguaje que no admite expresiones regulares recursivas.
Pruébalo en línea!
Ediciones:
[::-1]
para guardar 6 bytes, gracias a Mr.Xcoder.La
g
función es el bloque de construcción básico, que encuentra una ocurrencia de((A)B)
, lo cambia a(A)(B)
luego se aplica al resultado hasta que no sea posible más transformación.Los pasos principales son:
g
a la entrada normalmente.g
a la entrada invertida. Esta ejecución encuentra la aparición de))A(B(
en la entrada invertida, que maneja efectivamente(A(B))
.()
.El problema es que
g
tiene una estructura de control tan mala que tratar de hacer una línea lo hizo hincharse mucho, por lo que no creo que sea posible una mejora importante en función de esta solución.fuente