Dibuje el diagrama de temporización digital XNOR

12

A continuación se muestra un diagrama de temporización digital (esquemático) , para la puerta lógica XNOR .

    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐       
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐ 
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐   
X ──┘     └───┘ └───┘ └───┘   └────

Su objetivo es reproducirlo exactamente como se muestra.

Reglas:

  • Puede imprimirlo o devolver una cadena de varias líneas;

  • Se permite un número arbitrario de líneas nuevas y / o iniciales nuevas;

  • Se permite el espacio en blanco al final (¡pero no al inicio!);

  • Si no puede usar los caracteres de dibujo de cuadro ASCII extendidos, puede sustituirlos por los equivalentes Unicode (sin penalización de byte).

Este es el por lo que gana la respuesta más corta en bytes.

Representacion Binaria

Para su comodidad, la representación binaria del diagrama anterior es la siguiente:

INP A=0101011101010110
INP B=1101101011100101
  ___
X=A⊕B=0111001001001100

Salida de muestra

ingrese la descripción de la imagen aquí

Nota al margen

Mientras trabajaba en esta pregunta, he implementado dos soluciones bash diferentes para ella, una tiene 122 caracteres / bytes de longitud (como se muestra arriba) y otra tiene exactamente 100 bytes de longitud.

No tengo planes de publicarlos (ya que normalmente no publico respuestas a mis propias preguntas), así que eso es solo para referencia.

También creo que al menos algunas soluciones de menos de 100 bytes son posibles.

zepelín
fuente
2
Esa es una puerta XNOR, ¿no es así?
clismique
@ Qwerp-Derp Sí, tal vez lo sea :)
zepelín
2
En lugar de sugerir (0 == 0) == 0, ¿B o X no comienzan y terminan en 1?
Roman Czyborra
@Roman Czyborra No estoy seguro de entender la idea, ¿podría explicarlo un poco más?
zeppelin
1
@zeppelin Mire a la derecha al comienzo del patrón: los primeros dos píxeles. A, B y X están todos bajos allí. Lo mismo es cierto al final. ¿Por qué es este el caso? (Creo que esta es la pregunta de Roman).
isaacg

Respuestas:

5

05AB1E , 101 bytes + 5 bytes UTF-8 = 116 bytes totales = 106 bytes

(LEGADO VERSIÓN 05AB1E, YA NO EN TIO)

•=(Ín§Àoà`œ¯_eè8y1ÜŸ,Ú®:¹$:,õKA–x[Âì0ãXÔfz}y×ì¹Ï½uEÜ5äÀTë@ºQÈ™ñó:ò…Eä•6B"102345"" ┌─┐└┘"‡6ävyN" A B X"èì}»

Pruébalo en línea!

La compresión:

•=(Ín§Àoà`œ¯_eè8y1ÜŸ,Ú®:¹$:,õKA–x[Âì0ãXÔfz}y×ì¹Ï½uEÜ5äÀTë@ºQÈ™ñó:ò…Eä• 
# Pattern, converted to base-6 in base-6=214.

111023102310222223102310231022231112251425142511111425142514251114221022231022231023102222231110231023151114251114251425111114222514251411102222231110231110231110222311111225111114222514222514222511142222
# Actual base-6 pattern.

1110231023102222231023102310222311
1225142514251111142514251425111422
1022231022231023102222231110231023
1511142511142514251111142225142514
1110222223111023111023111022231111
1225111114222514222514222511142222
#Pattern split into chunks of 34.

   ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐  
 ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
 ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
 ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
   ┌─────┐   ┌─┐   ┌─┐   ┌───┐    
 ──┘     └───┘ └───┘ └───┘   └────
# Pattern after replacing 0,1,2,3,4,5 with appropriate blocks.

La conversión:

6B                                   # Convert back to base-6.
  "102345"" ┌─┐└┘"‡                  # Replace numbers with appropriate counterparts.
                   6ä                # Split into 6 equal parts (the rows).
                     vy           }  # For each row (chunk).
                       N" A B X"èì   # Push label at index [i], prepend to line.
                                   » # Print all separated by newlines.

Usando la codificación CP-1252 .

Urna de pulpo mágico
fuente
Se le permite contar cada carácter de dibujo de caja Unicode como solo 1 byte, a los efectos de este desafío (consulte "Reglas"), por lo que su respuesta tiene 106 bytes de largo de acuerdo con esto. La razón es que estos caracteres unicode se pueden reemplazar con caracteres de 1 byte, por ejemplo, en CP437 o IBM850, pero pueden ser más difíciles de mostrar.
zepelín
Estoy de acuerdo con zeppelin. Dada la concesión dada en las reglas, esto sería 106 bytes.
Level River St el
Método alternativo que solo funciona en la nueva versión de 05AB1E usando el incorporado Åв(también he actualizado la sugerencia del generador de arte ASCII con esto): 106 bytes
Kevin Cruijssen
4

Chicle , 76 bytes

00000000: 92d6 3000 5431 1505 1403 50e8 4e0a aafc  ..0.T1....P.N...
00000010: 9f62 15e6 a3ff 61fa dc05 e06d 8b66 cbc7  .b....a....m.f..
00000020: e6b6 cff8 519a b85a 3eb6 b67d 95c0 0feb  ....Q..Z>..}....
00000030: 35b5 521d 7f7e 68af a916 fa20 d999 564d  5.R..~h.... ..VM
00000040: 1f03 d559 59ed 265c f243 42be            ...YY.&\.CB.

Pruébalo en línea!

Utiliza caracteres de dibujo de recuadro del conjunto de caracteres alternativo VT100, que TIO no puede demostrar. Ejecutar en un terminal UNIX para obtener mejores resultados. Mi terminal convierte el ACS a UTF-8 en copiar y pegar, para que pueda ver el efecto aquí.

anders@change-mode:/tmp$ bubblegum xnor.zlib
    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐
X ──┘     └───┘ └───┘ └───┘   └────
▒┼␍␊⎼⎽@␌␤▒┼±␊-└⎺␍␊:/├└⎻$ 

Pues bien, el reto no dijo que necesitamos para tomar la parte posterior del terminal a cabo de modo ACS antes de regresar a la cáscara. Buena suerte con eso.

Anders Kaseorg
fuente
3

Ruby, 113 bytes

contando los símbolos impresos como un byte según lo autorizado por el desafío (me sorprendió descubrir que en realidad son 3 bytes).

6.times{|i|s=' A B X'[i]
'D]zunIWkF]nIRukFH'.bytes{|b|s+='   ┌─┐───┘ └'[(b*2>>i/2*2&6)-i%2*6,2]}
s[1]=' '
puts s}

6 líneas de salida se prestan a una codificación de 6 bits por cada carácter de la cadena mágica. Pero los caracteres de la cadena mágica en realidad codifican para cada transición así:

least significant bit 0 New value for A  
                      1 Current value for A
                      2 New value for B
                      3 Current value for B
                      4 New value for X
                      5 Current value for X
most significant bit  6 Always 1 (to remain in printable range)

Esto se decodifica para encontrar los 2 caracteres que deben imprimirse para cada transición (el primero de los cuales es espacio o una línea horizontal). Las cadenas de 8 caracteres para las filas superior e inferior se superponen: los dos últimos caracteres para la fila superior 11son dos líneas horizontales, que coinciden con lo que se necesita para los dos primeros caracteres de la fila inferior 00. Los 8 caracteres para la fila inferior se envuelven: son los últimos 6 y los primeros 2 caracteres de la cadena de símbolos.

Código sin golf

6.times{|i|s=' A B X'[i]               #iterate through 6 lines of output. Set s to the 1st character.
  'D]zunIWkF]nIRukFH'.bytes{|b|        #for each byte in the magic string
     s+='   ┌─┐───┘ └'[(b*2>>i/2*2&6)- #add 2 bytes to s, index 0,2,4, or 6 of the symbol string depending on relevant 2 bits of the magic string.
     i%2*6,2]                          #if the second (odd) row of a particular graph, modify index to -6,-4,-2, or 0 
  }                                    #(ruby indices wrap around. mystring[-1] is the last character of the string.)
  s[1]=' '                             #replace intitial ─ of the curve with space to be consistent with question
  puts s                               #output line
}
Level River St
fuente
Esto es en realidad 129 bytes, 113 caracteres.
Magic Octopus Urn
1
@carusocomputing Veo que has hecho el mismo comentario sobre la mayoría de las respuestas aquí. Consulte la primera línea de mi respuesta y la regla 4 del OP: If you can not use the extended ASCII box-drawing characters, you may substitute them for the unicode equivalents (at no byte penalty)Todos hemos calificado nuestras respuestas de acuerdo con las reglas.
Level River St el
2

PowerShell, 255 caracteres, 265 bytes (UTF-8)

$a='    012 012 0111112 012 012 01112
A 113 413 413     413 413 413   411
  01112 01112 012 0111112   012 012
B 3   413   413 413     41113 413 4
    0111112   012   012   01112
X 113     41113 41113 41113   41111'
0..4|%{$a=$a-replace$_,('┌─┐┘└'[$_])};$a

Esto funciona en mi computadora, pero no parece analizar los bytes correctamente en TIO ...

captura de pantalla

Esto se convierte $aen una cadena de varias líneas llena de números y espacios, luego bucles 0..4|%{...}. Cada iteración, tenemos -replaceel dígito apropiado $_con el carácter apropiado '┌─┐┘└'[$_]y lo almacenamos nuevamente $a. Luego, simplemente dejamos $aen la tubería y la salida es implícita.

AdmBorkBork
fuente
Se le permite contar los caracteres Unicode como bytes individuales, de acuerdo con el desafío
FlipTack
2

JavaScript (ES6), 163 158 154 bytes

NB: contar los caracteres UTF-8 como bytes, según lo autorizado por el desafío.

_=>[..." A B X"].map((c,i)=>c+" "+[...Array(33)].map((_,j)=>j%2?" ─"[p^i&1]:" ┐┌─└┘ "[p+(p=[27370,42843,12878][i>>1]>>j/2&1)*2+i%2*3]).join``,p=0).join`
`

Manifestación

Guardado 4 bytes gracias a Neil

Arnauld
fuente
j%2?" ─"[p^i&1]:" ┐┌─└┘ "[p+(p=[27370,42843,12878][i>>1]>>j/2&1)*2+i%2*3]ahorra 3 bytes.
Neil
Ah, y cambia de 17 a 33 también.
Neil
Una vez más, 152 caracteres, 164 bytes.
Magic Octopus Urn
2

C, 213205 bytes

Para variar, el tamaño del programa C, en este desafío, no es completamente ridículo en comparación con otros lenguajes.

#define X(a) u[i]=C[a],l[i++]=C[(a)+4]
p(n,c){char u[34],l[34],*C=" ┐┌──└┘ ",i=0;while(i<34)X(n&3),n>>=1,X((n&1)*3);printf("  %.33s\n%c %.33s\n",u,c,l);}main(){p(0xD5D4,'A');p(0x14EB6,'B');p(0x649C,'X');}

Ungolfed, define expandido y comentado:

p(n,c){
    // u is the upper line of the graph, l the lower line
    char u[34],l[34],*C=" ┐┌──└┘ ",i=0;
    while(i<34)
        u[i]=C[n&3],            // using the two LSBs to set the transition char depending on the current and next state
        l[i++]=C[(n&3)+4],      // do for both upper and lower lines
        n>>=1,                  // shift bits right to go to next state
        u[i]=C[(n&1)*3],        // using only the LSB to set the "steady" char depending on current state only
        l[i++]=C[((n&1)*3)+4];  // do for both upper and lower lines
    printf("  %.33s\n%c %.33s\n",u,c,l);
}
main() {
    // Call p for each graph
    // Constants are chosen so the display is consistent with the request.
    // Each bit represents a state, but the order is reversed
    // (leftmost is put on lowest significant bit, after a 0)
    p(0xD5D4,'A');p(0x14EB6,'B');p(0x649C,'X');
}

Nota: la cadena C no debe contener caracteres unicode. Todos los caracteres que se pueden mostrar deben ser caracteres viejos de 8 bits (pero se pueden elegir en el rango extendido). Básicamente, la validez de la salida depende de su página de códigos.

tenue fe perdida en SE
fuente
1

tcl, 221 caracteres, 299 bytes

lmap {b _ n u A V} {"   " ┌─────┐ ┌───┐ └───┘ ┌─┐ └─┘} {puts "[set S \ $b][set m $A\ $A] $_ $m $n
A ──┘ [set w $V\ $V][set s \ $S]$w $V$b└──
  $n $n $A $_$b$m
B ┘$b$V$b$w$s$u $V └
$S$_$b$A$b$A$b$n
X ──┘$s$u $u $u$b└────"}

se puede ejecutar en: http://rextester.com/live/VVQU99270

sergiol
fuente
228 caracteres, sin embargo, son 306 bytes.
Magic Octopus Urn
@carusocomputing: ¿Qué herramienta en línea utiliza para contar bytes en lugar de caracteres? Tks de antemano.
sergiol
mothereff.in/byte-counter
Urna de pulpo mágico