Question

Write a program that generates a simple three statement calculator. It should display the following menu:

When an option other than (quit) is selected, it should prompt the user to enter the appropriate number of statement letters (1 for negation ; 2 for everything else). And then it should return the resulting truth column.

It should accept only A, B, C, F, T, R, M where A=[11110000], B= [11001100], C=[10101010], F=[00000000], T=[11111111], and R and M are the current and previous resultants respectively which are both initially [00000000].

The program should continue until quit is selected.

Answer 1

enum Input
{

    A
        {
            @Override
            int[] getArray() {
                return new int[]{1,1,1,1,0,0,0,0};
            }
        },
    B
        {
            @Override
            int[] getArray() {
                return new int[]{1,1,0,0,1,1,0,0};
            }
        },
    C
        {
            @Override
            int[] getArray() {
                return new int[]{1,0,1,0,1,0,1,0};
            }
        },
    F
        {
            @Override
            int[] getArray() {
            return new int[]{0,0,0,0,0,0,0,0};
          }
        },
    T
        {
            @Override
            int[] getArray() {
                return new int[]{1,1,1,1,1,1,1,1};
            }
        };
    abstract int[] getArray();
}
class Propositions
{
    static int[] arr1;
    static int[] arr2;
    static int[] current=new int[]{0,0,0,0,0,0,0,0};
    static int[] prev=new int[]{0,0,0,0,0,0,0,0};
    public static void main(String[] args)
    {
        boolean exitFlag=false;
        Scanner sc=new Scanner(System.in);
        String input1,input2;
        while(!exitFlag)
        {
            System.out.println("Simple propositional calculator\n1.Negation\n2.Conjunction\n3.Disjunction\n4.Implication\n5.Equivalence\n6.Quit");
            int choice=sc.nextInt();
            switch (choice)
            {
                case 1:
                    System.out.println("Enter a number from A,B,C,F,T,R,M:");
                    input1=sc.next();
                    if(input1.equals("R"))
                    {
                        current=negation(current);
                    }
                    else if(input1.equals("M"))
                    {
                        current=negation(prev);
                    }
                    else
                    {
                        current=negation(Input.valueOf(input1).getArray());
                    }
                    prev=current; //for next iteration
                    break;
                case 2:
                    System.out.println("Enter 2 numbers from A,B,C,F,T,R,M:");
                    input1=sc.next();
                    input2=sc.next();
                    assignActualArguments(input1,input2);
                    current=conjunction(arr1,arr2);
                    prev=current; //for next iteration
                    break;
                case 3:
                    System.out.println("Enter 2 numbers from A,B,C,F,T,R,M:");
                    input1=sc.next();
                    input2=sc.next();
                    assignActualArguments(input1,input2);
                    prev=current; //for next iteration
                    break;
                case 4:
                    System.out.println("Enter 2 numbers from A,B,C,F,T,R,M:");
                    input1=sc.next();
                    input2=sc.next();
                    assignActualArguments(input1,input2);
                    prev=current; //for next iteration
                    break;
                case 5:
                    System.out.println("Enter 2 numbers from A,B,C,F,T,R,M:");
                    input1=sc.next();
                    input2=sc.next();
                    assignActualArguments(input1,input2);
                    prev=current; //for next iteration
                    break;
                case 6:
                    exitFlag=true;
                    break;
            }
        }
        sc.close();
    }
    public static int[] negation(int[] arr)
    {
        int[] res=new int[arr.length];
        for(int i=0;i<arr.length;i++)
        {
            res[i]=arr[i]^1;
        }
        System.out.println(Arrays.toString(res));
        return res;
    }
    public static int[] conjunction(int[] arr1,int[] arr2)
    {
        int[] res=new int[arr1.length];
        for(int i=0;i<arr1.length;i++)
        {
            res[i]=arr1[i]|arr2[i]; //bitwise or
        }
        System.out.println(Arrays.toString(res));
        return res;
    }
    public static int[] disjunction(int[] arr1,int[] arr2)
    {
        int[] res=new int[arr1.length];
        for(int i=0;i<arr1.length;i++)
        {
            res[i]=arr1[i]&arr2[i];
        }
        System.out.println(Arrays.toString(res));
        return res;
    }
    public static int[] implication(int[] arr1,int[] arr2)
    {
        int[] res=new int[arr1.length];
        for(int i=0;i<arr1.length;i++)
        {
            res[i]=arr1[i]==1 && arr2[i]==0?0:1; //based on truth table of implication
        }
        System.out.println(Arrays.toString(res));
        return res;
    }
    public static int[] equivalence(int[] arr1,int[] arr2)
    {
        int[] res=new int[arr1.length];
        for(int i=0;i<arr1.length;i++)
        {
            res[i]=(arr1[i]==1 && arr2[i]==1) ||(arr1[i]==0 && arr2[i]==0)?1:0; //based on truth table of equivalence
        }
        System.out.println(Arrays.toString(res));
        return res;
    }
    public static void assignActualArguments(String s1,String s2)
    {
        if(s1.equals("R"))
        {
            arr1=current;
        }
        else if(s1.equals("M"))
        {
            arr1=prev;
        }
        else
        {
            arr1=Input.valueOf(s1).getArray();
        }
        if(s2.equals("R"))
        {
            arr2=current;
        }
        else if(s2.equals("M"))
        {
            arr2=prev;
        }
        else
        {
            arr2=Input.valueOf(s2).getArray();
        }
    }
}