大数的加法与乘法

APPLEUFO

用的是小学老师黑板上教的方法啦，看代码
两个简单的函数就可以实现相加，相乘
没用那个大数支持

捣鼓出了加法与乘法，理论上两亿个数字相加，相乘都是OK的，文本型没有溢出嘛ps:代码旧了 两个跳出循环 可以删除

  

调试输出 (四则运算_加法 (“123456789123456789123456789”, “987654321123456789”))
调试输出 (“xxxxxxxxxxxxxxxxxxxxx”)
调试输出 (四则运算_乘法 (“123456789987654321”, “159753456852”))

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> 调试输出 (四则运算_加法 (“123456789123456789123456789”, “987654321123456789”))<br /> 调试输出 (“xxxxxxxxxxxxxxxxxxxxx”)<br /> 调试输出 (四则运算_乘法 (“123456789987654321”, “159753456852”))

* “123456790111111110246913578”
* “xxxxxxxxxxxxxxxxxxxxx”
* “19722648972379160182564857492”

  

子程序名	返回值类型	公开	备 注
四则运算_加法	文本型		注意：加数 与 被加数 都不能为 空文本！
参数名	类 型	参考	可空	数组	备 注
参数_a	文本型
参数_b	文本型

变量名	类 型	静态	数组	备 注
局变_格式化a	文本型
局变_格式化b	文本型
局变_a	整数型		0
局变_b	整数型		0
局变_c	整数型		0	结果
n1	整数型
ls	整数型			相加结果
局变_十位数	整数型			进一位，会加入每次相加的结果中去
局变_个位数	整数型
局变_合并数组文本	文本型

如果 (参数_a ＝ “”)
局变_格式化a ＝ “0”
局变_格式化a ＝ 参数_a

如果 (参数_b ＝ “”)
局变_格式化b ＝ “0”
局变_格式化b ＝ 参数_b

子程序_格式化一对文本长度 (局变_格式化a, 局变_格式化b)  ' 将两个数字格式化为一样长度的文本，缺的部分前面补0
子程序_文本转化为数组 (局变_格式化a, 局变_a)  ' 生成3个数组，c 为结果数组
子程序_文本转化为数组 (局变_格式化b, 局变_b)
重定义数组 (局变_c, 假, 取数组成员数 (局变_a))  ' 数组成员数，只要定义为a或B的个数即可，因为每次都是个位数相加
变量循环首 (取数组成员数 (局变_a), 1, -1, n1)  ' 将两个数组合并 ！！！！！！！！为 局变_c
ls ＝ 局变_a [n1] ＋ 局变_b [n1] ＋ 局变_十位数
如果 (n1 ＝ 1)
局变_c [n1] ＝ ls  ' 这是临界，等于第一个运算的时候，可以不用分解数字了
跳出循环 ()


子程序_分解数字 (ls, 局变_十位数, 局变_个位数)  ' 这是正常情况下
局变_c [n1] ＝ 局变_个位数

变量循环尾 ()
局变_合并数组文本 ＝ 子程序_数组转化为文本 (局变_c)
返回 (局变_合并数组文本)

子程序名	返回值类型	公开	备 注
四则运算_乘法	文本型
参数名	类 型	参考	可空	数组	备 注
参数_被乘数	文本型
参数_乘数	文本型

变量名	类 型	静态	数组	备 注
局变_a	整数型		0	a
局变_b	整数型		0	b
局变_c	整数型		0	c= a*b
n1	整数型
m1	整数型
ls	整数型			9*9表里面的运算
局变_十位数	整数型
局变_个位数	整数型
局变_补零个数	整数型			在末尾补零
局变_数组合并后文本	文本型
t1	整数型
局变_不断相加的结果	文本型			最终结果

子程序_文本转化为数组 (参数_被乘数, 局变_a)
子程序_文本转化为数组 (参数_乘数, 局变_b)
' 调试输出 (局变_被乘数, 局变_乘数)
变量循环首 (取数组成员数 (局变_b), 1, -1, m1)
局变_十位数 ＝ 0  ' 上一行被乘数为最前面一个数字时，就不要留进几位的小数字（局变_十位数）了
重定义数组 (局变_c, 假, 取数组成员数 (局变_a))  ' 最后还要咔嚓掉前面为0的数组
变量循环首 (取数组成员数 (局变_a), 1, -1, n1)
ls ＝ 局变_a [n1] × 局变_b [m1] ＋ 局变_十位数  ' 会是a =1 2 3 4  逐个乘以b =5 这样的节奏
如果 (n1 ＝ 1)
局变_c [n1] ＝ ls  ' 到最前面一个结果了
跳出循环 ()


子程序_分解数字 (ls, 局变_十位数, 局变_个位数)
局变_c [n1] ＝ 局变_个位数  ' 正常

变量循环尾 ()
局变_数组合并后文本 ＝ 子程序_数组转化为文本 (局变_c)
局变_数组合并后文本 ＝ 局变_数组合并后文本 ＋ 取重复文本 (局变_补零个数, “0”)
局变_补零个数 ＝ 局变_补零个数 ＋ 1  ' 个位数相乘不必补零(看前面已经加了0个零)，十位数补1个，百位数补两个，以此类推……
局变_不断相加的结果 ＝ 四则运算_加法 (局变_不断相加的结果, 局变_数组合并后文本)
变量循环尾 ()
返回 (局变_不断相加的结果)

.版本 2<br /> <br /> .子程序 四则运算_加法, 文本型, , 注意：加数 与 被加数 都不能为 空文本！<br /> .参数 参数_a, 文本型<br /> .参数 参数_b, 文本型<br /> .局部变量 局变_格式化a, 文本型<br /> .局部变量 局变_格式化b, 文本型<br /> .局部变量 局变_a, 整数型, , "0"<br /> .局部变量 局变_b, 整数型, , "0"<br /> .局部变量 局变_c, 整数型, , "0", 结果<br /> .局部变量 n1, 整数型<br /> .局部变量 ls, 整数型, , , 相加结果<br /> .局部变量 局变_十位数, 整数型, , , 进一位，会加入每次相加的结果中去<br /> .局部变量 局变_个位数, 整数型<br /> .局部变量 局变_合并数组文本, 文本型<br /> <br /> .如果 (参数_a ＝ “”)<br />     局变_格式化a ＝ “0”<br /> .否则<br />     局变_格式化a ＝ 参数_a<br /> .如果结束<br /> <br /> .如果 (参数_b ＝ “”)<br />     局变_格式化b ＝ “0”<br /> .否则<br />     局变_格式化b ＝ 参数_b<br /> .如果结束<br /> <br /> 子程序_格式化一对文本长度 (局变_格式化a, 局变_格式化b)  ' 将两个数字格式化为一样长度的文本，缺的部分前面补0<br /> <br /> 子程序_文本转化为数组 (局变_格式化a, 局变_a)  ' 生成3个数组，c 为结果数组<br /> 子程序_文本转化为数组 (局变_格式化b, 局变_b)<br /> 重定义数组 (局变_c, 假, 取数组成员数 (局变_a))  ' 数组成员数，只要定义为a或B的个数即可，因为每次都是个位数相加<br /> <br /> <br /> .变量循环首 (取数组成员数 (局变_a), 1, -1, n1)  ' 将两个数组合并 ！！！！！！！！为 局变_c<br /> <br />     ls ＝ 局变_a [n1] ＋ 局变_b [n1] ＋ 局变_十位数<br /> <br />     .如果 (n1 ＝ 1)<br />         局变_c [n1] ＝ ls  ' 这是临界，等于第一个运算的时候，可以不用分解数字了<br />         跳出循环 ()<br />     .否则<br /> <br />         子程序_分解数字 (ls, 局变_十位数, 局变_个位数)  ' 这是正常情况下<br />         局变_c [n1] ＝ 局变_个位数<br />     .如果结束<br /> <br /> .变量循环尾 ()<br /> <br /> 局变_合并数组文本 ＝ 子程序_数组转化为文本 (局变_c)<br /> 返回 (局变_合并数组文本)<br /> <br /> .子程序 四则运算_乘法, 文本型<br /> .参数 参数_被乘数, 文本型<br /> .参数 参数_乘数, 文本型<br /> .局部变量 局变_a, 整数型, , "0", a<br /> .局部变量 局变_b, 整数型, , "0", b<br /> .局部变量 局变_c, 整数型, , "0", c= a*b<br /> .局部变量 n1, 整数型<br /> .局部变量 m1, 整数型<br /> .局部变量 ls, 整数型, , , 9*9表里面的运算<br /> .局部变量 局变_十位数, 整数型<br /> .局部变量 局变_个位数, 整数型<br /> .局部变量 局变_补零个数, 整数型, , , 在末尾补零<br /> .局部变量 局变_数组合并后文本, 文本型<br /> .局部变量 t1, 整数型<br /> .局部变量 局变_不断相加的结果, 文本型, , , 最终结果<br /> <br /> 子程序_文本转化为数组 (参数_被乘数, 局变_a)<br /> 子程序_文本转化为数组 (参数_乘数, 局变_b)<br /> ' 调试输出 (局变_被乘数, 局变_乘数)<br /> <br /> .变量循环首 (取数组成员数 (局变_b), 1, -1, m1)<br /> <br />     局变_十位数 ＝ 0  ' 上一行被乘数为最前面一个数字时，就不要留进几位的小数字（局变_十位数）了<br />     重定义数组 (局变_c, 假, 取数组成员数 (局变_a))  ' 最后还要咔嚓掉前面为0的数组<br /> <br /> <br />     .变量循环首 (取数组成员数 (局变_a), 1, -1, n1)<br /> <br />         ls ＝ 局变_a [n1] × 局变_b [m1] ＋ 局变_十位数  ' 会是a =1 2 3 4  逐个乘以b =5 这样的节奏<br /> <br />         .如果 (n1 ＝ 1)<br />             局变_c [n1] ＝ ls  ' 到最前面一个结果了<br />             跳出循环 ()<br />         .否则<br /> <br />             子程序_分解数字 (ls, 局变_十位数, 局变_个位数)<br />             局变_c [n1] ＝ 局变_个位数  ' 正常<br />         .如果结束<br /> <br />     .变量循环尾 ()<br /> <br />     局变_数组合并后文本 ＝ 子程序_数组转化为文本 (局变_c)<br />     局变_数组合并后文本 ＝ 局变_数组合并后文本 ＋ 取重复文本 (局变_补零个数, “0”)<br /> <br />     局变_补零个数 ＝ 局变_补零个数 ＋ 1  ' 个位数相乘不必补零(看前面已经加了0个零)，十位数补1个，百位数补两个，以此类推……<br /> <br />     局变_不断相加的结果 ＝ 四则运算_加法 (局变_不断相加的结果, 局变_数组合并后文本)<br /> .变量循环尾 ()<br /> <br /> 返回 (局变_不断相加的结果)

aidexinhao

看看咋样呢  

邪意邪神

抢个沙发拿个源码