精华内容
下载资源
问答
  • 求命题公式的主范式

    2020-11-26 19:43:57
    求命题公式的主范式题目信息输入输出解答想法 题目信息 输入命题公式的合式公式,求出公式的真值表,并输出该公式的主合取范式和主析取范式。 输入 命题公式的合式公式 输出 公式的主析取范式和主析取范式,输出形式...

    求命题公式的主范式

    题目信息

    输入命题公式的合式公式,求出公式的真值表,并输出该公式的主合取范式和主析取范式。

    输入

    命题公式的合式公式

    输出

    公式的主析取范式和主析取范式,输出形式为:mi ∨ mj ; Mi ∧ Mj ,极小项和 ∨ 符号之间有一个空格,极大项和 ∧ 符号之间有一个空格;主析取范式和主合取范式之间用;隔开,;前后各有一个空格。 永真式的主合取范式为 1 ,永假式的主析取范式为 0 。
    输入公式的符号说明:
    ! 非,相当于书面符号中的 ¬
    & 与,相当于书面符号中的
    |或,相当于书面符号中的
    -蕴含联结词,相当于书面符号中的
    + 等价联结词,相当于书面符号中的
    ( 前括号
    ) 后括号

    解答

    #include <iostream>
    #include <cmath>
    #include <stack>
    #include <cstring>
    
    using namespace std;
    #define N 1000
    #define MAX 10000000
    char x[N];//s是存放输入进去的
    bool table[30] = {false};
    int explain[30] = {0};
    int value[MAX] = {0};
    int sum = 0;
    
    int Priority(char c)
    {//符号优先级判定
        switch (c)
        {
            case '!': return 5;
            case '&': return 4;
            case '|': return 3;
            case '-': return 2;
            case '+': return 1;
            case '(': return 0;
            default: return 0;
        }
    }
    
    void postfix()
    {//中缀转后缀表达式,转换完后仍存放在原字符串中
        char post[N] = {'\0'};
        int p = -1;
        stack<char> s;
    
        int len = strlen(x);
        for (int i = 0; i < len; i++)
        {
            if (x[i] >= 'a' && x[i] <= 'z')
            {
                post[++p] = x[i];
            }
            else if (x[i] == '!' || x[i] == '&' || x[i] == '|' || x[i] == '-' || x[i] == '+')
            {
                while (!s.empty() && Priority(x[i]) <= Priority(s.top()))
                {
                    post[++p] = s.top();
                    s.pop();
                }
                s.push(x[i]);
            }
            else if (x[i] == '(')
            {
                s.push(x[i]);
            }
            else if (x[i] == ')')
            {
                while (s.top() != '(')
                {
                    post[++p] = s.top();
                    s.pop();
                }
                s.pop();//最后记得将(弹出
            }
        }
        while (!s.empty())
        {
            post[++p] = s.top();
            s.pop();
        }
        strcpy(x, post);
    }
    
    void settable()
    {//寻找一共有多少个元素
        int len = strlen(x);
        for (int i = 0; i < len; i++)
        {
            if (x[i] >= 'a' && x[i] <= 'z')
            {
                table[x[i] - 'a'] = true;
            }
        }
        for (int i = 0; i < 26; i++)
        {
            if (table[i])
            {
                sum++;
            }
        }//一共有多少种组合
        sum = (int) pow(2, sum);
    }
    
    int BToI()
    {//二进制转换为十进制
        int ans = 0, weight = 1;
        for (int i = 25; i >= 0; i--)
        {//再一次遍历所有的字母
            if (table[i])
            {
                if (explain[i])
                {
                    ans += weight;
                }
                weight *= 2;
            }
        }
        return ans;
    }
    
    int calc(int a, int b, char c)
    {//
        switch (c)
        {
            case '&':return a * b;
            case '|':
                if (a + b) return 1;
                else return 0;
            case '-':
                if (a == 1 && b == 0) return 0;
                else return 1;
            case '+':return !((a + b) & 1);
            default:return -1;
        }
    }
    
    int work()
    {//运算真值表
        stack<int> s;
        int len = strlen(x);
        for (int i = 0; i < len; i++)
        {
            if (x[i] >= 'a' && x[i] <= 'z')
            {//如果是字母的话,将当前字母取得的0或1放入运算栈中
                s.push(explain[x[i] - 'a']);
            }
            else if (x[i] == '!')
            {//如果是非的话
                if (!s.empty())
                {
                    int tmp = (s.top() + 1) & 1;
                    s.pop();
                    s.push(tmp);
                }
            }
            else
            {//如果是其他双元运算符的话,进入计算
                int b = s.top();
                s.pop();
                int a = s.top();
                s.pop();
                s.push(calc(a, b, x[i]));
            }
        }
        return s.top();
    }
    
    void Generate(char c)
    {//列举每个出现的元素的0,1取值情况
        while (c <= 'z' && table[c - 'a'] == false)
        {//从第一个字母开始寻找
            c++;
        }
        if (c > 'z')
        {//会得到一个二进制值,将真值表计算出的答案存储在value中
            value[BToI()] = work();
            return;
        }
        explain[c - 'a'] = 0;
        Generate(c + 1);
        explain[c - 'a'] = 1;
        Generate(c + 1);
    }
    
    void OutputMIN()
    {
        int i = 0;
        while (i < sum && !value[i])
        {
            i++;
        }
        if (i >= sum)
        {
            cout << "0 ; ";
            return;
        }
        cout << "m" << i;
        for (i++; i < sum; i++)
        {
            if (value[i])
            {
                cout << " ∨ m" << i;
            }
        }
        cout << " ; ";
    }
    
    void OutputMAX()
    {
        int i = 0;
        while (i < sum && value[i]) i++;
        if (i >= sum)
        {
            cout << 1 << endl;
            return;
        }
        cout << "M" << i;
        for (i++; i < sum; i++)
        {
            if (!value[i])
            {
                cout << " ∧ M" << i;
            }
        }
        cout << endl;
    }
    
    int main()
    {
        //freopen("/Users/zhj/Downloads/test.txt", "r", stdin);
        cin >> x;
        postfix();
        settable();
        Generate('a');
        OutputMIN();
        OutputMAX();
        return 0;
    }
    

    想法

    首先我们先明确题目里的含义:
    一个公式的主析取范式的极小项的编码对应着该公式的所有成真赋值。
    一个公式的主合取范式的极大项的编码对应着该公式的所有成假赋值。

    例如a^b

    二进制取值 a b a^b
    0 0 0 0
    1 0 1 0
    2 1 0 0
    3 1 1 1

    此时我们取出所有最终值为0的构成主合取范式的极大项,即M0 ∧ M1 ∧ M2
    取出所有最终值为1的构成主析取范式的极小项,即m3

    例如avb

    二进制取值 a b avb
    0 0 0 0
    1 0 1 1
    2 1 0 1
    3 1 1 1

    取出所有最终值为0的构成主合取范式的极大项,即M0
    取出所有最终值为1的构成主析取范式的极小项,即m1 ∨ m2 ∨ m3

    那么此时程序可以有如下的思路
    第一步,将中缀表达式转换为后缀表达式。
    第二步,列举所有可能性的二进制取值,构成一张真值表。
    第三步,运算出每一个真值表最后的答案。
    第四步,按要求输出相应的主合取范式和主析取范式。

    这里面有个运算的细节:
    一、a & ba ^ b等价于a * b

    a b a & b a * b
    0 0 0 0
    0 1 0 0
    1 0 0 0
    1 1 1 1

    二、a | ba v b等价于if (a + b) return 1; else return 0;

    a b a|b ans
    0 0 0 0
    0 1 1 1
    1 0 1 1
    1 1 1 1

    三、a - ba → b等价于if (a == 1 && b == 0) return 0; else return 1;

    a b a - b ans
    0 0 1 1
    0 1 1 1
    1 0 0 0
    1 1 1 1

    四、a + ba ↔ b等价于!((a + b) & 1)

    a b a + b ans
    0 0 1 1
    0 1 0 0
    1 0 0 0
    1 1 1 1
    展开全文
  • 【离散数学】编程练习:求命题公式的主范式 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #define N 50 char input[N]; bool table[N]; int cvt[N]; ...

    【离散数学】编程练习:求命题公式的主范式

    在这里插入图片描述

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <math.h>
    
    #define N 50
    
    char input[N];
    bool table[N];
    int cvt[N];
    int value[N];
    
    int order(char c)
    {
        switch (c)
        {
        case '#':
            return -1;
        case '(':
            return 0;
        case '+':
            return 1;
        case '-':
            return 2;
        case '|':
            return 3;
        case '&':
            return 4;
        case '!':
            return 5;
        default:
            return 0;
        }
    }
    
    void postfix()
    {
    
        char post[N] = {'\0'};
    
        int index = -1;
    
        char stack[N] = {'#'};
    
        int sub = 0;
    
        int len = strlen(input);
    
        for (int i = 0; i < len; i++)
    
        {
    
            if (input[i] >= 'a' && input[i] <= 'z')
            {
                post[++index] = input[i];
                continue;
            }
            if (input[i] == '!' || input[i] == '&' || input[i] == '|' || input[i] == '-' || input[i] == '+')
            {
                while (order(input[i]) <= order(stack[sub]))
                    post[++index] = stack[sub--];
                stack[++sub] = input[i];
                continue;
            }
            if (input[i] == '(')
            {
                stack[++sub] = input[i];
                continue;
            }
            if (input[i] == ')')
            {
                while (stack[sub] != '(')
                    post[++index] = stack[sub--];
                sub--;
                continue;
            }
        }
    
        while (sub)
            post[++index] = stack[sub--];
    
        strcpy(input, post);
    }
    
    int btoi()
    
    {
        int sum = 0, weight = 1;
        for (int i = 25; i >= 0; i--)
            if (table[i])
            {
                if (cvt[i]) sum += weight;
                weight *= 2;
            }
        return sum;
    }
    
    int calc(int a, int b, char c)
    {
        switch (c)
        {
            case '&': return a * b;
            case '|': if (a + b) return 1; else return 0;
            case '-': if (a == 1 && b == 0) return 0; else return 1;
            case '+': return !((a + b) & 1);
        }
    }
    
    int work()
    {
        int stack[N], ps = -1;
        int len = strlen(input);
        for (int i = 0; i < len; i++)
        {
            if (input[i] >= 'a' && input[i] <= 'z')
            {
                stack[++ps] = cvt[input[i] - 'a'];
                continue;
            }
            if (input[i] == '!')
            {
                stack[ps] = (stack[ps] + 1) & 1;
                continue;
            }
            int ans = calc(stack[ps - 1], stack[ps], input[i]);
            stack[--ps] = ans;
        }
        return stack[0];
    }
    
    void assign()
    {
        int x = btoi();
        int ans = work();
        value[x] = ans;}
    
    void generate(char c)
    {
        while (c <= 'z' && table[c - 'a'] == false)
            c++;
        if (c > 'z')
        {
            assign();
            return;
        }
    
        cvt[c - 'a'] = 0;
    
        generate(c + 1);
    
        cvt[c - 'a'] = 1;
    
        generate(c + 1);
    }
    
    int set_order()
    {
        int v = 0;
        memset(table, 0, sizeof(table));
    
        int len = strlen(input);
    
        for (int i = 0; i < len; i++)
    
        {
    
            if (input[i] >= 'a' && input[i] < 'z')
    
                table[input[i] - 'a'] = true;
        }
    
        for (int i = 0; i < 26; i++)
    
            if (table[i])
                v++;
    
        v = pow(2, v);
    
        return v;
    }
    
    void outDis(int sum)
    {
        int i = 0;
        while (i < sum && !value[i]) i++;
        if (i >= sum)
        {
            printf("0 ; ");
            return;
        }
        printf("m%d", i);
        for (i++; i < sum; i++)
            if (value[i]) printf(" ∨ m%d", i);
        printf(" ; ");
    }
    
    void outCon(int sum)
    {
        int i = 0;
        while (i < sum && value[i]) i++;
        if (i >= sum)
        {
            printf("1\n");
            return;
        }
        printf("M%d", i);
        for (i++; i < sum; i++)
            if (!value[i]) printf(" ∧ M%d", i);
        printf("\n");
    }
    
    void result(int sum)
    {
        generate('a');
        outDis(sum);
        outCon(sum);
    }
    
    
    int main()
    {        int sum;
        scanf("%s", input);
        postfix();
        sum = set_order();
        result(sum);
        return 0;
    }
    
    展开全文
  • 离散数学 求命题公式的主范式

    千次阅读 多人点赞 2016-04-27 23:02:32
    实现功能:输入命题公式的合式公式,出公式的真值表,并输出该公式的主合取范式和主析取范式。 输入:命题公式的合式公式 输出:公式的主析取范式和主析取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项和 ...
    实现功能:输入命题公式的合式公式,求出公式的真值表,并输出该公式的主合取范式和主析取范式。
    输入:命题公式的合式公式
    输出:公式的主析取范式和主析取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项和 ∨ 符号之间有一个空格,极大项和 ∧ 符号之间有一个空格;主析取范式和主合取范式之间用“ ; ”隔开,“ ; ”前后各有一个空格。 永真式的主合取范式为 1 ,永假式的主析取范式为 0 。
    输入公式的符号说明:
    ! 非,相当于书面符号中的 “ ¬ ”
    & 与,相当于书面符号中的 “ ∧ ”
    | 或,相当于书面符号中的 “ ∨ ”
    - 蕴含联结词,相当于书面符号中的 “ → ”
    + 等价联结词,相当于书面符号中的 “ ↔ ”
    ( 前括号

    ) 后括号

    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #define N 1000
    #define MAX 10000000
    char s[N];
    bool table[30];
    int explain[30];
    int value[MAX];
    int sum = 0;
    int priority(char c)
    {
    	switch (c)
    	{
    		case '#': return -1;
    		case '!': return 5;
    		case '&': return 4;
    		case '|': return 3;
    		case '-': return 2;
    		case '+': return 1;
    		case '(': return 0;
    		default: return 0;
    	}
    }
    void postfix()
    {
    	char post[N] = { '\0' };
    	int pp = -1;
    	char stack[N] = { '#' };
    	int ps = 0;
    
    	int len = strlen(s);
    	for (int i = 0; i < len; i++)
    	{
    		if (s[i] >= 'a' && s[i] <= 'z')
    		{
    			post[++pp] = s[i];
    			continue;
    		}
    		if (s[i] == '!' || s[i] == '&' || s[i] == '|' || s[i] == '-' || s[i] == '+')
    		{
    			while (priority(s[i]) <= priority(stack[ps]))
    				post[++pp] = stack[ps--];
    			stack[++ps] = s[i];
    			continue;
    		}
    		if (s[i] == '(')
    		{
    			stack[++ps] = s[i];
    			continue;
    		}
    		if (s[i] == ')')
    		{
    			while (stack[ps] != '(') post[++pp] = stack[ps--];
    			ps--;
    			continue;
    		}
    	}
    	while (ps) post[++pp] = stack[ps--];
    	strcpy(s, post);
    	int l = strlen(s);
    }
    void settable()
    {
    	memset(table, 0, sizeof(table));
    	int len = strlen(s);
    	for (int i = 0; i < len; i++)
    	{
    		if (s[i] >= 'a' && s[i] < 'z')
    			table[s[i] - 'a'] = true;
    	}
    	for (int i = 0; i < 26; i++)
    		if (table[i]) sum++;
    	sum = pow(2, sum);
    }
    int btoi()
    {
    	int sum = 0, weight = 1;
    	for (int i = 25; i >= 0; i--)
    		if (table[i])
    		{
    			if (explain[i]) sum += weight;
    			weight *= 2;
    		}
    	return sum;
    }
    int calc(int a, int b, char c)
    {
    	switch (c)
    	{
    		case '&': return a * b;
    		case '|': if (a + b) return 1; else return 0;
    		case '-': if (a == 1 && b == 0) return 0; else return 1;
    		case '+': return !((a + b) & 1);
    	}
    }
    int work()
    {
    	int stack[N], ps = -1;
    	int len = strlen(s);
    	for (int i = 0; i < len; i++)
    	{
    		if (s[i] >= 'a' && s[i] <= 'z')
    		{
    			stack[++ps] = explain[s[i] - 'a'];
    			continue;
    		}
    		if (s[i] == '!')
    		{
    			stack[ps] = (stack[ps] + 1) & 1;
    			continue;
    		}
    		int ans = calc(stack[ps - 1], stack[ps], s[i]);
    		stack[--ps] = ans;
    	}
    	return stack[0];
    }
    void assign()
    {
    	int x = btoi();
    	int ans = work();
    	value[x] = ans;
    }
    void generate(char c)
    {
    	while (c <= 'z' && table[c - 'a'] == false) c++;
    	if (c > 'z')
    	{
    		assign();
    		return;
    	}
    	explain[c - 'a'] = 0;
    	generate(c + 1);
    	explain[c - 'a'] = 1;
    	generate(c + 1);
    }
    void output1()
    {
    	int i = 0;
    	while (i < sum && !value[i]) i++;
    	if (i >= sum)
    	{
    		printf("0 ; ");
    		return;
    	}
    	printf("m%d", i);
    	for (i++; i < sum; i++)
    		if (value[i]) printf(" ∨ m%d", i);
    	printf(" ; ");
    }
    void output2()
    {
    	int i = 0;
    	while (i < sum && value[i]) i++;
    	if (i >= sum)
    	{
    		printf("1\n");
    		return;
    	}
    	printf("M%d", i);
    	for (i++; i < sum; i++)
    		if (!value[i]) printf(" ∧ M%d", i);
    	printf("\n");
    }
    int main()
    {
    	scanf("%s", s);
    	postfix();
    	settable();
    	memset(value, 0, sizeof(value));
    	memset(explain, 0, sizeof(explain));
    	generate('a');
    	output1();
    	output2();
    	return 0;
    }


    展开全文
  • 输入命题公式的合式公式,出公式的真值表,并输出该公式的主合取范式和主析取范式。 Input 命题公式的合式公式 Output 公式的主析取范式和主合取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项和 ∨ 符号...

    Description

    输入命题公式的合式公式,求出公式的真值表,并输出该公式的主合取范式和主析取范式。

    Input

    命题公式的合式公式

    Output

    公式的主析取范式和主合取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项和 ∨ 符号之间有一个空格,极大项和 ∧ 符号之间有一个空格;主析取范式和主合取范式之间用“ ; ”隔开,“ ; ”前后各有一个空格。 永真式的主合取范式为 1 ,永假式的主析取范式为 0 。

    输入公式的符号说明:
    ! 非,相当于书面符号中的 “ ¬ ”
    & 与,相当于书面符号中的 “ ∧ ”
    | 或,相当于书面符号中的 “ ∨ ”

    • 蕴含联结词,相当于书面符号中的 “ → ”
    • 等价联结词,相当于书面符号中的 “ ↔ ”
      ( 前括号
      ) 后括号

    Code

    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #define N 1000
    #define MAX 10000000
    char s[N];
    bool table[30];
    int explain[30];
    int value[MAX];
    int sum = 0;
    int priority(char c)
    {
        switch (c)
        {
            case '#': return -1;
            case '!': return 5;
            case '&': return 4;
            case '|': return 3;
            case '-': return 2;
            case '+': return 1;
            case '(': return 0;
            default: return 0;
        }
    }
    void postfix()
    {
        char post[N] = { '\0' };
        int pp = -1;
        char stack[N] = { '#' };
        int ps = 0;
    
        int len = strlen(s);
        for (int i = 0; i < len; i++)
        {
            if (s[i] >= 'a' && s[i] <= 'z')
            {
                post[++pp] = s[i];
                continue;
            }
            if (s[i] == '!' || s[i] == '&' || s[i] == '|' || s[i] == '-' || s[i] == '+')
            {
                while (priority(s[i]) <= priority(stack[ps]))
                    post[++pp] = stack[ps--];
                stack[++ps] = s[i];
                continue;
            }
            if (s[i] == '(')
            {
                stack[++ps] = s[i];
                continue;
            }
            if (s[i] == ')')
            {
                while (stack[ps] != '(') post[++pp] = stack[ps--];
                ps--;
                continue;
            }
        }
        while (ps) post[++pp] = stack[ps--];
        strcpy(s, post);
        int l = strlen(s);
    }
    void settable()
    {
        memset(table, 0, sizeof(table));
        int len = strlen(s);
        for (int i = 0; i < len; i++)
        {
            if (s[i] >= 'a' && s[i] < 'z')
                table[s[i] - 'a'] = true;
        }
        for (int i = 0; i < 26; i++)
            if (table[i]) sum++;
        sum = pow(2, sum);
    }
    int btoi()
    {
        int sum = 0, weight = 1;
        for (int i = 25; i >= 0; i--)
            if (table[i])
            {
                if (explain[i]) sum += weight;
                weight *= 2;
            }
        return sum;
    }
    int calc(int a, int b, char c)
    {
        switch (c)
        {
            case '&': return a * b;
            case '|': if (a + b) return 1; else return 0;
            case '-': if (a == 1 && b == 0) return 0; else return 1;
            case '+': return !((a + b) & 1);
        }
    }
    int work()
    {
        int stack[N], ps = -1;
        int len = strlen(s);
        for (int i = 0; i < len; i++)
        {
            if (s[i] >= 'a' && s[i] <= 'z')
            {
                stack[++ps] = explain[s[i] - 'a'];
                continue;
            }
            if (s[i] == '!')
            {
                stack[ps] = (stack[ps] + 1) & 1;
                continue;
            }
            int ans = calc(stack[ps - 1], stack[ps], s[i]);
            stack[--ps] = ans;
        }
        return stack[0];
    }
    void assign()
    {
        int x = btoi();
        int ans = work();
        value[x] = ans;
    }
    void generate(char c)
    {
        while (c <= 'z' && table[c - 'a'] == false) c++;
        if (c > 'z')
        {
            assign();
            return;
        }
        explain[c - 'a'] = 0;
        generate(c + 1);
        explain[c - 'a'] = 1;
        generate(c + 1);
    }
    void output1()
    {
        int i = 0;
        while (i < sum && !value[i]) i++;
        if (i >= sum)
        {
            printf("0 ; ");
            return;
        }
        printf("m%d", i);
        for (i++; i < sum; i++)
            if (value[i]) printf(" ∨ m%d", i);
        printf(" ; ");
    }
    void output2()
    {
        int i = 0;
        while (i < sum && value[i]) i++;
        if (i >= sum)
        {
            printf("1\n");
            return;
        }
        printf("M%d", i);
        for (i++; i < sum; i++)
            if (!value[i]) printf(" ∧ M%d", i);
        printf("\n");
    }
    int main()
    {
        scanf("%s", s);
        postfix();
        settable();
        memset(value, 0, sizeof(value));
        memset(explain, 0, sizeof(explain));
        generate('a');
        output1();
        output2();
        return 0;
    }

    转载于:https://www.cnblogs.com/dadamrx/p/7294633.html

    展开全文
  • 使用C++求命题公式的主析取范式与主合取范式

    千次阅读 多人点赞 2018-09-22 17:21:29
    最近离散数学一个上机作业,要求任意输入一个命题公式真值表与析取范式和主合取范式。其中命题连接词都是用特殊符号来表示(怕麻烦……),并最终选择使用C++来编写程序。 先贴代码: // 五种...
  • 首先用一个串来储存使用者所输入命题表达式,依据人类思维,会对输入的命题公式进行分析和计算,但计算机可不会,这时我们就要写入相关代码把使用者输入命题表达式转换为计算机所能进行计算后缀表达式,我们...
  • 一个命题公式的主析取(合取)范式 这是大二学离散数学的时候写的, 在这里留个档吧, 算是回忆... 代码各种乱, 不改了. 1 /* header.h 2 *author : jackiesteed 3 *内容: 给定一个命题公式, 可以...
  • 第二行开始到最后为命题公式的真值表最后一列。 输出格式: 输出析取范式。 注意: 1.逻辑连接词非为!,与为^,或为+; 2.输出中空格格式; 3.输出中命题符合依次从A开始; 4.如果该命题为永假式,则输出为空。 ...
  • [离散] 编程求命题公式真值表

    千次阅读 多人点赞 2017-03-18 09:41:19
    [离散] 编程求命题公式真值表概述 真值表是离散数学中的一个重要概念,由真值表我们能求得任意命题公式的主析取范式和主合取范式。本文将用C语言编写一个求任意命题公式真值表的程序
  • 《荷塘月色》第五段讲了几层意思,请选出最恰当的一项()【简答题】5张与服装有关的牛仔元素面料再造,10张牛仔面料再造的文创作品【单选题】A-B=B 的充分必要条件是 (5.0分)【单选题】下列式子不是谓词合式公式的是( ...
  • 任意输入一个命题公式,计算并输出其... /usr/bin/env python3# -*- coding:utf-8 -*-sInput = '' #输入的命题公式字符串sParse = '' #化简后sInputvariable = [] #保存公式中变量ornl = [] #析取范式最小项a...
  • 命题公式若在复合命题中,p、q、r 等不仅可以代表命题常项,还可以代表命题变项,这样复合命题形式称为命题公式。命题赋值设 A 为一命题公式, p ,p p 为出现在 A 中所有命题变项。给 p ,p p 指定一组真值,...
  • 离散数学—求主范式

    千次阅读 2017-04-30 18:13:59
    输出:公式的主析取范式和主析取范式,输出形式为:“ mi ∨ mj ; Mi ∧ Mj” ,极小项和 ∨ 符号之间有一个空格,极大项和 ∧ 符号之间有一个空格;主析取范式和主合取范式之间用“ ; ”隔开,“ ; ”前后各有一个...
  • 利用真值表法主合取范式析取范式的实现

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

    千次阅读 2014-11-03 10:43:47
     离散数学中析取范式如何通过计算机求主析取范式。其中一种办法就是用二维数组存储析取范式的真值表,然后代入命题公式,真值为T,就是它最小项。其中会用到栈这种数据结构判断优先级。。
  • 任意输入一个命题公式,计算并输出其真值表以及析取范式,主合取范式 思路:大概就是将蕴含,等价,异或进行转化,然后使用eval()计算 #! /usr/bin/env python3 # -*- coding:utf-8 -*- sInput = '' #输入的命题...
  • 例如,利用命题公式的真值表,可以判断命题公式的类型、求命题公式的主范式、判断两命题公式是否等价。(背景:离散数学) 2.实验代码 # -*- coding:gbk -*- sInput = '' #输入的命题公式字符串 sParse = '' #化简...
  • 命题公式后缀转中缀

    2019-11-12 22:04:16
    /* 任意一个命题公式的真值表(B),并根据真值表求主范式(C)*/ // p、 q、 r、 () 、 &(∧)、 |(∨)、 > (->蕴含) 、 -(<->等价) ! (﹁否定) //a &b | c > ( d ! e & f ) ! g...
  • ( 5 ) 极小项 成真赋值 公式 名称 之间 转化 与 推演 3. 极大项 ( 1 ) 极大项 简介 ( 2 ) 极大项 说明 ( 3 ) 两个命题变项极大项 ( 4 ) 三个命题变项极大项 ( 5 ) 极大项 成假赋值 公式 名称 之间
  • 通过代码编译出的程序帮助用户出其输入的命题公式的真值表以及主析取范式和主合取范式。 要求:能够列出含三个以内变量的合式公式的真值表,并给出相应的主析取和主合取范式
  • 范式

    2020-08-26 23:53:11
    范式简单析取范式与简单合取范式例子推论合取范式与析取范式例子性质求得析取范式与合取范式步骤定理主析取范式与主合取范式极小项例主析取范式的定义定理【任意命题公式都有唯一的主析取范式】主析取范式的用途1 ...

空空如也

空空如也

1 2 3
收藏数 42
精华内容 16
关键字:

求命题公式的主范式