精华内容
下载资源
问答
  • 南京邮电大学实验一真值表法求主析取范式和主合取范式代码 离散数学 实 验 一利用真值表法求主析取范式以及主合取范式的实现 实验名称:利用真值表法求主析取范式以及主合取范式的实现 实验目的:通过编程实现...
  • 实 验 一利用真值表法求主析取范式以及主合取范式的实现 实验名称:利用真值表法求主析取范式以及主合取范式的实现 实验目的:通过编程实现主析取范式以及主合取范式的真值表法以巩固相关理论的掌握 实验...
  • 数组(存放真值表) map(存放命题变元以及对应的真假值) #include<iostream> #include <string> #include <map> #include <stack> #define MAX 100 using namespace std; map<char,...

    实验原理

    使用的数据结构和存储结构:

    • 栈(中缀转后缀并计算)
    • 数组(存放真值表)
    • map(存放命题变元以及对应的真假值)
    #include<iostream>
    #include <string>
    #include <map>
    #include <stack>
    #define MAX 100
    
    using namespace std;
    
    map<char,bool> statements;			//存储命题变元
    int Prio(char ch);
    string Trans(string str);
    bool Judge(string str);
    void Output(string wff,string suffix);
    
    int main()
    {
    	string wff,suffix;
    	cout << " 由于命题逻辑的一些符号不在ASCII表中,所以做以下规定:" << endl;
    	cout << "	! :否定" << endl;
    	cout << "	* :合取" << endl;
    	cout << "	+ :析取" << endl;
    	cout << "	> :单条件" << endl;
    	cout << "	- :双条件" << endl;
    	cout << "请输入合式公式:";
    	cin >> wff;
    	suffix = Trans(wff);
    	Output(wff,suffix);
    	return 0;
    }
    
    int Prio(char ch)				//定义联结词优先级
    {
    	if (ch == '!')
    		return 4;
    	if (ch == '*')
    		return 3;
    	if (ch == '+')
    		return 2;
    	if (ch == '>')
    		return 1;
    	if (ch == '-') 
    		return 0;
    	if (ch == '(')
    		return -1;
    	return 0;
    }
    
    string Trans(string str)
    {
    	string suffix;
    	stack<char> stk;
    	for (int  i = 0; i < str.length(); i++)
    	{
    		if (isalpha(str[i]))
    			statements[str[i]]=0;
    	}
    	for (int i = 0; i < str.length(); i++)
    	{
    		if (statements.count(str[i]))		//操作数直接写入后缀表达式
    			suffix+=str[i];
    			
    		else
    		{
    			if (stk.empty())
    				stk.push(str[i]);
    			else if (str[i] == '(')									//'('直接入栈		
    				stk.push(str[i]);
    			else if (str[i] == ')')							//当遇到')'时弹出栈中元素加入后缀表达式直到'('弹出为止
    			{
    				while (stk.top() != '(')
    				{
    					suffix += stk.top();
    					stk.pop();
    				}
    				stk.pop();								//'('不需要加入后缀表达式
    			}
    			else
    			{
    				while (!stk.empty() && Prio(str[i]) <= Prio(stk.top()))			//当所遇到的操作符的优先级小于或等于栈顶元素的优先级时
    				{
    					suffix += stk.top();								//取出栈顶元素放入后缀表式,并弹出该栈顶元素
    					stk.pop();
    				}
    				stk.push(str[i]);
    			}
    		}
    	}
    	while (!stk.empty())		//最后,如果栈不空,则弹出所有元素并放入后缀表式
    	{
    		suffix += stk.top();
    		stk.pop();
    	}
    	return suffix;
    }
    
    bool Judge(string str)
    {
    	stack<bool> stk;		//用来计算真假值
    	bool a, b;
    	for (int i = 0; i < str.length(); i++)
    	{
    		if (statements.count(str[i]))			//命题直接入栈
    			stk.push(statements[str[i]]);
    		else
    		{
    			switch (str[i])
    			{
    			case '!':
    				a = stk.top();
    				stk.pop();
    				stk.push(!a);
    				break;
    			case'*':
    				a = stk.top();
    				stk.pop();
    				b = stk.top();
    				stk.pop();
    				stk.push(a * b);
    				break;
    			case'+':
    				a = stk.top();
    				stk.pop();
    				b = stk.top();
    				stk.pop();
    				stk.push(a + b);
    				break;
    			case'>':
    				a = stk.top();
    				stk.pop();
    				b = stk.top();
    				stk.pop();
    				stk.push(a + !b);
    				break;
    			case'-':
    				a = stk.top();
    				stk.pop();
    				b = stk.top();
    				stk.pop();
    				stk.push((!a + b) * (a + !b));
    				break;
    			}
    		}
    	}
    	return stk.top();
    }
    
    void Output(string wff,string suffix)
    {
    	string pdnf, pcnf,state;
    	int n = statements.size();
    	int truthTable[MAX][MAX];
    	for ( auto iter = statements.begin(); iter !=statements.end(); iter++)
    	{
    		state += iter->first;							
    		cout << iter->first << '\t';
    	}
    	cout << wff << endl;
    	for (int i = 0; i < pow(2,n); i++)
    	{
    		int tmp = i;
    		int j = n - 1;
    		for (auto it = statements.rbegin(); it !=statements.rend(); it++)			//10->2进制对其进行赋值(倒叙)
    		{
    			truthTable[i][j] = it->second = tmp % 2;
    			tmp /= 2;
    			j--;
    		}
    		truthTable[i][n] = Judge(suffix);
    	}
    	for (int i = 0; i < pow(2, n); i++)			//拼接主析取和主合取范式
    	{
    		if (truthTable[i][n])
    			pdnf += '(';
    		else
    			pcnf += '(';
    		for (int j = 0; j < n; j++)
    		{
    			cout << truthTable[i][j]<<'\t';			//输出真值表
    			if (truthTable[i][n])
    			{
    				if (truthTable[i][j] == 0) 
    					pdnf += '!';
    				pdnf += state[j];
    				if (j < n - 1)
    					pdnf += '*';
    			}
    			else
    			{
    				if(truthTable[i][j] == 1)
    					pcnf += '!';
    				pcnf += state[j];
    				if (j < n - 1)
    					pcnf += '+';
    			}
    		}
    		cout << truthTable[i][n] << endl;
    		if (truthTable[i][n])
    			pdnf += ")+";
    		else
    			pcnf += ")*";
    	}
    	pdnf.erase(pdnf.size() - 1);		//删除多余的联结词
    	pcnf.erase(pcnf.size() - 1);
    	cout << "主析取范式为:" << pdnf << endl;
    	cout << "主合取范式为:" << pcnf << endl;
    }
    
    
    展开全文
  • 编程实现求解逻辑表达式的真值表主析取范式、主合取范式对于一个含n个命题变元的表达式(n为相异的命题变元总个数),其真值表可看作由从0到2ⁿ-1的二进制数的变化表。因此,可以通过按行列举0到2ⁿ-1的二进制数来...
  • 根据命题公式真值表求主析取范式。 输入格式: 第一行为命题中符号的个数(最大不超过8); 第二行开始到最后为命题公式的真值表最后一列。 输出格式: 输出主析取范式。 注意: 1.逻辑连接词非为!,与为^,或为+; 2....

    根据命题公式真值表求主析取范式。

    输入格式:
    第一行为命题中符号的个数(最大不超过8);

    第二行开始到最后为命题公式的真值表最后一列。

    输出格式:
    输出主析取范式。

    注意:

    1.逻辑连接词非为!,与为^,或为+;

    2.输出中空格格式;

    3.输出中命题符合依次从A开始;

    4.如果该命题为永假式,则输出为空。

    输入样例:
    在这里给出一组输入。例如:

    样例一:

    2
    0
    0
    1
    1
    样例二:

    3
    0
    1
    0
    1
    1
    1
    0
    1
    输出样例:
    在这里给出相应的输出。例如:

    输出一:

    A^ !B + A^B
    输出二:

    !A^ !B^ C + !A^ B^ C + A^ !B^ !C + A^ !B^ C + A^ B^ C

    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    int dectobin( int n ){//十进制转二进制
        int result=0,k=1,i,temp;
        temp = n;
        while(temp){
            i = temp%2;
            result = k * i + result;
            k = k*10;
            temp = temp/2;
        }
        return result;
    
    }
    int main()
    {
        int i,l,j,k,m,a[300],temp,count=0;//count用于记录加号
        scanf("%d",&m);
        int b[m];
        char c[m];
    
        for(i=0;i<pow(2,m);i++)
        {
            scanf("%d",&a[i]);
            if(a[i]==1)  count++;
        }
        for(i=0;i<pow(2,m);i++)
        {
    
          if(a[i]==1)
            {
                for(l=0;l<m;l++)
                    {
                      b[l]=0;
                     }
             temp=dectobin(i);
             int w=m-1;
             while(temp>0)
                   {
    
                   b[w--]=temp%10;
                   temp /= 10;
                    }
             for(j=0;j<m;j++)
                  {
                 if(b[j]==0)  c[j]='!';
                  else        c[j]='\0';
                  }
             for(k=0;k<m;k++)
                  {
                   if(b[k]==0)
                  {
                   printf("!%c,'A'+k);
                  }
                  else  printf("%c",'A'+k);
                   if(k!=m-1)
                   {
                       printf("^");
                   }
    
                   }
             if(count!=1)
                {
                  printf("  +  ");
                  count--;
                }
    
            }
        }
        return 0;
    }
    
    展开全文
  • 题目:根据给定的式子,先输出其真值表,再利用真值表法求主析取范式以及主合取范式,输出答案。 举例:以 (P^Q) V (非P^R) 为例。 程序代码 //(P^Q) V (非P^R) //主合取范式: (非PVQV非R) ^ (非PVQVR) ^ (PV非...

    题目:根据给定的式子,先输出其真值表,再利用真值表法求取主析取范式以及主合取范式,输出答案。

    举例:以 (P^Q) V (非P^R) 为例。

    程序代码

    //(P^Q) V (非P^R)
    //主合取范式: (非PVQV非R) ^ (非PVQVR) ^ (PV非QVR) ^ (PVQVR)
    //主析取范式: (P^Q^R) V (P^Q^非R) V (非P^Q^R) V (非P^非Q^R)
    #include <iostream>
    #include <cmath>
    using namespace std;
    int a[1000], b[1000], c[1000];  //P^Q  非P^R  A
    int x[1000], y[1000], z[1000];  //P Q R
    int n;
    
    
    //输出真值表
    void Output_truth_table(){
    	cout << endl << "The truth table is:" << endl;
    	cout << 'P' << '\t' << 'Q' << '\t' << 'R' << '\t';
    	cout << "P^Q" << '\t' << "非P^R" << '\t' << "(P^Q) V (非P^R)" << endl;
    	for(int i = 0; i < pow(2, n); ++i){
    		//输出 P Q R 的真值
    		if(i < pow(2, n-1)){
    			x[i] = 1;
    			cout << 'T' << '\t';
    		}
    		if(i >= pow(2, n-1)){
    			x[i] = 0;
    			cout << 'F' << '\t';
    		}
    		if(i % 4 < 2){
    			y[i] = 1;
    			cout << 'T' << '\t';
    		}
    		if(i % 4 >= 2){
    			y[i] = 0;
    			cout << 'F' << '\t';
    		}
    		if(i % 2 == 0){
    			z[i] = 1;
    			cout << 'T' << '\t';
    		}
    		if(i % 2 == 1){
    			z[i] = 0;
    			cout << 'F' << '\t';
    		}
    		//输出(P^Q)  (非P^R)  (P^Q) V (非P^R) 的真值
    		if(a[i] == 1) cout << 'T' << '\t';
    		else if(a[i] == 0) cout << 'F' << '\t';
    		if(b[i] == 1) cout << 'T' << '\t';
    		else if(b[i] == 0) cout << 'F' << '\t';
    		if(c[i] == 1) cout << 'T' << endl;
    		else if(c[i] == 0) cout << 'F' << endl;
    	}
    }
    
    
    //主合取范式
    void Master_conjunction(){
    	cout << endl << "Master_conjunction is: ";
    	int count = 0;
    	for(int i = 0; i < pow(2, n); ++i){
    		if(c[i] == 0){  //如果公式真值为假,则输出相应的真值相反的 P Q R
    			if(x[i] == 1 && y[i] == 1 && z[i] == 1){
    				cout << "(非PV非QV非R)";
    				count++;
    			}
    			else if(x[i] == 1 && y[i] == 1 && z[i] == 0){
    				cout << "(非PV非QVR)";
    				count++;
    			}
    			else if(x[i] == 1 && y[i] == 0 && z[i] == 1){
    				cout << "(非PVQV非R)";
    				count++;
    			}
    			else if(x[i] == 1 && y[i] == 0 && z[i] == 0){
    				cout << "(非PVQVR)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 1 && z[i] == 1){
    				cout << "(PV非QV非R)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 1 && z[i] == 0){
    				cout << "(PV非QVR)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 0 && z[i] == 1){
    				cout << "(PVQV非R)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 0 && z[i] == 0){
    				cout << "(PVQVR)";
    				count++;
    			}
    			if(count != pow(2, n-1)) cout << " ^ ";
    		}
    	}
    	cout << endl;
    }
    
    
    //主析取范式
    void Master_disjunction(){
    	cout << endl << "Master_disjunction is: ";
    	int count = 0;
    	for(int i = 0; i < pow(2, n); ++i){
    		if(c[i] == 1){  //如果公式真值为真,则输出相应真值的 P Q R
    			if(x[i] == 1 && y[i] == 1 && z[i] == 1){
    				cout << "(P^Q^R)";
    				count++;
    			}
    			else if(x[i] == 1 && y[i] == 1 && z[i] == 0){
    				cout << "(P^Q^非R)";
    				count++;
    			}
    			else if(x[i] == 1 && y[i] == 0 && z[i] == 1){
    				cout << "(P^非Q^R)";
    				count++;
    			}
    			else if(x[i] == 1 && y[i] == 0 && z[i] == 0){
    				cout << "(P^非Q^非R)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 1 && z[i] == 1){
    				cout << "(非P^Q^R)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 1 && z[i] == 0){
    				cout << "(非P^Q^非R)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 0 && z[i] == 1){
    				cout << "(非P^非Q^R)";
    				count++;
    			}
    			else if(x[i] == 0 && y[i] == 0 && z[i] == 0){
    				cout << "(非P^非Q^非R)";
    				count++;
    			}
    			if(count != pow(2, n-1)) cout << " V ";
    		}
    	}
    	cout << endl;
    }
    
    
    int main(){
    	cout << "Please input the number of variable:";
    	cin >> n;
    	cout << endl << "The formula is:(P^Q) V (非P^R)" << endl;
    	int m1 = 0;
    	int m2 = 0;
    	int m3 = 0;
    	//三重循环
    	for(int i = 0; i < 2; ++i){
    		for(int j = 0; j < 2; ++j){
    			for(int k = 0; k < 2; ++k){
    				if(i == 0 && j == 0){
    					a[m1++] = 1;  //P为真,Q为真:P^Q 为真
    				}
    				if(j == 1 || i == 1){
    					a[m1++] = 0;  //P为真,Q为假 或 P为假:P^Q 为假
    				}
    				if(i == 0 || k == 1){
    					b[m2++] = 0;  //P为真 或 P为假,R为假:(非P^R)为假
    				}
    				if(i == 1 && k == 0){
    					b[m2++] = 1;  //P为假 且 R为真:(非P^R)为真
    				}
    			}
    		}
    	}
    	for(int m3 = 0; m3 < pow(2, n); ++m3){
    		if(a[m3] == 0 && b[m3] == 0){  //P^Q 为假 且 (非P^R)为假
    			c[m3] = 0;
    		}
    		else c[m3] = 1;
    	}
    	Output_truth_table();
    	Master_conjunction();
    	Master_disjunction();
    	return 0;
    }
    

    实验结果

    在这里插入图片描述

    展开全文
  • 编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。 要求: 能够列出任意合式公式的真值表并给出相应主析取和主合取范式。 内容: 编程实现用真值表法求取任意数量变量的合式公式的主析取...

    一、    实验目的和要求

    内容:

    编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。

    要求:

    能够列出任意合式公式的真值表并给出相应主析取和主合取范式。


    内容:

    编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。

    原理:

    先将中缀表达式转换成后缀表达式,再将后缀表达式中每一个字母变量一一赋值,用递归枚举的方法枚举所有赋值情况,并且用map映射将每一个字母变量与当前被枚举的值一一映射,对每一种赋值情况调用后缀表达式计算函数计算后缀表达式的值,打印真假情况。如果是真,记录到名为zhen的vector不定长数组中,如果是假,记录到名为jia的vector不定长数组中。最后根据zhen和jia的不定长数组来打印主析取范式和主合取范式。 

    此程序可以实现任意数量的字母变量的主析取范式求取和主合取范式求取,以及真值表打印。      



    //或运算 |  , 与运算 &   ,单条件 ->  ,双条件 <=> ,非运算 !
    
    #include <cstdio>
    #include <iostream>
    #include <vector>
    #include <string>
    #include <cstdlib>
    #include <queue>
    #include <stack>
    #include <map>
    #include <sstream>
    using namespace std;
    string zhong;  //中缀表达式
    char hou[1000];   //后缀表达式
    string alpha;   //存放所有字母变量
    map<char,int> M;   //映射,将字母变量与0或1一一对应
    
    struct note
    {
    	int a[100];
    };
    vector<note> zhen;  //不定长数组,存放主析取范式对应字母变量的01情况,也就是表达式真值为T
    vector<note> jia;  //不定长数组,存放主合取范式对应字母变量的01情况,也就是表达式真值是F
    
    void ddd()   //预处理,去除中缀表达式中条件->中的>,和双条件<=>中的= and > ,将这两个运算符当成一个字符处理,更方便
    {
    	string::iterator i=zhong.begin();
    	int flag=1;
    	while(flag)
        {
            flag=0;
            for(i=zhong.begin();i!=zhong.end();++i)
            {
                if(*i=='>')
                {
                    zhong.erase(i);
                    flag=1;
                    break;
                }
                if(*i=='=')
                {
                    zhong.erase(i);
                    flag=1;
                    break;
                }
            }
    	}
    }
    
    int icp(char a)
    {
    	if(a=='#') return 0;
    	if(a=='(') return 12;
    	if(a=='!') return 10;
    	if(a=='&') return 8;
    	if(a=='|') return 6;
    	if(a=='-') return 4;
    	if(a=='<') return 2;
    	if(a==')') return 1;
    }
    int isp(char a)
    {
    	if(a=='#') return 0;
    	if(a=='(') return 1;
    	if(a=='!') return 11;
    	if(a=='&') return 9;
    	if(a=='|') return 7;
    	if(a=='-') return 5;
    	if(a=='<') return 3;
    	if(a==')') return 12;
    }
    
    
    void change()    //中缀表达式转换后缀表达式
    {
    	int j=0;
    	stack<char> s;
    	char ch,y;
    	s.push('#');
    	char t1,t2;
    	stringstream ss(zhong);
    	while(ss>>ch,ch!='#')
    	{
    		if(isalpha(ch))
    		{
    			hou[j++]=ch;
    			if(alpha.find(ch)==-1)
    			{
    				alpha.push_back(ch);
    			}
    		}
    		else if(ch==')')
    		{
    			for(y=s.top(),s.pop();y!='(';y=s.top(),s.pop())
    			{
    				hou[j++]=y;
    			}
    		}
    		else
    		{
    			for(y=s.top(),s.pop();icp(ch)<=isp(y);y=s.top(),s.pop())
    			{
    				hou[j++]=y;
    			}
    			s.push(y);
    			s.push(ch);
    		}
    	}
    	while(!s.empty())
    	{
    		y=s.top();
    		s.pop();
    		if(y!='#')
    		{
    			hou[j++]=y;
    		}
    	}
    	hou[j]='#';
    }
    
    
    int cal()   //对赋值后的后缀表达式进行计算
    {
    	stack<int> s;
    	char ch;
    	int j=0;
    	int t1,t2;
    	while(1)
    	{
    		ch=hou[j];
    		if(ch=='#') break;
    		if(ch==0) break;
    		j++;
    		if((ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z'))
    		{
    			s.push(M[ch]);
    		}
    		else
    		{
    			if(ch=='!')
    			{
    				t1=s.top();
    				s.pop();
    				s.push(!t1);
    			}
    			else if(ch=='&')
    			{
    				t1=s.top();
    				s.pop();
    				t2=s.top();
    				s.pop();
    				if(t1==1&&t2==1)
    				{
    					s.push(1);
    				}
    				else
    				{
    					s.push(0);
    				}
    			}
    			else if(ch=='|')
    			{
    				t1=s.top();
    				s.pop();
    				t2=s.top();
    				s.pop();
    				if(t1==0&&t2==0)
    				{
    					s.push(0);
    				}
    				else
    				{
    					s.push(1);
    				}
    			}
    			else if(ch=='-')
    			{
    				t1=s.top();
    				s.pop();
    				t2=s.top();
    				s.pop();
    				if(t1==0&&t2==1)
    				{
    					s.push(0);
    				}
    				else
    				{
    					s.push(1);
    				}
    			}
    			else if(ch=='<')
    			{
    				t1=s.top();
    				s.pop();
    				t2=s.top();
    				s.pop();
    				if((t1==1&&t2==1)||(t1==0&&t2==0))
    				{
    					s.push(1);
    				}
    				else
    				{
    					s.push(0);
    				}
    			}
    		}
    	}
    	int ans=s.top();
    	return ans;
    }
    
    
    
    
    
    
    
    
    
    void dfs(int cur)   //递归枚举每一种字符变量的取值情况
    {
    	if(cur==alpha.size())
    	{
    		int ans=cal();
    		for(int i=0;i<alpha.size();i++)
    		{
    			if(M[alpha[i]])
    			{
    				printf("T\t");
    			}
    			else
    			{
    				printf("F\t");
    			}
    		}
    		if(ans==1)   //真值为T 计入到zhen数组,以待后面主析取范式使用
    		{
    			printf("T\n");
    			note t;
    			for(int i=0;i<alpha.size();i++)
    			{
    				t.a[i]=M[alpha[i]];
    			}
    			zhen.push_back(t);
    		}
    		else   //真值为F  计入到jia数组,以待后面主合取范式使用
    		{
    			printf("F\n");
    			note t;
    			for(int i=0;i<alpha.size();i++)
    			{
    				t.a[i]=M[alpha[i]];
    			}
    			jia.push_back(t);
    		}
    		return ;
    	}
    	M[alpha[cur]]=1;
    	dfs(cur+1);
    	M[alpha[cur]]=0;
    	dfs(cur+1);
    }
    
    
    
    
    
    int main()
    {
    	while(true)
    	{
    		int i;
    		M.clear();
    		alpha.clear();
    		zhen.clear();
    		jia.clear();
    		printf("或运算为 |  , 与运算为 &   ,单条件为 ->  ,双条件我 <=> ,非运算为 !\n");
    		printf("请输入表达式,回车结束\n");
    	 	cin>>zhong;
    	 	zhong.append("#");
    	 	ddd();
    	 	change();
    	 	for(i=0;i<alpha.size();i++)
    	 	{
    	 		printf("%c\t",alpha[i]);
    	 	}
    	 	printf("表达式真值\n");
    	 	dfs(0);
    	 	printf("主析取范式为\n");
    		int lena=zhen.size();
    		for(i=0;i<lena;i++)
    		{
    			if(i!=0) printf("∨");
    			int *p=zhen[i].a;
    			printf("(");
    			for(int j=0;j<alpha.size();j++)
    			{
    				if(j!=0) printf("∧");
    				if(p[j]==1)
    				{
    					printf("%c",alpha[j]);
    				}
    				else
    				{
    					printf("¬%c",alpha[j]);
    				}
    			}
    			printf(")");
    		}
    		printf("\n");
    		printf("主合取范式为\n");
    		for(i=0;i<jia.size();i++)
    		{
    			if(i!=0) printf("∧");
    			int *p=jia[i].a;
    			printf("(");
    			for(int j=0;j<alpha.size();j++)
    			{
    				if(j!=0) printf("∨");
    				if(p[j]==0)
    				{
    					printf("%c",alpha[j]);
    				}
    				else
    				{
    					printf("¬%c",alpha[j]);
    				}
    			}
    			printf(")");
    		}
    		printf("\n\n");
    	 }
    	return 0;
    }
    
    
    




    展开全文
  • cout 主析取范式为:" ; printAns(ans_vf, 'M', '|'); } void dfs(int n) { if (n == 26) { stack<char> s_s(s); stack<bool> s_t; while (!s_s.empty()) { if (s_s.top() == '&' || s_s.top() == '|...
  • 利用真值表法求主合取范式及主析取范式的实现

    万次阅读 多人点赞 2016-09-29 18:23:45
    利用真值表法求主析取范式主析取范式的实现(C++) 功能:用户可输入合式公式(包含!&|以及圆括号),程序即可输出变元真值表及主合取范式及主析取范式 《离散数学》南京邮电大学学习期间,离散数学实验一 2016.9...
  • 计算主析取范式 【问题描述】 请根据给定的命题公式,计算其真值为T的小项,列出主析取范式,并输出结果。 【输入形式】 输入一个字符串(字符串长度<=50)形式的命题公式,以回车表示输入结束。其中的命题公式为...
  • 请根据给定的命题公式,计算其真值为T的小项,列出主析取范式,并输出结果。 【输入形式】 输入一个字符串(字符串长度<=50)形式的命题公式,以回车表示输入结束。其中的命题公式为仅包含原子命题、联结词和括号...
  • 本程序可以实现任意输入表达式,变元数最多可为3个,即可输出主析取式和主合取式。 规定符号: ! 否定 | 析取 & 合取 -> 条件 双条件 #include #include usingnamespace std;... //主析取范式
  • 针对给定的包含任意个变量的真值表,编程实现用真值表法求取其所对应的主析取范式和主合取范式。 要求: 能够掌握通过真值表取相应主析取和主合取范式的方法及原理。 代码: /* * Author: Tob_yuhong * ...
  • 1. 简单 析取 合取 式 ( 1 ) 简单合取式 ( 2 ) 简单析取式 2. 极小项 ( 1 ) 极小项 简介 ( 2 ) 极小项 说明 ( 3 ) 两个命题变项 的 极小项 ( 4 ) 三个命题变项 的 极小项 ( 5 ) 极小项 成赋值 公式 名称 ...
  • 离散数学实验报告
  • 要求:  输入真值表(1/0),输出相应的zhu
  • #include<stdio.h> #include<string> #include<iostream> #define num 3 #define Fvalue A[0]*!A[1]+A[2]*!A[0]+!A[2]*A[0]+!A[1]*A[0] using namespace std;...string a...
  • 第二个是主析取范式或者主合取范式的输出问题。 对于第一个问题,可以利用真值与二进制之间的关系(1代表T,0代表F)来解决,对于第二个问题,需要在完成第一步的前提下·实现,因此,我采取的办法是先在第一步中...
  • 【问题描述】 请根据给定的命题公式,计算其真值为T的小项,列出主析取范式,并输出结果。 【输入形式】 输入一个字符串(字符串长度)形式的命题公式,以回车表示输入结束。其中的命题公式为仅包含原子命题、联结词...
  • 法一:相信大家都会的方法是——真值表法, 把真值表写出来后,把真值为1的项合取的结果就是主析取范式, 把真值为0的项析取的结果就是主合取范式。 法二(重点):这里讲得是配凑法。配凑法能直接配出来主析取范式...
  • 主析取范式与主合取范式

    万次阅读 多人点赞 2019-04-08 02:27:36
    主析取范式与主合取范式 定义设A为恰含命题变元p1,…,pn的公式。公式A'称为A的主析(合)取范式(majordisjunctive(conjunctive)normal form),如果A'是A的析(合)取范式,并且其每个合(析)取子句中p1,…,...
  • 最后根据tr和flase的数组来打印主析取范式和主合取范式。 #include #include #include //vector是顺序容器 #include #include #include //queue 模板类也需要两个模板参数,一个是元素类型,一个容器类型,元素类型...
  • 主析取范式和主合取范式

    千次阅读 2021-04-06 15:31:04
    主析取范式 小项 是n个命题变元的合取式,其中每个变元必出现且仅出现一次(以本身或否定形式),称这个合取式为小项 例:含有两个变元的小项 P ^ Q , P ^ !Q , !P ^ Q , !P ^ !Q 若有n个变元,则有2的n次方个小项 ...
  • 使用C++命题公式的主析取范式与主合取范式

    千次阅读 多人点赞 2018-09-22 17:21:29
    最近的离散数学的一个上机作业,要求任意输入一个命题公式,它的真值表主析取范式和主合取范式。其中的命题连接词都是用特殊符号来表示(怕麻烦……),并最终选择使用C++来编写程序。 先贴代码: // 五种...
  • 请根据给定的命题公式,计算其真值为T的小项,列出主析取范式,并输出结果。 【输入形式】 输入一个字符串(字符串长度<=50)形式的命题公式,以回车表示输入结束。其中的命题公式为仅包含原子命题、联结词和...
  • 输入命题公式的合式公式,出公式的真值表,并输出该公式的主合取范式和主析取范式。 Input 命题公式的合式公式 Output 公式的主析取范式和主合取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项和 ∨ 符号...
  • 2.2析取范式与合取范式

    万次阅读 2019-08-15 11:26:13
    2.2析取范式与合取范式 本节给出命题公式的两种规范表示方法,这种规范的表达式能表达真值表所能提供的一切信息 定义2.2命题变项及其否定统称作文宇.仅由有限个文字构成的析取式称作简单析取式仅由有限个文字构成...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 537
精华内容 214
关键字:

真值表法求主析取范式