तर्क गेट्स मैन्युअल रूप से

Question

एक प्रोग्राम बनाएं जो मूल लॉजिक गेट्स का अनुकरण करता है।

इनपुट: एक ऑल-कैप्स शब्द जिसके बाद 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

यह कोडगोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

Comments

क्या हम एक सरणी में इनपुट के रूप में ले सकते हैं?

— क्विंटेक

No @Quintec you can’t

— qazwsx

क्या हम True / False के रूप में आउटपुट कर सकते हैं?

— xnor

यकीन है कि @xnor (प्रासंगिक उपयोगकर्ता नाम भी)

— qazwsx

Answer 1

जेली , 13 10 बाइट्स

OSị“ʋN’BŻ¤

इसे ऑनलाइन आज़माएं!

पोर्ट ऑफ पीटर टेलर का जवाब।

Comments

9 बाइट्स @mazzy*256%339%2 के पॉवर्सशेल उत्तर ( ) का पोर्ट बनाकर ।

— केविन क्रूज़सेन 15

@KevinCruijssen आह, नया एल्गोरिथ्म नोटिस करने के लिए नहीं था, धन्यवाद।

— आउटगोल्फ़र

Answer 2

पायथन 2 , 38 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट स्ट्रिंग के ASCII मानों के योग पर एक अच्छा ol 'मोड्यूलो चेन लागू होता है, जो एक ऐसे समाधान के लिए बनाता है जो अभी ओवरफिटिंग है। कुल ASCII मूल्य प्रत्येक संभावित इनपुट के लिए अलग है, सिवाय इसके कि उन लोगों के साथ 0 1और 1 0एक ही परिणाम दें, जो कि बाहर काम करता है क्योंकि उपयोग किए जाने वाले सभी तर्क द्वार सममित हैं।

*3आदानों कि केवल बिट्स में विभिन्न के लिए अन्यथा-आसन्न मूल्यों से अलग रखता है, इन कर पाना कठिन हो आधुनिक श्रृंखला को विभाजित करने के लिए के बाद से। मॉड श्रृंखला में संख्याओं की लंबाई और आकार लगभग 18 बाइनरी आउटपुट फिट करने के लिए एंट्रॉपी की सही मात्रा बनाता है।

एक छोटा सा समाधान निश्चित रूप से उपयोग करना संभव है hash(s)या id(s), लेकिन मैंने इन से बचा लिया क्योंकि वे सिस्टम-निर्भर हैं।

---

पायथन 2 , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

थोड़ा और अधिक राजसी समाधान। प्रत्येक लॉजिक गेट इनपुट में शून्य की प्रत्येक गणना के लिए एक अलग परिणाम देता है, 1 से 6 तक तीन-बिट संख्या के रूप में एन्कोडेबल है। प्रत्येक संभव लॉजिक गेट को उसी संख्या में मैप किया जाता है (s*9)[35], जो सभी अलग-अलग होते हैं। इसके लिए OR, यह बिट्स में से किसी एक को पढ़ता है, इसलिए यह चरित्र हो सकता है 0या हो सकता है 1, लेकिन यह जांचने के लिए काम करता है कि क्या यह ठीक है 0, और कोई भी परिणाम 1सही रूप से देगा 1।

Comments

अरे, मैं अपने स्वयं के आधुनिक मूल्यों की तलाश कर रहा था, लेकिन आपने मुझे इसके लिए हरा दिया। क्या आपने कहीं भी इसके लिए अपनी रणनीतियां लिखी हैं, क्योंकि मेरी पाशविक बल विधियाँ बहुत लंबा समय लेती हैं

— जो किंग

@JoKing मैंने मूल रूप से कुल बल पर किया *a%b%c%d%e%2, वास्तव में कुछ भी चतुर नहीं है। केवल एक दिलचस्प बात *mods से पहले डाल रहा था ; मैंने अन्य स्वरूपों की कोशिश नहीं की।

— xnor

वाह ये तो सिर्फ दिमाग है! मैं भी ऐसा करने के लिए एक हैश की तरह विधि की उम्मीद नहीं है। क्या मैं आपके जवाब का 45-बाइट वाला JS पोर्ट बना सकता हूँ ?

— शायरु असकोतो

@ शायरूआसाकोतो निश्चित रूप से, इसके लिए जाएं।

— 5

@xnor मैंने ठीक उसी तरीके का उपयोग किया जैसा आपने किया था, इसलिए मुझे यह अपने आप पोस्ट करना ठीक नहीं लगेगा, लेकिन यह 36 बाइट्स हो सकता है ।

— nedla2004

Answer 3

जावास्क्रिप्ट (ईएस 6), 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

हम रिक्त स्थान को पार्स नहीं कर सकते parseInt(), कोई फर्क नहीं पड़ता कि हम किस आधार के साथ काम कर रहे हैं। इसलिए हम इसके बजाय इनपुट स्ट्रिंग के बेस -64 प्रतिनिधित्व को इंजेक्ट करते हैं। यह =पैडिंग कैरेक्टर उत्पन्न कर सकता है (जिसे 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

Comments

: पोर्ट किए गए उत्तर की तुलना में कम है

— शायरु असाकोतो

लेकिन ... यह काम नहीं लगता है NOR?

— शायरु असाकोतो

@ShieruAsakoto ध्यान देने के लिए धन्यवाद। मैं तो भूल ही गया NOR। अब तय हो गया।

— अरनौलड

Answer 4

CJam (13 बाइट्स)

q1bH%86825Yb=

मानता है कि इनपुट एक अनुगामी न्यूलाइन के बिना है।

ऑनलाइन टेस्ट सूट

यह सिर्फ एक साधारण हैश है जो 24 संभावित आदानों को 17 विशिष्ट लेकिन सुसंगत मूल्यों में मैप करता है और फिर उन्हें एक संकुचित तालिका में देखता है।

पायथन 2 (36 बाइट्स)

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

यह ऊपर CJam उत्तर का सिर्फ एक पोर्ट है। एक्सनोर के परीक्षण ढांचे का उपयोग करके टेस्ट सूट ।

Answer 5

05AB1E , 13 12 10 8 बाइट्स

ÇO₁*Ƶï%É

पोर्ट ऑफ @mazzy के वैकल्पिक गणना में उनके पॉवर्सशेल उत्तर ( *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।

Answer 6

चारकोल , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: संपीड़ित स्ट्रिंग समर्थित कार्यों की एक सूची में फैल जाती है ताकि दिए गए ऑपरेशन का सूचकांक फिर इनपुट के अनुसार सही स्थानांतरित हो जाए और इस प्रकार निकाले गए बिट परिणाम बन जाए।

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

74-बाइट संस्करण सभी 16 बाइनरी ऑपरेशंस के लिए काम करता है, जिसे मैंने मनमाने ढंग से नाम दिया है: शून्य और लेस सेकेंड GREATER FIRST XOR या NOR XNOR NFIRST NGREATER NSECOND NLESS NAND NEROERO।

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

Comments

+1 बल्कि पूरे 16 ऑपरेशन प्रोग्राम से प्रभावित हुए!

— theyyyumdub

Answer 7

मैथेमेटिका, 55 बाइट्स

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

शुद्ध कार्य। इनपुट और रिटर्न के रूप में Trueया Falseआउटपुट के रूप में एक स्ट्रिंग लेता है । के बाद से Or, And, Nor, Nand, Xor, और Xnorसभी का निर्माण-इन कर रहे हैं, हम का उपयोग ToCamelCaseपास्कल मामले को ऑपरेटर बदलने के लिए है, यह बराबर प्रतीक में बदलने का है, और दो तर्क करने के लिए इसे लागू होते हैं।

Answer 8

जे , 21 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Xnor के पायथन 2 समाधान का पोर्ट ।

---

जे , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Eval के साथ मज़ा में से कुछ बिट ".और मानक पुस्तकालय (जो पहले से ही सही भी शामिल है AND, OR, XOR)।

---

जे , 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अधिक जे-शैली दृष्टिकोण।

यह काम किस प्रकार करता है

एक बहुत ही सामान्य J ट्रिक यहाँ छिपा है। अक्सर, वांछित फ़ंक्शन में संरचना होती है "एक इनपुट पर एफ करें, दूसरे पर एच करें, और फिर दोनों परिणामों पर जी करें।" फिर इसे जैसे संचालित करना चाहिए (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

Comments

यदि आप पहले से ही नहीं है, तो ट्रिक को J टिप्स में गोल्फिंग के लिए पोस्ट करने पर विचार करें। स्वच्छ सामान। इसके अलावा मैं eval समाधान का एक बड़ा प्रशंसक हूँ।

— कोल

Answer 9

पॉवरशेल, 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

Comments

आपके मामलों के *16%95%7%2लिए विफल रहता है XNOR, यद्यपि। आप इस्तेमाल कर सकते हैं @ nedla2004 की*6%68%41%9%2 है, जो 2 बाइट्स से भी कम है @xnor ', रों एक यद्यपि।

— केविन क्रूज़सेन

धन्यवाद!!!! मैंने जोड़ा है xnor। मुझे लगता है कि *108%143यह अधिक आकर्षक है :) इसके अलावा, एक अच्छी जोड़ी है *256%339। यह जोड़ी उन भाषाओं के लिए भी बेहतर है जो बिट्स और बाइट्स के साथ काम करना जानती हैं।

— माज़ी

बहुत सुंदर! आपके उत्तर से एक पोर्ट मेरे जावा उत्तर में भी 2 बाइट बचाता है । :) और इसका उपयोग करके मेरे 05AB1E उत्तर के लिए 10-बाइट विकल्प है । *256%339

— केविन क्रूज़सेन 14

Answer 10

पर्ल 6 , 20 बाइट्स

*.ords.sum*108%143%2

इसे ऑनलाइन आज़माएं!

मैडी के दृष्टिकोण का एक बंदरगाह । वैकल्पिक रूप से, *256%339%2काम भी करता है।

पर्ल 6 , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Xnor के जवाब का एक बंदरगाह । मैं एक छोटे से एक को खोजने के लिए जाना होगा, लेकिन मुझे लगता है कि यह शायद सबसे अच्छा है।

Answer 11

जावास्क्रिप्ट (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 केस को मैप करना भूल गए।

Comments

शायद मुझे कुछ दिखाई नहीं दे रहा है, लेकिन मैं इनपुट कहां लिखूं? इनपुट टैब कुछ नहीं करता है।

— qazwsx

@qazwsx यह एक लंबो फ़ंक्शन है, जिसे डिफ़ॉल्ट रूप से अनुमति दी जाती है।

— शायरु असकोटो

@qazwsx लिंक हर संभव इनपुट के लिए आउटपुट दिखाता है। यह उत्तर एक फ़ंक्शन है, इसलिए यदि आप इसे मैन्युअल रूप से परीक्षण करना चाहते हैं, तो आप पाद लेख को उदाहरण के लिए बदल सकते हैंconsole.log(f("AND", 1, 1));

— Mego

@qazwsx और कृपया डाउनवोट को वापस लाएं। यह सब के बाद अमान्य नहीं है।

— शायरु असकोटो

ओह मैं समझा। मैंने डाउनवोट को वापस कर दिया

— qazwsx

Answer 12

जावा 10, 30 28 बाइट्स

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

पोर्ट ऑफ @ माज़ज़ी पॉवरशेल उत्तर ।

इसे ऑनलाइन आज़माएं।

Answer 13

जावास्क्रिप्ट (Node.js) , 45 बाइट्स

बस xnor के शानदार पायथन 2 उत्तर का एक पोर्ट सहमति पर पोस्ट किया गया है, कृपया इसका उत्तर इसके स्थान पर दें।

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

इसे ऑनलाइन आज़माएं!

Comments

43 बाइट्स @ nedla2004 के वैकल्पिक मोडुलोस के साथ ।

— केविन क्रूजसेन

या @PeterTaylor के पायथन के उत्तर के पोर्ट के साथ एक 43 बाइट्स विकल्प ।

— केविन क्रूजसेन 13

हो सकता है कि पहले इसे एक समुदाय के उत्तर में बदलने का एक अच्छा विचार हो? फिर उन जेएस पोर्ट्स को यहां एक संग्रह के रूप में जोड़ें।

— शायरु असाकोतो

शायद। निश्चित नहीं। यदि एक ही बाइट-काउंट के साथ कई विकल्प हैं, तो मैं आमतौर पर कई उत्तर जोड़ता हूं। mazzy के पॉवर्सशेल का उत्तर भले ही छोटा मिला: 41 बाइट्स ।

— केविन क्रूज़सेन

Answer 14

अटैची , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बल्कि एक क्रूर समाधान। इनपुट को संबंधित अटैच कमांड में परिवर्तित करता है और उसका मूल्यांकन करता है। (अटैच ने 6 लॉजिक गेट्स में से प्रत्येक के लिए बिल्ट-इन बनाया है।)

Answer 15

रूबी , 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है:

मूल रूप से पीटर टेलर के जवाब के समान है, लेकिन रूबी इसे आसान बनाती है। जादू की संख्या अलग है लेकिन विचार समान था।