Les mosaïques Duodyadic sont des types de blocs de fonction carrés qui prennent deux entrées, une de leur côté supérieur et une de leur côté gauche, et ont deux sorties, une de leur côté droit et une de leur côté inférieur. Chacune de leurs sorties est une fonction distincte de leurs deux entrées.
Par exemple, si #
représente une mosaïque générique, la sortie droite R
est une fonction f
des entrées T
et L
, et la sortie du bas B
est une autre fonction g
de T
et L
:
T
L#R R = f(T, L)
B B = g(T, L)
(Les tuiles sont appelées "duo" puisqu'il y a deux fonctions et "dyadiques" puisque les deux fonctions ont deux arguments .)
Les tuiles peuvent ensuite être composées ensemble sur une grille, les sorties d'une tuile allant directement aux entrées des tuiles qu'elle voisine. Ici par exemple, la sortie droite de gauche #
va dans l'entrée gauche de droite #
:
AB D = f(f(A, C), B)
C##D E = g(A, C)
EF F = g(f(A, C), B)
Vous pouvez imaginer qu'avec un ensemble de mosaïques duodyadiques, chacune avec une fonctionnalité spécifique, des compositions complexes (et potentiellement utiles) pourraient être créées.
Dans ce défi, nous ne nous intéresserons qu'au jeu traditionnel de dix mosaïques duodyadiques basées sur la logique , dans lesquelles toutes les entrées et sorties sont des nombres binaires à un bit (zéros ou uns). Nous utiliserons un caractère ASCII distinct pour désigner chaque type de mosaïque.
Les caractères de mosaïque et leurs relations d'entrée-sortie sont les suivants:
( T
est pour l'entrée supérieure, L
pour l'entrée gauche, R
pour la sortie droite, B
pour la sortie inférieure.)
- Zéro:
0
ou(espace) →
R = 0
,B = 0
- Un:
1
→R = 1
,B = 1
- Croix:
+
→R = L
,B = T
- Miroir:
\
→R = T
,B = L
- Haut seulement:
U
→R = T
,B = T
- Gauche seulement:
)
→R = L
,B = L
- Non:
!
→R = not L
,B = not T
- Et:
&
→R = L and T
,B = L and T
- Ou:
|
→R = L or T
,B = L or T
- Xor:
^
→R = L xor T
,B = L xor T
Défi
Ecrivez un programme ou une fonction prenant une grille rectangulaire de caractères 0 1+\U)!&|^
qui représente un "circuit" réalisé à l'aide des dix mosaïques duodyadiques à base logique. Vous devez également prendre en compte deux chaînes de 0
'et 1
'; un sera la colonne de gauche et un la première ligne. Votre programme / fonction doit imprimer / retourner la ligne de sortie inférieure et la colonne de sortie droite (également dans 0
's et 1
' s).
Par exemple, dans cette grille
+++
+++
toutes les entrées passent directement à travers la grille vers les sorties
ABC
D+++D
E+++E
ABC
donc une entrée de 010
/ 01
aurait la sortie 010
/ 01
:
010
0+++0
1+++1
010
Le résultat exact de votre programme serait [bottom output row]\n[right output column]
ou [bottom output row]/[right output column]
:
010
01
ou
010/01
Si vous avez écrit une fonction, vous pouvez renvoyer les deux chaînes dans un tuple ou une liste (ou encore les imprimer).
Détails
- Prenez les trois entrées comme des chaînes de manière raisonnable (de préférence dans la grille de commande, la ligne du haut, la colonne de gauche): ligne de commande, fichier texte, sdtin, fonction arg.
- Vous pouvez supposer que la longueur des lignes et des colonnes en entrée correspondra aux dimensions de la grille et ne contiendra que
0
les s et1
'. - Votre grille doit utiliser les caractères appropriés (
0 1+\U)!&|^
). N'oubliez pas cela0
etsignifie la même chose.
Cas de test
(Lire I / O sous la forme top
/ left
→ bottom
/ right
.)
Nand:
&!
00
/ 0
→ 01
/ 1
00
/ 1
→ 01
/ 1
10
/ 0
→ → 01
/ 1
10
/ 1
→ 11
/0
Tous les uns:
1111
1\+\
1+\+
1\+\
Toute entrée doit avoir pour résultat 1111
/ 1111
.
Xor from Nand: (notez la colonne d'espaces finaux)
\)+\
U&!&
+! !
\&!&
!
00000
/ 00000
→ 00000
/ 00000
00000
/ 10000
→ 00010
/ 00000
10000
/ 00000
→ → 00010
/ 00000
10000
/ 10000
→ 00000
/00000
Zig zag:
+++\00000000
000\!!!!\000
00000000\+++
Le premier bit de l'entrée de gauche devient le dernier bit de la sortie de droite. Tout le reste est 0
.
000000000000
/ 000
→ 000000000000
/ 000
000000000000
/ 100
→ 000000000000
/001
Propagation:
)))
UUU
U+U
U+U
UUU
Le premier bit de l'entrée de gauche va à toutes les sorties.
000
/ 00000
→ 000
/ 00000
000
/ 10000
→ 111
/11111
Voici une liste de tous les cas de test de grille 1 × 1.
Notation
La soumission la plus courte en octets l' emporte.
Bonus: Quels "circuits" cool pouvez-vous faire?
PS Ne vous embêtez pas sur Google "tuiles duodyadiques". Je les ai inventées hier; D
Si vous souhaitez discuter de l’extension de cette idée dans un langage de programmation à part entière, présentez-vous à cette salle de discussion .