南邮离散实验一（JavaScript）

最新推荐文章于 2022-07-19 11:24:51 发布
最新推荐文章于 2022-07-19 11:24:51 发布
阅读量188 收藏
点赞数
分类专栏： 实验 南邮离散实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42502919/article/details/111592283
版权

内容：编写程序实现利用真值表法求主析取和主合取范式。
要求：能够列出任意合式公式的真值表并给出响应主析取和主合取范式。
HTML部分

<!doctype html>
<html lang="en">
<!-- !否定 |主析取 &主合取 >条件 ~双条件
-->
<head>
  <meta charset="utf-8">
  <title>Page Not Found</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    * {
      line-height: 1.2;
      margin: 0;
    }

    html {
      color: #888;
      display: table;
      font-family: sans-serif;
      height: 100%;
      text-align: center;
      width: 100%;
    }

    body {
      display: table-cell;
      vertical-align: middle;
      margin: 2em auto;
    }

    .root {
      width: 100%;
      height: 100%;
    }

    .resout {
      display: flex;
      flex-direction: column;
      justify-content: center;
      align-items: center;
    }

    .ip {
      width: 50%;
      height: 50px;
      margin-top: 50px;
    }

    .OkBtn {
      margin-top: 40px;
    }

  </style>
</head>

<body>
  <div class="root">
    <div class="resout">
      <input class="ip" id="input1" placeholder="请输入公式">
      <button class="OkBtn" id="OkBtn">确定</button>
    </div>

  </div>
</body>

</html>

JavaScript部分

<script>
  let expression
  // let hasStr = []
  // let M = Map(String,Number)
  let map = new Map()
  let alpha = [] //记录所有字母
  let Atrue = [] //记录真值为T
  let Afalse = [] //记录真值为F
  let Hou = [] //后缀表达式
  var inputs = document.getElementById("input1")
  inputs.oninput = function (e) {
    expression = inputs.value
  }
  let OkBtn = document.getElementById("OkBtn")
  OkBtn.onclick = function () {
    // for (let i = 0; i < expression.length; i++) {
    //   if (expression[i] === "!" || expression[i] === "&" || expression[i] === "|" || expression[i] === ">" || expression[i] === "~") {
    //     continue
    //   }
    //   hasStr.push(expression[i])
    // }
    //中缀转后缀表达式
    alpha = []
    Atrue = []
    Afalse = []
    Hou = []
    map.clear()
    suffixExpression(expression)
  }

  //使用数组dataStore保存站内元素，构造函数将其初始化为一个空数组
  //变量top定义栈顶的位置，构造是初始化为0，表示栈的起始位置为0
  function Stack() {
    this.dataStore = []; //保存栈内元素
    this.top = 0;
    this.push = push;
    this.pop = pop;
    this.peek = peek;
    this.clear = clear;
    this.length = length;
    this.printElement = printStack
    //注意++操作符的位置，它放在this.top的后面，
    // 这样新入栈的元素就被放在top的当前位置对应的位置，
    // 同时top自加1，指向下一个位置
    function push(element) {
      this.dataStore[this.top++] = element
    }
    //返回栈顶元素，同时top位置减1
    function pop() {
      return this.dataStore[--this.top]
    }
    //peek()方法返回数组的第top-1个位置的元素，即栈顶元素
    function peek() {
      return this.dataStore[this.top-1]
    }
    //将top的值设置0，即清空一个栈
    function clear() {
      this.top = 0
    }
    //返回变量top的值即为栈内元素的个数
    function length() {
      return this.top
    }

    //输入栈内元素
    function printStack() {
      while (this.top > 0) {
        document.writeln(this.pop()+"&nbsp;&nbsp;")
      }
    }
  }

  //中缀表达式转后缀表达式
  function suffixExpression(s) {
    let str = s;
    let stack = new Stack(); //符号栈
    let outStack = new Array();
    // <!-- ！否定 |主析取 &主合取 >条件 ~双条件-->
    for (let i = 0; i < str.length; i++) {
      //遇到')'弹出符号栈中元素直到栈空或遇到'(','('只弹出不输出
      if (')' === str[i]) {
        while (true) {
          let top = stack.peek()
          stack.pop()
          if ('(' != top) {
            outStack[outStack.length] = top
          } else {
            break
          }
        }
      } else if(['(','!','|','&','~','>'].indexOf(str[i]) > -1){
        if (['~'].indexOf(str[i]) > -1) {
          if (['!','|','&','>'].indexOf(stack.peek()) > -1) {
            while (['!','|','&','>'].indexOf(stack.peek()) > -1) {
              outStack[outStack.length] = stack.peek()
              stack.pop()
            }
          }
        } else if (['>'].indexOf(str[i]) > -1) {
          if (['!','|','&'].indexOf(stack.peek()) > -1) {
            while (['!','|','&'].indexOf(stack.peek()) > -1){
              outStack[outStack.length] = stack.peek()
              stack.pop()
            }
          }
        } else if (['|'].indexOf(str[i]) > -1) {
          if (['!','&'].indexOf(stack.peek()) > -1) {
            while (['!','&'].indexOf(stack.peek()) > -1){
              outStack[outStack.length] = stack.peek()
              stack.pop()
            }
          }
        } else if (['&'].indexOf(str[i]) > -1) {
          if (['!'].indexOf(stack.peek()) > -1) {
            while (['!'].indexOf(stack.peek()) > -1){
              outStack[outStack.length] = stack.peek()
              stack.pop()
            }
          }
        }
        stack.push(str[i])
      }else {
        outStack[outStack.length] = str[i]
        if (alpha.indexOf(str[i]) === -1) {
          alpha.push(str[i])
        }
      }
    }
    let length = stack.length()
    while (length) {
      outStack[outStack.length] = stack.peek()
      stack.pop()
      length --
    }
    Hou = outStack
    dfs(0)
    Perhaps()
    Also()
  }

  //对后缀表达式进行计算
  function cal() {
    let stack = new Stack()
    let ch
    // let j = 0
    let t1
    let t2
    for (let i = 0; i < Hou.length; i++) {
      ch = Hou[i]
      if ((ch>='A'&&ch<='Z') || (ch>='a'&&ch<='z')) {
        stack.push(map.get(ch))
      } else {
        if (ch === '!') {
          t1 = stack.peek()
          stack.pop()
          t1 = ((t1 === 0) ? 1 : 0)
          stack.push(t1)
        } else if (ch === '&') {
          t1 = stack.peek()
          stack.pop()
          t2 = stack.peek()
          stack.pop()
          if (t1 === 1 && t2 === 1) {
            stack.push(1)
          } else {
            stack.push(0)
          }
        } else if (ch === '|') {
          t1 = stack.peek()
          stack.pop()
          t2 = stack.peek()
          stack.pop()
          if (t1 === 0 && t2 === 0) {
            stack.push(0)
          } else {
            stack.push(1)
          }
        } else if (ch === '>') {
          t1 = stack.peek()
          stack.pop()
          t2 = stack.peek()
          stack.pop()
          if (t1 === 0 && t2 === 1) {
            stack.push(0)
          } else {
            stack.push(1)
          }
        } else if (ch === '~') {
          t1 = stack.peek()
          stack.pop()
          t2 = stack.peek()
          stack.pop()
          if ((t1===1&&t2===1)||(t1===0&&t2===0)) {
            stack.push(1)
          }else {
            stack.push(0)
          }
        }
      }
    }
    let ans = stack.peek()
    return ans
  }

  //递归枚举每一种字符变量的取值情况
  function dfs(cur) {
    if (cur == alpha.length) {
      let ans = cal()
      // console.log(ans)
      for (let i = 0; i < alpha.length; i++) {
        if (map.get(alpha[i])) {
          console.log(alpha[i] + ': T')
        }else {
          console.log(alpha[i] + ': F')
        }
      }
      if (ans === 1) {
        //表达式真值为T，计入到Atrue数组，以待后面的主析取范式使用
        console.log('表达式:' + 'T')
        let t = []
        for (let i = 0; i < alpha.length; i++) {
          // t = map.get(alpha[i])
          t.push(map.get(alpha[i]))
          // Atrue.push(t)
        }
        Atrue.push(t)
      }else {
        console.log('表达式:' + 'F')
        let t = []
        for (let i = 0; i < alpha.length; i++) {
          // t = map.get(alpha[i])
          t.push(map.get(alpha[i]))
          // Afalse.push(t)
        }
        Afalse.push(t)
      }
      return
    }
    // M[alpha[cur]] = 1
    // console.log(M)
    map.set(alpha[cur],1)
    dfs(cur+1)
    // M[alpha[cur]] = 0
    map.set(alpha[cur],0)
    dfs(cur+1)
  }

  //获取主析取范式
  function Perhaps() {
    let length = Atrue.length
    let str = ""
    for (let i = 0; i < length; i++) {
      if (i != 0) {
        str = str + '∨'
        // str.push('∨')
      }
      let p = Atrue[i]
      str = str + '('
      // str.push('(')
      for (let j = 0; j < alpha.length; j++) {
        if (j != 0){str = str + '∧'}
        if (p[j] == 1) {
          str = str + alpha[j]
        }else {
          let c = '￢' + alpha[j]
          str = str + c
        }
      }
      str = str + ')'
    }
    console.log('主析取范式' + str)
  }

  //获取主合取范式
  function Also() {
    let str = ''
    for (let i = 0; i < Afalse.length; i++) {
      if (i != 0){str += '∧'}
      let p = Afalse[i]
      str += '('
      for (let j = 0; j < alpha.length; j++) {
        if (j != 0){str += '∨'}
        if (p[j] == 0) {
          str += alpha[j]
        }else {
          let c = "￢" + alpha[j]
          str += c
        }
      }
      str = str + ')'
    }
    console.log('主合取范式' + str)
  }
</script>

测试结果：
在这里插入图片描述

想要一只肥宅快乐兽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
南邮离散数学第一次实验
BeMount
10-20 647
南邮离散数学第一次实验
南邮离散数学实验1 （栈版） 根据表达式求真值表和主范式
Tc的专栏
10-18 3566
#include #include using namespace std; string org; //原式 string pcnf; //主合取范式 string pdnf; //主析取范式 int p, q, r, s, t, u; //变量 P、Q、R、S、T、U的值 int a, b, res; //a、b保存出栈的两个元素的值，res保存计
南邮离散数学实验全部源码
04-13
这是所有的离散数学的源码，在自己做的时候，有些问题确实不会，但是也没人问，所以，为了后来人，我把资源传上来，希望给大家参考，但是，我十分不希望大家直接打印源码交给老师，这样没什么效果，态度决定度！
南京邮电大学离散数学实验一（求主析取和主合取范式）
亦是远方的小地方
05-16 4881
南京邮电大学离散数学实验一（求主析取和主合取范式）
南京邮电大学离散数学实验.zip
05-15
南京邮电大学离散数学实验 lab1: 输入任意公式, 打印出该公式的真值表、主合取范式和主析取范式. lab2: 输入可以是具体的二元关系，也可以给定一个具体的集合，随机生成一个二元关系，根据二元关系性质及对应的判定...
DiscreteMathProgram:南邮离散数学 实验一(含GUI)
04-27
在“DiscreteMathProgram:南邮离散数学 实验一(含GUI)”这个项目中，我们可以看到一个结合了编程实践的离散数学实验。该项目使用C++作为后端处理主要逻辑，而前端界面则是通过WPF（Windows Presentation Foundation...
南京邮电大学离散数学实验
03-27
南京邮电大学离散数学实验 南京邮电大学离散数学实验 南京邮电大学离散数学实验 南京邮电大学离散数学实验 南京邮电大学离散数学实验 南京邮电大学离散数学实验 南京邮电大学离散数学实验
南邮离散第三次实验JS版
BeMount
12-15 186
// 实验项目名称：偏序关系中盖住关系的求取及格论中有补格的判定 // 实验内容： // 编程实现整除关系这一偏序关系上所有盖住关系的求取，并判定对应偏序集是否为格。 // 实验要求： // 对任意给定正整数，利用整除关系求所有由其因子构成的集合所构成的格，判断其是否为有补格 // 获得因子 function getFractors(n){ const ans = []; for(let i = 1; i <= n; i++){ if( n % i == 0){ ans.p
南邮离散数学实验二
Step by step
10-25 3941
#include #include #include #include #include #define M 100 char *get_element(char *p)//输入结点序列函数 { printf("输入集合的元素(不能有空格):"); gets(p); fflush(stdin); return p; } int get_position(char
离散数学实验
02-02
离散数学实验，详细描述：http://blog.csdn.net/xunciy/article/details/79242693
SimScript:TypeScript 中的离散事件模拟库
08-03
模拟脚本 TypeScript 中的离散事件模拟库，支持 2D 和 3D 动画。 描述了SimScript库中的所有类及其属性。 此显示了多个模拟，包括 2D 和 3D 动画。 SimScript使用 JavaScript 的功能使模拟易于编写和理解。 SimScript模拟是使用这些类构建的： 模拟课 模拟创建资源（队列）和实体，它们执行描述每个实体应该执行的操作的异步脚本方法。 Simulation类是抽象的。 在大多数情况下，您将创建扩展它的类以创建您需要的队列和实体。 实体类 实体代表执行脚本的活动元素。 脚本是包含实体指令的异步方法。 典型的操作包括进入和离开队列、经历延迟以及发送或等待信号。 Entity类是抽象的。 在大多数情况下，您将创建一个或多个类来扩展它以执行模拟所需的操作。 Entity类有一个可选的泛型参数，其中包含它所引用的模拟类型。 队列类 队列代表可
JS 打印函数堆栈信息
我的专栏
07-19 2322
js打印堆栈信息
JavaScript 打印调用堆栈
诸葛飞
11-12 1万+
项目使用Cocos2d-JS，查看别人的代码时，如果完全靠翻代码的话，效率太低，而js代码又不能调试，所以使用打印堆栈的方法可以大大提高效率。
南邮离散数学实验 利用真值表法求取主析取范式以及主合取范式的实现
热门推荐
Coding
01-23 2万+
一、    实验目的和要求 内容： 编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。 要求： 能够列出任意合式公式的真值表并给出相应主析取和主合取范式。 内容： 编程实现用真值表法求取任意数量变量的合式公式的主析取范式和主合取范式。 原理： 先将中缀表达式转换成后缀表达式，再将后缀表达式中每一个字母变量一一赋值，用递归枚举的方法枚举所有赋值情况，并
南邮 | 离散数学实验一：利用真值表法求取主析取范式以及主合取范式的实现
Wonz
02-08 1万+
题目：根据给定的式子，先输出其真值表，再利用真值表法求取主析取范式以及主合取范式，输出答案。 举例：以 (P^Q) V (非P^R) 为例。 程序代码 //(P^Q) V (非P^R) //主合取范式: (非PVQV非R) ^ (非PVQVR) ^ (PV非QVR) ^ (PVQVR) //主析取范式: (P^Q^R) V (P^Q^非R) V (非P^Q^R) V (非P^非Q^R) #i...
南邮离散数学实验1 （简单版） 根据真值求真值表和主范式
Tc的专栏
09-30 9287
#include #include using namespace std; int const MAX = 1e6; short true_value[MAX]; //真值 short true_table[MAX][10]; //真值表 short pdnf[MAX]; //主析取范式 short pcnf[MAX]; //主合取范式 char varible[10] = {'
南邮 | 离散数学实验二：集合上二元关系性质判定的实现
Wonz
02-08 7956
题目：根据某一集合元素以及关系矩阵，判断其满足什么特性，输出满足的特性，再求此集合的闭包。 举例：以集合{1,2,3,4}为例。关系矩阵为：[[1,0,1,0],[0,1,0,0],[1,0,1,1],[0,0,1,1]]。 程序代码 //集合 A = {1,2,3,4} //关系矩阵为： //1 0 1 0 //0 1 0 0 //1 0 1 1 //0 0 1 1 //满足：自反性、对称...
物联网工程_基于RFID的食堂食品安全监测系统设计.docx
最新发布
07-20
物联网工程_基于RFID的食堂食品安全监测系统设计
离散实验一：真值表法求主范式
在"离散实验一"的报告中，该实验针对的是南邮（南京邮电大学）的离散数学课程，由计算机科学与技术系的罗卫兰老师指导。本实验主要集中在2015-2016学年第一学期，时间为9月22日，目的是让学生通过实践学习如何利用真...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值