精华内容
下载资源
问答
  • 运算公式整理

    千次阅读 2021-02-09 22:33:39
    整理ACM中常用的模运算公式,包括加减乘除、幂运算。

    数论 - 模运算

    加减乘除

    (个人习惯, m o d mod mod 表示用来取模的数。)

    加法: ( a + b ) % m o d = ( a % m o d + b % m o d ) % m o d (a+b) \% mod = (a \%mod + b\%mod)\%mod (a+b)%mod=(a%mod+b%mod)%mod

    减法: ( a − b ) % m o d = ( a % m o d − b % m o d ) % m o d (a-b) \% mod = (a \%mod - b\%mod)\%mod (ab)%mod=(a%modb%mod)%mod

    乘法: a × b % m o d = ( a % m o d × b % m o d ) % m o d a \times b \%mod=(a\%mod\times b\%mod)\%mod a×b%mod=(a%mod×b%mod)%mod

    除法:

    • 可以用逆元:

      • b a % m o d = b × a m o d − 2 % m o d \frac ba\%mod=b\times a^{mod-2}\%mod ab%mod=b×amod2%mod,其中 m o d mod mod 为素数(根据费马小定理)。
      • b a % m o d = b × a ϕ ( m o d ) − 1 % m o d \frac ba\%mod=b \times a^{\phi(mod)-1}\%mod ab%mod=b×aϕ(mod)1%mod,其中 a a a m o d mod mod 互质(根据欧拉定理)。但也可以由欧拉函数的性质推出, a ϕ ( m o d ) − 1 a^{\phi(mod)-1} aϕ(mod)1 = a m o d − 1 − 1 =a^{mod-1-1} =amod11 = a m o d − 2 =a^{mod-2} =amod2
    • 不能用逆元: b a % m o d = a % m o d × b b \frac ba\%mod=\frac {a\%mod\times b}{b} ab%mod=ba%mod×b

      • 证明:
        a b m o d    k = d a b = k x + d a = k b x + b d a m o d    k b = b d a m o d    k b b = d \frac ab\mod k = d \\ \frac ab=kx+d\\ a=kbx+bd\\ a\mod kb=bd\\ \frac {a \mod kb}{b}=d bamodk=dba=kx+da=kbx+bdamodkb=bdbamodkb=d

    板子如下:

    LL qm (LL a, LL b ,LL c){  //要取模
        LL res = 1;
        while(b){
            if(b & 1)
                res = res * a % c;
            a = a * a % c;
            b = b >> 1;
        }
        return res;
    }
    LL inv(LL x) {return qm(x, mod - 2, mod);}
    //四种取模运算
    LL add(LL x, LL y) {return (x % mod + y % mod) % mod;}
    LL sub(LL x, LL y) {return (x % mod - y % mod) % mod;}
    LL mul(LL x, LL y) {return x * y % mod;}
    LL div_1(LL x, LL y) {return x * inv(y) % mod;}  //可以求逆元的情况
    LL div_2(LL x, LL y) {return x % mod * y / y;}  //不能求逆元的情况
    

    幂运算

    欧拉降幂。
    a b % p = { a b % ϕ ( p ) % p g c d ( a , p ) = 1 a b % p g c d ( a , p ) ≠ 1 , b < ϕ ( p ) a b % ϕ ( p ) + ϕ ( p ) % p g c d ( a , p ) ≠ 1 , b ≥ ϕ ( p ) a^b\%p=\left\{ \begin{aligned} &a^{b\%\phi(p)}\%p& \quad gcd(a,p)=1\\ &a^b\%p& \quad gcd(a,p) \neq1,b<\phi(p)\\ &a^{b\%\phi(p)+\phi(p)}\%p& \quad gcd(a,p) \neq1,b\ge\phi(p)\\ \end{aligned} \right . ab%p=ab%ϕ(p)%pab%pab%ϕ(p)+ϕ(p)%pgcd(a,p)=1gcd(a,p)=1,b<ϕ(p)gcd(a,p)=1,bϕ(p)

    此处仅给出第三种情况(常用)的代码。

    LL qm(LL a, LL b, LL c) {
        LL res = 1;
        while (b) {
            if (b & 1) res = res * a % c;
            a = a * a % c;
            b >>= 1;
        }
        return res;
    }
    
    LL jm(LL a, LL b) {  //欧拉降幂
        LL mi = b % phi(mod) + phi(mod);
        return qm(a, mi, mod);
    }
    
    展开全文
  • Excel常用运算公式汇总.docx
  • 指数对数概念及运算公式.doc
  • 指数对数概念与运算公式.doc
  • 指数对数概念和运算公式.doc
  • python 栈-解析四则运算公式

    万次阅读 2020-07-13 21:09:02
    python 栈-解析四则运算公式 文章目录python 栈-解析四则运算公式1、栈栈的抽象数据类型解析算数表达式中序转后序后序表达式计算2、解析四则运算-Coding 1、栈 栈也被称为下堆栈, 他是有序集合, 添加操作和移除...

    python 栈-解析四则运算公式

    1、栈

    也被称为下堆栈, 他是有序集合, 添加操作和移除操作发生在同一端,即顶端, 另一端称为底端

    • LIFO(last-in, first-out) 后进先出
    • 可用于反转排列顺序

    栈的抽象数据类型

    支持以下操作

    • push(item) 将元素添加到栈中
    • pop() 返回并删除顶端的元素
    • peek() 返回顶端的元素, 但不删除元素
    • isEmpty() 判断栈是否为空
    • size() 返回栈中的元素数量

    解析算数表达式

    • 括号匹配: 每一个左括号都有与之对应的又括号, 并且括号有正确的嵌套关系

    处理括号匹配
    由空栈开始,从左往右依次处理括号。遇到左括号, 使用push操作将其加入栈中;如果遇到右括号就调用pop操作, 所有的左括号都应有右括号与之匹配。
    处理完括号匹配,栈应该是空的

    • 前序表达式:运算符调整到两个操作数前, eg: +ab

    • 中序表达式:运算符出现在两个操作数间, eg: a*b

    • 后序表达式:运算符调整至操作数后, eg: ab+

    • 完全括号表达式: 对每一对运算符都添加一对括号, 由括号决定运算顺序, 杜绝歧义, 并且不需要记忆运算规则

      中序表达式前序表达式后序表达式
      a + b+ a ba b +
      a - b / c- a / b ca b c / -
      a + b * c + d+ a * b c + da b c * + d +
      (a + b) * ( c + d)* + a b + c da b + c d + *

    中序转后序

    • 创建一个空栈和列表, 分别保存运算符和转换结果列表
    • 将中序表达式转换为一个列表
    • 从左往右扫描列表
      • 数值, 添加至转换列表中
      • 左括号, 压入栈中
      • 右括号, 重复从栈中获取元素,添加至转换结果列表中, 直至获取左括号
      • 运算符,将其与栈中的顶端元素比较,从栈中取出优先级高的元素追加至转换列表中
    • 处理完表达式后将栈中残余的运算符追加至转换结果列表中

    后序表达式计算

    • 创建空栈
    • 将后续表达式转化为一个列表
    • 从左往右扫描列表
      • 数值,压入栈中
      • 运算符,从栈中去两个元素, 第一个为右数, 第二个为左数,计算出数值后重新压入栈中
    • 处理完表达式后, 从栈中获取数值

    2、解析四则运算-Coding

    后序表达式计算

    # -*- coding: utf-8 -*-
    
    """
    中序表达式转后序表达式, 并计算
    """
    import re
    import operator
    import string
    
    
    class PostOrderConversion:
    
        def conversionToPostOrder(self, inOrdErexpr):
            """
            后序转换
            """
            # 构建运算符优先级字典
            prec = {
                "*": 3,
                "/": 3,
                "+": 2,
                "-": 2,
                "(": 1,
                ")": 1
            }
    
            if not self.parseChecker(inOrdErexpr):
                raise ValueError
    
            opStack = Stack()
            postOrderList = list()
            exprList = inOrdErexpr.split()
    
            for ch in exprList:
                if ch.isdigit():
                    postOrderList.append(ch)
                elif ch == "(":
                    opStack.push(ch)
                elif ch == ")":
                    topOper = opStack.pop()
                    while topOper != "(":
                        postOrderList.append(topOper)
                        topOper = opStack.pop()
                else:
                    # 比较运算符优先级,如果栈中运算符的优先级>当前运算符, 追加至转换列表中
                    while (not opStack.isEmpty()) and (prec[opStack.peek()] > prec[ch]):
                        postOrderList.append(opStack.pop())
                    opStack.push(ch)
            # 将栈中的运算符追加至转换列表中
            while not opStack.isEmpty():
                postOrderList.append(opStack.pop())
            return "".join(postOrderList)
    
        def calculatePostOrderFormulas(self, postOrderformulas):
            """
            计算后序表达式
            """
            operaDict = {
                "+": operator.add,
                "-": operator.sub,
                "*": operator.mul,
                "/": operator.truediv
            }
            postStack = Stack()
            postOrderList = list(postOrderformulas)
            for ch in postOrderList:
                if ch.isdigit():
                    postStack.push(eval(ch))
                else:
                    opN1 = postStack.pop()
                    opN2 = postStack.pop()
                    postStack.push(operaDict[ch](opN2, opN1))
            return postStack.pop()
    
        def parseChecker(self, symbolStr):
            """
            判断括号是否完全匹配
            """
            symbolStr = self.extractBrackets(symbolStr)
            s = Stack()
            balanced = True
            index = 0
            while index < len(symbolStr) and balanced:
                symbol = symbolStr[index]
                if symbol in "{[(":
                    s.push(symbol)
                elif s.isEmpty():
                    balanced = False
                else:
                    topSym = s.pop()
                    if self.matches(topSym, symbol):
                        balanced = False
                index += 1
            if balanced and s.isEmpty():
                return True
            else:
                return False
    
        def extractBrackets(self, formulas):
            regex = re.compile(r'[{\[()\]}]')
            return "".join(regex.findall(formulas))
    
        def matches(self, open, close):
            opens = "{[("
            closers = "}])"
            return opens.index(opens) == closers.index(close)
    
    if __name__ == "__main__":
        formulas1 = "( 1 + 2 ) * 3"
        formulas2 = "5 + 6 * 7"
        postConversion = PostOrderConversion()
        cFormulas1 = postConversion.conversionToPostOrder(formulas1)
        cFormulas2 = postConversion.conversionToPostOrder(formulas2)
        print("formulas1: %s | formulas1: %s" % (cFormulas1, cFormulas1))
        print("formulas1: %s=" % formulas1, postConversion.calculatePostOrderFormulas(cFormulas1))
        print("formulas2: %s=" % formulas2, postConversion.calculatePostOrderFormulas(cFormulas2))
    
    
    

    计算结果

    formulas1: 12+3* | formulas1: 12+3*
    formulas1: ( 1 + 2 ) * 3= 9
    formulas2: 5 + 6 * 7= 47
    

    创建栈

    # -*- coding: utf-8 -*-
    
    
    class Stack():
    
        def __init__(self):
            self.items = list()
    
        def isEmpty(self):
            return self.items == []
    
        def push(self, item):
            self.items.append(item)
    
        def pop(self):
            return self.items.pop()
    
        def peek(self):
            return self.items[-1]
    
        def size(self):
            return len(self.items)
    
    
    if __name__ == "__main__":
        stack = Stack()
        stack.push(1)
        stack.push(2)
        stack.push(3)
        stack.push(4)
        print(stack.items)
        print(stack.peek())
        print(stack.isEmpty())
    
    展开全文
  • 库存管理运算公式和各章重点.doc
  • python 二叉树-解析四则运算公式

    万次阅读 2020-07-13 21:12:39
    python 二叉树-解析四则运算公式 文章目录python 二叉树-解析四则运算公式1、解析树完全括号表达式2、解析四则运算-Coding 1、解析树 根据括号构建解析数 计算解析树中的表达式 将解析树还原为最初的数学表达式 ...

    python 二叉树-解析四则运算公式

    1、解析树

    • 根据括号构建解析数
    • 计算解析树中的表达式
    • 将解析树还原为最初的数学表达式

    构建表达式 **((7+3)*(8-6))**的解析树

    先算加减,后算乘法
    在计算顶层的乘法前, 需要先计算子树中的加法和减法, 计算完之后使用记过替代整颗子树

    在这里插入图片描述
    在这里插入图片描述

    构建解析树规则

    • 如果标记是 (, 为当前节点创建一个子节点, 并下沉至该节点
    • 如果当前标记在列表["+", “-”, “/”, “*”], 将当前节点的值设置为当前标记对应的运算符;为当前节点穿件一个右节点并下沉至该节点
    • 如果当前值是是数值, 就将当前节点的数值设置为该数值并返回至父节点
    • 如果标记是), 则跳到当前节点的父节点

    完全括号表达式

    对每一对运算符都添加一对括号, 由括号决定运算顺序, 杜绝歧义, 并且不需要记忆运算规则

    2、解析四则运算-Coding

    BuildParseTree 类:解析并计算公式

    # -*- coding: utf-8 -*-
    import operator
    
    class BuildParseTree:
    
    
        def __init__(self, fpexp):
            self.fplist = fpexp.split()
    
        def buildParseTree(self):
            """
            构建解析树
            使用栈来保存父节点
            """
            pStack = Stack()
            eTree = BinaryTree('')
            pStack.push(eTree)
            curentTree = eTree
            for i in self.fplist:
                # 如果标记是 (, 为当前节点创建一个子节点, 并下沉至该节点
                if i == "(":
    
                    curentTree.insertLeft("")
                    pStack.push(curentTree)
                    curentTree = curentTree.getLeftChild()
                # 如果当前标记在列表["+", "-", "/", "*"], 将当前节点的值设置为当前标记对应的运算符;为当前节点穿件一个右节点并下沉至该节点
                elif i not in "=-*/":
                    curentTree.setRootVal(eval(i))
                    parent = pStack.pop()
                    curentTree = parent
                # 如果当前值是是数值, 就将当前节点的数值设置为该数值并返回至父节点
                elif i in "=-*/":
                    curentTree.setRootVal(eval(i))
                    curentTree.insertRight("")
                    pStack.push(curentTree)
                    curentTree.getRightChild()
                # 如果标记是), 则跳到当前节点的父节点
                elif i == ")":
                    parent = pStack.pop()
                    curentTree = parent
                else:
                    raise ValueError("Error: %s" % i)
            return eTree
    
        def evaluate(self, parseTree):
            """
            计算解析树
            """
    
            # 构建运算操作字典
            opers = {
                "+": operator.add,
                "-": operator.sub,
                "*": operator.mul,
                "/": operator.truediv
            }
    
            leftC = parseTree.getLeftChild()
            rightC = parseTree.getRightChild()
            if leftC and rightC:
                fn = opers[parseTree.getRootVal()]
                return fn(self.evaluate(leftC), self.evaluate(rightC))
            else:
                return parseTree.getRootVal()
    
    if __name__ == "__main__":
        formulas = "((7+3)*(8-6))"
        fTree = BuildParseTree(formulas)
        eTree = fTree.buildParseTree()
        value = fTree.evaluate(eTree)
        print("%s = " % formulas, value)
    

    BinaryTree类

    # -*- coding: utf-8 -*-
    
    class BinaryTree:
        """
        利用节点与引用创建二叉树
        """
        
        def __init__(self, rootObj):
            self.key = rootObj
            self.leftChild = None
            self.rightChild = None
    
    
        def insertLeft(self, newNode):
            """
            插入左节点
            """
            if self.leftChild is None:
                self.leftChild = BinaryTree(newNode)
            else:
                t = BinaryTree(newNode)
                t.leftChild = self.leftChild
                self.leftChild = t
        
        def insertRight(self, newNode):
            """
            插入右节点
            """
            if self.rightChild is None:
                self.rightChild = BinaryTree(newNode)
            else:
                t = BinaryTree(newNode)
                t.rightChild = self.rightChild
                self.rightChild = t
    
        def getRightChild(self):
            """
            返回当前节点的右节点和对应的二叉树
            """
            return self.rightChild
    
        def getLeftChild(self):
            """
            返回当前节点的左节点和对应的二叉树
            """
            return self.leftChild
    
        def getRootVal(self):
            """
            获取当前节点的数值
            """
            return self.key
    
        def setRootVal(self, obj):
            """
            存储当前节点的数值
            """
            self.key = obj
    
    
    

    Stack 类

    # -*- coding: utf-8 -*-
    
    
    class Stack():
    
        def __init__(self):
            self.items = list()
    
        def isEmpty(self):
            return self.items == []
    
        def push(self, item):
            self.items.append(item)
    
        def pop(self):
            return self.items.pop()
    
        def peek(self):
            return self.items[-1]
    
        def size(self):
            return len(self.items)
    
    
    if __name__ == "__main__":
        stack = Stack()
        stack.push(1)
        stack.push(2)
        stack.push(3)
        stack.push(4)
        print(stack.items)
        print(stack.peek())
        print(stack.isEmpty())
    
    展开全文
  • 包含两个信号之间的运算自相关与互相关运算
  • 运算单双公式.doc

    2021-09-15 18:00:34
    运算单双公式.doc
  • java执行字符串中的运算公式

    千次阅读 2018-01-17 15:54:17
    java执行字符串中的运算公式 原创 2014年05月07日 10:55:22 标签:java执行字符串型运算公式 17496 JDK自带的类可以实现调用JS的功能,可以实现执行字符串中的运算公式的功能。 ...

    java执行字符串中的运算公式


    原创  2014年05月07日 10:55:22

    JDK自带的类可以实现调用JS的功能,可以实现执行字符串中的运算公式的功能。


    [java]  view plain  copy
    1. public class runString {  
    2.   
    3.     static ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript");  
    4.   
    5.     /** 
    6.      * @param args 
    7.      */  
    8.     public static void main(String[] args) {  
    9.         String strs = "1+1*2+(10-(2*(5-3)*(2-1))-4)+10/(5-0)";  
    10.         try {  
    11.             System.out.println(jse.eval(strs));  
    12.         } catch (Exception t) {  
    13.         }  
    14.     }  
    15. }  

    注意:如果公式中存在变量作为运算的元素的话,可以借鉴使用replaceAll()方法将相应的变量替换成实际的数值。如果是多个变量可以利用循环遍历的方式来解决。

    例子:jse.eval("1+b".replaceAll("b", b.toString()));

    展开全文
  • 对数运算基本公式

    万次阅读 2016-10-18 15:20:55
    目录对数的换底公式 对数的四则运算 指数式与对数式的互化对数的换底公式对数的四则运算指数式与对数式的互化
  • js解析数学运算公式

    千次阅读 2019-06-19 18:52:00
    已上传到npm,NPM包地址: ... //运行demo const execMathExpress=require('./utils/execMathExpress');//贝叶斯 条件概率公式 SW=WS*S/(WS*S+WH*H);(只用于二分类)console.log(execMathExp...
  • 把普通等式运算,混合等式运算,普通或者混合不等式运算的String转换为逆波兰式,用于解析运算字符串的运算的工具 具体实现见:MyCalulator.java
  • 公务员考试专用行测数学运算公式相当有用所有题型.doc
  • Java 字符串转成运算公式

    千次阅读 2018-12-12 18:00:42
    转载:https://www.cnblogs.com/cocoat/p/6956610.html GroovyShell 实现 public static void main(String args[]) { Binding binding = new Binding(); binding.setVariable("F",2.5); bi...
  • 软件编程——逻辑运算公式

    千次阅读 2015-04-14 18:46:40
    大家可以在编程时,对照公式,简化代码,提高运行效率...逻辑运算公式: 1、!(a||b)=!a&&!b 2、!(a&&b)=!a||!b 3、(!a||!b)||!c=!((a&&b)&&c)=!(a&&b&&c) 4、(!a&&!b)&&!c=!((a||b)||c)=!(a||b||c) 5、!((a&&b)||c)
  • 在opencv文档中中,加法运算的一种计算公式如下: dst(I)=saturate(src1(I)+src2(I))if mask(I)≠0 类似的公式还有很多,要理解上述公式的含义,就需要理解这些公式中包含的saturate函数及变量后跟“(I)”的含义。...
  • 今天小编就为大家分享一篇java实现字符串四则运算公式解析工具类的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 矩阵求导详细手册-求导运算公式表文献,适合初学者学习。
  • 矩阵求导详细手册-求导运算公式表文献及-PPT,文献为斯坦福大学数学系推导和总结的矩阵求导运算表,PPT为一些矩阵求导运算规则。是我在看机器学习线性回归推导时时候要用到的内容,网上比较后找了这两个质量比较高的...
  • 项目中用到用户定义运算公式进行就算的需求,这样需要进行字符串四则运算解析,下面提供字符串公式四则运算解析与计算工具类,需要的同学可参考。工具类如下:FormulaCalculator.java: package org.nercita.bcp....
  • 二进制补码运算公式

    千次阅读 2009-11-09 12:58:00
    二进制补码运算公式: -x = ~x + 1 = ~(x-1) ~x = -x-1 -(~x) = x+1 ~(-x) = x-1 x+y = x - ~y - 1 = (x ¦y)+(x&y) x-y = x + ~y + 1 = (x ¦~y)-(~x|y) x^y = (x ¦y)-(x&y) x ¦y = (x&~y)+y x&y = (~x ¦y)-~x x...
  • 数制转换(取余,取商运算公式

    千次阅读 2018-11-16 12:20:29
     取商数运算公式 a取余b求商 a除以b整数部分为商数  取余运算公式 a取余b a除以b取商数,b=商数乘以b,a减去b等于余数  ...
  • excel中时间加分钟运算公式

    千次阅读 2020-12-03 11:10:09
    例如时间为06:30 要计算40分钟以后的时间,正确应该是07:10 excel公式中输入,其中C2表示06:30 G2表示40 =TEXT(C2+TIME(0,G2,0),"hh:mm") TIME(hour,minute,second)
  • import javax.script.ScriptEngine; import javax.script.ScriptEngineManager; import javax.script....//字符串的运算公式直接转计算结果 public class Demo1 { public static void main(String[] args) { Scr...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 202,813
精华内容 81,125
关键字:

自相关运算公式