精华内容
下载资源
问答
  • 南京邮电大学实验一真值表法求主析取范式和主合取范式代码 离散数学 实 验 一利用真值表法主析取范式以及主合取范式的实现 实验名称:利用真值表法主析取范式以及主合取范式的实现 实验目的:通过编程实现...
  • 编程实现求解逻辑表达式的真值表、主析取范式主合取范式对于一个含n个命题变元的表达式(n为相异的命题变元总个数),其真值表可看作由从0到2ⁿ-1的二进制数的变化表。因此,可以通过按行列举0到2ⁿ-1的二进制数来...
  • 实 验 一利用真值表法主析取范式以及主合取范式的实现 实验名称:利用真值表法主析取范式以及主合取范式的实现 实验目的:通过编程实现主析取范式以及主合取范式的真值表法以巩固相关理论的掌握 实验...
  • 求主析取范式主合取范式

    千次阅读 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)
    最后一式即为所求的主合取范式。

    展开全文
  • 主析取范式和主合取范式的c++求解程序

    千次阅读 多人点赞 2019-10-27 19:40:14
    主要思想是:先求真值表,再根据真值表输出主析取范式和主合取范式。 用!来表示非,用小写v表示析取,用^来表示合取,用~来表示双条件,用-来表示条件,用大写字母来表示命题变元。 真值表的...

    这是我们老师刚刚布置的作业,自己百度了一下,发现没有比较简单完善的程序代码,于是自己写成功后,与大家分享一下。有些地方描述的不好,可能比较难理解,请见谅。如果有啥不懂的,可以在下面评论,我会尽力解答
    一、算法思想
    主要思想是:先求真值表,再根据真值表输出主析取范式和主合取范式。

    用!来表示非,用小写v表示析取,用^来表示合取,用~来表示双条件,用-来表示条件,用大写字母来表示命题变元。

    真值表的求解
    ① 根据命题的个数n,得出所有命题变元赋值的情况个数sum,例如n=4个命题变元,则有sum=2^4种情况,并将所有情况存入二维数组a[i][j]中,a[i]代表第i种情况。
    ② 创建两个栈,一个用来存放操作符Operator,先自己在栈里面存放字符‘#’(输入命题公式时要最后应该加一个字符‘#’);一个存放操作数Operand。
    ③ 根据表达式求值的思想,读取表达式,若是操作符,则与之前的操作符相比优先级,若大于前者,则读取下一个;若相等,则说明两者为()则弹出前者,读取下一个;若小于前者,则可以进行运算;
    ④ 若读取的是操作数,则在数组a中读取操作数所对应的数,存入栈中;
    ⑤ 将最后的运算结果存入数组result中,再次循环步骤③,循环sum次即可
    ⑥ 根据result的结果,当输出主析取范式时,当result[i]==1时,则输出相应的命题变元(当命题变元为1则输出P,为0则输出!P),把result都遍历一遍,将结果为1的都连在一起即可;求取主合取范式就将result=0的输出连在一起即可;
    二、源代码

    第一个头文件const.h//预定义常量头文件
    #pragma once

    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 1
    #define INFEASIBLE -1
    #define OVERFLOW -2

    typedef int Status;

    第二个头文件prefunction.h//变量类型的定义与函数的声明
    #pragma once

    #include"const.h"

    #define STACK_INIT_SIZE 100
    #define STACKINCREMENT 10

    typedef char SElemType;

    typedef int SElemType_1;

    typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;
    }SqStack;//操作符栈

    typedef struct {
    SElemType_1 *INTbase;
    SElemType_1 *INTtop;
    int INTstacksize;
    }INTStack;//操作数栈
    Status InitStack(SqStack &S);//初始化
    Status GetTop(SqStack S, SElemType &e);//读栈顶
    Status Push(SqStack &S, SElemType e);//入栈
    Status Pop(SqStack &S, SElemType &e);//出栈
    Status initStack(INTStack &S);// 初始化
    Status pop(INTStack &S, SElemType_1 &e);// 出栈
    Status push(INTStack &S, SElemType_1 e);// 入栈
    char precede(SElemType e1, SElemType e2);//判断操作数的优先级
    Status bothway(int &a, SElemType b, int c);//双向运算符操作
    Status TruthTable(int a[65][6], int count,char ch[6]);//真值表
    Status Proposition(char a[50], char ch[6]);//求命题的个数

    第二个头文件function.h
    #pragma once
    #include
    #include
    #include

    #include"prefunction.h"

    Status InitStack(SqStack &s) {
    //构造一个空的栈
    s.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if (!s.base)
    exit(OVERFLOW);
    s.top = s.base;
    s.stacksize = STACK_INIT_SIZE;
    return OK;
    }
    Status GetTop(SqStack s, SElemType &e) {
    //获得栈顶元素
    if (s.top == s.base)
    return ERROR;
    e = (s.top - 1);
    return OK;
    }
    Status Push(SqStack &s, SElemType e) {
    //插入元素e为新的栈顶
    if (s.top - s.base >= s.stacksize) {
    s.base = (SElemType
    )realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(SElemType));
    if (!s.base)
    exit(OVERFLOW);
    s.top = s.base + s.stacksize;
    s.stacksize += STACKINCREMENT;
    }
    *s.top++ = e;
    return OK;
    }
    Status Pop(SqStack &s, SElemType &e) {
    //弹出栈顶元素
    if (s.top == s.base)
    return ERROR;
    e = –s.top;
    return OK;
    }
    Status initStack(INTStack &s)
    {
    //构造一个空的栈
    s.INTbase = (SElemType_1
    )malloc(STACK_INIT_SIZE * sizeof(SElemType_1));
    if (!s.INTbase)
    exit(OVERFLOW);
    s.INTtop = s.INTbase;
    s.INTstacksize = STACK_INIT_SIZE;
    return OK;
    }
    Status pop(INTStack &s, SElemType_1 &e)
    {//弹出栈顶元素
    if (s.INTtop == s.INTbase)
    return ERROR;
    e = –s.INTtop;
    return OK;
    }
    Status push(INTStack &s, SElemType_1 e)
    {
    //插入元素e为新的栈顶
    if (s.INTtop - s.INTbase >= s.INTstacksize) {
    s.INTbase = (SElemType_1
    )realloc(s.INTbase, (s.INTstacksize + STACKINCREMENT) * sizeof(SElemType_1));
    if (!s.INTbase)
    exit(OVERFLOW);
    s.INTtop = s.INTbase + s.INTstacksize;
    s.INTstacksize += STACKINCREMENT;
    }
    *s.INTtop++ = e;
    return OK;
    }
    char precede(SElemType e1, SElemType e2)//判断操作数的优先级
    {
    if (e1 == ‘v’&&e2 == ‘v’)
    return ‘>’ ;
    if (e1 == ‘v’&&e2 == ‘^’)
    return ‘>’;
    if (e1 == ‘v’&&e2 == ‘~’)
    return ‘>’;
    if (e1 == ‘v’&&e2 == ‘-’)
    return ‘>’;
    if (e1 == ‘v’&&e2 == ‘)’)
    return ‘>’;
    if (e1 == ‘v’&&e2 == ‘(’)
    return ‘<’;
    if (e1 == ‘v’&&e2 == ‘#’)
    return ‘>’;

    if (e1 == '^'&&e2 == 'v')
    	return '>';
    if (e1 == '^'&&e2 == '^')
    	return '>';
    if (e1 == '^'&&e2 == '~')
    	return '>';
    if (e1 == '^'&&e2 == '-')
    	return '>';
    if (e1 == '^'&&e2 == ')')
    	return '>';
    if (e1 == '^'&&e2 == '(')
    	return '<';
    if (e1 == '^'&&e2 == '#')
    	return '>';
    
    if (e1 == '-'&&e2 == 'v')
    	return '>';
    if (e1 == '-'&&e2 == '^')
    	return '>';
    if (e1 == '-'&&e2 == '~')
    	return '>';
    if (e1 == '-'&&e2 == '-')
    	return '>';
    if (e1 == '-'&&e2 == ')')
    	return '>';
    if (e1 == '-'&&e2 == '(')
    	return '<';
    if (e1 == '-'&&e2 == '#')
    	return '>';
    
    if (e1 == '~'&&e2 == 'v')
    	return '>';
    if (e1 == '~'&&e2 == '^')
    	return '>';
    if (e1 == '~'&&e2 == '~')
    	return '>';
    if (e1 == '~'&&e2 == '-')
    	return '>';
    if (e1 == '~'&&e2 == ')')
    	return '>';
    if (e1 == '~'&&e2 == '(')
    	return '<';
    if (e1 == '~'&&e2 == '#')
    	return '>';
    
    if (e1 == '('&&e2 == 'v')
    	return '<';
    if (e1 == '('&&e2 == '^')
    	return '<';
    if (e1 == '('&&e2 == '~')
    	return '<';
    if (e1 == '('&&e2 == '-')
    	return '<';
    
    
    
    if (e1 == '#'&&e2 == 'v')
    	return '<';
    if (e1 == '#'&&e2 == '^')
    	return '<';
    if (e1 == '#'&&e2 == '~')
    	return '<';
    if (e1 == '#'&&e2 == '-')
    	return '<';
    if (e1 == '#'&&e2 == '(')
    	return '<';
    
    if (e1 == '!'&&e2 == 'v')
    	return '>';
    if (e1 == '!'&&e2 == '^')
    	return '>';
    if (e1 == '!'&&e2 == '~')
    	return '>';
    if (e1 == '!'&&e2 == '-')
    	return '>';
    if (e1 == '!'&&e2 == ')')
    	return '>';
    if (e1 == '!'&&e2 == '(')
    	return '<';
    if (e1 == '!'&&e2 == '#')
    	return '>';
    
    
    
    if (e1 == 'v'&&e2 == '!')
    	return '<';
    if (e1 == '^'&&e2 == '!')
    	return '<';
    if (e1 == '~'&&e2 == '!')
    	return '<';
    if (e1 == '-'&&e2 == '!')
    	return '<';
    if (e1 == '#'&&e2 == '!')
    	return '<';
    
    
    
    
    
    if (e1 == '('&&e2 == '(')
    	return '<';
    if (e1 == '('&&e2 == ')')
    	return '=';
    return 'p';
    

    }
    //用小写的v来表示析取;用^来表示合取;用-来表示条件;用~来表示双条件;
    Status bothway(int &a, SElemType b, int c)
    {
    if ( b ==‘v’) {
    if (a == 0 && c == 0)
    a = 0;
    else
    a = 1;
    }
    if (b ‘^’) {
    if (a == 1 && c == 1)
    a = 1;
    else
    a = 0;
    }
    if (b == ‘-’) {
    if (a == 1 && c == 0)
    a = 0;
    else
    a = 1;
    }
    if (b == ‘~’) {
    if (a == c)
    a = 1;
    else
    a = 0;
    }
    return OK;
    }
    Status TruthTable(int a[65][6], int count,char ch[6])//真值表
    {
    int i,sum=1,s,k,j;
    for (i = 0; i < count; i++)
    sum = sum * 2;
    i = 1;
    s = sum;
    while (i <= count) {
    s = s / 2;
    k = 0;
    j = 1;
    while (j <= sum) {
    if((j/s)%2
    0)
    for (k = 0; k < s; k++) {
    a[j-1][i-1] = 0; j++;
    }
    else
    for (k = 0; k < s; k++) {
    a[j-1][i-1] = 1; j++;
    }
    }
    i++;
    }

    return OK;
    

    }
    Status Proposition(char a[50], char ch[6])//求命题的个数
    {
    int i=0,j=0,k=0;
    int flag = 0;
    while (a[i]) {
    if (a[i] >= 65 && a[i] <= 90) {
    while (ch[j]) {
    if (a[i] == ch[j])
    flag = 1;
    j++;
    }
    if (flag == 0) {
    ch[k] = a[i];
    k++;
    }
    flag = 0;
    j = 0;
    }
    i++;
    }
    return OK;
    }
    第四个文件是cpp文件:xiquhequ.cpp
    #include"function.h"

    using namespace std;

    int main() {

    int n,a[65][6],sum=1,s;
    char exqu[50], ch[6] = {0};
    printf_s("请输入命题的个数:");
    scanf("%d", &n);
    printf_s("请输入命题表达式:");
    scanf("%s", exqu);
    for (s = 0; s < n; s++) {
    	sum = sum * 2;
    }//求所有的情况个数sum
    
    
    Proposition(exqu,ch);//将n个变量变元提取出来存入字符数组ch
    
    TruthTable(a, n, ch);//将所有情况存入数组a中
    
    
    SqStack Operator;//操作符栈
    INTStack Operand;//操作数栈
    InitStack(Operator);//初始化
    initStack(Operand);//初始化
    
    
    SElemType e;
    int k = 0,result[65];
    int i = 0,j=0;
    SElemType_1 p, q;
    SElemType	E;
    
    while (k < sum)
    {
    	*Operator.top = '#';
    	Operator.top++;
    	GetTop(Operator, e);
    	i = 0;
    	while (exqu[i] != '#' || e != '#') 
    	{
    
    
    		if (exqu[i] <= 90 && exqu[i] >= 65) {
    			while (exqu[i] != ch[j]) {
    				j++;
    			}
    			push(Operand, a[k][j]);
    			//print(Operand);
    			//*Operand.INTtop = a[k][j];// printf_s("%d", a[k][j]);
    			//Operand.INTtop++;
    			j = 0;
    			i++;
    		}
    		else {
    			GetTop(Operator, e);
    			switch (precede(e, exqu[i])) {
    			case '<':Push(Operator, exqu[i]); i++;
    				break;
    			case '=':Pop(Operator, e); i++;
    				break;
    			case '>':Pop(Operator, E); 
    				if (E == '!')
    				{
    					pop(Operand, p);
    					if (p == 0)
    						p = 1;
    					else
    						p = 0;	
    					push(Operand, p);
    
    					//print(Operand);
    					//printf("%d", p);
    				}
    				else
    				{
    					pop(Operand, p); pop(Operand, q);  bothway(q, E, p); push(Operand, q);//print(Operand);
    				}
    				break;
    			default:printf_s("precede函数返回值错误\n");
    			}
    		}
    		GetTop(Operator, e);
    	}
    
    	pop(Operand, q);
    	//printf("%d\n", q);
    	result[k] = q;
    	k++;
    	Pop(Operator, e);
    	//Pop(Operator, e);
    
    
    }
    
    
    for (i = 0; i < n; i++) {
    	printf_s("%c    ", ch[i]);
    }
    i = 0;
    while (exqu[i]!='#') {
    	printf_s("%c", exqu[i]);
    	i++;
    }
    printf_s("\n");
    for (k = 0; k < sum; k++) {
    
    	for (i = 0; i < n; i++) {
    		printf_s("%d    ", a[k][i]);
    	}
    	printf_s("%d", result[k]);
    	printf_s("\n");
    }
    
    //输出主析取范式
    printf_s("主析取范式\n");
    for (k = 0; k < sum; k++)
    {
    	if (result[k] == 1)
    	{
    		printf_s("(");
    		for (i = 0; i < n; i++)
    		{
    			if (a[k][i] == 1)
    				printf_s("%c^", ch[i]);
    			else
    				printf_s("!%c^", ch[i]);
    		}
    		printf_s("\b)v");
    	}		
    }
    printf_s("\b \n");
    
    //输出主合取范式
    printf_s("主合取范式\n");
    for (k = 0; k < sum; k++)
    {
    	if (result[k] == 0)
    	{
    		printf_s("(");
    		for (i = 0; i < n; i++)
    		{
    			if (a[k][i] == 1)
    				printf_s("%c^", ch[i]);
    			else
    				printf_s("!%c^", ch[i]);
    		}
    		printf_s("\b)v");
    	}
    }
    printf_s("\b ");
    getchar();
    getchar();
    return 0;
    

    }
    三,输入输出结果

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 研究生人工智能课的作业,主合取范式转主析取范式,敲了四五个小时,亲测可用,python版本的,用anaconda可直接运行,注释详细,要的自取
  • 离散数学实验报告
  • 主析取范式主合取范式

    千次阅读 2021-03-11 19:08:24
    主析取范式主合取范式 概念性的定义用自己的理解解释,所以有不严谨的地方,以教材为准 范式:是将复杂的复合命题化简成为只有基本联结词的形式(化简掉蕴含,等价) 简单析取(合取)范式:有限个文字构成。 析取...

    主析取范式与主合取范式

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

    展开全文
  • 使用的数据结构存储结构: 栈(中缀转后缀并计算) 数组(存放真值表) map(存放命题变元以及对应的真假值) #include<iostream> #include <string> #include <map> #include <stack> ...

    实验原理

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

    • 栈(中缀转后缀并计算)
    • 数组(存放真值表)
    • 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;
    }
    
    
    展开全文
  • 题目:根据给定的式子,先输出其真值表,再利用真值表法主析取范式以及主合取范式,输出答案。 举例:以 (P^Q) V (非P^R) 为例。 程序代码 //(P^Q) V (非P^R) //主合取范式: (非PVQV非R) ^ (非PVQVR) ^ (PV非...
  • 主析取范式和主合取范式

    千次阅读 2021-04-06 15:31:04
    主析取范式 小项 是n个命题变元的合取式,其中每个变元必出现且仅出现一次(以本身或否定形式),称这个合取式为小项 例:含有两个变元的小项 P ^ Q , P ^ !Q , !P ^ Q , !P ^ !Q 若有n个变元,则有2的n次方个小项 ...
  • 1、形式化描述实验中所使用的数据结构存储结构,给出函数之间的调用关系数据传递方式; 2、给出核心算法的C++或Java等语言的源代码,并加上详细注释,分析算法的时间复杂度; 该实验先将中缀表达式转换成后缀...
  • 编程实现用真值表法取任意数量变量的合式公式的主析取范式主合取范式。 要求: 能够列出任意合式公式的真值表并给出相应主析取和主合取范式。 内容: 编程实现用真值表法取任意数量变量的合式公式的主析取...
  • C++实现求主析取范式主合取范式

    千次阅读 2016-11-01 22:42:04
    离散数学第一次上机实验,突击学完什么是主析取范式和主合取范式之后粗略地想了下实现的思路。 第一步自然是把输入的式子转换成后缀表达式。结合数据结构书上对基本四则运算的代码前人的思路勉强写出来一个,但...
  • #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...
  • 南京邮电大学离散数学求主析取范式和主合取范式实验代码。 因为CSDN上没有好的代码,于是博主自己写了一篇。 ```cpp #include <iostream> #include <cstdlib> #include <vector> #include <...
  • 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() == '|...
  • 使用C++命题公式的主析取范式主合取范式

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

    千次阅读 2021-03-24 09:01:46
    对任意一个命题公式来说,主析取范式主合取范式都是唯一的。 命题变元指原子化的,P,Q命题。 极小项的定义:包含全部N个命题变元的合取式,称其为极小项,且N个命题变元中,每个变元与它的否定不能同时存在,但...
  • 公式的主析取范式和主合取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项 ∨ 符号之间有一个空格,极大项 ∧ 符号之间有一个空格;主析取范式和主合取范式之间用“ ; ”隔开,“ ; ”前后各有一个空格。 ...
  • 离散数学主析取范式主合取范式

    万次阅读 多人点赞 2018-03-28 19:28:21
    今天总结了一下关于离散数学化简主析取范式以及主合取范式的一些方法。首先一般可能会用到 分配律: A∨(B∧C)&lt;=&gt;(A∨B)∧(A∨C), A∧(B∨C)&lt;=&gt;(A∧B)∨(A∧C);其次若化简式里有蕴涵...
  • 对任意一个命题公式来说,主析取范式主合取范式都是唯一的。 命题变元指原子化的,P,Q命题。 极小项的定义:包含全部N个命题变元的合取式,称其为极小项,且N个命题变元中,每个变元与它的否定不能同时存在,但...
  • 主析取范式主合取范式,并公式的成真赋值和成假赋值。 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('在本题中用!代表非,&代表合取,-&...
  • C语言实现主析取范式 第一次写,不喜勿喷 (先来水一波) 先保证输入的式子是合法的 (不合法我也不会,太弱了) 难点主要是计算真值表,可以用堆栈实现,建立两个堆栈,一个储存操作符,另一个储存数值 (手写堆栈) ...
  • 本程序可以实现任意输入表达式,变元数最多可为3个,即可输出主析取式和主合取式。 规定符号: ! 否定 | 析取 & 合取 -> 条件 双条件 #include #include ... //主合取范式 ... //主析取范式
  • 针对给定的包含任意个变量的真值表,编程实现用真值表法取其所对应的主析取范式主合取范式。 要求: 能够掌握通过真值表取相应主析取和主合取范式的方法及原理。 代码: /* * Author: Tob_yuhong * ...
  • //输出主合取范式 } } if (xq[0] == -1) printf("\n该命题公式不存在主析取范式。\n"); else { printf("\n\n该命题公式的主析取范式:\n\t"); for (i1 = 0; i1 ; i1++) { if (i1 > 0) printf...
  • 离散数学主析取主合取范式

    千次阅读 2019-12-06 23:11:56
    离散数学主析取主合取范式 ...文章目录离散数学主析取主合取范式**概念**一:析取范式与合取范式析取范式与合取范式范式的步骤二:主析取主合取范式**解法**等价公式真值表注: 概念 一:析取...
  • 法一:相信大家都会的方法是——真值表法, 把真值表写出来后,把真值为1的项合取的结果就是主析取范式, 把真值为0的项析取的结果就是主合取范式。 法二(重点):这里讲得是配凑法。配凑法能直接配出来主析取范式...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 364
精华内容 145
关键字:

求主析取范式和主合取范式