Java求取主析取范式、主合取范式、成真赋值、成假赋值、打印真值表

最新推荐文章于 2024-04-21 10:02:34 发布
最新推荐文章于 2024-04-21 10:02:34 发布
阅读量8.7k 收藏 63
点赞数 11
文章标签： java 后端 eclipse 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57076620/article/details/121865586
版权

离散数学实验

/*1.对给出的任意一个命题公式（不超过四个命题变元），
 * 使学生会利用编程软件表示出来，并且能够计算它在各组真值指派下所应有的真值，
 * 画出其真值表。
 * （1）﹁(﹁p∨q)∧q的真值表；
 * （2）(p∨q)→﹁r的真值表；
 */

/*2.输入命题公式(p→﹁q)→r
  *输出主析取范式、主合取范式
  *输出成真赋值、成假赋值
*/

实现思路：先求出命题公式变元由000~111的真值储存在数组中，循环遍历输出真值表；当命题公式真值为1时对应的变元值为成真赋值，此时若对应变元值为0输出对应变元的非，否则直接输出变元与变元之间用合取联结词连接，公式与公式之间用析取联结词连接（此时为主析取范式）；当命题公式真值为0时对应变元值为成假赋值，此时若对应变元值为0输出对应变元的非，否则直接输出，变元与变元之间用析取联结词连接，公式与公式间用合取联结词连接（此时为主合取范式）。

        命题公式的计算用后缀表达式（逆波兰表达式）求解，后缀表达式用栈来存储。

        在思考解决主析取范式、主合取范式时走了很多的弯路，后来经过很久才发现真值表与范式之间的联系，其实想通了写起来非常的顺畅。写完也非常的有成就感。

打印真值表代码运行结果：

 

 

主析取范式、主合取范式、成真赋值、成假赋值代码运行结果：

package experiment;

public class LogicalOperation {

	int disjunction(int x,int y){//析取∨
		if(x==1||y==1) {
			return 1;
		}
		else return 0;
	}
	int conjunction(int x,int y) {//合取∧
		if(x==y&&x==1) {
			return 1;
		}
		else return 0;
	}
	int nagation(int x) {//否定
		if(x==0) {
			return 1;
		}
		else return 0;
	}
	int implication(int x,int y) {//蕴涵
		if(x==1&&y==0) {
			return 0;
		}
		else return 1;
	}
	int equivalence(int x,int y) {//等价
		if(x==y) {
			return 1;
		}
		else return 0;
	}
}

 NormalForm.java

包含求取真值表、主析取范式、主合取范式、成真赋值、成假赋值等的方法

package experiment;

public class NormalForm {
	String form;
	int count=0;
	int count0=0;
	int count1=0;
	
	Proposition fo;
	Translation tr;
	NormalForm(String form){
		this.form=form;
		fo = new Proposition(form);
		tr = new Translation(form);
		tr.judge();
	}
	
	void calculate() {
		int [] x=new int[4];
		for(int i=0;i<2;i++) {
			for(int j=0;j<2;j++) {
				for(int k=0;k<2;k++) {
					for(int l=0;l<2;l++) {
						fo.va1[count]=i;
						fo.va2[count]=j;
						fo.va3[count]=k;
						fo.va4[count]=l;
						x[0]=i;
						x[1]=j;
						x[2]=k;
						x[3]=l;
						fo.truth[count]=tr.operate(x);
						if(fo.truth[count]==0) {
							count0++;
						}
						else
							count1++;
						count++;	
					}					
				}
			}
		}
	}
	void table() {
		if(tr.judge()==2) {
			System.out.println(tr.va[0]+" "+tr.va[1]+" "+tr.pfr);
			for(int i=0;i<4;i++) {
				System.out.println(fo.va1[i*4]+" "+fo.va2[i*4]+"   "+fo.truth[i*4]);
			}
		}
		if(tr.judge()==3) {
			System.out.println(tr.va[0]+" "+tr.va[1]+" "+tr.va[2]+" "+tr.pfr);
			for(int i=0;i<8;i++) {
				System.out.println(fo.va1[i*2]+" "+fo.va2[i*2]+" "+fo.va3[i*2]+"   "+fo.truth[i*2]);
			}
		}
		if(tr.judge()==4) {
			System.out.println(tr.va[0]+" "+tr.va[1]+" "+tr.va[2]+" "+tr.va[3]+" "+tr.pfr);
			for(int i=0;i<16;i++) {
				System.out.println(fo.va1[i]+" "+fo.va2[i]+" "+fo.va3[i]+" "+fo.va4[i]+"   "+fo.truth[i]);
			}
		}
		
	}
	void pdnf() {
		//this.calculate();
		count1=count1/2;
		count1--;
		System.out.println("主析取范式为:");
		for(int i=0;i<8;i++) {
			if(fo.truth[i*2]==1) {
				System.out.print("(");
				if(fo.va1[i*2]==0) {
					System.out.print("﹁"+tr.va[0]);
				}
				else {
					System.out.print(tr.va[0]);
				}
				System.out.print("∧");
				if(fo.va2[i*2]==0) {
					System.out.print("﹁"+tr.va[1]);
				}
				else {
					System.out.print(tr.va[1]);
				}
				System.out.print("∧");
				if(fo.va3[i*2]==0) {
					System.out.print("﹁"+tr.va[2]);
				}
				else {
					System.out.print(tr.va[2]);
				}
				System.out.print(")");
				
				if(count1>0) {
					System.out.print("∨");
					count1--;
				}
			}
		}
		System.out.println();
	}
	void pcnf() {
		count0=count0/2;
		count0--;
		System.out.println("主合取范式为:");
		for(int i=0;i<8;i++) {
			if(fo.truth[i*2]==0) {
				System.out.print("(");
				if(fo.va1[i*2]==0) {
					System.out.print("﹁"+tr.va[0]);
				}
				else {
					System.out.print(tr.va[0]);
				}
				System.out.print("∨");
				if(fo.va2[i*2]==0) {
					System.out.print("﹁"+tr.va[1]);
				}
				else {
					System.out.print(tr.va[1]);
				}
				System.out.print("∨");
				if(fo.va3[i*2]==0) {
					System.out.print("﹁"+tr.va[2]);
				}
				else {
					System.out.print(tr.va[2]);
				}
				System.out.print(")");
				
				if(count0>0) {
					System.out.print("∧");
					count0--;
				}
			}
		}
		System.out.println();
	}
	void comeTrue() {
		System.out.println("成真赋值为:");
		for(int i=0;i<8;i++) {
			if(fo.truth[i*2]==1) {
				System.out.print(fo.va1[i*2]+" "+fo.va2[i*2]+" "+fo.va3[i*2]);
				System.out.print("   ");
			}
		}
		System.out.println();
	}
	void aFalse() {
		System.out.println("成假赋值为:");
		for(int i=0;i<8;i++) {
			if(fo.truth[i*2]==0) {
				System.out.print(fo.va1[i*2]+" "+fo.va2[i*2]+" "+fo.va3[i*2]);
				System.out.print("   ");
			}
		}
		System.out.println();
	}
}

Translation.java

包含命题公式后缀表达式的转换和求解，变元个数的判断

package experiment;

public class Translation {
	String pfr;
	char[] op;//命题公式
	char[] op1;//后缀表达式
	char[] op2;//符号，中间数组
	char[] va=new char[4];//变量储存
	int[] variable=new int[4];                                                                                                                               
	int count1=-1;//op1计数器
	int count2=-1;//op2计数器
	int count3=0;//va计数器
	int x1,x2,x3,x;//x储存表达式的值
	LogicalOperation lg = new LogicalOperation();
	Translation(String pfr){
		this.pfr=pfr;
		op=pfr.toCharArray();
		op1=new char[op.length];
		op2=new char[op.length];
		for(int i=0;i<op.length;i++) {//转化为后缀表达式,遍历op数组；
			if(op[i]>='a'&&op[i]<='z') {
				count1++;
				op1[count1]=op[i];
			}
			else if(op[i]=='(') {
				count2++;
				op2[count2]=op[i];
			}
			else if(op[i]=='﹁') {
				if(count2==-1||op2[count2]=='∨'||op2[count2]=='∧'||op2[count2]=='→'||op2[count2]=='↔'||op2[count2]=='(') {
					count2++;
					op2[count2]=op[i];
				}
				else if(op2[count2]=='﹁') {
					count1++;
					op1[count1]='﹁';
				}
			}
			else if(op[i]=='∨'||op[i]=='∧'||op[i]=='→'||op[i]=='↔') {
				if(count2==-1||op2[count2]=='(') {
					count2++;
					op2[count2]=op[i];
				}
				else if(op2[count2]=='∨'||op2[count2]=='∧'||op2[count2]=='→'||op2[count2]=='﹁'||op2[count2]=='↔') {
					count1++;
					op1[count1]=op2[count2];
					op2[count2]=op[i];
				}
			}
			else if(op[i]==')') {
				while(op2[count2]!='(') {
					count1++;
					op1[count1]=op2[count2];
					count2--;
				}
				count2--;
			}
		}//循环结束
		while(count2>=0) {
			count1++;
			op1[count1]=op2[count2];
			count2--;
		}//后缀表达式完成
	}
	int judge() {//判断变量个数
		va[0]=op1[0];
		for(int i=1;i<=count1;i++) {
			if(op1[i]>='a'&&op1[i]<='z') {
				if(op1[i]!=va[0]&&op1[i]!=va[1]&&op1[i]!=va[2]) {
					if(va[1]==0) {
						va[1]=op1[i];
						count3=2;
					}
					else if(va[2]==0) {
						va[2]=op1[i];
						count3=3;
					}
					else {
						va[3]=op1[i];
						count3=4;
					}
				}
			}
		}
		return count3;
	}
	int operate(int []xi) {
		int num=-1;
		for(int i=0;i<=count1;i++) {
			if(op1[i]>='a'&&op1[i]<='z') {
				if(op1[i]==va[0]) {
					num++;
					variable[num]=xi[0];
				}
				else if(op1[i]==va[1]) {
					num++;
					variable[num]=xi[1];
				}
				else if(op1[i]==va[2]) {
					num++;
					variable[num]=xi[2];
				}
				else if(op1[i]==va[3]) {
					num++;
					variable[num]=xi[3];
				}
			}
			else if(op1[i]=='﹁') {
				variable[num]=lg.nagation(variable[num]);
			}
			else if(op1[i]=='∨') {
				variable[num-1]=lg.disjunction(variable[num-1], variable[num]);
				num--;
			}
			else if(op1[i]=='∧') {
				variable[num-1]=lg.conjunction(variable[num-1], variable[num]);
				num--;
			}
			else if(op1[i]=='→') {
				variable[num-1]=lg.implication(variable[num-1], variable[num]);
				num--;
			}
			else if(op1[i]=='↔') {
				variable[num-1]=lg.equivalence(variable[num-1], variable[num]);
				num--;
			}
		}
		return variable[num];
	}

}

Proposition.java

命题公式类，包含命题公式所具有的成员变量

package experiment;

public class Proposition {
	String formula;
	int[] va1 = new int[16];
	int[] va2 = new int[16];
	int[] va3 = new int[16];
	int[] va4 = new int[16];
	int[] truth = new int[16];
	Proposition(String formula) {
		this.formula=formula;
	}
}

experiment2.java

求真值表执行类

package experiment;
import java.util.*;
/*2.对给出的任意一个命题公式（不超过四个命题变元），
 * 使学生会利用编程软件表示出来，并且能够计算它在各组真值指派下所应有的真值，
 * 画出其真值表。
 * （1）﹁(﹁p∨q)∧q的真值表；
 * （2）(p∨q)→﹁r的真值表；
 */
public class experiment2 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner scanf=new Scanner(System.in);
		int[] w=new int[4];
		System.out.println("输入命题公式（不超过四个命题变元）：");
		System.out.println("非为‘﹁’，析取为‘∨’，合取为‘∧’蕴涵为‘→’，等价为‘↔’");
		String prf = scanf.nextLine();
		NormalForm form = new NormalForm(prf);
		form.calculate();
		form.table();
	}
}

 experiment3.java

求主析取范式主合取范式、成真赋值、成假赋值执行类

package experiment;
import java.util.*;
public class experiment3 {

	public static void main(String[] args) {
		/*输入命题公式(p→﹁q)→r
		 *输出主析取范式、主合取范式
		 *输出成真赋值、成假赋值
		 * 非为‘﹁’，析取为‘∨’，合取为‘∧’蕴涵为‘→’，等价为‘↔’*/
		String form;
		Scanner scanf = new Scanner(System.in);
		System.out.println("请输入命题公式:(非为‘﹁’，析取为‘∨’，合取为‘∧’蕴涵为‘→’，等价为‘↔’)");
		form = scanf.nextLine();
		NormalForm normal = new NormalForm(form);
		normal.calculate();
		normal.pdnf();
		normal.pcnf();
		normal.comeTrue();
		normal.aFalse();
	}

}

鬼⃨
关注
  • 11
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【离散数学】计算主析取范式（基于真值表）
weixin_45720246的博客
12-11 3188
【问题描述】 请根据给定的命题公式，计算其真值为T的小项，列出主析取范式，并输出结果。 【输入形式】 输入一个字符串（字符串长度<=50）形式的命题公式，以回车表示输入结束。其中的命题公式为仅包含原子命题、联结词和括号的合式公式。联结词仅包含下述5中联结词： 1、否定，表示为“!” 2、合取，表示为“*” 3、析取，表示为“|” 4、条件，表示为“-” 5、双条件，表示为“=” 例如： (P-Q)-R 注意：输入符号均采用英文输入。 【输出形式】 输出一个以单个空格分隔的字符串，字符串中各项分别对应.
离散数学——成真赋值与成假赋值
热门推荐
weixin_54354252的博客
12-15 2万+
今天复习离散数学的时候饱受一个问题的困扰——为什么主析取范式和主合取范式的小项和大项采用不一样的赋值方式，查阅一些资料后得出答案，在这里分享给大家。 首先给大家明确一下赋值、成真赋值、成假赋值的概念： 对于一个命题公式P中的所有命题变项指定一组真值，则称为P的一个赋值。如果在某种赋值下，命题公式P的值为1，这种赋值称为成真赋值； 如果在某种赋值下，命题公式P的值为0，这种赋值称为成假赋值。 现在为大家说明为什么对于两种范式采用不一样的赋...
Python 计算给定公式的真值表
最新发布
youyouxiong的博客
04-21 371
在Python中，计算给定逻辑公式的真值表可以通过编写一个简单的函数来实现，该函数遍历所有可能的输入变量组合，并计算表达式的值。函数接受变量列表和表达式字典作为输入。表达式字典包含变量列表和表达式的字符串表示。函数首先生成真值表的头部，然后遍历所有可能的变量组合，使用。在实际应用中，应避免使用。你可以根据需要修改表达式和变量来计算其他逻辑表达式的真值表。函数将表达式中的变量替换为当前组合的值，并使用Python的。，或者非常小心地使用它，并确保输入是安全的。函数计算表达式的值。函数计算表达式的值。
离散数学第一章总结
skn000的博客
01-18 1万+
离散数学1 1.公式类型 可用真值表判断 1）重言式 也是永真式，公式真值恒为1。 2）矛盾式 永假式，真值恒为0。 3）可满足式 不是矛盾式的就都是可满足式。重言式一定是可满足式。 成真赋值与成假赋值 也叫成真指派与成假指派。 一组原子的取值（真值指派）使得公式为真：成真指派（赋值） 一组原子的取值（真值指派）使得公式为假：成假指派（赋值） 等值式 ...
【离散数学期复习系列】一、命题逻辑
hjy6666hjy的博客
06-03 8201
1、何为命题 判断结果唯一的陈述句 (1)真命题:判断结果为真的命题 (2)假命题:判断结果为假的命题 (3)悖论:自相矛盾的语句 例如:我正在说的这句话是谎言 那么如何判断命题呢？ (1)首先看是否是陈述句。祈使句,反问句,感叹句…都不是命题 (2)看真值是否唯一 例:x>1不是命题 明天是晴天是命题：陈述句，结果唯一：要么是晴天要么是雨天2、何为简单命题（原子命题） 就是句子不能再分解了 命题符号化:将命题用符号表示,p,q,r等 命题常项(命题常元):真值确定的陈述句 命题变项(命题变元):真值可以变
离散数学实践一编程判断主析取范式和主合取范式【java实现】
缘友一世的博客
12-26 698
【代码】离散数学实践一编程判断主析取范式和主合取范式【java实现】
03 命题逻辑等值演算
baopengjian的专栏
10-18 1万+
离散数学与组合数学汇总 文章目录主要内容一 等值式等值式基本等值式等值演算与置换规则等值演算的应用举例二 析取范式与合取范式范式的性质极小项与极大项实例主析取范式与主合取范式求公式主范式的步骤实例主范式的应用三 联结词的完备集联结词完备集四 可满足性问题与消解法 主要内容 等值式与基本的等值式 等值演算与置换规则 析取范式与合取范式，主析取范式与主合取范式 联结词完备集 可满足性问题与消解法 一 等值式 等值式 定义2.1 若等价式A↔B是重言式，则称A与B等值，记作A<=>B，并称A&lt
真值表、主析取范式、主合取范式
10-25
编程实现求解逻辑表达式的真值表、主析取范式、主合取范式对于一个含n个命题变元的表达式（n为相异的命题变元总个数），其真值表可看作由从0到2ⁿ-1的二进制数的变化表。因此，可以通过按行列举0到2ⁿ-1的二进制数来...
利用真值表法求取主析取范式以与主合取范式的实现副本.doc
09-20
利用真值表法求取主析取范式以与主合取范式的实现副本.doc
南京邮电大学实验一真值表法求主析取主合取范式
09-17
实 验 一利用真值表法求取主析取范式以及主合取范式的实现 实验名称：利用真值表法求取主析取范式以及主合取范式的实现 实验目的：通过编程实现主析取范式以及主合取范式的真值表求法以巩固相关理论的掌握 实验...
利用真值表法求主析取范式与主合取范式的实现.doc
09-20
利用真值表法求主析取范式与主合取范式的实现.doc
shuliluoji.rar_主范式_合取范式_命题公式_真值表
09-24
本文将深入探讨一种名为“shuliluoji.rar”的数理逻辑辅助教学软件，该软件主要涉及三个核心概念：主范式、合取范式以及命题公式，同时也支持通过真值表来验证逻辑关系。以下是对这些概念的详细解析。 首先，让我们...
离散数学（二）：命题公式的等值演算
09-05 6189
离散数学基础
离散数学5
weixin_34419321的博客
06-24 1793
离散数学五 主析取范式的用途 1.求公式的成真赋值与成假赋值。 2.判断公式的类型。是重言式，矛盾式还是可满足式。 3.判断两个命题公式是否等值。 例：用公式的主析取范式判断下述公式的类型： 如果公式A里有n个命题变项，A的主析取范式里有s个极小项，那A就有s个成真赋值，2n-s个成假赋值。如果有2n个成真赋值就是重言式，有0个就是矛盾式，剩下的就是可满足式。 例：判断下面两组...
主析取范式和主合取范式的c++求解程序
cfc_andy的博客
10-27 6100
这是我们老师刚刚布置的作业，自己百度了一下，发现没有比较简单完善的程序代码，于是自己写成功后，与大家分享一下。有些地方描述的不好，可能比较难理解，请见谅。如果有啥不懂的，可以在下面评论，我会尽力解答 一、算法思想 主要思想是：先求真值表，再根据真值表输出主析取范式和主合取范式。 用！来表示非，用小写v表示析取，用^来表示合取，用~来表示双条件，用-来表示条件，用大写字母来表示命题变元。 真值表的求...
南邮|离散数学实验一（编程实现用真值表法求合式公式的主析取范式以及主合取范式）
南邮在读本科生的博客
11-12 1598
南邮|离散数学实验一（编程实现用真值表法求合式公式的主析取范式以及主合取范式）
python求主范式
crhxiyhx的博客
03-20 2247
目录 一、主要思路 二、主要步骤 1.输入所求的式子 2.化简所求的式子 3.求得真值表的所有情况 4.进行计算，得出结果 三.代码实现 四.运行结果 我们已经学习了主范式的相关知识，为了更加简便的求出主范式，可以用下面这个代码求，会变得更加简单。 一、主要思路 先化简输入的式子，比如：条件，双条件等无法被计算机直接计算，所以我们可以对式子进行化简。然后通过真值表便可以自然求出主析取范式和主合取范式了。 二、主要步骤 1.输入所求的式子 2.化简所求的式子 ...
运用matlab求公式 的主析取范式与主合取范式，并求公式的成真赋值和成假赋值。
kaakllhjkhjalv的博客
10-25 6478
求公式 的主析取范式与主合取范式，并求公式的成真赋值和成假赋值。 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('在本题中用！代表非，&代表合取，->代表蕴涵，||代表析取') fprintf('\n'); %输出p fprintf(' p'); for i=1:8 fprintf(' %d ',a1
中科大离散数学课程笔记
shuaikai的博客
03-14 513
总结了离散数学课程中的主要概念，方便复习用
Java怎么构造真值表并输出
04-05
构造真值表可以通过逐个枚举变量取值的方式进行。以下是一个Java程序示例，用于构造一个包含三个变量的真值表并输出： ```java public class TruthTable { public static void main(String[] args) { int n = 3; // 变量数量 int rows = (int) Math.pow(2, n); // 行数 for (int i = 0; i < rows; i++) { for (int j = n - 1; j >= 0; j--) { int val = (i / (int) Math.pow(2, j)) % 2; // 取值 System.out.print(val + " "); } boolean result = evaluate(i, n); // 计算结果 System.out.println(result); } } public static boolean evaluate(int row, int n) { // TODO: 根据需要编写逻辑表达式的计算逻辑 return false; } } ``` 在上述代码中，首先定义了变量数量和行数，然后使用两层循环逐个枚举变量取值，同时输出每个变量的取值。在内层循环中，使用了二进制位运算的方式来获取每个变量的取值。 在每一行输出变量取值后，调用了`evaluate`方法计算逻辑表达式的结果，并将其输出。 需要注意的是，在`evaluate`方法中需要根据实际需要编写逻辑表达式的计算逻辑。因为这个逻辑表达式是未知的，所以这里只是简单地返回了`false`作为示例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值