精华内容
下载资源
问答
  • 用C语言实现离散数学中的任意合式公式的真值表
  • 真值表

    千次阅读 多人点赞 2019-06-20 06:44:18
    文章目录真值表实验目的实验内容实验步骤实验源码实验结果示例 真值表 实验目的 熟悉五个真值表,掌握真值表技术。 实验内容 定义1 设命题变元P1、P2、P3、…、Pn是出现在公式G中的所有命题变元,指定P1、P2、P3、...

    真值表

    实验目的

     熟悉五个真值表,掌握真值表技术。
    

    实验内容

    定义1 设命题变元P1、P2、P3、…、Pn是出现在公式G中的所有命题变元,指定P1、P2、P3、…、Pn 的一组真值,则这组真值称为G的一个解释或指派,常记为I。
    定义2 真值表:公式G在其所有可能的解释下所取真值的表。 
    本实验要求从键盘输入一个命题公式列出其真值表。用C语言或MATLAB实现。
    

    实验步骤

    1. 采用C++编写代码,使用VC++6.0创建C++工程。
    2. 定义全局变量a、b,通过改变a、b的值来确定命题变元的所有指派的组合。
    3. 定义递归函数化简命题公式至只剩下两个命题变元和一个联结词或只有一个命题变元,判断其真值并返回。
    4. 主函数:从键盘输入命题公式,不断改变a、b的值为T或F来确定所有的真值指派并在每种情况下分别调用递归函数求解命题公式的真值,打印真值表。

    实验源码

    #include<iostream>
    #include<string>
    using namespace std;
    char a,b;
    char split(char* s);
    int main()
    {
     char s[10];
     cout<<"使用说明:"<<endl;
     cout<<"1.仅支持含有两个变元的复合命题(分别用a、b表示)"<<endl;
     cout<<"2.合取&、析取|、单条件*、双条件+、不支持否定"<<endl;
     cout<<"输入复合命题时将联结词两端的子公式用()括起来,如:a&(b|(a*(b+a))"<<endl; 
     cout<<endl;
     cout<<"请输入命题公式:";
     cin>>s;
     cout<<"真值表:"<<endl;
     cout<<"a\tb\t"<<s<<endl;
     a='T';b='T';
     cout<<"T\tT\t"<<split(s)<<endl;
     a='T';b='F';
     cout<<"T\tF\t"<<split(s)<<endl;
     a='F';b='T';
     cout<<"F\tT\t"<<split(s)<<endl;
     a='F';b='F';
     cout<<"F\tF\t"<<split(s)<<endl;
     return 0;
    }
    char split(char*s)
    {
     if(s[1]==0)
      switch(s[0])
      {
       case 'a':return a;
       case 'b':return b;
      } 
     int i=0;
     char l,r;
     if(s[0]!='(')
     {
      switch(s[0])
      {
       case 'a':l=a;
        break;
       case 'b':l=b;
        break;
      }
      i++;
     }
     else
     {
      i++;
      char s1[10];
      for(int j=0;s[i]!=')';j++,i++)
       s1[j]=s[i];
      l=split(s1);
      cout<<l;
     }
     char t[10];
     int j,k;
     for(j=0,k=i+1;s[k]!=0;k++)
      if(s[k]!='('&&s[k]!=')')
       t[j++]=s[k];
     t[j]=0;
     r=split(t);
     switch(s[i])
     {
      case '&':{
       if(l=='T'&&r=='T')
        return 'T';
       else
        return 'F';
      }
      case '|':{
       if(l=='F'&&r=='F')
        return 'F';
       else
        return 'T';
      }
      case '*':{
       if(l=='T'&&r=='F')
        return 'F';
       else
        return 'T';
       }
      case '+':{
       if(l==r)
        return 'T';
       else
        return 'F';
      }
     }
    }
    

    实验结果示例

    实验结果示例

    展开全文
  • 真值表生成器

    热门讨论 2011-11-17 20:40:47
    适用于离散数学,数字逻辑等课程的辅助工具。如有疑问,请联系qq:397974087 email:winter.bmw@stu.xjtu.edu.cn
  • * 显示合适公式的真值表 * 提供将一个中缀合适公式的真值表输出到某一PrintStream流中的功能 * 以单个大写字母表示变量(支持26个变量) * 以字符0或者1表示值 * 以 ~ ^ & > - 分别表示 非 析取 合取 条件 双...
  • 真值表-Python实现

    千次阅读 2019-12-12 19:47:31
    文章目录实验内容程序设计代码实现 ...真值表:公式 G 在其所有可能的解释下所取真值的表 本实验要求从键盘输入一个命题公式列出其真值表。 程序设计 实现真值表难点在于: 对变元的 T(True) F(False) 的枚...

    实验内容

    1. 设命题变元 P1、P2、P3、…、Pn 是出现在公式 G 中的所有命题变元,指定 P1、 P2、P3、…、Pn的一组真值,则这组真值称为 G 的一个解释或指派,常记为I
    2. 真值表:公式 G 在其所有可能的解释下所取真值的表

    本实验要求从键盘输入一个命题公式列出其真值表。

    程序设计

    实现真值表难点在于:

    1. 对变元的 T(True) F(False) 的枚举,相当于未知阶的嵌套循环,对此应用递归解决
      对此首先找到递归结束的标志,即把所有变元的TF都枚举出来
    2. 找到命题包含的变元很简单,只需要构造一个集合,或者使用列表
    3. 对于中缀表达式转换后缀表达式,请参考后缀表达式

    代码实现

    operators = ['!','&', '|', '*', '+'] # 按照优先级从高到低的顺序
    
    def postfix(elements):
        global operators
        stack = list()
        output = list()
        for ele in elements:
            if ele not in operators and ele not in ('(',')'): #
                output.append(ele)
            # '(' 在运算符中优先级最小,其唯一出栈条件时遇到右括号
            elif ele == '(':
                stack.append(ele)
            # 若是 ) ,则出栈直到遇到 ( ,这里注意: ) 遇到的第一个 ( 一定是匹配的一对
            elif ele == ')':
                val = stack.pop()
                while val !='(':
                    output.append(val)
                    if stack:
                        val = stack.pop()
                    else:
                        break
            elif ele in ('&', '|', '*', '+', '!'): # 遇到运算符,比较优先级
                if len(stack) == 0:
                    stack.append(ele)
                    continue
                # 比较该运算符与栈顶运算符的优先级,遇到比该运算符优先级大于或等于的则将其弹出,最后将该运算符压栈
                while (ele == '!' and stack[-1] =='!') or \
                        (ele == '&' and stack[-1] in ('!', '&')) or \
                        (ele == '|' and stack[-1] in ('!', '&', '|')) or \
                        (ele == '*' and stack[-1] in ('!', '&', '|', '*')) or \
                        (ele == '+' and stack[-1] in ('!', '&', '|', '*', '+')):
                    val = stack.pop()
                    output.append(val)
                    if not stack:
                        break
                stack.append(ele)
        while stack: # 当表达式完全处理完之后,把栈中的运算符一一出栈,FILO,转化成后缀表表达式
            output.append(stack.pop())
        return ''.join(output)
    
    def logicalOp(tmp):
        idx = 0  # 当前命题元素的位置
        while len(tmp) > 1:  # 当最后命题仅为真值后,退出循环
            if tmp[idx] in operators:
                if tmp[idx] == '!':  # 非
                    # 这里把命题变元进行转换,根据后缀表达式,一定满足idx的前1位或前2位是真值而不是运算符
                    tmp[idx - 1] = 1 if int(tmp[idx - 1]) == 0 else 0
                    tmp[idx:idx + 1] = []  # 子命题结果对原命题覆盖
                    # 每次从头开始对命题处理
                    idx = 0
                    continue
                elif tmp[idx] == '&':  # 合取
                    tmp[idx] = 1 if int(tmp[idx - 1]) == 1 and int(tmp[idx - 2]) == 1 else 0
                    tmp[idx - 2:idx] = []
                    idx = 0
                    continue
                elif tmp[idx] == '|':  # 析取
                    tmp[idx] = 0 if int(tmp[idx - 1]) == 0 and int(tmp[idx - 2]) == 0 else 1
                    tmp[idx - 2:idx] = []
                    idx = 0
                    continue
                elif tmp[idx] == '*':  # 则
                    tmp[idx] = 0 if int(tmp[idx - 2]) == 1 and int(tmp[idx - 1]) == 0 else 1
                    tmp[idx - 2:idx] = []
                    idx = 0
                    continue
                elif tmp[idx] == '+':  # 当且仅当
                    tmp[idx] = 1 if int(tmp[idx - 2]) == int(tmp[idx - 1]) else 0
                    tmp[idx - 2:idx] = []
                    idx = 0
                    continue
            idx += 1
        print(tmp[0])
    
    def e(idx):
        global expr
        if idx == len(enum): # 递归终止条件为枚举完全部的变元
            print('\t'.join(list(enum.values())),end='\t') # 打印出枚举情况
            tmp = ' '.join(expr) # tmp为对命题处理带入真值的中间量
            for ele in expr:
                if ele in enum:
                    tmp = tmp.replace(ele, enum[ele])
            tmp = tmp.split(' ') # 转化成list,由于字符串内部不能修改
            logicalOp(tmp)
            return
        enum[var[idx]] = '0' # 枚举False,最后在转换为int类型,使得可使用字符串替换,把0,1代入
        e(idx+1) # 接着对下一位变元枚举
        enum[var[idx]] = '1' # 枚举True
        e(idx+1)
    
    if __name__=='__main__':
        """
        Attention :
        定义:
        !:非 (单命题变元)
        &:合取
        |:析取
        *:单条件(则)
        +:双条件(当且仅当)
        """
        print('please input the problem\tExample:  (p*q)&!r  p&q|r*q&!s|r')
        inp = input('>>>')
        expr = postfix(inp)  # expr为生成的后缀表达式
        var = list()  # var为命题变元
        for item in expr:
            # 找出变元且不能重复
            if item not in operators and \
                    item not in var and \
                    item not in ('(', ')'):
                var.append(item)
        # 对变元枚举TF字典
        enum = {}.fromkeys(var)
        # 打印表头
        print('\t'.join(var),end='\t')
        print(inp)
        # 从第一个变元枚举
        e(0)
    Attention :
    定义:
    !:非 (单命题变元)
    &:合取
    |:析取
    *:单条件(则)
    +:双条件(当且仅当)
    
    please input the problem	Example:  (p*q)&!r  p&q|r*q&!s|r
    >>>p&q|r*q&!s|r
    p	q	r	s	p&q|r*q&!s|r
    0	0	0	0	1
    0	0	0	1	1
    0	0	1	0	1
    0	0	1	1	1
    0	1	0	0	1
    0	1	0	1	1
    0	1	1	0	1
    0	1	1	1	1
    1	0	0	0	1
    1	0	0	1	1
    1	0	1	0	1
    1	0	1	1	1
    1	1	0	0	1
    1	1	0	1	0
    1	1	1	0	1
    1	1	1	1	1
    
    展开全文
  • 使用python输出真值表

    千次阅读 2019-12-14 15:38:22
    使用一个递归函数输出真值表,用于对每个对象赋值并打印真值表 此处关于递归的算法,我借鉴了大佬的代码,在此声明 https://blog.csdn.net/Kprogram/article/details/83686154 def give_value(i): global ...

    首先创建一个类,利用python自身的优势对表达式进行解析

    # &为合取,v为析取,~为非,>为条件联结词,*为双条件联结词
    class Variable:
        def __init__(self, value=0):
            self.value = value
        # 返回两个对象的合取
        def __and__(self, other):# 对 & 运算符的定义
            return Variable(1) if (self.value==1 and other.value==1) else Variable(0)
        def __or__(self, other):# 对 | 运算符的定义
            return Variable(0) if self.value==other.value==0 else Variable(1)
        # 对象的条件连接
        def __gt__(self, other):# 对 > 运算符的定义
            return Variable(0) if (self.value==1 and other.value==0) else Variable(1)
        # 对象的取反
        def __invert__(self):# 对 ~ 运算符的定义
            return Variable(1) if self.value==0 else Variable(0)
        # 对象的双条件连接
        def __mul__(self, other):# 对 * 运算符的定义
            return Variable(1) if self.value==other.value else Variable(0)
        def __str__(self):# 对打印显示的重载
            return str(self.value)

    然后我们输入一个字符串

    formula = input("输入你的公式:")
    # 所有的变量字符组成的列表,使用集合去掉了重复的变量字符
    var_chars = list(set(formula).difference(set("()&|>*~")))
    variables = []# 用来存储所有的Variable对象
    for v in var_chars:
        # 对于每一个解析得到的变量字符为变量名生成一个Variable对象
        exec(v+'=Variable(0)')
        variables.append(eval(v))# 添加到上面的列表中

    使用一个递归函数输出真值表,用于对每个对象赋值并打印真值表

    此处关于递归的算法,我借鉴了大佬的代码,在此声明https://blog.csdn.net/Kprogram/article/details/83686154

    def give_value(i):
        global formula
        if i == len(variables):
            for v in variables:
                print(v.value, end="  ")
            print(eval(formula))
            return
        variables[i].value = 0# 先赋值为0
        give_value(i+1)# 递归调用自己
        variables[i].value = 1# 后赋值为1
        give_value(i+1)# 递归调用自己

    先输出真值表的第一行

    for v in variables:
        print(v, end="  ")
    print(formula)

    显示真值表里面的内容

    give_value(0)

    效果截图

    有很多小伙伴的离散数学可能会需要做实验,一般要求是使用c语言或者是matlab,而我们的老师说python也是可以接受的,但是不能使用人家已经写好的模块,而对输入的公式(一个字符串)进行解析又是一件十分复杂的事情,还需要对括号进行匹配等,我个人不喜欢那么复杂,所以我用了eval()函数,直接把字符串两端的引号给去掉,从而执行里面的内容,所以我的代码:

    首先解析输入的字符串,使用集合工具去掉相同的变量,再转换成列表;

    根据列表里面的字符使用exec()函数直接生成对应的变量,从而每个变量的内容就是字符本身;

    把得到的每一个Variable对象都添加到一个列表中便于管理;

    使用递归对列表里面的每一个对象的value属性进行赋值,同时输出真值表。

     

    展开全文
  • python - 根据表达式打印真值表

    千次阅读 多人点赞 2018-11-03 20:31:34
    输入逻辑表达式,输出真值表,支持六个基本逻辑运算 最终效果:  输入合适公式(没有考虑优先级,只根据括号优先),输出时会提取其中的元素(比如这里有A B C),并打印真值表。  算法思路:  求值的一般...

      输入逻辑表达式,输出真值表,支持六个基本逻辑运算

    最终效果

        输入合适公式(没有考虑优先级,只根据括号优先),输出时会提取其中的元素(比如这里有A B C),并打印真值表

     算法思路

        求值的一般顺序是:带入每个元素的值,求出式子的真值,所以可以分为两块:1.枚举元素值(枚举) 2.根据元素值求式子值(计算

        我认为这个的难点在于枚举,我们既要想办法提取出每一个元素,又要为其赋值(0和1)

        我们先约定好六个运算符

    '''
    否.......... !(非)
    合取........ &(与)
    可兼或...... |(或)
    不可兼或.... #
    由...可得... >
    当且仅当.... =
    '''

        并封装好这个真值表打印器 

    class FindTruth:
        '''构造函数'''
        def __init__(self):
    
        '''输入'''
        def __In(self):
    
        '''枚举'''
        def __Count(self, i):
    
        '''计算公式结果'''
        def __Sum(self, Str):
    
        '''配对左右括号'''
        def __Pei(self, cur, Str):
       
        '''运算操作符'''
        def __Add(self, w, a, b = -1):
    
        '''输出'''
        def __Out(self):
    

        一,首先处理枚举:

        对于提取元素:涉及到字符串的处理以及查重,python提供了便捷的set集合来处理

        对于赋值:比如式子A|B|C,提取出ABC后,一共有从000 到 111,2^3种情况,而N个元素就有2^N种情况,显然是不能用简单的循环是实现的,这里可以用递归来处理

            a.利用set提取元素  

                set(字符串)能把字符串里每个字符提取出来,构成一个集合,而集合是不存在相同字符的,所以这里完成了筛选重复字符的工作。

                如set('A|B&C') = {'A', 'B', 'C', '|', '&'}

                seta.difference(setb)能让seta留下于setb集合中不同的元素。

                所以第二句生成了一个筛选掉运算符的元素集合,完成了元素的提取

    def __In(self):
        #得到表达式Str
        self.Str = input("input your expression: \n")
        #筛出字母集合
        self.Set = set(self.Str).difference(set("()!&|>=#"))

            b.利用递归枚举赋值

                如何递归呢,这里假如有三个元素A,B,C

                递归函数有一个参数 i ,用来指定此次因该枚举哪一个元素的值,比如 i = 0, 则枚举A的值。

                首先初始化一个字典用来存储元素的值:self.dict = {'A':0, 'B':0, 'C': 0}

                第一次:{'A':0, 'B':0, 'C': 0},i = 1,所以先分别给A赋值0和赋值1,并把 i 加一,再调用枚举函数(也就是递归调用自己)。因为要调用自己两次,这里就产生了1*2 = 2个分支:

                    分支1:{'A':0, 'B':0, 'C': 0},i = 1

                    分支2:{'A':1, 'B':0, 'C': 0},i = 1

                第二次,i = 1,分别给B赋值0和1,在第一次的两个分支的基础上产生了2*2 = 4个分支

                    分支1:{'A':0, 'B':0, 'C': 0},i = 1 

                        分支11:{'A':0, 'B':0, 'C': 0},i = 2

                        分支12:{'A':0, 'B':1, 'C': 0},i = 2

                    分支2:{'A':1, 'B':0, 'C': 0},i = 1

                        分支21:{'A':1, 'B':0, 'C': 0},i = 2

                        分支22:{'A':1, 'B':1, 'C': 0},i = 2

                第三次,同理,给C赋值的时候,会产生总共4*2 = 8个分支,这时候递归枚举也结束了,我们也得到了八个枚举的结果 

    A B C
    0 0 0 
    0 0 1
    0 1 0
    0 1 1
    1 0 0
    1 0 1
    1 1 0
    1 1 1

            实现代码:

    def __Count(self, i):
        '''结束条件:若最后一个元素也完成了枚举,则 打印 + 运算 '''
        if i == len(self.Lis):
            S = ''
            for l in self.Lis:
                S = S + str(self.Dic[l]) + ' '
            print(S,self.__Sum(self.Str))#调用self__Sum()函数进行运算
            return
        '''不是结尾,则赋值并调用自己,产生两个分支'''
        self.Dic[self.Lis[i]] = 0
        self.__Count(i+1)
        self.Dic[self.Lis[i]] = 1
        self.__Count(i+1)

        二,再来处理计算 __Sum(self, Str)

        计算的思路很简单,我们分别设置三个值:

            s :用来存储当前的终值,初始值设置为-1

            s0 :用来存储当前式子或元素的值

            operater :用来存储目前的操作符 

        然后一个字符一个字符地循环遍历表达式:

           例:str = 'A | (A & B) & C'   调用 __sum(self, str):

            循环1:字符 = 'A",则s = A的值

            循环2:字符 = '|',则operater = '|'

            循环3:字符 = '(',则s0 = __sum(self, ’括号内的那坨表达式‘),(这样便可利用递归简单地完成括号的处理)

                         s = (s operator s0),s0 = -1(更新s的值)

            .......

            到最后一个字符结束后,式子的值已经存储于s中了。

            实现代码:

    #求公式结果
    def __Sum(self, Str):
        i = 0 #字符位置
        s = -1#式子真值
        while i < len(Str):
            c = Str[i]
        #单操作符'!'要做特殊的分类处理
            if c == "!":
            #右边是字母
                if Str[i+1] in self.Set:
                    c = Str[i+1]
                    i = i + 1
                    s0 = self.__Add('!',self.Dic[c])   
            #右边是左括号
                else:
                    end = self.__Pei(i+1, Str)
                    s0 = self.__Add('!', self.__Sum(Str[i+1:end+1]))
                    i = end
        #字母
            elif c in self.Set:
                s0 = self.Dic[c]
        #其它运算符
            elif c in set("&|>=#"):
                operat = c
        #左括号
            elif c == '(':
                end = self.__Pei(i, Str)
                s0 = self.__Sum(Str[i+1:end])
                i = end
        #运算结果
            if s == -1:
                s = s0
                s0 = -1
            elif operat != 0 and s0 != -1:
                s1 = s
                s = self.__Add(operat, s, s0)
                operat = 0
                s0 = -1
            i = i + 1
        return s
    #配对左右括号
    def __Pei(self, cur, Str):
        kflag = 1  # 左括号的数目
        while not kflag == 0:
            cur = cur + 1
            if Str[cur] == '(':
                kflag = kflag + 1
            elif Str[cur] == ')':
                kflag = kflag - 1
        return cur    
    #运算操作
    def __Add(self, operator, a, b = -1):#b默认为-1时,表示是单操作符号' ! '
        if operator == '!':
            boo = not a
        elif operator == '&':
            boo = a and b
        elif operator == '|':
            boo = a or b
        elif operator == '#':
            boo = ((not a) or (not b)) and (a or b)
        elif operator == '>':
            boo = (not a) or b
        elif operator == '=':
            boo = ((not a) and (not b)) or (a and b)
        else:
            print("there is no such operator")
        if boo:
            return 1
        else:
            return 0

    完整代码: 

    # -*- coding: utf-8 -*-
    '''
    否.......... !
    合取........ &
    可兼或...... |
    不可兼或.... #
    由...可得... >
    当且仅当.... =
    '''
    class FindTruth:
        def __init__(self):
            #存储字母及其真值
            self.Dic = {}
            self.Lis = []
            #输入表达式
            self.__In()
            #输出真值表
            self.__Out()
        #输入
        def __In(self):
            #得到表达式Str
            self.Str = input("input your expression: \n")
            #筛出字母集合
            self.Set = set(self.Str).difference(set("()!&|>=#"))
        #求公式结果
        def __Sum(self, Str):
            i = 0 #字符位置
            s = -1#式子真值
            while i < len(Str):
                c = Str[i]
            #单操作符'!'要做特殊的分类处理
                if c == "!":
                #右边是字母
                    if Str[i+1] in self.Set:
                        c = Str[i+1]
                        i = i + 1
                        s0 = self.__Add('!',self.Dic[c])   
                #右边是左括号
                    else:
                        end = self.__Pei(i+1, Str)
                        s0 = self.__Add('!', self.__Sum(Str[i+1:end+1]))
                        i = end
            #字母
                elif c in self.Set:
                    s0 = self.Dic[c]
            #其它运算符
                elif c in set("&|>=#"):
                    operat = c
            #左括号
                elif c == '(':
                    end = self.__Pei(i, Str)
                    s0 = self.__Sum(Str[i+1:end])
                    i = end
            #运算结果
                if s == -1:
                    s = s0
                    s0 = -1
                elif operat != 0 and s0 != -1:
                    s1 = s
                    s = self.__Add(operat, s, s0)
                    operat = 0
                    s0 = -1
                i = i + 1
            return s
        #配对左右括号
        def __Pei(self, cur, Str):
            kflag = 1  # 左括号的数目
            while not kflag == 0:
                cur = cur + 1
                if Str[cur] == '(':
                    kflag = kflag + 1
                elif Str[cur] == ')':
                    kflag = kflag - 1
            return cur    
        #运算操作
        def __Add(self, operator, a, b = -1):#b默认为-1时,表示是单操作符号' ! '
            if operator == '!':
                boo = not a
            elif operator == '&':
                boo = a and b
            elif operator == '|':
                boo = a or b
            elif operator == '#':
                boo = ((not a) or (not b)) and (a or b)
            elif operator == '>':
                boo = (not a) or b
            elif operator == '=':
                boo = ((not a) and (not b)) or (a and b)
            else:
                print("there is no such operator")
            if boo:
                return 1
            else:
                return 0
        #输出
        def __Out(self):
            #将字母放入dict和List
            S = ''
            for c in self.Set:
                self.Dic[c] = 0
                self.Lis.append(c)
                S = S + c + ' '
            print(S, self.Str)
            self.__Count(0)
        #构造2^n的序列
        def __Count(self, i):
            #是结尾,打印 + 运算
            if i == len(self.Lis):
                S = ''
                for l in self.Lis:
                    S = S + str(self.Dic[l]) + ' '
                print(S,self.__Sum(self.Str))
                return
            #不是结尾,递归赋值
            self.Dic[self.Lis[i]] = 0
            self.__Count(i+1)
            self.Dic[self.Lis[i]] = 1
            self.__Count(i+1)
    
    if __name__ == '__main__':
        F = FindTruth()
    

     

    展开全文
  • python实现真值表

    千次阅读 2018-10-13 12:57:27
    python实现真值表 import copy def boo(x,leng,listboo,array): #递归实现布尔真值全排列 if x==leng: for i in range (0,leng): array.append(listboo[i]) ...
  • C语言 命题公式真值表

    千次阅读 2020-11-21 00:49:36
    掌握命题公式真值表的求解,并实现自动求解程序。 2.实验内容 输入:任意命题公式 输出:该命题公式的真值表 要求: 输入任意命题公式,要求用数据存储命题公式的所有赋值及对应真值,并输出该公式真值表 此题...
  • 采用逻辑门和MSI模块来进行组合逻辑电路的设计,需要我们根据实验的需求和电路的功能要求,明确输出量与输入量之间的关系,即得到一张真值表(或者是功能表)。根据这张真值表,我们还需要将其转化成逻辑函数,即用...
  • 离散数学编程实现真值表输出

    万次阅读 2018-09-27 23:44:26
    根据给出的命题数n与对应的真值写出真值表 #include &lt;iostream&gt; #include &lt;math.h&gt; using namespace std; void shuru(char *p,int s);//输入T or F void shuchu(char *p,int s);//...
  • 离散数学实验二 真值表

    千次阅读 2020-06-13 22:08:46
    熟悉五个真值表,掌握真值表技术。 二、实验内容 定义1 设命题变元P1、P2、P3、…、Pn是出现在公式G中的所有命题变元,指定P1、P2、P3、…、Pn 的一组真值,则这组真值称为G的一个解释或指派,常记为I。 定义2 真值...
  • 根据真值表绘制电路

    千次阅读 2020-12-07 23:53:18
    本关任务:根据如下给定的真值表绘制逻辑电路,其中A、B、C是输入变量,F是输出变量。 A B C F 0 0 0 1 0 0 1 0 0 1 0 0 0 1 1 0 1 0 0 0 1 0 1 0 1 1 0 0 1 1 1 1
  • c++实现真值表

    千次阅读 2017-03-30 17:21:14
    后缀表达式求点击打开链接 图解后缀表达式的计算过程 点击打开链接 #include #include #include #include #include using namespace std; int table2[4][2]= {{0,0},{0,1},{1,0},{1,1}}; int table3[8][3]...
  • 简化真值表(根据表绘制电路)

    千次阅读 2021-03-26 23:09:55
    文章目录前言一、根据简化真值表绘制电路二、做法1.相关概念2.步骤总结 前言 关于电子技术基础(数字部分)的edu个人学习记录 一、根据简化真值表绘制电路 任务描述 本关任务:根据如下简化真值表,写出Gt的表达式...
  • 实验一 命题逻辑:求给定命题公式的真值表 实验原理:[可忽略] 将命题公式A在所有赋值下取值情况列成表,称作A的真值表。 构造真值表的具体步骤如下: (1) 找出公式中所含的全体命题变项p1,p2,…,pn (若无下角标就...
  • 七种常见的逻辑门真值表

    万次阅读 多人点赞 2020-05-04 13:44:51
    (verilog学习笔记一之常见的逻辑门真值表) 1、 与门:所有输入为高时,才会有输出高。逻辑函数表示为F=A*B。 输入A 输入B 输出Y 0 0 0 0 1 0 1 0 0 1 1 1 2、 或门:所有输入为低时,才会有输出低...
  • 离散数学程序实现——真值表——c

    千次阅读 2020-06-06 11:58:06
    //1.4 写一个程序,包含三个变量和两个逻辑连接词生成真值表. #include<stdio.h> //逻辑联结词的计算 int f( int a,int b,int connection ) { switch( connection ) { //合取 case 0: return a*b;...
  • 一:最简D触发器D为信号 输入端,clk为时钟控制...D触发器的真值表二:带复位端的D触发器在D触发器的实际使用过程中,有时候需要一个复位端(也称清零端)电路上电时,电路的逻辑处于不定状态,复位脉冲的到来将电路...
  • 74LS138真值表以及快速计算方法 掌握了74LS138译码器的快速计算的方法,就能够在使用74LS138译码器的时候,不用老是去查阅译码器的真值表的对应关系。 74LS138译码器真值表 快速计算方法 将输入端的A B C看作成3...
  • 根据简化真值表绘制电路

    千次阅读 2020-12-07 23:54:08
    本关任务:根据如下简化真值表,写出Gt的表达式并绘制电路。 X1 X0 Y1 Y0 Gt 1 d 0 d 1 1 1 1 0 1 0 1 0 0 1
  • 离散数学真值表(c语言编程实现)

    万次阅读 多人点赞 2018-10-14 13:08:21
    代码如下: 废话不多说: 主要利用二进制的转化实现  #include &lt;iostream&gt; #include &lt;math.h&gt; using namespace std; void shuru(char *p,int s); void shuchu(char *p,int s);...v...
  • 输出命题公式真值表

    千次阅读 2019-03-04 15:17:08
    描述 先输入一个正整数 n(n 小于等于 10),...用类似于逆波兰表达式形式的字符串表示的命题公式的真值表波兰表达式(即二 元运算,两个操作数在前,运算符在后;一元运算,一个操作数在前,运算符在 后)。 输入 ...
  • 真值表求逻辑表达式的方法

    万次阅读 多人点赞 2020-02-12 08:59:59
    第一步:从真值表内找输出端为“1”的各行,把每行的输入变量写成乘积形式;遇到“0”的输入变量上加非号。 第二步:把各乘积项相加,即得逻辑函数的表达式。 第二种方法:以真值表内输出端“0”为准 第一步:从真值...
  • 全加器的真值表 全加器的代数表达 和S的推导: 由真值表可写出 S=A‾ B‾ C+A‾ B C‾+AB‾ C‾+ABC S =\overline A\ \overline B \ C+\overline A \ B \ \overline C + A \overline B \...
  • 74芯片引脚真值表汇总

    千次阅读 2019-10-17 22:57:52
    真值表
  • 题目要求如下: 定义1 设命题变元P1、...定义2 真值表:公式G在其所有可能的解释下所取真值的表。 本实验要求从键盘输入一个命题公式列出其真值表。 源代码: #define _CRT_SECURE_NO_WARNINGS #include <stdio...
  • 离散数学_C++生成真值表_模拟

    千次阅读 多人点赞 2018-04-07 17:34:59
    生成真值表的代码 输入一个真值表达式, 程序自动生成它的真值表. 纯模拟思路 合取* 析取| 单条件&gt; 双条件- 非! #include &lt;iostream&gt; #include &lt;string&gt; #...
  • 真值表以及卡诺图化简的时候可以使用,至于为什么真值表0,1的顺序是固定顺序。这就体现了格雷码的优点,每一串格雷码和上一串格雷码只有一位数字的改变。比如: 由上图可以发现,格雷码左边的数字不是最先改变,...
  • 【2018.6.2】今天在看书的时候无意中需要使用... 据说有两种方法,这里都列举一下吧: 方法一: step 1 首先,根据真值表当中结果是true的项,找出它的两个输入项,然后进行与运算;如果遇到输入项的取值是fals...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 713,889
精华内容 285,555
关键字:

真值表