C# 高精度减法 支持小数(待优化)

是现实思路

1,先小数点补位,8913758923475893274958738945793845-4893127498372459823745324532453245.284929384729837498237492 => 8913758923475893274958738945793845.000000000000000000000000-4893127498372459823745324532453245.284929384729837498237492.

2,进行计算,最后补符号

        public static void BuweiF(ref string a, ref string b)
        {
            int al = a.Length;
            int bl = b.Length;
            string[] c = a.Split(‘.‘);
            string[] d = b.Split(‘.‘);
            int i = al - c[0].Length;
            int j = bl - d[0].Length;
            if (i != 0 && j != 0)
            {
                if (i > j)
                {
                    while (i != j)
                    {
                        b += "0";
                        j++;
                    }
                }
                else
                {
                    while (i != j)
                    {
                        a += "0";
                        i++;
                    }
                }
            }
            else if (i != 0 && j == 0)
            {
                b += ".";
                j++;
                while (i != j)
                {
                    b += "0";
                    j++;
                }
            }
            else if (i == 0 && j != 0)
            {
                a += ".";
                i++;
                while (i != j)
                {
                    a += "0";
                    i++;
                }
            }
            //Console.WriteLine(a);
           // Console.WriteLine(b);
        }
  public static char[] Diff(string a, string b)
        {
            BuweiF(ref a, ref b);
            List<char> item = new List<char>();
            int al = a.Length;
            int bl = b.Length;
            int r = 0;
            int jw = 0;//退位
            bool fushu = false;
            if (al > bl)
            {
                do
                {
                    if (al > 0 && bl > 0)
                    {
                        if (a[al - 1] == ‘.‘)
                        {
                            r = ‘.‘;
                        }
                        else
                        {
                            r = (int)a[al - 1] - (int)b[bl - 1] - jw;
                            jw = 0;
                            if (r < 0)
                            {
                                r = 10 + r;
                                jw++;
                            }
                        }
                    }
                    else if (al > 0 && bl <= 0)
                    {
                        r = a[al - 1] - 48 - jw;
                        jw = 0;
                        if (r < 0)
                        {
                            r = 10 + r;
                            jw++;
                        }
                    }

                    if (r == 46)
                    {
                        item.Add(Convert.ToChar(r));
                    }
                    else
                    {
                        item.Add(Convert.ToChar(r.ToString()));
                    }
                    al--; bl--;
                } while (al > 0 || bl > 0);
            }
            else if (al < bl)
            {
                fushu = true;
                do
                {
                    if (al > 0 && bl > 0)
                    {
                        if (b[bl - 1] == ‘.‘)
                        {
                            r = ‘.‘;
                        }
                        else
                        {
                            r = (int)b[bl - 1] - (int)a[al - 1] - jw;
                            jw = 0;
                            if (r < 0)
                            {
                                r = 10 + r;
                                jw++;
                            }
                        }
                    }
                    else if (bl > 0 && al <= 0)
                    {
                        r = b[bl - 1] - 48 - jw;
                        jw = 0;
                        if (r < 0)
                        {
                            r = 10 + r;
                            jw++;
                        }
                    }

                    if (r == 46)
                    {
                        item.Add(Convert.ToChar(r));
                    }
                    else
                    {
                        item.Add(Convert.ToChar(r.ToString()));
                    }
                    al--; bl--;
                } while (al > 0 || bl > 0);
            }
            else
            {
                if (a[0] > b[0])
                {
                    do
                    {
                        if (al > 0 && bl > 0)
                        {
                            if (a[al - 1] == ‘.‘)
                            {
                                r = ‘.‘;
                            }
                            else
                            {
                                r = (int)a[al - 1] - (int)b[bl - 1] - jw;
                                jw = 0;
                                if (r < 0)
                                {
                                    r = 10 + r;
                                    jw++;
                                }
                            }
                        }
                        else if (al > 0 && bl <= 0)
                        {
                            r = a[al - 1] - 48 - jw;
                            jw = 0;
                            if (r < 0)
                            {
                                r = 10 + r;
                                jw++;
                            }
                        }

                        if (r == 46)
                        {
                            item.Add(Convert.ToChar(r));
                        }
                        else
                        {
                            item.Add(Convert.ToChar(r.ToString()));
                        }
                        al--; bl--;
                    } while (al > 0 || bl > 0);
                }
                else
                {
                    fushu = true;
                    do
                    {
                        if (al > 0 && bl > 0)
                        {
                            if (b[bl - 1] == ‘.‘)
                            {
                                r = ‘.‘;
                            }
                            else
                            {
                                r = (int)b[bl - 1] - (int)a[al - 1] - jw;
                                jw = 0;
                                if (r < 0)
                                {
                                    r = 10 + r;
                                    jw++;
                                }
                            }
                        }
                        else if (bl > 0 && al <= 0)
                        {
                            r = b[bl - 1] - 48 - jw;
                            jw = 0;
                            if (r < 0)
                            {
                                r = 10 + r;
                                jw++;
                            }
                        }

                        if (r == 46)
                        {
                            item.Add(Convert.ToChar(r));
                        }
                        else
                        {
                            item.Add(Convert.ToChar(r.ToString()));
                        }
                        al--; bl--;
                    } while (al > 0 || bl > 0);
                }
            }
            if (item[item.Count() - 1] == ‘0‘ && item[item.Count() - 2] != ‘.‘)
            {
                item.RemoveAt(item.Count() - 1);
            }
            if (fushu)
            {
                item.Add(‘-‘);
            }
            return item.ToArray();

        }
时间: 2024-10-10 09:35:27

C# 高精度减法 支持小数(待优化)的相关文章

C# 高精度乘法 支持小数(待优化)

将N*N乘法转化为(N*n1)+(N*n2)....(N*nn) 乘完后在补充小数点 public static char[] SumF(string a, string b) { BuweiF(ref a, ref b);//小数点后补位 List<char> item = new List<char>(); List<char> ritems = new List<char>(); int al = a.Length; int bl = b.Length

C# 高精度加法 支持小数(待优化)

直接上代码 实现思路: 1.首先小数点补 位,9223372036854775808.9+9223372036854775808.9223372036854775808 => 9223372036854775808.900000000000000000+9223372036854775808.9223372036854775808 2.然后开始按位进行计算,进位数放入jw,在下一位计算时加上 public static char[] Sum(string a, string b) { retur

高精度减法

高精度减法(a-b)(a>b且a,b均为正整数) .从键盘读入两个正整数,求它们的差. 分析:类似加法,可以用竖式求减法.在做减法运算时,需要注意的是:被减数必须比减数大,同时需要处理借位.高精度减法的参考程序: 1 program exam2; 2 const 3 max=200; 4 var 5 a,b,c:array[1..max] of 0..9; 6 n,n1,n2:string; 7 lena,lenb,lenc,i,x:integer; 8 begin 9 readln(n1);

C#.NET 大型通用信息化系统集成快速开发平台 4.1 版本 - 大数据支持分表优化

公司的短信平台,数据量越来越大了,需要对数据进行一些优化,下面是拆分后的数据库量参考. 新开发的软件模块,必须支持分表,拆表的功能一个数据表里,不适合保存1000万以上的记录新开发的业务模块,能分表的全分表,否则,将来我们无法用其他小型数据库,例如mysql 现在系统的短信已经进行了拆表接着打算把日志也进行拆表确保数据库里,没有庞大的表,随时可以切换数据库 每个人把自己负责的事情,做到自己能力的及至,做到部门能力的及至,公司能力的及至,就很有希望了有时候我说话很随意,但是一般会注意,我说出去的话

一、四则运算栈实现,支持小数、负数

四则运算栈实现,支持小数.负数,经过测试,暂时没发现错误! 思路: 1.去掉字符串中的空格,将字符串按照运算符和数字保存到vector<string>中: 2.判断字符串是否符合四则运算的表达式: 3.栈实现:数字栈.运算符栈,从左到右扫描中缀表达式: 数字:直接入栈:运算符: (1)”(“:直接入栈: (2)”)“:弹出()之间的运算符,进行运算: (3)”+-*/“:如果当前运算符优先级<栈顶运算符优先级,则数字栈弹出两个数和栈顶运算符进行运算,并将结果存入数字运算符,再将当前运算符

大数减法(含小数)

正数减法 描述: 两个任意长度的正数相减,这两个正数可以带小数点,也可以是整数,请输出结果.输入的字符串中,不会出现除了数字与小数点以外的其它字符,不会出现多个小数点以及小数点在第一个字符的位置等非法情况,所以考生的程序中无须考虑输入的数值字符串非法的情况. 详细要求以及约束:1.输入均为正数,但输出可能为负数:2.输入输出均为字符串形式:3.如果输出是正数则不需要带符号,如果为负数,则输出的结果字符串需要带负号例如:2.2-1.1 直接输出为"1.1",1.1-2.2 则需要输出为&

洛谷 P2142 高精度减法 题解

此文为博主原创题解,转载时请通知博主,并把原文链接放在正文醒目位置. 题目链接 :https://www.luogu.org/problem/show?pid=1581 题目描述 高精度减法 输入输出格式 输入格式: 两个整数a,b(第二个可能比第一个大) 输出格式: 结果(是负数要输出负号) 输入输出样例 输入样例#1: 2 1 输出样例#1: 1 说明 20%数据a,b在long long范围内 100%数据0<a,b<=10的10000次方 AC代码: 1 #include<alg

C++ 该死的高精度减法

没看书直接硬上的结果是,一个简单的高精度减法我用了一个多小时只写了一个90分的代码.之前准备NOIP的时候确实是学了,可惜现在早就还给老师了. 结果回家一看标准程序,顿时有种想哭的赶脚. 先上我的90分代码: //高精度减法 #include<iostream> #include<cstring> #include<cstdlib> #include<cmath> #include<algorithm> #include<vector>

二柱子问题扩充:1、题目避免重复; 2、可定制(数量/打印方式); 3、可以控制下列参数: 是否有乘除法、是否有括号、 数值范围、加减有无负数、除法有无余数、否支持分数 (真分数, 假分数, …)、是否支持小数 (精确到多少位)、打印中每行的间隔可调整;

程序设计思想 程序的主要设计思想为用字符串数组保存生成的运算题,将操作数采用单独算法处理,然后进行类型转换和操作符一起存入数组中,鉴于字符串的特性,可以对字符串的长度进行随意添加而不必考虑长度问题,最后进行字符串数组的输出产生客户要求的运算题; 源代码 #include<stdlib.h> #include<conio.h> #include<time.h> #include<iostream> #include<string> #include