devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

HNU-离散数学-程序设计实验-消解法推理系统_c++消解法

作者：小丑西瓜9 | 2024-05-12 23:28:18

赞

踩

c++消解法

 离散数学程序设计实验（占期末比重1.5%）

利用程序进行自然推理

希望能帮到HNUers，加油！

注释部分是原代码部分，如果帮到你了麻烦点个赞

  1. /*
  2.  * 实验四
  3.  * 利用消解法进行推理
  4.  * by Arcticwolf 
  5.  * CSEE----Computer Science and Technology 21XX
  6.  * 信息科学与工程学院----计算机科学与技术 21XX班----wolf
  7.  * 学号202108XXXXXX
  8.  */
  9.  
  10. #include <string.h>
  11. #include <iostream>
  12. #include <cstdio>
  13. #include <cmath>
  14. #include <cstdlib>
  15. #include <algorithm>
  16. //修改点：可用#include<bits/stdc++.h>减少头文件数量 
  17.  
  18. struct tmd
  19. {
  20. 	char gs[120], gsLast[120], niyou[120];//前件与后件及理由
  21. 	int nLitter, nUsed, isLitter, isCond;
  22. };
  23.  
  24. void nonoop2( char aa[] )
  25. {
  26. 	//!!p=p
  27. 	int i = 0, j = 0;
  28. 	while (i < strlen( aa ) - 2)
  29. 	{
  30. 		//至少还有两个字符
  31. 		if (((i + 1) < strlen( aa )) && (aa[i] == '!') && (aa[i + 1] == '!'))
  32. 		{
  33. 			j = i;
  34. 			while (j < strlen( aa ) - 2)
  35. 			{
  36. 				aa[j] = aa[j + 2];
  37. 				j++;
  38. 			}
  39. 			aa[j] = '\0';
  40. 			break;
  41. 		}
  42. 		else
  43. 			i++;
  44. 	}
  45. }
  46.  
  47. void printYsh( struct tmd tmdrec[], int np )
  48. {
  49. 	int i = 0;
  50. 	for (i = 0; i < np; i++)
  51. 	{
  52. 		if (tmdrec[i].isLitter == 1)
  53. 			printf( "(%d)\t%s为真\t\t\t%s---文字\n", i + 1, tmdrec[i].gs, tmdrec[i].niyou );
  54. 		else if (tmdrec[i].isCond == 1)
  55. 			printf( "(%d)\t%s+%s为真\t\t\t%s---析取式\n", i + 1, tmdrec[i].gs, tmdrec[i].gsLast, tmdrec[i].niyou );
  56. 		else
  57. 			printf( "(%d)\t%s为真\t\t\t%s\n", i + 1, tmdrec[i].gs, tmdrec[i].niyou );
  58. 	}
  59. }
  60.  
  61. /* 修改点1：调换函数位置，否则会出现调用未定义函数的情况 */
  62. int setNiyou( struct tmd tmdrec[], int np, char ny0[], int j0, int j1, int nUsed0, int isCond0, int isLitter0 )
  63. {
  64. 	//将字符串ny0与j0赋到推理意见中
  65. 	char stmdpj0[20], stmdpj1[20];
  66. 	int nLen1 = 0, j = 0, nLenj0 = 0, nLenj1 = 0;
  67. 	nLen1 = strlen( ny0 );
  68. 	itoa( j0 + 1, stmdpj0, 10 );
  69. 	nLenj0 = strlen( stmdpj0 );//前一个依据
  70. 	itoa( j1 + 1, stmdpj1, 10 );
  71. 	nLenj1 = strlen( stmdpj1 );//后一个依据
  72. 	if (j0 == -1)
  73. 	{
  74. 		//原始前提
  75. 		for (j = 0; j < nLen1; j++)
  76. 			tmdrec[np].niyou[j] = ny0[j];
  77. 		tmdrec[np].niyou[j] = '\0';
  78. 	}
  79. 	else if (j1 == -1)//由前一步推理所得结论
  80. 	{
  81. 		tmdrec[np].niyou[0] = '(';
  82. 		for (j = 0; j < nLenj0; j++)
  83. 			tmdrec[np].niyou[j + 1] = stmdpj0[j];
  84. 		tmdrec[np].niyou[j + 1] = ')';
  85.  
  86. 		for (j = 0; j < nLen1; j++)
  87. 			tmdrec[np].niyou[j + 2 + nLenj0] = ny0[j];
  88. 		tmdrec[np].niyou[j + 2 + nLenj0] = '\0';
  89. 	}
  90. 	else
  91. 	{
  92. 		//由前二步推理所得
  93. 		tmdrec[np].niyou[0] = '(';
  94. 		for (j = 0; j < nLenj0; j++)
  95. 			tmdrec[np].niyou[j + 1] = stmdpj0[j];
  96. 		tmdrec[np].niyou[j + 1] = ')';
  97.  
  98. 		tmdrec[np].niyou[nLenj0 + 2] = '(';
  99. 		for (j = 0; j < nLenj1; j++)
  100. 			tmdrec[np].niyou[nLenj0 + 3 + j] = stmdpj1[j];
  101. 		tmdrec[np].niyou[nLenj0 + 3 + j] = ')';
  102.  
  103. 		for (j = 0; j < nLen1; j++)
  104. 			tmdrec[np].niyou[nLenj0 + nLenj1 + 4 + j] = ny0[j];
  105. 		tmdrec[np].niyou[nLenj0 + nLenj1 + 4 + j] = '\0';
  106. 	}
  107.  
  108. 	tmdrec[np].nUsed = nUsed0;//附加前提从未使用过nUsed0,int isCond0,int isLitter0
  109. 	tmdrec[np].isCond = isCond0;//是条件式
  110. 	tmdrec[np].isLitter = isLitter0;//是文字
  111. }
  112.  
  113. void swaptmd(tmd &a,tmd &b)
  114. {
  115.     tmd temp;
  116.     temp=a;
  117.     a=b;
  118.     b=temp;
  119. }
  120.  
  121.  
  122. int inputPrimary( struct tmd gs0[] )
  123. {
  124. 	struct tmd tmdp;
  125. 	char pstate[120];
  126. 	char *ny0 = "前提条件";
  127. 	char *ny1 = "条件式转为析取式";
  128. 	char *ny2 = "双条件导出的析取式";
  129. 	int i = 0, j = 0, nLen = 0, k = 0;
  130. 	int i0 = 0;//原始条件
  131. 	printf( "输完一个前提条件请按回车，不输直接回车则结束\n析+,合*,条-,双=,否定!\n前提中只能为双条件、单条件、析取式,\n若为2个条件的合取,请输入2个前提,文字请在最前面输入:\n" );
  132. 	while (1)
  133. 	{
  134. 		gets( pstate );
  135. 		nLen = strlen( pstate );
  136. 		if (nLen == 0)
  137. 		{
  138. 			break;
  139. 		}//设置nUsed,isLitter,isCond,nLittle的值
  140. 		//判断是否为文字
  141. 		if (nLen == 1)//标注单个文字
  142. 		{
  143. 			gs0[i].nLitter = strlen( pstate );
  144. 			gs0[i].gs[0] = pstate[0];
  145. 			gs0[i].gs[1] = '\0';
  146. 			gs0[i].gsLast[0] = '\0';
  147. 			setNiyou( gs0, i, ny0, -1, -1, 0, 0, 1 );//前提类型，无，无，未使用，不是条件式，是文字
  148. 		}
  149. 		else if ((nLen == 2) && (pstate[0] == '!')) //标注！p
  150. 		{
  151. 			gs0[i].nLitter = strlen( pstate );
  152. 			gs0[i].gs[0] = pstate[0];
  153. 			gs0[i].gs[1] = pstate[1];
  154. 			gs0[i].gs[2] = '\0';
  155. 			gs0[i].gsLast[0] = '\0';
  156. 			setNiyou( gs0, i, ny0, -1, -1, 0, 0, 1 );//前提类型，无，无，未使用，不是条件式，是文字
  157. 		}
  158. 		else
  159. 		{
  160. 			for (j = 0; j < nLen; j++)
  161. 			{
  162. 				if (pstate[j] == '-')//标注条件式p-q
  163. 				{
  164. 					gs0[i].nLitter = strlen( pstate );
  165. 					for (k = 0; k < nLen; k++)
  166. 						gs0[i].gs[k] = pstate[k];//整个表达式进入gs
  167. 					gs0[i].gs[k] = '\0';
  168. 					gs0[i].gsLast[0] = '\0';
  169. 					setNiyou( gs0, i, ny0, -1, -1, 0, 0, 0 );//前提类型，无，无，未使用，不是析取式，不是文字
  170.  
  171. 					i++;
  172. 					gs0[i].nLitter = gs0[i - 1].nLitter;
  173. 					gs0[i].gs[0] = '!';
  174. 					for (k = 0; k < j; k++)
  175. 						gs0[i].gs[k + 1] = pstate[k];
  176. 					gs0[i].gs[k + 1] = '\0';
  177. 					nonoop2( gs0[i].gs );
  178.  
  179. 					for (k = j + 1; k < nLen; k++)
  180. 						gs0[i].gsLast[k - j - 1] = pstate[k];
  181. 					gs0[i].gsLast[k - j - 1] = '\0';
  182. 					setNiyou( gs0, i, ny1, i - 1, -1, 0, 1, 0 );//前提类型，无，无，未使用，是条件式，不是文字
  183. 					break;
  184. 				}
  185.  
  186. 				else if (pstate[j] == '=')//标注双条件p=q
  187. 				{
  188. 					//先保存双条件
  189. 					gs0[i].nLitter = strlen( pstate );
  190. 					for (k = 0; k < strlen( pstate ); k++) { gs0[i].gs[k] = pstate[k]; }//双条件全部进gs
  191. 					gs0[i].gs[k] = '\0';
  192. 					gs0[i].gsLast[0] = '\0';
  193. 					setNiyou( gs0, i, ny0, -1, -1, 0, 0, 0 );//前提类型，无，无，未使用，是条件式，不是文字
  194. 															 //p-q即!p+q
  195. 					i++;
  196. 					gs0[i].nLitter = strlen( pstate );
  197. 					gs0[i].gs[0] = '!';
  198. 					for (k = 0; k < j; k++) { gs0[i].gs[k + 1] = pstate[k]; }//p进gs
  199. 					gs0[i].gs[k + 1] = '\0';
  200. 					for (k = j + 1; k < nLen; k++) { gs0[i].gsLast[k - j - 1] = pstate[k]; }//q进gsLast
  201. 					gs0[i].gsLast[k - j - 1] = '\0';
  202. 					setNiyou( gs0, i, ny2, i - 1, -1, 0, 1, 0 );//前提类型，无，无，未使用，是条件式，不是文字
  203. 					nonoop2( gs0[i].gs );//去掉可能存在的!!?
  204. 										 //q-p=p+!q
  205. 					i++;
  206. 					gs0[i].nLitter = gs0[i - 1].nLitter;
  207. 					for (k = 0; k < j; k++) { gs0[i].gs[k] = pstate[k]; }//条件前件p进gs
  208. 					gs0[i].gs[k] = '\0';
  209. 					gs0[i].gsLast[0] = '!';
  210. 					for (k = j + 1; k < nLen; k++) { gs0[i].gsLast[k - j - 1 + 1] = pstate[k]; }//条件后件!q进gsLast
  211. 					gs0[i].gsLast[k - j - 1 + 1] = '\0';
  212. 					setNiyou( gs0, i, ny2, i - 2, -1, 0, 1, 0 );//前提类型，无，无，未使用，是条件式，不是文字
  213. 					nonoop2( gs0[i].gsLast );//去掉可能存在的!!?
  214. 					break;
  215.  
  216. 				}
  217.  
  218. 				else if (pstate[j] == '+')//标注析取式p+q，也要分解到gs与gsLast中
  219. 				{
  220. 					gs0[i].nLitter = strlen( pstate );
  221. 					for (k = 0; k < j; k++)
  222. 						gs0[i].gs[k] = pstate[k];    //前件进gs
  223. 					gs0[i].gs[k] = '\0';
  224. 					for (k = j + 1; k < nLen; k++)
  225. 						gs0[i].gsLast[k - j - 1] = pstate[k];    //条件全部进gs
  226. 					gs0[i].gsLast[k - j - 1] = '\0';
  227. 					setNiyou( gs0, i, ny0, -1, -1, 0, 1, 0 );//前提类型,无，无，未使用，是条件式，不是文字
  228. 					break;
  229. 				}
  230. 			}
  231. 			if (j >= nLen)//不是条件式，也不是文字，则是普通的条件
  232. 			{
  233. 				gs0[i].nLitter = strlen( pstate );
  234. 				for (k = 0; k < nLen; k++)
  235. 					gs0[i].gs[k] = pstate[k];    //公式全进gs
  236. 				gs0[i].gs[k] = '\0';
  237. 				gs0[i].gsLast[0] = '\0'; //gsLast为空串
  238. 				setNiyou( gs0, i, ny0, -1, -1, 0, 0, 0 );//前提类型，无，无，未使用，不是条件式，不是文字
  239. 			}
  240. 		}
  241. 		i++;//当前公式处理完以后，指针i的值增1
  242. 	}
  243. 	nLen = i;//按字符串的长度排序
  244. 	for (i = 0; i < nLen - 1; i++)
  245. 	{
  246. 		k = i;
  247. 		//for (j = i + 1; j < nLen - 1; j++)
  248. 		/* 修改点2：修改循环条件使得最后的元素可排序 */
  249. 		for (j = i + 1; j < nLen; j++)
  250. 			if (gs0[k].nLitter > gs0[j].nLitter)
  251. 				k = j;
  252. 		if (k > i)
  253. 		{
  254. 			/* 修改点3：使用自定义的swaptmd排序 */
  255. 			swaptmd(gs0[i],gs0[k]);
  256. //			tmdp = gs0[i];
  257. //			gs0[i] = gs0[k];
  258. //			gs0[k] = tmdp;
  259. 		}
  260. 	}
  261. 	return nLen;
  262. }
  263.  
  264. int main()
  265. {
  266. 	struct tmd gs0[100];//推理前提条件
  267. 	char result0[128]; //结论
  268. 	struct tmd tmdrec[1024];//最多1000步
  269.  
  270. 	char stmdp[128];
  271. 	char lastNiYou[128] = " ";//上一个推理式的理由
  272. 	char *ny01 = "消解";
  273. 	int i = 0, j = 0, k = 0;
  274. 	int np = 1, np0 = 0, isOk = 0;
  275. 	int i0 = 0, nPosLitter = 0, nPosCond = 0;//文字起始的位置，首个文字的位置，消解式的位置
  276. 	np0 = inputPrimary( gs0 );
  277. 	//输入结论
  278. 	printf( "输入要推理的结论，结论只能是文字，\n若是条件式，析取式请先手工转换为条件，将前件作为附加前提：" );
  279. 	gets( result0 );
  280. 	fflush( stdin );
  281. 	for (i = 0; i < np0; i++)
  282. 	{
  283. 		tmdrec[i] = gs0[i];//所有原始公式转抄到tmdrec中
  284. 	}
  285. 	np = i;//推理队列的尾部指针
  286. 	nPosLitter = 0;//文字的位置号
  287. 	nPosCond = 0;//条件的位置号
  288. 	isOk = 0;
  289. 	i0 = -1;
  290. 	while (1)
  291. 	{
  292. 		i = i0 + 1;//寻找下一个文字，i是起始位置，np是命令串的长度
  293. 		while ((i < np) && (tmdrec[i].isLitter != 1))
  294. 			i++;
  295. 		if (i >= np)
  296. 			break;//找不到文字我就没法推理了
  297. 		i0 = i;//记录从源头查询的首个文字的位置号，下次从此号往后寻找
  298. 		nPosLitter = i;//记录文字的位置
  299. 		strcpy( stmdp, tmdrec[i].gs );//保存当前文字的内容
  300. 		np0 = np - 1;
  301. 		while (np > np0) //从当前文字的下一个位置起寻找析取式，则一路往下走
  302. 		{
  303. 			np0 = np;
  304. 			for (i = 0; i < np; i++)//找到一个没有用过的戏曲式
  305. 				if ((tmdrec[i].isCond == 1) && (tmdrec[i].nUsed == 0))
  306. 					break;
  307. 			if (i == np)
  308. 				break;//没有找到则结束推理，所有条件式都用到了
  309. 			while (i < np)//若找到了这样的条件式
  310. 			{
  311. 				if ((tmdrec[i].isCond == 1))//若是条件式
  312. 				{
  313. 					//与上条命令的来源不同，或者但是同为前提条件也是可以的，即首个字符不是（
  314. 					if (((strcmp( lastNiYou, tmdrec[i].niyou ) != 0) || ((strcmp( lastNiYou, tmdrec[i].niyou ) == 0) && tmdrec[i].niyou[0] != '(')))
  315. 					{
  316.  
  317. 						if ((tmdrec[i].gs[0] == '!') && (stmdp[0] != '!') && (strlen( tmdrec[i].gs ) - strlen( stmdp ) == 1))    // !p+q p cuo
  318. 						{
  319. 							//如果析取式的前件与stmdp即可消解，则将后件保存的stmdp中
  320. 							j = 0;
  321. 							while (j < strlen( stmdp ))//依次比较每个字符
  322. 							{
  323. 								if (tmdrec[i].gs[j + 1] != stmdp[j])
  324. 									break;//有一个不相等则结束比较
  325. 								j++;
  326. 							}
  327.  
  328. 							if (j >= strlen( stmdp ))  //如果比到最后仍然相等，则这二个可消解
  329. 							{
  330. 								strcpy( lastNiYou, tmdrec[i].niyou );
  331. 								tmdrec[nPosLitter].nUsed++;  //这个文字用过一次了
  332. 								tmdrec[i].nUsed++;  //这个析取式用过一次了
  333.  
  334. 								strcpy( stmdp, tmdrec[i].gsLast );  //将次消解结果保存到推导序列中
  335. 								strcpy( tmdrec[np].gs, stmdp );  //将当前推出来的结果保存起来
  336. 								tmdrec[np].gsLast[0] = '\0';  //后件清空，保存当前条件
  337. 								setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 );  //前提类型，有，无，未使用，不是条件
  338. 								nPosLitter = np;  //记录当前文字的序号
  339. 								np++;
  340. 								if (strcmp( result0, stmdp ) == 0)
  341. 								{
  342. 									isOk = 1;    //推出结论同条原是调节的下一轮
  343. 									break;
  344. 								}
  345. 							}
  346. 						}
  347. 						else if ((tmdrec[i].gsLast[0] == '!') && (stmdp[0] != '!') && (strlen( tmdrec[i].gsLast ) - strlen( stmdp ) == 1))		//a+!b  b dui
  348. 						{
  349. 							//如果析取式的后件与stmdp即可消解，则将前件保存到stmdp中
  350. 							j = 0;
  351. 							while (j < strlen( stmdp ))  //依次比较每一个字符
  352. 							{
  353. 								if (tmdrec[i].gsLast[j + 1] != stmdp[j])
  354. 									break;    //有一个不相等则结束比较
  355. 								j++;
  356. 							}
  357. 							if (j >= strlen( stmdp ))  //如果比到最后仍然相等，则这两个可消解
  358. 							{
  359. 								strcpy( lastNiYou, tmdrec[i].niyou );
  360. 								tmdrec[nPosLitter].nUsed++;  //这个文字用过一次了
  361. 								tmdrec[i].nUsed++;  //这个析取式用过一次了
  362.  
  363. 								strcpy( stmdp, tmdrec[i].gs );  //将次消解结果保存到推导序列中
  364. 								strcpy( tmdrec[np].gs, stmdp );  //将当前推出来的结果保存起来
  365. 								tmdrec[np].gsLast[0] = '\0';  //后件清空，保存当前条件
  366. 								setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 );  //前提类型，有，无，未使用，不是条件
  367. 								nPosLitter = np;  //记录当前文字的序号
  368. 								np++;
  369. 								if (strcmp( result0, stmdp ) == 0)
  370. 								{
  371. 									isOk = 1;    //推出结论同条原是调节的下一轮
  372. 									break;
  373. 								}
  374. 							}
  375. 						}
  376. 						else if ((tmdrec[i].gs[0] != '!') && (stmdp[0] == '!') && (strlen( tmdrec[i].gs ) - strlen( stmdp ) == -1))		//	p+q !p
  377. 						{
  378. 							//如果析取式的后件与stmdp即可消解，则将前件保存到stmdp中
  379. 							j = 0;
  380. 							while (j < strlen( tmdrec[i].gs ))  //依次比较每一个字符
  381. 							{
  382. 								if (stmdp[j + 1] != tmdrec[i].gs[j])
  383. 									break;    //有一个不相等则结束比较
  384. 								j++;
  385. 							}
  386. 							if (j >= strlen( tmdrec[i].gs ))
  387. 							{
  388. 								strcpy( lastNiYou, tmdrec[i].niyou );
  389. 								tmdrec[nPosLitter].nUsed++;  //这个文字用过一次了
  390. 								tmdrec[i].nUsed++;  //这个析取式用过一次了
  391.  
  392. 								strcpy( stmdp, tmdrec[i].gsLast );  //将次消解结果保存到推导序列中
  393. 								strcpy( tmdrec[np].gs, stmdp );  //将当前推出来的结果保存起来
  394. 								tmdrec[np].gsLast[0] = '\0';  //后件清空，保存当前条件
  395. 								setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 );  //前提类型，有，无，未使用，不是条件
  396. 								nPosLitter = np;  //记录当前文字的序号
  397. 								np++;
  398. 								if (strcmp( result0, stmdp ) == 0)
  399. 								{
  400. 									isOk = 1;    //推出结论同条原是调节的下一轮
  401. 									break;
  402. 								}
  403. 							}
  404.  
  405. 						}
  406. 						else if ((tmdrec[i].gsLast[0] != '!') && (stmdp[0] == '!') && (strlen( tmdrec[i].gsLast ) - strlen( stmdp ) == -1))		//p+q !q
  407. 						{
  408. 							//如果析取式的后件与stmdp即可消解，则将前件保存到stmdp中
  409. 							j = 0;
  410. 							while (j < strlen( tmdrec[i].gsLast ))//依次比较每一个字符
  411. 							{
  412. 								if (stmdp[j + 1] != tmdrec[i].gsLast[j])
  413. 									break;    //有一个不相等则结束比较
  414. 								j++;
  415. 							}
  416. 							if (j >= strlen( tmdrec[i].gsLast ))//如果比到最后仍然相等，则这两个可消解
  417. 							{
  418. 								strcpy( lastNiYou, tmdrec[i].niyou );
  419. 								tmdrec[nPosLitter].nUsed++;	//这个文字用过一次了
  420. 								tmdrec[i].nUsed++;			//这个条件用过一次了
  421.  
  422. 								strcpy( stmdp, tmdrec[i].gs );	    //将此中间结果保存到推导序列中
  423. 								strcpy( tmdrec[np].gs, stmdp );		//将当前推出来的结果保存起来
  424. 								tmdrec[np].gsLast[0] = '\0';		//后件清空，保存当前条件
  425. 								setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 );//前提类型，有，无，未使用，不是条件式
  426. 								nPosLitter = np;		            //记录当前文字的序号
  427. 								np++;
  428. 								if (strcmp( result0, stmdp ) == 0)
  429. 								{
  430. 									isOk = 1;    //推出结论同原始条件的下一轮
  431. 									break;
  432. 								}
  433. 							}
  434. 						}
  435. 					}
  436. 				}
  437. 				i++;//判断下一个表达式是否为条件，是否为可推理的条件式
  438. 			}
  439. 		}
  440. 		if (isOk == 1)
  441. 			break;    //我推出来了，不要再找下一个文字了
  442. 	}
  443. 	if (isOk == 1)
  444. 		printf( "我推出来了,推理过程如下:\n" );
  445. 	else
  446. 		printf( "我推不出来,推理过程如下:\n" );
  447. 	printYsh( tmdrec, np );
  448. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/560981
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号