एक साधारण लॉजिक गेट कैलकुलेटर

Question

आपका मिशन, यदि आप इसे स्वीकार करना चुनते हैं, तो निम्न तार्किक ऑपरेटरों के लिए एक सरल सत्य मूल्यांकनकर्ता का निर्माण करना है:

----------------------------------------------------------------------------------
  Logical Name          |  Gate Name   |  Symbol  |  Symbol Name  |  Truth Table
----------------------------------------------------------------------------------
  Identity              |  is          |          |  (none)       |  10
  Negation              |  not         |    ~     |  tilde        |  01
  Conjunction           |  and         |    &     |  ampersand    |  1000
  Disjunction           |  or          |    |     |  pipe         |  1110
  Negative Conjunction  |  nand        |    ^     |  caret        |  0111
  Joint Denial          |  nor         |    v     |  "vee"        |  0001
  Exclusive Disjunction |  xor         |    x     |  "ecks"       |  0110
  Equivalence           |  equals/xnor |    =     |  equals       |  1001
  Implication           |  implies     |    >     |  greater than |  1011

सत्य सारणी निम्नलिखित क्रम में हैं:

1. 1 1
2. १ ०
3. 0 1
4. ० ०

इनपुट 0, 1, और सिंबल के एक साधारण स्ट्रिंग के रूप में आएगा। आप या तो इनपुट को एक पैरामीटर के रूप में स्वीकार कर सकते हैं या इसे स्टड पर उपयोगकर्ता से पढ़ सकते हैं। यहाँ कुछ नमूना इनपुट / आउटपुट जोड़े हैं:

Input: 1
Output: 1

Input: ~1
Output: 0

Input: 0|1
Output: 1

Input: 1>0
Output: 0

एकात्मक ऑपरेटर (नकार) बूलियन मान के समक्ष हमेशा दिखाई देगा, जबकि बाइनरी ऑपरेटर हमेशा दो बूलियन मानों के बीच दिखाई देंगे। आप मान सकते हैं कि सभी इनपुट मान्य होंगे। स्ट्रिंग्स नियमित ASCII स्ट्रिंग्स हैं।

यदि आप पसंद करते हैं, तो आप अपने वर्ण गणना में 1 और 0. -6 के बजाय T और F का उपयोग कर सकते हैं यदि आप दोनों का समर्थन करते हैं।

ये है कोड गोल्फ: किसी भी भाषा में सबसे कम कोड जीतता है!

Comments

मेरा मानना ​​है कि ^प्रतीक का नाम कैरेट कहना चाहिए ।

— FireFly

@FireFly Haha, तुम सही हो। दोपहर के भोजन के बहुत करीब! धन्यवाद।

— एस्टरी

Answer 1

एपीएल (45 - 6 = 39)

⍎(1+9≠L)⌷¨↓⍉Z⍪⍉⍪'10∧∨⍲⍱≠≤*'[L←'TF&|^vx>'⍳Z←⍞]

समर्थन करता है Tऔर Fइनपुट के रूप में लेकिन हमेशा आउटपुट 0या 1।

स्पष्टीकरण:

• Z←⍞: एक लाइन पढ़ें और इसे स्टोर करें Z
• L←'TF&|^vx>'⍳Z: 'TF&|^vx>'प्रत्येक वर्ण के लिए इंडेक्स प्राप्त करें Z, 9यदि चरित्र अंदर नहीं है 'TF&|^vx>'।
• '10∧∨⍲⍱≠≤*'[... ]: में संबंधित वर्ण खोजें '10∧∨⍲⍱≠≤*'। (इसलिए जो अक्षर पहली सूची में नहीं थे *) बन जाते हैं ।
• ↓⍉Z⍪⍉⍪: इसे एक मैट्रिक्स में बनाएं, मूल ( Z) को इसके ऊपर रखें, और इसे तार की एक सूची में विभाजित करें, जहां पहला चरित्र मूल है और दूसरा चरित्र इसका अनुवाद है, यदि कोई हो।
• (1+9≠L)⌷¨: इनमें से प्रत्येक तार के लिए, पहला वर्ण प्राप्त करें यदि कोई अनुवाद नहीं था (यदि L=9उस स्थान पर है) और दूसरा चरित्र यदि वहाँ था।
• उदाहरण: यदि इनपुट किया गया था T|0, तो 1∨0अब तक हमारे पास यही एपीएल अभिव्यक्ति है
• ⍎: eval

नोट: ~और =पहले से ही सही काम करते हैं ताकि उन्हें कुछ भी बदलने की आवश्यकता न हो।

Comments

बहुत अच्छा! यह ट्रांसलेट-टू-एपीएल-एंड-एवल अप्रोच है, है ना? मैं जम्मू में एक gerund- आधारित दृष्टिकोण की ओर इशारा कर रहा था, लेकिन मुझे नहीं पता कि चतुराई से ऑपरेंड को कैसे विभाजित किया जाए। : \

— फायरऑफली

मैट्रिक्स हेरफेर क्यों करते हैं जब आप बिना किसी परिवर्तन के वर्णों के लिए अनुवाद नियम जोड़ सकते हैं ⍎'1010~∧∨⍲⍱≠=≤'['10TF~&|^vx=>'⍳⍞]? (स्कोर 33-6 = 27)

— 22

Answer 2

सी - 165 127

वह मजेदार था! लुकअप के लिए एक निश्चित ऑफसेट पर निर्भर प्लेन लुकअप टेबल।

main(){
  char*s="100011001110110v& x = |^> /~",
       t[6]="0/xxx",
      *u= strchr((gets(t+2),t),0)-3;
  putchar(strchr(s,u[1])[*u*2+u[2]-159]);
}

के लिए किसी कारण getsपरोक्ष घोषित नहीं होता है, इसलिए जब मैं हटाया शामिल मैं बदलना पड़ा gets(t+2)करने के लिए (gets(t+2),t)(या इसी कहीं और, जितना की लागत)।

---

व्याख्या

सबसे पहले, चूंकि ऑपरेटरों के लिए सत्य तालिकाओं में ओवरलैपिंग वर्णों के बहुत सारे हैं, हम लुकअप तालिकाओं को एक तरह से संग्रहीत करना चाहते हैं ताकि हम ओवरलैप करें। यहाँ बताया गया है कि मैंने उन्हें कैसे चुना:

v    &    x    =    |    ^    >       ~     (operation)
1000 0001 0110 1001 0111 1110 1101 01 10    (truth table [order 00,01,10,11])
0    1    3    5    7    8    9    B  D     (offset in LUT below)

0123456789ABCDE   (offsets)
100011001110110   (values)

अगला, हम ऑपरेटर को इन ऑफसेट में मैप करना चाहते हैं। हम LUT डेटा (अर्थात्, 16 अक्षर बाद में, यानी सीधे LUT डेटा के बाद) से एक निश्चित ऑफसेट पर एक ही स्ट्रिंग में ऑपरेटर प्रतीकों को संग्रहीत करके ऐसा करते हैं। लुकअप प्रक्रिया "ऑपरेटर ढूंढना है s, घटाना 16, जोड़ना left*2+right(बाएं / दायाँ ऑपरेंड)। खाली" पहचान संचालन "की खोज के लिए, इस इनपुट के कारण ऑपरेटर को इस मामले में कैसे लाया जाता है, इसका पता लगाने के लिए जो भी t[1]शुरू होता है उसका समाधान होगा- -हमारे मामले में /। इस प्रकार, हम /पहचान ऑपरेशन का प्रतिनिधित्व करने के लिए लुकअप टेबल कुंजी के रूप में उपयोग करते हैं। जब हम एकरी ~ऑपरेशन की प्रक्रिया करते हैं " left" (पहले उल्लिखित लुकअप गणना के लिए) हमेशा यही होता है / । /0ASCII- वार, जिसका अर्थ है कि जब हम ASCII अंकों की भरपाई \करेंगे तो प्रतिनिधित्व करेंगे -1। लुकअप टेबल कुंजी क्षेत्र में स्लैश (दूसरा-से-अंतिम वर्ण s, जो है) इसके लिए क्षतिपूर्ति करने के लिए तैनात है।

अगला, इनपुट हैंडलिंग। इनपुट में डायनेमिक लंबाई है, लेकिन यह आसान होगा अगर हमारे पास इनपुट की परवाह किए बिना बाएं ऑपरेटर, ऑपरेटर और सही ऑपरेटर के लिए विशिष्ट स्थिर नाम हैं। यदि हम दिखावा करते हैं कि हम इनपुट को दाएं-बाएं पढ़ सकते हैं, तो यह मूल रूप से स्वचालित रूप से होगा - सही ऑपरेंड हमेशा सबसे सही वर्ण होता है, ऑपरेटर (यदि मौजूद है) दूसरा-से-सबसे दाएं, बाएं ऑपरेंड (यदि मौजूद है) ) तीसरा-सही है। स्ट्रिंग को इस तरह अनुक्रमित करने में सक्षम होने के लिए, हम टर्मिनेटर strchrका पता लगाने के लिए \0( - 3अनुक्रमण को सरल बनाने के लिए) उपयोग करते हैं। इससे पता चलता है कि इनपुट 1 या 2 वर्ण होने पर क्रमशः बाएं ऑपरेंड / ऑपरेटर क्यों t[0]और t[1]बन जाता है।

इसे एक साथ putchar(strchr(s,u[1])[(u[0] - '0')*2 + (u[2] - '0') - 15])रखना, आउटपुट होगा , लेकिन इसके बजाय कुछ रीफैक्टरिंग और निरंतर तह हमें कम मिलता है putchar(strchr(s,u[1])[u[0]*2+u[2]-159])।

Comments

क्या आप बता सकते हैं कि यह कैसे काम करता है?

— जोहान्स कुह्न

सत्य तालिका ओवरलैप एक शानदार विचार था। खुद के बारे में कभी नहीं सोचा होगा। :)

— एस्टरी

साथ ही रीडिंग राइट-टू-लेफ्ट। मुझे पता था कि वेरिएबल लेंथ इनपुट और पोजिशनिंग एक चुनौती होगी, और इसे हल करने का एक शानदार तरीका है। वास्तव में उत्कृष्ट आउट-ऑफ-द-बॉक्स सोच। मेरी विकास टीम पर काम करना चाहते हैं? Haha

— एस्टरी

मुझे लगता है कि अधिक उत्तर में इस तरह स्पष्टीकरण होना चाहिए। हम में से उन लोगों की मदद करता है जो अभी भी काफी कुछ सीख रहे हैं! (और उन लोगों द्वारा जो अभी भी बहुत कुछ सीख रहे हैं, हर किसी का मतलब है)

— agweber

@agweber: यह सुनने के लिए अच्छा है, मैं अपने स्पष्टीकरण के बारे में थोड़ा चिंतित था। और हां, शायद यहां हर कोई "अभी भी सीख रहा है" चरण में है .. ठीक है, कम से कम मुझे पता है कि मैं हूं।

— फायरफली

Answer 3

Tcl, 212 208-6 = 202

proc o n\ e {proc $n a\ b expr\ $e}
o > {$a<=$b}
o v {!($a|$b)}
o x {$a^$b}
o ^ {!($a&$b)}
namespace pat tcl::mathop 
lmap o\ b [lassign [split [string map {~0 1 ~1 0} $argv] {}] a] {set a [$o $a $b]}
puts $a

Ungolfed:

# Defines an operator
proc operator {name expression} {
    proc $name {a b} "expr $expression"
}
operator > {$a<=$b}
operator v {!($a|$b)}
operator x {$a^$b}
operator ^ {!($a&$b)}
# Call the commands in ::tcl::mathop if the command is not in the global namespace
namespace path tcl::mathop
# lmap instead foreach
# assume that we only got 1 argument.
foreach {op b} [lassign [string map {{~ 0} 1 {~ 1} 0} [split $argv {}]] a] {
   set a [$op $a $b]
}
puts $a

मुझे लगता है कि फॉरच्यू लाइन को कुछ स्पष्टीकरण की आवश्यकता है:

• split $argv {} इनपुट स्ट्रिंग को विभाजित करता है (यह वास्तव में एक सूची है, लेकिन कोड-गोल्फ) इसके पात्रों में है।
• string map {{~ 0} 1 {~ 1} 0} ...एक स्ट्रिंग और बदलने वाला लेता है ~ 0के साथ 1और ~ 1साथ0
• lassign ... a सूची का पहला तत्व लेता है और इसे चर a को असाइन करता है, बाकी को लौटाता है।
• foreach {op b} ... {code}सूची पर चलता है और हर बार 2 तत्व लेता है: opऔरb
• set a [$op $a $b]चर में कमांड निष्पादित करता है op, परिणाम को स्टोर करता हैa

Answer 4

जावास्क्रिप्ट - 107 105 वर्ण

alert((x=eval(prompt().replace(/v/,'|~').replace(/\^/,'&~').replace(/x/,'^').replace(/=/,'==')))!=-1?x:0)

Comments

हा हा बड़िया। यह आसान है। eval()जब मैंने इसे बनाया , तब भी नहीं सोचा था। बस मुझे घर लाने और परीक्षण करने के लिए थोड़ा सा दे दो।

— एस्टरी

नंद = &~और न = |~?

— जोहान्स कुह्न

@ जोहान्स: यह वास्तव में नहीं है &~और |~, लेकिन एनएंड सिर्फ एंड का उलटा है। तो, बिट्स में से एक को उलटने से परिणाम भी उल्टा हो जाता है।

— प्रोग्रामफॉक्स

Answer 5

बेगुंज -98 - 104 101 98-6 72

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

#v~
2_vp5a00+*2%2\p10\%
0:<+1_v#-g5\g1
1_|#:\</2\-
.@>2%
 v   ~x^&=.>  |

मजेदार तथ्य: आप @को बदलें a,$और आपको बदले में एक फैंसी आरईपीएल मिलता है (हालांकि, यदि आप ऐसा करते हैं तो आप देखेंगे कि पहचान वास्तव में "lhs = 0 और rhs = इनपुट के साथ अंतिम कमांड दोहराएं), जो पहचान के लिए डिफ़ॉल्ट रूप से होता है। )। REPL अब और नहीं है।

Ungolfed (पूर्व संस्करण):

v10001100111011v& x = |^>~
  $       1111111111222222
 1234567890123456789012345

 [read input]
> ~ :a- #v_   $ 21g " "- + 0g , @

v p11:   <
   ↑save chr

0 ←lup   [traverse LUT]
> 1+  :11g  \0g -! #v_
 v                  <
    lup chr acc
v>  :3` #v_  $"0"-\2*+

               v>   . , a,
 v       <
v> 9+9+ 21p $

संपादित करें: @jpjacobs के समाधान से प्रेरित, मैं अब सत्य तालिकाओं का प्रतिनिधित्व करने के लिए LUT में पात्रों की स्थिति पर भरोसा करता हूं। उदाहरण के लिए, |1110 ₂ = 14 की स्थिति में है क्योंकि यह सत्य तालिका से मेल खाती है |।

Comments

वह पागल है। ठीक है, befunge में हर समाधान पागल है।

— जोहान्स कुह्न

Answer 6

जे - ६५ ६ 65-६ = ६१

और नहीं बी। क्रिया विशेषण। फ़ंक्शन के असाइनमेंट की गिनती के बिना: टीएफ संस्करण के लिए 67 अक्षर, गैर-टीएफ संस्करण के लिए 63:

lgcTF =:".@({&('*+-+-<*01',.3 6#'.:')"1@n^:(9>n=:'&|~xv>^FT'&i.)@{.&.>&.;:)
lgc   =:".@({&('*+-+-<*',.3 4#'.:')"1@n^:(7>n=:'&|~xv>^'&i.)@{.&.>&.;:)

LgcTF 0 और 1 दोनों के साथ-साथ T और F को भी संभालता है।

गाड़ियों, कोष्ठक के संदर्भ में J के सभी सिंटैक्स का समर्थन करता है, और बाएं से दाएं (कोई अन्य पूर्वता नियम) कड़ाई से मूल्यांकन करता है।

ऑपरेटर सूची + जेड में नहीं सभी पात्रों का उपयोग नहीं किया जा सकता है, अन्य मानक जे (चर सहित) में कार्य करेंगे।

उपयोग:

NB.Assign TF anyhow
T=:1 [ F=: 0
lgc 'T & F'
0
lgc ' T ~@& F' NB. negation after and = nand
NB. make a truth table
d=: 0 1
lgc 'd ~@|/ d'
1 0
0 0 
NB. and so on... 

Answer 7

पोस्टस्क्रिप्ट 263

जुगनू के विचार का अनुवाद पोस्टस्क्रिप्ट में किया गया।

{(0/xxx)dup 2 3 getinterval(%lineedit)(r)file exch 
readstring pop length 1 sub 3
getinterval(100011001110110v& x = |^> /~)dup
2 index 1 1 getinterval search pop exch pop exch pop 
length 3 2 roll{}forall exch pop exch 2 mul add 159 sub add 
1 getinterval =}loop

इंडेंट:

%!

{
    (0/xxx) dup 2 3 getinterval
    (%lineedit)(r)file exch % (0/xxx) file (xxx)
    readstring pop
    length % (0/xxx) len(x|xx|xxx)
    1 sub 3 getinterval % (0/x)|(/xx)|(xxx)
    (100011001110110v& x = |^> /~) dup
    2 index 1 1 getinterval search pop % (0/x)|(/xx)|(xxx) s post match pre
    exch pop exch pop % (xxx) s pre
    length 
    3 2 roll {} forall exch pop % s len(pre) u_0 u_2
    exch 2 mul add 159 sub add % s ind
    1 getinterval
    = flush
} loop

Answer 8

बेगुंज -93, 86 वर्ण

एई के समन्वय के लिए इनपुट के दूसरे सिंबल हैशिंग (एक ऐसा फंक्शन, जो कॉम्पैक्ट और अवॉइड दोनों तरह का था, कुछ काम का था) काम करता है, और पहले और तीसरे सिंबल को ले कर प्रत्येक मॉडुलो 2 को एक्स कम से कम दो महत्वपूर्ण बिट्स के रूप में समन्वयित करते हैं, फिर संकेतित स्थिति में जो भी मूल्य है, उसे प्राप्त करना। सच तालिकाओं को संग्रहीत / संबोधित करने का एक बेहतर हैश फ़ंक्शन या अधिक कॉम्पैक्ट तरीका केवल दो संभव तरीके हैं जो एक लंबाई में कटौती कर सकता है।

~~~\:8/\5%:++00p2%\2%2*+00gg,@
0 1







1001
0001
1101
1

0
0110



1110
1000


0111