당신이 당신의 학교 교육 년에 다시 기억한다면, 당신은에 대해 배우고 기억할 수있는 진실 테이블 . 그들은 지루해 보였지만 논리의 기초이며 모든 컴퓨팅은 논쟁의 여지가 있습니다 ...

문제

당신의 임무는 당신이 그것을 받아들이기로 선택한다면, 주어진 주어진 진리표를 출력 할 수있는 프로그램, 함수, 또는 코드 위젯을 작성하는 것입니다.

입력

입력은 진리표를 만들 논리 문을 포함하는 문자열 (데이터 구조와 같은)이됩니다. 예를 들면 다음과 같습니다.

p ∧ q

이것은 p and q(논리적 결합)을 의미 하며 다음을 출력합니다 :

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

간격을 확인하십시오. 열의 항목 이 머리글의 중앙에 있습니다.

캐릭터

바이트가 아닌 문자를 통한 점수 논리 비교 문자는 특별하며 항상 모양이 아닙니다. 다음 문자를 사용하십시오.

논리적 연결 (AND) : ∧U + 2227

논리 이탈 (OR) : ∨U + 2228

논리 부정 (NOT) ~또는 ¬U + 7e 및 U + ac

보너스

이 보너스는 모두 선택 사항이지만 점수를 떨어 뜨립니다. 선택하십시오.

논리 부정

논리 부정은 진리표의 단항 연산자입니다. !대부분의 C 기반 언어 와 동일 합니다. 그것은 수 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

규칙

• 표준 허점 적용
• 외부 자원이 없음
• 규칙을 어기려면 영리하십시오.)

가장 짧은 코드 (문자)가 이깁니다. 행운을 빕니다!

자바 스크립트 (ES6), 141

간단한 기능, 보너스 없음, 141 자 (140 uft8, 1 유니 코드 너비)

복잡한 함수 처리 ~ 또는 ¬, 254 자 (253 utf, 1 유니 코드 너비), 점수 229

alert대신에 6 바이트를 절약 할 수 console.log있지만 alert특히 테이블을 표시하기에 적합하지 않습니다.

EcmaScript 6 호환 브라우저에서 아래 스 니펫을 테스트하십시오 (Firefox에서 테스트되었습니다. Chrome은을 지원하지 않으므로 Chrome에서는 작동하지 않습니다 .... 또한 보너스 버전 split은 Firefox에만 해당 되는 확장명을 사용합니다 ).

/* 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>

미디어 위키 템플릿-2347 자

MediaWiki에는 {{#expr}}논리식을 처리 할 수 있는 내장 템플릿 함수 가 있습니다. 이것은 미디어 위키 템플릿에있어 완벽한 도전이어야합니다! 그러나 변수, 루프 및 읽기 쉬운 구문과 같은 기능은 약간 도움이 될 것입니다. 또한 expr 함수에 NOT 연산자가 없다는 사실로 인해 좀 더 복잡해졌습니다.

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

ParserFunctions 확장 기능이 소프트웨어와 함께 제공되는 MediaWiki> = 1.18이라고 가정합니다.

Python-288 자 (+10 페널티로 인해 유니 코드를 사용할 수 없음 : c)

보너스가 없습니다. 이것은 나의 첫 번째 codegolf 답변입니다.

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 입력입니다.

편집 : 몇 개의 공백을 제거하고 이제 함수 인수를 입력으로 사용합니다.

Dyalog APL , 58 48 자

⎕IO←0많은 시스템에서 기본값 인이 필요합니다 . 문자열을 인수로 사용합니다.

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

보너스는 없지만 플러스 측에서는 모든 연산자가 작동합니다.

⍳4 처음 네 지수 (01 2 3)

⌽ 역전 (31 2 0)

2 2⊤ 2 비트 부울 테이블

↓ 두 요소로 구성된 목록 (하위 비트, 하위 비트)으로 분할

p q←p 와 q  로 저장

≢ 그들을 집계 (2) *

9⍴ 주기적으로 길이를 9 (2 2 2 2 2 2 2)로 변경

324⊤⍨ 따라서 324를 따라서, 즉 12 비트 이진 (1 0 0 0 0 0)으로 인코딩한다

\⍨ 그것을 사용하여 확장하십시오 (각 0에 공백을 삽입하십시오) ...

'FT '[... ] 다음에 의해 색인화 된 문자열 "FT"

 ⍎⍵ 실행 인수 ( p 와 q는 이제 값을 가지 므로 유효 합니다)

 ⍪ 그것을 열 행렬로 만드십시오.

 q,q  로 구성된 열 앞에 붙습니다 (1 0 0)

 q,p (  1010)로 구성된 열 앞에 추가

(... )⍪ 로 구성된 위의 행을 삽입하십시오.

 ⍵ 논쟁 거리

 'p q ', 앞에 문자열 "p q"가 붙습니다.

* 로 표시 되고 그렇지 않으면 이 문제에 별표 를 표시하십시오 .≢≢̸≡

줄리아, 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)

언 골프 드 :

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

매스 매 티카, 129 바이트

골프 :

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

언 골프 드 :

(*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 전문가는 아니지만 직접 문자를 비교 해야하는 것과 비교할 때 이것이 우아하다는 것을 알았습니다.

부정에 효과가있는 솔루션이 있었지만 점수를 줄이는 것보다 길었습니다.

예쁜 인쇄의 대상에 따라 그 보너스를 시도 할 수 있습니다. Mathematica에서 ASCII로 출력하는 것이 점수를 줄이려면 너무 비싸지 만 두 가지 주요 기능이 점선 테두리와 셀 안에 지정된 패딩 인 경우 Grid의 몇 가지 옵션입니다.

예쁜 인쇄로 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]

Python3, 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])

기본적으로 유니 코드를 지원하기 위해 Python3이 필요합니다.

DJgamer98 Python 코드를 기반으로 테이블을 계산하는 것이 옳지 않습니다.

Edit1 : 고유 변수로 분할하고 연산자 문자열 변수 생략

편집 2 : (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));

C / C ++ 302 바이트

부정 처리를 위해 10 % 미만인 335 자 불완전한 형식이지만 완성에 미치는 영향을보기 전에 제출하십시오.

내 gcc와 g ++가 -fpermissive로 받아들이고 C ++보다 훨씬 C처럼 보이기 때문에 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");}}

아마도 적용될 수있는 몇 가지 조정이있을 것입니다. 실제로 노트를 처리하면 10 % 이상의 보너스 제거가 추가됩니다.

이것은 입력 형식이 언급 된 바와 같이, 즉 접두사를 포함하거나 포함하지 않는 2 개의 입력 값 (p 및 q), 다른 것은 없으며 모든 토큰이 단일 공백으로 구분된다고 가정합니다.

언 골프 드 :

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;
}

매스 매 티카, 128 자

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

전용 사용 문자 U+F3C7표현은 \[Transpose].

다행히 우리 티카 골퍼, ∧그리고 ∨ 이미 대표 And하고 Or, 우리가해야 할 모든이 매스 매 티카 식으로 입력 문자열을 변환 그래서 우리는 그것을 상징적 인 논리 연산을 수행 할 수 있습니다.

이 솔루션은 Not(¬ ), Implies( ), Equivalent( ⧦), Xor( ⊻), Nand( ⊼), Xor( ⊻) 및 Nor( ⊽)도 처리하지만 ~pMathematica의 구문 오류로 인해 보너스를 얻지 못합니다 . Meh.

설명

b=ToExpression@#

입력 문자열을 Mathematica 표현식으로 변환하여에 저장합니다 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"}

그런 다음 true ( 0<1)를 "T"로 바꾸고 false ( 0>1)를 "F"로 바꾸십시오 .

(...)

행과 열을 교환하십시오.

Grid[...]

결과를로 표시하십시오 Grid.

TraditionalForm@Grid[...]

Grid멋진 기호를 사용하도록를 전통적인 형식으로 변환하십시오 .