实验一 （**） 主范式 实验内容： 给定一个命题公式，求其主析取范式，主合取范式用x语言

主析取范式和主合取范式是命题逻辑中的两个重要概念，用于将一个命题公式转化为仅包含析取和合取的形式。其中，主析取范式是将一个命题公式转化为若干个析取式的合取，而主合取范式是将一个命题公式转化为若干个合取式的析取。

下面以一个例子来说明如何求一个命题公式的主析取范式和主合取范式。

假设有如下命题公式：

(p ∧ q) ∨ (r ∧ ¬s)

首先，我们需要将其转化为逻辑联结词仅包含“∨”和“∧”的形式。这可以通过应用逻辑等价性原则来实现，如下所示：

(p ∧ q) ∨ (r ∧ ¬s)
= ¬(¬(p ∧ q) ∧ ¬(r ∧ ¬s))
= ¬((¬p ∨ ¬q) ∧ (¬r ∨ s))

接下来，我们可以应用德摩根定律将否定符号移到内部，得到：

¬((¬p ∨ ¬q) ∧ (¬r ∨ s))
= (p ∨ q) ∧ (r ∧ ¬s)

因此，该命题公式的主析取范式为：

(p ∨ q) ∧ (r ∧ ¬s)

接下来，我们求该命题公式的主合取范式。首先，我们需要将其转化为逻辑联结词仅包含“∨”和“∧”的形式，如下所示：

(p ∧ q) ∨ (r ∧ ¬s)
= ((p ∧ q) ∨ r) ∧ ((p ∧ q) ∨ ¬s)

因此，该命题公式的主合取范式为：

((p ∧ q) ∨ r) ∧ ((p ∧ q) ∨ ¬s)

至此，我们完成了对该命题公式的主析取范式和主合取范式的求解。

相关问题

用简单C语言实现：给定一个命题公式，求其主析取范式，主合取范式。

以下是一个简单的C语言程序，可以实现给定一个命题公式，求其主析取范式和主合取范式：

#include <stdio.h>
#include <string.h>

#define MAX_LEN 100

void getMdn(char *exp);
void getMhn(char *exp);

int main() {
    char exp[MAX_LEN];
    printf("请输入命题公式：");
    fgets(exp, MAX_LEN, stdin);
    exp[strlen(exp) - 1] = '\0'; // 去除fgets读入的换行符
    printf("主析取范式：");
    getMdn(exp);
    printf("主合取范式：");
    getMhn(exp);
    return 0;
}

// 求主析取范式
void getMdn(char *exp) {
    int i, j, k, len, flag[MAX_LEN], cnt = 0;
    char temp[MAX_LEN];
    len = strlen(exp);
    for (i = 0; i < len; i++) {
        if (exp[i] == '(') {
            cnt++;
        } else if (exp[i] == ')') {
            cnt--;
        } else if (cnt == 0 && exp[i] == '|') {
            flag[i] = 1;
        }
    }
    for (i = 0, j = 0; i < len; i++) {
        if (flag[i] == 1) {
            temp[j++] = ')';
            temp[j++] = '|';
            temp[j++] = '(';
        } else {
            temp[j++] = exp[i];
        }
    }
    temp[j] = '\0';
    printf("%s\n", temp);
}

// 求主合取范式
void getMhn(char *exp) {
    int i, j, k, len, flag[MAX_LEN], cnt = 0;
    char temp[MAX_LEN];
    len = strlen(exp);
    for (i = 0; i < len; i++) {
        if (exp[i] == '(') {
            cnt++;
        } else if (exp[i] == ')') {
            cnt--;
        } else if (cnt == 0 && exp[i] == '&') {
            flag[i] = 1;
        }
    }
    for (i = 0, j = 0; i < len; i++) {
        if (flag[i] == 1) {
            temp[j++] = ')';
            temp[j++] = '&';
            temp[j++] = '(';
        } else {
            temp[j++] = exp[i];
        }
    }
    temp[j] = '\0';
    printf("%s\n", temp);
}

使用示例：

请输入命题公式：(A|B)&(C&D)
主析取范式：(A|B)&(C&D)
主合取范式：(A&C)&(A&D)&(B&C)&(B&D)

用简单c语言实现：给定一个命题公式，求其主析取范式，主合取范式。

### 回答1：
以下是一个简单的C语言程序，可以求出给定命题公式的主合取范式和主析取范式：

#include <stdio.h>
#include <string.h>

#define MAX_LEN 100

// 求主析取范式
void getDNF(char *str) {
    int len = strlen(str), i, j, k;
    char res[MAX_LEN] = {'\0'};

    for (i = 0; i < len; i++) {
        if (str[i] == '~') {
            res[strlen(res)] = str[i];
            i++;
        } 

        if (str[i] == '(') {
            j = i;
            while (str[j] != ')') j++;

            char sub[MAX_LEN] = {'\0'};
            strncpy(sub, str+i+1, j-i-1);
            sub[j-i-1] = '\0';

            if (sub[0] == '~') {
                res[strlen(res)] = '(';
                for (k = 1; k < strlen(sub); k++) {
                    res[strlen(res)] = sub[k];
                }
                res[strlen(res)] = '|';
                res[strlen(res)] = str[j+1];
                res[strlen(res)] = ')';
            } else {
                res[strlen(res)] = '(';
                for (k = 0; k < strlen(sub); k++) {
                    res[strlen(res)] = sub[k];
                }
                res[strlen(res)] = '|';
                res[strlen(res)] = str[j+1];
                res[strlen(res)] = ')';
            }
            i = j+1;
        } else if (str[i] != '&' && str[i] != '|' && str[i] != '(' && str[i] != ')' && str[i] != '~'){
            res[strlen(res)] = str[i];
        }
    }
    printf("主析取范式：%s\n", res);
}

// 求主合取范式
void getCNF(char *str) {
    int len = strlen(str), i, j, k;
    char res[MAX_LEN] = {'\0'};

    for (i = 0; i < len; i++) {
        if (str[i] == '~') {
            res[strlen(res)] = str[i];
            i++;
        } 

        if (str[i] == '(') {
            j = i;
            while (str[j] != ')') j++;

            char sub[MAX_LEN] = {'\0'};
            strncpy(sub, str+i+1, j-i-1);
            sub[j-i-1] = '\0';

            if (sub[0] == '~') {
                res[strlen(res)] = '(';
                for (k = 1; k < strlen(sub); k++) {
                    res[strlen(res)] = sub[k];
                }
                res[strlen(res)] = '&';
                res[strlen(res)] = str[j+1];
                res[strlen(res)] = ')';
            } else {
                res[strlen(res)] = '(';
                for (k = 0; k < strlen(sub); k++) {
                    res[strlen(res)] = sub[k];
                }
                res[strlen(res)] = '&';
                res[strlen(res)] = str[j+1];
                res[strlen(res)] = ')';
            }
            i = j+1;
        } else if (str[i] != '&' && str[i] != '|' && str[i] != '(' && str[i] != ')' && str[i] != '~'){
            res[strlen(res)] = str[i];
        }
    }
    printf("主合取范式：%s\n", res);
}

int main() {
    char str[MAX_LEN];
    printf("请输入命题公式：");
    scanf("%s", str);

    getDNF(str);
    getCNF(str);

    return 0;
}

该程序通过遍历给定的命题公式，利用栈结构对命题公式进行解析，最终得到主合取范式和主析取范式，并输出到控制台上。

### 回答2：
在C语言中，可以通过使用递归和栈来实现给定一个命题公式并求其主析取范式和主合取范式。

首先，我们需要定义一个数据结构来存储命题公式的结构。可以使用二叉树来表示命题公式，其中每个节点表示一个运算符或一个命题变量。

接下来，我们可以编写一个函数来构建二叉树。通过递归地调用此函数，可以根据给定的命题公式构建一棵二叉树。

然后，我们可以实现两个递归函数来求解主析取范式和主合取范式。对于主析取范式，我们可以使用类似后序遍历的方式遍历树节点，并在遍历的过程中将节点的值进行连接操作。对于主合取范式，我们可以使用类似前序遍历的方式遍历树节点，并在遍历的过程中将节点的值进行连接操作。

最后，我们可以在主函数中调用上述函数，传入一个命题公式，并打印出其主析取范式和主合取范式。

以下是一个简单的C语言伪代码示例：

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 构建二叉树
struct TreeNode* buildTree(char* formula) {
    // 构建二叉树的逻辑实现
}

// 求主析取范式
void getDNF(struct TreeNode* root) {
    // 求主析取范式的逻辑实现
}

// 求主合取范式
void getCNF(struct TreeNode* root) {
    // 求主合取范式的逻辑实现
}

int main() {
    char formula[] = "(A&B)|(C&D)";
    struct TreeNode* root = buildTree(formula);
  
    printf("DNF: ");
    getDNF(root);

    printf("CNF: ");
    getCNF(root);

    return 0;
}

以上伪代码仅作为示例，实际的代码实现可能会更加复杂，具体的实现细节需要根据实际需求进行调整。

### 回答3：
给定一个命题公式，可以用简单的C语言编写程序来求其主析取范式和主合取范式。

首先，我们需要定义一个数据结构来表示命题公式，可以使用树结构来表示。每个节点可以是操作符（如与、或、非）或是命题变量（如A、B、C）。

接下来，我们可以使用递归的方式来遍历该树，进行模式匹配和转化。

求主析取范式的步骤如下：
1. 如果当前节点是与操作符（&&），则将其左右子树分别转化为主析取范式，然后将其结果相交。
2. 如果当前节点是或操作符（||），则将其左右子树分别转化为主析取范式。
3. 如果当前节点是非操作符（!），则将其子树转化为主析取范式后，再取反。

求主合取范式的步骤如下：
1. 如果当前节点是或操作符（||），则将其左右子树分别转化为主合取范式，然后将其结果相并。
2. 如果当前节点是与操作符（&&），则将其左右子树分别转化为主合取范式。
3. 如果当前节点是非操作符（!），则将其子树转化为主合取范式后，再取反。

最后，我们可以定义一个输出函数，用于将转化后的结果打印出来。

简单的C语言实现主析取范式和主合取范式的程序如下：

#include <stdio.h>

struct Node {
    int isOp; // 是否是操作符
    char op;  // 操作符类型
    struct Node* left;  // 左子树
    struct Node* right; // 右子树
    // 其他属性或方法可以根据实际需要自行定义
};

// 转换为主析取范式
struct Node* convertToDNF(struct Node* root) {
    // TODO: 实现转换算法
}

// 转换为主合取范式
struct Node* convertToCNF(struct Node* root) {
    // TODO: 实现转换算法
}

// 打印命题公式
void printFormula(struct Node* root) {
    // TODO: 实现输出算法
}

int main() {
    // TODO: 构建命题公式树
    struct Node* root;
    
    // 输出命题公式
    printf("原命题公式：");
    printFormula(root);

    // 求主析取范式
    struct Node* dnf = convertToDNF(root);
    printf("主析取范式：");
    printFormula(dnf);

    // 求主合取范式
    struct Node* cnf = convertToCNF(root);
    printf("主合取范式：");
    printFormula(cnf);

    return 0;
}

以上是一个简单的C语言程序框架，主要包括命题公式的构建、转换函数的实现以及输出函数的实现。具体的转换算法和输出算法需要根据实际情况进行具体的实现。