求命题真值表及主范式

  1 #include "iostream"
  2 #include "cstring"
  3 #include "cstdlib"
  4 #include "stack"
  5 #include "cmath"
  6 #define maxsize 100
  7 using namespace std;
  8 char str[100];
  9 int  zhipai[20]={0};
 10 int length;
 11 char expression[100];
 12 class symbol {
 13 public:
 14     void solve();
 15 private:
 16     void change();
 17     int Calculate();
 18     void DoOperator(char op);
 19     stack<int> s;
 20 };
 21
 22 void symbol ::DoOperator(char op){
 23     double left=0,right=0;
 24         switch(op){
 25         case ‘|‘:s.push(left||right);break;
 26         case ‘&‘:s.push(left&&right);break;
 27         case ‘>‘:s.push(!left||right);break;
 28         case ‘!‘:s.push((!right)&&left);break;
 29         case ‘=‘:s.push(left==right);break;
 30         }
 31
 32 }
 33 void symbol ::change()
 34 {
 35     int k=0;
 36     int flag=1;
 37     int count=0;
 38     for(int i=0;i<pow(2.0,count);i++)
 39     {
 40         k=1;
 41         for(int m=0;m<length;m++)
 42         {
 43             if(isalpha(str[m]))
 44             {
 45                 if(flag==1)
 46                 {
 47                 if(zhipai[k]==0)
 48                     expression[m]=‘0‘;
 49                 else
 50                     expression[m]=‘1‘;
 51                 k++;
 52                 }
 53                 else
 54                     expression[m]=‘0‘;
 55                 flag=1;
 56                 for(int t=m;t>=0;t--)
 57                 {
 58
 59                     if((str[m+1]==str[t])&&isalpha(str[m+1])&&isalpha(str[t]))
 60                         flag=0;
 61                 }
 62             }
 63             else
 64                 expression[m]=str[m];
 65         }
 66         for(int t=0;t<length;t++)
 67         {
 68             for(int j=t;j<length;j++)
 69             {
 70                     if(str[t]==str[j])
 71                     {
 72                         expression[j]=expression[t];
 73                     }
 74                 }
 75         }
 76     }
 77 }
 78 void plus(int a[],int q)
 79 {
 80     a[q]=a[q]+1;
 81     for(int i=q;a[i]==2;i--)
 82     {
 83         a[i]=0;
 84         a[i-1]=a[i-1]+1;
 85     }
 86 }
 87 int isp(char ch)     //联结词的栈内优先级
 88 {
 89     switch(ch){
 90     case ‘#‘:return 0;break;
 91     case ‘(‘:return 1;break;
 92     case ‘!‘:return 10;break;
 93     case ‘=‘:return 9;break;
 94     case ‘&‘:return 7;break;
 95     case ‘|‘:return 5;break;
 96     case ‘>‘:return 3;break;
 97     case ‘)‘:return 12;break;
 98     default:return -1;break;
 99     }
100 }
101 int icp(char ch)     //联结词的栈外优先级
102 {
103     switch(ch){
104     case ‘#‘:return 0;break;
105     case ‘(‘:return 12;break;
106     case ‘!‘:return 11;break;
107     case ‘=‘:return 8;break;
108     case ‘&‘:return 6;break;
109     case ‘|‘:return 4;break;
110     case ‘>‘:return 2;break;
111     case ‘)‘:return 1;break;
112     default:return -1;break;
113     }
114 }
115 int symbol ::Calculate()
116 {
117     stack<char> h;
118     char ch,y;
119     h.push(‘#‘);
120     for(int temp=0;temp<length-1;temp++){
121         ch=expression[temp];
122         if(isdigit(ch))
123         {
124             if(ch==‘0‘)
125             s.push(0);
126             else
127                 s.push(1);
128         }
129         else if(ch==‘)‘)
130         {
131             for(y=h.top(),h.pop();y!=‘(‘;y=h.top(),h.pop()){
132                 DoOperator(y);}
133         }
134         else{
135             if(ch==‘!‘)
136             {
137                 s.push(1);
138             }
139             for(y=h.top(),h.pop();isp(y)>icp(ch);y=h.top(),h.pop())
140                 DoOperator(y);
141             h.push(y);
142             h.push(ch);
143         }
144     }
145     while(h.size()!=1){
146         y=h.top();
147         h.pop();
148         DoOperator(y);
149     }
150     cout <<s.top()<<endl;
151     return s.top();
152 }
153
154 void symbol::solve()
155 {
156     cout<<"请输入命题逻辑表达式:"<<endl;
157     cout<<"(|:或运算,&:与运算,!非运算,>蕴涵运算,=等价运算,以#结尾)"<<endl;
158     cout<<""<<endl;
159     int flag=1;
160     int count=0;
161     cin >>str;
162     length=strlen(str);
163     if(str[length-1]!=‘#‘)
164     {
165         cout<<"未以#结尾,重新输入!"<<endl;
166         system("pause");
167         exit(0);
168     }
169     char bianyuan[100];
170     for(int i=0;i<length;i++)
171     {
172         if(isalpha(str[i])&&(flag==1))
173         {
174             bianyuan[count]=str[i];count++;
175         }
176         flag=1;
177         for(int k=0;k<count;k++)
178         {
179             if(bianyuan[k]==str[i+1])flag=0;
180         }
181     }
182     if(count==0)
183     {
184         cout<<"无命题变元,重新输入!"<<endl;
185         solve();
186     }
187     cout<<"真值表(用0代替F,用1代替T):" <<endl;
188
189     for(int w=0;w<count;w++)
190     cout<<bianyuan[w]<<‘ ‘;
191     cout<<"result"<<endl;
192     int* truth=new int[pow(2.0,count)];
193     stack<char> xh1;
194     xh1.push(‘(‘);
195     stack<char> xh2;
196     stack<char> hx1;
197     hx1.push(‘(‘);
198     stack<char> hx2;
199     for(int r=0;r<pow(2.0,count);r++)
200     {
201         for(int j=1;j<=count;j++)
202         {cout<<zhipai[j]<<‘ ‘;}
203         change();
204         truth[r]=Calculate();
205         if(truth[r]==1)
206         {
207             for(int t=0;t<count;t++)
208             {
209                 if(zhipai[t+1]==1)
210                 {
211                     xh1.push(bianyuan[t]);
212                     xh1.push(‘&‘);
213                 }
214                 else
215                 {
216                     xh1.push(‘!‘);
217                     xh1.push(bianyuan[t]);
218                     xh1.push(‘&‘);
219                 }
220             }
221             xh1.pop();
222             xh1.push(‘)‘);
223             xh1.push(‘|‘);
224             xh1.push(‘(‘);
225         }
226         if(truth[r]==0)
227         {
228             for(int c=0;c<count;c++)
229             {
230                 if(zhipai[c+1]==1)
231                 {
232                     hx1.push(bianyuan[c]);
233                     hx1.push(‘|‘);
234                 }
235                 else
236                 {
237                     hx1.push(‘!‘);
238                     hx1.push(bianyuan[c]);
239                     hx1.push(‘|‘);
240                 }
241             }
242             hx1.pop();
243             hx1.push(‘)‘);
244             hx1.push(‘&‘);
245             hx1.push(‘(‘);
246         }
247         plus(zhipai,count);
248     }
249     cout<<"析合范式为:";
250     if(xh1.size()==1)
251         cout<<"无析合范式,此表达式为矛盾式";
252     else{
253         xh1.pop();
254         xh1.pop();
255         while(xh1.size()!=0)
256         {
257             xh2.push(xh1.top());
258             xh1.pop();
259         }
260         while(xh2.size()!=0)
261         {
262             cout<<xh2.top();
263             xh2.pop();
264         }
265     }
266     cout<<endl;
267     cout<<"合析范式为:";
268     if(hx1.size()==1)
269         cout<<"无合析范式,此表达式为重言式";
270     else{
271         hx1.pop();
272         hx1.pop();
273         while(hx1.size()!=0)
274         {
275             hx2.push(hx1.top());
276             hx1.pop();
277         }
278         while(hx2.size()!=0)
279         {
280             cout<<hx2.top();
281             hx2.pop();
282         }
283     }
284     cout<<endl;
285 }
286 void main()
287 {
288
289     symbol a;
290     a.solve();
291     system("pause");
292 }
时间: 2024-10-07 03:25:25

求命题真值表及主范式的相关文章

离散数学——python实现真值表和打印主范式

最近用python实现了真值表,经过有点儿曲折,刚开始没考虑优先级,直到前天才发现这个问题(离散数学没学好啊),用栈改了一下.话说python就是强,把列表类型当栈用,直接调用列表的pop()和append()非常方便,废话少说上代码(命令行版). 首先是导入外部库和定义函数 #导入正则表达式re库,用来从字符串中提取信息 import re #prettytable库帮我们打印出漂亮的表格 from prettytable import PrettyTable #过滤掉( def filter

离散数学--第二章--范式和命题逻辑推理理论

范式和命题逻辑推理理论 1.命题公式的等值置换规则(等价变形,化简)  合式公式的子式:如果合式公式A的一个子串X也是合式公式,那称X是A的一个子式.  置换规则:设X是合式公式A的一个子式,Y是一个合式公式且Y<=>X,则将A中的子式中的X换成Y,生成的新的式子B,仍为一个合式公式且B<=>A.  用递等式简化证明的书写.  等值演算用于逻辑含义的化简 也可以化简与门或门电路 2.命题公式的重言代入规则 重言代入规则:设A为重言式,p为其中任一原子变量,则将A中p处处替换为另一合

MATLAB 单变量函数一阶及N阶求导

1 对一维函数的求导及求特定函数处的变量值 %%最简单的一阶单变量函数进行求导 function usemyfunArray() %主函数必须位于最上方 clc clear syms x %syms x代表着声明符号变量x,只有声明了符号变量才可以进行符号运算,包括求导. %f(x)=sin(x)+x^2; %我们输入的要求导的函数 y = diff(sin(x)+x^2); %代表着对单变量函数f(x)求一阶导数 disp('f(x)=sin(x)+x^2的导数是'); pretty(y);

Floyd求最小环!(转载,非原创)

//Floyd 的 改进写法可以解决最小环问题,时间复杂度依然是 O(n^3),储存结构也是邻接矩阵 int mincircle = infinity; Dist = Graph; for(int k=0;k<nVertex;++k){ //新增部分: for(int i=0;i<k;++i) for(int j=0;j<i;++j) mincircle = min(mincircle,Dist[i][j]+Graph[j][k]+Graph[k][i]); //通常的 floyd 部分

HDU 2087 剪花布条(模式串在主串中出现的次数主串中子串不可重叠)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2087 题意:求模式串在主串中出现的次数,与模式串匹配的子串之间不可重叠. 思路:用kmp算法解决,在匹配更新结果后,重新定位模式串时,不可用j = next[j],应该直接让j定位到模式串开头. code: 1 #include <cstdio> 2 #include <cstring> 3 4 const int MAXN = 1005; 5 6 char aa[MAXN]; 7 c

性质命题推理(上)

前言 人们对事物或现象的认识可以通过直观来感知,但在大多数情况下直观的认识是肤浅的.不可靠的,想要真正地把握事物的客观规律和本质,必须借助一定的思维工具进行抽象和概括. 不论是日常思维还是科学思维,命题和推理都是人类思维的重要形式工具.命题是推理的基础,推理是命题的联结和运用. 人类思维通过由命题组合形成的推理揭示事物的本质和规律,从而获得新知识. 第一节 命题与推理概述 一.命题 逻辑学研究的对象是思维形式结构和规律,研究内容是推理的推理的正确性.命题是推理的组成部分,推理的前提和结论都是由命

性质命题推理(下)

性质命题的直接推理 指前提和结论都是性质命题的推理,是依照性质命题的内部结构(量项)进行推理.据前提的数目,可分为直接推理(一个命题推出另一新命题:可再细分为对当关系直推.变形直推)和三段论(两个命题推出一个新命题). 一.对当关系直接推理 1.反对关系直接推理 据A.E不能同真,但可同假的性质: (1)若A真,则并非E真. (2)若E真,则并非A真. 例1.所有酒后驾驶都是违法的,所以,并非所有酒后驾驶都不是违法的.(A真,E真) 例2.所有领导讲话都不(是)能信口开河(的),所以,并非所有领

离散数学--第二章--命题逻辑

第2章 命题逻辑• 2.1 命题逻辑基本概念• 2.2 命题逻辑等值演算• 2.3 范式• 2.4 命题逻辑推理理论 蕴涵联结词 等价联结词  p <--> q为真       当且仅当 p与q同时为真或同时为假. 合式公式 真值表:命题公式在所有可能的赋值下的取值的列表 ,含n个变项的公式有2n个赋值 等值式:若等价式A<=>B是重言式, 则称A与B等值, 记作A<=>B, 并称A<=>B是等值式 n个命题变项的真值表共有 个, 故每个命题公式都有无穷多个

商学院

前 言 中南大学以“建设特色鲜明的世界一流大学”为办学目标,主动对接国家重大发展战略需求,为行业和地方社会经济发展服务,坚持将“质量提升”作为构建一流本科教育的核心任务.为进一步深化本科教育教学改革,完善本科人才培养体系,全面提升人才培养质量,学校从2014年3月开始,启动2016版本科人才培养方案的修订工作,同时组织了各教学单位对其开设课程的教学大纲进行修订.教学大纲是实施专业培养方案,实现高校培养目标及要求的教学指导文件,是组织教学过程.进行教学质量评估和实施教学管理的主要依据.制订与本科教