Écrivez un programme ou une fonction dans n'importe quel langage de programmation qui prend une entrée / un argument hexadécimal à 6 chiffres. L'entrée / l'argument peut être 6 valeurs ou une chaîne de 6 caractères.

Votre programme doit produire un bloc rectangulaire de 8 caractères de largeur contenant uniquement les hexadécimaux fournis combinés avec des espaces (+ saut de ligne). Le bloc rectangulaire est une combinaison de formes de blocs plus petites, une pour chacune des 6 valeurs fournies.

Voici 2 exemples d'entrées de démonstration et des échantillons de sorties valides:

Exemple d' entrée :

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

Une sortie de solution valide :

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

Exemple d' entrée :

"35bf12"

Une sortie de solution valide :

55555 22

bbbbbbbb
b b b   
      33
fffff  3
ff  ff  
ffffff 1

Règles:

1. La sortie doit être de forme rectangulaire

2. La sortie peut avoir n'importe quelle hauteur verticale, mais doit avoir exactement 8 caractères de large

3. Les "blocs intérieurs", appelés "formes de bloc", ne peuvent se connecter à aucune autre forme de bloc, les formes de bloc doivent être séparées par un mur d'espaces vides d'une largeur exacte de 1 caractère horizontalement, verticalement et en diagonale.

4. Le mur d'espaces vides ne peut pas être parallèle aux bords extérieurs, il ne peut exister que 1 bord de mur de large caractère aux bords de sortie. Il ne doit exister aucun espace lié sur le bord rectangle le plus à l'extérieur de la sortie.

5. La largeur du mur d'espaces vierges ne doit à aucun moment dépasser 1 caractère.

6. Les formes des blocs internes doivent être uniformes avec la zone de x caractères, où x est la valeur hexadécimale fournie et la forme doit être constituée du caractère x où x est le caractère hexadécimal représentatif.

7. Les formes de bloc internes peuvent avoir n'importe quelle forme tant que tous les caractères de forme se connectent verticalement ou horizontalement, et ne valident pas les règles pour le mur d'espaces vides.

8. Les 6 formes de bloc peuvent être placées dans n'importe quel "ordre" interne à l'intérieur du rectangle sorti.

9. Plage de saisie valide: 1 ... 15 ("1" ... "f") pour chaque forme. L'entrée de votre programme ne doit contenir aucune autre information que les 6 nombres hexadécimaux, et l'entrée ne doit pas être triée autrement que dans les échantillons avant d'être fournie à votre programme / fonction. Dites-nous quel format d'entrée votre solution utilise (l'entrée ne peut pas contenir d'autres informations que les valeurs hexadécimales).

10. Une forme de bloc interne peut être creuse. Le trou doit être composé de caractères d'espace vide qui comptent comme un mur d'espaces vides, ce qui signifie que le trou en forme de bloc interne creux ne peut pas avoir plus de 1 caractère de large.

Trois exemples de formes creuses valides:

aaa
a aaa
aaa

999
9 9
999
9

ffffff
f   ff
ffffff

Un exemple d'une forme creuse invalide:

ffffff
f   f
f   f
fffff

Je suppose que toutes les combinaisons d'entrées ne sont pas possibles à "résoudre" selon les règles ci-dessus, je énumère donc 10 exemples d'entrées que votre programme devrait être en mesure de "résoudre" (tout est vérifié résoluble):

 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

Votre programme devrait être en mesure de résoudre l'un des 10 échantillons d'entrée en un temps raisonnable. traduire le temps résonable en moins d'une heure sur un ordinateur de bureau standard. Dites comme: 3 Ghz Dual core, 4 Go de mémoire pour référence.

C'est le golf de code, la solution la plus courte l'emporte. La solution peut être un programme entièrement fonctionnel ou une fonction

Haskell, 156

Eh bien, celui-ci étire un peu les règles. Je n'ai pas de murs d'espaces vides à l'exception des sauts de ligne, donc tous mes murs ont une longueur 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

sortie pour 464fa6:

4444

666666

4444

ffffffff
fffffff

aaaaaaaa
aa

666666

BrainF * ck - 134 (newline intr

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

Je pense que c'est la réponse simpliste

Entrée prise via 6 caractères hexadécimaux vers stdin, suivie d'une nouvelle ligne à soumettre.

EDIT: Cela échoue en raison de la règle 6, que je n'avais pas pleinement réalisé jusqu'à présent: /