Antecedentes
Esta es una continuación de mi desafío anterior , donde la tarea era calcular la forma de una escultura obtenida colocando imanes en una enorme pila.
Buenas noticias: al artista excéntrico le gustó tu trabajo y tiene otro proyecto para ti. Todavía trabaja con esculturas magnéticas, pero ha decidido expandir su estudio de arte al espacio . Su método actual es disparar un solo imán en forma de cubo en la órbita y dispararle a otros imanes para crear un enorme satélite magnético.
Entrada
Su entrada es una lista finita de 0
sys 1
, dada en el formato de lista nativa de su idioma, o una cadena. Se interpreta como un "plano" de una obra de arte, y se procesa de izquierda a derecha de la siguiente manera.
Comienza con un solo imán flotando en alguna coordenada entera del plano 2D, y sigue agregando más imanes según las directivas. La directiva 0
gira toda la escultura 90 grados en sentido antihorario. En el caso de la directiva 1
, el artista encuentra la columna más a la izquierda de la escultura y le dispara un nuevo imán desde abajo. El nuevo imán se adhiere al imán más inferior existente en la columna y se convierte en parte de la escultura. Tenga en cuenta que el imán no se adhiere a otros imanes en la columna vecina, a diferencia del desafío anterior; ¡su velocidad ahora es astronómica!
Salida
El artista quiere saber si la escultura completa cabe en su garaje (no está claro cómo la bajará de la órbita). Por lo tanto, su salida es el ancho y la altura de la escultura, ordenada de menor a mayor. Se pueden dar como una lista de dos elementos, un par o como una cadena separada por una coma.
Ejemplo
Considere la secuencia de entrada
[1,0,1,1,0,1,0,0,1,1]
Para procesarlo, comenzamos con un imán flotando en el espacio:
#
La primera directiva es 1
, así que disparamos un nuevo imán desde abajo:
#
#
La siguiente directiva es 0
, así que rotamos la escultura:
##
Las siguientes dos directivas son 1,1
, lo que significa que dispararemos dos imanes a la columna más a la izquierda:
##
#
#
Luego, giramos nuevamente y disparamos una vez, como lo indica 0,1
:
#
###
#
Finalmente, giramos dos veces y disparamos dos veces:
#
###
# #
#
La escultura resultante tiene ancho 3
y alto 4
, por lo que sacamos [3,4]
.
Reglas
Puede dar una función o un programa completo. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.
Casos de prueba
[1,0,1] -> [2,2]
[1,0,1,1,0,1,0,0,1,1] -> [3,4]
[1,1,0,1,1,0,1,0,1,1] -> [4,5]
[1,1,0,1,1,0,1,0,1,1,0] -> [4,5]
[1,0,1,0,0,0,1,1,0,0,0,1,1,0,0,0,1,1] -> [3,3]
[0,1,0,1,1,1,1,0,0,1,0,1,0,0,1,1,0,1,0,1,0,0,1,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,1,1] -> [5,7]
[1,0,1,1,1,1,0,1,0,0,0,0,1,1,1,0,1,1,0,1,0,1,0,0,0,0,0,0,1,1,0,1,0,1,1,1,1,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,0,1,0,0,1,1,0,1,1,0,0,1,0,1,0,0,1,0,1,1,1,0,1,1,0,0,1,0,1,1,0,0,0,1,0,1,1,0,0,1,0,1,1,0] -> [11,12]
[1,1,0,1,1,0,1,0,1,1,0]
volver[5,4]
y no[4,5]
? La escultura se gira al final.Respuestas:
Pyth :
3433 bytesLa entrada es una lista de unos y ceros, como en la pregunta. Pruébelo en línea: Pyth Compiler / Executor
Explicación:
Es una traducción uno a uno del siguiente código de Python 2 ( 126 bytes ).
Creo una lista de coordenadas de los imanes individuales. Esto se inicializa con el imán
[0,0]
. Luego, para cada uno de los enteros del plano, manipulo la lista de la siguiente manera. Si el siguiente número entero es0
, puedo rotar la escultura cambiando las coordenadas para cada imán[a,b]
a[-b,a]
(básicamente multiplicando con una matriz de rotación). Si el siguiente entero es un1
, busco la pieza mínima[a,b]
(que es automáticamente el imán más bajo de la columna más a la izquierda) y agrego el imán[a,b-1]
a la lista.Después de procesar toda la entrada, creo 2 conjuntos (para eliminar duplicados), uno para los valores xy otro para los valores y, e imprimo los tamaños de ellos en orden ordenado.
Una idea para mejorar : usar números complejos como coordenadas para los imanes. Una rotación es solo una multiplicación
j
y restaj
del imán más bajo en la columna más a la izquierda. Lamentablemente, encontrar este imán más bajo a la izquierda requiere demasiados caracteres en Python, ni siquiera hablar de encontrar el rectángulo.fuente
CJam, 48 bytes
Pruébalo aquí.
Espera la entrada como una matriz de estilo CJam (es decir, espacios en lugar de comas) y presentará la salida de manera similar. Si desea utilizar los casos de prueba de la pregunta directamente, cópielos directamente en el campo de entrada (incluya los
->
resultados y) y use este arnés de prueba, que convierte las líneas al formato de entrada correcto (y descarta los resultados):Explicación
Solo estoy implementando las reglas muy literalmente. Mantengo una cuadrícula con la escultura actual (como un conjunto de cadenas), y luego, para cada instrucción, giro la cuadrícula o agrego un nuevo bloque. Los principales trucos para guardar bytes son:
S
yN
tengo acceso a cadenas que contienen el espacio y el carácter de nueva línea (es decir, el carácter envuelto en una matriz), en lugar de tener que usar, por ejemplo,1a
y0a
obtener una matriz que contenga un número.Veamos el código:
fuente
Matlab (92)
Se utiliza la entrada estándar. Los datos deben introducirse en el formulario
[1,0,1,1,0,1,0,0,1,1]
.Sin golf:
Ejemplo de ejecución:
fuente
Python - 211
fuente
[1]
.CJam, 47 bytes
Esto toma la entrada de matriz con estilo CJam (espacio separado en lugar de coma) de STDIN e imprime el resultado en STDOUT.
Ejemplo:
da
salida.
Explicación a seguir después de que estoy convencido de que esto no se puede jugar más.
Pruébalo en línea aquí
fuente