The purpose of this series is developing understanding of stastical problems in AS and A level maths. Let's get started with a simple concept in statistics: Mutually exclusive events.

The probability of an OR event is calculated by the following rule:

`P(A || B) = P(A) + P(B) - P(A && B)`

The probability of event A or event B happening is equal to the probability of event A plus the probability of event B minus the probability of event A and event B happening simultaneously.

Mutually exclusive events are events that cannot happen at the same time. For example, the head and tail results of a toin coss are mutually exclusive because they can't both happen at once. Thus, the above example for a coin toss would look like this:

`P(H || T) = P(H) + P(T) - P(H && T)`

Note that the probaility of tossing a coin and the result being both head and tails is 0.

`P(H || T) = (0.5) + (0.5) - (0)`
`P(H || T) = 1`

Thus the probability of a coin toss result being a heads or a tails is 1, in other words: certain.


Your task:

You are going to have to work out the probability of one roll of a die returning two given outcomes, or rolls. Given that dice rolls are mutually exclusive, you will have to implement the above forumala. To make this interesting (this is a coding challenge after all), these dice are not fair and thus the probabilites of receiving each roll is different.

You will be given a two-dimensional array containing the number each of the results (1-6) of the die and the probability of that roll for example `[1 , 0.23]` as well as the two rolls for example `1` and `5`. 

Given the two roll probabilities to calculate, return the probability of a single roll of the die returning either. If the total probability of the six rolls doesn't add up to one, there is a problem with the die; in this case, return null. 
Return your result as a string to two decimal places.

Example below:

`1 : 1/6`

`2 : 1/6`

`3 : 1/6`

`4 : 1/6`

`5 : 1/6`

`6 : 1/6`

If asked for the rolls `1` and `2` then you would need to sum the probabilities, both `1/6` therefore `2/6` and return this. As above, you will need to return it as a decimal and not a  fraction.

Difficulty: introductory

Starter code:

def mutually_exclusive(dice, call1, call2):
	

Solutions:
def mutually_exclusive(dice, call1, call2):
    dice = dict(dice)
    if abs(sum(dice.values()) - 1) < 1e-12:
        return '%0.2f' % (dice[call1] + dice[call2])

def mutually_exclusive(dice, call1, call2):
    if sum(prob for _, prob in dice) != 1:
        return None
    x = dict(dice)
    return format(x[call1] + x[call2], '.2f')

def mutually_exclusive(dice, call1, call2):
    d = dict(dice)
    return '{:0.2f}'.format(d[call1] + d[call2]) if 0.999 < sum(d.values()) < 1.001 else None

def mutually_exclusive(dice, call1, call2):   
    prob = 0
    tprob = 0
    for i in dice:
        if i[0] == call1 or i[0] == call2:
            prob += i[1]
            
        tprob += i[1]
    
    return '{:.2f}'.format(prob) if tprob == 1 else None

def mutually_exclusive(dice, call1, call2):
    dice.sort()
    if sum(pair[1] for pair in dice) != 1:
        return None
    else:
        return '{:.2f}'.format(dice[call1-1][1] + dice[call2-1][1])

def mutually_exclusive(dice, call1, call2):
    dice = {a: b for a, b in dice}
    return None if sum(dice.values()) != 1 else f'{float(dice[call1] + dice[call2]):.02f}'


def mutually_exclusive(dice, call1, call2):
    prob_of_each_roll = []
    for roll in dice:
        prob_of_each_roll.append(roll[1])
        if roll[0] == call1:
            p1 = roll[1]
        if roll[0] == call2:
            p2 = roll[1]
    if sum(prob_of_each_roll) != 1:
        return
    else:
        total_prob = (p1 + p2)
        return ("{:.2f}".format(total_prob))

def mutually_exclusive(dice, call1, call2):
    prob_of_each_roll = []
    for roll in dice:
        prob_of_each_roll.append(roll[1])
        if roll[0] == call1:
            p1 = roll[1]
        if roll[0] == call2:
            p2 = roll[1]
    if sum(prob_of_each_roll) != 1:
        return
    else:
        total_prob = round((p1 + p2),2)
        return ("{:.2f}".format(total_prob))

def mutually_exclusive(dice, call1, call2):
    checknull = 0
    diecall1 = 0
    diecall2 = 0
    for die in dice:
        #[3,0.4]
        checknull += die[1]
        if die[0] == call1:
            diecall1 = die[1]
        elif die[0] == call2:
            diecall2 = die[1] 
    if checknull != 1:
        return None
    else:
        return format((diecall1 + diecall2), ".2f")

def mutually_exclusive(dice, call1, call2):
    checknull = 0
    diecall1 = 0
    diecall2 = 0
    for die in dice:
        #[3,0.4]
        checknull += die[1]
        if die[0] == call1:
            diecall1 = die[1]
        elif die[0] == call2:
            diecall2 = die[1] 
    if checknull != 1:
        return None
    else:
        return format((diecall1 + diecall2), ".2f")#- (diecall1*diecall2),2)) #:[
        
#dice = [[3,0.4],[4,0.1],[1,0.01],[2,0.09],[5,0.2],[6,0.1]]