A group of friends (n >= 2) have reunited for a get-together after 
a very long time. 

They agree that they will make presentations on holiday destinations 
or expeditions they have been to only if it satisfies **one simple rule**: 
> the holiday/journey being presented must have been visited _only_ by the presenter and no one else from the audience.

Write a program to output the presentation agenda, including the
presenter and their respective presentation titles. 

---
### EXAMPLES

```python
presentation_agenda([
    {'person': 'Abe', 'dest': ['London', 'Dubai']},
    {'person': 'Bond', 'dest': ['Melbourne', 'Dubai']}
]) == [{'person': 'Abe', 'dest': ['London']},
       {'person': 'Bond', 'dest': ['Melbourne']}]

presentation_agenda([
    {'person': 'Abe', 'dest': ['Dubai']},
    {'person': 'Brad', 'dest': ['Dubai']}
]) == []

presentation_agenda([
    {'person': 'Abe', 'dest': ['London', 'Dubai']},
    {'person': 'Bond', 'dest': ['Melbourne', 'Dubai']},
    {'person': 'Carrie', 'dest': ['Melbourne']},
    {'person': 'Damu', 'dest': ['Melbourne', 'Dubai', 'Paris']}
]) == [{'person': 'Abe',  'dest': ['London']},
       {'person': 'Damu', 'dest': ['Paris']}]

```

Difficulty: introductory

Starter code:

def presentation_agenda(friend_list):
	

Solutions:
from collections import Counter

def presentation_agenda(friend_list):
    uniqueDest    = {d for d,c in Counter(d for p in friend_list for d in p['dest']).items() if c == 1}
    pFilteredDest = tuple((p['person'], [d for d in p['dest'] if d in uniqueDest]) for p in friend_list)
    return [{'person': name, 'dest': lst} for name,lst in pFilteredDest if lst]

def presentation_agenda(friend_list):
    out = []
    for friend in friend_list:
        p_list = friend['dest'] 
        for f in friend_list:
            p_list = [loc for loc in p_list if f == friend or loc not in f['dest']]
        if len(p_list):
            out.append({'person': friend['person'], 'dest': p_list})
    return out

from operator import itemgetter
from collections import Counter
from itertools import chain

def presentation_agenda(friend_list):
    okay = {k for k,v in Counter(chain.from_iterable(map(itemgetter('dest'), friend_list))).items() if v == 1}.__contains__
    result = []
    for friend in friend_list:
        temp = list(filter(okay, friend['dest']))
        if temp: result.append({'person':friend['person'], 'dest':temp})
    return result

def presentation_agenda(friend_list):
    result = []
    for i, friend in enumerate(friend_list):
        ds = {x for j, f in enumerate(friend_list) if j != i for x in f['dest']}
        xs = [x for x in friend['dest'] if x not in ds]
        if xs:
            result.append({'person': friend['person'], 'dest': xs})
    return result

from functools import reduce 
def presentation_agenda(friend_list):
    def add_exclusive_locations(agenda, presenter):
        def is_unique(location):
            return False if any(location in friend['dest'] 
                for friend in filter(lambda f: f != presenter, friend_list)
            ) else True

        exclusive = list(filter(is_unique, presenter['dest']))
        if exclusive:
            agenda.append({'person': presenter['person'], 'dest': exclusive})
        return agenda
            
    return reduce(add_exclusive_locations, friend_list, []); 

from functools import reduce 
def presentation_agenda(friend_list):
    
    def add_exclusive_locations(agenda, friend):
        
        def is_unique(loc):
            return all(peer == friend or loc not in peer['dest'] 
                          for peer in friend_list
                      )
            
        exclusive = list(filter(is_unique, friend['dest']))
        if exclusive: 
            agenda.append({'person': friend['person'], 'dest': exclusive})
        return agenda
            
    return reduce(add_exclusive_locations, friend_list, []); 

from functools import reduce 
def presentation_agenda(friend_list):

    def add_exclusive_locations(agenda, friend):
        locations_visited_by_peers = reduce(
                lambda lst, p: lst + p['dest'] if p != friend else lst,
                friend_list,
                []
        )
  
        def is_unique(loc): 
            return loc not in locations_visited_by_peers
            
        exclusive = list(filter(is_unique, friend['dest']))
        if exclusive: # at least one location?
            agenda.append({'person': friend['person'], 'dest': exclusive})
        return agenda
            
    return reduce(add_exclusive_locations, friend_list, []); 

from copy import deepcopy

def presentation_agenda(presentation_agenda):
    data = deepcopy(presentation_agenda)
    for person in data:
        
        B = []
        for p in presentation_agenda:
            if p['person'] != person['person']:
                B += p['dest']
        person['dest'] = sorted( list( set(person['dest']) - set(B) ) )
    
    return [person for person in data if person['dest']]


def presentation_agenda(friend_list):
    out = []
    for friend in friend_list:
        p_list = friend['dest']
        sub_list = [x for x in friend_list if x != friend]
        for f in sub_list:
            p_list = [loc for loc in p_list if loc not in f['dest']]
        if len(p_list):
            out.append({'person': friend['person'], 'dest': p_list})
    return out


from collections import Counter

def presentation_agenda(friend_list):
    all_dests = sum((friend['dest'] for friend in friend_list), [])
    uniq_dests = [dest for dest, count in Counter(all_dests).items() if count == 1]
    agenda = []
    for friend in friend_list:
        uniq = [x for x in friend['dest'] if x in uniq_dests]
        if uniq:
            agenda.append({'person': friend['person'], 'dest': uniq})
    return agenda