Tres longue variable

Réponse acceptée !
Salut,

Tu ne peux pas stocker directement des nombres aussi grands. Les types de bases sont généralement limités à 64 bits (c'est le cas de .Net avec les long), ce qui représente une vingtaine de chiffres en base décimale.

Ce que tu peux faire, c'est créer ton propre type de nombres. Le principe consiste à créer une classe qui stocke un tableau d'entiers (par exemple de taille 4) :
int[] nbre = new int[4];
A partir de là, tu disposes de 32 (taille des int) * 4 = 128 bits pour stocker un nombre :
- les 32 premiers bits sont stockés dans nbre[0]
- les bits 33 à 64 sont stockés dans nbre[1]
- etc.
Cela implique juste de recoder les opérations d'addition, de soustraction, etc. pour permettre de travailler avec ces nombres. En effet, lors des calculs, il faut gérer le report de la retenue entre deux éléments du tableau nbre. Tu peux envisager d'implémenter cela en utilisant la surcharge d'opérateurs disponible en C#.

Pour référence, tu peux voir l'implémentation de la classe BigInteger du langage Java qui réalise exactement ce type de traitement. A noter que le code de cette classe est un peu effrayant : les algorithmes utilisés sont assez costauds :-)

Réponse acceptée !
Oki doki...

Je vois ce que tu veux faire. Pour faire 183^1079 mod 5141, il te faut écrire la puissance (donc la multiplication et l'addition) et le modulo (donc la division et la soustraction). Donc presque tout :-)

Pour t'aider à commencer, je vais te montrer comment faire une addition sur une tableau de 2 entiers de 32 bits (qui représentent donc un nombre de 64 bits)... attention, tout ça se fait sur des entiers non signés :

/*
    Additionne a et b
    a et b doivent être des tableaux de longueur 2 (si non, il faut adapter le code)
    a[0] (respectivement b[0]) contient les bits de poids faibles de a (resp. b)
    a[1] (resp. b[1]) contient les bits de poids forts de a (resp. b)
    C'est à dire : a = a[0] + 2^32 * a[1]
*/
public static uint[] Addition(uint[] a, uint[] b)
{
    bool carry = false; // indique s'il y a une retenue
    uint[] result = new uint[2];
   
    for (uint i = 0; i < 2; i++)
    {
        result[i] += a[i] + b[i];
       
        /*
            Incrémente encore le résultat de 1 s'il y a une retenu
            Comme on est en base 2, la retenue est soit de zéro, soit de 1
        */
        if (carry)
            result[i]++;
       
        /*
            On calcul s'il y a une retenue pour le tour suivant
            C'est le cas si le résultat de l'addition est plus petit que a (ou b)
            En effet, cela signifie que l'addition a provoqué un dépassement de capacité
            pour le processeur et qu'il a du tronqué un bit du nombre.
        */
        carry= (result[i] < a[i]);
           
    }

    /*
        ATTENTION ! Si à ce stage carry est à true, cela signifie que l'addition a
        provoquée un dépassement de capacité (il aurait fallu faire l'addition sur au moins
        65 bits parce que a et b étaient trop grand pour que a+b tiennent sur
        64 bits).
    */
    return result;
}

Je te laisse imaginer la généralisation de cet algo avec des entiers plus grands (=> remplacer les "2" avec la taille des tableaux).

Pour faire 270363096527615 + 68388485210612178, il suffit de pratiquer ainsi :
uint[] a = new uint[] { 0xd05432ff, 0x0000f5e4 }; // = 0x0000f5e4d05432ff (hexa)= 270363096527615 (décimal)
uint[] b = new uint[] { 0x07b4a1d2, 0x00f2f6f7 }; // = 0x00f2f6f707b4a1d2 (hexa) = 68388485210612178 (décimal)
uint[] res = Addition(a, b);

Ce qui doit te renvoyer 0xF3ECDBD808D4D1 (res[0] = D808D4D1, res[1] = F3ECDB).

Si tu veux avoir la représentation décimale à l'écran (68658848307139793 pour notre calcul), il te faut faire la conversion de la base 2 à la base 10. Pour arriver à cela, encore faut il implémenter la division et le modulo ;-)

Good luck !