How to make an integer store a 12-digit number?

Question

How to make an integer store a 12-digit number?

Navigation

#1 by (3 votes)
#2 by (0 votes)
#3 by (-1 votes)

1

I need to find the largest prime factor of the number 600851475143.

Because it is a very large number, I can not store it in a variable of the normal integer type.

The code I made to find the largest prime factor of a number is this:

#include <iostream>

using namespace std;

int main()
{
    int maiorFator = 0;
    unsigned long int numero = 600851475143;

    for (int i = 2; numero != 1;) {
        if (numero % i == 0) {
            numero /= i;
            if (maiorFator < i) {
                maiorFator = i;
            }
            cout << i << endl;
        }
        else {
            i++;
        }
    }
    cout << "\nMaior fator primo: " << maiorFator << endl;

    return 0;
}

I've already tried to use the long and unsigned f modifiers in the numero variable, but it does not work, there is always overflow , and because of that I can not get the result.

I can not use variables of type float nor double , because I use the rest % operator to do the calculations.

The factorization algorithm works well, at least for the numbers I tested. My only problem is not being able to store the large number.

c c++ tipagem

asked by anonymous 13.09.2015 / 05:59

3 answers

Pass the value of the input to another page How to maintain ordered list of records in relationship N: N

score 3 · Answer 1

I will answer only what was asked.

The correct type in this case is long long which guarantees the 64 bits required for a number of this size.

That said, the algorithm is wrong but I think you will want to fix it yourself as it is an exercise.

score 0 · Answer 2

You can use one of these options. the first if you want a variable that stores only integers the second if you want something more global

long long; long double

You can also choose to create a class with this type of prototyped variable, and add it to a repository / library of your own

long long uVar(long long myUVar) {return myUVar;}

alternatively

long double uVar(long long myUVar) {return myUVar;}

score -1 · Answer 3

A possible approach will be the serialization technique, much used to record states in graphics engines of video games, especially if we consider the beginnings, and that can be used for purposes of gpgpu

link

#include <fstream>

// include headers that implement a archive in simple text format
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

/////////////////////////////////////////////////////////////
// gps coordinate
//
// illustrates serialization for a simple type
//
class gps_position
{
private:
    friend class boost::serialization::access;
    // When the class Archive corresponds to an output archive, the
    // & operator is defined similar to <<.  Likewise, when the class Archive
    // is a type of input archive the & operator is defined similar to >>.
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & degrees;
        ar & minutes;
        ar & seconds;
    }
    int degrees;
    int minutes;
    float seconds;
public:
    gps_position(){};
    gps_position(int d, int m, float s) :
        degrees(d), minutes(m), seconds(s)
    {}
};

int main() {
    // create and open a character archive for output
    std::ofstream ofs("filename");

    // create class instance
    const gps_position g(35, 59, 24.567f);

    // save data to archive
    {
        boost::archive::text_oarchive oa(ofs);
        // write class instance to archive
        oa << g;
        // archive and stream closed when destructors are called
    }

    // ... some time later restore the class instance to its orginal state
    gps_position newg;
    {
        // create and open an archive for input
        std::ifstream ifs("filename");
        boost::archive::text_iarchive ia(ifs);
        // read class state from archive
        ia >> newg;
        // archive and stream closed when destructors are called
    }
    return 0;
}