Escriba un programa o una función en cualquier lenguaje de programación que tome una entrada / argumento hexadecimal de 6 dígitos. La entrada / argumento puede ser de 6 valores o una cadena de 6 caracteres.

Su programa debe generar un bloque rectangular de caracteres de exactamente 8 caracteres de ancho que contenga solo los hexadecimales suministrados combinados con espacios (+ salto de línea). El bloque rectangular es una combinación de formas de bloque más pequeñas, una para cada uno de los 6 valores suministrados.

A continuación se muestran 2 entradas de muestra demostrativas y salidas válidas de muestra:

Entrada de muestra :

"464fa6" or [4, 6, 4, 15, 10, 6]

Una salida de solución válida :

44 66 ff
44 66 ff
   66 ff
aa     f
aaa ffff
aa  ffff
aaa     
    6 44
66666 44

Entrada de muestra :

"35bf12"

Una salida de solución válida :

55555 22

bbbbbbbb
b b b   
      33
fffff  3
ff  ff  
ffffff 1

Reglas:

1. La salida debe ser de forma rectangular.

2. La salida puede ser de cualquier altura vertical, pero debe tener exactamente 8 caracteres de ancho

3. Los "bloques internos", referidos como "forma de bloque", no pueden conectarse a ninguna otra forma de bloque, las formas de bloque deben estar separadas por una pared de espacios en blanco de exactamente 1 carácter de ancho horizontal, vertical y diagonal.

4. El muro de espacios en blanco no puede correr paralelo a los bordes exteriores, solo pueden existir bordes de pared de 1 carácter de ancho en los bordes de salida. No debería existir ningún espacio vinculado en ninguna parte del borde rectangular exterior de la salida.

5. El ancho de la pared de espacios en blanco no debe exceder en ningún momento 1 carácter.

6. Las formas del bloque interno deben ser uniformes con el área de los caracteres x, donde x es el valor hexadecimal proporcionado y la forma debe consistir en el carácter x donde x es el representante del carácter hexadecimal.

7. Las formas del bloque interno pueden ser de cualquier forma siempre que todos los caracteres de la forma se conecten vertical u horizontalmente, y no validen las reglas para la pared de espacios en blanco.

8. Las 6 formas de bloque se pueden colocar en cualquier "orden" interno dentro del rectángulo de salida.

9. Rango de entrada válido: 1 ... 15 ("1" ... "f") para cada forma. La entrada a su programa no debe contener otra información que no sean los 6 números hexadecimales, y la entrada no debe clasificarse de ninguna otra manera que no sea en las muestras antes de que se suministre a su programa / función. Díganos qué formato de entrada usa su solución (la entrada no puede contener otra información que los valores hexadecimales).

10. Una forma de bloque interno puede ser hueca. El agujero debe tener caracteres de espacio en blanco que cuenten como una pared de espacios en blanco, lo que significa que el agujero en forma de bloque interior hueco no puede tener más de 1 carácter de ancho.

Tres ejemplos de formas huecas válidas:

aaa
a aaa
aaa

999
9 9
999
9

ffffff
f   ff
ffffff

Un ejemplo de una forma hueca no válida:

ffffff
f   f
f   f
fffff

Supongo que no es posible "resolver" todas las combinaciones de entrada de acuerdo con las reglas anteriores, por lo tanto, enumero 10 entradas de muestra que su programa debería poder "resolver" (todo se verifica como solucionable):

 1. 464fa6 (same as the first sample)
 2. 35bf12 (second example input seen above)
 3. 111126
 4. ff7fff
 5. 565656
 6. abcdef
 7. 1357bd
 8. 8c6a42
 9. ab7845
10. 349a67

Su programa debe poder resolver cualquiera de las 10 entradas de muestra en un tiempo razonable. traduzca el tiempo razonable dentro de 1 hora en una computadora de escritorio estándar. Diga como: 3 Ghz Dual core, 4GB de memoria como referencia.

Este es el código de golf, la solución más corta gana. La solución puede ser un programa totalmente funcional o una función

Haskell, 156

Bueno, este estira las reglas un poco. No tengo paredes de espacio en blanco, excepto los saltos de línea, por lo tanto, todas mis paredes tienen una longitud de 1.

import Data.List
r=replicate
main=getLine>>=putStrLn.concatMap(\b->unlines$s(head$elemIndices b"0123456789abcdef")b)
s n c|n<9=[r n c,""]|True=r 8 c:s(n-8)c

salida para 464fa6:

4444

666666

4444

ffffffff
fffffff

aaaaaaaa
aa

666666

BrainF * ck - 134 (nueva línea intr

>>+[++++++++++>,----------]>++++++[<+++++>-]<++[<]<++++++[>+++++<-]>++>-
>..<<.>>>..<<<.>>>>..<<<.<........>.>>>>..>>>.<<..>>.<..[<]>>.

Creo que esta es la respuesta simplista.

Entrada tomada a través de 6 caracteres hexadecimales a stdin, seguida de una nueva línea para enviar.

EDITAR: Esto falla debido a la regla 6, que no me había dado cuenta hasta ahora: /