Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Big Number
Forum - C/C++ - Big Number

Avatar
johntiror (Normal User)
Newbie


Messaggi: 4
Iscritto: 24/11/2007

Segnala al moderatore
Postato alle 15:43
Martedì, 27/11/2007
Ciao a tutti! In questi giorni stavo cercando di realizzare un programma che codificasse dei messaggi con la crittatura RSA e mi sono inbattuto nel programma BigNumber. Ho notato che non esegue bene le differenze (ed infatti il creatore lo aveva scritto nel source) ed ho provato a scrivere io l'algoritmo... Non so se è il posto giusto per postarlo.

P.S. sono alle prime armi con la programmazione quindi è inevitabile che si può migliorare di molto il codice da me scritto, però direi che funziona anche con numeri molto grandi

Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <BigNumber.h>
  4.  
  5. int main(int argc, char *argv[])
  6. {
  7.     LUN_BNUM=100;
  8.    
  9.     BigN n,l;
  10.    
  11.     n=bIntero();
  12.     l=bIntero();
  13.    
  14.     bLeggi(n);
  15.     bLeggi(l);
  16.  
  17.  
  18.     int i,c,lris,p;
  19.     if (n->lun==l->lun) {           //calcola il numero di cifre che avrà il risultato
  20.                         i=n->lun;
  21.                         while (n->pun[i]==l->pun[i] && i>1) {
  22.                               i--;
  23.                               }
  24.                         if (n->pun[i]-l->pun[i]==1 && n->pun[i-1]<l->pun[i-1]) {
  25.                                                     i--;
  26.                                                     }
  27.                         while (n->pun[i]==0 && l->pun[i]==9) {
  28.                               i--;
  29.                               }
  30.                         if (i==0) {
  31.                                   i=1;
  32.                                   }
  33.                         lris=i;
  34.                                                     }
  35.                                                          
  36.     if (n->lun > l->lun) {
  37.                        c=n->lun;
  38.                        if (n->lun - l->lun==1 && n->pun[c]==1 && n->pun[c-1]<l->pun[c-1]) {
  39.                                             c--;
  40.                                             }
  41.                            while (n->pun[c]==0 && l->pun[c]==9) {
  42.                                  c--;
  43.                                  }
  44.                        if (n->lun - l->lun > 1) {
  45.                                   p=l->lun;
  46.                                            if (n->pun[p] < l->pun[p] && n->pun[p]==0) {
  47.                                                          while (n->pun[p]==0) {
  48.                                                                p++;
  49.                                                                }
  50.                                                                }
  51.                                            if (p==c && n->pun[c]==1) {
  52.                                                     c--;
  53.                                                     }
  54.                                   if(n->pun[c]==0) {
  55.                                                    c--;
  56.                                                    }
  57.                                   }
  58.                        if (c==0) {
  59.                                  c=1;
  60.                                  }
  61.                        lris=c;
  62.                        }
  63.                        
  64.     BigN ris;
  65.     int z=1,d;
  66.     ris=bIntero();
  67.         while (z<=lris) {                    //esegue la sottrazione
  68.               if (n->pun[z] < l->pun[z]) {
  69.                  ris->pun[z] = 10+(n->pun[z]) - l->pun[z];
  70.                              if (n->pun[z+1] != 0) {
  71.                                              n->pun[z+1] = n->pun[z+1] - 1;
  72.                                              }
  73.                              else
  74.                              {
  75.                                  n->pun[z+1] = 9;
  76.                                  d=z+2;
  77.                                        while (n->pun[d]==0) {
  78.                                              n->pun[d]=9;
  79.                                              d++;
  80.                                              }
  81.                                  n->pun[d] = n->pun[d] - 1;
  82.                              }
  83.                             z++;
  84.                             }
  85.               else
  86.               {
  87.                   ris->pun[z] = n->pun[z] - l->pun[z];
  88.                   z++;
  89.                   }  
  90.                   }
  91.                                  
  92.  while (lris > 0){
  93.     printf ("%d", ris->pun[lris]);
  94.     lris--;
  95.    }
  96.  
  97.  
  98.   printf("\n");
  99.  
  100.   system("PAUSE");     
  101.   return 0;
  102. }


Ultima modifica effettuata da johntiror il 28/11/2007 alle 9:52
PM Quote