DEV Community


Posted on • Originally published at

Python Exercise 14: sum of fractions


  • Create a function that takes a list containing nested lists as an argument.
  • Each sublist has 2 elements.
  • The first element is the numerator and the second element is the denominator.
  • Return the sum of the fractions rounded to the nearest whole number.


sum_fractions([[18, 13], [4, 5]]) ➞ 2

sum_fractions([[36, 4], [22, 60]]) ➞ 9

sum_fractions([[11, 2], [3, 4], [5, 4], [21, 11], [12, 6]]) ➞ 11
Enter fullscreen mode Exit fullscreen mode

My solution

  • algorithm
>>separate the sublist in the nested list
  iterate over the nested list
>>separate elementes in the sublist
  iterate over the sublist
>>for each sublist, calculate the fraction
  set the first element to the numerator 
  set the second element is the denominator
  store the result to a variable called:total
>>return the variable total

Enter fullscreen mode Exit fullscreen mode
  • code
def sum_fractions(nested_list:list):  
    total = 0  
    list_of_sum = list()  
    for sublist in nested_list:  
        division = int(sublist[0]) / int(sublist [1])  
        total += division  
    return round(total)  
Enter fullscreen mode Exit fullscreen mode

Other solution

  • unpacking the sublist by multiple assignment
    • i.e. use numerator for the first element of the sublist
      • use denominator for the second element of the sublist
def sum_fractions(lst):
    return round(sum(numerator/ denominator for numerator, denominator in lst))
Enter fullscreen mode Exit fullscreen mode

My reflection

  • I have learned using multiple assignment instead of using index to access the value of a list.


Top comments (2)

mellen profile image
Matt Ellen

Fun little problem! Here's my solution, using the way we were taught to add fractions at school 😋 (I added in fraction reduction for extra spice!)

from math import gcd

def reduce_fraction(fraction):
    hcf = gcd(fraction[0], fraction[1])
    return [fraction[0]//hcf, fraction[1]//hcf]

def sum_of_fractions(fractions):
    total = fractions.pop()
    while len(fractions) > 0:
        next = fractions.pop()
        bottom = total[1] * next[1]
        topLeft = next[1] * total[0];
        topRight = next[0] * total[1]
        total = [topLeft + topRight, bottom]
    return reduce_fraction(total)

test = [[11, 2], [3, 4], [5, 4], [21, 11], [12, 6]]

fraction_sum = sum_of_fractions(test[:])

result = round(fraction_sum[0]/fraction_sum[1])

print(f'The sum of {test} fractions is {fraction_sum}, which is {result} to the nearest integer')

Enter fullscreen mode Exit fullscreen mode
mathewchan profile image

Interesting method, just learn a syntax(test[:]) from you. Also good exercise for me to read long code from others.