Tạo một chương trình mô phỏng các cổng logic cơ bản.

Dữ liệu vào: Một từ có tất cả chữ hoa theo sau là số nhị phân 2 1 chữ số, được phân tách bằng dấu cách, chẳng hạn như OR 1 0. Cửa OR, AND, NOR, NAND, XOR, và XNORlà cần thiết.

Đầu ra: Đầu ra của cổng logic đã nhập sẽ được cung cấp hai số: 1 hoặc 0.

Ví dụ:
AND 1 0 trở 0
XOR 0 1thành 1
OR 1 1trở 1
NAND 1 1thành trở thành0

Đây là codegolf, vì vậy mã ngắn nhất sẽ thắng.

Thạch , 13 10 byte

OSị“ʋN’BŻ¤

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

Câu trả lời của cảng Peter Taylor.

Python 2 , 38 byte

lambda s:sum(map(ord,s))*3%61%37%9%7%2

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

Một chuỗi modulo ol 'tốt được áp dụng cho tổng các giá trị ASCII của chuỗi đầu vào, tạo ra một giải pháp chỉ là quá mức. Tổng giá trị ASCII là khác biệt cho từng đầu vào có thể, ngoại trừ những giá trị có 0 1và 1 0cho cùng một kết quả, điều này có hiệu quả vì tất cả các cổng logic được sử dụng là đối xứng.

Việc *3tách ra các giá trị liền kề khác cho các đầu vào chỉ khác nhau ở các bit, vì các giá trị này làm cho chuỗi mod khó phân tách. Độ dài và kích thước của các số trong chuỗi mod tạo ra lượng entropy phù hợp để phù hợp với 18 đầu ra nhị phân.

Một giải pháp ngắn hơn chắc chắn là có thể sử dụng hash(s)hoặc id(s), nhưng tôi đã tránh những điều này vì chúng phụ thuộc vào hệ thống.

Python 2 , 50 byte

lambda s:'_AX0NRD'.find((s*9)[35])>>s.count('0')&1

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

Một giải pháp nguyên tắc hơn một chút. Mỗi cổng logic cung cấp một kết quả khác nhau cho mỗi số 0 trong đầu vào, được mã hóa thành số ba bit từ 1 đến 6. Mỗi cổng logic có thể được ánh xạ tới số tương ứng bằng cách lấy (s*9)[35], tất cả đều khác biệt. Đối với OR, điều này kết thúc việc đọc một trong các bit để nhân vật có thể 0hoặc 1, nhưng hóa ra nó hoạt động để kiểm tra xem nó có 0hay không và dù sao đi nữa cũng 1sẽ đưa ra 1kết quả chính xác .

JavaScript (ES6), 39 byte

s=>341139>>parseInt(btoa(s),34)%86%23&1

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

Làm sao?

Chúng tôi không thể phân tích các không gian với parseInt(), cho dù chúng tôi đang làm việc với cơ sở nào. Vì vậy, chúng tôi chèn một đại diện cơ sở-64 của chuỗi đầu vào thay thế. Điều này có thể tạo ra các =ký tự đệm (không thể được phân tích cú pháp bằng parseInt()một trong hai), nhưng những ký tự này được đảm bảo nằm ở cuối chuỗi và có thể được bỏ qua một cách an toàn.

Chúng tôi phân tích thành cơ sở $34$ và áp dụng modulo $86$ , tiếp theo là modulo $23$ , cho kết quả như sau. Điều này bao gồm không chính xác do mất độ chính xác. Kết quả cuối cùng là trong $[0..19]$ , với chỉ số trung thực cao nhất là $18$ , dẫn đến bitmask tra cứu 19 bit.

 input      | to base-64     | parsed as base-34 | mod 86 | mod 23 | output
------------+----------------+-------------------+--------+--------+--------
 "AND 0 0"  | "QU5EIDAgMA==" |  1632500708709782 |   26   |    3   |    0
 "AND 0 1"  | "QU5EIDAgMQ==" |  1632500708709798 |   42   |   19   |    0
 "AND 1 0"  | "QU5EIDEgMA==" |  1632500708866998 |   34   |   11   |    0
 "AND 1 1"  | "QU5EIDEgMQ==" |  1632500708867014 |   50   |    4   |    1
 "OR 0 0"   | "T1IgMCAw"     |     1525562056532 |   52   |    6   |    0
 "OR 0 1"   | "T1IgMCAx"     |     1525562056533 |   53   |    7   |    1
 "OR 1 0"   | "T1IgMSAw"     |     1525562075028 |   58   |   12   |    1
 "OR 1 1"   | "T1IgMSAx"     |     1525562075029 |   59   |   13   |    1
 "XOR 0 0"  | "WE9SIDAgMA==" |  1968461683492630 |   48   |    2   |    0
 "XOR 0 1"  | "WE9SIDAgMQ==" |  1968461683492646 |   64   |   18   |    1
 "XOR 1 0"  | "WE9SIDEgMA==" |  1968461683649846 |   56   |   10   |    1
 "XOR 1 1"  | "WE9SIDEgMQ==" |  1968461683649862 |   72   |    3   |    0
 "NAND 0 0" | "TkFORCAwIDA=" | 61109384461626344 |   62   |   16   |    1
 "NAND 0 1" | "TkFORCAwIDE=" | 61109384461626350 |   70   |    1   |    1
 "NAND 1 0" | "TkFORCAxIDA=" | 61109384461665650 |   64   |   18   |    1
 "NAND 1 1" | "TkFORCAxIDE=" | 61109384461665656 |   72   |    3   |    0
 "NOR 0 0"  | "Tk9SIDAgMA==" |  1797025468622614 |   76   |    7   |    1
 "NOR 0 1"  | "Tk9SIDAgMQ==" |  1797025468622630 |    6   |    6   |    0
 "NOR 1 0"  | "Tk9SIDEgMA==" |  1797025468779830 |   84   |   15   |    0
 "NOR 1 1"  | "Tk9SIDEgMQ==" |  1797025468779846 |   14   |   14   |    0
 "XNOR 0 0" | "WE5PUiAwIDA=" | 66920415258533864 |    0   |    0   |    1
 "XNOR 0 1" | "WE5PUiAwIDE=" | 66920415258533870 |    8   |    8   |    0
 "XNOR 1 0" | "WE5PUiAxIDA=" | 66920415258573170 |    2   |    2   |    0
 "XNOR 1 1" | "WE5PUiAxIDE=" | 66920415258573176 |   10   |   10   |    1

CJam (13 byte)

q1bH%86825Yb=

Giả sử rằng đầu vào là không có một dòng mới.

Bộ kiểm tra trực tuyến

Đây chỉ là một hàm băm đơn giản, ánh xạ 24 đầu vào có thể thành 17 giá trị riêng biệt nhưng nhất quán và sau đó tìm kiếm chúng trong một bảng nén.

Python 2 (36 byte)

lambda s:76165>>sum(map(ord,s))%17&1

Đây chỉ là một cổng của câu trả lời của CJam ở trên. Bộ thử nghiệm sử dụng khung thử nghiệm của xnor.

05AB1E , 13 12 10 8 byte

ÇO₁*Ƶï%É

Tính toán thay thế của cảng @mazzy được đề cập trong bình luận về câu trả lời Powershell của anh ấy ( *256%339%2thay vì *108%143%2).

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Ç            # Convert each character in the (implicit) input to a unicode value
 O           # Sum them together
  ₁*         # Multiply it by 256
    Ƶï%      # Then take modulo-339
        É    # And finally check if it's odd (short for %2), and output implicitly

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để nén các số nguyên lớn? ) Để hiểu tại sao Ƶïlà 339.

Than , 32 byte

§01÷⌕⪪”＆⌈4Ｙ⍘ＬH⦄vü|⦃³Ｕ}×▷” Ｓ∨⁺ＮＮ⁴

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: Chuỗi nén mở rộng thành một danh sách các hoạt động được hỗ trợ để chỉ số của hoạt động đã cho sau đó được dịch chuyển sang phải theo các đầu vào và do đó bit được trích xuất trở thành kết quả.

XOR     001
AND     010
OR      011
NOR     100
NAND    101
XNOR    110
inputs  011
        010

Phiên bản 74 byte hoạt động cho tất cả 16 thao tác nhị phân, mà tôi đã đặt tên tùy ý như sau: ZERO VÀ LESS SECOND GREATER FIRST XOR HOẶC NOR XNOR NFIRST NGREATER NSECOND NLESS NAND NZERO.

§10÷÷⌕⪪”＆↖VρＳ´↥cj/v⊗J[Rf↓⪫？9ＫO↘Ｙ⦄;↙W´Ｃ>η=⁴⌕✳AＫＸIＢ｜⊖\`⊖:Ｂ�Ｊ/≧vF@$h⧴” Ｓ∨Ｎ²∨Ｎ⁴

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Toán học, 55 byte

Symbol[ToCamelCase@#][#2=="1",#3=="1"]&@@StringSplit@#&

Chức năng thuần túy. Lấy một chuỗi làm đầu vào và trả về Truehoặc Falselà đầu ra. Kể từ khi Or, And, Nor, Nand, Xor, và Xnortất cả đều được xây dựng-in, chúng tôi sử dụng ToCamelCaseđể thay đổi các nhà điều hành cho trường hợp Pascal, chuyển nó sang biểu tượng tương đương, và áp dụng nó vào hai tham số.

J , 21 byte

2|7|9|37|61|3*1#.3&u:

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

Cổng giải pháp Python 2 của xnor .

J , 30 byte

XNOR=:=/
NAND=:*:/
NOR=:+:/
".

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

Một số chút vui vẻ với eval ".thư viện và tiêu chuẩn (mà đã bao gồm đúng AND, OR, XOR).

J , 41 byte

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

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

Thêm cách tiếp cận kiểu J.

Làm thế nào nó hoạt động

Một mẹo J rất chung được ẩn ở đây. Thông thường, hàm mong muốn có cấu trúc "Làm F trên một đầu vào, làm H trên đầu vào khác và sau đó thực hiện G trên cả hai kết quả." Sau đó, nó sẽ hoạt động như thế nào (F x) G H y. Ở dạng ngầm, nó tương đương với (G~F)~H:

x ((G~F)~H) y
x (G~F)~ H y
(H y) (G~F) x
(H y) G~ F x
(F x) G H y

Nếu Glà một nguyên thủy bất đối xứng, chỉ cần trao đổi các đối số trái và phải của hàm mục tiêu và chúng ta có thể lưu một byte.

Bây giờ đến câu trả lời ở trên:

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

1 i.~' XXNNA'E.~_2&}.  Processing right argument (X): the operation's name
                _2&}.  Drop two chars from the end
1 i.~' XXNNA'E.~       Find the first match's index as substring
                       Resulting mapping is [OR, XOR, XNOR, NOR, NAND, AND]

7 6 9 8 14 1 b./  Processing left argument (Y): all logic operations on the bits
7 6 9 8 14 1 b.   Given two bits as left and right args, compute the six logic functions
               /  Reduce by above

X{Y  Operation on both: Take the value at the index

Powershell, 36 34 byte

Lấy cảm hứng từ xnor , nhưng trình tự *108%143%2ngắn hơn bản gốc*3%61%37%9%7%2

$args|% t*y|%{$n+=108*$_};$n%143%2

Kịch bản thử nghiệm:

$f = {

 $args|% t*y|%{$n+=108*$_};$n%143%2
#$args|% t*y|%{$n+=3*$_};$n%61%37%9%7%2   # sequence by xnor

}

@(
    ,("AND 0 0", 0)
    ,("AND 0 1", 0)
    ,("AND 1 0", 0)
    ,("AND 1 1", 1)
    ,("XOR 0 0", 0)
    ,("XOR 0 1", 1)
    ,("XOR 1 0", 1)
    ,("XOR 1 1", 0)
    ,("OR 0 0", 0)
    ,("OR 0 1", 1)
    ,("OR 1 0", 1)
    ,("OR 1 1", 1)
    ,("NAND 0 0", 1)
    ,("NAND 0 1", 1)
    ,("NAND 1 0", 1)
    ,("NAND 1 1", 0)
    ,("NOR 0 0", 1)
    ,("NOR 0 1", 0)
    ,("NOR 1 0", 0)
    ,("NOR 1 1", 0)
    ,("XNOR 0 0", 1)
    ,("XNOR 0 1", 0)
    ,("XNOR 1 0", 0)
    ,("XNOR 1 1", 1)

) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-eq$e): $s=$r"
}

Đầu ra:

True: AND 0 0=0
True: AND 0 1=0
True: AND 1 0=0
True: AND 1 1=1
True: XOR 0 0=0
True: XOR 0 1=1
True: XOR 1 0=1
True: XOR 1 1=0
True: OR 0 0=0
True: OR 0 1=1
True: OR 1 0=1
True: OR 1 1=1
True: NAND 0 0=1
True: NAND 0 1=1
True: NAND 1 0=1
True: NAND 1 1=0
True: NOR 0 0=1
True: NOR 0 1=0
True: NOR 1 0=0
True: NOR 1 1=0
True: XNOR 0 0=1
True: XNOR 0 1=0
True: XNOR 1 0=0
True: XNOR 1 1=1

Perl 6 , 20 byte

*.ords.sum*108%143%2

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

Một cách tiếp cận của maddy . Ngoài ra, *256%339%2cũng hoạt động.

Perl 6 , 24 byte

*.ords.sum*3%61%37%9%7%2

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

Một câu trả lời của xnor . Tôi sẽ đi tìm một cái ngắn hơn, nhưng tôi nghĩ đó có lẽ là thứ tốt nhất.

JavaScript (Node.js) , 106 94 byte

x=>([a,c,d]=x.split` `,g=[c&d,c^d,c|d]["OR".search(a.slice(1+(b=/N[^D]/.test(a))))+1],b?1-g:g)

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

Liên kết đến mã và tất cả 24 trường hợp.

+9 vì đã quên ánh xạ trường hợp XNOR.

Java 10, 30 28 byte

s->s.chars().sum()*108%143%2

Cổng câu trả lời Powershell của @mazzy .

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

JavaScript (Node.js) , 45 byte

Chỉ cần một cổng của câu trả lời Python 2 tuyệt vời của xnor được đăng khi có sự đồng ý, vui lòng cung cấp cho câu trả lời đó thay vì câu trả lời này.

x=>Buffer(x).reduce((a,b)=>a+b)*3%61%37%9%7%2

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

Tùy viên , 55 byte

{Eval!$"${Sum!Id''Downcase!SplitAt!_}${N=>__2}"}@@Split

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

Một giải pháp khá tàn bạo. Chuyển đổi đầu vào thành lệnh Attache có liên quan và đánh giá nó. (Attache đã tích hợp sẵn cho mỗi trong số 6 cổng logic.)

Ruby , 20 byte

->s{76277[s.sum%17]}

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

Làm thế nào nó hoạt động:

Về cơ bản giống như câu trả lời của Peter Taylor, nhưng Ruby làm cho nó dễ dàng hơn. Số ma thuật là khác nhau nhưng ý tưởng là như nhau.