C# - Classe qui utilise ILists pour stocker d'énormes entiers sans BigInt. Je n'arrive pas à comprendre comment utiliser CompareTo et Int.TryParse à +, -, et * deux Listes

Question

J'ai travaillé sur un devoir et je suis débutant en C#. Je dois implémenter un programme similaire à ce que BigInt peut faire: effectuer une addition, une soustraction ou une multiplication avec deux valeurs absurdement grandes (sans réellement utiliser la bibliothèque BigInt). On m'a dit d'utiliser CompareTo et que cela faciliterait la création des méthodes add, subtract et multiply, mais je n'ai aucune idée de la façon d'implémenter CompareTo. Je ne sais même pas si ma classe est correctement mise en œuvre ou s'il me manque quelque chose d'important. Voici mon code:

public class HugeInt 
{ 
    char sign; 
    public IList<int> theInt = new List<int>(); 


    public string ToString(IList<int> theInt) 
    { 
     string bigInt = theInt.ToString(); 
     return bigInt; 
    } 

    public HugeInt CompareTo(HugeInt num1) 
    { 
     int numParse; 
     string number = ToString(theInt); /// I did this to convert the List into a string 
     for(int i = 0; i < number.Length; i++) 
     { 
      bool temp = Int32.TryParse(number, out numParse); /// Supposed to change each index of the string to a separate integer (not sure how to properly do this) 

      /// These are *supposed to* perform operations on two HugeInts /// 
      num1.plus(numParse, num1); 
      num1.minus(numParse, num1); 
      num1.times(numParse, num1); 
     } 

     return num1; 
    } 

Je ne suis pas ici pour demander toutes les réponses à cette mission, je viens de travailler sur ce depuis des heures et ne peut pas comprendre ce que je fais faux - j'ai déjà fait beaucoup de recherche google. Merci d'avance pour tous conseils et aide!

Answer 1

Pour écrire une telle classe, il faut que vous en sachiez un peu plus sur la façon de faire des mathématiques à la main. Par exemple, lorsque vous ajoutez deux nombres, vous commencez par ajouter leurs chiffres les moins significatifs. Si le résultat est supérieur à 9, vous devez porter un 1 au chiffre suivant (explanation). Ensuite, vous continuez au chiffre suivant.

Maintenant, voici mon point de vue. Je veux enregistrer le "énorme int" comme une liste de chiffres en commençant par le chiffre le moins significatif. Ensuite, j'implémente la méthode Plus comme décrit ci-dessus. Je peux comparer deux "énormes" en regardant le nombre de chiffres. Le nombre avec le plus de chiffres est le plus grand. Dans le cas où le nombre de chiffres est le même, je devrai comparer chaque chiffre un par un, en commençant par le chiffre le plus significatif.

Ce qui suit est juste quelque chose pour vous aider à démarrer. Il ne gère que les entiers positifs et a Plus et CompareTo méthodes. Sachez qu'il y a beaucoup de cas d'angle dont je n'ai pas pris soin.

Il peut être utilisé comme ceci:

var num1 = new HugeInt("11112222333399998888777123123"); 
var num2 = new HugeInt("00194257297549"); 

Console.WriteLine(num1.Plus(num2).ToString()); // Writes 11112222333399999083034420672 
Console.WriteLine(num1.CompareTo(num2)); // Writes -1 since num1 > num2 

Voici la classe:

public class HugeInt 
{ 
    // The array that contains all the digits of the number. To create a new number, you do not change this array but instead you create a new instance of HugeInt. 
    // The first digit is the least significant digit. 
    private readonly int[] digits; 

    public HugeInt(string number) 
    { 
     // Trim off the leading zeros 
     number = number.TrimStart('0'); 
     if (number == "") 
      number = "0"; 

     // Convert to digit array with the least significant digit first 
     digits = number.ToCharArray().Select(c => int.Parse(c.ToString())).Reverse().ToArray(); 
    } 

    public HugeInt(IList<int> digits) 
    { 
     // Trim off the leading zeros 
     var d = digits.ToList(); 
     while (d.Count > 1 && d.Last() == 0) 
      d.RemoveAt(d.Count - 1); 

     // Convert to digit array with the least significant digit first 
     this.digits = d.ToArray(); 
    } 

    public HugeInt Plus(HugeInt num) 
    { 
     // Add two positive integers by adding each digit together, starting with the least significant digit. 
     var result = new List<int>(); 
     int carry = 0; 
     for (var i = 0; i < this.digits.Length || i < num.digits.Length; i++) 
     { 
      var digit1 = i < this.digits.Length ? this.digits[i] : 0; 
      var digit2 = i < num.digits.Length ? num.digits[i] : 0; 
      var digitResult = digit1 + digit2 + carry; 
      carry = 0; 
      if (digitResult >= 10) 
      { 
       digitResult -= 10; 
       carry = 1; 
      } 
      result.Add(digitResult); 
     } 
     if (carry > 0) 
      result.Add(carry); 

     return new HugeInt(result); 
    } 

    public int CompareTo(HugeInt num) 
    { 
     // First compare by length of number 
     if (this.digits.Length > num.digits.Length) 
      return -1; 
     else if (this.digits.Length < num.digits.Length) 
      return 1; 
     else 
     { 
      // If lengths are equal, then compare each digit - starting with the most significant digit. 
      for (var i = this.digits.Length - 1; i >= 0; i--) 
      { 
       var cmp = this.digits[i].CompareTo(num.digits[i]); 
       if (cmp != 0) 
        return cmp; 
      } 
      return 0; 
     } 
    } 

    public override string ToString() 
    { 
     return String.Join("", digits.Reverse()); 
    } 
}