Dưới đây là sơ đồ thời gian kỹ thuật số (sơ đồ) cho cổng logic XNOR .

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

Mục tiêu của bạn là tái tạo nó chính xác như mô tả.

Quy tắc:

• Bạn có thể in nó hoặc trả về một chuỗi nhiều dòng;

• Số lượng tùy ý của việc truy tìm và / hoặc các dòng mới hàng đầu được cho phép;

• Trailing (nhưng không dẫn đầu!) Khoảng trắng được cho phép;

• Nếu bạn không thể sử dụng các ký tự vẽ hộp ASCII mở rộng, bạn có thể thay thế chúng cho các tương đương unicode (không bị phạt byte).

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Đại diện nhị phân

Để thuận tiện cho bạn, biểu diễn nhị phân của sơ đồ trên như sau:

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

Đầu ra mẫu

Sidenote

Khi giải quyết câu hỏi này, tôi đã triển khai hai giải pháp bash khác nhau cho nó, một giải pháp dài 122 ký tự / byte (như mô tả ở trên) và một giải pháp khác dài chính xác 100 byte.

Tôi không có kế hoạch đăng chúng (vì tôi thường không đăng câu trả lời cho câu hỏi của riêng mình), vì vậy đó chỉ là để tham khảo.

Tôi cũng tin rằng ít nhất một số giải pháp phụ 100 byte là có thể.

05AB1E , 101 byte + 5 UTF-8 byte = 116 Tổng số byte = 106 byte

(PHIÊN BẢN LEGACY 05AB1E, KHÔNG DỄ DÀNG TRÊN TIO)

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

Hãy thử trực tuyến!

Việc né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.

Việc chuyển đổi:

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.

Sử dụng mã hóa CP-1252 .

Bong bóng , 76 byte

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.

Hãy thử trực tuyến!

Sử dụng các ký tự vẽ hộp từ bộ ký tự thay thế VT100, mà TIO không thể chứng minh. Chạy trong một thiết bị đầu cuối UNIX để có kết quả tốt nhất. Thiết bị đầu cuối của tôi chuyển đổi ACS thành UTF-8 khi sao chép và dán, do đó bạn có thể thấy hiệu ứng ở đây.

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

Chà, thách thức không nói rằng chúng ta cần rút thiết bị đầu cuối ra khỏi chế độ ACS trước khi quay trở lại vỏ. Chúc may mắn với điều đó.

Ruby, 113 byte

đếm các ký hiệu được in dưới dạng một byte như được cho phép bởi thử thách (tôi rất ngạc nhiên khi phát hiện ra chúng thực sự là 3 byte.)

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 dòng đầu ra cho phép mã hóa 6 bit cho mỗi ký tự của chuỗi ma thuật. Nhưng các ký tự chuỗi ma thuật thực sự mã hóa cho mỗi lần chuyển đổi, do đó:

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)

Điều này được giải mã để tìm 2 ký tự phải được in cho mỗi lần chuyển đổi (ký tự đầu tiên là dấu cách hoặc một hàng ngang.) Chuỗi 8 ký tự cho các hàng trên và dưới trùng nhau: Hai ký tự cuối cùng cho hàng trên 11là hai đường kẻ ngang, khớp với những gì cần thiết cho hai ký tự đầu tiên của hàng dưới 00. 8 ký tự cho hàng thấp hơn bao quanh: chúng là 6 ký tự cuối cùng và 2 ký tự đầu tiên của chuỗi ký hiệu.

Mã bị đánh cắp

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 ký tự, 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

Điều này hoạt động trên máy tính của tôi, nhưng dường như không phân tích cú pháp byte chính xác trên TIO ...

Đây $alà một chuỗi nhiều dòng chứa đầy số và khoảng trắng, sau đó là các vòng lặp 0..4|%{...}. Mỗi lần lặp, chúng ta -replacelà chữ số thích hợp $_với ký tự phù hợp '┌─┐┘└'[$_]và lưu lại $a. Sau đó, chúng tôi chỉ để lại $atrên đường ống và đầu ra là ẩn.

JavaScript (ES6), 163 158 154 byte

NB: đếm các ký tự UTF-8 dưới dạng byte, như được cho phép bởi thử thách.

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

Bản giới thiệu

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())

Đã lưu 4 byte nhờ Neil

C, 213 205 byte

Đối với một sự thay đổi, kích thước chương trình C, trong thử thách này, không hoàn toàn vô lý so với các ngôn ngữ khác.

#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, định nghĩa mở rộng và nhận xét:

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

Lưu ý: chuỗi C không được chứa các ký tự unicode. Tất cả các ký tự hiển thị phải là ký tự 8 bit cũ đơn giản (nhưng chúng có thể được chọn trong phạm vi mở rộng). Vì vậy, về cơ bản, tính hợp lệ của đầu ra phụ thuộc vào trang mã của bạn.

tcl, 221 ký tự, 299 byte

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└────"}

có thể chạy trên: http://rextester.com/live/VVQU99270