精华内容
下载资源
问答
  • 真值表生成逻辑表达式程序

    千次阅读 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

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

    千次阅读 2014-12-24 10:53:01
    这个处理方法和多项式的处理方法一样。试着写了一下,发现自己对栈的应用能力还是不够,不过很感谢 ... 然后模仿着把这个离散实验作业完成了。.../*程序设计类似与多项式的计算,用双栈来实现,完成变量的表达式
    这个处理方法和多项式的处理方法一样。试着写了一下,发现自己对栈的应用能力还是不够,不过很感谢 
    

    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的...

    离散数学

    编程实现求解逻辑表达式的真值表、主析取范式、主合取范式

    一:程序设计思想:

    总思想可分为三部分:
    1)真值表的求解:
    对于一个含n个命题变元的表达式(n为相异的命题变元总个数),其真值表可看作由从0到2ⁿ-1的二进制数的变化表。因此,可以通过按行列举0到2ⁿ-1的二进制数来模拟真值表中命题变元的值。而对于表达式,在每一行,其值可通过运用该行的命题变元的值来求解。为此,应考虑:
    ①建立命题变元与0/1的键值对关系。可通过C++:stl::map来建立。
    ②理解表达式并求值。
    2) 表达式求解:
    对于表达式,应考虑:
    ①定义各个运算符的运算法则。
    ②定义各个运算符的优先级关系。
    求解:
    在求解表达式的过程中,可利用两个栈,分别存入临时读取的命题变元的值和逻辑运算符。在依次读取表达式的过程中,通过比较运算符的优先级关系,边读取边运算,并将值存入储存值的栈中。最终,读取完毕,求解完成。储存值的栈的栈顶即为逻辑表达式的值。
    3)求解主合取范式、主取范式:
    主合取范式: 与1)中思想类似,在输出真值表的过程中,若某行的表达式的值为0,通过该行的map中的键值对关系,按照相应的格式,将命题变元或其否定存入主合取范式的字符串中。
    同理,
    主析取范式:在输出真值表的过程中,若某行的表达式的值为1,通过该行的map中的键值对关系,按照相应的格式,将命题变元或其否定存入主析取范式的字符串中。
    最后,一并输出两个字符串即可。

    二:程序源码:

    #include<string>
    #include<vector>
    #include<map>
    #include<stack>
    #include<iostream>
    #include<algorithm>
    
    using namespace std;
    
    // fun1: (十进制转换为二进制) 赋真值 
    void fun1( int x,  map <char,int>& m){
    	auto p = --m.end();//由于map升序排列,用迭代器p指向map的末尾 
    	for(int i = 1; i <= distance( m.begin(), m.end()); i ++){
    		p->second = x % 2;
    		x = x / 2;
    		p --;
    	}
    }
    
    //compare:用于描述运算符之间的优先级关系 
    int compare( char a, char b){
    	if(a == '!') {
    		if( b == '(') return -1;
    		else if(b == '!') return 0;
    		else return 1;
    	}
    	
    	else if(a == '@' ){
    		if((b == '(' || b == '!')) return -1;
    		else return 1;
    	}
    	
    	else if(a == '#') {
    		if((b == '@'|| b == '(' || b == '!')) return -1;
    		else return 1;
    	}
    	else if(a == '$' ){
    		if((b == '@'|| b == '(' || b == '#' || b == '!')) return -1;
    		else return 1;	
    	}
    	else if(a == '%'){
    		if(( b == '%' || b == ')')) return 1;
    		else return -1;
    	} 
    	else if(a == '(' ){
    		if(b == ')') return 0;
    		else return -1;
    	}
    }
    
    //value:定义运算法则 并计算 a ? b 并返回值 
    int value( int a, char c, int b){
    	if(c == '@') return a*b;//合取 
    
    	if(c == '#') {
    		if(a == 0 && b == 0) return 0;
    		else return 1;
    	}//析取 
    	
    	if(c == '$') {
    		if(a == 1 && b == 0) return 0;
    		else return 1;
    	}//条件
    	 
    	if(c == '%') {
    		if(a == b) return 1;
    		else return 0;
    	}//双条件 
    }
    
    //key:表达式求解 利用两个栈分别存储 值和运算符 逐渐求解 
    int key(string s, map <char,int> m){
    	s += ")";
    	stack <int> s1;
    	stack <char> s2;	s2.push('(');
    	for(int i = 0; i != s.length(); i ++){
    			if(isalpha(s[i])){
    				auto p = m.find(s[i]);
    				s1.push(p->second);
    			}
    			else if(isdigit(s[i])) s1.push(s[i] - '0');
    			else {
    				if(compare( s2.top(), s[i]) == -1) s2.push(s[i]);
    				else if(compare( s2.top(), s[i]) == 0) s2.pop();
    				else if(compare( s2.top(), s[i]) == 1) {
    					if(s2.top() == '!') {
    						int a = s1.top();	s1.pop();
    						if(a == 1) s1.push( 0);
    						else s1.push( 1);
    						
    						s2.pop();	i --;
    					}
    					else{
    						int b = s1.top(); s1.pop();
    						int a = s1.top(); s1.pop();
    						s1.push( value( a, s2.top(), b));
    						s2.pop();	s2.push( s[i]);
    					}
    				}
    			}
    			
    		}
    	return s1.top();
    }
    
    //fun2:(利用真值表) 计算主合取范式和主析取范式 并存入s1, s2  
    void fun2(int i, int key, map <char,int> m, vector <int>& Max,vector <int>& min, string& s1, string& s2){
    		if(key == 0) {
    			Max.push_back(i);
    			s1+='(';
    			for(auto i = m.begin(); i != m.end(); i ++){
    				if(i->second == 1) s1+='!';
    				s1+=i->first;
    				if(i != --m.end()) s1+='#';
    			}
    			s1+=')';
    			s1+='@';
    		}
    		else {
    			min.push_back(i);
    			s2+='(';
    			for(auto i = m.begin(); i != m.end(); i ++){
    				if(i->second == 0) s2+='!';
    				s2+=i->first;
    				if(i != --m.end()) s2+='@';
    			}
    			s2+=')';
    			s2+='#';
    		}
    }
    
    //print函数: 输出 主合取范式和主析取范式
    void print( vector <int> Max, vector <int> min, string s1, string s2){	
    	
    	printf("主合取范式:\n");
    	cout << "∏"; 
    	for(auto i = Max.begin(); i < Max.end(); i ++){
    		if( i == Max.begin()) {
    			cout << *i; 
    		} 
    		else cout << ", " << *i;
    	}
    	cout << endl;
    	
    	for(int i = 0; i < s1.length(); i++){
    		if(i == s1.length() - 1) {
    			if(s1[i] != '@') cout << s1[i];
    		}
    		else cout << s1[i];
    	}
    	cout<< endl<< endl;
    	
    	printf("主析取范式:\n");
    	cout << "∑"; 
    	for(auto i = min.begin(); i < min.end(); i ++){
    		if( i == min.begin()) {
    			cout << *i; 
    		} 
    		else cout << ", " << *i;
    	}
    	cout << endl;
    	
    	for(int i = 0; i < s2.length(); i++){
    		if(i == s2.length() - 1) {
    			if(s2[i] != '#') cout << s2[i];
    		}
    		else cout << s2[i];
    	}
    }
    
    int main(){
    	
    	//声明 
    	printf("由于合取、析取等特殊字符难以表示,故作以下声明\n");
    	printf("声明:\n");
    	printf("以!代替否定\n");
    	printf("以@代替合取\n");
    	printf("以#代替析取\n");
    	printf("以$代替条件\n");
    	printf("以%代替双条件\n\n");
    	printf("支持使用括号()、支持n个命题变元、支持重复的命题变元、支持0/1参与运算\n\n");
    	printf("请输入合法的表达式:\n->");
    	
    	string s;//表达式 
    	string s1, s2;// 合取范式和主析取范式
    	vector <int> Max, min;//集合:存储大项和小项的下标 
    	map < char, int> m;// map<char, int>: 建立命题变元与 0/1 的键值对关系 
    	cin >> s;
    	cout << endl;
    	
    	//map: P Q R ... ...  map的初始化 
    	for(auto i = s.begin(); i != s.end(); i ++){
    		if(isalpha(*i)) m.insert(make_pair( *i, 0));
    	}
    	
    	printf("真值表:\n");
    	
    	//输出真值表——表头
    	//1 输出 键 map_key
    	for(auto i = m.begin(); i != m.end(); i ++){
    		cout << i->first << "   ";
    	}
    	
    	//2 输出表达式 
    	cout << s; 
    	cout << endl;
    	
    	int n = pow( 2,distance(m.begin(), m.end()));//总情况个数 
    	
    	//(按行依次)输出真值表——真值 
    	for(int i = 0; i < n; i ++){
    		
    		//1 为键赋值 
    		fun1( i, m);
    		
    		//2 输出 值 map_value
    		for(auto i = m.begin(); i != m.end(); i ++)
    			cout << i->second << "   ";
    		
    		//3 计算并输出表达式的真值 
    		cout << key( s, m) << endl;
    		
    		//4 计算主合取范式和主析取范式 并存入s1, s2 
    		fun2( i, key( s, m), m, Max, min, s1, s2);
    	}
    	
    	cout << endl << endl;
    	
    	print( Max, min, s1, s2);//输出 主合取范式和主析取范式
    	
    	return 0; // 程序结束 
    }
    
    
    展开全文
  • 逻辑表达式分析器和真值表生成器。 。 运算符使用说明: 连接析取:或 连词:AND 专有析取连接词:XOU 条件连接:-> 双条件连接器:<-> 连接否定连词:~E 连接析取否定:~OU 拒绝:~(只是在字母前面加...
  • 根据这张真值表,我们还需要将其转化逻辑函数,即用电路的逻辑语言来描述输出量与输入量之间的关系,替代这一张庞大的真值表。只有明确地表示出输出与输入之间对应的函数关系或者功能模块的逻辑...

    一、引言

            采用逻辑门和MSI模块来进行组合逻辑电路的设计,需要我们根据实验的需求和电路的功能要求,明确输出量与输入量之间的关系,即得到一张真值表(或者是功能表)。根据这张真值表,我们还需要将其转化成逻辑函数,即用逻辑语言来描述输出量与输入量之间的关系,替代这一张庞大的真值表。只有明确地表示出输出量与输入量之间对应的函数关系或者功能模块的逻辑关系,才有办法搭建逻辑门或者MSI模块使不同的输入量实现对应的输出。
            要想根据电路的功能需求得到一张真值表并不困难,只需要将每种输入和其对应的输出情况排列出来即可。而从真值表转化到逻辑函数,需要我们掌握一些方法和技巧,常见的方法有两种:①卡诺图法:先根据真值表写出逻辑函数的最小项和最大项表达式,再根据卡诺图来进行化简,得到最简与或式和最简或与式。②观察法:直接在真值表中,观察输出与输入之间的关系,就可以写出与或式和或与式,但这样得到的与或式和或与式不一定是逻辑函数的最简形式,可能需要我们通过卡诺图进行检验和化简。
            我们今天的重点是教大家使用第②种方法,即如何在真值表中通过观察法描述输出量与输入量之间的关系,得到逻辑函数的与或表达式和或与表达式。

    二、与或表达式

            要想从真值表中得到一个与或表达式,我们需要根据或运算的特点:等号右边的每一项只要有一项为1,那么或运算表达式的结果一定为1。也就是说,我们用不同的乘积项组合表示出真值表中所有输出结果为1的情况即可。
            具体的实现方法是:我们需要在真值表中找到输出为1的行,观察该行对应的输入项有什么特点,能够使得输出一定为1而不是为0。这个特点可以表示成输入项之间的乘积形式(&),成为与或式的其中一项

            我们可以来看这样一个例子:要求用4位全加法器芯片7483实现1位8421BCD码加法器。我们都知道,7483是4位二进制加法器,其进位规则是逢16进1,而8421BCD码表示的是十进制数,进位规则是逢10进1,所以直接用7483加法器让两个8421BCD码相加时,如果和≤9,结果正确,如果和≥10,结果将出现误差。用7483实现BCD码相加时,关键在于确定何时对结果进行修正,以及如何修正。
            显然,我们需要先通过7483全加器芯片来实现两个BCD码的相加,但此时得到的结果是一个二进制数,并不是8421BCD码,所以我们还需要一个校正电路,来实现7483相加后的结果(二进制数)到8421BCD码(十进制数)的一个转化。要设计这个校正电路,我们需要先分析校正电路需要实现的输出与输入之间的关系,列出真值表如下图所示:
    在这里插入图片描述

            真值表中的N10为两个BCD码相加用十进制数表达的结果(范围只可能从0 - 18)。比较表中的输出和输入可以发现,当N10≤9时,8421BCD码的进位DC为0,二进制数与8421BCD码相同;当N10≥10时,8421BCD码的进位DC为1,8421BCD码就比相应的二进制数大6。那么我们如何知道N10什么时候≤9,什么时候≥10呢?不难发现,只需要根据DC是否为1来判断。
            当DC = 0时,校正电路的输出也就是7483输出的结果;当DC = 1时,将7483的输出值与(0110)2相加,就可以实现输出值的修正。也就是说,校正电路也需要一个全加器来实现,相加的两个数分别为上一级7483全加器输出的结果和(0DCDC0)2。所以问题分析的关键变成:如何从真值表中得到输出DC与输入(C4S3S2S1S0)之间的关系?那这个问题就是我们今天的重点了,我们可以通过观察,用与或式将DC的逻辑函数给表达出来。

            我们将上面提到的重点重复一遍!“我们需要在真值表中找到输出为1的行,观察该行对应的输入项有什么特点,能够使得输出一定为1而不是为0。这个特点可以表示成输入项之间的乘积形式(&),成为与或式的其中一项”

            对应到这个例子中,我们观察输出DC为1的行,不难发现如果输入C4为1,那么DC一定为1,那么C4就是这个与或式的其中一项。但是还有C4不为1的输入项能够使得输出DC也为1,那么这些输入项具有什么特点呢?我们又可以发现,如果输入S3和S2同时为1,那么输出DC也一定为1,故可将这一特点表示成输入项之间乘积的形式,即S3·S2,这又可以成为与或式中的其中一项(意思是:只有S3和S2同时取1,才能使得这个与运算的结果为1,进而使得DC与或表达式的结果为1)。同理,我们可以发现如果输入S3和S1同时为1,那么输出DC也一定为1,所以可以表示为S3·S1
            至此,我们已经找到了能使且仅能使输出DC = 1的所有可能特点,故可以写出DC的与或式:DC = C4 + S3·S2 + S3·S1

    三、或与表达式

            我们当然也可以将DC表示成或与式的形式,依据的原理就是与运算的特点:等号右边的每一项只要有一项为0,那么与运算表达式的结果一定为0。也就是说,我们用不同的加和项(或运算)组合表示出真值表中所有输出结果为0的情况即可。
            具体的实现方法是:我们需要在真值表中找到输出为0的行,观察该行对应的输入项有什么特点,能够使得输出一定为0而不是为1。这个特点可以表示成输入项之间的加和形式(+),成为或与式的其中一项

            对应到这个例子中,我们观察输出DC为0的行,不难发现如果输入C4和S3全都为0,那么输出DC一定为0,故可将这一特点表示成输入项之间加和的形式,即(C4 + S3),这可以成为或与表达式中的一项(意思是:只有C4和S3同时取0,才能使得这个或运算的结果为0,进而使得DC或与表达式的结果为0)。为了对应完DC为0的所有情况,我们还要寻找其他的特征,又可以发现如果输入C4和S2以及S1同时为0,那么输出DC也一定为0,所以可以将这一特点表示成(C4 + S2 + S1),这是或与表达式的另外一项。
            至此,我们已经找到了能使且仅能使输出DC = 0的所有可能特点,故可以写出DC的或与式:DC = (C4 + S3)(C4 + S2 + S1)。

    四、电路的实现

            根据DC的与或式或者或与式,我们自然地就可以设计出上述例题对应的校正电路了,这里以DC的与或式:DC = C4 + S3·S2 + S3·S1 为例,用两片4位全加器芯片7483设计出一位BCD码的加法运算电路,如下图所示:
    在这里插入图片描述

    五、表达式的化简

            用观察法从真值表中得到的与或式和或与式不一定是最简的形式,我们可以通过代数法或者卡诺图来进行检验和化简。当然,如开篇引言所说,我们也可以直接从真值表转化到卡诺图中进行最简与或式和最简或与式的求解。但先在真值表中观察写出表达式的方法,可能消去了一些输入量,在某种程度上比直接使用卡诺图更为快速。下图展示了将上述例题通过观察法得到的两个表达式进行卡诺图检验的结果,结果表明该与或式和或与式已经是最简的形式。而且,该卡诺图只含有4个输入量,若直接根据最小项或最大项表达式画卡诺图,将会含有5个输入量。
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 从建立0-1整数规划模型的实际出发,对该模型中若干逻辑表达式线性表示、互斥和乘积表达式转化,以及具体的指派问题中能力限制约束的表示问题进行了研究,利用真值表等工具给出了相应的结果。
  • 真值表-Python实现

    千次阅读 2019-12-12 19:47:31
    文章目录实验内容程序设计代码实现 ...真值表:公式 G 在其所有可能的解释下所取真值的表 本实验要求从键盘输入一个命题公式列出其真值表。 程序设计 实现真值表难点在于: 对变元的 T(True) F(False) 的枚...
  • 逻辑函数表达式转化为标准形式

    千次阅读 2020-03-09 12:32:17
    要求化简的最终结果 是逻辑函数的标准形式,即用最大项、最小项表示的表达式 一、代数转换法(要求对公理定理熟悉掌握) 化简成 与或表达式 化简到最后 缺省变量的项用 X = X(Y+Y非)扩充变量 将上面逻辑函数...
  • 我昨天听这节课的时候,发现这次的内容和离散数学里面的知识几乎是一样的诶!...逻辑函数表达式的基本形式 “与-或”表达式 由若干“与项”进行“或”运算构成的表达式 “与项”可以是单个变量的原变量,可
  • 标题:真值表求主析取范式、主合取范式的计算机语言实现 背景 语言、环境选择 C++ Visual Studio 2010 知识涉及(关键词) 线性栈的使用 中缀表达式,后缀表达式 映射 二进制枚举 实验思路 将中缀表达式转化...
  • 利用真值表法求主合取范式及主析取范式的实现

    万次阅读 多人点赞 2016-09-29 18:23:45
    利用真值表法求主析取范式及主析取范式的实现(C++) 功能:用户可输入合式公式(包含!&|以及圆括号),程序即可输出变元真值表及主合取范式及主析取范式 《离散数学》南京邮电大学学习期间,离散数学实验一 2016.9...
  • 首先用一个串来储存使用者所输入的命题表达式,依据人类的思维,会对输入的命题公式进行分析和计算,但计算机可不会,这时我们就要写入相关代码把使用者输入的命题表达式转换为计算机所能进行计算的后缀表达式,我们...
  • 真值表法基础 定义: 在真值表中,一个公式的真值为T的指派所对应的小项的析取,即为公式的主析取范式。 1.代码实现 给各个原子命题设定初值(T/F),然后计算命题公式的真值,如果为真,就输出原子命题对应的数字。 ...
  • 逻辑函数

    2020-10-18 09:42:08
    逻辑函数表示方法之间的转化真值表逻辑图的转换逻辑图到真值表的转换 1. 逻辑函数的几种表示方法 逻辑函数:描述输入逻辑变量和输出逻辑变量之间的因果关系。 (1)真值表 (2)逻辑函数表达式 (3)逻辑图 将...
  • java计算表达式

    千次阅读 2012-09-17 11:34:19
    package sweexamination.level1; import java.util.ArrayList;... * 转为后缀表达式:  * 操作数直接放入结果  * 当前操作符与栈中的操作符比较:  * 栈空:进  * 当前高:进  * 当前低:将栈顶
  • 选择结构程序设计一、选择结构概述二、实现前提(关系表达式与逻辑表达式)1.关系表达式与关系运算符2.逻辑表达式与逻辑运算符三、算法与流程图四、关于算法说一点吧 一、选择结构概述 有的问题,需要根据不同的条件...
  • C语言-用栈实现表达式(顺序栈)

    千次阅读 多人点赞 2020-04-16 22:34:37
    函数目录: 栈的基本操作: 创建栈并初始化(create) ...表达式函数(evaluateExpression) 其他:操作符栈(OPTR),操作数栈(OPND) 谈谈我遇到的问题: 1.该选择数字栈还是字符栈? 运算数是整型...
  • 一实验目的 二实验要求及实验环境 1实验要求 2实验环境 三设计思想 1逻辑设计 2物理设计 四测试结果 五系统不足与经验体会 1系统不足 2经验体会 六源码
  • 三元表达式

    千次阅读 热门讨论 2017-07-16 16:56:05
    逻辑为:“如果为执行第一个,否则执行第二个。” 实例: String result = name==”老赵”?”帅的掉渣了”:”山炮掉渣了”; 项目中需要对显示的文本进行转换,但在代码中没有定义相关内容,在
  • 1,逻辑真值表 2,逻辑函数式:由与或非等各种运算符所构成的逻辑表达式 3,逻辑图:由各种门的逻辑符号连接所构成的逻辑电路图。 以上三种表示放都可以互相转化 1.逻辑函数式求真值表:把输入变量的所有可能的...
  • 正则表达式

    千次阅读 2018-06-22 10:50:48
    正则表达式语法2014年09月24日 18:01:43阅读数:8241. 正则表达式规则1.1 普通字符 字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号,都是"普通字符"。表达式中的普通字符,在匹配一个...
  • 4.波形图:与真值表一样,每一列代表真值表的一行,用波形表示01值 表达形式之间的转化: 1.真值表 ==> 函数式 a.考虑所有能让结果为 1 的情况,用'或' 连接 b.考虑每一种让结果为 1 的情况 ,用'与' 连接每一...
  • 74LS151 8选1数据选择器实现4位奇偶判断电路-QuartusII 软件仿真一、74LS151 8选1数据选择器介绍二、真值表逻辑表达式构建三、设计原理图和波形仿真四、总结用数据选择器设计组合逻辑电路的方法 一、74LS151 8选1...
  • 关系运算符 < 小于 > 大于 >= 大于等于 <= 小于等于 == 等于 ...关系表达式 由关系运算符连成的表达式 关系运算符两边可以是C语言中...表达式类型不同时系统自动转化 关系表达式 (1) 假(0) ...
  • EL表达式详解

    2013-10-19 18:17:51
    EL表达式详解 在 JSP 页面中,使用标签库代替传统的 Java 片段语言来实现页面的显示逻辑已经不是新技术了,然而,由自定义标签很容易造成重复定义和非标准的实现。鉴于此,出现了 JSTL ( JSP Standard ...
  • 1. 介绍 表达式分为前缀、中缀、后缀。前缀表达式,也称为波兰表达式,其特点是将操作符置于操作数的前面。...前缀表达式和后缀表达式相对于中缀表达式最大的不同是,去掉了表示运算优先级的括号。 1.1 前缀表达
  • C语言运算符表达式

    2018-06-11 10:31:26
    一、分类C语言一共有34种运算符,10种运算类型:...=)、逻辑运算符(!、||、&amp;&amp;)、条件运算符、(?:)指针运算符(&amp;、*)、赋值运算符(=)、逗号运算符(,)、求字节运算符(sizeof)、强...
  • 谓词表达式

    千次阅读 2016-10-18 20:55:43
    AND、&&:逻辑与,要求两个表达式都为YES时,结果才为YES。 1 2 3 4 NSArray *testArray = @[@1, @2, @3, @4, @5, @6];   NSPredicate *predicate = ...
  • 正则表达式语法

    2014-09-24 18:01:43
    1. 正则表达式规则 1.1 普通字符  字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号,都是"普通字符"。表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同的一个字符。  举例1:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,338
精华内容 11,735
关键字:

真值表转化逻辑表达式