यदि आप अपने स्कूल के वर्षों को याद करते हैं, तो आप ट्रू टेबल्स के बारे में सीखना याद रख सकते हैं । वे उबाऊ लग रहे थे, लेकिन वे तर्क के लिए आधार हैं और (कुछ बहस करेंगे) सभी कंप्यूटिंग ...

मुसीबत

आपका मिशन, क्या आपको यह स्वीकार करना चाहिए कि यह एक प्रोग्राम, फ़ंक्शन, या कोड के विजेट को लिखना है जो किसी दिए गए ट्रुथ टेबल को इनपुट कर सकता है।

इनपुट

ट्रुथ ट्रुथ (डेटा संरचना की तरह) लॉजिक स्टेटमेंट बनाने के लिए लॉजिक स्टेटमेंट होगा। उदाहरण के लिए:

p ∧ q

इसका मतलब है p and q(तार्किक संयोजन) और आउटपुट होगा:

 p  q  p ∧ q
 T  T    T
 T  F    F
 F  T    F
 F  F    F

स्पेसिंग को नोटिस करें: कॉलम का आइटम हेडर के केंद्र में है

पात्र

पात्रों के माध्यम से स्कोर, बाइट्स नहीं । तर्क तुलना वर्ण विशेष होते हैं और हमेशा वे जो दिखते हैं वह नहीं। इन वर्णों का उपयोग करें:

तार्किक संयोजन (और): ∧U + 2227

तार्किक विघटन (OR): ∨U + 2228

तार्किक नकारात्मक (नहीं) ~या ¬U + 7e और U + एसी क्रमशः

बोनस

ये सभी बोनस वैकल्पिक हैं, लेकिन आपके स्कोर को अंक देंगे। कोई भी उठाओ।

तार्किक नकारात्मकता

लॉजिकल नेगेटिव सत्य तालिकाओं में एक अपर संचालक है। यह !अधिकांश सी-आधारित भाषाओं में बराबर है । यह false=> trueऔर वाइस वर्सा बनाता है । यह एक ¬ या ~ (आप दोनों का समर्थन करना चाहिए) के साथ अंकित नहीं है । इसका समर्थन करने से आपके स्कोर का 10% बंद हो जाएगा। हालाँकि, आपको इसके परिणाम दिखाने के लिए एक अतिरिक्त कॉलम जोड़ना होगा: उदाहरण के लिए:

~p ∧ q

उत्पादन होगा:

p  ~p  q  ~p ∧ q
T  F   T     F
T  F   F     F
F  T   T     T
F  T   F     F

सुंदर प्रिंट

सामान्य टेबल नोटेशन उबाऊ है। चलो इसे सुंदर बनाते हैं! सुंदर प्रिंट प्रारूप इस p ∧ qप्रकार है:

+---+---+-------+
| p | q | p ∧ q |
+---+---+-------+
| T | T |   T   |
+---+---+-------+
| T | F |   F   |
+---+---+-------+
| F | T |   F   |
+---+---+-------+
| F | F |   F   |
+---+---+-------+

सुंदर मुद्रण के लिए विशेष विवरण:

प्रत्येक सेल में 1 स्पेस पैडिंग है
सेल वैल्यू अभी भी केंद्रित हैं

यदि आप अपने कोड से अपने टेबल को सुंदर प्रिंट करते हैं, और फिर 0.6 से गुणा करें। इस बोनस के लिए इस फ़ंक्शन का उपयोग करें:

score = 0.6 * code

उदाहरण

p ∧ q:

p  q  p ∧ q
T  T    T
T  F    F
F  T    F
F  F    F

p ∨ q:

p  q  p ∨ q
T  T    T
T  F    T
F  T    T
F  F    F

~p ∧ q:

p  ~p  q  ~p ∧ q
T   F  T     F
T   F  F     F
F   T  T     T
F   T  F     F

~p ∨ q:

p  ~p  q  ~p ∧ q
T   F  T     T
T   F  F     F
F   T  T     T
F   T  F     T

नियम

मानक खामियां लागू होती हैं
कोई बाहरी संसाधन नहीं
यदि आप नियम तोड़ने जा रहे हैं, तो चतुर हो;)

सबसे छोटा कोड (वर्णों में) जीतता है। शुभ लाभ!

code-golf ascii-art logic-gates

— MayorMonty
स्रोत

4

विवरण से ऐसा लगता है कि ये मनमाने ढंग से बूलियन शब्द थे। लेकिन सभी उदाहरणों (बोनस के बिना) में केवल एक ऑपरेटर होता है। क्या यह एक ही ऑपरेटर के लिए प्रतिबंधित है? इसके अलावा, उदाहरणों में मूल्यों के नाम सभी हैं pऔर q। जब तक उनके पास हमेशा ये नाम नहीं होंगे, आप परीक्षण के उदाहरणों में कुछ अलग विकल्प दिखाना चाह सकते हैं। क्या वे हमेशा एक ही अक्षर हैं?

— रेटो कोराडी

2

चूंकि यह गैर-एएससीआईआई पात्रों का उपयोग करता है, इसलिए यह निर्दिष्ट करना अच्छा हो सकता है कि कोड की लंबाई वर्ण या बाइट्स में गिना जाता है। यदि यह बाइट्स है, तो यह जानना उपयोगी होगा कि यूनिकोड वर्ण कितने बाइट्स का उपयोग करता है।

— रेटो कोराडी

सरलीकृत :)। score = 0.6 * (code - 15)=.6 * code - 9

— mınxomaτ

@RetoKoradi बदल गया। पात्रों द्वारा स्कोर, बाइट्स नहीं

— मेयरमोनी

@RetoKoradi अगर मेरी ज्यामिति शिक्षक मुझसे कहते हैं कि आप सही हैं तो आप कभी भी अधिक p qऔर rसत्य तालिका में नहीं देखेंगे ;)

— मेयोरमोनी

6

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

सरल कार्य, कोई बोनस नहीं, 141 चार्ट। (140 uft8, 1 यूनिकोड चौड़ा)

जटिल फ़ंक्शन हैंडलिंग ~ या ¬, 254 वर्ण (253 utf, 1 यूनिकोड चौड़ा), स्कोर 229

के alertबजाय 6 बाइट्स बचा सकता है console.log, लेकिन alertविशेष रूप से टेबल प्रदर्शित करने के लिए अयोग्य है।

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे दिए गए स्निपेट का परीक्षण करें (फ़ायरफ़ॉक्स के साथ परीक्षण किया गया। क्रोम में काम नहीं करेगा क्योंकि यह समर्थन नहीं करता है ...। इसके अलावा, बोनस संस्करण का विस्तार splitफ़ायरफ़ॉक्स विशिष्ट का उपयोग करता है)।

/* TEST: redirect console.log into the snippet body */ console.log=x=>O.innerHTML+=x+'\n'

// Simple
F=s=>{[a,o,b]=[...s],z='  ',r=a+z+b+z+a+` ${o} ${b}
`;for(w='FT',n=4;n--;r+=w[c]+z+w[e]+z+z+w[o<'∧'?c|e:c&e]+`
`)c=n&1,e=n>>1;console.log(r)}

// Simple, more readable
f=s=>{
   [a,o,b]=[...s]
   r=a+'  '+b+'  '+a+` ${o} ${b}\n`
   for(w='FT',n=4; n--; )
   {
     c = n&1, e = n>>1, x=o<'∧' ? c|e : c&e
     r += w[c]+'  '+w[e]+'    '+w[x]+'\n'
   }
   console.log(r)
}

// 10% Bonus
B=s=>{[a,o,b]=s.split(/([∧∨])/),t=a>'z',u=b>'z',z='  ',r=(t?a[1]+z:'')+a+z+(u?b[1]+z:'')+b+z+a+` ${o} ${b}
`;for(s=v=>'FT'[v]+z,n=4;n--;r+=s(c)+(t?s(d)+' ':'')+s(e)+(u?s(f)+' ':'')+(t?'   ':z)+s(o<'∧'?d|f:d&f)+`
`)c=n&1,d=c^t,e=n>>1,f=e^u;console.log(r)}

Test1 = ['q∨p','q∧p']
Test2 = Test1.concat([
  '~q∨p','q∨~p','~q∨~p','~q∧p','q∧~p','~q∧~p',
  '¬q∨p','q∨¬p','¬q∨¬p','¬q∧p','q∧¬p','¬q∧¬p'
])


console.log('SIMPLE')
Test1.forEach(t=>F(t));

console.log('BONUS')
Test2.forEach(t=>B(t));

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

1

+1, मुझे जावास्क्रिप्ट पसंद है और यह समाधान एक उत्थान के योग्य है।

— अर्जुन

जावास्क्रिप्ट मेरी मूल भाषा है, लेकिन मैं इसे प्रभावित नहीं होने दूंगा! : डी गुड जॉब!

— मेयरमोनी

6

मीडियाविकि टेम्पलेट - २३४ characters अक्षर

MediaWiki में एक अंतर्निहित टेम्प्लेट फ़ंक्शन होता है जिसे {{#expr}}लॉजिकल एक्सप्रेशन कहते हैं। MediaWiki टेम्प्लेट के लिए यह सही चुनौती होनी चाहिए! हालांकि चर, लूप और एक पठनीय वाक्यविन्यास जैसी सुविधाओं ने थोड़ी मदद की होगी। इसके अलावा, इस तथ्य के लिए कि एक्सपायर फ़ंक्शन के लिए कोई ऑपरेटर नहीं है, इसे थोड़ा और अधिक जटिल बना दिया।

{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}} {{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}} {{{1}}}<br>T T &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|0|1}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|0|1}}|0|1}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}<br>T F &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|0|1}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|1|0}}|1|0}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}<br>F T &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|1|0}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|0|1}}|0|1}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}<br>F F &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|1|0}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|1|0}}|1|0}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}

परीक्षा:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

परिणाम:

X Y ¬X ∧ ~Y
T T    F
T F    F
F T    F
F F    T

p q p ∨ q
T T   T
T F   T
F T   T
F F   F

मैं MediaWiki> = 1.18 मान रहा हूं, जहां ParserFunctions एक्सटेंशन सॉफ्टवेयर के साथ बंडल में आते हैं।

— लियो
स्रोत

2

प्रोग्रामिंग और कोड गोल्फ में आपका स्वागत है। MediaWiki का उपयोग करना कुछ ऐसा नहीं है जिसके बारे में मैंने सोचा होगा; +1। हालाँकि, ¬/ ~ऑपरेटर का अतिरिक्त स्तंभ व्यवहार अनुपलब्ध है; यदि आप इसे जोड़ते हैं, तो आप एक 10%बोनस के लिए अर्हता प्राप्त करेंगे ।

— wizzwizz4

मुझे बस एहसास हुआ कि, जब तक कि मैं नेस्टेड टेम्पलेट का उपयोग नहीं कर सकता (जो कि नियमों को बहुत दूर खींच सकता है?), ठीक से उस कॉलम को जोड़ने से वास्तव में चरित्र की गिनती बढ़ जाएगी ... :)

— leo

किस मामले में, आपको शायद नकारात्मक समर्थन को हटा देना चाहिए, क्योंकि आपको इसके लिए कोई बोनस नहीं मिल रहा है।

— wizzwizz4

हाँ, इस पर गौर करेंगे। मुझे नहीं लगता कि अंतिम रैंकिंग पर इसका बहुत असर पड़ेगा, हालांकि ...: D

— leo

1

@ येलो यह बहुत अच्छा है, और मुझे लगता है कि नेस्टेड टेम्प्लेट का उपयोग करना ठीक होगा यदि आप सिर्फ उन दोनों के चरित्र की गिनती जोड़ते हैं, जो आजकल स्वीकृत अभ्यास लगता है।

— हैरी

4

पायथन - 288 अक्षर (+10 दंड का कारण मुझे काम करने के लिए यूनिकोड नहीं मिल सकता है: c)

कोई बोनस नहीं। यह मेरा पहला कोडगोल्फ जवाब है।

def f(i):
    i=i.split(" ")
    print i[0],i[2],
    for f in i[0:3]: print f,
    print ""
    for t in["TT","TF","FT","FF"]:
        p,q=t[0],t[1]
        y = t[0]+" "+t[1]
        if i[1]=="^": r=(False,True)[p==q]
        if i[1]=="v": r=(False,True)[p!=q]
        if r: y+="   T"
        else: y+="   F"
        print y

i इनपुट है

संपादित करें: कुछ रिक्त स्थान हटा दिए गए हैं और यह अब इनपुट के रूप में फ़ंक्शन आर्ग का उपयोग करता है।

— DJgamer98
स्रोत

1

PP & CG में आपका स्वागत है! कृपया नियम के अनुसार अपना कोड नियमों का पालन करना सुनिश्चित करें। नियम विनिर्देश के रूप में, आपका कोड एक फ़ंक्शन, पूर्ण प्रोग्राम या बिट कोड होना चाहिए। इसका मतलब है कि इनपुट जरूरी होना चाहिए या फ़ंक्शन तर्क (या समतुल्य) हैप्पी कोडिंग!

— मेयरमोनी

3

दिल्लोग एपीएल , 58 ४ , अक्षर

आवश्यकता है ⎕IO←0, जो कई प्रणालियों पर डिफ़ॉल्ट है। तर्क के रूप में स्ट्रिंग लेता है।

{('p q ',⍵)⍪'FT '[p,q,⍪⍎⍵]\⍨324⊤⍨9⍴≢p q←↓2 2⊤⌽⍳4}

कोई बोनस नहीं, लेकिन प्लस साइड पर, कोई भी ऑपरेटर काम करता है।

⍳4 पहले चार सूचकांक (0 1 2 3)

⌽ रिवर्स (3 2 1 0)

2 2⊤ दो-बिट बूलियन तालिका

↓ सूचियों के दो-तत्व सूची (उच्च-बिट्स, निम्न-बिट्स) में विभाजित करें

p q←पी और क्यू के रूप में स्टोर करें

≢ उन्हें टैली (2) *

9⍴ चक्रीय रूप से 9 की लंबाई (2 2 2 2 2 2 2 2 2 2) को पुनः आकार दें

324⊤⍨ इसी तरह से 324 एनकोड करें, यानी 12-बिट बाइनरी (1 0 1 0 0 0 1 1 0 0)

\⍨ का उपयोग करने के लिए विस्तार (प्रत्येक 0 के लिए एक स्थान डालें) ...

'FT '[... ] स्ट्रिंग "एफटी", द्वारा अनुक्रमित

⍎⍵ निष्पादित तर्क ( पी और क्यू के बाद से मान्य अब मूल्य हैं)

⍪ इसे एक कॉलम मैट्रिक्स में बनाएं

q,q (1 1 0 0) से युक्त कॉलम को प्रिपेंड करें

q,पी (1 0 1 0) से मिलकर एक कॉलम तैयार करना

(... )⍪ ऊपर एक पंक्ति सम्मिलित करें, जिसमें शामिल है

⍵ बहस

'p q ', स्ट्रिंग "पी क्यू" के साथ तैयार किया गया

* स्टार कृपया इस मुद्दे यदि आप देखते हैं ≢के रूप में ≢और नहीं के रूप में ̸≡।

— एडम
स्रोत

2

जूलिया, 161 बाइट्स

कोई बोनस नहीं।

s->(S=split(s);P=println;p=S[1];q=S[3];a=[&,|][(S[2]=="∨")+1];c="  ";P(p,c,q,c,s);for t=["TT","TF","FT","FF"] P(t[1],c,t[2],c^2,"FT"[a(t[1]>'F',t[2]>'F')+1])end)

Ungolfed:

function f(s::String)
    # Split the input on spaces
    S = split(s)

    # Separate out the pieces of the statement
    p = S[1]
    q = S[3]
    a = [&, |][(S[2] == "∨") + 1]

    # Print the header
    println(p, "  ", q, "  ", s)

    # Create the table entries in a loop
    for t = ["TT", "TF", "FT", "FF"]
        println(t[1], "  ", t[2], "    ", "FT"[a(t[1] > 'F', t[2] > 'F') + 1])
    end
end

— एलेक्स ए।
स्रोत

1

गणितज्ञ, 129 बाइट्स

golfed:

t=InputString[];s=Append[StringCases[t,LetterCharacter],t];Grid[Prepend[Map[If[#,"T","F"]&,BooleanTable[ToExpression[s]],{2}],s]]

Ungolfed:

(*Take input*)
t=InputString[];
(* Find all occurrences of letters and append the final statement.*)
s=Append[StringCases[t,LetterCharacter],t];
(* Evaluate the list as expressions and create a boolean table of True/False values, then display as a table. *)
(* To satisfy the output conditions, we must convert each True/False to T/F *)
Grid[Prepend[Map[If[#,"T","F"]&,BooleanTable[ToExpression[s]],{2}],s]]

मैथेमेटिका विशेषज्ञ नहीं, लेकिन मैंने इसे प्रत्यक्ष चरित्र तुलना करने के बजाय सुरुचिपूर्ण पाया।

मेरे पास एक समाधान था जो नकारात्मकता के लिए काम करता था, लेकिन यह स्कोर की कमी से दूर था।

सुंदर छपाई के लिए जो योग्य है, उसके आधार पर, मैं उस बोनस के लिए प्रयास कर सकता हूं। मुझे लगता है कि Mathematica में ASCII में आउटपुट देना क्षतिपूर्ति के लिए स्कोर में कमी के लिए बहुत महंगा होगा, लेकिन अगर दो मुख्य विशेषताएं एक बिंदीदार सीमा और कोशिकाओं के अंदर निर्दिष्ट पैडिंग हैं, तो यह ग्रिड में केवल कुछ विकल्प हैं।

सुंदर छपाई के साथ, 171 * 0.6 = 102.6 बाइट्स

t=InputString[];s=Append[StringCases[t,LetterCharacter],t];Grid[Prepend[Map[If[#,"T","F"]&,BooleanTable[ToExpression[s]],{2}],s],Spacings->1,Frame->All,FrameStyle->Dashed]

— Xanderhall
स्रोत

1

पायथन 3, 145 139 120 119 बाइट्स

कोई बोनस नहीं (अंत में बोनस के साथ)

 def f(s):
 a,m,b=s.split(" ");print(a,b,s);F,T,c=0,1,"FT"
 for p in c:
  for q in c:print(p,q," ",c[eval(p+"+*"[m=="∧"]+q)>0])

बॉक्स से बाहर यूनिकोड समर्थन के लिए पायथन 3 की आवश्यकता है।

DJgamer98 Python कोड के आधार पर, उसकी तालिका का पता लगाना सही नहीं है।

Edit1: अलग-अलग चर में विभाजित करना और ऑपरेटर स्ट्रिंग चर को समझना

Edit2: (ab) F और T दोनों चर और स्ट्रिंग वर्णों के रूप में उपयोग करते हैं

Edit3: NoOneIsHere के लिए एक स्थान की बचत

बोनस के साथ, 215 * 0.6 = 129

def f(s):
 r="+---"*3+"----+"
 a,m,b=s.split(" ");F,T,c=0,1,"FT"
 print("%s\n| %s | %s | %s |\n%s"%(r,a,b,s,r));
 for p in c:
  for q in c: print("| %s | %s |   %s   |\n%s"%(p,q,c[eval(p+"+*"[m=="∧"]+q)>0],r));

— कार्ल नेफ
स्रोत

PPCG में आपका स्वागत है! आप बाद में स्थान को हटाकर एक बाइट बचा सकते हैं q in c:।

— NoOneIsHere

Edit2: यह दुरुपयोग नहीं है। यहां देखें , जहां मैं फ़ाइल सामग्री के पहले चरित्र को फ़ाइल नाम के रूप में उपयोग करता हूं!

— एडम

1

सी / सी ++ 302 बाइट्स

नकार से निपटने के लिए 335 अक्षर कम 10%। अपूर्ण प्रारूपण लेकिन प्रस्तुत करने से पहले मैं देखता हूं कि पूरा होने का प्रभाव क्या है।

C / C ++ के रूप में चिह्नित किया गया क्योंकि मेरा gcc और g ++ इसे -fpermissive के साथ स्वीकार करता है और यह C ++ की तुलना में कहीं अधिक C जैसा दिखता है।

#include <stdio.h>
void T(char*S) { int (*P)(char*,...)=printf;char*v[2]={"F","T"};for(int m=4;m--;){P("|");char*s=S;int x=m&1;X:P(" %s |",v[x]);if(*++s!=' '){x=x^1;goto X;}char*o=++s;s+=3;int y=(m>>1)&1;Y:P(" %s |",v[y]);if(*++s){y=y^1;goto Y;}int g;for(g=o-S+1;g--;)P(" ");P(*++o==39?v[x&y]:v[x|y]);for(g=s-o;g--;)P(" ");P("|\n");}}

मुझे यकीन है कि वहाँ शायद कुछ tweaks कि लागू किया जा सकता है। वास्तव में नॉट्स को संभालने से 10% से अधिक बोनस जुड़ जाता है।

यह मान लेता है कि इनपुट प्रारूप जैसा कि कहा गया है, यानी 2 इनपुट वैल्यू (पी और क्यू), उपसर्ग के बिना या बिना और कुछ नहीं, और सभी टोकन एक ही स्थान द्वारा सीमांकित।

Ungolfed:

void ungolfed(char* S)
{
   int (*P)(char*,...) = printf;         // useful lookup stuff
   char* v[2] = {"F","T"};

   for(int m = 4; m--;) {                // loop over all 2 bit bit patterns (truth table inputs)

      P("|");                            // start of line format
      char* s=S;                         // iterator to start of equation for each bit pattern

      int x = m&1;                       // input 1 (aka. p which I called x here to be awkward)
X:    P(" %s |",v[x]);                   // input 1 output and format

      if(*++s!=' ') {                    // if next character is not a space then input must be prefixed with the not character
         x=x^1;                          // so negate the input
         goto X;                         // and redo input 1 output
      }

      char* o = ++s;                     // remember where the operator is
      s+=3;                              // and skip it and following space

      int y = (m>>1)&1;                  // input 2 (aka. q which I called y obviously) processing as for input 1
Y:    P(" %s |",v[y]);

      if(*++s) {
         y=y^1;
         goto Y;
      }

      int g;

      for(g=o-S+1;g--;) P(" ");         // pre-result value padding

      P(*++o==39?v[x&y]:v[x|y]);      // result

      for(g=s-o;g--;) P(" ");           // post-result value padding and format
      P("|\n");
   }
}

और परीक्षण:

int main()
{
   T("p \x22\x27 q");  // p & q
   puts("");

   T("p \x22\x28 q");  // p | q
   puts("");

   T("\x7ep \x22\x27 q");  // ~p & q
   puts("");

   T("\xacp \x22\x28 q");  // ~p | q
   puts("");

   T("p \x22\x28 \xacq");  // p | ~q
   puts("");

   return 0;
}

— original.legin
स्रोत

0

गणितज्ञ, 128 वर्ण

TraditionalForm@Grid[({#}~Join~BooleanTable[#,Cases[b,_Symbol,{0,∞}]]&/@Cases[b=ToExpression@#,_,{0,∞}]/.{0<1->"T",0>1->"F"})]&

निजी उपयोग चरित्र का U+F3C7प्रतिनिधित्व करता है \[Transpose]।

सौभाग्य से हमारे लिए Mathematica golfers, ∧और ∨ पहले से ही प्रतिनिधित्व करते हैं Andऔर Orइसलिए, हमें बस इतना करना है कि input string को Mathematica अभिव्यक्ति में बदल दें और हम इस पर प्रतीकात्मक तार्किक संचालन कर सकते हैं।

ध्यान दें कि यह समाधान भी Not( ¬), Implies( ), Equivalent( ⧦), Xor( ⊻), Nand( ⊼), Xor( ⊻), और Nor( ⊽) को संभाल लेगा , लेकिन यह बोनस नहीं मिलता है क्योंकि ~pमैथमेटिका में एक वाक्यविन्यास त्रुटि है। भावहीन।

व्याख्या

b=ToExpression@#

इनपुट स्ट्रिंग को एक मैथेमैटिका अभिव्यक्ति में परिवर्तित करता है और इसे स्टोर करता है b।

Cases[b=ToExpression@#,_,{0,∞}]

यह इनपुट की हर संभव उपसंचालन सूची है। प्रत्येक को अपना कॉलम मिलेगा।

Cases[b,_Symbol,{0,∞}]

यह उन सभी चरों की सूची है जो इनपुट में दिखाई देते हैं।

BooleanTable[#,Cases[b,_Symbol,{0,∞}]]&

शुद्ध फ़ंक्शन जो एक इनपुट अभिव्यक्ति लेता है #और चर के लिए सत्य मूल्यों के सभी संभावित संयोजनों के लिए सत्य मूल्यों की एक सूची देता है।

{#}~Join~BooleanTable[...]

इस सूची में अभिव्यक्ति को ही प्रस्तुत करता है।

.../@Cases[b=ToExpression@#,_,{0,∞}]

इस फ़ंक्शन को इनपुट के प्रत्येक सबडिप्रेशन पर लागू करता है।

.../.{0<1->"T",0>1->"F"}

फिर सच्चे ( 0<1) को "T" और झूठे ( 0>1) को "F" से बदलें ।

(...)

इंटरचेंज रो और कॉलम।

Grid[...]

परिणाम को ए के रूप में प्रदर्शित करें Grid।

TraditionalForm@Grid[...]

Gridपारंपरिक रूप में परिवर्तित करें ताकि यह फैंसी प्रतीकों का उपयोग करे।

— ngenisis
स्रोत

ट्रुथ टेबल्स: आपके परदादा का कंप्यूटर

मुसीबत

इनपुट

पात्र

बोनस

तार्किक नकारात्मकता

सुंदर प्रिंट

उदाहरण

नियम

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

मीडियाविकि टेम्पलेट - २३४ characters अक्षर

पायथन - 288 अक्षर (+10 दंड का कारण मुझे काम करने के लिए यूनिकोड नहीं मिल सकता है: c)

दिल्लोग एपीएल , 58 ४ , अक्षर

जूलिया, 161 बाइट्स

गणितज्ञ, 129 बाइट्स

पायथन 3, 145 139 120 119 बाइट्स

बोनस के साथ, 215 * 0.6 = 129

सी / सी ++ 302 बाइट्स

गणितज्ञ, 128 वर्ण

व्याख्या