Foro de elhacker.net

if ((numero > 99999999999999999999) && (numero < 10000000000000000)) //si numero tiene 21 caracteres
	{
	}

if ((numero > 99999999999999999999) && (numero < 10000000000000000)) //si numero tiene 21 caracteres
	{
	}

numero>99999999999999999999  y
numero<10000000000000000

#include <bitset>
#include <iostream>
#include <string>
#include <vector>
 
class BigNum
{
  public:
 
    BigNum( int number = 0 );
 
    BigNum( const std::string& number );
 
    BigNum operator+( const BigNum& number );
 
    std::string ToBinString( ) const;
 
    std::string ToString( ) const;
 
  private:
 
    bool _negative;
    std::vector< unsigned int > _number;
 
    void Mul10AddN( unsigned int number );
 
    std::string Mul2( const std::string& number ) const;
 
    std::string Mul2AddN( const std::string& number, int carry ) const;
 
    void FromString( const std::string& number );
};
 
BigNum::BigNum( int number )
  : _negative( false )
{
  if ( number < 0 )
  {
    _negative = true;
    number = -number;
  }
  else if ( number > 0 )
    _number.push_back( number );
}
 
BigNum::BigNum( const std::string& number )
{
  FromString( number );
}
 
BigNum BigNum::operator +( const BigNum& number )
{
//  if ( number1._negative != number2._negative )
//  {
//    if ( number1._negative )
//    {
//      BigNum temp = number1;
//      temp._negative = false;
//      return number2 - temp;
//    }
//    else
//    {
//      BigNum temp = number2;
//      temp._negative = false;
//      return number1 - temp;
//    }
//  }
 
  BigNum to_return;
  to_return._negative = _negative;
 
  unsigned int carry = 0;
  unsigned int max = (_number.size( ) > number._number.size( ) )? _number.size( )
                                                                : number._number.size( );
 
  for ( unsigned int i=0; i < max; i++ )
  {
    unsigned long long temp = 0;
 
    if ( i < _number.size( ) )
      temp = static_cast< unsigned long long >( _number[ i ] );
 
    if ( i < number._number.size( ) )
      temp += static_cast< unsigned long long >( number._number[ i ] );
 
    temp += carry;
 
    to_return._number.push_back( static_cast< unsigned int >(temp & 0xFFFFFFFF) );
    carry = static_cast< unsigned int >(temp >> 32);
  }
 
  if ( carry != 0 )
    to_return._number.push_back( static_cast< unsigned int >( carry ) );
 
  return to_return;
}
 
std::string BigNum::ToBinString( ) const
{
  std::string to_return;
 
  for ( unsigned int i=_number.size( ) - 1; i < _number.size( ); i-- )
  {
    std::bitset< 32 > bits( static_cast< int >( _number[ i ] ) );
    to_return += bits.to_string( );
  }
 
  while ( to_return[ 0 ] == '0' )
    to_return.erase( to_return.begin( ) );
 
  int i = static_cast< int >( to_return.size( ) ) - 4;
  while ( i > 0 )
  {
    to_return.insert( i, 1, ' ' );
    i -= 4;
  }
  return to_return;
}
 
std::string BigNum::ToString() const
{
  std::string to_return = "0";
 
  for ( auto it = _number.rbegin( ); it != _number.rend( ); ++it )
  {
    int data = *it;
    for ( int i=0; i< 32; i++ )
    {
      to_return = Mul2AddN( to_return, (data & 0x80000000)? 1 : 0 );
      data <<= 1;
    }
  }
 
  return to_return;
}
 
void BigNum::Mul10AddN(unsigned int number)
{
  if ( _number.empty( ) )
  {
    _number.push_back( number );
    return;
  }
 
  unsigned long long carry = static_cast< unsigned long long >( number );
  unsigned long long ten = 10;
  for ( unsigned int i = 0; i < _number.size( ); i++ )
  {
    unsigned long long temp = static_cast< unsigned long long >( _number[ i ] ) * ten + carry;
 
    _number[ i ] = static_cast < unsigned int >( temp & 0xFFFFFFFF);
    carry = ( temp >> 32 );
  }
 
  if ( carry != 0 )
    _number.push_back( static_cast< unsigned int >( carry ) );
}
 
std::string BigNum::Mul2AddN(const std::string& number, int carry ) const
{
  std::string to_return;
 
  for ( auto it = number.rbegin( ); it != number.rend( ); ++it )
  {
    int temp = (*it - '0') * 2 + carry;
 
    if ( temp >= 10 )
    {
      temp -= 10;
      carry = 1;
    }
    else
      carry = 0;
 
    to_return.insert( 0, 1, temp + '0' );
  }
 
  if ( carry != 0 )
    to_return.insert( 0, 1, carry + '0' );
 
  return to_return;
}
 
void BigNum::FromString(const std::string& number)
{
  unsigned int i=0;
  if ( number[ i ] == '-' )
  {
    _negative = true;
    i++;
  }
  else
    _negative = false;
 
  _number.clear( );
 
  for ( ; i < number.length( ); i++ )
  {
    unsigned int digit = number[ i ] - 0x30;
    Mul10AddN( digit );
  }
}
 
int main( )
{
  BigNum a( 100 );
  BigNum b( "9000000000000" );
 
  BigNum c = a + b;
 
  std::cout << a.ToString( ) << std::endl
            << "+" << std::endl
            << b.ToString( ) << std::endl
            << "=" << std::endl
            << c.ToString( ) << std::endl;
 
  a = BigNum( "123456123456123456123456123456123123" );
  b = BigNum( "876543211234567876543212345678");
  c = a + b;
 
 
  std::cout << a.ToString( ) << std::endl
            << "+" << std::endl
            << b.ToString( ) << std::endl
            << "=" << std::endl
            << c.ToString( ) << std::endl;
}
 

to_return = Mul2AddN( to_return, (data & 0x80000000)? 1 : 0 );
data <<= 1;

(data & 0x80000000 )? 1 : 0

data <<= 1;

Número en binario: 1100101
resultado inicial: "0"

1a iteracion:
  "data & 0x800...": 1
  resultado = "0" * 2 + 1 = "1"

2a iteracion:
  "Data & 0x800...": 1
  resultado = "1" * 2 + 1 = "3"

3a iteracion:
  "Data & 0x800...": 0
  resultado = "3" * 2 + 0 = "6"

4a iteracion:
  "Data & 0x800...": 0
  resultado = "6" * 2 + 0 = "12"

5a iteracion:
  "Data & 0x800...": 1
  resultado = "12" * 2 + 1 = "25"

6a iteracion:
  "Data & 0x800...": 0
  resultado = "25" * 2 + 0 = "50"

7a iteracion:
  "Data & 0x800...": 1
  resultado = "50" * 2 + 1 = "101"

resultado final: "101"

#include <stdio.h>
#include <string.h>
 
#define MAX_DIGITOS 200
 
void suma (char a[], char b[], char c[]){
  int i,temp,residuo=0,lon_a,lon_b,dif;
  lon_a = strlen(a);
  lon_b = strlen(b);
  if (lon_a > lon_b){
    dif=lon_a-lon_b;
    for (i=lon_b-1; i >=0;i--)
      b[i+dif]=b[i];
    for (i=0; i < dif;i++)
        b[i]='0';
  }
  else if (lon_b > lon_a){
    dif=lon_b-lon_a;
    for (i=lon_a-1; i >=0;i--)
      a[i+dif]=a[i];
    for (i=0; i < dif;i++)
        a[i]='0';
  }
  for (i=strlen(a)-1; i>=0;i-- ){
    temp = a[i]-'0' + b[i]-'0' + residuo;
    c[i+1]=temp%10+'0';
    residuo=temp/10;
  }
  c[0] = residuo + '0';
  if (c[0]=='0'){
    for (i=0; i < strlen(a);i++ ){
      c[i]=c[i+1];
    }
    c[strlen(a)]='\0';
  }
  c[strlen(a)+1]='\0';
}
 
int main(void){
  char a[MAX_DIGITOS] = /*  "99" */ /* "99" */ "123456123456123456123456123456123123";
  char b[MAX_DIGITOS] = /* "199" */ /* "99" */  "983456123456123456123456123456123123";
  char c[MAX_DIGITOS+1];
  suma (a,b,c);
  printf ("\n  %s +\n  %s=\n\n %s\n ",a,b,c);
  return 0;
}

#include <stdio.h>
#include <string.h>
 
#define MAX_DIGITOS 300 /* o 3000*/
#define DIGITOS   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define BASE  16
 
void suma (char a[], char b[], char c[]){
  int i,temp,temp_a,temp_b,residuo=0,lon_a,lon_b,dif,digit;
  lon_a = strlen(a);
  lon_b = strlen(b);
  if (lon_a > lon_b){
    dif=lon_a-lon_b;
    for (i=lon_b-1; i >=0;i--)
      b[i+dif]=b[i];
    for (i=0; i < dif;i++)
        b[i]='0';
  }
  else if (lon_b > lon_a){
    dif=lon_b-lon_a;
    for (i=lon_a-1; i >=0;i--)
      a[i+dif]=a[i];
    for (i=0; i < dif;i++)
        a[i]='0';
  }
  for (i=strlen(a)-1; i>=0;i-- ){
    if(a[i]-48>9 )
      temp_a = a[i] -55 ;
    else
      temp_a = a[i] - '0';
    if(b[i]-48>9)
      temp_b = b[i] -55;
    else
      temp_b = b[i] - '0';
    temp = temp_a + temp_b + residuo;
    digit = DIGITOS [temp % BASE];
    if (digit<10)
      c[i+1]=DIGITOS [temp % BASE] + '0';
    else
      c[i+1]=DIGITOS [temp % BASE] ;
    residuo = temp / BASE;
  }
  c[0] = residuo + '0';
  if (c[0]=='0'){
    for (i=0; i < strlen(a);i++ )
      c[i]=c[i+1];
    c[strlen(a)]='\0';
  }
  c[strlen(a)+1]='\0';
}
 
int main(void){
  /** ¡¡¡ NO OLVIDES CAMBIAR LA BASE DE (2-36) EN #DEFINE¡¡¡ **/
  /** Tienes tres ejemplos: base 16, base 2, base 10 **/
  char a[MAX_DIGITOS] = "A33A15FADBC9"  /*"1001001110111001" */ /*"123456123456123456123456123456123123"*/;
  char b[MAX_DIGITOS] = "FFC593C5BA33A" /*"1001001110111001" */ /* "983456123456123456123456123456123123"*/;
  char c[MAX_DIGITOS+1];
  suma (a,b,c);
  printf ("\n  %s +\n  %s=\n\n %s\n ",a,b,c);
  return 0;
}
 

#include <iostream>
#include <cstring>
 
#define max 50
 
bool Sumar(char *str1, char *str2, char *r);
 
int main(void)
{
    char n1[] = "12345612345612345612345612345612312348513552";
    char n2[] = "87654321123456787654321234567851515";
    char suma[max] = "";
 
    Sumar(n1, n2, suma);
    std::cout << n1 << "\n+\n" << n2 << "\n\n" << suma << std::endl;
 
    return 0;
}
 
bool Sumar(char *str1, char *str2, char *r)
{
    char c1, c2;
    int carry = 0;
    int a = strlen(str1), b = strlen(str2);
 
    r[a > b? a : b] = 0;
    do{
         a--, b--;
        (a < 0)? c1 = '0' : c1 = str1[a];
        (b < 0)? c2 = '0' : c2 = str2[b];
 
        r[a > b? a : b] = carry + c1 + c2 - '0';
        r[a > b ? a : b] > '9'? r[a > b ? a : b] -= 10, carry = 1 : carry = 0;
    }while (a > 0 || b > 0);
 
    if (carry){
      if (strlen(r) < max){
         for (int i = strlen(r)+1; i > 0; i--)
            r[i] = r[i-1];
         r[0] = '1';
         return false;
        }
    }
    return true;
}