สร้างโปรแกรมที่จำลองประตูตรรกะพื้นฐาน

การป้อนข้อมูล:ทุกคำหมวกตามด้วยเลขฐานสอง 2 1 OR 1 0บาทคั่นด้วยช่องว่างเช่น ประตูOR, AND, NOR, NAND, XORและXNORมีความจำเป็น

เอาท์พุท:สิ่งที่เอาท์พุทของประตูตรรกะที่ป้อนจะได้รับตัวเลขสอง: 1 หรือ 0

ตัวอย่าง:
AND 1 0กลาย0
XOR 0 1เป็น1
OR 1 1กลาย1
NAND 1 1เป็นกลายเป็น0

นี่คือ codegolf ดังนั้นรหัสที่สั้นที่สุดชนะ

เยลลี่ , 13 10 ไบต์

OSị“ʋN’BŻ¤

ลองออนไลน์!

คำตอบของพอร์ตของ Peter Taylor

Python 2 , 38 ไบต์

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

ลองออนไลน์!

ห่วงโซ่ modulo ol ที่ดีนำไปใช้กับผลรวมของค่า ASCII ของสายป้อนทำให้การแก้ปัญหาที่เพิ่ง overfitting ค่า ASCII ทั้งหมดนั้นแตกต่างกันสำหรับอินพุตที่เป็นไปได้แต่ละอันยกเว้นค่าที่มี0 1และ1 0ให้ผลเหมือนกันซึ่งจะได้ผลเพราะประตูตรรกะทั้งหมดที่ใช้มีความสมมาตร

การ*3แยกค่าที่อยู่ติดกันเป็นอย่างอื่นสำหรับอินพุตที่แตกต่างกันเฉพาะในบิตเนื่องจากสิ่งเหล่านี้ทำให้การแยก mod chain ทำได้ยาก ความยาวและขนาดของตัวเลขในห่วงโซ่ mod สร้างปริมาณเอนโทรปีที่เหมาะสมให้พอดีกับเอาต์พุต 18 ไบนารี่

วิธีแก้ปัญหาที่สั้นกว่านั้นเป็นไปได้โดยใช้hash(s)หรือid(s)แต่ฉันหลีกเลี่ยงสิ่งเหล่านี้เพราะมันขึ้นอยู่กับระบบ

Python 2 , 50 ไบต์

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

ลองออนไลน์!

ทางออกที่ดีกว่าเล็กน้อย ลอจิกเกแต่ละให้ผลที่แตกต่างกันสำหรับการนับแต่ละศูนย์ในการป้อนข้อมูล, encodable เป็นจำนวนสามบิตจาก 1 ถึง 6 ประตูแต่ละตรรกะเป็นไปได้คือแมปไปยังหมายเลขที่สอดคล้องกันโดยการ(s*9)[35]ที่มีทั้งหมดที่แตกต่างกัน สำหรับORเรื่องนี้จบลงด้วยการอ่านหนึ่งในบิตดังนั้นตัวละครอาจจะเป็น0หรือ1แต่มันกลับกลายเป็นว่าต้องทำงานเพื่อตรวจสอบว่าเป็น0หรือไม่และ a 1จะให้1ผลลัพธ์ที่ถูกต้องอยู่แล้ว

JavaScript (ES6) 39 ไบต์

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

ลองออนไลน์!

อย่างไร?

เราไม่สามารถแยกช่องว่างด้วยparseInt()ไม่ว่าเราจะทำงานร่วมกับฐานใด ดังนั้นเราจึงฉีดการแสดงฐาน -64 ของสตริงอินพุตแทน สิ่งนี้อาจสร้าง=อักขระ padding (ซึ่งไม่สามารถแยกวิเคราะห์ด้วยparseInt()) แต่อักขระเหล่านี้รับประกันว่าจะอยู่ที่ท้ายสตริงและสามารถละเว้นได้อย่างปลอดภัย

$34$$86$$23$$[0..19]$$18$

 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 ไบต์)

q1bH%86825Yb=

ถือว่าอินพุตนั้นไม่มีการขึ้นบรรทัดใหม่

ชุดทดสอบออนไลน์

นี่เป็นเพียงแฮชธรรมดาที่แมปอินพุต 24 ที่เป็นไปได้เป็น 17 ค่าที่แตกต่าง แต่มีความสอดคล้องกันจากนั้นค้นหาในตารางที่ถูกบีบอัด

Python 2 (36 ไบต์)

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

นี่เป็นเพียงพอร์ตของคำตอบ CJam ด้านบน ชุดทดสอบโดยใช้กรอบการทดสอบของ xnor

05AB1E , 13 12 10 8 ไบต์

ÇO₁*Ƶï%É

การคำนวณทางเลือกของพอร์ตของ@mazzyกล่าวถึงในความคิดเห็นในคำตอบ Powershell ของเขา ( *256%339%2แทน*108%143%2)

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

Ç            # 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

ดู 05AB1E นี้เคล็ดลับของฉัน (ส่วนวิธีการบีบอัดจำนวนเต็มขนาดใหญ่? )จะเข้าใจว่าทำไมเป็นƵï339

ถ่าน 32 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย: สตริงที่บีบอัดขยายไปยังรายการของการดำเนินการที่ได้รับการสนับสนุนเพื่อให้ดัชนีของการดำเนินการที่กำหนดนั้นถูกเลื่อนไปทางขวาตามอินพุตและบิตที่แยกจึงกลายเป็นผลลัพธ์

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

เวอร์ชัน 74 ไบต์ใช้งานได้กับการดำเนินการทั้ง 16 แบบซึ่งฉันตั้งชื่อตามอำเภอใจดังนี้: ZERO AND LESS SECOND GREATER ครั้งแรก XOR หรือ NOR XNOR NFIRST NGREATER NSECOND NLESS NAND NZERO

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด

Mathematica ขนาด 55 ไบต์

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

ฟังก์ชั่นบริสุทธิ์ รับสตริงเป็นอินพุตและส่งคืนTrueหรือFalseเป็นเอาต์พุต ตั้งแต่Or, And, Nor, Nand, XorและXnorทุกคนสร้างอินที่เราใช้ToCamelCaseในการเปลี่ยนผู้ประกอบการเพื่อกรณีปาสกาลแปลงเป็นสัญลักษณ์เทียบเท่าและใช้มันทั้งสองมีปากเสียง

J , 21 ไบต์

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

ลองออนไลน์!

ท่าเรือXNOR วิธีการแก้ปัญหาของงูหลาม

J , 30 ไบต์

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

ลองออนไลน์!

ความสนุกเล็กน้อยกับ eval ".และไลบรารี่มาตรฐาน (ซึ่งรวมถึงถูกต้องANDแล้วOR, XOR)

J , 41 ไบต์

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

ลองออนไลน์!

วิธีการแบบ J เพิ่มเติม

มันทำงานอย่างไร

เคล็ดลับ J ทั่วไปถูกซ่อนอยู่ที่นี่ บ่อยครั้งที่ฟังก์ชั่นที่ต้องการมีโครงสร้าง "Do F ในอินพุตหนึ่ง, ทำ H บนอีกอัน, จากนั้นทำ G กับผลลัพธ์ทั้งสอง" (F x) G H yแล้วมันควรจะดำเนินการเช่น ในรูปแบบโดยปริยายมันเทียบเท่ากับ(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

หากGเป็นแบบดั้งเดิมไม่สมมาตรเพียงแค่สลับอาร์กิวเมนต์ซ้ายและขวาของฟังก์ชั่นเป้าหมายและเราสามารถบันทึกไบต์

ตอนนี้ไปที่คำตอบข้างต้น:

({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 ไบต์

แรงบันดาลใจจากxnorแต่ลำดับ*108%143%2จะสั้นกว่าต้นฉบับ*3%61%37%9%7%2

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

สคริปต์ทดสอบ:

$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"
}

เอาท์พุท:

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 ไบต์

*.ords.sum*108%143%2

ลองออนไลน์!

พอร์ตของวิธีการของแมดดี้ อีกวิธีหนึ่ง*256%339%2ก็ใช้งานได้

Perl 6 , 24 ไบต์

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

ลองออนไลน์!

พอร์ตของคำตอบของ XNOR ฉันจะไปหาอันที่สั้นกว่านี้ แต่ฉันคิดว่านั่นน่าจะดีที่สุด

JavaScript (Node.js) , 106 94 ไบต์

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)

ลองออนไลน์!

เชื่อมโยงไปยังรหัสและทั้งหมด 24 ราย

+9 สำหรับการลืมแผนที่กรณี XNOR

Java 10, 30 28 ไบต์

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

ท่าเรือ@mazzyคำตอบ 's Powershell

ลองออนไลน์

JavaScript (Node.js)ขนาด 45 ไบต์

มีเพียงพอร์ตของ Python 2 ที่ยอดเยี่ยมของ xnor ที่โพสต์เมื่อได้รับความยินยอมโปรดให้คำตอบ upvotes แทนสิ่งนี้

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

ลองออนไลน์!

ทูตขนาด 55 ไบต์

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

ลองออนไลน์!

ทางออกที่ค่อนข้างโหดเหี้ยม แปลงอินพุตเป็นคำสั่ง Attache ที่เกี่ยวข้องและประเมินค่า (Attache มีบิวด์อินสำหรับประตูลอจิกทั้ง 6 ประตู)

Ruby , 20 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร:

โดยพื้นฐานแล้วเหมือนกับคำตอบของ Peter Taylor แต่ Ruby ทำให้ง่ายขึ้น หมายเลขเวทย์มนตร์แตกต่างกัน แต่ความคิดก็เหมือนกัน