zoukankan      html  css  js  c++  java
  • 关于C#的大数值处理

    using System;
    using System.Text.RegularExpressions;

    [System.Serializable]
    public class Int :IComparable
    {
    public string Body = "0";

    public static readonly Int Zero = new Int("0");

    public int Length
    {
    get
    {
    if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
    return this.Body.Length - 1;
    return this.Body.Length;
    }
    }

    public int this[int index]
    {
    get
    {
    if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
    return (int)this.Body[index + 1] - 48;
    return (int)this.Body[index] - 48;
    }
    }

    public bool IsPositive
    {
    get
    {
    return (int)this.Body[0] != 45 || !(new Int(this.Body.Substring(1)) != (Int)0L);
    }
    }

    public Int()
    {
    }

    public Int(string numStr)
    {
    if (string.IsNullOrEmpty(numStr))
    this.Body = "0";
    else
    this.Body = this.Trim(numStr);
    }

    public static implicit operator string(Int source)
    {
    return source.Body;
    }

    public static implicit operator Int(long real)
    {
    return new Int(real.ToString());
    }

    public static implicit operator Int(string real)
    {
    return new Int(real);
    }

    public static bool operator >(Int left, Int right)
    {
    if (left.IsPositive && !right.IsPositive && left.Absolute().Body != "0" && right.Absolute().Body != "0")
    return true;
    if (left.IsPositive && right.IsPositive)
    {
    if (left.Length > right.Length)
    return true;
    if (left.Length != right.Length)
    return false;
    for (int index = 0; index < left.Length; ++index)
    {
    if (left[index] > right[index])
    return true;
    if (left[index] < right[index])
    return false;
    }
    }
    else if (!left.IsPositive && !right.IsPositive)
    {
    if (left.Length < right.Length)
    return true;
    if (left.Length != right.Length)
    return false;
    for (int index = 0; index < left.Length; ++index)
    {
    if (left[index] < right[index])
    return true;
    if (left[index] > right[index])
    return false;
    }
    }
    else if (left.IsPositive && !right.IsPositive && (left.Absolute().Body == "0" && right.Absolute().Body != "0" || left.Absolute().Body != "0" && right.Absolute().Body == "0"))
    return true;
    return false;
    }

    public static bool operator <(Int left, Int right)
    {
    return right > left;
    }

    public static bool operator >=(Int left, Int right)
    {
    return left > right || left == right;
    }

    public static bool operator <=(Int left, Int right)
    {
    return left < right || left == right;
    }

    public static bool operator ==(Int left, Int right)
    {
    return !(left > right) && !(left < right);
    }

    public static bool operator !=(Int left, Int right)
    {
    return left > right || left < right;
    }

    public static bool operator >(Int left, object right)
    {
    return left > new Int(right.ToString());
    }

    public static bool operator >(object left, Int right)
    {
    return new Int(left.ToString()) > right;
    }

    public static bool operator <(Int left, object right)
    {
    return left < new Int(right.ToString());
    }

    public static bool operator <(object left, Int right)
    {
    return new Int(left.ToString()) < right;
    }

    public static bool operator >=(Int left, object right)
    {
    return left >= new Int(right.ToString());
    }

    public static bool operator >=(object left, Int right)
    {
    return new Int(left.ToString()) >= right;
    }

    public static bool operator <=(Int left, object right)
    {
    return left <= new Int(right.ToString());
    }

    public static bool operator <=(object left, Int right)
    {
    return new Int(left.ToString()) <= right;
    }

    public static bool operator ==(Int left, object right)
    {
    return left == new Int(right.ToString());
    }

    public static bool operator ==(object left, Int right)
    {
    return new Int(left.ToString()) == right;
    }

    public static bool operator !=(Int left, object right)
    {
    return left != new Int(right.ToString());
    }

    public static bool operator !=(object left, Int right)
    {
    return new Int(left.ToString()) != right;
    }
    public static string operator +(string left, Int right) {
    return string.Format("{0}{1}",left,right.Body);
    }

    public static string operator + (Int right ,string left )
    {
    return string.Format("{0}{1}", right.Body,left);
    }

    public static Int operator +(Int left, Int right)
    {
    Int Int1 = new Int();
    if (left.IsPositive && right.IsPositive)
    {
    int length = right.Length;
    if (left.Length > right.Length)
    length = left.Length;
    int num1 = 0;
    for (int index = 0; index < length; ++index)
    {
    int num2 = index >= left.Length || index >= right.Length ? (index < left.Length ? (index < right.Length ? 0 : left[left.Length - 1 - index] + num1) : right[right.Length - 1 - index] + num1) : left[left.Length - 1 - index] + right[right.Length - 1 - index] + num1;
    num1 = num2 / 10;
    int num3;
    if (index == 0)
    {
    Int Int2 = Int1;
    num3 = num2 % 10;
    string str = num3.ToString();
    Int2.Body = str;
    }
    else
    {
    Int Int2 = Int1;
    string str1 = Int1.Body;
    int startIndex = 0;
    num3 = num2 % 10;
    string str2 = num3.ToString();
    string str3 = str1.Insert(startIndex, str2);
    Int2.Body = str3;
    }
    }
    Int1.Body = Int1.Body.Insert(0, num1.ToString());
    }
    else if (left.IsPositive && !right.IsPositive)
    Int1 = left - new Int((string)right.Absolute());
    else if (!left.IsPositive && right.IsPositive)
    Int1 = right - new Int((string)left.Absolute());
    else if (!left.IsPositive && !right.IsPositive)
    Int1 = left - new Int((string)right.Absolute());
    Int1.Trim();
    return Int1;
    }

    public static Int operator -(Int left, Int right)
    {
    Int Int = new Int();
    if (left == right)
    return new Int("0");
    if (left > Int.Zero && right == Int.Zero)
    return left;
    if (left == Int.Zero && right < Int.Zero)
    return new Int((string)right.Absolute());
    if (left == Int.Zero && right > Int.Zero)
    return new Int(right.Body.Insert(0, "-"));
    if (left > Int.Zero && right > Int.Zero)
    {
    if (left > right)
    {
    int num1 = 0;
    for (int index = 0; index < left.Length; ++index)
    {
    int num2 = index >= left.Length || index >= right.Length ? (index < right.Length ? 0 : left[left.Length - 1 - index] - num1) : left[left.Length - 1 - index] - right[right.Length - 1 - index] - num1;
    num1 = num2 / 10;
    if (num2 < 0)
    {
    num1 = 1;
    num2 = 10 + num2;
    }
    Int.Body = index != 0 ? Int.Body.Insert(0, num2.ToString()) : num2.ToString();
    }
    }
    else if (left < right)
    {
    Int = right - left;
    Int.Body = Int.Body.Insert(0, "-");
    }
    }
    else if (left < Int.Zero && right < Int.Zero)
    Int = new Int((string)right.Absolute()) - new Int((string)left.Absolute());
    else if (left > Int.Zero && right < Int.Zero)
    Int = left + new Int((string)right.Absolute());
    else if (left < Int.Zero && right > Int.Zero)
    {
    Int = new Int((string)left.Absolute()) + right;
    Int.Body = Int.Body.Insert(0, "-");
    }
    Int.Trim();
    return Int;
    }

    public static Int operator *(Int left, Int right)
    {
    Int Int = new Int();
    if (left == Int.Zero || right == Int.Zero)
    return Int.Zero;
    if (left.IsPositive && right.IsPositive)
    {
    for (int index1 = right.Length - 1; index1 >= 0; --index1)
    {
    int num1 = 0;
    string numStr = "";
    for (int index2 = left.Length - 1; index2 >= 0; --index2)
    {
    int num2 = right.Absolute()[index1] * left.Absolute()[index2] + num1;
    numStr = numStr.Insert(0, (num2 % 10).ToString());
    num1 = num2 / 10;
    }
    if ((uint)num1 > 0U)
    numStr = numStr.Insert(0, num1.ToString());
    for (int index2 = 0; index2 < right.Length - 1 - index1; ++index2)
    numStr += "0";
    Int += new Int(numStr);
    }
    }
    else if (!left.IsPositive && right.IsPositive || left.IsPositive && !right.IsPositive)
    {
    Int = new Int((string)left.Absolute()) * new Int((string)right.Absolute());
    Int.Body = Int.Body.Insert(0, "-");
    }
    else if (!left.IsPositive && !right.IsPositive)
    Int = new Int((string)left.Absolute()) * new Int((string)right.Absolute());
    Int.Trim();
    return Int;
    }

    public static Int operator /(Int left, Int right)
    {
    Int Int1 = new Int();
    if (right == Int.Zero)
    throw new Exception("除零错误!");
    if (left == Int.Zero)
    return Int.Zero;
    if (right == new Int("1"))
    return left;
    if (left.IsPositive && right.IsPositive)
    {
    if (left < right)
    {
    Int1 = Int.Zero;
    }
    else
    {
    string numStr = "";
    Int Int2 = new Int(left.Body.Substring(0, right.Length - 1));
    for (int index = right.Length - 1; index < left.Length; ++index)
    {
    Int2 = Int2 * new Int("10") + new Int(left[index].ToString());
    Int2.Trim();
    int num = 0;
    for (num = 0; num < 10; ++num)
    {
    Int Int3 = right * new Int(num.ToString());
    if (Int3 > Int2)
    {
    numStr += (num - 1);
    Int2 -= right * new Int((num - 1).ToString());
    break;
    }
    if (Int3 == Int2)
    {
    numStr += num;
    Int2 = Int.Zero;
    break;
    }
    }
    if (num == 10)
    {
    numStr += (num - 1);
    Int2 -= right * new Int((num - 1).ToString());
    }
    }
    Int1 = new Int(numStr);
    }
    }
    else if (!left.IsPositive && right.IsPositive || left.IsPositive && !right.IsPositive)
    {
    Int1 = new Int((string)left.Absolute()) / new Int((string)right.Absolute());
    Int1.Body = Int1.Body.Insert(0, "-");
    }
    else if (!left.IsPositive && !right.IsPositive)
    Int1 = new Int((string)left.Absolute()) / new Int((string)right.Absolute());
    Int1.Trim();
    return Int1;
    }

    public static Int operator %(Int left, Int right)
    {
    Int Int1 = new Int();
    Int Int2 = left - left / right * right;
    Int2.Trim();
    return Int2;
    }

    public static Int operator +(Int left, object right)
    {
    return left.Body + new Int(right.ToString());
    }

    public static Int operator +(object left, Int right)
    {
    return new Int(left.ToString()) + right.Body;
    }

    public static Int operator -(Int left, object right)
    {
    return left - new Int(right.ToString());
    }

    public static Int operator -(object left, Int right)
    {
    return new Int(left.ToString()) - right;
    }

    public static Int operator *(Int left, object right)
    {
    return left * new Int(right.ToString());
    }

    public static Int operator *(object left, Int right)
    {
    return new Int(left.ToString()) * right;
    }

    public static Int operator /(Int left, object right)
    {
    return left / new Int(right.ToString());
    }

    public static Int operator /(object left, Int right)
    {
    return new Int(left.ToString()) / right;
    }

    public static Int operator %(Int left, object right)
    {
    return left % new Int(right.ToString());
    }

    public static Int operator %(object left, Int right)
    {
    return new Int(left.ToString()) % right;
    }

    public Int Absolute()
    {
    if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
    return new Int(this.Body.Substring(1));
    return this;
    }

    public void Trim()
    {
    this.Body = this.Trim(this.Body);
    }

    public string Trim(string numStr)
    {
    string str1 = numStr.Trim();
    if ((int)str1[0] == 43)
    str1 = str1.Substring(1);
    string str2 = str1;
    if ((int)str1[0] == 45)
    str2 = str1.Substring(1);
    int index = 0;
    while (index < str2.Length && (int)str2[index] == 48)
    ++index;
    if (index == str2.Length)
    return "0";
    bool flag = true;
    if ((int)str1[0] == 45)
    flag = false;
    int startIndex = 0;
    while (startIndex < str2.Length && (int)str2[startIndex] == 48)
    ++startIndex;
    string str3 = str2.Substring(startIndex);
    if (!flag)
    str3 = str3.Insert(0, "-");
    return str3;
    }

    public override string ToString()
    {
    return this.Body;
    }

    public int CompareTo(object obj)
    {
    return this == (Int)obj ? 0 : this - (Int)obj > 0 ? 1 : -1;
    }

    public Float ToFloat()
    {
    return new Float(this.Body);
    }

    public override bool Equals(object obj)
    {
    return base.Equals(obj);
    }

    public override int GetHashCode()
    {
    return base.GetHashCode();
    }
    }

    [System.Serializable]
    public class Float : Int
    {
    public static int DividResaultPrecision = 50;
    private long DotIndex = 0;
    private string BodyNoDotNoSignal = "0";

    public string IntPart
    {
    get
    {
    if (this.DotIndex <= 0L)
    return "0";
    return this.BodyNoDotNoSignal.Substring(0, (int)this.DotIndex);
    }
    }

    public string FloatPart
    {
    get
    {
    if (this.DotIndex == (long)this.BodyNoDotNoSignal.Length)
    return "0";
    if (this.DotIndex == 0L)
    return this.BodyNoDotNoSignal;
    if (this.DotIndex >= 0L)
    return this.BodyNoDotNoSignal.Substring((int)this.DotIndex);
    string str = this.BodyNoDotNoSignal;
    for (int index = 0; (long)index < -this.DotIndex; ++index)
    str = str.Insert(0, "0");
    return str;
    }
    }

    public int IntPartLength
    {
    get
    {
    return this.IntPart.Length;
    }
    }

    public int FloatPartLength
    {
    get
    {
    if (this.FloatPart.Length == 1 && (int)this.FloatPart[0] == 48)
    return 0;
    return this.FloatPart.Length;
    }
    }

    public Float()
    {
    this.DotIndex = 1L;
    this.Body = "0";
    this.BodyNoDotNoSignal = "0";
    }

    public Float(string body)
    {
    if (string.IsNullOrEmpty(body))
    this.Body = "0";
    else
    this.Body = this.Trim(body);
    Match match = Regex.Match(this.Body, "[1-9]");
    int num = this.Body.IndexOf('.');
    this.DotIndex = num < 0 ? (long)(this.Body.Length - match.Index) : (num <= match.Index ? (long)(num - match.Index + 1) : (long)(num - match.Index));
    this.BodyNoDotNoSignal = this.Body.Substring(match.Index);
    int startIndex = this.BodyNoDotNoSignal.IndexOf('.');
    if (startIndex >= 0)
    this.BodyNoDotNoSignal = this.BodyNoDotNoSignal.Remove(startIndex, 1);
    this.BodyNoDotNoSignal = base.Trim(this.BodyNoDotNoSignal);
    }

    public static implicit operator string(Float source)
    {
    return source.Body;
    }

    public static implicit operator Float(long real)
    {
    return new Float(real.ToString());
    }

    public static implicit operator Float(string real)
    {
    return new Float(real);
    }

    public static implicit operator Float(float real)
    {
    return new Float(real.ToString());
    }

    public static bool operator >(Float left, Float right)
    {
    if (left.IsPositive && right.IsPositive)
    {
    if (new Int(left.IntPart) > new Int(right.IntPart))
    return true;
    int length1 = left.FloatPart.Length;
    int length2 = right.FloatPart.Length;
    string floatPart1 = left.FloatPart;
    string floatPart2 = right.FloatPart;
    if (length1 > length2)
    {
    for (int index = length2; index < length1; ++index)
    floatPart2 += "0";
    }
    else if (length1 < length2)
    {
    for (int index = length1; index < length2; ++index)
    floatPart1 += "0";
    }
    return new Int(floatPart1) > new Int(floatPart2);
    }
    return left.IsPositive && !right.IsPositive || (left.IsPositive || !right.IsPositive) && (!left.IsPositive && !right.IsPositive && new Float((string)right.Absolute()) > new Float((string)left.Absolute()));
    }

    public static bool operator <(Float left, Float right)
    {
    return right > left;
    }

    public static bool operator ==(Float left, Float right)
    {
    return !(left > right) && !(left < right);
    }

    public static bool operator !=(Float left, Float right)
    {
    return left > right || left < right;
    }

    public static bool operator >=(Float left, Float right)
    {
    return left < right || left == right;
    }

    public static bool operator <=(Float left, Float right)
    {
    return left > right || left == right;
    }

    public static bool operator >(Float left, object right)
    {
    return left > new Float(right.ToString());
    }

    public static bool operator >(object left, Float right)
    {
    return new Float(left.ToString()) > right;
    }

    public static bool operator <(Float left, object right)
    {
    return left < new Float(right.ToString());
    }

    public static bool operator <(object left, Float right)
    {
    return new Float(left.ToString()) < right;
    }

    public static bool operator ==(Float left, object right)
    {
    return left == new Float(right.ToString());
    }

    public static bool operator ==(object left, Float right)
    {
    return new Float(left.ToString()) == right;
    }

    public static bool operator !=(Float left, object right)
    {
    return left != new Float(right.ToString());
    }

    public static bool operator !=(object left, Float right)
    {
    return new Float(left.ToString()) != right;
    }

    public static bool operator >=(Float left, object right)
    {
    return left >= new Float(right.ToString());
    }

    public static bool operator >=(object left, Float right)
    {
    return new Float(left.ToString()) >= right;
    }

    public static bool operator <=(Float left, object right)
    {
    return left <= new Float(right.ToString());
    }

    public static bool operator <=(object left, Float right)
    {
    return new Float(left.ToString()) <= right;
    }

    public static Float operator +(Float left, Float right)
    {
    if (left == (Float)0L)
    return right;
    if (right == (Float)0L)
    return left;
    string numStr1 = left.Body;
    int startIndex1 = numStr1.IndexOf('.');
    if (startIndex1 >= 0)
    numStr1 = numStr1.Remove(startIndex1, 1);
    string numStr2 = right.Body;
    int startIndex2 = numStr2.IndexOf('.');
    if (startIndex2 >= 0)
    numStr2 = numStr2.Remove(startIndex2, 1);
    int length1 = left.FloatPart.Length;
    if (right.FloatPart.Length > length1)
    {
    length1 = right.FloatPart.Length;
    if (left.FloatPart == "0")
    {
    for (int length2 = left.FloatPart.Length; length2 <= length1; ++length2)
    numStr1 += "0";
    }
    else
    {
    for (int length2 = left.FloatPart.Length; length2 < length1; ++length2)
    numStr1 += "0";
    }
    }
    else if (right.FloatPart == "0")
    {
    for (int length2 = right.FloatPart.Length; length2 <= length1; ++length2)
    numStr2 += "0";
    }
    else
    {
    for (int length2 = right.FloatPart.Length; length2 < length1; ++length2)
    numStr2 += "0";
    }
    Int Int = new Int(numStr1) + new Int(numStr2);
    if (Int.Length == length1)
    return (Float)Int.Body.Insert(Int.Body.Length - length1, "0.");
    if (Int.Length >= length1)
    return (Float)Int.Body.Insert(Int.Body.Length - length1, ".");
    string str = (string)Int.Absolute();
    for (int length2 = str.Length; length2 < length1; ++length2)
    str = "0" + str;
    if (Int.IsPositive)
    return (Float)str.Insert(0, "0.");
    return (Float)str.Insert(0, "-0.");
    }

    public static Float operator -(Float left, Float right)
    {
    if (right == (Float)0L)
    return left;
    if (right.IsPositive)
    return left + (Float)right.Absolute().Body.Insert(0, "-");
    return left + right.Absolute();
    }

    public static Float operator *(Float left, Float right)
    {
    string numStr1 = left.Body;
    int startIndex1 = numStr1.IndexOf('.');
    if (startIndex1 >= 0)
    numStr1 = numStr1.Remove(startIndex1, 1);
    string numStr2 = right.Body;
    int startIndex2 = numStr2.IndexOf('.');
    if (startIndex2 >= 0)
    numStr2 = numStr2.Remove(startIndex2, 1);
    int floatPartLength1 = left.FloatPartLength;
    if (right.FloatPartLength > floatPartLength1)
    {
    floatPartLength1 = right.FloatPartLength;
    for (int floatPartLength2 = left.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
    numStr1 += "0";
    }
    else if (right.FloatPartLength < floatPartLength1)
    {
    for (int floatPartLength2 = right.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
    numStr2 += "0";
    }
    Int Int = new Int(numStr1) * new Int(numStr2);
    int num = floatPartLength1 + floatPartLength1;
    if (Int.Length == num)
    return (Float)Int.Body.Insert(Int.Body.Length - num, "0.");
    if (Int.Length >= num)
    return (Float)Int.Body.Insert(Int.Body.Length - num, ".");
    string str = (string)Int.Absolute();
    for (int length = str.Length; length < num; ++length)
    str = "0" + str;
    if (Int.IsPositive)
    return (Float)str.Insert(0, "0.");
    return (Float)str.Insert(0, "-0.");
    }

    public static Float operator /(Float left, Float right)
    {
    string numStr1 = left.Body;
    int startIndex1 = numStr1.IndexOf('.');
    if (startIndex1 >= 0)
    numStr1 = numStr1.Remove(startIndex1, 1);
    string numStr2 = right.Body;
    int startIndex2 = numStr2.IndexOf('.');
    if (startIndex2 >= 0)
    numStr2 = numStr2.Remove(startIndex2, 1);
    int floatPartLength1 = left.FloatPartLength;
    if (right.FloatPartLength > floatPartLength1)
    {
    int floatPartLength2 = right.FloatPartLength;
    for (int floatPartLength3 = left.FloatPartLength; floatPartLength3 < floatPartLength2; ++floatPartLength3)
    numStr1 += "0";
    }
    else if (right.FloatPartLength < floatPartLength1)
    {
    for (int floatPartLength2 = right.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
    numStr2 += "0";
    }
    for (int index = 0; index < Float.DividResaultPrecision; ++index)
    numStr1 += "0";
    Int Int = new Int(numStr1) / new Int(numStr2);
    int num = Float.DividResaultPrecision;
    if (Int.Length == num)
    return (Float)Int.Body.Insert(Int.Body.Length - num, "0.");
    if (Int.Length >= num)
    return (Float)Int.Body.Insert(Int.Body.Length - num, ".");
    string str = (string)Int.Absolute();
    for (int length = str.Length; length < num; ++length)
    str = "0" + str;
    if (Int.IsPositive)
    return (Float)str.Insert(0, "0.");
    return (Float)str.Insert(0, "-0.");
    }

    public static Float operator +(Float left, object right)
    {
    return left + new Float(right.ToString());
    }

    public static Float operator +(object left, Float right)
    {
    return new Float(left.ToString()) + right;
    }

    public static Float operator -(Float left, object right)
    {
    return left - new Float(right.ToString());
    }

    public static Float operator -(object left, Float right)
    {
    return new Float(left.ToString()) - right;
    }

    public static Float operator *(Float left, object right)
    {
    return left * new Float(right.ToString());
    }

    public static Float operator *(object left, Float right)
    {
    return new Float(left.ToString()) * right;
    }

    public static Float operator /(Float left, object right)
    {
    return left / new Float(right.ToString());
    }

    public static Float operator /(object left, Float right)
    {
    return new Float(left.ToString()) / right;
    }

    public Float Absolute()
    {
    if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
    return new Float(this.Body.Substring(1));
    return this;
    }

    public new string Trim(string numStr)
    {
    string str1 = numStr.Trim();
    if ((int)str1[0] == 43)
    str1 = str1.Substring(1);
    int num = str1.IndexOf('.');
    if (num >= 0)
    {
    for (int length = str1.Length - 1; length >= num; --length)
    {
    if ((int)str1[length] != 48)
    {
    str1 = (int)str1[length] != 46 ? str1.Substring(0, length + 1) : str1.Substring(0, length);
    break;
    }
    }
    }
    bool flag = false;
    string str2 = str1;
    string str3 = "";
    char ch;
    for (int index = 0; index < str2.Length; ++index)
    {
    if (flag)
    {
    string str4 = str3;
    ch = str2[index];
    string str5 = ch.ToString();
    str3 = str4 + str5;
    }
    else if ((int)str2[index] == 45)
    {
    string str4 = str3;
    ch = str2[index];
    string str5 = ch.ToString();
    str3 = str4 + str5;
    }
    else if ((int)str2[index] == 48)
    {
    if (index + 1 < str2.Length && (int)str2[index + 1] == 46 || index + 1 >= str2.Length)
    {
    string str4 = str3;
    ch = str2[index];
    string str5 = ch.ToString();
    str3 = str4 + str5;
    flag = true;
    }
    }
    else
    {
    string str4 = str3;
    ch = str2[index];
    string str5 = ch.ToString();
    str3 = str4 + str5;
    flag = true;
    }
    }
    if (str3.Length == 2 && (int)str3[0] == 45 && (int)str3[1] == 48)
    str3 = "0";
    return str3;
    }

    public override string ToString()
    {
    return this.Body;
    }

    public Int ToInt()
    {
    string numStr = this.IntPart;
    if (!this.IsPositive)
    numStr = numStr.Insert(0, "-");
    return new Int(numStr);
    }

    public override bool Equals(object obj)
    {
    return base.Equals(obj);
    }

    public override int GetHashCode()
    {
    return base.GetHashCode();
    }
    }
  • 相关阅读:
    HDOJ 1846 Brave Game
    并查集模板
    HDU 2102 A计划
    POJ 1426 Find The Multiple
    POJ 3278 Catch That Cow
    POJ 1321 棋盘问题
    CF 999 C.Alphabetic Removals
    CF 999 B. Reversing Encryption
    string的基础用法
    51nod 1267 4个数和为0
  • 原文地址:https://www.cnblogs.com/chenggg/p/12571877.html
Copyright © 2011-2022 走看看