Una pared de ladrillos es un rectángulo hecho de ladrillos horizontales de 1 por n apilados en filas. Aquí hay un muro de altura 4 y ancho 8, con tamaños de ladrillo a la derecha.
[______][______] 4 4
[__][____][__][] 2 3 2 1
[][______][____] 1 4 3
[____][______][] 3 4 1
Este muro es inestable porque tiene una falla , un lugar donde se alinean dos grietas verticales entre los ladrillos, que se muestran a continuación con parens en los ladrillos circundantes.
[______][______]
[__][____)(__][]
[][______)(____]
[____][______][]
Pero, las grietas que bordean los ladrillos de tamaño 1 a la derecha no forman una falla porque están separadas por una fila.
Escriba un código que encuentre y muestre un muro estable construido con ladrillos de tamaños específicos. Pocos bytes ganan.
Entrada
Una lista no vacía de tamaños de ladrillo (números positivos) y una altura de al menos 2. Esta lista se puede ordenar si lo desea. Alternativamente, puede tomar un recuento de ladrillos de cada tamaño.
Salida
Una imagen de una pared rectangular estable de la altura requerida que utiliza todos los ladrillos dados. Imprimirlo o devolverlo como una cadena con nuevas líneas.
Dibuje un ladrillo de tamaño n como 2n caracteres, guiones bajos entre paréntesis.
1: []
2: [__]
3: [____]
4: [______]
...
Se garantiza que la entrada tenga al menos una solución. Si hay varios, solo debes dibujar una pared.
No hay restricción de tiempo; usa tanta fuerza bruta como quieras. En teoría, su algoritmo debería funcionar en entradas de cualquier tamaño.
Casos de prueba:
Existen múltiples soluciones, por lo que sus resultados pueden ser diferentes.
>> [1, 1, 2, 2], 2
[][__]
[__][]
>> [1, 1, 1, 2, 2, 2, 2, 3], 2
[__][____][__]
[][__][][__][]
>> [1, 1, 2, 2, 3, 3, 3, 3], 3
[][__][____]
[__][____][]
[____][____]
>> [1, 2, 3, 4, 5, 6, 7, 8, 9], 5
[][______________]
[__][____________]
[________________]
[____][__________]
[______][________]
>> [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], 5
[][__][__]
[__][__][]
[][__][__]
[__][__][]
[][__][__]
n>1
y no me gustó cómo restringía los casos de prueba. Además, aparentemente hay precedentes .Respuestas:
Perl,
166170194Una tarea perfecta para un lenguaje creado por Larry Wall.
Fuerza bruta, pero bastante rápida en los casos de prueba (<1s). Uso:
Ponme a prueba .
fuente
CJam,
94 9282 bytesEsta es la versión de 92 bytes. Sigue la versión de 82 bytes.
Esto divide los ladrillos en todas las formas posibles y toma solo el que es válido. Fuerza bruta bastante por ahora, pero aún ejecuta el último caso de prueba en unos 10 segundos en el intérprete de Java en mi máquina.
Explicacion :
El código se divide en 5 partes:
1) Dada una matriz de longitud
L
, ¿cómo podemos dividirla enH
partes?Después de esto, tenemos todas las formas posibles de dividir nuestra matriz de entrada en capas de ladrillo H.
2) Obtenga todas las permutaciones de la matriz de entrada y luego obtenga todas las particiones para todas las permutaciones
Después de esto, tenemos todos los diseños posibles de los ladrillos de entrada en una
H
pared de ladrillo de capas.3) Filtre solo aquellos diseños cuyas longitudes de ladrillo sean iguales
Después del final de este filtro, todos los diseños restantes serían rectángulos perfectos.
4) Saque el primer diseño de ladrillo que coincida con los criterios de estabilidad
Después de este paso, simplemente tenemos que imprimir el diseño.
5) Imprimir el diseño
Pruébalo en línea aquí
82 bytes
Esto es casi similar a la versión de 92 bytes, excepto que tiene un toque de aleatoriedad. Si ha leído la explicación de la versión de 92 bytes, en la versión de 82 bytes, las partes 3, 4 y 5 son exactamente iguales, mientras que en lugar de repetir todas las permutaciones de las partes 1 y 2, esta versión simplemente genera aleatoriamente una de las permutación a la vez, lo prueba usando las partes 3 y 4, y luego reinicia el proceso si las pruebas de las partes 3 y 4 fallan.
Esto imprime los resultados muy rápidamente para los primeros 3 casos de prueba. El caso de prueba height = 5 todavía tiene que dar una salida en mi computadora.
Explicación de la diferencia.
La idea para esta versión fue dada por randomra (¿Entiendes?)
Prueba este en línea
fuente
Python 2,
680670660 bytesNo sé por qué insisto en tener estos "golfs" súper largos ... pero de todos modos, aquí tienes.
Esto requiere la salida en orden ascendente ordenado, y se llama vía
b(brick_sizes, height)
.Casos de prueba:
La forma en que esto funciona es:
fuente
continue
desde cerca del final. Tampocoreturn(N,N)
necesitará el paréntesis.continue
fue una reliquia de una versión anterior.W
yT
se le pasa un argumento adicional.Haskell, 262 bytes
Ejemplo de uso:
Cómo funciona: la función principal
#
toma una listal
(lista de ladrillos) y un númeroh
(altura) y divide todas las permutacionesl
enh
sublistas en todas las posiciones posibles (a través de la función%
, por ejemplo,2%[1,2,3,4]
->[ [[1],[2,3]] , [[1,2],[3]] , [[1,2,3],[]] ]
). Mantiene aquellos en los que dos elementos consecutivos tienen la misma suma (es decir, la misma longitud en ladrillos) y las listas de subtotales no tienen elementos comunes (es decir, las grietas no se alinean, funcionanv
). Tome la primera lista que se ajuste y construya una cadena de ladrillos.fuente
Python 2,
528,417,393, 381Muy larga, solución de fuerza bruta. Funciona pero eso es todo, el universo puede terminar antes de obtener el resultado para el último caso de prueba.
a es la función principal:
fuente
from itertools import*
y eliminándolaitertools.
de lapermutations
llamada. Además, laif
s al final se puede cambiar aif all(x==w[0] for x in w)and~-f(o):return
... para guardar 13 bytes.f
siempre regresa en la primera iteración? Eso se ve raro. Es un error o una gran oportunidad de golf.t=0
dos vecesr()
; puede convertir esa función enmap(sum,[x[:i] for i in range(len(x))])
una línea (adecuada para lambda-ing si lo desea). El uso de isdisjoint y setsf()
lo reduciría significativamente (f()
actualmente también regresa después de solo una prueba, ya sea que se encuentre un error o no). Personalmente lo reescribiríaf()
comoreturn not all(map(isdisjoint,map(set,map(r,w[:-1])),map(set,map(r,w[1:]))))
o algo similar.JavaScript (ES6) 222
232 265 279 319Aún por jugar al golf.Este encuentra todas las soluciones, genera solo el último encontrado y es bastante rápido.Ejecute el fragmento en Firefox para probar
Desengañado y explicado
fuente
Python 2, método de cuadrícula (290 caracteres)
El método aquí es transponer la cuadrícula y buscar una
[[
o]]
cualquier parte de las columnas. También prueba que todos los ladrillos en los lados izquierdo y derecho de la pared se alinean: lo lindo aquí es probar que todos los elementos de una cadena son iguales:'[[[[[['.strip('[')==''
versión mini de arriba:
Esto probablemente podría hacerse más fácilmente en un lenguaje de manipulación matricial.
... o abuso de expresiones regulares, que nos permite combinar la condición de "bloques alineados en los extremos" con la condición de "sin grietas":
Digamos que el ancho de la pared era w = 6. Las ubicaciones de la subcadena "[..... [" y "] .....]" deben ser exactamente el conjunto {0, w-1, w, 2w-1,2w, 3w-1 ,. ..}. La inexistencia en esos puntos significa que los ladrillos 'linewrap' así:
La existencia NO en esos puntos significa que hay una 'grieta' inestable en la pared:
Por lo tanto, reducimos el problema para establecer la equivalencia, donde los conjuntos en las preguntas son los índices de una coincidencia de expresión regular.
Python, método regexp (304 caracteres):
fuente
x,h=input()
.Matlab (359)
Entrada
un vector de enteros, ejemplo: p ([1 1 2 2 3])
Salida
El esquema del ejemplo del muro:
fuente