Scrivi un programma o una funzione in qualsiasi linguaggio di programmazione che accetta un input / argomento esadecimale a 6 cifre. L'input / argomento può essere di 6 valori o una stringa di 6 caratteri.

Il tuo programma dovrebbe generare un blocco rettangolare di 8 caratteri di esattamente 8 caratteri contenente solo gli esadecimali forniti combinati con gli spazi (+ avanzamento riga). Il blocco rettangolare è una combinazione di forme di blocco più piccole, una per ciascuno dei 6 valori forniti.

Di seguito sono riportati 2 input di esempio dimostrativi e output di esempio validi:

Input di esempio :

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

Un risultato soluzione valido :

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

Input di esempio :

"35bf12"

Un risultato soluzione valido :

55555 22

bbbbbbbb
b b b   
      33
fffff  3
ff  ff  
ffffff 1

Regole:

1. L'output deve essere di forma rettangolare

2. L'output può avere qualsiasi altezza verticale, ma deve avere esattamente 8 caratteri di larghezza

3. I "blocchi interni", indicati come "forme di blocco", non possono collegarsi a nessun'altra forma di blocco, le forme di blocco devono essere separate da una parete di spazi vuoti esattamente 1 carattere largo orizzontalmente, verticalmente e diagonalmente.

4. La parete degli spazi vuoti non può essere parallela ai bordi esterni, ai bordi di uscita può esistere solo bordi di parete larghi 1 carattere. Non dovrebbero esistere spazi collegati ovunque sul bordo del rettangolo più esterno sull'output.

5. La larghezza del muro degli spazi vuoti non deve in nessun caso superare 1 carattere.

6. Le forme del blocco interno devono essere uniformi con l'area di caratteri x, dove x è il valore esadecimale fornito e la forma deve essere costituita dal carattere x dove x è il carattere esadecimale rappresentativo.

7. Le forme del blocco interno possono essere di qualsiasi forma purché tutti i caratteri della forma si connettano verticalmente o orizzontalmente e non valuti le regole per il muro degli spazi vuoti.

8. Le 6 forme di blocco possono essere posizionate in qualsiasi "ordine" interno all'interno del rettangolo emesso.

9. Intervallo di input valido: 1 ... 15 ("1" ... "f") per ogni forma. L'input per il programma non deve contenere altre informazioni oltre ai 6 numeri esadecimali e l'input non deve essere ordinato in modo diverso rispetto ai campioni prima di essere fornito al programma / funzione. Indica quale formato di input utilizza la tua soluzione (l'input non può contenere altre informazioni oltre ai valori esadecimali).

10. Una forma di blocco interno può essere vuota. Il buco dovrebbe essere composto da caratteri di spazio vuoto che conta come un muro di spazi vuoti, il che significa che il buco in una forma di blocco interno vuoto non può essere largo più di 1 carattere.

Tre esempi di forme vuote valide:

aaa
a aaa
aaa

999
9 9
999
9

ffffff
f   ff
ffffff

Un esempio di una forma vuota non valida:

ffffff
f   f
f   f
fffff

Presumo che non sia possibile "risolvere" tutte le combinazioni di input in base alle regole precedenti, quindi elencherò 10 input di esempio che il vostro programma dovrebbe essere in grado di "risolvere" (tutto è verificabile risolvibile):

 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

Il tuo programma dovrebbe essere in grado di risolvere uno qualsiasi dei 10 input di esempio in tempo resonable. tradurre il tempo di risonanza entro 1 ora su un computer desktop standard. Di 'come: 3 Ghz Dual core, 4 GB di memoria per riferimento.

Questo è il golf del codice, vince la soluzione più breve. La soluzione può essere un programma completamente funzionante o una funzione

Haskell, 156

Bene, questo allunga un po 'le regole. Non ho pareti vuote tranne le interruzioni di linea, quindi tutte le mie pareti hanno una lunghezza di 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

uscita per 464fa6:

4444

666666

4444

ffffffff
fffffff

aaaaaaaa
aa

666666

BrainF * ck - 134 (newline intr

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

Penso che questa sia la risposta più semplice

Input preso tramite 6 caratteri esadecimali su stdin, seguito da una nuova riga da inviare.

EDIT: Questo non riesce a causa della regola 6, che non avevo realizzato fino ad ora: /