精华内容
下载资源
问答
  • 主析取范式与主合取范式
    千次阅读
    2021-03-11 19:08:24

    主析取范式与主合取范式

    概念性的定义用自己的理解解释,所以有不严谨的地方,以教材为准
    范式:是将复杂的复合命题化简成为只有基本联结词的形式(化简掉蕴含,等价)
    简单析取(合取)范式:有限个文字构成。
    析取范式:有限个简单合取式用(析或)联结词构成
    合取范式:有限个简单析取式用(合取)联结词构成
    极大值(极小值):每个命题变项及其否定只出现一次 ,所有的极小值(主析取范式对应)或极大值(主合取范式对应)放到一张表格,并赋值则为真值表。-----------这也解释了为什么可以用求主析(合)取范式可以作为一种用于论证结论是否成立的方法。
    主析取范式是极小项构成 联结词为析取
    主合取范式是极大项构成 联结词为合取
    求主析取范式和主合取范式的方法步骤(不是文字题直接从2开始):
    1)将命题符号化,根据题意化为复杂命题,然后化为范式
    2)如果求主析取范式则化为合取范式
    3)以主析取范式为例:确定中间的联结词是析取,然后如果分出的多个合取范式有缺少命题的,用排中律(矛盾律)加上
    4)按照角标,将每一个极大(极小)项用名称表示。

    更多相关内容
  • 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() == '|...

    代码如下:

    #include <iostream>
    #include <stack>
    #include <string>
    #include <vector>
    using namespace std;
    const int N = 300;
    stack<char> s;
    stack<char> v;
    int seq;
    bool vis[N];
    bool flag[N];
    void dfs(int n);
    vector<int> ans_v;
    vector<int> ans_vf;
    
    
    void printMenu()
    {
    	cout << "代码其实有点不健壮,需要用括号来手动处理优先级!" << endl;
    	cout << "比如:!!!(a&b&c)  要写成!(!(!(a&b&c)))" << endl;
    	cout << "比如:!(a&b)->c 要写成 (!(a&b))>c" << endl;
    	cout << "合取& 析取| 非! 条件> 双条件~ 括号() " << endl;
    	cout << endl;
    }
    
    void printAns(vector<int> &ans_v, char f, char v)
    {
    	for (int i = 0; i < ans_v.size(); i++)
    	{
    		cout << f << ans_v[i];
    		if (i != ans_v.size() - 1)
    		{
    			cout << v;
    		}
    	}
    	cout << endl;
    }
    
    
    
    
    void calculator(int n, string &str)
    {
    	str = '(' + str + ')';
    	for (int i = 0; i < str.length(); i++)
    	{
    		char tmp = str[i];
    
    		if (tmp >= 'a' && tmp <= 'z')
    		{
    			vis[tmp - 'a'] = true;
    			s.push(tmp);
    		}
    		else if (tmp == '(')
    		{
    			v.push(tmp);
    		}
    		else if (tmp == ')')
    		{
    			while (v.top() != '(')
    			{
    				s.push(v.top());
    				v.pop();
    			}
    			v.pop();
    		}
    		else
    		{
    			v.push(tmp);
    		}
    	}
    
    
    
    
    	stack<char>t;
    	while (!s.empty())
    	{
    		t.push(s.top());
    		s.pop();
    	}
    	s = t;
    
    
    	stack<char>h(s);
    	while (!h.empty())
    	{
    		cout << h.top();
    		h.pop();
    	}
    	cout << endl;
    
    	dfs(0);
    	cout << "主合取范式为:" << endl;
    	printAns(ans_v, 'm', '&');
    	cout << "主析取范式为:" << endl;
    	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() == '|' || s_s.top() == '~' || s_s.top() == '>')
    			{
    				if (s_s.top() == '&')
    				{
    					s_s.pop();
    					bool a2 = s_t.top();
    					s_t.pop();
    					bool a1 = s_t.top();
    					s_t.pop();
    					bool ans = a2 && a1;
    					s_t.push(ans);
    				}
    				else if (s_s.top() == '|')
    				{
    					s_s.pop();
    					bool a2 = s_t.top();
    					s_t.pop();
    					bool a1 = s_t.top();
    					s_t.pop();
    					bool ans = a2 || a1;
    					s_t.push(ans);
    				}
    				else if (s_s.top() == '>')
    				{
    					s_s.pop();
    					bool a2 = s_t.top();
    					s_t.pop();
    					bool a1 = s_t.top();
    					s_t.pop();
    					if (a1 == true && a2 == true)
    					{
    						s_t.push(true);
    					}
    					else if (a1 == true && a2 == false)
    					{
    						s_t.push(false);
    					}
    					else if (a1 == false)
    					{
    						s_t.push(true);
    					}
    				}
    				else if (s_s.top() == '~')
    				{
    					s_s.pop();
    					bool a2 = s_t.top();
    					s_t.pop();
    					bool a1 = s_t.top();
    					s_t.pop();
    					if (a1 == a2)
    					{
    						s_t.push(true);
    					}
    					else s_t.push(false);
    				}
    			}
    			else if (s_s.top() == '!')
    			{
    				s_s.pop();
    				bool tmp = !s_t.top();
    				s_t.pop();
    				s_t.push(tmp);
    			}
    			else
    			{
    				s_t.push(flag[s_s.top() - 'a']);
    				s_s.pop();
    			}
    
    		}
    
    		for (int i = 0; i < 26; i++)
    		{
    			if (vis[i])
    			{
    				cout << char(i + 'a') << "=" << flag[i] << " ";
    			}
    		}
    
    
    
    		if (s_t.top())
    		{
    
    			ans_v.push_back(seq);
    			cout << "ans=true" << endl;
    		}
    		else
    		{
    			ans_vf.push_back(seq);
    			cout << "ans=false" << endl;
    		}
    		seq++;
    
    		return;
    
    	}
    
    	if (vis[n])
    	{
    		for (int i = 0; i <= 1; i++)
    		{
    			flag[n] = i;
    			dfs(n + 1);
    		}
    	}
    	else
    	{
    		dfs(n + 1);
    	}
    
    
    }
    
    
    
    
    int main()
    {
    	int n;
    	string str;
    	printMenu();
    	cout << "请先输入式子含有的变量个数" << endl;
    	cin >> n;
    	cout << "按格式输入式子" << endl;
    	cin >> str;
    	calculator(n, str);
    	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;
    }
    
    
    




    展开全文
  • 编程析取范式求主析取范式。。

    千次阅读 2014-11-03 10:43:47
     ...离散数学中析取范式如何通过计算机求主析取范式。其中一种办法就是用二维数组存储析取范式的真值表,然后代入命题公式,真值为T,就是它的最小项。其中会用到栈这种数据结构判断优先级。。
    
    离散数学中析取范式如何通过计算机求主析取范式。其中一种办法就是用二维数组存储析取范式的真值表,然后代入命题公式,真值为T,就是它的最小项。其中会用到栈这种数据结构判断优先级。。
    #include<iostream>
    #include <cstdio>  
    #include <cstdlib>
    #include <string>
    using namespace std;
    template<class T>
    class stack
    {
    private:
    	int top;
    	T *atr;
    	int maxize;
    public:
    	stack(int size=0);
    	~stack();
    	bool IsFull();
    	bool IsEmpty();
    	void pop(T &item);
    	void push(T &item);
    	void clear();
    	void GetTop(T &item);
    };
    class calculator
    {
    private:
    	int number;
    	int iN;
    	string thz;
    	char* min;
    	int **p;
    	string st1;
    public:
    	calculator();
    	~calculator();
    	void TheMin();
    	void show();
    };
    template<class T>
    stack<T>::stack(int size=0)
    {
    	maxize = size;
    	atr = new T[maxize];
    	top = -1;
    }
    template<class T>
    stack<T>::~stack()
    {
    	delete[]atr;
    }
    template<class T>
    bool stack<T>::IsFull()
    {
    	return top ==maxize - 1;
    }
    template<class T>
    bool stack<T>::IsEmpty()
    {
    	return top== -1;
    }
    template<class T>
    void stack<T>::clear()
    {
    	top == -1;
    }
    template<class T>
    void stack<T>::pop(T &item)
    {
    	item = atr[top--];
    }
    template<class T>
    void stack<T>::push(T &item)
    {
    	atr[++top] = item;
    }
    template<class T>
    void stack<T>::GetTop(T &item)
    {
    	item = atr[top];
    }
    calculator::calculator()
    {
    	char p[100], c = '\0',a='\0';
    	stack <char> s(10);
    	int i = 0;
    	number = 0;
    	cout << "输入*表示合取,+表示析取,!表示非,记得输入大写字母的命题变员" << endl;
    	while (1)
    	{
    		c = getchar();
    		if (c == '\n')
    			break;
    		p[i++] = c;
    	}
    	
    	for (int j = 0; j < i; j++)
    	{
    		if (p[j] >= 'A'&&p[j] <= 'Z')
    		{
    			thz += p[j];
    			int k = 0;
    			for (;st1[k];k++)
    			{
    				if (p[j] == st1[k])
    					break;
    			}
    			if (!st1[k])
    			{
    				st1 += p[j];
    				number++;
    			}
    		}
    		else if (p[j] == '+' || p[j] == '*' || p[j] == '!'||p[j]=='(')
    		{
    			s.GetTop(c);
    			if (s.IsEmpty()||p[j]=='!'||p[j] == '(')
    			{
    				s.push(p[j]);
    			}
    			else if (p[j] == '*'&&(c=='*'||c=='!'))
    			{
    				s.pop(a);
    				thz += a;
    				s.push(p[j]);
    			}
    			else if (p[j] == '+'&&!s.IsEmpty() && c != '(')
    			{
    				s.pop(a);
    				thz += a;
    				s.push(p[j]);
    			}
    			else if (c == '(')
    				s.push(p[j]);
    		}
    		else if (p[j] == ')')
    		{
    			if (!s.IsEmpty())
    			{
    				while (!s.IsEmpty())
    				{
    					s.pop(a);
    					if (a == '(')
    						break;
    					thz += a;
    				}
    				if (a != '(')
    				{
    					cout << "能不能输入正确呀!" << endl;
    					return ;
    				}
    			}
    			else
    			{
    				cout << "哈哈哈,你又错了!" << endl;
    				return;
    			}
    		}
    	}
    	while (!s.IsEmpty())
    	{
    		s.pop(a);
    		thz += a;
    		
    	}
    }
    calculator::~calculator()
    {    
    	
    	for (int i = 0; i < iN; i++)
    	{
    		delete[]p[i];
    	}
    	delete []p;
    }
    void calculator::TheMin()
    {
    	stack<int> s1(20);
    	min = new char[100];
    	int a, b,c=0,d=1,t=0;
    	iN = pow(2, number);
    	int count = number;
    	p = new int*[iN];
    	for (int i = 0; i < iN; i++)
    	{
    		p[i] =new int[number];
    
    	}
    	for (int i = 0; i < iN; i++)
    	{
    		for (int j = count - 1, k = i; j >= 0; j--)
    		{
    
    			p[i][j] = k % 2;
    			k = k / 2;
    		}
    	}
    	int k = 0;
    	for (; k<iN; k++)
    	{
    		for (int j = 0;thz[j]; j++)
    		{
    			if (thz[j] >= 'A'&&thz[j] <= 'Z')
    			{
    				int e = 0;
    				for (; st1[e]; e++)
    				{
    					if (thz[j] == st1[e])
    						break;
    				}
    				s1.push(p[k][e]);
    			}
    			else if (thz[j] == '!')
    			{
    				s1.pop(a);
    				if (a == 1)
    					s1.push(c);
    				else
    					s1.push(d);
    			}
    			else if (thz[j]=='*')
    			{
    				s1.pop(a);
    				s1.pop(b);
    				if (a == 1 && b == 1)
    					s1.push(d);
    				else
    					s1.push(c);
    			}
    			else
    			{
    				s1.pop(a);
    				s1.pop(b);
    				if (a == 0 && b == 0)
    					s1.push(c);
    				else
    					s1.push(d);
    			}
    		}
            s1.pop(a);
    		if (a == 1)
    		{
    			for (int f = 0; f < number; f++)
    				{
    					if (p[k][f] == 0)
    					{
    						min[t++]= '!';
    						min[t++]= st1[f];
    					}
    					if (p[k][f] == 1)
    						min[t++]= st1[f];
    					if (f != number - 1)
    						min [t++]= '*';
    				}
    				min[t++]= '+';
    	}
    }
    	min[t] = '\0';
    	for (int i = 0; i<t-1; i++)
    	{
    		cout << min[i];
    	}
    }
    int main()
    {
    	calculator c;
    	c.TheMin();
    }

    展开全文
  • 求解主析取范式、主合取范式方法 ①真值表法 ②等值演算法 例题 公式 (p→q)∧(q→r) 的主析取范式和主合取范式、成真赋值。 解: ①真值表法 p q r p→q q→r (p→q)∧(q→r) 0 0 0 1 1 1 0 0 1 1 1 1 ...
  • 范式 6.1 文字、析取式、合取式、析取范式、合取范式和方法 6.2 主析取范式 6.2.1 极小项、编码及其性质 6.2.2 主析取范式方法(真值表和逻辑推演) 6.3 主合取范式 6.3.1 极大项、编码及其性质 6.2.2 ...
  • 公式法主合取范式和主析取范式的一种思路
  • 公式(p∨q)→r的主析取范式。 [输入] 本题无输入。 [输出] 在单独的一行中输出公式的主析取范式,所有极小项按照对应的解释的字典顺序输出,即┐p∧┐q∧┐r是字典序的第一个极小项,p∧q∧r是字典序的最后...
  • 1. 简单 析取 合取 式 ( 1 ) 简单合取式 ( 2 ) 简单析取式 2. 极小项 ( 1 ) 极小项 简介 ( 2 ) 极小项 说明 ( 3 ) 两个命题变项 的 极小项 ( 4 ) 三个命题变项 的 极小项 ( 5 ) 极小项 成真赋值 公式 名称 ...
  • 离散数学主析取范式及主合取范式

    万次阅读 多人点赞 2018-03-28 19:28:21
    今天总结了一下关于离散数学化简主析取范式以及主合取范式的一些方法。首先一般可能会用到 分配律: A∨(B∧C)&lt;=&gt;(A∨B)∧(A∨C), A∧(B∨C)&lt;=&gt;(A∧B)∨(A∧C);其次若化简式里有蕴涵...
  • 最后根据tr和flase的数组来打印主析取范式和主合取范式。 #include #include #include //vector是顺序容器 #include #include #include //queue 模板类也需要两个模板参数,一个是元素类型,一个容器类型,元素类型...
  • 法一:相信大家都会的方法是——真值表法, 把真值表写出来后,把真值为1的项合取的结果就是主析取范式, 把真值为0的项析取的结果就是主合取范式。 法二(重点):这里讲得是配凑法。配凑法能直接配出来主析取范式...
  • 离散数学实验 /*1.对给出的任意一个命题公式(不超过四个命题变元), * 使学生会利用编程软件表示出来,并且能够计算它在各组真值指派下所应有的真值, ...*输出主析取范式、主合取范式 *输出成真赋值、成假赋值 */
  • 原式┐(P↔Q)∧(┐P→R) =┐((P∧Q)∨(┐P∧┐Q))∧(P∨R) =(┐P∨┐Q)∧(P∨Q)∧(P∨R) =(┐P∨┐Q∨┐R)∧(┐P∨┐Q∨R)∧(P∨Q∨┐R)∧(P∨Q∨R)∧(P∨┐Q∨R)
  • 利用真值表法主合取范式及主析取范式的实现

    万次阅读 多人点赞 2016-09-29 18:23:45
    利用真值表法求主析取范式及主析取范式的实现(C++) 功能:用户可输入合式公式(包含!&|以及圆括号),程序即可输出变元真值表及主合取范式及主析取范式 《离散数学》南京邮电大学学习期间,离散数学实验一 2016.9...
  • 构造主析取范式(离散数学)

    千次阅读 2019-06-11 09:12:58
    构造主析取范式 先上图。。。 主界面: 真值表: 主析取范式
  • 2.2析取范式与合取范式

    万次阅读 2019-08-15 11:26:13
    2.2析取范式与合取范式 本节给出命题公式的两种规范表示方法,这种规范的表达式能表达真值表所能提供的一切信息 定义2.2命题变项及其否定统称作文宇.仅由有限个文字构成的析取式称作简单析取式仅由有限个文字构成...
  • 针对给定的包含任意个变量的真值表,编程实现用真值表法取其所对应的主析取范式和主合取范式。 要求: 能够掌握通过真值表取相应主析取和主合取范式的方法及原理。 代码: /* * Author: Tob_yuhong * ...
  • 方法涉及栈的应用,经过本人测试正确, 上传的代码可能有的符号有问题,可略改 代码如下: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #define TRUE...
  • 【单选题】不是电化学分析仪器测量的特性为( ) 【单选题】车站对托运人提出的发货需求,经确认,在货物运单上签证货物约定交接日期,即为 【问答题】公式q→(r∧p)的析取范式。 【单选题】邯郸学步出自哪个典故...
  • 主析取范式

    千次阅读 2020-04-14 14:00:42
    #include<bits/stdc++.h> using namespace std; stackoptr; stackopnd; int cmp[10][10] { {’ ‘,’!’,’!’,’!’,’!’,’<’,’!’,’!’},//! {’<’,’>’,’>’,’>......
  • 本程序可以实现任意输入表达式,变元数最多可为3个,即可输出主析取式和主合取式。 规定符号: ! 否定 | 析取 & 合取 -> 条件 双条件 #include #include usingnamespace std;... //主析取范式
  • 离散数学上机实验,给定一个命题公式,主析取范式,主合取范式,能力有限,参考了我学长的一篇博客,并进行了许多优化。 本次离散数学实验,我学到了许多东西,也看了自己的不足之处 1).我深刻地体会到在比较...
  • 在物理优化中, 会调用 DetachCondAndBuildRangeForIndex 来生成扫描区间, 这个函数会递归的调用如下 2 个函数: detachDNFCondAndBuildRangeForIndex, 展开 析取范式(DNF), 生成扫描区间或合并扫描区间; ...
  • 析取 | ,条件 - ,双条件 =)约定 A-B为A->B 由书本定理1-3.1;制定三个规则: 规则1:将原子命题全部转换为字符1; 规则2:将!1、(1)替换为字符1; 规则3:将1|1、1&1、1-1、1=1替换为字符1。 定义替换...
  • 离散数据:析取范式与合取范式

    万次阅读 多人点赞 2019-01-09 23:20:21
    一、前言 析取范式和合取范式是命题逻辑...所以,也将给出主析取范式和主合取范式的求解方法。 二、范式存在定理 范式存在定理:任一命题公式都存在与之等值的析取范式和合取范式。 求解给定公式范式的步骤:...
  • ③正域等价类作为决策可辨识矩阵的行,分情况给出了新决策表取所有决策约简集的极小析取范式属性约简方法。该方法统一解决了相容和不相容决策表所有决策约简集的取问题,最后通过实例分析验证了算法的可行性与有效...
  • 离散数学期末复习-求主范式

    千次阅读 2021-06-09 16:54:53
    文章目录析取范式与合取范式定义简单析取式析取式简单合取式合取式析取范式合取范式范式公式A的析取范式公式A的合取...主析取范式A的主合取范式定理公式的主范式用等值演算法公式的主范式的步骤例题主范式的用途...

空空如也

空空如也

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

求主析取范式的方法