[栈的应用] 打印任意命题公示的真值表和主范式（这是转载同学的）

最新推荐文章于 2022-05-06 12:58:40 发布
最新推荐文章于 2022-05-06 12:58:40 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 离散数学学习笔记 文章标签： input struct table string 出版 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxq1138634642/article/details/8083790
版权

课本是高等教育出版社出版的《离散数学及其应用》。

程序会自动分析输入的表达式，并且列出真值表，最后打印出主析取范式和主合取范式，最多支持256 个变元。

主要用到的算法：中缀表达式转后缀表达式、后缀表达式求值还有一个二进制加法模拟。


下面上2 个图，第一个是表达式开头没有非运算的（课本P85 例3.5.5）：


第二个不但表达式开头有非运算，而且非运算之后并不是一个数值，而是一个操作符（课本P83 例3.5.4）：

下面是代码，如果CSDN 的编辑器弄乱了就将就着看吧，本来代码的缩进和排版都是整洁的。

file:///main.c

* main.c 
 * use MinGW Developer Studio to compile 
 * by iSpeller (shell_way@foxmail.com) 
 */  
  
#include <stdio.h>   
#include <stdlib.h>   
#include <string.h>   
  
#define _BUF_LEN    (1<<10)   
#define _STACK_LEN  (_BUF_LEN/2)   
#define _PROP_LEN   (1<<7)   
  
#define VOID_NUM    (0) /* 不存在的运算数 */   
typedef char *  string;  
typedef int bool;  
#define true    (1)   
#define false   (0)   
typedef int     data_t;  
/* 防止各种老式编译器来大姨妈 */  
#ifndef _SIZE_T   
typedef unsigned int    size_t;  
#endif   
#ifndef _SSIZE_T   
typedef int ssize_t;  
#endif   
  
/* 范式类型，     析取,    合取 */  
enum paradigm   { EXTRACT, CONJUNCT, };  
/* 优先级大小     等于, 小于,   大于 */  
enum priorities { EG=0, NGE=-1, NLE=1, };  
/* 联结词（包括英文圆括号）优先级，全真 */  
/*     左括号, 非,    合取,  析取, 蕴含,   右括号,  结束符 */  
enum { LEFT=5, NOT=4, AND=3, OR=3, CONT=3, RIGHT=2, END=1, };  
  
/* 4个栈，expr 储存后缀表达式，truth_expr 是expr 的真值解释 
 * ops 储存联结词, truth 做后缀表达式求值栈，truth 最后存放表达式真值  
 */  
struct  stack {  
    data_t data[_STACK_LEN];  
    ssize_t len;  
    size_t len_max;  
}expr, truth_expr, ops, truth;    
string  input_buf = NULL;   /* 存放输入的表达式 */  
struct  prop {    
    char p; /* 变元名 */  
    bool v; /* 真值 */  
};  
struct  table {  
    struct prop data[_PROP_LEN];  
    ssize_t len;  
    size_t len_max;  
} prop_table;   /* 原子命题变元的列表 */  
typedef int truth_item;  
struct truth_table {  
    truth_item data[_STACK_LEN];  
    ssize_t len;  
    size_t len_max;  
} truth_table;  /* 真值表 */  
  
#define push(s,a)   ((s).data[++(s).len] = (a))   
#define pop(s)      ((s).data[(s).len--])   
#define is_empty(s) ((s).len+1)   
#define get_top(s)  ((s).data[(s).len])   
#define init(s,m)   (((s).len = -1) || ((s).len_max = (m)))   
  
#define STRCMP(a,r,b)   (strcmp ((a), (b)) r 0)   
  
/* 判断字符是否是原子命题变元 
 */  
bool  
is_op (char c) {  
    switch (c) {  
    case '|':   return OR;      break;  
    case '&':   return AND;     break;  
    case '!':   return NOT;     break;  
    case '>':    return CONT;    break;  
    case '(':   return LEFT;    break;  
    case ')':   return RIGHT;   break;  
    case '#':   return END;     break;    
    default :   return false;  
    }  
}  
  
/* 判断运算符的优先级 
 */  
enum priorities  
get_priority (char op1, char op2) {  
    if (is_op (op1) == is_op (op2))  
        return EG;  
    else if (is_op (op1) < is_op (op2))  
        return NGE;  
    else  
        return NLE;  
}  
  
/* 进行数据运算 
 */  
data_t  
do_op (char op, bool num1, bool num2) {  
    bool truth = false;  
      
    if('!' == op)   
        return num1 ? false : true;  
    switch (op) {  
    case '|':   truth = (num2 || num1); break;  
    case '&':   truth = (num2 && num1); break;  
    case '>':    truth = (num2 && !num1) ? false : true; break;  
    default:    fprintf (stderr, "Boy, WHAT Did U Have Done!!??\n");  
                exit (0);  
    }  
    return truth;  
}  
  
/* 判断识别的命题变元是否已经存在 
 */  
bool  
prop_find (struct prop item) {  
    ssize_t count = 0;  
      
    for (count=0; count<prop_table.len+1; ++count)  
        if (item.p == prop_table.data[count].p)  
            return true;  
    return false;  
}  
  
/* 判断变元真值是否设置完毕 
 * 如果真值全真返回真 
 */  
bool  
set_truth_end (void) {  
    ssize_t count;  
      
    for (count=0; count<prop_table.len+1; ++count)  
        if (!prop_table.data[count].v)  
            return false;  
      
    return true;  
}  
   
/* 输出“你好” 
 */  
void  
start (void) {  
    printf ("输入诸如\"P|(Q&R)>!P\" 的表达式，程序将会列出真值表并求出主范式。\n\n");  
    printf ("其中：\"|\"表示析取；\"&\"表示合取；\"!\"表示非；\">\"表示蕴含。支持英文圆括号。\n");  
    printf ("字符串处理不是算法的核心，所以不会处理非法输入\n");  
    printf ("\t----因此当你输入了非法的表达式，你也会得到一个非法的结果 :D\n");  
    printf ("exit 指令退出。\n\n");  
}  
  
/* 要求用户输入表达式和原子命题变元的真值 
 */  
void  
get_input () {  
    char *loc = input_buf;  
    size_t size = 0;  
    struct prop item;  
      
    /* 清栈 */  
    init (expr, _STACK_LEN);   
    init (ops, _STACK_LEN);  
    init (truth_expr, _STACK_LEN);  
    init (truth, _STACK_LEN);  
    init (truth_table, _STACK_LEN);  
    init (prop_table, _PROP_LEN);  
      
    if (!(input_buf = (char *)malloc (_BUF_LEN))) {  
        perror ("malloc ()");  
        exit (1);  
    }  
              
    /* 获取表达式 */  
    do {  
        printf (" # ");  
        if (!fgets (input_buf, _BUF_LEN-1, stdin)) {  
            perror ("fgets ()");  
            exit (1);  
        }  
        input_buf[strlen (input_buf)-1] = '#';  /* 结束符号 */  
      
        if (STRCMP ("exit#", ==, input_buf)) {  
            printf ("再见 :D\n");  
            exit (0);  
        }  
    } while (STRCMP ("#", ==, input_buf));  
      
    /* 识别原子命题变元和联结词并压入变元列表 */  
    size = strlen (input_buf);  
    for (loc = input_buf; loc-input_buf < size; ++loc) {  
        if (' ' != *loc)   
            if (!is_op (*loc)) {  
                item.p = *loc;  
                if (!prop_find (item))  
                    push (prop_table, item);    /* 现在并不赋真值 */  
            }   
    }  
}  
  
/* input_buf 中的表达式转换为后缀表达式 
 */  
void  
make_postfix_expr () {  
    data_t item;  
    ssize_t count;  
    enum priorities level;  
      
    push (ops, '#');    /* 栈底元素，结束符号，优先级最小 */  
    for (count=0; count<strlen (input_buf); ++count) {  
        item = input_buf[count];  
          
        if (' ' == item)  
            continue;  
          
        if (!is_op (item))  /* 是操作数则压入表达式栈 */  
            push (expr, item);  
        else if (')' == item || '#' == item) {  /* 去除成对的括号和结束标记'#' */  
            while ('#' != (item = pop (ops)))  
                push (expr, item);  
            pop (ops);  
        } else {  
            level = get_priority (item, get_top (ops));  
              
            /* 通过压入一个不存在的操作数，把单目运算符'!'  
             * 当作双目运算符来处理 
             */  
            if ('!' == item)      
                push (expr, VOID_NUM);  
              
            if (NLE == level) {     /* 如果后进运算符高于栈顶元素 */  
                push (ops, item);       /* 压入运算符栈 */      
                if ('(' == item)        /* 如果压入了一个左括号 */  
                    push (ops, '#');        /* 压入运算符栈一个结束标记来保持正确的优先级 */  
            } else {                /* 否则 */  
                push (expr, pop (ops)); /* 栈顶元素压入表达式栈 */  
                push (ops, item);       /* 后进运算符压入运算符栈 */  
            }  
        }  
    }  
    free (input_buf);  
}  
  
/* 设置变元的初始真值，全假 
 */  
void  
init_props_truth (void) {  
    ssize_t count = 0;  
      
    for (count=0; count<prop_table.len+1; ++count)   
        prop_table.data[count].v = false;  
      
    for (count=0; count<prop_table.len+1; ++count)  
        printf ("%d ", prop_table.data[count].v);  
          
    /* 立刻计算一次真值,因为其后的计算不包含全假的情况 */  
    void find_truth (void);  
    find_truth ();  
}  
  
/* 设置变元的真值，把所有变元当做一个二进制数 
 * 用二进制加法模拟真值，每次调用函数都会给二进制数加一 
 */  
void  
set_props_truth (void) {  
    bool carry = false; /* 进位标志 */  
    ssize_t count, count2;  
      
    for (count=0, carry=true; carry && (count<prop_table.len+1); ++count) {  
            if (prop_table.data[count].v) {  
                prop_table.data[count].v = (carry ? 0 : 1);  
                if (prop_table.len>0)  
                    /* 同时要处理前面的位 */  
                    for (count2=1; count2<count+1; ++count2)  
                        prop_table.data[count-count2].v = false;  
                carry = (prop_table.data[count].v ? false : true);  
            } else {      
                prop_table.data[count].v = (carry ? 1 : 0);  
                carry = false;  
            }  
    }  
      
    for (count=0; count<prop_table.len+1; ++count)  
            printf ("%d ", prop_table.data[count].v);  
    void find_truth (void);  
    find_truth ();  
}  
  
/* 调用函数之时默认prop_table 已经设置了一组有效的真值 
 * 函数计算在这组真值下整个后缀表达式的真值 
 */  
void  
find_truth (void) {  
    truth_item item;  
    ssize_t count, count2;  
    data_t data, num1, num2, ans;  
      
    /* 首先把truth_expr 中的变元全部换成真值 */  
    truth_expr = expr;  
    for (count=0; count<truth_expr.len+1; ++count) {  
        data =  truth_expr.data[count];  
          
        if (!is_op (data)) {  
            for (count2=0; count2<prop_table.len+1; ++count2)  
                if (data == prop_table.data[count2].p) {  
                    truth_expr.data[count] = prop_table.data[count2].v;  
                    break;  
                }  
        }  
    }  
      
    /* 后缀表达式求值 */  
    for (count=0; count<truth_expr.len+1; ++count) {  
        data =  truth_expr.data[count];  
          
        if (!is_op (data))      /* 非运算符 */  
            push (truth, data);  
        else {                  /* 是运算符 */  
            num1 = pop (truth);  
            num2 = pop (truth);  
            ans = do_op (data, num1, num2);  
            push (truth, ans);  
        }  
    }     
      
    /* 储存真值 */  
    item = pop (truth);  
    push (truth_table, item);  
      
    /* 顺便打印真值 */  
    printf ("\t%d\n", truth_table.data[truth_table.len]);  
}  
  
/* 打印主范式 
 */  
void      
print_main_paradigm (enum paradigm type) {  
    ssize_t count;  
    bool has_find;  
      
    if ((EXTRACT!=type) && (CONJUNCT!=type))  
        exit (0);  
      
    printf ("主%s范式为 : ", (EXTRACT==type) ? "析取" : "合取");  
    for (count=0, has_find=false; count<truth_table.len+1; ++count) {  
        if ((EXTRACT==type)   
            ? truth_table.data[count]  
            : !truth_table.data[count]) {  
            has_find = true;  
            printf ("%c%d %s ", (EXTRACT==type) ? 'm' : 'M',   
                                count,  
                                (EXTRACT==type) ? "∨" : "∧");  
        }  
    }  
    if (has_find)  
        printf ("\b\b  \n");  
    else   
        printf ("为空");  
}  
  
/* MAIN  
 */  
int  
main (int argc, char *argv[]) {  
    ssize_t count;  
      
    start ();  
      
    while (true) {  
        get_input ();  
        make_postfix_expr ();  
          
        for (count=0; count<prop_table.len+1; ++count) {  
            printf ("%c ", prop_table.data[count].p);  
        }  
        printf ("\t真值\n\n");  
          
        init_props_truth ();  
          
        while (!set_truth_end ())  
            set_props_truth ();  
          
        print_main_paradigm (EXTRACT);  /* 主析取范式 */  
        print_main_paradigm (CONJUNCT); /* 主合取范式 */  
    }  
      
    return 0;  
}


 


@struggle@
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2018/9/27 离散大作业 根据输入命题输出真值表及主析取（合取）范式
oidoidoid的博客
09-27 4098
zl老师布置的作业，网上代码都好长，自己写一个才200行 自己写就是很开心，抄代码有什么意思呢 /* 符号注记： + * - -&gt; &lt;-&gt; T F 合取 析取 非 单条件 双条件 true false 运用的方法： 1.将中缀表达式转换为后缀表达式便于计算 2.DFS二进制枚举每个状态并用后缀...
离散数学实验 C语言编程
12-06
1. 从键盘输入两个命题变元P和Q的真值，求它们的合取、析取、条件和双条件的真值。（A） 2. 求任意一个命题公式的真值表（B，并根据真值表求主范式（C））
离散数学实验三则（关系元算，集合运算与操作，最短路）
m0_61126523的博客
05-06 2313
前言 前段时间才做了离散实验的实验报告，为防止在本地遗失，所以上传到CSDN上一份，欢迎大家一起学习 实验1 关系元算 实验报告内容 一、实验目的 熟悉掌握命题逻辑中的联结词、真值表、主范式等，进一步能用他们来解决实际问题。 二、实验内容 1、从键盘输入两个命题变元P和Q的真值，求它们的合取、析取、条件和双条件的真值。（A） 2、求任意一个命题公式的真值表（B，并根据真值表求主范式（C）） 三、实验环境 C或C++语言编程环境实现。 DEVC++ 5.4.0 MinGW GCC 4.7
求命题公式的真值表及主范式（栈实现）
终成大师的博客
04-19 4313
设计思路 首先用一个串来储存使用者所输入的命题表达式，依据人类的思维，会对输入的命题公式进行分析和计算，但计算机可不会，这时我们就要写入相关代码把使用者输入的命题表达式转换为计算机所能进行计算的后缀表达式，我们用计算机进行对数字相关运算时也是这个原理！首先用一个字符串来储存遍历命题表达式所遇到的命题变元，之后遇到操作符时就利用开发者根据C++运算符优先级自定义的操作符优先级函数对操作符的优先级比较...
[离散] 打印任意命题公示的真值表和主范式
dawuafang
09-23 736
课本是高等教育出版社出版的《离散数学及其应用》。 程序会自动分析输入的表达式，并且列出真值表，最后打印出主析取范式和主合取范式，最多支持256 个变元。 主要用到的算法：中缀表达式转后缀表达式、后缀表达式求值还有一个二进制加法模拟。 下面上2 个图，第一个是表达式开头没有非运算的（课本P85 例3.5.5）： 第二个不但表达式开头有非运算，而且非运算之后并不是一个数值，而是一个...
shuliluoji.rar_主范式_合取范式_命题公式_真值表
09-24
在“shuliluoji.rar”软件中，用户可以输入任意命题公式，软件不仅能够生成真值表，还能进一步提供主范式和合取范式的转换结果。这种交互式的教学方式使得学习数理逻辑变得更加生动有趣，有助于提高学生理解和应用...
离散数学实验一：利用真值表法求取主析取范式以及主合取范式的实现.doc
10-29
在离散数学中，真值表、主析取范式（Minterm）和主合取范式（Maxterm）是布尔代数和逻辑运算的重要概念，它们用于表示和简化复杂的布尔表达式。 真值表是将布尔变量的所有可能组合及其对应的布尔表达式结果列出的...
必做题—命题公式真值表输出选做题—函数曲线的离散化 提高题(选做)—用离散的点显示自己的姓名（评分：优秀）
09-14
已知命题公式A=﹁( p q ) ( (p r) s)，用JAVA或C/C++语言编写程序构造该命题公式的真值表，真值表输出样式自己设计(变量值可以不手工输入)，编制程序、画流程图、解释核心程序段、展示结果、心得描述等，撰写并提交...
真值表 2 源.cpp
12-02
利用真值表法求取主析取范式以及主合取范式的实现 定义符号优先级以及栈的相关函数，输入公式，公式进栈，转换成后缀表达式，存储在数组中，再次进栈，通过对命题变元赋值，求出对应的真值，打印对应的组合项。定义...
求给定命题公式的真值表并根据真值表求公式的主范式.pdf
11-18
"离散数学实验报告：求给定命题公式的真值表并根据真值表求公式的主范式" 本实验报告的目的是通过编写程序来求给定命题公式的真值表，并根据真值表求公式的主范式。实验环境使用 Visual C++ 6.0，编程语言为 C 语言...
输出多个命题公式的合取式真值表
02-28
给出任意变元的合式公式，构造该合式公式的真值表
命题公式真值表 的生成算法
05-06
真值表 是命题逻辑理论 中的一个重要 概念 , 利用它可 以求命 题公式 的主 范式 、 定命 题公式 的类型以及 进行 判命题 逻辑的推理等 。本文给 出了 意命题 公式真值 表的生成 算法 , 用计算机 解决命题 逻辑 中的其它 问题奠定 了基础 。
输出命题公式真值表
子生的博客
03-04 8320
描述 先输入一个正整数 n（n 小于等于 10），表示共有 n 个命题变元，再输入一个类 似于逆波兰表达式的字符串表示一个命题公式，约定在该字符串中用一位的十进 制数表示一个命题变元，用 a、o、n、i、e 分别表示且、或、非、蕴含、等值， 用类似于逆波兰表达式形式的字符串表示的命题公式的真值表波兰表达式（即二 元运算，两个操作数在前，运算符在后；一元运算，一个操作数在前，运算符在 后）。 输入 ...
c++实现真值表
横济沧海的博客
03-30 8466
后缀表达式求值点击打开链接 图解后缀表达式的计算过程 点击打开链接 #include #include #include #include #include using namespace std; int  table2[4][2]= {{0,0},{0,1},{1,0},{1,1}}; int  table3[8][3]= {{0,0,0},{0,
求命题公式的主范式
weixin_38199770的博客
01-09 2924
成绩 100 开启时间 2017年04月6日 星期四 08:00 折扣 0.8 折扣时间 2017年05月5日 星期五 08:00 允许迟交 否 关闭时间 2017年05月18日 星期四 23:55 实现功能：输入命题公式的合式公式，求出公式的真值表，并输出该公式的主合取范式和主析取范式
真值表的遍历(C语言版)
qq_36655919的博客
12-07 1988
真值表的遍历(C语言版)做作业的时候遇到需要遍历真值表以判断是否有值为真(T)的情况.基本思路： 将真值表的每一行看作一个二进制数，逐行分别为上一行加一. 代码如下：代码块语法遵循标准markdown代码，例如：//初始化所有位置0 for(int i = 0;i < len;i++) { assignations[i] = false; } //如果第一位不为1，则
南邮离散数学实验 利用真值表法求取主析取范式以及主合取范式的实现
热门推荐
Coding
01-23 2万+
一、    实验目的和要求 内容： 编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。 要求： 能够列出任意合式公式的真值表并给出相应主析取和主合取范式。 内容： 编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。 原理： 先将中缀表达式转换成后缀表达式，再将后缀表达式中每一个字母变量一一赋值，用递归枚举的方法枚举所有赋值情况，并
c语言离散数学命题公式实验程序输出真值表和主析取主合取范式
最新发布
11-18
首先，我们需要使用c语言来输入离散数学的命题公式，并且利用逻辑运算符来构建真值表的计算。 在程序中，我们可以使用循环语句和条件语句来计算命题公式在不同真值情况下的结果。然后，我们可以将计算得出的真值表...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值