[Project Euler] Problem 57

Problem Description

It is possible to show that the square root of two can be expressed as an infinite continued fraction.

sqrt(2) = 1 + 1/(2 + 1/(2 + 1/(2 + ... ))) = 1.414213...

By expanding this for the first four iterations, we get:

1 + 1/2 = 3/2 = 1.5
1 + 1/(2 + 1/2) = 7/5 = 1.4
1 + 1/(2 + 1/(2 + 1/2)) = 17/12 = 1.41666...
1 + 1/(2 + 1/(2 + 1/(2 + 1/2))) = 41/29 = 1.41379...

The next three expansions are 99/70, 239/169, and 577/408, but the eighth expansion, 1393/985, is the first example where the number of digits in the numerator exceeds the number of digits in the denominator.

In the first one-thousand expansions, how many fractions contain a numerator with more digits than denominator?

C++

Get the pseudo-code of calculating the numerator and denominator of the fraciton first from the expression above. Then you could easily write the main code:

Main()

void Problem_57()
{
    int count = 0;
    for(int i=1; i<= EXPANSION_TIME; i++)
    {
        Fraction fra(1, 2);
        int loop = 1;
        while(loop <i)
        {
            fra.Add(2);
            fra.Reciprocal();
            loop++;
        }
        fra.Add(1);

        if(fra.IsOKForProblem())
        {
            count++;
            // fra.Display();
        }
    }
    printf("result = %d\n", count);
}

You may need a Fraction class which manages two fields numerator and denominator.

Plealse note that the numbers in the calculation are far beyond the maxnium of a 4 bytes integer, you need a Big Integer type.

I would like to show my simple implementation below:

Fraction and BigInteger

class BigInteger
{
public:
    BigInteger(int a)
    {
        memset(m_digits, 0, 1000);
        int index = 0;
        while(a != 0)
        {
            m_digits[index] = a % 10;
            a = a/ 10;
            index++;
        }

        m_length = index;
    }    

    void Add(const BigInteger& other)
    {
        int maxLength = max(m_length, other.m_length);
        
        for(int i=0; i<maxLength; i++)
        {
            int temp = m_digits[i] + other.m_digits[i];
            if(temp >= 10)
            {
                m_digits[i+1]++;
                m_digits[i] = temp % 10;
            }
            else
            {
                m_digits[i] = temp;
            }
        }
        m_length = (m_digits[maxLength] == 0) ? maxLength : (maxLength + 1);
    }

    void Multiply(int num)
    {
        BigInteger other(*this);
        for(int i=0; i<num - 1; i++)
        {
            Add(other);
        }
    }
    int GetLength()
    {
        return m_length;
    }

    void Display()
    {
        char str[1000] = {0};
        for(int i = m_length - 1; i>=0; i--)
        {
            str[m_length - i - 1] = (char)(m_digits[i] + '0');
        }
        printf("%s", str);
    }
private:
    BYTE m_digits[1000];
    int m_length;
};

class Fraction
{
public:
    Fraction(int numerator, int denominator)
        : m_bi1(numerator), m_bi2(denominator), m_isBI1Numerator(true)
    {

    }

    void Reciprocal()
    {
        m_isBI1Numerator = !m_isBI1Numerator;
    }

    void Add(int addend)
    {
        BigInteger temp(GetDenominator());
        temp.Multiply(addend);
        GetNumerator().Add(temp);
    }

    void Display()
    {
        GetNumerator().Display();
        printf("/");
        GetDenominator().Display();
        printf("\n");
    }
    
    bool IsOKForProblem()
    {
        return GetNumerator().GetLength() > GetDenominator().GetLength();
    }

private:
    BigInteger& GetNumerator()
    {
        return m_isBI1Numerator ? m_bi1 : m_bi2;
    }

    BigInteger& GetDenominator()
    {
        return m_isBI1Numerator ? m_bi2 : m_bi1;
    }

    bool m_isBI1Numerator;
    BigInteger m_bi1;
    BigInteger m_bi2;
};