id
stringlengths 35
39
| content
stringlengths 44
3.85k
| max_stars_repo_path
stringlengths 52
57
|
|---|---|---|
refactory_data_question_2_correct_2_197
|
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
|
./refactory/data/question_2/code/correct/correct_2_197.py
|
refactory_data_question_2_correct_2_038
|
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):
for birthday in possible_birthdays:
if birthday[0] == month and unique_day(birthday[1], possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_038.py
|
refactory_data_question_2_correct_2_252
|
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
|
./refactory/data/question_2/code/correct/correct_2_252.py
|
refactory_data_question_2_correct_2_140
|
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
|
./refactory/data/question_2/code/correct/correct_2_140.py
|
refactory_data_question_2_correct_2_016
|
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 True
else:
return False
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 True
else:
return False
def contains_unique_day(month, possible_birthdays):
for date in possible_birthdays:
if unique_day(date[1], possible_birthdays) == True and month == date[0]:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_016.py
|
refactory_data_question_2_correct_2_158
|
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
|
./refactory/data/question_2/code/correct/correct_2_158.py
|
refactory_data_question_2_correct_2_086
|
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
|
./refactory/data/question_2/code/correct/correct_2_086.py
|
refactory_data_question_2_correct_2_172
|
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
|
./refactory/data/question_2/code/correct/correct_2_172.py
|
refactory_data_question_2_correct_2_230
|
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
|
./refactory/data/question_2/code/correct/correct_2_230.py
|
refactory_data_question_2_correct_2_182
|
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
|
./refactory/data/question_2/code/correct/correct_2_182.py
|
refactory_data_question_2_correct_2_265
|
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
|
./refactory/data/question_2/code/correct/correct_2_265.py
|
refactory_data_question_2_correct_2_258
|
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
|
./refactory/data/question_2/code/correct/correct_2_258.py
|
refactory_data_question_2_correct_2_129
|
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
|
./refactory/data/question_2/code/correct/correct_2_129.py
|
refactory_data_question_2_correct_2_188
|
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
|
./refactory/data/question_2/code/correct/correct_2_188.py
|
refactory_data_question_2_correct_2_027
|
def unique_day(day, possible_birthdays):
counter = 0
for dates in possible_birthdays:
if day in dates:
counter += 1
if counter == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
counter = 0
for dates in possible_birthdays:
if month in dates:
counter += 1
if counter == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
counter = 0
filtered_dates = ()
for dates in possible_birthdays:
if month in dates:
filtered_dates += (dates,)
for date in filtered_dates:
if unique_day(date[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_027.py
|
refactory_data_question_2_correct_2_138
|
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
|
./refactory/data/question_2/code/correct/correct_2_138.py
|
refactory_data_question_2_correct_2_036
|
def unique_day(day, possible_birthdays):
result = 0
for bday in possible_birthdays:
if bday[1] == day:
result += 1
return result == 1
def unique_month(month, possible_birthdays):
result = 0
for bday in possible_birthdays:
if bday[0] == month:
result += 1
return result == 1
def contains_unique_day(month, possible_birthdays):
filter_month = tuple(filter(lambda x: x[0] == month, possible_birthdays))
for day in filter_month:
if unique_day(day[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_036.py
|
refactory_data_question_2_correct_2_259
|
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
|
./refactory/data/question_2/code/correct/correct_2_259.py
|
refactory_data_question_2_correct_2_150
|
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
|
./refactory/data/question_2/code/correct/correct_2_150.py
|
refactory_data_question_2_correct_2_249
|
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
|
./refactory/data/question_2/code/correct/correct_2_249.py
|
refactory_data_question_2_correct_2_044
|
def unique_day(day, possible_birthdays):
tup = ()
for i in possible_birthdays:
if i[1] == day:
tup += (i[1],)
if len(tup) == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
tup = ()
for i in possible_birthdays:
if i[0] == month:
tup += (i[0],)
if len(tup) == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
tup = ()
for date in possible_birthdays:
if date[0] == month:
tup += (date,)
for bday in tup:
if unique_day(bday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_044.py
|
refactory_data_question_2_correct_2_222
|
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
|
./refactory/data/question_2/code/correct/correct_2_222.py
|
refactory_data_question_2_correct_2_001
|
def unique_day(day, possible_birthdays):
all_days = ()
for i in possible_birthdays:
all_days += (i[1],)
return all_days.count(day) == 1
def unique_month(month, possible_birthdays):
all_months = ()
for i in possible_birthdays:
all_months += (i[0],)
return all_months.count(month) == 1
def contains_unique_day(month, possible_birthdays):
all_day_in_given_month = ()
for i in possible_birthdays:
if i[0] == month:
all_day_in_given_month += (i[1],)
for i in all_day_in_given_month:
if unique_day(i, possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_001.py
|
refactory_data_question_2_correct_2_165
|
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
|
./refactory/data/question_2/code/correct/correct_2_165.py
|
refactory_data_question_2_correct_2_096
|
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
|
./refactory/data/question_2/code/correct/correct_2_096.py
|
refactory_data_question_2_correct_2_163
|
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
|
./refactory/data/question_2/code/correct/correct_2_163.py
|
refactory_data_question_2_correct_2_256
|
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
|
./refactory/data/question_2/code/correct/correct_2_256.py
|
refactory_data_question_2_correct_2_130
|
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
|
./refactory/data/question_2/code/correct/correct_2_130.py
|
refactory_data_question_2_correct_2_054
|
def filter(pred, seq):
res = ()
for ele in seq:
if pred(ele):
res = res + (ele, )
return res
def unique_day(day, possible_birthdays):
return len(filter(lambda x:x[1]==day, possible_birthdays)) == 1
def unique_month(month, possible_birthdays):
return len(filter(lambda x:x[0]==month, possible_birthdays)) == 1
def contains_unique_day(month, possible_birthdays):
bdays_in_mth = filter(lambda x:x[0]==month, possible_birthdays)
for bday in bdays_in_mth:
if unique_day(bday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_054.py
|
refactory_data_question_2_correct_2_062
|
def unique_day(day, possible_birthdays):
unique = ()
for birthday in possible_birthdays:
if day == birthday[1]:
unique = unique + (day,)
if len(unique) == 1:
return True
return False
def unique_month(month, possible_birthdays):
unique = ()
for birthday in possible_birthdays:
if month == birthday[0]:
unique = unique + (month,)
if len(unique) == 1:
return True
return False
def contains_unique_day(month, possible_birthdays):
correct_months = ()
for birthday in possible_birthdays:
if unique_day(birthday[1], possible_birthdays):
correct_months = correct_months + (birthday[0],)
if month in correct_months:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_062.py
|
refactory_data_question_2_correct_2_287
|
def unique_day(date, possible_birthdays):
count = 0
for i in possible_birthdays:
if date == i[1]:
count += 1
return count == 1
def unique_month(month, possible_birthdays):
count = 0
for i in possible_birthdays:
if month == i[0]:
count += 1
return count == 1
def contains_unique_day(month, possible_birthdays):
days = ()
for i in possible_birthdays:
if month == i[0]:
days += (i[1],)
for i in days:
if unique_day(i, possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_287.py
|
refactory_data_question_2_correct_2_088
|
def unique_day(day, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[1] == day:
counter += 1
if counter == 1:
return True
else:
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
else:
return False
def contains_unique_day(month, possible_birthdays):
possible_days = ()
count = 0
for i in possible_birthdays:
if i[0] == month:
possible_days += (i,)
for j in possible_days:
day = j[1]
if (unique_day(day, possible_birthdays) == True):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_088.py
|
refactory_data_question_2_correct_2_193
|
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
|
./refactory/data/question_2/code/correct/correct_2_193.py
|
refactory_data_question_2_correct_2_025
|
def unique_day(day, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
counter += 1 if day == birthday[1] else 0
return (counter == 1)
def unique_month(month, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
counter += 1 if month == birthday[0] else 0
return (counter == 1)
def contains_unique_day(month, possible_birthdays):
birthdays_in_month = ()
for birthday in possible_birthdays:
if birthday[0] == month: birthdays_in_month += (birthday,)
for birthday in birthdays_in_month:
if unique_day(birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_025.py
|
refactory_data_question_2_correct_2_051
|
def unique_day(day, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[1] == day:
count += 1
if count == 1:
return True
return False
def unique_month(month, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[0] == month:
count += 1
if count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
result = ()
for birthday in possible_birthdays:
if birthday[0] == month:
result += (unique_day(birthday[1], possible_birthdays),)
if any(result):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_051.py
|
refactory_data_question_2_correct_2_111
|
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
|
./refactory/data/question_2/code/correct/correct_2_111.py
|
refactory_data_question_2_correct_2_191
|
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
|
./refactory/data/question_2/code/correct/correct_2_191.py
|
refactory_data_question_2_correct_2_233
|
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
|
./refactory/data/question_2/code/correct/correct_2_233.py
|
refactory_data_question_2_correct_2_015
|
def unique_day(day, possible_birthdays):
count = 0
days = map(lambda x:x[1], possible_birthdays)
for i in days:
if i == day:
count += 1
if count != 1:
return False
return True
def unique_month(month, possible_birthdays):
count = 0
months = map(lambda x:x[0], possible_birthdays)
for i in months:
if i == month:
count += 1
if count != 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
months = map(lambda x:x[0], possible_birthdays)
for birthday in possible_birthdays:
if birthday[0] == month:
if unique_day(birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_015.py
|
refactory_data_question_2_correct_2_039
|
def unique_day(day, possible_birthdays):
day_count = 0
for birthday in possible_birthdays:
if birthday[1] == day:
day_count = day_count + 1
if day_count > 1:
break
if day_count == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
month_count = 0
for birthday in possible_birthdays:
if birthday[0] == month:
month_count = month_count + 1
if month_count > 1:
break
if month_count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
has_unique_day = 0
for birthday in possible_birthdays:
if birthday[0] == month:
if unique_day(birthday[1], possible_birthdays):
has_unique_day = 1
break
if has_unique_day:
return True
else:
return False
|
./refactory/data/question_2/code/correct/correct_2_039.py
|
refactory_data_question_2_correct_2_108
|
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
|
./refactory/data/question_2/code/correct/correct_2_108.py
|
refactory_data_question_2_correct_2_185
|
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
|
./refactory/data/question_2/code/correct/correct_2_185.py
|
refactory_data_question_2_correct_2_242
|
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
|
./refactory/data/question_2/code/correct/correct_2_242.py
|
refactory_data_question_2_correct_2_225
|
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
|
./refactory/data/question_2/code/correct/correct_2_225.py
|
refactory_data_question_2_correct_2_202
|
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
|
./refactory/data/question_2/code/correct/correct_2_202.py
|
refactory_data_question_2_correct_2_018
|
def unique_day(day, possible_birthdays):
days = 0
for i in range(len(possible_birthdays)):
if possible_birthdays[i][1] == day:
days = days + 1
if days == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
months = 0
for j in range(len(possible_birthdays)):
if possible_birthdays[j][0] == month:
months = months + 1
if months == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
x = ()
for k in range(len(possible_birthdays)):
if possible_birthdays[k][0] == month:
x = x + (possible_birthdays[k],)
for l in range(len(x)):
if unique_day(x[l][1], possible_birthdays):
return True
else:
continue
return False
|
./refactory/data/question_2/code/correct/correct_2_018.py
|
refactory_data_question_2_correct_2_223
|
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
|
./refactory/data/question_2/code/correct/correct_2_223.py
|
refactory_data_question_2_correct_2_216
|
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
|
./refactory/data/question_2/code/correct/correct_2_216.py
|
refactory_data_question_2_correct_2_153
|
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
|
./refactory/data/question_2/code/correct/correct_2_153.py
|
refactory_data_question_2_correct_2_264
|
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
|
./refactory/data/question_2/code/correct/correct_2_264.py
|
refactory_data_question_2_correct_2_220
|
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)
|
./refactory/data/question_2/code/correct/correct_2_220.py
|
refactory_data_question_2_correct_2_281
|
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
|
./refactory/data/question_2/code/correct/correct_2_281.py
|
refactory_data_question_2_correct_2_266
|
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
|
./refactory/data/question_2/code/correct/correct_2_266.py
|
refactory_data_question_2_correct_2_254
|
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
|
./refactory/data/question_2/code/correct/correct_2_254.py
|
refactory_data_question_2_correct_2_113
|
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
|
./refactory/data/question_2/code/correct/correct_2_113.py
|
refactory_data_question_2_correct_2_077
|
def unique_day(date, possible_birthdays):
tester = 0
for i in possible_birthdays:
if date == i[1]:
if tester:
return False
else:
tester = 1
return tester
def unique_month(month, possible_birthdays):
tester = 0
for i in possible_birthdays:
if month == i[0]:
if tester:
return False
else:
tester = 1
return tester
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
|
./refactory/data/question_2/code/correct/correct_2_077.py
|
refactory_data_question_2_correct_2_227
|
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
|
./refactory/data/question_2/code/correct/correct_2_227.py
|
refactory_data_question_2_correct_2_157
|
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
|
./refactory/data/question_2/code/correct/correct_2_157.py
|
refactory_data_question_2_correct_2_009
|
def unique_day(day, possible_birthdays):
return tuple(map(lambda x: x[1], possible_birthdays)).count(day) == 1
def unique_month(month, possible_birthdays):
return tuple(map(lambda x: x[0], possible_birthdays)).count(month) == 1
def contains_unique_day(month, possible_birthdays):
is_unique_day = tuple((i, unique_day(i, possible_birthdays)) for i in tuple(map(lambda y: y[1], possible_birthdays)))
is_unique_day_true = tuple(map(lambda c: c[0], tuple(filter(lambda b: b[1] == True, is_unique_day))))
days_in_month = tuple(map(lambda b: b[1], tuple(filter(lambda d: d[0] == month, possible_birthdays))))
check_month = tuple(x in days_in_month for x in is_unique_day_true)
return True in check_month
|
./refactory/data/question_2/code/correct/correct_2_009.py
|
refactory_data_question_2_correct_2_014
|
def unique_day(day, possible_birthdays):
days = 0
for i in range(len(possible_birthdays)): #creating the for loop for the range of possible birthdays
if possible_birthdays[i][1] == day: # looking for the date according to the list
days = days + 1
if days == 1: #return when the day matches
return True
else:
return False
def unique_month(month, possible_birthdays):
months = 0
for j in range(len(possible_birthdays)): #creating the for loop for the range of possible birthday months
if possible_birthdays[j][0] == month:# looking for the month according to the list
months = months + 1
if months == 1: #return when the month matches
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
tup = ()
for k in range(len(possible_birthdays)):
if possible_birthdays[k][0] == month:
tup = tup + (possible_birthdays[k],)
for l in range(len(tup)):
if unique_day(tup[l][1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_014.py
|
refactory_data_question_2_correct_2_119
|
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
|
./refactory/data/question_2/code/correct/correct_2_119.py
|
refactory_data_question_2_correct_2_189
|
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
|
./refactory/data/question_2/code/correct/correct_2_189.py
|
refactory_data_question_2_correct_2_080
|
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
|
./refactory/data/question_2/code/correct/correct_2_080.py
|
refactory_data_question_2_correct_2_177
|
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
|
./refactory/data/question_2/code/correct/correct_2_177.py
|
refactory_data_question_2_correct_2_131
|
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
|
./refactory/data/question_2/code/correct/correct_2_131.py
|
refactory_data_question_2_correct_2_083
|
def unique_day(day, possible_birthdays):
count = 0
for k in possible_birthdays:
if k[1] == day:
count = count + 1
else:
continue
if count == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
count = 0
for k in possible_birthdays:
if k[0] == month:
count = count + 1
else:
continue
if count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
for k in possible_birthdays:
if month == k[0] and unique_day(k[1], possible_birthdays)==True:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_083.py
|
refactory_data_question_2_correct_2_209
|
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
|
./refactory/data/question_2/code/correct/correct_2_209.py
|
refactory_data_question_2_correct_2_237
|
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
|
./refactory/data/question_2/code/correct/correct_2_237.py
|
refactory_data_question_2_correct_2_116
|
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
|
./refactory/data/question_2/code/correct/correct_2_116.py
|
refactory_data_question_2_correct_2_120
|
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
|
./refactory/data/question_2/code/correct/correct_2_120.py
|
refactory_data_question_2_correct_2_192
|
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
|
./refactory/data/question_2/code/correct/correct_2_192.py
|
refactory_data_question_2_correct_2_012
|
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 and unique_day(i[1],possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_012.py
|
refactory_data_question_2_correct_2_091
|
def unique_day(day, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[1] == day:
counter += 1
if counter == 1:
return True
else:
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
else:
return False
def contains_unique_day(month, possible_birthdays):
possible_days = ()
count = 0
for i in possible_birthdays:
if i[0] == month:
possible_days += (i,)
for j in possible_days:
day = j[1]
if (unique_day(day, possible_birthdays) == True):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_091.py
|
refactory_data_question_2_correct_2_289
|
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
|
./refactory/data/question_2/code/correct/correct_2_289.py
|
refactory_data_question_2_correct_2_224
|
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
|
./refactory/data/question_2/code/correct/correct_2_224.py
|
refactory_data_question_2_correct_2_122
|
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
|
./refactory/data/question_2/code/correct/correct_2_122.py
|
refactory_data_question_2_correct_2_076
|
def unique_day(day, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[1] == day:
count += 1
if count == 1:
return True
return False
def unique_month(month, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[0] == month:
count += 1
if count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
result = ()
for birthday in possible_birthdays:
if birthday[0] == month:
result += (unique_day(birthday[1], possible_birthdays),)
if any(result):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_076.py
|
refactory_data_question_2_correct_2_160
|
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
|
./refactory/data/question_2/code/correct/correct_2_160.py
|
refactory_data_question_2_correct_2_101
|
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
|
./refactory/data/question_2/code/correct/correct_2_101.py
|
refactory_data_question_2_correct_2_006
|
def unique_day(day, possible_birthdays):
possible_days = tuple(map(lambda x: x[1], possible_birthdays))
if possible_days.count(day) == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
possible_months = tuple(map(lambda x: x[0], possible_birthdays))
if possible_months.count(month) == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
#Gets the unique days in the form (month, days)
unique_days = tuple(filter(lambda x: unique_day(x[1], possible_birthdays), possible_birthdays))
for birthday in unique_days:
if birthday[0] == month:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_006.py
|
refactory_data_question_2_correct_2_010
|
def unique_day(day, possible_birthdays):
counter = 0
for i in possible_birthdays:
if day in i:
counter += 1
return counter == 1
def unique_month(month, possible_birthdays):
counter = 0
for i in possible_birthdays:
if month in i:
counter += 1
return counter == 1
def contains_unique_day(month, possible_birthdays):
daysinmonth =()
for i in possible_birthdays:
if month in i:
daysinmonth += (i[1],)
for j in daysinmonth:
if unique_day(j, possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_010.py
|
refactory_data_question_2_correct_2_056
|
def unique_day(day, possible_birthdays):
freq=0
for birthday in possible_birthdays:
if birthday[1]==day:
freq=freq+1
else:
continue
if freq==1:
return True
else:
return False
def unique_month(month, possible_birthdays):
freq=0
for birthday in possible_birthdays:
if birthday[0]==month:
freq=freq+1
else:
continue
if freq==1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
for birthday in possible_birthdays:
if birthday[0]==month:
if unique_day(birthday[1], possible_birthdays)==True:
return True
break
return False
|
./refactory/data/question_2/code/correct/correct_2_056.py
|
refactory_data_question_2_correct_2_019
|
def unique_day(day, possible_birthdays):
days = 0
for i in range(len(possible_birthdays)): #creating the for loop for the range of possible birthdays
if possible_birthdays[i][1] == day: # looking for the date according to the list
days = days + 1
if days == 1: #return when the day matches
return True
else:
return False
def unique_month(month, possible_birthdays):
months = 0
for j in range(len(possible_birthdays)): #creating the for loop for the range of possible birthday months
if possible_birthdays[j][0] == month:# looking for the month according to the list
months = months + 1
if months == 1: #return when the month matches
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
x = ()
for k in range(len(possible_birthdays)):
if possible_birthdays[k][0] == month:
x = x + (possible_birthdays[k],)
for l in range(len(x)):
if unique_day(x[l][1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_019.py
|
refactory_data_question_2_correct_2_066
|
def unique_day(date, possible_birthdays):
count = 0
for i in range(len(possible_birthdays)):
if possible_birthdays[i][1] == date:
count += 1
if count == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
count = 0
for i in range(len(possible_birthdays)):
if possible_birthdays[i][0] == month:
count += 1
if count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
for i in range(len(possible_birthdays)):
if possible_birthdays[i][0] == month and unique_day(possible_birthdays[i][1], possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_066.py
|
refactory_data_question_2_correct_2_110
|
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
|
./refactory/data/question_2/code/correct/correct_2_110.py
|
refactory_data_question_2_correct_2_040
|
def unique_day(day, possible_birthdays):
day_count = 0
for birthday in possible_birthdays:
if birthday[1] == day:
day_count = day_count + 1
if day_count > 1:
break
if day_count == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
month_count = 0
for birthday in possible_birthdays:
if birthday[0] == month:
month_count = month_count + 1
if month_count > 1:
break
if month_count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
has_unique_day = 0
for birthday in possible_birthdays:
if birthday[0] == month:
if unique_day(birthday[1], possible_birthdays):
has_unique_day = 1
break
if has_unique_day:
return True
else:
return False
|
./refactory/data/question_2/code/correct/correct_2_040.py
|
refactory_data_question_2_correct_2_126
|
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
|
./refactory/data/question_2/code/correct/correct_2_126.py
|
refactory_data_question_2_correct_2_050
|
def unique_day(day, possible_birthdays):
freq=0
for birthday in possible_birthdays:
if birthday[1]==day:
freq=freq+1
else:
continue
if freq==1:
return True
else:
return False
def unique_month(month, possible_birthdays):
freq=0
for birthday in possible_birthdays:
if birthday[0]==month:
freq=freq+1
else:
continue
if freq==1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
for birthday in possible_birthdays:
if birthday[0]==month:
if unique_day(birthday[1], possible_birthdays)==True:
return True
break
return False
|
./refactory/data/question_2/code/correct/correct_2_050.py
|
refactory_data_question_2_correct_2_097
|
def unique_day(day, possible_birthdays):
count = 0
for possible_dates in possible_birthdays:
if possible_dates[1] == day:
count += 1
if count != 1:
return False
return True
def unique_month(month, possible_birthdays):
count = 0
for possible_dates in possible_birthdays:
if possible_dates[0] == month:
count += 1
if count != 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
possible_days_in_month = ()
possible_days_in_others = ()
for possible_dates in possible_birthdays:
if possible_dates[0] == month:
possible_days_in_month += (possible_dates[1],)
else:
possible_days_in_others += (possible_dates[1],)
for day_in_month in possible_days_in_month:
unique = True
for day_in_others in possible_days_in_others:
if day_in_month == day_in_others:
unique = False
break
if unique == True:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_097.py
|
refactory_data_question_2_correct_2_251
|
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
|
./refactory/data/question_2/code/correct/correct_2_251.py
|
refactory_data_question_2_correct_2_228
|
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
|
./refactory/data/question_2/code/correct/correct_2_228.py
|
refactory_data_question_2_correct_2_284
|
def unique_day(day, possible_birthdays):
counter=0
for birthday in possible_birthdays:
if day==birthday[1]:
counter+=1
else:
continue
if counter==1:
return True
else:
return False
def unique_month(month, possible_birthdays):
counter=0
for birthday in possible_birthdays:
if month==birthday[0]:
counter+=1
else:
continue
if counter==1:
return True
else:
return False
def filter_1(pred,seq):
if seq==():
return ()
elif pred(seq[0]):
return (seq[0],) + filter_1(pred,seq[1:])
else:
return filter_1(pred,seq[1:])
def contains_unique_day(month, possible_birthdays):
month_dates=filter_1(lambda x:True if x[0]==month else False, possible_birthdays)
for date in month_dates:
if unique_day(date[1],possible_birthdays):
return True
else:
continue
else:
return False
|
./refactory/data/question_2/code/correct/correct_2_284.py
|
refactory_data_question_2_correct_2_045
|
def unique_day(date, possible_birthdays):
num = 0
for birthday in possible_birthdays:
if date == birthday[1]:
num += 1
return num == 1
def unique_month(month, possible_birthdays):
num = 0
for birthday in possible_birthdays:
if month == birthday[0]:
num += 1
return num == 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
|
./refactory/data/question_2/code/correct/correct_2_045.py
|
refactory_data_question_2_correct_2_024
|
def unique_day(day, possible_birthdays):
counter = 0
for bday in possible_birthdays:
if day == bday[1]:
counter += 1
if counter == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
counter = 0
for bday in possible_birthdays:
if month == bday[0]:
counter += 1
if counter == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
days_in_month = ()
for bday in possible_birthdays:
if month == bday[0]:
days_in_month += (bday[1],)
for day in days_in_month:
if unique_day(day, possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_024.py
|
refactory_data_question_2_correct_2_104
|
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
|
./refactory/data/question_2/code/correct/correct_2_104.py
|
refactory_data_question_2_correct_2_128
|
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
|
./refactory/data/question_2/code/correct/correct_2_128.py
|
refactory_data_question_2_correct_2_069
|
def unique_day(day, possible_birthdays):
days = tuple(map(lambda x: x[1],possible_birthdays))
count = 0
for i in days:
if i == day:
count = count+1
return count == 1
def unique_month(month, possible_birthdays):
months = tuple(map(lambda x: x[0],possible_birthdays))
count = 0
for i in months:
if i == month:
count = count +1
return count ==1
def contains_unique_day(month, possible_birthdays):
specific_set = tuple(filter(lambda x: x[0] == month, possible_birthdays))
get_days = tuple(map(lambda x: x[1],specific_set))
ans = tuple(map(lambda x: unique_day(x,possible_birthdays),get_days))
if True in ans:
return True
else:
return False
|
./refactory/data/question_2/code/correct/correct_2_069.py
|
refactory_data_question_2_correct_2_199
|
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
|
./refactory/data/question_2/code/correct/correct_2_199.py
|
refactory_data_question_2_correct_2_114
|
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
|
./refactory/data/question_2/code/correct/correct_2_114.py
|
refactory_data_question_2_correct_2_241
|
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
|
./refactory/data/question_2/code/correct/correct_2_241.py
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.