精华内容
下载资源
问答
  • 由真值表逻辑表达式的方法

    万次阅读 多人点赞 2020-02-12 08:59:59
    第一步:从真值表内找输出端为“1”的各行,把每行的输入变量成乘积形式;遇到“0”的输入变量上加非号。 第二步:把各乘积项相加,即得逻辑函数的表达式。 第二种方法:以真值表内输出端“0”为准 第一步:从真值...
    • 第一种方法:以真值表内输出端“1”为准

    第一步:从真值表内找输出端为“1”的各行,把每行的输入变量写成乘积形式;遇到“0”的输入变量上加非号。

    第二步:把各乘积项相加,即得逻辑函数的表达式。

    • 第二种方法:以真值表内输出端“0”为准

    第一步:从真值表内找输出端为“0”的各行,把每行的输入变量写成求和的形式,遇到“1”的输入变量上加非号。

    第二步:把各求和项相乘,即得逻辑函数表达式。

    • 总结,哪种方法得到的表达式简洁就用哪种。
    展开全文
  • 真值表生成逻辑表达式程序

    千次阅读 2013-04-15 12:07:00
    boomhttp://ddd.fit.cvut.cz/prj/BOOM/index... BOOM –QG –Ov in.txt out.txt 逻辑表达式生成真值表http://turner.faculty.swau.edu/mathematics/materialslibrary/truth/ 转载于:https://www.cnblogs.com/mipscp...

    boom http://ddd.fit.cvut.cz/prj/BOOM/index.php?page=main

    BOOM –QG  –Ov in.txt out.txt

    逻辑表达式生成真值表 http://turner.faculty.swau.edu/mathematics/materialslibrary/truth/

    转载于:https://www.cnblogs.com/mipscpu/archive/2013/04/15/3021806.html

    展开全文
  • 才有二叉树做的,用后序法将表达式存储在二叉树中
  • 目的:读入一个逻辑表达式,包含多个变量及各种逻辑运算,输出该逻辑表达式真值表; 思路: 1.与计算多项式的思路一致,利用双栈存储从左到右遍历; 栈具有LIFO的特点,利用栈可以储存离当前操作符最近的符号与...

    目的:读入一个逻辑表达式,包含多个变量及各种逻辑运算,输出该逻辑表达式的真值表;

    思路:

    1.与计算多项式的思路一致,利用双栈存储从左到右遍历;

    栈具有LIFO的特点,利用栈可以储存离当前操作符最近的符号与数据,从左到右遍历,直到最终得出表达式的值;

    2.两个栈一个存储符号,一个存储数据,设置栈内栈外符号位的优先级;

    相同符号栈内优先级大于栈外优先级;

    左括号栈内优先级最高,栈外优先级紧大于‘#’;

    右括号与左括号相反;

    将‘#’优先级设为最低,放入栈底,方便比较并判断终止条件;

    3.每次读入一位,若为数据入数据栈;若为操作符,进行优先级比较

    当栈内运算符优先级大于栈外运算符优先级,执行运算;

    当栈内运算符优先级等于栈外运算符优先级,必为左右括号,弹出左括号;

    当栈内运算符优先级小于栈外运算符优先级,将该符号入栈;

    代码实现:

    #include <iostream>
    #include <iomanip>
    #include <stdio.h>
    #include <stdlib.h>
    #include <cstring>
    #include <algorithm>
    #include <stack>
    #include <map>
    #include <cmath>
    using namespace std;
    int num[10];//按位存储生成的二进制码
    int letter_num;//全局变量存储表达式中变量数目
    map<char,int> m;//用map将字符与数字绑定,方便对应
    char letter[10];//储存所有字符变量
    char relation[256];//储存关系表达式
    int show[100];//记录变量是否出现
    int in[]={3,3,3,3,4,1,5,0};//栈内优先级
    int out[]={2,2,2,2,4,5,1,0};//栈外优先级
    char symbol[]={'^','V','>','<','~','(',')','#'};//储存操作符
    int get(char x);//返回操作符对应下标
    void get_num(int x);//更新按位二进制表示
    int get_letter_num(char *);//统计并储存变量
    char com(char x1,char x2);//比较优先级
    bool if_variable(char x);//判断当前字符是否为变量
    void print_truth_table(char *);//打印真值表
    int figure(int x1,int rel,int x2);//计算基本表达式值
    int main()
    {
        cin>>relation;
        print_truth_table(relation);
        return 0;
    }
    
    
    void print_truth_table(char* top)
    {
        int sum;
        char* y;
        int x,x1,x2;
        char rel;
        stack<int> data;//存储数据
        stack<int> ope;//存储操作符
    /*初始化*/
        memset(show,0,sizeof(show));
        memset(letter,0,sizeof(letter));
        memset(num,0,sizeof(num));
    
        ope.push(get('#'));
        y=top;
        x=get_letter_num(top);
        x=(int)pow(2,x);//对应于2^x数的真值表
    
    
    /*打印表头*/
        for(int i=0;i<=letter_num;i++)
        {
            if(i==letter_num)
            {
                printf("%-10s\n",relation);
                for(int j=0;j<=letter_num;j++)
                    cout<<"----------";
                cout<<endl;
                continue;
            }
            printf("%-10c",letter[i]);
        }
    
    
        while(x--)
        {
            top=y;//保存头指针,每次遍历完需重置
            get_num(x);//更新二进制表示
            int index=ope.top();
            while(*top||index!=7)
            {
                sum=0;
                if(*top=='-')
                    top++;
                if(*top=='~')//取非将4压入操作栈
                {
                    ope.push(4);
                    top++;
                }
                if(*top=='<')//若为等价符另右移两位
                {
                    ope.push(get(*top));
                    top+=3;
                }
                if(if_variable(*top))//压入变量值
                {
                    sum=m[*top];
                    data.push(sum);
                    top++;
                }
                else//符号操作
                {
                    switch(com(symbol[ope.top()], *top))
                    {
                    case 1://'>'
                        if(ope.top()==4)//取反单独计算
                        {
                            x1=data.top();
                            data.pop();
                            x1=(x1+1)%2;
                            data.push(x1);
                            ope.pop();
                            break;
                        }
                        x1=data.top();
                        data.pop();
                        x2=data.top();
                        data.pop();
                        rel=ope.top();
                        ope.pop();
                        data.push(figure(x1,rel,x2));
                        break;
                    case 2://'<'
                        ope.push(get(*top));
                        if(*top)
                            top++;
                        break;
                    case 3://'='
                        ope.pop();
                        if(*top)
                            top++;
                        break;
                    }
                }
                index=ope.top();
            }
    
    /*打印结果*/
            for(int i=0;i<=letter_num;i++)
            {
                if(i==letter_num)
                {
                    printf("%d\n",data.top());
                    data.pop();
                    continue;
                }
                printf("%-10d",num[i]);
            }
        }
        return ;
    }
    
    
    void get_num(int x)
    {
        for(int i=letter_num-1;i>=0;i--)
        {
            num[i]=x%2;
            m.erase(letter[i]);
            m.insert(make_pair(letter[i],num[i]));
            x/=2;
        }
        return ;
    }
    
    int get(char x)
    {
        switch(x)
        {
        case '^':
            return 0;
        case 'V':
            return 1;
        case '>':
            return 2;
        case '<':
            return 3;
        case '~':
            return 4;
        case '(':
            return 5;
        case ')':
            return 6;
        case '#':
            return 7;
        default:
            return 7;
        }
    }
    
    int get_letter_num(char *x)
    {
        letter_num=0;
        while(*x)
        {
            switch(*x)
            {
            case '^':
            case 'V':
            case '>':
            case '<':
            case '(':
            case ')':
            case '#':
            case '-':
            case '~':
                x++;
                break;
            default:
                if(!show[(int)*x])
                {
                    letter[letter_num]=*x;
                    letter_num++;
                    show[(int)*x]=1;
                }
                x++;
                break;
            }
        }
        return letter_num;
    }
    
    char com(char x1,char x2)
    {
        int i1=get(x1);
        int i2=get(x2);
    
        if(in[i1] > out[i2])
            return 1;
        else if(in[i1] < out[i2])
            return 2;
        else
            return 3;
    }
    
    bool if_variable(char x)
    {
        switch(x)
        {
        case '^':
        case 'V':
        case '>':
        case '<':
        case '(':
        case ')':
        case '#':
        case '\0':
            return false;
        default:
            return true;
        }
    }
    
    int figure(int x1,int rel,int x2)
    {
        switch(rel)
        {
        case 0:
            return x1&&x2;//与
        case 1:
            return x1||x2;//或
        case 2:
            return x1||!x2;//蕴含
        case 3:
            return (!x1&&!x2)||(x1&&x2);//等价
        }
        return 0;
    }

    展开全文
  • 逻辑表达式化为真值表

    千次阅读 2014-12-24 10:53:01
    试着了一下,发现自己对栈的应用能力还是不够,不过很感谢 supermary863的博客http://blog.csdn.net/supermary863/article/details/6363570。 然后模仿着把这个离散实验作业完成了。可能存在一些小问题,但是...
    这个处理方法和多项式的处理方法一样。试着写了一下,发现自己对栈的应用能力还是不够,不过很感谢 
    

    supermary863的博客http://blog.csdn.net/supermary863/article/details/6363570。

    然后模仿着把这个离散实验作业完成了。可能存在一些小问题,但是总体思路就是那样吧。

    /*程序设计类似与多项式的计算,用双栈来实现,完成<任意个>变量的表达式的运算*/
    /*变量请统一用小写字母*/
    /*目前支持的逻辑运算符有~(非),V(析取,用大写字母V),^(合取,用shitf + 6), 以及->(蕴含)。
    没有添加<->(只是多添加一个操作符,优先级同->,同理,有兴趣的读者可以自己实现)*/
    /*程序运行方式见main函数入口。*/
    
    
    #include <iostream>
    #include <string>
    #include <cstring>
    #include <cstdio>
    #include <stack>
    using namespace std;
    
    class TrueFalseTable
    {
    protected:
        string read;    //限定表达式变量为小写字母。
        char x[10];     //存储变量。
        int x_num;      //变量数。
        int value[10]; //下标对应变量的值0或1。
        int Ans;    //每行真值表计算一个值。
        /*打印开头部分*/
        void printTitle()
        {
            for(int i = 0; i < x_num; i ++)
            {
                printf("%c\t", x[i]);
            }
            cout << read << endl;
            printf("-------------------------------------------------\n");
        }
        /*检测是否穷举了所有的真值表*/
        bool check_end()
        {
            for(int i = 0; i < x_num; i ++)
            {
                if(value[i] == 0)
                    return false;
            }
            return true;
        }
        /*获得字符对应的当前真值*/
        int getValue(char c)
        {
            for(int i = 0; i < x_num; i ++)
            {
                if(x[i] == c)
                {
                    return value[i];
                }
            }
            return -1;
        }
    public:
        TrueFalseTable() {Ans = 0;}
    
        /*允许用字符串直接初始化表达式*/
        TrueFalseTable(string read)
        {
    		Ans = 0;
            this->read = read;
        }
    
        /*初始化,主要是输入表达式,统计变量个数*/
        void Init()
        {
            if(read == "")
                cin >> read;
            int tmp[27] = {0}, k = 0;
            for (int i = 0; i < read.size(); i ++)
            {
                if(read[i] >= 'a' && read[i] <= 'z')
                {
                    tmp[read[i]-'a'] ++;   //统计出现的字母,即变量个数。
                }
            }
            for(int i = 0; i < 27; i ++)
            {
                if(tmp[i] != 0)
                {
                    x[k++] = i + 'a'; //所有出现字母均保存了。
                }
            }
            x_num = k;
            memset(value, 0, sizeof(value));
            printTitle();
        }
        /*产生下一组变量的真值*/
        bool next_value()
        {
            if(check_end())
                return 0;
            value[x_num - 1] ++;
            for(int i = x_num-1; i >= 0; i --)
            {
                if(value[i] > 1)
                {
                    value[i] = 0;
                    value[i-1] ++;
                }
            }
            return 1;
        }
        /*输出每一行真值表*/
        void printValue()
        {
            for (int i = 0; i < x_num; i ++)
            {
                printf("%d\t", value[i]);
            }
            printf("%d\n", Ans);
        }
    };
    
    
    
    /*因为再写到上面的类就太臃肿了,写一个<子类>
      用于计算表达式的值(双栈)*/
    class Calculate : public TrueFalseTable
    {
    private:
        stack<int> data;    //数据栈
        stack<int> oper;    //符号栈
    public:
        Calculate() {}
        Calculate(string read)
        {
            this->read = read;
        }
        /*计算表达式的值*/
        void calculate()
        {
    		char op[7] = {'~', '>', '^', 'V', '(',')','#'}; //运算符,其中->用>表示。#为栈底。
    		int  in[7] = {5, 3, 3, 3, 1, 6, 0};            //栈内优先级;
    		int  out[7] = {4, 2, 2, 2, 6, 1, 0};           //栈外优先级 < 栈内优先级;
            int a, b, thera;
            oper.push(getIndex('#'));
    		int i = 0;
            int index = oper.top();
            while( i < read.size() || op[index] != '#')
            {
                //遇到表达式中的->, -不读取。
                if(i < read.size() && read[i] == '-')
    			{
    				i++;
                    continue;
    			}
    
                if(i < read.size() && read[i] >= 'a' && read[i] <= 'z')
                {
                    data.push(getValue(read[i]));
    				i ++;
                }
    
                else
                {
                    //遇到~,单独处理。
    				if(oper.top() == 0)
    				{
    					oper.pop();
    					a = data.top();
    					data.pop();
    					a = !a;
    					data.push(a);
    					index = oper.top();
    					continue;
    				}
    				//末尾没有符号来比较,那么直接计算。
                    int readIdx;
    				if(i >= read.size())
    				{
    					readIdx = 5;
    				}
    				else
    				{
    					readIdx = getIndex(read[i]);
    				}
    
                    switch(precede(oper.top(), readIdx))
                    {
                    case '>':
                        a = data.top();
                        data.pop();
    					b = data.top();
    					data.pop();
                        thera = oper.top();
    					oper.pop();
                        data.push(fiture(b, thera, a));
                        break;
                    case '<':
                        oper.push(getIndex(read[i]));
                        if(i < read.size() - 1)
                        {
                            i ++;
                        }
                        break;
                    case '=':
                        oper.pop();
                        if(i < read.size() - 1)
                        {
                            i ++;
                        }
                        break;
                    }
                }
    			//字符串最后为一个右括号,就结束。
    			if(i == read.size() - 1 && oper.top() == 5)
    			{
    				oper.pop();
    				i ++;
    			}
                index = oper.top();
            }
    		Ans = data.top();
    		data.pop();
    		oper.pop();
        }
    private:
        /*获得运算符在数组中的下标*/
        int getIndex(char c)
        {
            switch(c)
            {
            case '~':
                return 0;
            case '>':
                return 1;
            case '^':
                return 2;
            case 'V':
                return 3;
            case '(':
                return 4;
            case ')':
                return 5;
            case '#':
                return 6;
            default:
                return -1;
            }
        }
        /*比较栈内运算符和栈外运算符的优先级*/
        char precede(int i1, int i2)
        {
    //		char op[7] = {'~', '>', '^', 'V', '(',')','#'}; //运算符,其中->用>表示。#为栈底。
    		int  in[7] = {5, 3, 3, 3, 1, 6, 0};            //栈内优先级;
    		int  out[7] = {4, 2, 2, 2, 6, 1, 0};           //栈外优先级 < 栈内优先级;
            if(in[i1] > out[i2])
            {
                return '>';
            }
            else if(in[i1] < out[i2])
            {
                return '<';
            }
            else
            {
                return '=';
            }
        }
    
        int fiture(int a, int ope, int b)
        {
            switch(ope)
            {
            case 0:
                return !a;
            case 1:
                return !a || b;
            case 2:
                return a && b;
            case 3:
                return a || b;
            }
        }
    };
    
    int main()
    {
        Calculate t("(p^~q)V(~p^q)");	//   1、直接在定义类的时候就给表达式。
    //    Calculate t;                      //   2、通过控制台输入表达式。
        t.Init();
        do
        {
            t.calculate();
            t.printValue();
        }
        while(t.next_value());
        return 0;
    }
    



    展开全文
  • 编程实现求解逻辑表达式真值表、主析取范式、主合取范式 一:程序设计思想: 总思想可分为三部分: 1)真值表的求解: 对于一个含n个命题变元的表达式(n为相异的命题变元总个数),其真值表可看作从0到2ⁿ-1的...
  • 最近帮老师改作业,发现同学们交上来的作业里,同一个表达式有好几种写法,被搞得...逻辑表达式中有4中运算符,+,*,#和[] 分别表示或,与,异或,非运算。其中,异或运算不推荐与其他运算混合。如果一定要混合的话,
  • 真值表推出表达式

    2019-06-02 16:33:00
    真值表表达式的化简,想起来似乎不好弄,其实很简单,三步就好: 1:找所有真值为1的情况。 2:用“与”组织输出为1的组合 3:将所有组合用“或”结合 举例: 表达式为: 转载于:...
  • python - 根据表达式打印真值表

    千次阅读 2018-11-03 20:31:34
    输入逻辑表达式,输出真值表,支持六个基本逻辑运算 最终效果:  输入合适公式(没有考虑优先级,只根据括号优先),输出时会提取其中的元素(比如这里有A B C),并打印真值表。  算法思路:  求值的一般...
  • 离散作业,功能是把真值表达式转换成真值表,里面包括表达式转换成逆波兰式,栈的利用
  • 一个电路有三个输入端A,B,C,当其中两个输入端为高电平时,输出X为高电平,试列出真值表,并出X的逻辑表达式。 A B C X 1 1 1 1 1 1 0 1 1 0 1 1 1 0 0 0 0 1 1 1 0 1 0 0 0 0 1 0 0 0 0 ...
  • 逻辑表达式分析器和真值表生成器。 。 运算符使用说明: 连接析取:或 连词:AND 专有析取连接词:XOU 条件连接:-> 双条件连接器:<-> 连接否定连词:~E 连接析取否定:~OU 拒绝:~(只是在字母前面加...
  • 【2018.6.2】今天在看书的时候无意中需要使用... 据说有两种方法,这里都列举一下吧: 方法一: step 1 首先,根据真值表当中结果是true的项,找出它的两个输入项,然后进行与运算;如果遇到输入项的取值是fals...
  • C语言 逻辑表达式

    千次阅读 2019-02-05 09:37:40
    则求解表达式"(x=n1&gt;n2)&amp;&amp;(y=n3&gt;n4)"后,x的和y的分别为多少? main() { int x=1,y=1; int n1=1,n2=2,n3=3,n4=4; int result=0; result=(x=n1&gt;n2)&amp;...
  • 用表格描述所有的软件操作逻辑,用表格描述所有的软件操作逻辑
  • C语言提供三种逻辑表达式,按照运算优先级从高到低依次为:!、&&、||。 注意事项: 系统给出的逻辑运算结果非0即1,不可能是其他数值 逻辑运算符两侧的运算对象可以是数字0、1,也可以是字符型、实型、...
  • 如果不易最简为目的画如下图所示的卡诺圈,经过推到,可以得到含异或的表达式.
  • 逻辑运算符和逻辑表达式详解

    千次阅读 2020-05-20 09:42:55
    逻辑运算符和逻辑表达式 首先,我们思考一个问题: if (fabs(data2) <= 1e - 7)
  • Python:条件判断和逻辑表达式

    千次阅读 2019-04-21 14:38:13
    条件判断和逻辑表达式 (1)逻辑类型bool (2)比较运算符 (3)逻辑运算符 (4)优先级和结合性 逻辑类型bool 运算符求一个关系表达式,应该得到一个运算结果。python中用两个特殊的逻辑对象表示比较的结果...
  • 真值表生成器 用 C# 和 WinForms 编写的真值表生成器/比较器。 它解析逻辑电路中使用的特定符号中的布尔表达式,例如: A + B(C' * D) ^ D' 下面是程序的截图: 我在 2 天内创建了一个有趣的项目,以帮助验证我在...
  • C++逻辑常量和变量 C++的逻辑常量只有两个:false和true,逻辑型变量的定义是用bool,bool...在C++的逻辑表达式中,如果这个逻辑表达式有多个逻辑运算符,则优先级会按照逻辑非->逻辑与->逻辑或,其中逻辑非优先
  • 基本rs触发器真值表

    2020-07-16 11:46:31
    1. RS 触发器真值表 2. 考虑 “ 清零 ” 和 “ 预置 ” 后的 RS 触发器真值表 3. RS触发器的布尔方程: SRT:= S + /R * SRT SRC:= R + /S * SRC
  • 一、算述表达式 优先级高 左结合 赋值表达式 优先级低 右结合 二、关系表达式(比较) 1、关系表达式(左结合): ...成立:命题为(true)为1 不成立:命题为假(false)为0 三、条件表达式(...
  • 简化真值表(根据表绘制电路)

    千次阅读 2021-03-26 23:09:55
    本关任务:根据如下简化真值表出Gt的表达式并绘制电路。 案例场景举例 已知X和Y是两个2位的二进制整数,出判别X>Y的逻辑表达式并绘制逻辑电路。 相关知识 为了完成本关任务,你需要掌握: 1.简化真值表的...
  • java逻辑运算符 真值表

    千次阅读 2017-11-12 15:16:00
    逻辑与 “&&” 逻辑或 “||” 逻辑非 “!” 逻辑异或 “∧” ...逻辑与 ...逻辑或 ...逻辑运算符的真值表 A B A&&B A||B !A A∧B A&B A|B T T T T F F T T T F F T ...
  • 采用逻辑门和MSI模块来进行组合逻辑电路的设计,需要我们根据实验的需求和电路的功能要求,明确输出量与输入量之间的关系,即得到一张真值表(或者是功能表)。根据这张真值表,我们还需要将其转化成逻辑函数,即用...
  • C语言中 &&和||的问题 一篇文章带你读懂逻辑表达式! 一篇文章,带你深刻理解逻辑运算符在表达式中的运算情况
  • 例1: 1!=3>4 运算结果为多少? 结果为: 1 例2: int x; x=100; printf("%d",x>10);...2、关系、逻辑表达式的运算结果是一个逻辑,1(),0(假),不存在其他,它们的可作为算术处理; 3、3>
  • 逻辑运算符和逻辑表达式

    千次阅读 2014-04-14 10:56:36
    逻辑运算符,用来进行逻辑...1为假)“&&”逻辑与,如:a&&b,若a,b均为,刚a&&b为,否则a&&b为假。(也就是a,b中有一个为假,即为假)“||”逻辑或,如a||b,若a,b均为假,则a||b为假,否则a||b为。 (也就
  • 74ls138译码器真值表

    2020-07-15 06:09:30
    本文主要为74ls138译码器真值表,下面一起来学习一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,692
精华内容 40,276
关键字:

由真值表写逻辑表达式