Unten sehen Sie ein (schematisches) digitales Zeitdiagramm für das XNOR- Logikgatter.

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

Ihr Ziel ist es, es genau wie abgebildet zu reproduzieren.

Regeln:

• Sie können es entweder drucken oder eine mehrzeilige Zeichenfolge zurückgeben.

• Eine beliebige Anzahl von Traling- und / oder führenden Zeilenumbrüchen ist zulässig.

• Nachgestellte (aber nicht führende!) Leerzeichen sind zulässig.

• Wenn Sie die erweiterten ASCII-Boxzeichen nicht verwenden können, können Sie die Unicode-Entsprechungen durch diese ersetzen (ohne Byte-Strafe).

Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.

Binäre Darstellung

Die binäre Darstellung des obigen Diagramms lautet wie folgt:

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

Beispielausgabe

Randnotiz

Während ich an dieser Frage arbeite, habe ich zwei verschiedene Bash-Lösungen implementiert, eine ist 122 Zeichen / Bytes lang (wie oben dargestellt) und eine andere ist genau 100 Bytes lang.

Ich habe nicht vor, sie zu veröffentlichen (da ich normalerweise keine Antworten auf meine eigenen Fragen veröffentliche), daher dient dies nur als Referenz.

Ich glaube auch, dass mindestens einige Sub-100-Byte-Lösungen möglich sind.

05AB1E , 101 Bytes + 5 UTF-8 Bytes = 116 Gesamtbytes = 106 Bytes

(LEGACY 05AB1E VERSION, NICHT MEHR AUF TIO)

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

Probieren Sie es online aus!

Die Komprimierung:

•=(Í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.

Die Umwandlung:

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.

Verwenden der CP-1252- Codierung.

Bubblegum , 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.

Probieren Sie es online aus!

Verwendet Box-Zeichen aus dem alternativen Zeichensatz VT100, die TIO nicht demonstrieren kann. Führen Sie die besten Ergebnisse in einem UNIX-Terminal aus. Mein Terminal konvertiert das ACS beim Kopieren und Einfügen in UTF-8, sodass Sie den Effekt hier sehen können.

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

Die Herausforderung bestand nicht darin, das Terminal wieder aus dem ACS-Modus zu entfernen, bevor wir zur Shell zurückkehren. Viel Glück damit.

Ruby, 113 Bytes

Zählen gedruckter Symbole als ein Byte, wie von der Herausforderung autorisiert (Ich war überrascht zu entdecken, dass es sich tatsächlich um 3 Bytes handelt.)

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 Ausgabezeilen eignen sich für eine Codierung von 6 Bit pro Zeichen der magischen Zeichenfolge. Aber die magischen Zeichenfolgen codieren tatsächlich für jeden Übergang folgendermaßen:

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)

Dies wird dekodiert, um die 2 Zeichen zu finden, die für jeden Übergang gedruckt werden müssen (das erste ist entweder ein Leerzeichen oder eine horizontale Linie). Die 8-Zeichen-Zeichenfolgen für die obere und untere Zeile überlappen sich: Die letzten beiden Zeichen für die obere Zeile 11sind zwei horizontale Linien, die mit den Anforderungen für die ersten beiden Zeichen der unteren Zeile übereinstimmen 00. Die 8 Zeichen für die untere Zeile werden umbrochen: Es handelt sich um die letzten 6 und ersten 2 Zeichen der Symbolzeichenfolge.

Ungolfed Code

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
}

PowerShell, 255 Zeichen, 265 Byte (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

Dies funktioniert auf meinem Computer, scheint aber die Bytes auf TIO nicht richtig zu analysieren ...

Dies $aist eine mehrzeilige Zeichenfolge, die mit Zahlen und Leerzeichen gefüllt ist und dann Schleifen enthält 0..4|%{...}. Bei jeder Iteration geben wir -replacedie entsprechende Ziffer $_mit dem entsprechenden Zeichen ein '┌─┐┘└'[$_]und speichern sie wieder in $a. Dann verlassen wir einfach $adie Pipeline und die Ausgabe ist implizit.

JavaScript (ES6), 163 158 154 Bytes

NB: Zählen von UTF-8-Zeichen als Bytes, wie von der Herausforderung autorisiert.

_=>[..." 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`
`

Demo

let f =

_=>[..." 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`
`

console.log(f())

4 Bytes dank Neil gespeichert

C 213 205 Bytes

Zur Abwechslung ist die C-Programmgröße bei dieser Herausforderung im Vergleich zu anderen Sprachen nicht ganz lächerlich.

#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, definieren erweitert und kommentiert:

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');
}

Hinweis: Die C- Zeichenfolge darf keine Unicode-Zeichen enthalten. Alle anzeigbaren Zeichen müssen einfache alte 8-Bit-Zeichen sein (sie können jedoch im erweiterten Bereich ausgewählt werden). Grundsätzlich hängt die Gültigkeit der Ausgabe von Ihrer Codepage ab.

tcl, 221 Zeichen, 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└────"}

kann ausgeführt werden unter: http://rextester.com/live/VVQU99270