精华内容
下载资源
问答
  • 南京邮电大学实验一真值表法求主析取范式和主合取范式代码 离散数学 实 验 一利用真值表法求取主析取范式以及主合取范式的实现 实验名称:利用真值表法求取主析取范式以及主合取范式的实现 实验目的:通过编程实现主...
  • 求主析取范式与主合取范式

    千次阅读 2021-06-22 20:47:13
    定义设A为恰含命题变元p1,…,pn的公式。公式A称为A的主析(合)取范式(majordisjunctive...例 公式(p∧q)∨r的主析取范式及主合取范式。 (p∧q)∨r (p∧q∧(r∨┐r))∨((p∨┐p)∧(q∨┐q)∧r) (p∧q∧r)∨(p

    定义设A为恰含命题变元p1,…,pn的公式。公式A称为A的主析(合)取范式(majordisjunctive(conjunctive)normal form),如果A是A的析(合)取范式,并且其每个合(析)取子句中p1,…,pn均恰出现一次。
    据定义,公式┐p→┐(p→q)的主析取范式是(p∧q)∨(p∧┐q),而其主合取范式则应是(p∨q)∧(p∨┐q)。
    例 求公式(p∧q)∨r的主析取范式及主合取范式。
    (p∧q)∨r
    (p∧q∧(r∨┐r))∨((p∨┐p)∧(q∨┐q)∧r)
    (p∧q∧r)∨(p∧q∧┐r)∨(p∧q∧r)∨(p∧┐q∧r)∨(┐p∧q∧r)∨(┐p∧┐q∧r)
    (p∧q∧r)∨(p∧q∧┐r)∨(p∧┐q∧r)∨(┐p∧q∧r)∨(┐p∧┐q∧r)
    此即所求的主析取范式。另外
    (p∧q)∨r
    (p∨r)∧(q∨r)
    (p∨(q∧┐q)∨r)∧((p∧┐p)∨q∨r)
    (p∨q∨r)∧(p∨┐q∨r)∧(p∨q∨r)∧(┐p∨q∨r)
    (p∨q∨r)∧(p∨┐q∨r)∧(┐p∨q∨r)
    最后一式即为所求的主合取范式。

    展开全文
  • 实 验 一利用真值表法主析取范式以及主合取范式的实现 实验名称:利用真值表法主析取范式以及主合取范式的实现 实验目的:通过编程实现主析取范式以及主合取范式的真值表法以巩固相关理论的掌握 实验...
  • 根据命题公式真值表求主析取范式。 输入格式: 第一行为命题中符号的个数(最大不超过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;
    }
    
    展开全文
  • 主析取范式

    2016-09-25 23:11:00
    简要介绍合取范式与析取范式
  • 编程析取范式求主析取范式。。

    千次阅读 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();
    }

    展开全文
  • C++实现求主析取范式、主合取范式

    千次阅读 2016-11-01 22:42:04
    离散数学第一次上机实验,突击学完什么是主析取范式和主合取范式之后粗略地想了下实现的思路。 第一步自然是把输入的式子转换成后缀表达式。结合数据结构书上对基本四则运算的代码和前人的思路勉强写出来一个,但...


    离散数学第一次上机实验,突击学完什么是主析取范式和主合取范式之后粗略地想了下实现的思路。

    第一步自然是把输入的式子转换成后缀表达式。结合数据结构书上对基本四则运算的代码和前人的思路勉强写出来一个,但还是有很多地方可能一转头就会忘了怎么实现。

    转换成后缀表达式之后的事情就显得轻松多了。

    下面贴代码。

    #include<iostream>
    #include<string>
    
    using namespace std;
    
    class SeqStack {
    public:
    	SeqStack(int mSize);
    	~SeqStack();
    	bool Push(char x);
    	bool Pop();
    	char Top();
    	bool Empty();
    private:
    	int top;
    	char *stack;
    	int maxtop;
    };
    SeqStack::SeqStack(int mSize) {
    	maxtop = mSize - 1;
    	stack = new char[mSize];
    	top = -1;
    }
    SeqStack::~SeqStack() {
    	delete[]stack;
    }
    bool SeqStack::Push(char x) {
    	if (top == maxtop)
    		return false;
    	stack[++top] = x;
    	return true;
    }
    bool SeqStack::Pop() {
    	if (-1==top )return false;
    	top--;
    	return true;
    }
    bool SeqStack::Empty() {
    	if (-1==top)return true;
    	return false;
    }
    char SeqStack::Top() {
    	return stack[top];
    }
    bool IsLegal(const string orgin) {
    	for (unsigned int i = 0; i < orgin.length(); i++) {
    		if (orgin[i] != 'P' && orgin[i] != 'Q' && orgin[i] != 'R' && orgin[i] != '&' && orgin[i] != '|' && orgin[i] != '=' && orgin[i] != '>'&&orgin[i]!='!')return false;
    	}
    	return true;
    }
    int And(int a,int b, SeqStack &stack) { 
    	int res = a * b;
    	stack.Push(res);
    	return res;
    }
    
    int Or (int a, int b, SeqStack &stack) {
    	int res = a + b;
    	res = res > 1 ? 1 : res;
    	stack.Push(res);
    	return res;
    }
    int Not(int a, SeqStack &stack) {  
    	a = stack.Top();
    	stack.Pop();
    	int res = a == 1 ? 0 : 1;
    	stack.Push(res);
    	return res;
    }
    
    int If(int a, int b, SeqStack &stack) { //条件
    	int res = (b == 1 && a == 0) ? 0 : 1;
    	stack.Push(res);
    	return res;
    }
    
    int Iif(int a, int b, SeqStack &stack) {//双条件
    	int res = (b == a) ? 1 : 0;
    	stack.Push(res);
    	return res;
    }
    
    bool CanIn(char out,SeqStack &stack) {        //先计算优先级,然后判断能否进栈
    	char in = stack.Top();
    	int i=0, o=0;  //分别表示栈内外运算符的优先级
    	switch (in) {
    	case '#':i = 0; break;
    	case '(':i = 1; break;
    	case '=':i = 3; break;
    	case '>':i = 5; break;
    	case '|':i = 7; break;
    	case '&':i = 9; break;
    	case '!':i = 11; break;
    	case ')':i = 12; break;
    	}
    
    	switch (out) {
    	case '#':o = 0; break;
    	case '(':o = 12; break;
    	case '=':o = 2; break;
    	case '>':o = 4; break;
    	case '|':o = 6; break;
    	case '&':o = 8; break;
    	case '!':o = 10; break;
    	case ')':o = 1; break;
    	}
    	if (i < o)      //栈外优先级比栈内高就进栈
    		return true;
    	else
    		return false;
    }
    
    void InfixToPostfix(string &orgin ,SeqStack &stack) {  //转换为后缀表达式
    	string tmp;                //保存后缀表达式
    	stack.Push('#');                
    	for (int i = 0; (unsigned)i <orgin.length(); i++) {
    		if (orgin[i] == 'P' || orgin[i] == 'Q' || orgin[i] == 'R' ) {
    			tmp = tmp + orgin[i];
    			continue;
    		}
    		if (CanIn(orgin[i],stack))
    			stack.Push(orgin[i]);
    		else if (orgin[i] == ')'){
    			while (stack.Top() != '('){
    				tmp = tmp + stack.Top();
    				stack.Pop();
    			}
    			stack.Pop();
    		}
    		else{
    			do{
    				tmp = tmp + stack.Top();
    				stack.Pop();
    			} while (!CanIn(orgin[i],stack));
    			stack.Push(orgin[i]);
    		}
    	}
    	while (stack.Top() != '#'){
    		tmp = tmp + stack.Top();
    		stack.Pop();
    	}
    	stack.Pop();                // '#' 出栈
    	orgin = tmp;
    }
    
    
    int Calculate(int number,string &org,SeqStack &stack, int p, int q, int r){
    	int value=0,a=0,b=0,res=0;
    	if (number == 3){
    		for (int i = 0; (unsigned)i <org.length(); i++){
    			if (org[i] == 'P' || org[i] == 'Q' || org[i] == 'R'){
    				value = org[i] == 'P' ? p : org[i] == 'Q' ? q : r;
    				stack.Push(value);
    				continue;
    			}
    			if (org[i] != '!'){
    				a = stack.Top();
    				stack.Pop();
    				b = stack.Top();
    				stack.Pop();
    			}
    			switch (org[i]){
    			case '=':res=Iif(a,b,stack); break;
    			case '>':res=If(a, b, stack); break;
    			case '|':res=Or(a, b, stack); break;
    			case '&':res=And(a, b, stack); break;
    			case '!':res=Not(a, stack); break;
    			}
    		}
    	}
    	if (number == 2){
    		for (int i = 0;(unsigned)i <org.length(); i++){
    			if (org[i] == 'P' || org[i] == 'Q'){
    				value = org[i] == 'P' ? p : q;
    				stack.Push(value);
    				continue;
    			}
    			if (org[i] != '!'){
    				a = stack.Top();
    				stack.Pop();
    				b = stack.Top();
    				stack.Pop();
    			}
    			switch (org[i]) {
    			case '=':res = Iif(a, b, stack); break;
    			case '>':res = If(a, b, stack); break;
    			case '|':res = Or(a, b, stack); break;
    			case '&':res = And(a, b, stack); break;
    			case '!':res = Not(a, stack); break;
    			}
    		}
    	}
    	return res;
    }
    char num2bool(int t) {
    	if (0 == t)return 'T';
    	else return 'F';
    }
    
    
    void Print(int number, string &orgin, SeqStack &stack) {
    	int p, q, r, res;
    	string pcnf;    //主合取范式
    	string  pdnf;    //主析取范式
    	if (number == 3) {
    		cout << "P\t" << "Q\t" << "R\t" << "Z" << endl;
    		for (p = 1; p >= 0; p--) {
    			for (q = 1; q >= 0; q--) {
    				for (r = 1; r >= 0; r--) {
    					res = Calculate(3, orgin, stack, p, q, r);
    					if (res == 1)
    						pdnf = pdnf + "(" + (p == 1 ? "P" : "!P") + "&" + (q == 1 ? "Q" : "!Q") + "&"
    						+ (r == 1 ? "R" : "!R") + ")" + " | ";
    					else
    						pcnf = pcnf + "(" + (p == 0 ? "P" : "!P") + "|" + (q == 0 ? "Q" : "!Q") + "|"
    						+ (r == 0 ? "R" : "!R") + ")" + " & ";
    					char cp, cq, cr, cres;
    					cp = num2bool(p);
    					cq = num2bool(q);
    					cr = num2bool(r);
    					cres = num2bool(res);
    					cout << cp << "\t" << cq << "\t" << cr << "\t" << cres << endl;
    				}
    			}
    		}
    	}
    	if (number == 2) {
    		cout << "P\t" << "Q\t" << "Z" << endl;
    		for (p = 1; p >= 0; p--) {
    			for (q = 1; q >= 0; q--) {
    				res=Calculate(2, orgin, stack, p, q, 0);
    				if (res == 1)
    					pdnf = pdnf + "(" + (p == 1 ? "P" : "!P") + "&" + (q == 1 ? "Q" : "!Q") + ")" + " | ";
    				else
    					pcnf = pcnf + "(" + (p == 0 ? "P" : "!P") + "|" + (q == 0 ? "Q" : "!Q") + ")" + " & ";
    				char cp, cq, cres;
    				cp = num2bool(p);
    				cq = num2bool(q);
    				cres = num2bool(res);
    				cout << cp << "\t" << cq << "\t" << cres << endl;
    			}
    		}
    	}
    	//永真和永假的情况下长度为0
    	if (pdnf.length() != 0)
    		pdnf.erase(pdnf.length() - 2);
    	if (pcnf.length() != 0)
    		pcnf.erase(pcnf.length() - 2);
    	cout << "主析取范式:" << pdnf << endl << endl;
    	cout << "主合取范式:" << pcnf << endl << endl;
    
    }
    /****************************主函数******************************/
    int main() {
    	SeqStack stack(200);
    	int cnt = 0;
    	string orgin;
    	int number;
    
    
    	cout << "/**************输入提示*****************/" << endl;
    	cout << "/*              ! 否定                 */" << endl;
    	cout << "/*              | 析取                 */" << endl;
    	cout << "/*              & 合取                 */" << endl;
    	cout << "/*              > 条件                 */" << endl;
    	cout << "/*              = 双条件               */" << endl;
    	cout << "/**************输入提示*****************/" << endl;
    	cout << "请输入变元数量 (2 或 3)" << endl;
    
    	loop:cin >> number;
    	if(2==number) 
    		cout << endl << "变元请用P、Q表示" << endl ;
    	else if (3==number)
    		cout << endl << "变元请用P、Q、R表示" << endl;
    	else {
    		cout << "请输入2或3:  " << endl;
    		goto loop;
    	}
    	cout << "输入命题:";
    	int flag = 0;
    	
    	do {
    		if (flag != 0) {
    			cout << "输入包含不合法字符,请仔细阅读输入提示并重新输入\n(符号请使用半角英文符号)" << endl;
    			cout << "输入命题:";
    		}
    		cin >> orgin;
    		flag = 1;
    	} while (!IsLegal(orgin));
    	InfixToPostfix(orgin,stack);
    	Print(number,orgin,stack);
    	while (1);
    	return 0;
    
    }



    展开全文
  • 关于离散数学中主合取与主析取范式的实现,主要通过c++实现
  • 编程实现求解逻辑表达式的真值表、主析取范式、主合取范式对于一个含n个命题变元的表达式(n为相异的命题变元总个数),其真值表可看作由从0到2ⁿ-1的二进制数的变化表。因此,可以通过按行列举0到2ⁿ-1的二进制数来...
  • 主析取范式和主合取范式的c++求解程序

    千次阅读 多人点赞 2019-10-27 19:40:14
    主要思想是:先求真值表,再根据真值表输出主析取范式和主合取范式。 用!来表示非,用小写v表示析取,用^来表示合取,用~来表示双条件,用-来表示条件,用大写字母来表示命题变元。 真值表的...
  • 南京邮电大学离散数学求主析取范式和主合取范式实验代码。 因为CSDN上没有好的代码,于是博主自己写了一篇。 ```cpp #include <iostream> #include <cstdlib> #include <vector> #include <...
  • 实验原理 使用的数据结构和存储结构: 栈(中缀转后缀并计算) 数组(存放真值表) map(存放命题变元以及对应的真假值) #include #include #include #include ... cout 主析取范式为:" ; cout 主合取范式为:" ; }
  • 主析取范式与主合取范式

    万次阅读 多人点赞 2019-04-08 02:27:36
    主析取范式与主合取范式 定义设A为恰含命题变元p1,…,pn的公式。公式A'称为A的主析(合)取范式(majordisjunctive(conjunctive)normal form),如果A'是A的析(合)取范式,并且其每个合(析)取子句中p1,…,...
  • 题目:根据给定的式子,先输出其真值表,再利用真值表法主析取范式以及主合取范式,输出答案。 举例:以 (P^Q) V (非P^R) 为例。 程序代码 //(P^Q) V (非P^R) //主合取范式: (非PVQV非R) ^ (非PVQVR) ^ (PV非...
  • 编程实现用真值表法取任意数量变量的合式公式的主析取范式和主合取范式。 要求: 能够列出任意合式公式的真值表并给出相应主析取和主合取范式。 内容: 编程实现用真值表法取任意数量变量的合式公式的主析取...
  • 计算主析取范式 【问题描述】 请根据给定的命题公式,计算其真值为T的小项,列出主析取范式,并输出结果。 【输入形式】 输入一个字符串(字符串长度<=50)形式的命题公式,以回车表示输入结束。其中的命题公式为...
  • 请根据给定的命题公式,计算其真值为T的小项,列出主析取范式,并输出结果。 【输入形式】 输入一个字符串(字符串长度<=50)形式的命题公式,以回车表示输入结束。其中的命题公式为仅包含原子命题、联结词和括号...
  • 主析取范式 对任意一个命题公式来说,主析取范式与主合取范式都是唯一的。 命题变元指原子化的,P,Q命题。 极小项的定义:包含全部N个命题变元的合取式,称其为极小项,且N个命题变元中,每个变元与它的否定不能...
  • 任意输入一个命题公式,计算并输出其真值表以及主析取范式,主合取范式 思路:大概就是将蕴含,等价,异或进行转化,然后使用eval()计算 #! /usr/bin/env python3 # -*- coding:utf-8 -*- sInput = '' #输入的命题...
  • 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() == '|...
  • 法一:相信大家都会的方法是——真值表法, 把真值表写出来后,把真值为1的项合取的结果就是主析取范式, 把真值为0的项析取的结果就是主合取范式。 法二(重点):这里讲得是配凑法。配凑法能直接配出来主析取范式...
  • 离散数学主析取范式及主合取范式

    万次阅读 多人点赞 2018-03-28 19:28:21
    今天总结了一下关于离散数学化简主析取范式以及主合取范式的一些方法。首先一般可能会用到 分配律: A∨(B∧C)&lt;=&gt;(A∨B)∧(A∨C), A∧(B∨C)&lt;=&gt;(A∧B)∨(A∧C);其次若化简式里有蕴涵...
  • #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...
  • C# 主析取范式求解工具,对于输入的表达式,可以快速地得出其极小项
  • 标题:真值表求主析取范式、主合取范式的计算机语言实现 背景 语言、环境选择 C++ Visual Studio 2010 知识涉及(关键词) 线性栈的使用 中缀表达式,后缀表达式 映射 二进制枚举 实验思路 将中缀表达式转化...
  • 使用C++命题公式的主析取范式与主合取范式

    千次阅读 多人点赞 2018-09-22 17:21:29
    最近的离散数学的一个上机作业,要求任意输入一个命题公式,它的真值表与主析取范式和主合取范式。其中的命题连接词都是用特殊符号来表示(怕麻烦……),并最终选择使用C++来编写程序。 先贴代码: // 五种...
  • 利用真值表法主合取范式及主析取范式的实现

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

    千次阅读 2019-06-11 09:12:58
    构造主析取范式 先上图。。。 主界面: 真值表: 主析取范式
  • 主析取范式与主合取范式,并公式的成真赋值和成假赋值。 a1 = [0,0,0,0,1,1,1,1]; a2 = [0,0,1,1,0,0,1,1]; a3 = [0,1,0,1,0,1,0,1]; a4 = [1,1,0,0,1,1,0,0]; fprintf('在本题中用!代表非,&代表合取,-&...

空空如也

空空如也

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

求主析取范式