# EulerProblem064

# Odd period square roots (Euler Problem 64)¶

Back to overview.

https://projecteuler.net/problem=64

The first ten continued fraction representations of (irrational) square roots are:

√2=[1;(2)], period=1

√3=[1;(1,2)], period=2

√5=[2;(4)], period=1

√6=[2;(2,4)], period=2

√7=[2;(1,1,1,4)], period=4

√8=[2;(1,4)], period=2

√10=[3;(6)], period=1

√11=[3;(3,6)], period=2

√12= [3;(2,6)], period=2

√13=[3;(1,1,1,1,6)], period=5

Exactly four continued fractions, for N ≤ 13, have an odd period.

How many continued fractions for N ≤ 10000 have an odd period?

In [1]:

    import math

    def get_floor_sqrt(n):
        return math.floor(math.sqrt(n))

    assert(get_floor_sqrt(5) == 2)
    assert(get_floor_sqrt(23) == 4)

In [2]:

    def next_expansion(current_a, current_nominator, current_denominator, original_number):
        # Less typing
        cn = current_nominator
        cd = current_denominator

        # Step 1: Multiply the fraction so that we can use the third binomial formula.
        # Make sure we can reduce the nominator.
        assert((original_number - cd * cd) % cn == 0)
        # The new nominator is the denominator since we multiply with (x + cd) and then
        # reduce the previous nominator.
        # The new denominator is calculated by applying the third binomial formula and
        # then by divided by the previous nominator.
        cn, cd = cd, (original_number - cd * cd) // cn

        # Step 2: Calculate the next a by finding the next floor square root.
        next_a = math.floor((math.sqrt(original_number) + cn) // cd)

        # Step 3: Remove next a from the fraction by substracting it.
        cn = cn - next_a * cd
        cn *= -1

        return next_a, cn, cd

    next_expansion(1, 7, 3, 23)

Out[2]:

    (3, 3, 2)

In [3]:

    def get_continued_fraction_sequence(n):

        # If number is a square number we return it.
        floor_sqrt = get_floor_sqrt(n)
        if n == floor_sqrt * floor_sqrt:
            return ((floor_sqrt), [])

        # Otherwise, we calculate the next expansion till we
        # encounter a step a second time.
        a = floor_sqrt
        cn = a
        cd = 1
        sequence = []
        previous_steps = []

        while not (a, cn, cd) in previous_steps :
            #print("a: {} cn: {} cd: {}".format(a, cn, cd))
            previous_steps.append((a, cn, cd))
            a, cn, cd = next_expansion(a, cd, cn, n)
            sequence.append(a)
        sequence.pop()
        return ((floor_sqrt), sequence)

    assert(get_continued_fraction_sequence(1) == ((1), []))
    assert(get_continued_fraction_sequence(4) == ((2), []))
    assert(get_continued_fraction_sequence(25) == ((5), []))
    assert(get_continued_fraction_sequence(2) == ((1), [2]))
    assert(get_continued_fraction_sequence(3) == ((1), [1,2]))
    assert(get_continued_fraction_sequence(5) == ((2), [4]))
    assert(get_continued_fraction_sequence(13) == ((3), [1,1,1,1,6]))

In [4]:

    def get_period(n):
        _, sequence = get_continued_fraction_sequence(n)
        return len(sequence)

    assert(get_period(23) == 4)

In [5]:

    s = len([n for n in range(1, 10001) if get_period(n) % 2 != 0])
    print(s)
    assert(s == 1322)

    1322

In [ ]: