def unique_day(day, possible_birthdays):
    days = ()
    unique = ()
    for i in possible_birthdays:
        days += (i[1],)
    for i in days:
        if i == day:
            unique += (i,)
        else:
            continue
    if len(unique) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    unique = ()
    for i in possible_birthdays:
        months += (i[0],)
    for i in months:
        if i == month:
            unique += (i,)
        else:
            continue
    if len(unique) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    selected_month = ()
    unique = ()
    for i in possible_birthdays:
        if i[0] == month:
            selected_month += (i,)
        else:
            continue
    for i in selected_month:
        if unique_day(i[1], possible_birthdays) == True:
            return True
    return False


def unique_day(date, possible_birthdays):
    counter=0
    for i in possible_birthdays:
        if i[1]==date:
            counter+=1
        else:
            counter=counter
    if counter==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if date[0]==month:
            counter+=1
        else:
            counter=counter
    if counter==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    date=()
    for mon in possible_birthdays:
        if month ==mon[0]:
            date+=(mon,)
        else:
            date=date
    days=()
    for day in date:
        days+=(day[1],)
    y=()
    for x in days:
        if unique_day(x, possible_birthdays)==True:
            y+=(x,)
        else:
            y=y
    if y==():
        return False
    else:
        return True

tuple_of_possible_birthdays = (('May', '15'),
                              ('May', '16'),
                              ('May', '19'),
                              ('June', '17'),
                              ('June', '18'),
                              ('July', '14'),
                              ('July', '16'),
                              ('August', '14'),
                              ('August', '15'),
                              ('August', '17'))

assert unique_day("1", (("January","1"),("February","1")))==False and unique_month("January", (("January","1"),("January","2")))==False and unique_month("January", (("January","1"),("February","1")))==True and contains_unique_day("January", (("January","1"),("January","2")))==True and contains_unique_day("January", (("January","1"),("February","1")))==False and contains_unique_day("February", (("January","10"),("February","1"),("February","10")))==True and unique_day("3", (("January","1"),("January","2")))==False and unique_month("March", (("January","1"),("February","1")))==False and unique_day("1", (("January","1"),("January","2")))==True and unique_day("16", tuple_of_possible_birthdays)==False and unique_day("17", tuple_of_possible_birthdays)==False and unique_day("18", tuple_of_possible_birthdays)==True and unique_day("19", tuple_of_possible_birthdays)==True and unique_month("May", tuple_of_possible_birthdays)==False and unique_month("June", tuple_of_possible_birthdays)==False and contains_unique_day("June", tuple_of_possible_birthdays)==True and contains_unique_day("July", tuple_of_possible_birthdays)==False

Task: Unique dates and months

Implement unique_day, unique_month and contains_unique_day.


def unique_day(day, possible_birthdays):
    count = 0
    for x in possible_birthdays:
      if day == x[1]:
        count += 1
    if count == 1:
      return True
    else:
      return False

def unique_month(month, possible_birthdays):
    count = 0
    for x in possible_birthdays:
      if month == x[0]:
        count += 1
    if count == 1:
      return True
    else:
      return False

def contains_unique_day(month, possible_birthdays):
  possible_days = ()
  for x in possible_birthdays:
    if x[0] == month:
      possible_days += (x,)
  for day in possible_days:
    if unique_day(day[1], possible_birthdays) == True:
      return True
  else:
    return False


def count_dates(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count += 1
    return count

def unique_day(date, possible_birthdays):
    if count_dates(date, possible_birthdays) == 1:
        return True
    else:
        return False

def count_months(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count += 1
    return count

def unique_month(month, possible_birthdays):
    if count_months(month, possible_birthdays) == 1:
        return True
    else:
        return False

def days(month, possible_birthdays):
    days_in_month = ()
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            days_in_month += (possible_birthdays[i],)
    return days_in_month

def contains_unique_day(month, possible_birthdays):
    for x in range(len(days(month, possible_birthdays))):
        if unique_day(days(month, possible_birthdays)[x][1], possible_birthdays):
            return True
        elif unique_day(days(month, possible_birthdays)[len(days(month, possible_birthdays))-1][1], possible_birthdays) == False:
            return False


def unique_day(date, possible_birthdays):
    dates = ()
    for d in possible_birthdays:
        dates += (d[1],)
    if dates.count(date) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    for a in possible_birthdays:
        months += (a[0],)
    if months.count(month) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    dates = ()
    for z in possible_birthdays:
        if unique_day(z[1], possible_birthdays):
            dates += (z,)
        else:
            continue
    for i in dates:
        if i[0] == month:
            return True
    else:
        return False


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count +=1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if unique_day(birthday[1],possible_birthdays):
            months = birthday[0]
            if months == month:
                return True
            else:
                continue
        else:
            continue
    return False


def unique_day(date, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[1]==date:
            count+=1
    if count!=1:           #if not can put count==1
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[0]==month:
            count+=1
    if count!= 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    new_possible_birthdays = ()
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
           new_possible_birthdays += (possible_birthdays[i],)
    new_day = ""
    counter = 0
    for n in range(len(new_possible_birthdays)):
        new_day = new_possible_birthdays[n][1]
        if unique_day(new_day,possible_birthdays) == True:
            counter += 1
    if counter == 0:
        return False
    else:
        return True


def unique_day(date, possible_birthdays):
    counter = 0
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][1] == date:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            if unique_day(possible_birthdays[i][1],possible_birthdays):
                return True
    return False


def unique_day(date, possible_birthdays):
    counter = 0
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][1] == date:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in range(0,len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            if unique_day(possible_birthdays[i][1],possible_birthdays):
                return True
    else:
        return False


def unique_day(day, possible_birthdays):
    counter = 0
    for j in possible_birthdays:
        if day == j[1]:
            counter += 1
    if counter != 1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    counter = 0
    for j in possible_birthdays:
        if month == j[0]:
            counter +=1
    if counter != 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    for j in possible_birthdays:
        if month != j[0]:
            continue
        else:
            if unique_day(j[1],possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    checker=0
    for k in possible_birthdays:
        if k[1]==day:
          checker+=1
    return checker==1

def unique_month(day, possible_birthdays):
    checker=0
    for k in possible_birthdays:
        if k[0]==day:
          checker+=1
    return checker==1

def contains_unique_day(month, possible_birthdays):
    collect=()
    for i in possible_birthdays:
      if i[0]==month:
        collect+=(i[1],)
    for i in collect:
      if unique_day(i,possible_birthdays):
        return True
    return False


def unique_day(day, possible_birthdays):
    days = tuple(map(lambda x: x[1], possible_birthdays))
    count = 0
    for temp_day in days:
        if temp_day == day:
            count+=1
    return True if count == 1 else False

def unique_month(month, possible_birthdays):
    months = tuple(map(lambda x: x[0], possible_birthdays))
    count = 0
    for temp_month in months:
        if temp_month==month:
            count+=1
    return True if count == 1 else False

def contains_unique_day(month, possible_birthdays):
    temp_days = tuple(map(lambda x: x[1] ,filter(lambda x: x[0]==month,possible_birthdays)))
    for temp_day in temp_days:
        if unique_day(temp_day, possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    product = 0
    for i in possible_birthdays:
        if i[1] == day:
            product +=1
    if product == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    product = 0
    for i in possible_birthdays:
        if i[0] == month:
            product +=1
    if product == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month and unique_day(i[1], possible_birthdays) == True:
            return True
    else:
        return False


def unique_day(day, possible_birthdays):
    occurence = 0
    for date in possible_birthdays:
        if day == date[1]:
            occurence +=1
    if occurence == 0 or occurence > 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    occurence = 0
    for date in possible_birthdays:
        if month == date[0]:
            occurence +=1
    if occurence == 0 or occurence > 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    more_possible_dates = filter(lambda date: date[0] == month, possible_birthdays)
    for date in more_possible_dates:
        if unique_day(date[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for birthday in possible_birthdays:
        birthday_day = birthday[1]
        if day == birthday_day:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for birthday in possible_birthdays:
        birthday_month = birthday[0]
        if month == birthday_month:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    birthday_days_in_month = ()
    for birthday in possible_birthdays:
        if month == birthday[0]:
            birthday_days_in_month += (birthday[1],)
    day_counter = 0
    for day in birthday_days_in_month:
        if unique_day(day, possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter=0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            counter+=1
    if counter==1:
        return True
    return False

def unique_month(month, possible_birthdays):
    counter=0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            counter+=1
    if counter==1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if month==birthday[0] and unique_day(birthday[1],possible_birthdays)==True:
            return True
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if day == i[1]:
            result = result + 1

    if result == 1:
        return True

    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if month == i[0]:
            result = result + 1

    if result == 1:
        return True

    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if month == i[0]:
            if unique_day(i[1], possible_birthdays) == True:
                return True

    return False


def unique_day(date, possible_birthdays):
    j = 0
    for i in possible_birthdays:
        if date == i[1]:
            j = j+1
        else:
            j = j
    if j == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    j = 0
    for i in possible_birthdays:
        if month == i[0]:
            j = j+1
        else:
            j = j
    if j == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    dayi = ()
    result = False
    for i in possible_birthdays:
        if month == i[0]:
            dayi += (i[1],)
    for j in dayi:
        result = result or unique_day(j, possible_birthdays)
    return result


def unique_day(day, possible_birthdays):
    count = 0
    for element in possible_birthdays:
        if element[1] == day:
            count += 1
    if count != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    count = 0
    for element in possible_birthdays:
        if element[0] == month:
            count += 1
    if count != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    month_collection = ()
    outside_month_collection = ()
    for element in possible_birthdays:
        if element[0] == month:
            month_collection += (element, )
        else:
            outside_month_collection += (element, )
    for days in month_collection:
        count = 0
        for dates in outside_month_collection:
            if days[1] == dates[1]:
                count += 1
        if count == 0:
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == day:
            count = count + 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count = count + 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1], possible_birthdays) == True:
                return True
    else:
        return False


def unique_day(day, possible_birthdays):
    counter = 0
    for x in possible_birthdays:
        if day == x[1]:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for x in possible_birthdays:
        if month == x[0]:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    temp = [x for x in possible_birthdays if x[0] == month]
    temp = tuple(temp)
    counter = 0
    for x in temp:
        if unique_day(x[1], possible_birthdays):
            counter += 1
    if counter > 0:
        return True
    else:
        return False


def unique_day(day, possible_birthdays):
    counter = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            counter += 1
    return counter == 1

def unique_month(month, possible_birthdays):
    counter = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            counter += 1
    return counter == 1

def contains_unique_day(month, possible_birthdays):
    truth_holder = False
    for birthday in possible_birthdays:
        if birthday[0] != month:
            continue
        else:
            truth_holder = truth_holder or unique_day(birthday[1], possible_birthdays)
    return truth_holder


def unique_day(date, possible_birthdays):
    count = 0
    for bday in possible_birthdays:
        if date == bday[1]:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for bday in possible_birthdays:
        if month == bday[0]:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    for bday in possible_birthdays:
        if month == bday[0]:
            if unique_day(bday[1], possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    #generate boolean array of whether tuple matches day
    days = sum(map(lambda x: x[1]==day,possible_birthdays))
    return days == 1

def unique_month(month, possible_birthdays):
    #generate boolean array of whether tuple matches month
    months = sum(map(lambda x: x[0]==month,possible_birthdays))
    return months == 1

def contains_unique_day(month, possible_birthdays):
    this_month = filter(lambda x: x[0]==month,possible_birthdays)
    days_in_this_month = tuple(map(lambda x: x[1],this_month))
    for i in range(1,31):
        if unique_day(str(i),possible_birthdays) and str(i) in days_in_this_month:
            return True
    return False


def unique_day(day, possible_birthdays):
    a  = 0
    for date in possible_birthdays:
        cb = date[1]
        if day == cb:
            a+= 1
        else:
            continue
    if a==1:
        return True
    else:
        return False
def unique_month(month, possible_birthdays):
    a = 0
    for date in possible_birthdays:
        lj = date[0]
        if month == lj:
           a+= 1
        else:
            continue
    if a == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    #find the possible days in that month
    #determine if they are unique days one by one
    possible_days = ()
    for date in possible_birthdays:
        if month == date[0]:
            possible_days += (date[1],)
        else:
            continue
    for day in possible_days:
        if unique_day(day,possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    x = ()
    for i in range (0,len(possible_birthdays)):
        x += (possible_birthdays[i][-1],)
    if x.count(day) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    y = ()
    for i in range (0,len(possible_birthdays)):
        y += (possible_birthdays[i][0],)
    if y.count(month) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for x in possible_birthdays:
        if month == x[0]:
            if unique_day(x[-1],possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if day == date[1]:
            counter+=1
    return counter==1

def unique_month(month, possible_birthdays):
    counter=0
    for date in possible_birthdays:
        if month == date[0]:
            counter+=1
    return counter==1

def contains_unique_day(month, possible_birthdays):
    for date in possible_birthdays:
        if month==date[0]:
            if unique_day(date[1], possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for date in possible_birthdays:
        if date[1] == day:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for mon in possible_birthdays:
        if mon[0] == month:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    filter_by_month = tuple( filter(lambda x: x[0] == month, possible_birthdays))
    for date in filter_by_month:
        if unique_day(date[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    count = tuple(filter(lambda x: x[1] == day, possible_birthdays))
    if len(count) == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    count = tuple(filter(lambda x: x[0] == month, possible_birthdays))
    if len(count) == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    T_or_F = False
    for i in possible_birthdays:
        if i[0] == month and unique_day(i[1], possible_birthdays):
            T_or_F = T_or_F or True
    return T_or_F


def unique_day(day, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if i[1] == day:
            result += 1
        elif i[1] != day:
            result += 0
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if i[0] == month:
            result += 1
        elif i[0] != month:
            result += 0
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1],possible_birthdays):
                return True
            else:
                continue
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    count = 0
    alldays = ()
    for i in possible_birthdays:
        alldays += (i[1],)
    for i in alldays:
        if day == i:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    allmonths = ()
    for i in possible_birthdays:
        allmonths += (i[0],)
    for i in allmonths:
        if month == i:
            count += 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    count = 0
    matchmonth = ()
    for i in possible_birthdays:
        if month == i[0]:
            matchmonth += (i,)
    for i in matchmonth:
        if unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter += 1
        else:
            continue
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter += 1
        else:
            continue
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    counter = 0
    dummy = ()
    indicator = ()
    for i in possible_birthdays:
        if month == i[0]:
            dummy += (i,)
    for i in dummy:
        indicator += (unique_day(i[1],possible_birthdays),)
    if True not in indicator:
        return False
    else:
        return True


def unique_day(day, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[1]==day:
            count+=1
    return count==1

def unique_month(month, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[0]==month:
            count+=1
    return count==1

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0]==month:
            if unique_day(i[1],possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter = counter + 1
    if counter != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter = counter + 1
    if counter != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    count_of_days = ()
    for i in possible_birthdays:
        if month == i[0]:
            count_of_days = count_of_days + (i[1], )
    for i2 in count_of_days:
        if unique_day(i2, possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    count, result = 0, 0
    for count in range(0, len(possible_birthdays)):
        if day == possible_birthdays[count][1]:
            result = result + 1
        else:
            continue
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count, result = 0, 0
    for count in range(0, len(possible_birthdays)):
        if month == possible_birthdays[count][0]:
            result = result + 1
        else:
            continue
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for day in possible_birthdays:
        if month == day[0]:
            if unique_day(day[1], possible_birthdays):
                return True
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    b=[]  # list of dates
    for birthday in possible_birthdays:
        b.append(birthday[1])
    if b.count(day)==1:
        return True

    return False

def unique_month(month, possible_birthdays):
    b=[]
    for birthday in possible_birthdays:
        b.append(birthday[0])
    if b.count(month)==1:
        return True

    return False

def contains_unique_day(month, possible_birthdays):
    b=[]
    for birthday in possible_birthdays:
        if month == birthday[0]:
            b.append(birthday[1])  #add date to b
    for day in b:
        if unique_day(day,possible_birthdays)==True:
            return True

    return False


def unique_day(day, possible_birthdays):
    days = ()
    for i in possible_birthdays:
        days += (i[1],)
    count = 0
    for ele in days:
        if ele == day:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    for i in possible_birthdays:
        months += (i[0],)
    count = 0
    for ele in months:
        if ele == month:
            count += 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    possible_birthdays_in_month = tuple(filter(lambda x: x[0] == month, possible_birthdays))
    for i in possible_birthdays_in_month:
        if unique_day(i[1], possible_birthdays):
            return True
    else:
        return False


def unique_day(day, possible_birthdays):
    x = ()
    y = ()
    for i in possible_birthdays:
        x += (i[1],)
    for i in x:
        if i == day:
            y += (i,)
        else:
            continue
    if len(y) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    x = ()
    y = ()
    for i in possible_birthdays:
        x += (i[0],)
    for i in x:
        if i == month:
            y += (i,)
        else:
            continue
    if len(y) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    x = ()
    y = ()
    for i in possible_birthdays:
        if i[0] == month:
            x += (i,)
        else:
            continue
    for i in x:
        if unique_day(i[1], possible_birthdays) == True:
            return True
    return False


def unique_day(date, possible_birthdays):
    if len(tuple(filter(lambda x: x[1] == date ,possible_birthdays))) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    if len(tuple(filter(lambda x: x[0] == month ,possible_birthdays))) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    birthdays = tuple(filter(lambda x: x[0] == month ,possible_birthdays))
    for i in birthdays:
        if unique_day(i[1], possible_birthdays) == True:
            return True
    else:
        return False


def unique_day(date, possible_birthdays):
    count = 0
    for tup in possible_birthdays:
        if tup[1] == date:
            count+=1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for tup in possible_birthdays:
        if tup[0] == month:
            count+=1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    month_tup = ()
    for tup in possible_birthdays:
        if month in tup:
            month_tup += (tup,)
    for tup in month_tup:
        if unique_day(tup[1],possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter =0
    for elements in possible_birthdays:
        if day == elements[1]:
            counter +=1
    return counter == 1

def unique_month(month, possible_birthdays):
    counter =0
    for elements in possible_birthdays:
        if month == elements[0]:
            counter +=1
    return counter == 1

def contains_unique_day(month, possible_birthdays):
    tupleofdays=()
    for elements in possible_birthdays:
        if elements[0]==month:
            tupleofdays += (elements[1],)
    for elements in tupleofdays:
        if unique_day(elements,possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    days = ()
    for elem in possible_birthdays:
        days += (elem[1],)
    times = days.count(day)
    if times == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    for elem in possible_birthdays:
        months += (elem[0],)
    times = months.count(month)
    if times == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    bdays_in_month = ()
    for elem in possible_birthdays:
        if elem[0] == month:
            bdays_in_month += (elem[1],)
        else:
            bdays_in_month = bdays_in_month
    for el in bdays_in_month:
        if unique_day(el, possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[1] == day:
            counter += 1
    if counter == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[0] == month:
            counter += 1
    if counter == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0] and unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(date, possible_birthdays):
    counter = 0
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][1] == date:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    monies = ()
    for i in range(len(possible_birthdays)):
        if possible_birthdays[i][0] == month:
            monies += (possible_birthdays[i][1],)
    for i in range(len(monies)):
        if unique_day(monies[i], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    c=0
    for birthday in possible_birthdays:
        if day==birthday[1]:
            c+=1
    return c==1

def unique_month(month, possible_birthdays):
    c=0
    for birthday in possible_birthdays:
        if month==birthday[0]:
            c+=1
    return c==1

def contains_unique_day(month, possible_birthdays):
    d=map(lambda birthday:birthday[1],filter(lambda birthday:birthday[0]==month,possible_birthdays))
    for day in d:
        if unique_day(day,possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if month == birthday[0]:
            if unique_day(birthday[1], possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for x in possible_birthdays:
        if day in x:
            count += 1
    return count == 1

def unique_month(month, possible_birthdays):
    count = 0
    for x in possible_birthdays:
        if month in x:
            count += 1
    return count == 1

def contains_unique_day(month, possible_birthdays):
    possible_days = ()
    for x in possible_birthdays:
        if month in x:
            possible_days += (x[1],)
    for x in possible_days:
        contains = unique_day(x,possible_birthdays)
        if contains == False:
            continue
        else:
            return True
    return False


def unique_day(day, possible_birthdays):
    days = ()
    unique = ()
    for i in possible_birthdays:
        days += (i[1],)
    for i in days:
        if i == day:
            unique += (i,)
        else:
            continue
    if len(unique) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    unique = ()
    for i in possible_birthdays:
        months += (i[0],)
    for i in months:
        if i == month:
            unique += (i,)
        else:
            continue
    if len(unique) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    selected_month = ()
    unique = ()
    for i in possible_birthdays:
        if i[0] == month:
            selected_month += (i,)
        else:
            continue
    for i in selected_month:
        if unique_day(i[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    value = 0
    for i in range(0, len(possible_birthdays)):
        if (day == possible_birthdays[i][1]):
            value += 1
    if (value > 1) or (value == 0):
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    value = 0
    for i in range(0, len(possible_birthdays)):
        if (month == possible_birthdays[i][0]):
            value += 1
    if (value > 1) or (value == 0):
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    unique_days = ()
    for i in range(0, len(possible_birthdays)):
        if (unique_day(possible_birthdays[i][1], possible_birthdays) == True):
            unique_days += (possible_birthdays[i][1],)
    for j in range(0, len(unique_days)):
        if ((month, unique_days[j]) in possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    appearance = 0
    for i in possible_birthdays:
        if i[1] == day:
            appearance += 1
    if appearance == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    appearance = 0
    for i in possible_birthdays:
        if i[0] == month:
            appearance += 1
    if appearance == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1],possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if day == i[1]:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if month == i[0]:
            count += 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if month == i[0]:
            if unique_day(i[1], possible_birthdays):
               return True
               break
    return False


def unique_day(day, possible_birthdays):
    a=0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            a = a + 1
    if a == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    a=0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            a = a + 1
    if a == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    x = ()
    for birthday in possible_birthdays:
        mn,dy = birthday
        if mn == month:
            x = x + (dy,)
    for i in x:
        if unique_day(i,possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            count += 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for birthday in possible_birthdays:
        if month == birthday[0]:
            if unique_day(birthday[1], possible_birthdays) == True:
                return True
    return False


def unique_day(day, possible_birthdays):
    number=0
    for i in possible_birthdays:
        if i[1]==day:
            number+=1
    return number==1

def unique_month(month, possible_birthdays):
    number=0
    for i in possible_birthdays:
        if i[0]==month:
            number+=1
    return number==1

def contains_unique_day(month, possible_birthdays):
    number=0
    for i in possible_birthdays:
        if i[0]==month:
            if unique_day(i[1], possible_birthdays)== True:
                number+=1
    return number>0


def unique_day(day, possible_birthdays):
    if len(tuple(filter(lambda x: x[1] == day, possible_birthdays))) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    if len(tuple(filter(lambda x: x[0] == month, possible_birthdays))) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    total = ()
    i = 0
    while i < len(possible_birthdays):
        if possible_birthdays[i][0] == month:
            total = total + (possible_birthdays[i],)
        else:
            total = total
        i = i + 1
    for t in total:
        if unique_day(t[1], possible_birthdays) == True:
            return True
    return False


def unique_day(date, possible_birthdays):
    lenth=len(possible_birthdays)
    count=0
    for i in range(0,lenth):
        if date==possible_birthdays[i][1]:
            count=count+1
    if count==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    lenth=len(possible_birthdays)
    count=0
    for i in range(0,lenth):
        if month==possible_birthdays[i][0]:
            count=count+1
    if count==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    count=()
    for i in possible_birthdays:
        if i[0]==month:
            if i not in count:
                count=count+(i,)
    for j in count:
        if unique_day(j[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    a = 0
    for i in range(len(possible_birthdays)):
        if day == possible_birthdays[i][1]:
            a += 1
    if a == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    a = 0
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
            a += 1
    if a == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
            if unique_day(possible_birthdays[i][1], possible_birthdays) == True:
                return True
    else:
        return False


def unique_day(day, possible_birthdays):
    count=0
    for i in possible_birthdays:
        count+=i.count(day)
    if count==1:
        return True
    return False

def unique_month(month, possible_birthdays):
    count=0
    for i in possible_birthdays:
        count+=i.count(month)
    if count==1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    tup=tuple(filter(lambda x: x[0]==month,possible_birthdays))
    for i in range(len(tup)):
        if unique_day(tup[i][1],possible_birthdays)==True:
            return True
    return False


def unique_day(day, possible_birthdays):
    n=0
    for tup in possible_birthdays:
        if tup[1]==day:
            n+=1
    if n==1:
        return True
    return False

def unique_month(month, possible_birthdays):
    n=0
    for tup in possible_birthdays:
        if tup[0]==month:
            n+=1
    if n==1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    n=0
    for tup in possible_birthdays:
        if tup[0]==month:
            if unique_day(tup[1],possible_birthdays):
                n+=1
    if n>=1:
        return True
    return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            count += 1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if month == i[0]:
            count += 1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    months = ()
    for i in possible_birthdays:
        if i[0] == month:
            months = months + (i,)
        else:
            continue
    for i in months:
        if unique_day(i[1], possible_birthdays) == True:
            return True
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    unique = ()
    for i in possible_birthdays:
        if unique_day(i[1], possible_birthdays):
            unique += (i,)
    for i in unique:
        if month == i[0]:
            return True
    else:
        return False


def unique_day(day, possible_birthdays):
    n = len(possible_birthdays)
    result = 0
    for counter in range(n):
        if day == possible_birthdays[counter][1]:
            result = result + 1
    return result == 1

def unique_month(month, possible_birthdays):
    n = len(possible_birthdays)
    result = 0
    for counter in range(n):
        if month == possible_birthdays[counter][0]:
            result = result + 1
    return result == 1

def contains_unique_day(month, possible_birthdays):
    n = len(possible_birthdays)
    for counter in range(n):
        if month == possible_birthdays[counter][0]:
            if unique_day(possible_birthdays[counter][1], possible_birthdays) == True:
                return True
    return False


def unique_day(day, possible_birthdays):
    dates = map(lambda x: x[1], possible_birthdays)
    counter = 0
    for date in dates:
        if day == date:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = map(lambda x: x[0], possible_birthdays)
    counter = 0
    for i in months:
        if month == i:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    days_in_month = map(lambda x: x[1] if x[0] == month else (), possible_birthdays)
    check = map(lambda x: unique_day(x, possible_birthdays), days_in_month)
    return True in check


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count = count + 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count = count + 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    same_month_tuple = ()
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            same_month_tuple = same_month_tuple + (i,)
    for i in same_month_tuple:
        if unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(date, possible_birthdays):
    total= 0
    for i in possible_birthdays:
        if date == i[1]:
            total= total + 1
    return total == 1

def unique_month(month, possible_birthdays):
    total= 0
    for i in possible_birthdays:
        if month == i[0]:
            total= total + 1
    return total == 1

def contains_unique_day(month, possible_birthdays):
    for a in possible_birthdays:
        if unique_day(a[1],possible_birthdays):
            if month == a[0]:
                return True
    return False


def unique_day(day, possible_birthdays):
    the_day = ()
    for i in possible_birthdays:
        if i[1] == day:
            the_day += (day,)
    return len(the_day) == 1

def unique_month(month, possible_birthdays):
    the_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            the_month += (month,)
    return len(the_month) == 1

def contains_unique_day(month, possible_birthdays):
    wanted_month = ()
    for i in possible_birthdays:
        if i[0] == month:
            wanted_month += (i,)
    wanted_month_days = list(map(lambda x: x[1], wanted_month))
    unique_days = list(filter(lambda x: unique_day(x, possible_birthdays), wanted_month_days))
    return len(unique_days) > 0


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter += 1
    return counter == 1

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter += 1
    return counter == 1

def contains_unique_day(month, possible_birthdays):
    mth = tuple(filter(lambda bd: month == bd[0], possible_birthdays))
    for i in mth:
        if unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in range(len(possible_birthdays)):
        if day in possible_birthdays[i]:
            result += 1
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in range(len(possible_birthdays)):
        if month in possible_birthdays[i]:
            result += 1
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    days = ()
    for i in possible_birthdays:
        if i[0] == month:
            days += (i[1],)
    for i in days:
        if unique_day(i, possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    appearance = 0
    for i in possible_birthdays:
        if i[1] == day:
            appearance += 1
    if appearance == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    appearance = 0
    for i in possible_birthdays:
        if i[0] == month:
            appearance += 1
    if appearance == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1],possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            count+=1
    if count==1:
        return True
    return False

def unique_month(month, possible_birthdays):
    count = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
                count+=1
    if count==1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    days=()
    for birthday in possible_birthdays:
        if month== birthday[0]:
            days += (birthday[1],)
    for day in days:
        if unique_day(day, possible_birthdays)== False:
            continue
        else:
            return unique_day(day, possible_birthdays)
    return False


def unique_day(day, possible_birthdays):
    new = ()
    for i in range (len(possible_birthdays)):
        new = new + (possible_birthdays[i][1],)
    if new.count(day) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    new = ()
    for i in range (len(possible_birthdays)):
        new = new + (possible_birthdays[i][0],)
    if new.count(month) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    new = ()
    for i in possible_birthdays:
        if i[0] == month:
            new = new + (i[1],)
    for i in new:
        if unique_day(i, possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for item in possible_birthdays:
        if item[1] == day:
            counter = counter + 1
    if counter !=1:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter = 0
    for item in possible_birthdays:
        if item[0] == month:
            counter = counter + 1
    if counter != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    dates_in_month = ()
    new_possible_birthdays = ()
    for item in possible_birthdays:
        if month in item:
            dates_in_month += (item[1],)
        elif month not in item:
            new_possible_birthdays += (item[1],)
    result = 0
    for item in dates_in_month:
        if item in new_possible_birthdays:
            result += 1
    if result != len(dates_in_month):
        return True
    else:
        return False


def unique_day(date, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if i[1] == date:
            result += 1
        elif i[1] != date:
            result += 0
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if i[0] == month:
            result += 1
        elif i[0] != month:
            result += 0
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] != month:
            continue
        elif unique_day(i[1],possible_birthdays):
            return True
    return False


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1]==date:
            count+=1
    if count==1:
        return True
    return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0]==month:
            count+=1
    if count==1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if month==i[0]:
            if unique_day(i[1], possible_birthdays):
                return True
    return False


def unique_day(date, possible_birthdays):
    uniqueday = ()
    days = ()
    for i in possible_birthdays:
        days += (i[1],)
    for i in days:
        if i == date:
            uniqueday += (i,)
        else:
            continue

    if len(uniqueday) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    uniquemonth = ()
    months = ()
    for i in possible_birthdays:
        months += (i[0],)
    for i in months:
        if i == month:
            uniquemonth += (i,)
        else:
            continue

    if len(uniquemonth) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    choose_month = ()
    uniqueday_in_month = ()

    for i in possible_birthdays:
        if i[0] == month:
            choose_month += (i,)
        else:
            continue

    for i in choose_month:
        if unique_day(i[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    count, result = 0, 0
    for count in range(0, len(possible_birthdays)):
        if day == possible_birthdays[count][1]:
            result = result + 1
        else:
            continue
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count, result = 0, 0
    for count in range(0, len(possible_birthdays)):
        if month == possible_birthdays[count][0]:
            result = result + 1
        else:
            continue
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for day in possible_birthdays:
        if month == day[0]:
            if unique_day(day[1], possible_birthdays):
                return True
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if day == i[1]:
            result = result + 1

    if result == 1:
        return True

    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if month == i[0]:
            result = result + 1

    if result == 1:
        return True

    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if month == i[0]:
            if unique_day(i[1], possible_birthdays) == True:
                return True

    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    tup = ()
    for i in possible_birthdays:
        if month == i[0]:
           tup = tup + (i,)
    for j in tup:
        day = j[1]
        if unique_day(day, possible_birthdays) == True:
            return True
    else:
        return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    month_day = ()
    for j in possible_birthdays:
        if month == j[0]:
            month_day = month_day + (j,)
    for t in month_day:
        if unique_day(t[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
	return len(tuple(filter(lambda y: day == y,
	map(lambda x: x[1], possible_birthdays)))) == 1

def unique_month(month, possible_birthdays):
	return len(tuple(filter(lambda y: month == y,
	map(lambda x: x[0], possible_birthdays)))) == 1

def contains_unique_day(month, possible_birthdays):
	return len(tuple(filter(lambda x: unique_day(x[1], possible_birthdays),
		filter(lambda y: y[0] == month, possible_birthdays)))) > 0


def unique_day(day, possible_birthdays):
    counter = 0
    for i in range(len(possible_birthdays)):
        if day == possible_birthdays[i][1]:
            counter = counter + 1
    return counter == 1

def unique_month(month, possible_birthdays):
    counter = 0
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
            counter = counter + 1
    return counter == 1

def contains_unique_day(month, possible_birthdays):
    counter = 0
    birthdays = ()
    days = ()
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
            birthdays = birthdays + (possible_birthdays[i],)
        else:
            days = days + (possible_birthdays[i][1],)
    for i in range(len(birthdays)):
        if birthdays[i][1] in days:
            counter = counter + 1
    return (len(birthdays)> counter)


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if date == i[1]:
            count += 1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if month == i[0]:
            count += 1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    months = ()
    for i in possible_birthdays:
        if i[0] == month:
            months = months + (i,)
        else:
            continue
    for i in months:
        if unique_day(i[1], possible_birthdays) == True:
            return True
        else:
            continue
    return False


def unique_day(date, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[1] == date:
            counter += 1
    if counter == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[0] == month:
            counter += 1
    if counter == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0] and unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[1] == day:
            counter += 1
    if counter == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if i[0] == month:
            counter += 1
    if counter == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0] and unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    count=0
    for x in possible_birthdays:
        if x[1]==day:
            count=count+1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count=0
    for x in possible_birthdays:
        if x[0]==month:
            count=count+1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for x in possible_birthdays:
        if x[0]==month:
            if unique_day(x[1], possible_birthdays):
                return True
            else:
                continue
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if day in i:
            result = result + 1
    if result > 1:
        return False
    elif result == 0:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if month in i:
            result = result + 1
    if result > 1:
        return False
    elif result == 0:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    month_tup = ()
    helper = 0
    for i in possible_birthdays:
        if month in i:
            month_tup = month_tup + possible_birthdays[helper]
        helper = helper + 1
    for i in range(1, 32):
        if unique_day(str(i), possible_birthdays) == True:
            if str(i) in month_tup:
                return True
    return False


def unique_day(day, possible_birthdays):
    s=0
    for b in possible_birthdays:
        if b[1]==day:
            s=s+1
        else:
            continue
    return s==1

def unique_month(month, possible_birthdays):
    s=0
    for b in possible_birthdays:
        if b[0]==month:
            s=s+1
        else:
            continue
    return s==1

def contains_unique_day(month, possible_birthdays):
    a=0
    for b in possible_birthdays:
        if b[0]==month:
            s=b[1]
            if unique_day(s,possible_birthdays):
                a=a+1
                break
            else:
                continue
        else:
            continue
    if a==1:
        return True
    else:
        return False


def unique_day(day, possible_birthdays):
    bag = []
    for birthdays in possible_birthdays:
        if birthdays[1] == day:
            bag.append(day)
    n = len(bag)
    if n == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    bag = []
    for months in possible_birthdays:
        if months[0] == month:
            bag.append(month)
    n = len(bag)
    if n == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    bag = ()
    for months in possible_birthdays:
        if months[0] == month:
            bag += ((months[1]),)
    for days in bag:
        if unique_day(days,possible_birthdays):
            return True
    else:
        return False


def unique_day(date, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[1] == date:
            count+=1
    return count==1

def unique_month(month, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[0] == month:
            count=count+1
    return count==1

def contains_unique_day(month, possible_birthdays):
    tf=False
    for i in possible_birthdays:
        if i[0]==month:
            tf=tf or unique_day(i[1],possible_birthdays)
    return tf


def unique_day(date, possible_birthdays):
    total= 0
    for i in possible_birthdays:
        if date == i[1]:
            total= total + 1
    return total == 1

def unique_month(month, possible_birthdays):
    total= 0
    for i in possible_birthdays:
        if month == i[0]:
            total= total + 1
    return total == 1

def contains_unique_day(month, possible_birthdays):
    for a in possible_birthdays:
        if unique_day(a[1],possible_birthdays):
            if month == a[0]:
                return True
    return False


def unique_day(day, possible_birthdays):
    a= tuple(filter(lambda birthday: day == birthday[1], possible_birthdays))

    return (len(a) ==1)

def unique_month(month, possible_birthdays):
    a= tuple(filter(lambda birth_month: month == birth_month[0], possible_birthdays))

    return (len(a) ==1)

def contains_unique_day(month, possible_birthdays):
    #filter out month
    a = filter(lambda birth_month: month == birth_month[0], possible_birthdays)
    for i in a:
        if unique_day(i[1],possible_birthdays):
            return True

    return False


def unique_day(day, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if day == i[1]:
            count+=1
        else:
            continue
    if count==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if month == i[0]:
            count+=1
        else:
            continue
    if count==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0]==month:
            if unique_day(i[1],possible_birthdays):
                return True
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for birthdays in possible_birthdays:
        if birthdays[1] == day:
            result = result + 1
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for months in possible_birthdays:
        if months[0] == month:
            result = result + 1
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    result = ()
    for birthdays in possible_birthdays:
        if birthdays[0] == month:
            result = result + (birthdays,)
    for birthdayss in result:
        if unique_day(birthdayss[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    b=[]  # list of dates
    for birthday in possible_birthdays:
        b.append(birthday[1])
    if b.count(day)==1:
        return True

    return False

def unique_month(month, possible_birthdays):
    b=[]
    for birthday in possible_birthdays:
        b.append(birthday[0])
    if b.count(month)==1:
        return True

    return False

def contains_unique_day(month, possible_birthdays):
    b=[]
    for birthday in possible_birthdays:
        if month == birthday[0]:
            b.append(birthday[1])  #add date to b
    for day in b:
        if unique_day(day,possible_birthdays)==True:
            return True

    return False


def unique_day(date, possible_birthdays):
    lenth=len(possible_birthdays)
    count=0
    for i in range(0,lenth):
        if date==possible_birthdays[i][1]:
            count=count+1
    if count==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    lenth=len(possible_birthdays)
    count=0
    for i in range(0,lenth):
        if month==possible_birthdays[i][0]:
            count=count+1
    if count==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    count=()
    for i in possible_birthdays:
        if i[0]==month:
            if i not in count:
                count=count+(i,)
    for j in count:
        if unique_day(j[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if i[1] == day:
            result += 1
        elif i[1] != day:
            result += 0
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if i[0] == month:
            result += 1
        elif i[0] != month:
            result += 0
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if i[0] == month:
            if unique_day(i[1],possible_birthdays):
                return True
            else:
                continue
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for birthday in possible_birthdays:
        if day == birthday[1]:
            counter += 1
    return counter == 1

def unique_month(month, possible_birthdays):
    counter = 0
    for birthday in possible_birthdays:
        if month == birthday[0]:
            counter += 1
    return counter == 1

def contains_unique_day(month, possible_birthdays):
    truth_holder = False
    for birthday in possible_birthdays:
        if birthday[0] != month:
            continue
        else:
            truth_holder = truth_holder or unique_day(birthday[1], possible_birthdays)
    return truth_holder


def unique_day(day, possible_birthdays):
    check_day = tuple(filter(lambda x: x[1] == day, possible_birthdays))
    if len(check_day) == 1:
        return True
    return False

def unique_month(month, possible_birthdays):
    """Your solution here"""
    check_month = tuple(filter(lambda x: x[0] == month, possible_birthdays))
    if len(check_month) == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    date_day = ()
    for date in possible_birthdays:
        if date[0] == month:
            date_day += (date[1],)
    for check in date_day: # loop through the tuple date_day, each element gives a day
        check_day = tuple(filter(lambda x: x[1] == check, possible_birthdays))
        if len(check_day) == 1:
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in range (len(possible_birthdays)):
        if day == possible_birthdays[i][1]:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in range (len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    total,i = (), 0
    while i < len(possible_birthdays):
        if possible_birthdays[i][0] == month:
            total += (possible_birthdays[i],)
        i += 1
    for x in total:
        if unique_day(x[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for i in range(len(possible_birthdays)):
        if day == possible_birthdays[i][1]:
            count += 1
    if count != 1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    count = 0
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
           count += 1
    if count != 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    new_possible_birthdays = ()
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
           new_possible_birthdays += (possible_birthdays[i],)
    new_day = ""
    counter = 0
    for n in range(len(new_possible_birthdays)):
        new_day = new_possible_birthdays[n][1]
        if unique_day(new_day,possible_birthdays) == True:
            counter += 1
    if counter == 0:
        return False
    else:
        return True


def unique_day(date, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[1] == date:
            count = count + 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            count = count + 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    same_month_tuple = ()
    count = 0
    for i in possible_birthdays:
        if i[0] == month:
            same_month_tuple = same_month_tuple + (i,)
    for i in same_month_tuple:
        if unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter = counter + 1
    if counter != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter = counter + 1
    if counter != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    count_of_days = ()
    for i in possible_birthdays:
        if month == i[0]:
            count_of_days = count_of_days + (i[1], )
    for i2 in count_of_days:
        if unique_day(i2, possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in range(len(possible_birthdays)):
        if day in possible_birthdays[i]:
            result += 1
    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in range(len(possible_birthdays)):
        if month in possible_birthdays[i]:
            result += 1
    if result == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    days = ()
    for i in possible_birthdays:
        if i[0] == month:
            days += (i[1],)
    for i in days:
        if unique_day(i, possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    i = 0
    for days in possible_birthdays:
        if int(day) == int(days[1]):
            i += 1
    if i == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    i = 0
    for months in possible_birthdays:
        if month == months[0]:
            i += 1
    if i == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    data = ()
    number = 0
    for datas in possible_birthdays:
        if month in datas:
            data += (datas,)
    for days in data:
        number += unique_day(days[1], possible_birthdays)
    if number >= 1:
        return True
    else:
        return False


def unique_day(day, possible_birthdays):
    data=()
    for birthday in possible_birthdays:
        if day == birthday[1]:
            data += (birthday,)
    if len(data)==1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    data = ()
    for birthday in possible_birthdays:
        if month == birthday[0]:
            data += (birthday,)
    if len(data)==1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    data, outcome = (),()
    for birthday in possible_birthdays:
        if month == birthday[0]:
            data += (birthday,)
    for birthday in data:
        if unique_day(birthday[1], possible_birthdays) == True:
            outcome += birthday
        else:
            continue
    if outcome == ():
        return False
    else:
        return unique_day(outcome[1],possible_birthdays)


def unique_day(date, possible_birthdays):
    result = 0
    for n in possible_birthdays:
        if n[1] == date:
            result = result + 1
    if result != 1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    result = 0
    for n in possible_birthdays:
        if n[0] == month:
            result = result + 1
    if result != 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    tup = ()
    for n in possible_birthdays:
        if n[0] == month:
            tup = tup + ((n), )
        else:
            continue
    for n in tup:
        if unique_day(n[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter += 1
    if counter != 1:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter += 1
    if counter != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            if unique_day(i[1], possible_birthdays):
                counter += 1
    if counter != 0:
        return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for elem in possible_birthdays:
        birthday = elem[1]
        if birthday == day:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for elem in possible_birthdays:
        birthmonth = elem[0]
        if birthmonth == month:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for elem in possible_birthdays:
        birthmonth = elem[0]
        if birthmonth == month:
            if unique_day(elem[1], possible_birthdays) == True:
                return True
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if day in i:
            result = result + 1
    if result > 1:
        return False
    elif result == 0:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if month in i:
            result = result + 1
    if result > 1:
        return False
    elif result == 0:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    month_tup = ()
    helper = 0
    for i in possible_birthdays:
        if month in i:
            month_tup = month_tup + possible_birthdays[helper]
        helper = helper + 1
    for i in range(1, 32):
        if unique_day(str(i), possible_birthdays) == True:
            if str(i) in month_tup:
                return True
    return False


def unique_day(day, possible_birthdays):
    datetup = ()
    for item in possible_birthdays:
        if item[1] == day:
            datetup = datetup + (item[1],)
    if len(datetup) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    datetup = ()
    for item in possible_birthdays:
        if item[0] == month:
            datetup = datetup + (item[0],)
    if len(datetup) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    datetup = ()
    for item in possible_birthdays:
        if item[0] == month:
            datetup = datetup + (item,)
    for item in datetup:
        if unique_day(item[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day in i:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month in i:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    new_list = ()
    for i in possible_birthdays:
        if month in i:
            new_list += (i,)
    if len(new_list)== 1 or 0:
        return False
    else:
        counter = 0
        for i in new_list:
            if unique_day(i[1], possible_birthdays) == True:
                counter += 1
        if counter >= 1:
            return True
        else:
            return False


def unique_day(date, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[1]==date:
            count+=1
    if count!=1:           #if not can put count==1
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    count=0
    for i in possible_birthdays:
        if i[0]==month:
            count+=1
    if count!= 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    new_possible_birthdays = ()
    for i in range(len(possible_birthdays)):
        if month == possible_birthdays[i][0]:
           new_possible_birthdays += (possible_birthdays[i],)
    new_day = ""
    counter = 0
    for n in range(len(new_possible_birthdays)):
        new_day = new_possible_birthdays[n][1]
        if unique_day(new_day,possible_birthdays) == True:
            counter += 1
    if counter == 0:
        return False
    else:
        return True


def unique_day(day, possible_birthdays):
    a = 0
    for birthday in possible_birthdays:
        if birthday[1] == day:
            a = a + 1
    if a == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    """Your solution here"""
    a = 0
    for birthday in possible_birthdays:
        if birthday[0] == month:
            a = a + 1
    if a == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    """Your solution here"""
    b = False
    def month_tup(month):
        a = ()
        for birthday in possible_birthdays:
            if month == birthday[0]:
                a = a + (birthday,)
        return a
    for birthday in month_tup(month):
        if unique_day(birthday[1], possible_birthdays) == True:
            b = True
    return b


def unique_day(day, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if day == i[1]:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for i in possible_birthdays:
        if month == i[0]:
            counter = counter + 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    month_day = ()
    for j in possible_birthdays:
        if month == j[0]:
            month_day = month_day + (j,)
    for t in month_day:
        if unique_day(t[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    alldays = ()
    for i in possible_birthdays:
        alldays += (i[1],)
    for i in alldays:
        if day == i:
            count += 1
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    count = 0
    allmonths = ()
    for i in possible_birthdays:
        allmonths += (i[0],)
    for i in allmonths:
        if month == i:
            count += 1
    if count == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    count = 0
    matchmonth = ()
    for i in possible_birthdays:
        if month == i[0]:
            matchmonth += (i,)
    for i in matchmonth:
        if unique_day(i[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    def get_day(birthday):
        return birthday[1]
    count = 0
    for i in possible_birthdays:
        if get_day(i) == day:
            count +=1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    def get_month(birthday):
        return birthday[0]
    count = 0
    for i in possible_birthdays:
        if get_month(i) == month:
            count +=1
        else:
            continue
    if count == 1:
        return True
    else:
        return False

def get_month(birthday):
        return birthday[0]
def get_day(birthday):
        return birthday[1]

def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if get_month(i) == month and unique_day(get_day(i), possible_birthdays):
            return True
        else:
            continue
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for x in possible_birthdays:
        x_day = x[1]
        if day == x_day:
            counter += 1
        else:
            counter = counter
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for x in possible_birthdays:
        x_month = x[0]
        if month == x_month:
            counter += 1
        else:
            counter = counter
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    list_of_days = ()
    for x in possible_birthdays:
        if month == x[0]:
            x_day = x[1]
            if unique_day(x_day,possible_birthdays) == True:
                return True
    return False


def unique_day(date, possible_birthdays):
    if len(tuple(filter(lambda x: x[1] == date, possible_birthdays))) != 1:
        return False
    else:
        return True

def unique_month(month, possible_birthdays):
    if len(tuple(filter(lambda x: x[0] == month, possible_birthdays))) != 1:
        return False
    else:
        return True

def contains_unique_day(month, possible_birthdays):
    singledays = tuple(filter((lambda x: unique_day(x[1], possible_birthdays)), possible_birthdays))
    for i in singledays:
        if i[0] == month:
            return True
    return False


def unique_day(date, possible_birthdays):
    total= 0
    for i in possible_birthdays:
        if date == i[1]:
            total= total + 1
    return total == 1

def unique_month(month, possible_birthdays):
    total= 0
    for i in possible_birthdays:
        if month == i[0]:
            total= total + 1
    return total == 1

def contains_unique_day(month, possible_birthdays):
    for a in possible_birthdays:
        if unique_day(a[1],possible_birthdays):
            if month == a[0]:
                return True
    return False


def unique_day(day, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if day == i[1]:
            result = result + 1
        else:
            continue

    if result == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    result = 0
    for i in possible_birthdays:
        if month == i[0]:
            result = result + 1
        else:
            continue

    if result == 1:
        return True
    else:
        return False
def contains_unique_day(month, possible_birthdays):
    for i in possible_birthdays:
        if month == i[0]:
            if unique_day(i[1], possible_birthdays) == False:
                continue
            else:
                return True
    return False
    return True


def unique_day(day, possible_birthdays):
    counter = 0
    for item in possible_birthdays:
        if item[1] == day:
            counter = counter + 1
    if counter !=1:
        return False
    return True

def unique_month(month, possible_birthdays):
    counter = 0
    for item in possible_birthdays:
        if item[0] == month:
            counter = counter + 1
    if counter != 1:
        return False
    return True

def contains_unique_day(month, possible_birthdays):
    dates_in_month = ()
    new_possible_birthdays = ()
    for item in possible_birthdays:
        if month in item:
            dates_in_month += (item[1],)
        elif month not in item:
            new_possible_birthdays += (item[1],)
    result = 0
    for item in dates_in_month:
        if item in new_possible_birthdays:
            result += 1
    if result != len(dates_in_month):
        return True
    else:
        return False


def unique_day(day, possible_birthdays):

    if len(tuple(filter(
        lambda x : x[1] == day, possible_birthdays))) == 1:
        return True
    return False

def unique_month(month, possible_birthdays):

    if len(tuple(filter(
        lambda x : x[0] == month, possible_birthdays))) == 1:
        return True
    return False

def contains_unique_day(month, possible_birthdays):
    special_days = tuple(filter((
        lambda x: unique_day(x[1], possible_birthdays)),
                                possible_birthdays))
    for i in special_days:
        if i[0] == month:
            return True
    return False


def unique_day(date, possible_birthdays):
    days = [birthday[1] for birthday in possible_birthdays]
    return days.count(date) == 1

def unique_month(month, possible_birthdays):
    months = [birthday[0] for birthday in possible_birthdays]
    return months.count(month) == 1

def contains_unique_day(month, possible_birthdays):
    days = list(filter(lambda x: x[0] == month, possible_birthdays))
    for day in days:
        if unique_day(day[1], possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    x = ()
    y = ()
    for i in possible_birthdays:
        x += (i[1],)
    for i in x:
        if i == day:
            y += (i,)
        else:
            continue
    if len(y) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    x = ()
    y = ()
    for i in possible_birthdays:
        x += (i[0],)
    for i in x:
        if i == month:
            y += (i,)
        else:
            continue
    if len(y) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    x = ()
    y = ()
    for i in possible_birthdays:
        if i[0] == month:
            x += (i,)
        else:
            continue
    for i in x:
        if unique_day(i[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if day == i[1]:
            count = count + 1
    if count == 1:
        return True
    else:
        return False
def unique_month(month, possible_birthdays):
    count = 0
    for i in possible_birthdays:
        if month== i[0]:
            count = count + 1
    if count == 1:
        return True
    else:
        return False
def contains_unique_day(month, possible_birthdays):
    newtuple = ()
    for i in possible_birthdays:
        if month== i[0]:
            newtuple = newtuple + (i,)
    for j in newtuple:
        if unique_day(j[1], possible_birthdays) == True:
            return True
    else:
        return False


def unique_day(day, possible_birthdays):
    i, times = 0, 0
    while i < len(possible_birthdays):
        if possible_birthdays[i][1] == day:
            times += 1
        i += 1
    if times == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    i, times = 0, 0
    while i < len(possible_birthdays):
        if possible_birthdays[i][0] == month:
            times += 1
        i += 1
    if times == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for i in range (0,len(possible_birthdays)):
        if possible_birthdays[i][0] == month and unique_day(possible_birthdays[i][1], possible_birthdays):
            return True
    else:
        return False


def unique_day(day, possible_birthdays):
    days = ()
    unique = ()
    for i in possible_birthdays:
        days += (i[1],)
    for i in days:
        if i == day:
            unique += (i,)
        else:
            continue
    if len(unique) == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    months = ()
    unique = ()
    for i in possible_birthdays:
        months += (i[0],)
    for i in months:
        if i == month:
            unique += (i,)
        else:
            continue
    if len(unique) == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    selected_month = ()
    unique = ()
    for i in possible_birthdays:
        if i[0] == month:
            selected_month += (i,)
        else:
            continue
    for i in selected_month:
        if unique_day(i[1], possible_birthdays) == True:
            return True
    return False


def unique_day(day, possible_birthdays):
    def map(fn,seq):
        if seq == ():
            return ()
        else:
            return (fn(seq[0]),) + map(fn,seq[1:])
    days = map(lambda x: x[1], possible_birthdays)
    filter1 = filter(lambda x:x == day, days)
    tup = tuple(filter1)
    return len(tup) == 1

def unique_month(month, possible_birthdays):
    def map(fn,seq):
        if seq == ():
            return ()
        else:
            return (fn(seq[0]),) + map(fn,seq[1:])
    months = map(lambda x: x[0], possible_birthdays)
    filter2 = filter(lambda x:x == month, months)
    tup2 = tuple(filter2)
    return len(tup2) == 1

def contains_unique_day(month, possible_birthdays):
    days = ()
    for a in possible_birthdays:
        if a[0] == month:
            days = days + (a[1],)
    for b in days:
        if unique_day(b, possible_birthdays):
            return True
    return False


def unique_day(day, possible_birthdays):
    counter = 0
    for ele in possible_birthdays:
        birthday = ele[1]
        if birthday == day:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def unique_month(month, possible_birthdays):
    counter = 0
    for ele in possible_birthdays:
        birthmonth = ele[0]
        if birthmonth == month:
            counter += 1
    if counter == 1:
        return True
    else:
        return False

def contains_unique_day(month, possible_birthdays):
    for ele in possible_birthdays:
        birthmonth = ele[0]
        if birthmonth == month:
            if unique_day(ele[1], possible_birthdays) == True:
                return True
    return False


def unique_day(day, possible_birthdays):
    get_possible_days = map(lambda bdays:bdays[1],possible_birthdays)
    count = 0
    for days in get_possible_days:
        if days == day:
            count = count + 1
    if count == 1:
        return True
    else:
        return False
def unique_month(month, possible_birthdays):
    get_possible_months = map(lambda bdays:bdays[0],possible_birthdays)
    count = 0
    for months in get_possible_months:
        if months == month:
            count = count + 1
    if count == 1:
        return True
    else:
        return False
def contains_unique_day(month, possible_birthdays):
     get_possible_months = filter(lambda birthday: birthday[0] == month, possible_birthdays)
     get_possible_days = map(lambda birthday: birthday[1],get_possible_months)
     for days in get_possible_days:
        if unique_day(days, possible_birthdays):
            return True
     return False