精华内容
下载资源
问答
  • Fraction to Recurring Decimal Given two integers representing the numerator and denominator of a fraction, return the fraction in string format. If the fractional part is repeating, e...

    LeetCode - 166. Fraction to Recurring Decimal

    Given two integers representing the numerator and denominator of a
    fraction, return the fraction in string format.

    If the fractional part is repeating, enclose the repeating part in
    parentheses.

    Input: numerator = 1, denominator = 2
    Output: “0.5”

    Input: numerator = 2, denominator = 1
    Output: “2”

    Input: numerator = 2, denominator = 3
    Output: “0.(6)”

      其实就是分数计算成小数形势,如果出现了循环小数,则用 ‘(’ 和 ‘)’ 将循环部分括起来(值得注意的是:因为是从分数转为小数,所以不会出现无限不循环小数,因为能用分数形式表示的都是有理数,而无限不循环小数无理数,这是因为:分数每次“试商”都要使本次余数小于除数,然而小于除数的余数是有限的,如果除数是17,那么最多有17种余数。所以如果除不尽的话必定产生循环,循环节不会超过17位)。

    Solution:
      如果不能整除,就不断进行余数补零除以除数。
      维护一个映射表map<long long, int> m, 用来记录每个除数对应返回值ret中的位置。
    (1)当出现重复的除数n时,说明找到了循环体,根据m[n]找到ret中位置,加上相应的’(‘和’)'将循环体括起来即可返回。
    (2)当余数r为0时,返回ret。
      注意点:
      1、正负号
      2、分子为0
      3、可能出现INT_MIN/-1的越界情况,因此第一步现将int转为long long

    // 小数部分如果余数重复出现两次就表示该小数是循环小数了
    string fractionToDecimal(int numerator, int denominator) {
        if(denominator == 0) return "";  // 分母为0
        if(numerator == 0)   return "0"; // 边界条件,分子为0
        string res;
        
        // 转为 long long 防止溢出
        long long up = numerator, down = denominator;
        
        // 处理正负号
        if((up > 0) ^ (down > 0))
            res.push_back('-');
        
        // 分子分母全部转换为正数
        up = llabs(up);
        down = llabs(down);
        
        // 处理整数部分
        res += to_string(up / down);
        
        //处理小数部分
        up %= down;                      // 获得余数
        if(up == 0) return res;          // 余数为0,表示整除了,直接返回结果
        res += '.';                      // 余数不为0,添加小数点
        int idx = res.size() - 1;        // 获得小数点的下标
        unordered_map<int, int> mp;      // map用来记录出现重复数的下标
        while(up && mp.count(up) == 0) { // 小数部分:余数不为0且余数还没有出现重复数字
            mp[up]= ++idx;
            up *= 10;                    // 余数扩大10倍,然后求商
            res += to_string(up / down);
            up %= down;
        }
        if(mp.count(up) == 1) {          // 出现循环余数
            res.insert(mp[up], "(");     // 只能insert字符串
            res.push_back(')');
        }
        return res;
    }
    
    展开全文
  • python decimal 精确计算

    万次阅读 多人点赞 2018-03-07 19:41:17
    经常使用的几个点1.可以传递给Decimal整型...传入浮点数 5.55In [74]: Decimal(5.55)*100Out[74]: Decimal('554.9999999999999822364316060')传入字符串 ‘5.55’In [75]: Decimal('5.55')*100Out[75]: Decimal('555...

    经常使用的几个点

    1.可以传递给Decimal整型或者字符串参数,但不能是浮点数据,因为浮点数据本身就不准确。

    传入浮点数 5.55

    In [74]: Decimal(5.55)*100

    Out[74]: Decimal('554.9999999999999822364316060')


    传入字符串 ‘5.55’

    In [75]: Decimal('5.55')*100
    Out[75]: Decimal('555.00')

    2.要从浮点数据转换为Decimal类型

    from decimal import *

    Decimal.from_float(22.222)

    # 结果为Decimal('22.2219999999999995310417943983338773250579833984375')

    3.通过设定有效数字,限定结果样式:

    from decimal import *

    getcontext().prec = 6

    Decimal(1)/Decimal(7)

    # 结果为Decimal('0.142857'),六个有效数字

    4.四舍五入,保留几位小数

    from decimal import *

    Decimal('50.5679').quantize(Decimal('0.00'))

    # 结果为Decimal('50.57'),结果四舍五入保留了两位小数

    5.Decimal 结果转化为string

    from decimal import *

    str(Decimal('3.40').quantize(Decimal('0.0')))

    # 结果为'3.40',字符串类型

    特别注意  

    from decimal import *
    print(getcontext())  # Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, 。。。。。)
    num,num1 = '12355','123.55'
    getcontext().prec = len(num) +2
    print(Decimal(num1)*100 == Decimal(num))   True
    getcontext().prec = 3
    # todo 如果prec的长度比数字的长度小的话,*100得出的数就不对了
    print(Decimal(num1)*100)                   1.24E+4
    print(Decimal(num1))                       123.55
    print(Decimal(num1)*100 == Decimal(num))   False
    print(Decimal(num))                        12355

    decimal模块进行十进制数学计算

    python中的decimal模块可以解决上面的烦恼 
    decimal模块中,可以通过整数,字符串或原则构建decimal.Decimal对象。如果是浮点数,特别注意因为浮点数本身存在误差,需要先将浮点数转化为字符串。

    >>> from decimal import Decimal>>> from decimal import getcontext

    >>> Decimal('4.20') + Decimal('2.10')Decimal('6.30')

    >>> from decimal import Decimal

    >>> from decimal import getcontext

    >>> x = 4.20

    >>> y = 2.10

    >>> z = Decimal(str(x)) + Decimal(str(y))

    >>> zDecimal('6.3')

    >>> getcontext().prec = 4 #设置精度

    >>> Decimal('1.00') /Decimal('3.0')

    输出 Decimal('0.3333')

    当然精度提升的同时,肯定带来的是性能的损失。在对数据要求特别精确的场合(例如财务结算),这些性能的损失是值得的。但是如果是大规模的科学计算,就需要考虑运行效率了。毕竟原生的float比Decimal对象肯定是要快很多的。

    python decimal.quantize()参数rounding的各参数解释与行为

    我最开始其实是由于疑惑ROUND_FLOOR和 ROUND_DOWN的表现区别才看了一波文档,但是感觉拉出一票以前没有留意过的东西。

    贴一个decimal文档里面的解释:

    复制代码
    ROUND_CEILING (towards Infinity),
    ROUND_DOWN (towards zero),
    ROUND_FLOOR (towards -Infinity),
    ROUND_HALF_DOWN (to nearest with ties going towards zero),
    ROUND_HALF_EVEN (to nearest with ties going to nearest even integer),
    ROUND_HALF_UP (to nearest with ties going away from zero), or
    ROUND_UP (away from zero).
    ROUND_05UP (away from zero if last digit after rounding towards zero would have been 0 or 5; otherwise towards zero)
    复制代码

     

    直接阅读上面的解释十分抽象,下面我结合例子来解释一下在正负数不同的情况下 他们究竟有着什么样的行为

    首先给出一组负数的后一位超过5的数据:

    from decimal import *
    
    x = Decimal('-3.333333333') + Decimal('-2.222222222')
    print(x)   # -5.555555555
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_EVEN))    # -5.5556
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_DOWN))    # -5.5556
    print(x.quantize(Decimal('1.0000'), ROUND_CEILING))      # -5.5555
    print(x.quantize(Decimal('1.0000'), ROUND_FLOOR))        # -5.8599
    print(x.quantize(Decimal('1.0000'), ROUND_UP))           # -5.8599
    print(x.quantize(Decimal('1.0000'), ROUND_DOWN))         # -5.5555

    ROUND_HALF_EVENT 和 ROUND_HALF_DOWN:EVENT是quansize的默认设置值,可以通过getcontext()得到,EVENT四舍五入进了一位,DOWN为接近最近的0进了一位。

    ROUND_CEILING 和 ROUND_FLOOR:CEILING超过5没有进位是因为它倾向正无穷,FLOOR为了总是变得更小所以进了一位。

    ROUND_UP 和 ROUND_DOWN:UP始终进位,DOWN始终不会进位。。

     

    再多对比一组后一位没有超过5的数据:

    from decimal import *
    
    x = Decimal('-3.333333333') + Decimal('-1.111111111')
    print(x)   # 4.444444444
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_EVEN))    # -4.4444
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_DOWN))    # -4.4444
    print(x.quantize(Decimal('1.0000'), ROUND_CEILING))      # -4.4444
    print(x.quantize(Decimal('1.0000'), ROUND_FLOOR))        # -4.4445
    print(x.quantize(Decimal('1.0000'), ROUND_UP))           # -4.4445
    print(x.quantize(Decimal('1.0000'), ROUND_DOWN))         # -4.4444

    ROUND_HALF_EVENT 和 ROUND_HALF_DOWN:EVENT是quansize的默认设置值,可以通过getcontext()得到,EVENT由于达不到四舍五入所以不进位,DOWN同样也不进位。

    ROUND_CEILING 和 ROUND_FLOOR:CEILING倾向正无穷不进位,FLOOR即使没有超过5,但是为了总是变得更小进了一位。

    ROUND_UP 和 ROUND_DOWN:UP始终进位,DOWN始终不会进位。。

     

    正数部分后面数大于5的情况:

    from decimal import *
    
    x = Decimal('3.333333333') + Decimal('2.222222222')
    print(x)   # 5.555555555
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_EVEN))    # 5.5556
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_DOWN))    # 5.5556
    print(x.quantize(Decimal('1.0000'), ROUND_CEILING))      # 5.5556
    print(x.quantize(Decimal('1.0000'), ROUND_FLOOR))        # 5.5555
    print(x.quantize(Decimal('1.0000'), ROUND_UP))           # 5.5556
    print(x.quantize(Decimal('1.0000'), ROUND_DOWN))         # 5.5555

    ROUND_HALF_EVENT 和 ROUND_HALF_DOWN:EVENT是quansize的默认设置值,可以通过getcontext()得到,EVENT由于达到四舍五入所以进位,DOWN同样进位。

    ROUND_CEILING 和 ROUND_FLOOR:CEILING正数始终进位,FLOOR在正数则始终不会进位。

    ROUND_UP 和 ROUND_DOWN:UP始终进位,DOWN始终不会进位。

     

    正数部分后面数小于5的情况:

    from decimal import *
    
    x = Decimal('3.333333333') + Decimal('1.111111111')
    print(x)   # 4.444444444
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_EVEN))    # 4.4444
    print(x.quantize(Decimal('1.0000'), ROUND_HALF_DOWN))    # 4.4444
    print(x.quantize(Decimal('1.0000'), ROUND_CEILING))      # 4.4445
    print(x.quantize(Decimal('1.0000'), ROUND_FLOOR))        # 4.4444
    print(x.quantize(Decimal('1.0000'), ROUND_UP))           # 4.4445
    print(x.quantize(Decimal('1.0000'), ROUND_DOWN))         # 4.4444

    ROUND_HALF_EVENT 和 ROUND_HALF_DOWN:EVENT是quansize的默认设置值,可以通过getcontext()得到,EVENT由于没有达到四舍五入所以不进位,DOWN同样不进位。

    ROUND_CEILING 和 ROUND_FLOOR:CEILING正数始终进位,FLOOR在正数则始终不会进位。

    ROUND_UP 和 ROUND_DOWN:UP始终进位,DOWN始终不会进位。

     

    总结:

    其实这里我们通过上面一组例子可以发现,正数的行为非常可预期也非常简单,负数的情况稍复杂,有些函数就是设计为负数在某些情况中使用的。正数中无法重现的ROUND_DOWN和ROUND_FLOOR的区别,ROUND_DOWN是无论后面是否大于5都不会管保持原状,而Floor在正数中的行为也是如此,但是在负数中为了倾向无穷小,所以无论是否大于5,他都会变得更小而进位。反而ROUND_UP和ROUND_DOWN的行为是最可预期的,那就是无论后面数大小,UP就进位,DOWN就始终不进位。


    展开全文
  • decimal 精确计算模块

    2019-04-03 14:43:27
    decimal 这个模块提供了十进制浮点运算支持 decimal模块中,可以通过整数,字符串构建decimal.Decimal对象。 如果是浮点数,特别注意,因为浮点数本身存在误差,需要先将浮点数转化为字符串。 精度提升的同时,...

    decimal 这个模块提供了十进制浮点运算支持

    decimal模块中,可以通过整数,字符串构建decimal.Decimal对象。

    如果是浮点数,特别注意,因为浮点数本身存在误差,需要先将浮点数转化为字符串。

    精度提升的同时,肯定带来的是性能的损失;原生的float比Decimal对象肯定是要快很多的。

     

    from decimal import *
    
    ####可以传递给Decimal整型或者字符串参数,但不能是浮点数据,因为浮点数据本身就不准确。
    
    a1 = Decimal(5.55)*100
    print 'a1=',a1  #a1= 554.9999999999999822364316060 数据不准确
    
    a3= Decimal.from_float(5.55)*100
    print 'a3=',a3  #a3= 554.9999999999999822364316060 数据不准确
    
    a2 = Decimal('5.55')*100
    print 'a2=',a2  #a2= 555.00  数据准确
    
    
    ######四舍五入,保留几位小数
    b1 = Decimal('50.5679').quantize(Decimal('0.00'))
    print"b1 = ",b1 #b1 =  50.57
    
    
    #####设定有效数字,限定结果样式:
    print(getcontext().prec)
    getcontext().prec = 3
    print Decimal(1)/Decimal(3)

     

    展开全文
  • python decimal精确计算 python decimal精确计算 (1). Decimal接收int和string类型参数 from decimal import * # 不能传入浮点数据,因为浮点数据就不准确 a = Decimal(3.33)*100 b = Decimal('3.33')*100 c = ...

    python decimal精确计算

    python decimal精确计算

    • (1). Decimal接收int和string类型参数
    from decimal import *
    
    # 不能传入浮点数据,因为浮点数据就不准确
    a = Decimal(3.33)*100
    b = Decimal('3.33')*100
    c = Decimal(3)
    print(a)
    print(b)
    print(c)
    
    # 结果
    '''
    Decimal('333.0000000000000071054273576')
    Decimal('333.00')
    Decimal('3')
    '''
    
    • (2). 浮点数据转换为Decimal类型
    from decimal import *
    
    Decimal.from_float(2.222)
    
    # 结果
    '''
    Decimal('2.221999999999999975131004248396493494510650634765625')
    '''
    
    • (3). 设定有效数字

    特别注意,如果prec的长度比数字的长度小的话,扩充*100时就会出错

    from decimal import *
    
    # 保留6个有效数字
    getcontext().prec = 6
    Decimal(1)/Decimal(7)
    
    # 结果
    '''
    Decimal('0.142857')
    '''
    
    • (4). 四舍五入,保留几位小数
    from decimal import *
    
    # 保留两位小数
    Decimal('0.2335662').quantize(Decimal('0.00'))
    
    # 结果
    '''
    Decimal('0.23')
    '''
    
    • (5). Decimal转化为字符串类型
    from decimal import *
    
    # 保留两位小数
    str(Decimal('0.2335662').quantize(Decimal('0.00')))
    
    # 结果
    '''
    '0.23'
    '''
    
    展开全文
  • from decimal import * a =Decimal('0.1')+Decimal('0.1')+Decimal('0.1')+Decimal('0.3') float(a) >>>>>0.6 转载于:https://www.cnblogs.com/shmily3929/p/9103654.html
  • 浮点数的存储规则不精确,因为0.1 转换为二进制是无限循环的。在内存中规定,多余部分截断。所以在计算浮点型或者精度要求比较的时候,使用... while decimal.Decimal(i).quantize(decimal.Decimal("0.00")) != dec...
  • Python3中decimal处理计算精度问题示例

    千次阅读 2018-12-17 11:56:28
    #!/usr/bin/python3 ...from decimal import Decimal, getcontext class damo1(object): """ 取整问题: ROUND_CEILING 总是趋向无穷大向上取整  ROUND_DOWN 总是趋向0取整  ROUND_FL...
  • 浮点型加法 0.1+0.2 Out[15]: 0.30000000000000004 ...decimal.Decimal(0.1) + decimal.Decimal(0.2) Out[17]: Decimal('0.3000000000000000166533453694') # 设置精度 decimal.getcontext().pre...
  • decimal.js 实现了对任意精度的十进制进行计算的 JavaScript 库。 标签:decimal
  • python 中的 decimal 模块提供十... 为了消除这种误差,可以用 decimal 模块进行更加精确的浮点计算。 from decimal import Decimal #参数这里是字符串 a = Decimal('1.1') b = Decimal('2.2') print(a + b) 运算
  • 转载自案例分析 | 由Decimal操作计算引发的Spark数据丢失问题 供稿 | Hadoop Team 编辑 | 顾欣怡 本文3058字,预计阅读时间10分钟 导读 eBay的Hadoop集群上面每天运行着大量Spark计算任务。对于数据计算任务,...
  • 直到最近在一个项目中遇到了小数点计算的问题,发现要解决小数计算的精度问题,还真得用到这个Decimal不可。 文章目录问题描述解决办法四舍五入Decimal 问题描述 浮点数在内存中存储的时候因为存储机制的原因,天然...
  • Python提供了decimal模块用于十进制数学计算,它具有以下特点: 提供十进制数据类型,并且存储为十进制数序列; 有界精度:用于存储数字的位数是固定的,可以通过decimal.getcontext().prec=x 来设定,不同的数字...
  • python之decimal模块

    千次阅读 2020-04-10 21:16:24
    在python中小数相加...但这个地方有个坑,那就是Decimal(),括号里面必须是字符串,假如我们需要通过Decimal计算的话就需要将数值转换成字符串或者直接加上引号 还可以通过decimal里面的getcontext().prec 设定有...
  • Decimal

    2015-11-23 22:03:01
    python 中处理浮点数常用方法是float,但是由于计算机保存浮点数...一般情况下这样处理是没有问题,但当我们处理货币等确定精度数字时需要引入十进制数字运算decimal >>from decimal import * >> a = Decimal(str('2.
  • 如题,(decimal)100/(decimal)300*(decimal)60的运算结果是多少? 20? 是19.999999999999999999999999998 有点费解。 (double)100/(double)300*(double)60的运算结果是20 有点无法理解,求解! 感谢...
  • [python计算金额]decimal常用操作

    千次阅读 2017-10-31 10:25:03
    decimal模块 简介 decimal意思为十进制,这个模块提供了十进制浮点运算支持。 常用方法 1.可以传递给Decimal整型或者字符串参数,但不能是浮点数据,因为浮点数据本身就不准确。 2.要从浮点数据转换...
  • SQLserver 计算列以及 money decimal 区别

    千次阅读 2020-03-15 14:10:37
    sql server的 money 类型其实就是小数类型 decimal ,我不喜欢用它,因为有一次什么工具生成,发现它自动把money类型转换成了decimal类型了,与其让它转,还不如自己设计数据库时将货币类型字段设置为 decimal 类型...
  • 1.加载 $ npm install --save decimal.js ...import {Decimal} from 'decimal.js' 3.使用 // 加法 new Decimal(a).add(new Decimal(b)) // 减法 new Decimal(a).sub(new Decimal(b)) // 乘法 new Decimal(...
  • 代码如下: ...#十进制计算 from decimal import Decimal as D from decimal import getcontext print getcontext() print D(1.0)/D(3.0) print type(D(1.0)/D(3.0)) print (D(1.0)/D(3.0))*D(3

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,727
精华内容 690
关键字:

decimal计算