Quiz 2

# Written by *** and Eric Martin for COMP9021


'''
Prompts the user for two strictly positive integers, numerator and denominator.

Determines whether the decimal expansion of numerator / denominator is finite or infinite.

Then computes integral_part, sigma and tau such that numerator / denominator is of the form
integral_part . sigma tau tau tau ...
where integral_part in an integer, sigma and tau are (possibly empty) strings of digits,
and sigma and tau are as short as possible.
'''


import sys
from math import gcd


try:
    numerator, denominator = input('Enter two strictly positive integers: ').split()
except ValueError:
    print('Incorrect input, giving up.')
    sys.exit()
try:
    numerator, denominator = int(numerator), int(denominator)
    if numerator <= 0 or denominator <= 0:
        raise ValueError
except ValueError:
    print('Incorrect input, giving up.')
    sys.exit()

has_finite_expansion = False
integral_part = 0
sigma = ''
tau = ''

gcd_num_den = gcd(numerator,denominator)
numerator//= gcd_num_den
denominator//= gcd_num_den

integral_part = numerator//denominator

def find_prime_factors(denominator):
    prime_factors = []
    factor = 2
    if denominator == 1:
        return
    while denominator>1:
        if denominator%factor == 0:
            denominator =  denominator/factor
            prime_factors.append(factor)
        else:
            factor =  factor + 1
    return prime_factors

def finite_or_infinite(denominator):

    if denominator == 1:
        return True
    L = find_prime_factors(denominator)
    for i in L:
        if i != 2:
            if i!=5:
                return False
    return True

has_finite_expansion = finite_or_infinite(denominator)

def find_sigma_tau(numerator, denominator):
    list_of_remainders = []
    flag = True
    quotient = []
    #quotient = numerator/denominator
    #quotient -= numerator//denominator
    while flag:
        if numerator%denominator == 0:
            flag = False
            break
        else:
            remainder = numerator%denominator
            #print(numerator, denominator, remainder)
            #print("list ", list_of_remainders)
            for element in list_of_remainders:
                #print(element)
                if element == remainder:
                    flag = False
            #if not flag:
                #print(remainder)
               # continue
            list_of_remainders.append(remainder)
            quotient.append((numerator-remainder)/denominator)
            numerator = numerator * 10
            #print(numerator/denominator)
            #counter+=1
            #if counter>5:
            #    break

    #print(quotient)
    #print(remainder)
    print(quotient)
    print(list_of_remainders)
    '''quotient = str(quotient)
    sigma = []
    tau = []
    #quotients = get_quotients(numerator, denominator, remainder)
    #accidentally printed remainders. Not what we want
    i = 2
    for value in list_of_remainders:
       ''' '''if list_of_remainders[index] == remainder:
            sigma = list_of_remainders[0:index]
            tau = list_of_remainders[index:]
            break''''''
        if value!=remainder:
            sigma.append(quotient[i])
            #print(sigma)
            i+=1
        else:
            tau.append(quotient[i])
            i+=1
    print(sigma, tau)  '''


'''def get_quotients(numerator, denominator, remainder):
    flag = True
    quotients = []
    while Flag:
        quotient = numerator//denominator'''

find_sigma_tau(numerator, denominator)

if has_finite_expansion:
    print(f'\n{numerator*gcd_num_den} / {denominator*gcd_num_den} has a finite expansion')
else:
    print(f'\n{numerator*gcd_num_den} / {denominator*gcd_num_den} has no finite expansion')
if not tau:
    if not sigma:
        print(f'{numerator*gcd_num_den} / {denominator*gcd_num_den} = {integral_part}')
    else:
        print(f'{numerator*gcd_num_den} / {denominator*gcd_num_den} = {integral_part}.{sigma}')
else:
    print(f'{numerator*gcd_num_den} / {denominator*gcd_num_den} = {integral_part}.{sigma}({tau})*')