天啊，数据类型！高手看看！答对马上给分！

Question

天啊，数据类型！
有两组数据如下：
var
  IntA,IntB:LongInt;
  StrC:String;IntA:=12345678901234567890123456789012345678901234567890;
IntB:=12345678901234567890;我的目的是
StrC:=StrToInt64(IntA mod IntB);可是IntA和IntB的数据类型总是出错，高手看看！答对马上给分！

Answer 1

无符号的INT64只能表示0~ 18446744073709551615这种大数乘除你自己定义数据类型和乘除算法吧。

Answer 2

天呀！！！你的数太大了！换种数据类型吧，
另外你的StrC:=StrToInt64(IntA mod IntB);语句中的函数是不是写反了！！应该是整数类型转换为字符类型吧！

Answer 3

to:xdf_hubei(残月) : 我也想要这么多MM！
to:halfdream(哈欠) ：怎么自己定义数据类型和乘除算法吧？
to:klyh(风笛) ：没有写反，就是要得出这个余数的整数！
to:liner44(毛飞) : 你的数组理论能不能说详细一点，或给个例子呀！
谢谢大家了，分不够再加！

Answer 4

LongInt是32位的, Delphi只有Int64是64位的.
向你这种非常规的用法Borland的程序员们也没想到...
自己编程解决吧, 我帮你想想... 我记得以前看过一篇文章, 有种方法可以用10位计算器算大于10位的乘除运算...

Answer 5

IntA:=12345678901234567890123456789012345678901234567890;
IntB:=12345678901234567890;你是草草的举了个例子, 还是真要算这个数?
如果真是这两个数的话, 口算就能算出来, 余数是1234567890.
(IntA = IntB*E30 + IntB*E10 + 1234567890)

Answer 6

TO:zousoft(凶狠汤) 
这个不过是一个例子，真正的数字比这个要复杂几十倍，还要大得多，天啊，怎么办？还请各位大哥多帮忙？答对马上给分！

Answer 7

最近比较忙, 不过我还是抽空帮你想想.
我打算遍一个DLL文件, 用来计算超长整数的四则运算. 我现在已经编好了加法, 可以处理大约10的2亿次方的整数, 这个范围足够你用的了吧. 其他的我有时间再编, 你先把信箱留下, 我编好了发给你, 好吗?

Answer 8

TO: zousoft(凶狠汤) 非常感谢！

Answer 9

呵呵，这不是Object Pascal的错。

Answer 10

自已看看delphi的数据类型定义

Answer 11

比较简单的方法用Delphi中的字符串对象(string)处理http://www.csdn.net/Develop/article/17/17108.shtm看看吧~~~

Answer 12

!!@@什么? 有人编过了?!! 那我还费什么劲...
不过可以参考一下, 我用的是AnsiString, 范围比String大.
刚又编好了乘法, 不过现在要好好研究一下了, 楼上推荐的程序好像还能算实数, 呃.. 不错.

Answer 13

错了,默认的编译开关处于{H+},这时String等同于AnsiString~~~纯属娱乐,加法和乘法是老版主zswang(伴水)写的,减法和除法是我写的

Answer 14

哈哈，有没有搞过中学信息学奥赛的人咯，这就是其中的一个基础题，必须知道的“高精度的加减乘除运算。“加，减，乘都很减单，除法有点复杂就是：如果除数也是字符型的，就要用到高精度的乘法和减法，所以写个单元是不错的想法，最近忙考托，没时间写代码，就把思路说说了：
用两个字符串输入要算的数，存入两个数组中，一位一位的算，（我以前做的PASCAL代码找找不着了，）注意处理进位和两个加数的位数不一定相同，减法注意正负，乘法注意得数别超过了数组范围。除法注意不一定除得尽，所以到了一定的精度记得停止循环

Answer 15

如果当年有机会参加信息学奥赛,说不定就有机会保送清华,北大什么的了,也没啥,现在的发展机会也不差正是因为如此,才用String,而非字符数组,String可储存的数据长度可是2G~~~楼主还是自己设计出程序试试看吧,想到方法后,写除法我也就花了几十分钟而已

Answer 16

暂不支持小数, 近期改进.
function LongIO(s: AnsiString): AnsiString;   //输入输出倒续转换
var
  i: integer;
begin
  result:='';
  for i:= Length(s) downto 1 do
    result:= result+s[i];
end;function FormatIO(s: AnsiString): AnsiString;
var
  i: integer;
begin
  //去掉头部多余0
  i:= 1;
  while (i<=Length(s)) and (s[i]='0') do  //寻找头部的多余0
    inc(i);
  s:= Copy(s, i, Length(s)-i+1);  result:= s;
end;function LongAdd(A, B: AnsiString): AnsiString;
var
  minArray, i, carry: integer;
function myAdd(a, b: char; var carry: integer): char;
var
  temp_ord: integer;
begin
  temp_ord:= ord(a)+ord(b)+carry;  //ASCII码求和
  carry:= 0;  //清空进位
  if temp_ord>=106 then   //判断是否进位, 106=ord(0)+ord(0)+10
    begin
      carry:= 1;
      temp_ord:= temp_ord-10;  //去掉十位
    end;
  result:= chr(temp_ord-48);
end;
begin
  A:= LongIO(FormatIO(A));   //转换输入量
  B:= LongIO(FormatIO(B));
  //计算被加数与加数的最小位数作为第一遍的循环次数
  if Length(A)>=Length(B) then
    minArray:= Length(B)
  else
    minArray:= Length(A);
  //第一次循环开始
  carry:= 0;   //初始化进位
  result:='';   //初始化结果
  for i:= 1 to minArray do
    result:= result+myAdd(A[i], B[i], carry);
  //第二次循环开始, 用于处理位数不等情况下的剩余位
  if Length(A)>minArray then
    for i:= minArray+1 to Length(A) do
      result:= result+myAdd(A[i], '0', carry);
  if Length(B)>minArray then
    for i:= minArray+1 to Length(B) do
      result:= result+myAdd(B[i], '0', carry);
  //输出最高位进位
  if carry>0 then
    result:= result+'1';
  result:= FormatIO(LongIO(result));   //转换输出
end;function LongSub(A, B: AnsiString): AnsiString;
var
  i, carry, c: integer;
  temps: AnsiString;
function Compare(A, B: AnsiString): integer;   //0< 1= 2>
var
  i: integer;
begin
  if Length(A)>Length(B) then
    begin
      result:= 2;
      exit;
    end;
  if Length(A)<Length(B) then
    begin
      result:= 0;
      exit;
    end;
  //Length(A)=Length(B)
  for i:= Length(A) downto 1 do
    begin
      if A[i]=B[i] then
        continue;
      if A[i]>B[i] then
        result:= 2
      else
        result:= 0;
      exit;
    end;
  //A=B
  result:= 1;
end;
function mySub(a, b: char; var carry: integer): char;
var
  temp_ord: integer;
begin
  temp_ord:= ord(a)-ord(b)-carry;  //ASCII码求差
  carry:= 0;  //清空借位
  if temp_ord<0 then   //判断是否借位
    begin
      carry:= 1;
      temp_ord:= temp_ord+10;  //去掉负数
    end;
  result:= chr(temp_ord+48);
end;
begin
  A:= LongIO(FormatIO(A));   //转换输入量
  B:= LongIO(FormatIO(B));
  //判断被减数与减数, 大的为被减数
  c:= Compare(A, B);
  case c of
    0: begin  //A<B
         temps:= A;
         A:= B;
         B:= temps;
       end;
    1: begin  //A=B
         result:= '0';
         exit;
       end;
  end;
  //第一次循环开始
  carry:= 0;   //初始化借位
  result:='';   //初始化结果
  for i:= 1 to Length(B) do   //Length(B)=minArray
    result:= result+mySub(A[i], B[i], carry);
  //第二次循环开始, 用于处理位数不等情况下的剩余位
  if Length(A)>Length(B) then
    for i:= Length(B)+1 to Length(A) do
      result:= result+mySub(A[i], '0', carry);
  //输出最高位进位
  if c=0 then
    result:= result+'-';
  result:= FormatIO(LongIO(result));   //转换输出
end;function LongMul(A, B: AnsiString): AnsiString;
var
  i, j, carry: integer;
  temp_result: array of AnsiString;
function myMul(a, b: char; var carry: integer): string;
var
  temp: integer;
begin
  temp:= StrToInt(a)*StrToInt(b)+carry;
  //处理进位
  carry:= temp div 10;
  temp:= temp mod 10;
  result:= IntToStr(temp);
end;
begin
  A:= LongIO(FormatIO(A));   //转换输入量
  B:= LongIO(FormatIO(B));
  for i:=1 to Length(B) do
    begin
      carry:= 0;  //初始化进位
      SetLength(temp_result, i);  //设置分步乘积的累加
      for j:= 1 to i-1 do   //设置移位累加补零
        temp_result[i-1]:= temp_result[i-1]+'0';
      for j:= 1 to Length(A) do     //分步相乘
        temp_result[i-1]:= temp_result[i-1]+myMul(B[i], A[j], carry);
      //输出最高位进位
      if carry>0 then
        temp_result[i-1]:= temp_result[i-1]+IntToStr(carry);
    end;
  //进行累加
  result:='0';
  for i:= 0 to Length(temp_result)-1 do
    result:= LongAdd(result, LongIO(temp_result[i]));  //转换输出
  result:= FormatIO(result);
end;function LongDiv(A, B: AnsiString; var Remainder: AnsiString): AnsiString;
var
  i: integer;
function myDiv(a, b: AnsiString; var Remainder: AnsiString): string;
var
  temp: integer;  //商
  temp_r: AnsiString;  //临时余数
begin
  temp:= 0;
  Remainder:= a;
  temp_r:= LongSub(a, b);
  while temp_r[1]<>'-' do  //没减过头
    begin
      inc(temp);
      Remainder:= temp_r;
      temp_r:= LongSub(Remainder, b);
    end;
  result:= IntToStr(temp);
end;
begin
  //除法从高位算起, 所以无需LongIO
  A:= FormatIO(A);
  B:= FormatIO(B);
  Remainder:= '';  //初始化减法余数
  result:= '';  //初始化商
  for i:=1 to Length(A) do
    begin
      Remainder:= Remainder+A[i];   //余数加新位
      result:= result+myDiv(Remainder, B, Remainder);
    end;
  result:= FormatIO(result);
  Remainder:= FormatIO(Remainder);
end;