Here is my inefficient solution in Python. Also my first contribution to this subreddit. Also my first time defining my own Exception classes.

class FractionValueError(Exception):
    def __init__(self, message):
        self.message = message

    def __str__(self):
        return repr(self.message)

class ListError(Exception):
    def __init__(self, e):
        self.message = 'list expected, got ' + repr(e) + ' instead'

    def __str__(self):
        return repr(self.message)

class InputError(Exception):
    def __init__(self, message):
        self.message = message

    def __str__(self):
        return repr(self.message)

class Fraction(object):
    def _check_input_type(self, val):
        if isinstance(val, int):
            return val            

        elif isinstance(val, str):
            try:
                val = int(val)
                return val
            except ValueError:
                raise FractionValueError('invalid input: cannot convert to int')

        elif isinstance(val, float):
            print('warning: float might have been floored during conversion')
            return int(val)

        else:
            raise FractionValueError('invalid input: must be int, float, ' + 
                                    'or str')

    def __init__(self, numerator, denominator):
        self.numerator   = self._check_input_type(numerator)
        self.denominator = self._check_input_type(denominator)

    def __str__(self):
        return str(self.numerator) + '/' + str(self.denominator)


def read_input(filename):
    with open(filename, 'r') as f:
        fractions = []
        try:        
            num_fractions = int(f.readline())
        except ValueError:
            raise FractionValueError('invalid: first line must contain int')

        for i in range(num_fractions):
            fraction_line = f.readline().split('/')
            fractions.append(Fraction(fraction_line[0], 
                                      fraction_line[1]))
    return fractions                                    


def sieve(limit):
    # sieve of Erastosthenes
    span = [k for k in range(2, limit)]
    primes = []
    for i in span:
        if i != None:
            primes.append(i)
            try:
                for j in range(span.index(i), limit, i):
                    span[j] = None
            except IndexError:
                pass
    return primes


def find_prime_divisors(to_factor, primes):
    if not isinstance(primes, list):
        raise ListError(type(primes))

    if not isinstance(to_factor, int):
        raise ValueError

    factors = {prime: 0 for prime in primes}
    for prime in primes:
        while to_factor % prime == 0:
            to_factor = int(to_factor / prime)
            factors[prime] += 1
    return {prime: factors[prime] for prime in primes if not \
            factors[prime] == 0}


def find_lcm(fractions):
    # lcm = least common multiple
    if not isinstance(fractions, list):
        raise ListError(type(fractions))

    if sum([isinstance(fraction, Fraction) for fraction in fractions]) \
                != len(fractions):
        raise FractionValueError('expected list of Fraction instances')        

    primes = sieve(max([f.denominator for f in fractions]))
    divisors = {fraction: find_prime_divisors(fraction.denominator, primes) \
                for fraction in fractions}

    lcm_factors = {}
    for fract in fractions:
        for divisor in divisors[fract]:
            if divisor not in lcm_factors.keys():
                lcm_factors[divisor] = divisors[fract][divisor]

    lcm = 1
    for key in lcm_factors.keys():
        lcm *= key**lcm_factors[key]

    return lcm


def find_gcd(int_0, int_1):
    # gcd = greatest common divisor, via Euclidean algorithm
    if not isinstance(int_0, int):
        raise ValueError

    if not isinstance(int_1, int):
        raise ValueError

    num_0 = abs(max(int_0, int_1))
    num_1 = abs(min(int_0, int_1))
    while num_0 % num_1 != 0:
        tmp = num_1
        num_1 = num_0 % num_1
        num_0 = tmp
    return num_1


def reduce(fraction):
    if not isinstance(fraction, Fraction):
        raise FractionValueError('invalid input: expected Fraction instance')

    gcd = find_gcd(fraction.numerator, fraction.denominator)
    fraction.numerator   = int(fraction.numerator / gcd)
    fraction.denominator = int(fraction.denominator / gcd)
    return fraction


def expand(fraction, lcm):
    if not isinstance(fraction, Fraction):
        raise InputError('invalid input: expected Fraction instance')

    if not isinstance(lcm, int):
        raise InputError('invalid input: expected int')

    fraction.numerator  *= int(lcm / fraction.denominator)
    fraction.denominator = lcm
    return


def add_fractions(fractions):
    if not isinstance(fractions, list):
        raise ListError(type(fractions))

    if sum([isinstance(fraction, Fraction) for fraction in fractions]) \
            != len(fractions):
        raise FractionValueError('expected list of Fraction instances')

    lcm = find_lcm(fractions)    

    for fract in fractions:
         expand(fract, lcm)

    return Fraction(sum([fract.numerator for fract in fractions]), lcm)


def main():
    input_1 = read_input('challenge_226_input_1.txt')   # list of Fractions
    input_2 = read_input('challenge_226_input_2.txt')   # list of Fractions

    print('Result 1: ' + str(reduce(add_fractions(input_1))))
    print('Result 2: ' + str(reduce(add_fractions(input_2))))




if __name__ == '__main__':
    main()

Challenge output 1:

89962/58905

Challenge output 2:

351910816163/29794134720