Truth table: Difference between revisions

 

=={{header|11l}}==

String id

Int lbp

print(v.value, end' ‘ ’)

print(‘: ’p.eval())

 

{{out}}

This program runs under CP/M and takes the Boolean expression on the command line.

 

;;; Supported operators:

;;; ~ (not), & (and), | (or), ^ (xor) and => (implies)

vars: equ opstk+256 ; Space for variables

vused: equ vars+256 ; Marks which variables are used

 

{{out}}

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses the Algol 68G specific evaluate procedure to evaluate the Boolean expressions. The expressions must therefore be infix and valid Algol 68 boolean expressions.

# the boolean operators AND, OR, XOR and NOT and the literal values TRUE and FALSE #

# The evaluation is done with the Algol 68G evaluate function which is an extension #

DO

print truth table( expr )

{{out}}

<pre>

rules (unlike normal APL, which evaluates right-to-left).

 

op←⍉↑'~∧∨≠→('(4 3 2 2 1 0)

order←⍬⍬{

hdr←hdr,(' ',⍵,' '),[0.5]'─'

hdr⍪(,∘' '⍣(⊃⊃-/1↓¨⍴¨hdr tab))tab

 

{{out}}

=={{header|BASIC}}==

 

20 DIM V(26),E(255),S(255),C(5),C$(5)

30 FOR I=1 TO 5: READ C$(I),C(I): NEXT

750 IF S(S-1) THEN S(S-1)=S(S) ELSE S(S-1)=-1

760 GOTO 650

 

{{out}}

=={{header|C}}==

{{trans|D}}

#include <string.h>

#include <stdlib.h>

}

return 0;

 

{{output}}

=={{header|C++}}==

{{trans|C}}

#include <stack>

#include <string>

 

return 0;

{{out}}

<pre>Accepts single-character variables (except for 'T' and 'F',

To not make it too complicated, operators are limited to a single character.<br/>

Either postfix or infix expressions are allowed. Infix expressions are converted to postfix.

using System.Collections;

using System.Collections.Generic;

}

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(:require [clojure.string :as s]

[clojure.pprint :as pprint]))

 

(truth-table "! a | b") ;; interpreted as ! (a | b)

{{out}}

<pre>

=={{header|Cowgol}}==

 

# -

# This program will generate a truth table for the Boolean expression

# next configuration

vars := vars + 1;

 

{{out}}

=={{header|D}}==

{{trans|JavaScript}}

 

struct Var {

writefln("%-(%s %) %s", .vars.map!(v => v.name), .expr);

setVariables(0);

{{out}}

<pre>Accepts single-character variables (except for 'T' and 'F',

=={{header|Déjà Vu}}==

{{incorrect|Déjà Vu|User input is not arbitrary but fixed to the three examples shown}}

for v in reversed copy lst:

print\( v chr 9 )

print-truth-table [ "A" "B" ] "A ^ B" @/=

print-truth-table [ "S" "T" "U" ] "S | (T ^ U)" @stu

{{out}}

<pre>A B A ^ B

=={{header|Factor}}==

Postfix is a natural choice. That way, we can use <code>(eval)</code> to to evaluate the expressions without much fuss.

math.combinatorics prettyprint qw sequences splitting

vocabs.parser ;

add-col print-table drop ;

{{out}}

<pre>

=={{header|Go}}==

Expression parsing and evaluation taken from the Arithmetic evaluation task. Operator precedence and association are that of the Go language, and are determined by the library parser. The unary ^ is first, then &, then | and ^ associating left to right. Note also that the symbols &, |, and ^ operate bitwise on integer types in Go, but here since we implement our own evaluator we can apply them to the type of bool.

 

import (

return false, errors.New(fmt.Sprintf("%v unsupported", i))

}

Output:

<pre>

Uses operators "&", "|", "!", "^" (xor), "=>" (implication); all other words are interpreted as variable names.

 

import Data.List (unwords, unlines, nub)

import Data.Maybe (fromJust)

colWidth = max 6 $ maximum $ map length (head tbl)

 

{{Out}}

 

Translation from infix notation to RPN using Parsec:

import Text.Parsec

 

many1 alphaNum

op1 s = (\x -> unwords [x, s]) <$ string s

 

{{Out}}

 

Human Mortal Socratus result

False True False True

False False True True

 

=={{header|J}}==

Implementation:

 

assert. -. 1 e. 'data expr names table' e.&;: y

names=. ~. (#~ _1 <: nc) ;:expr=. y

(names)=. |:data

(' ',;:inv names,<expr),(1+#@>names,<expr)":data,.".expr

 

The argument is expected to be a valid boolean J sentence which, among other things, does not use any of the words used within this implementation (but any single-character name is valid).

Example use:

 

b -.b

0 1

1 0 1 1

1 1 0 1

 

=={{header|Java}}==

{{works with|Java|1.8+}}

This takes an expression from the command line in reverse Polish notation. The supported operators are & | ^ ! and you probably need to escape them so that your shell doesn't interpret them. As an exercise for the reader, you could make it prompt the user for input (which would avoid the escaping issue), or accept infix expressions (see other examples here for how to turn infix into RPN).

import java.util.HashMap;

import java.util.Iterator;

return stack.pop();

}

{{out}}

Note that the escape character is ^ for Windows

=={{header|JavaScript}}==

Actually a HTML document. Save as a .html document and double-click it. You should be fine.

var elem,expr,vars;

function isboolop(chr){return "&|!^".indexOf(chr)!=-1;}

return stack[0];

}

{{Out|Output in browser window after entering "AB^"}}

<pre>A B AB^

=={{header|Julia}}==

'''Module''':

 

using Printf

end

 

 

'''Main''':

TruthTable.@table a | b

TruthTable.@table (a ⊻ b) | (c & a)

TruthTable.@table (a & b) | (c ⊻ d)

 

{{out}}

=={{header|Kotlin}}==

{{trans|D}}

 

import java.util.Stack

setVariables(0)

}

 

{{out}}

This at first seems trivial, given our lovely 'eval' function. However it is complicated by LB's use of 'non-zero' for 'true', and by the requirements of accepting different numbers and names of variables.

My program assumes all space-separated words in the expression$ are either a logic-operator, bracket delimiter, or variable name. Since a truth table for 8 or more variables is of silly length, I regard that as a practical limit.

print

print " TRUTH TABLES"

end if

end function

<pre>

Too_High and Fuel_Out

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

TokenRemoved = StringSplit[data,{"~And~","~Or~","~Xor~","!","(",")"}];

Union[Select[Map[StringTrim,TokenRemoved] , Not[StringMatchQ[#,""]]&]]

Join[List[Flatten[{VariableNames[BooleanEquation],BooleanEquation}]],

Flatten[{#/.Rule[x_,y_] -> y,ReplaceAll[ToExpression[BooleanEquation],#]}]&/@TestDataSet]//Grid

Example usage:

<pre>TruthTable["V ~Xor~ (B ~Xor~ (K ~Xor~ D ) )"]

 

=={{header|Maxima}}==

=, # (not equal), not, and, or

define some more and set 'binding power' (operator

gen_table('(Jim and (Spock xor Bones) or Scotty));

gen_table('(A => (B and A)));

 

OUtput of the last example:

[ V B K D V xor (B xor (K xor D)) ]

[ ]

[ ]

[ false false false false false ]

 

=={{header|Nim}}==

This is an adaptation of Kotlin version, using the same rules and the same algorithm, but with a different representation of expressions. The result is identical.

 

 

# List of possible variables names.

let h = vs.len + expr.formula.len + 2

echo repeat('=', h)

 

{{out}}

 

It would be easy to modify the program to take <code>+</code> for XOR instead.

my(v=List(),x);

while(type(P)=="t_POL",

};

truthTable("x+y") \\ OR

{{out}}

<pre>000

{{trans|C}}

{{works with|Free Pascal}}

program TruthTables;

const

end;

end.

{{out}}

<pre>

=={{header|Perl}}==

Note: can't process stuff like "X xor Y"; "xor" would be treated as a variable name here.

 

sub truth_table {

truth_table 'A ^ A_1';

truth_table 'foo & bar | baz';

A A_1 A ^ A_1

----------------------------------------

=={{header|Phix}}==

Expression parsing and evaluation similar to that in the Arithmetic evaluation task.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">bFT</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span> <span style="color: #000080;font-style:italic;">-- true: use F/T, false: use 0/1, as next</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let Vars

(uniq

(space (if (print (val "V")) 6 4)) )

(println (eval Expr))

Test:

 

 

A B C

NIL NIL NIL NIL

T NIL T T

NIL T T T

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|Any - tested with release 7.6.4}}

To evaluate the truth table a line of text is inputted and then there are three steps

Let's say the expression is:

e(xor,0,0,0). e(xor,0,1,1). e(xor,1,0,1). e(xor,1,1,0).

e(nand,0,0,1). e(nand,0,1,1). e(nand,1,0,1). e(nand,1,1,0).

{{out}}

<pre>

=={{header|Python}}==

This accepts correctly formatted Python boolean expressions.

 

while True:

env = dict(zip(names, values))

print(' '.join(str(v) for v in values), ':', eval(code, env))

 

;Sample output:

=={{header|Quackery}}==

 

[ stack ] is results ( --> s )

[ stack ] is function ( --> s )

results release

function release ] is truthtable ( --> )

 

{{out}}

=={{header|R}}==

 

truth_table <- function(x) {

vars <- unique(unlist(strsplit(x, "[^a-zA-Z]+")))

## 15 FALSE TRUE TRUE TRUE TRUE

## 16 TRUE TRUE TRUE TRUE FALSE

 

=={{header|Racket}}==

Since the requirement is to read an expression dynamically, <tt>eval</tt> is a natural choice. The following isn't trying to protect against bad inputs when doing that.

 

#lang racket

 

(printf "Enter an expression: ")

(truth-table (read))

 

Sample run:

(formerly Perl 6)

{{works with|Rakudo|2016.01}}

 

sub MAIN ($x) {

.join("\t").say for map &fun, flat map { .fmt("\%0{+@n}b").comb».Int».so }, 0 ..^ 2**@n;

say '';

{{out}}

<pre>

::* &nbsp; '''^''' &nbsp; &nbsp; (caret, &nbsp; circumflex, &nbsp; hat)

Also included is support for two boolean values: '''TRUE''' and '''FALSE''' which are part of boolean expressions.

/*─────────────── is supported with one character propositional constants; variables */

/*─────────────── (propositional constants) that are allowed: A──►Z, a──►z except u.*/

/*f*/ when ? == 'TRUE' then return 1

otherwise return -13

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

 

=={{header|Ruby}}==

Uses <code>eval</code>, so blindly trusts the user's input. The core <code>true</code> and <code>false</code> objects understand the methods <code>&</code> (and), <code>|</code> (or), <code>!</code> (not) and <code>^</code> (xor) -- [http://www.ruby-doc.org/core-1.9.2/TrueClass.html]

print "\ninput a boolean expression (e.g. 'a & b'): "

expr = gets.strip.downcase

 

eval (prefix + [body] + suffix).join("\n")

 

Example

Extending the set of implemented operators should be almost trivial without any change of the logically more complex parts.

 

collections::HashMap,

fmt::{Display, Formatter},

}

}

 

{{out}}

{{trans|Ruby}}

A simple solution which accepts arbitrary user-input:

var expr = Sys.readln("\nBoolean expression (e.g. 'a & b'): ").strip.lc

break if expr.is_empty;

var body = ("say (" + vars.map{|v| v+",'\t'," }.join + " '| ', #{expr})")

eval(prefix + [body] + suffix -> join("\n"))

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

expr := Stdin

request:'Enter boolean expression (name variables a,b,c...):'

].

 

{{out}}

<pre>Enter boolean expression (name variables a,b,c...): [[a|b]]:

 

=={{header|Tcl}}==

 

puts -nonewline "Enter a boolean expression: "

 

puts [join $vars \t]\tResult

Sample run:

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>!!!T

{{libheader|Wren-seq}}

{{libheader|Wren-str}}

import "/ioutil" for Input

import "/seq" for Stack

System.print("=" * h)

setVariables.call(0)

 

{{out}}

{{trans|C}}

{{works with|Windows XBasic}}

PROGRAM "truthtables"

VERSION "0.001"

END FUNCTION

END PROGRAM

{{out}}

<pre>