id
stringlengths 35
39
| content
stringlengths 44
3.85k
| max_stars_repo_path
stringlengths 52
57
|
|---|---|---|
refactory_data_question_2_correct_2_145
|
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
|
./refactory/data/question_2/code/correct/correct_2_145.py
|
refactory_data_question_2_correct_2_171
|
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
|
./refactory/data/question_2/code/correct/correct_2_171.py
|
refactory_data_question_2_correct_2_174
|
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_174.py
|
refactory_data_question_2_correct_2_109
|
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
|
./refactory/data/question_2/code/correct/correct_2_109.py
|
refactory_data_question_2_correct_2_011
|
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_011.py
|
refactory_data_question_2_correct_2_217
|
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
|
./refactory/data/question_2/code/correct/correct_2_217.py
|
refactory_data_question_2_correct_2_085
|
def unique_day(day, possible_birthdays):
count = 0
for i in possible_birthdays:
if day in i:
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 in i:
count += 1
if count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
for i in possible_birthdays:
if month in i:
if unique_day(i[1],possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_085.py
|
refactory_data_question_2_correct_2_196
|
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
|
./refactory/data/question_2/code/correct/correct_2_196.py
|
refactory_data_question_2_correct_2_002
|
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_002.py
|
refactory_data_question_2_correct_2_207
|
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
|
./refactory/data/question_2/code/correct/correct_2_207.py
|
refactory_data_question_2_correct_2_034
|
def unique_day(date, possible_birthdays):
flag = 0
for i in possible_birthdays:
if i[1] == date:
flag += 1
return True if flag == 1 else False
def unique_month(month, possible_birthdays):
flag = 0
for i in possible_birthdays:
if i[0] == month:
flag += 1
return True if flag == 1 else False
def contains_unique_day(month, possible_birthdays):
flag = 0
unique_days = []
for i in possible_birthdays:
if i[1] not in unique_days:
unique_days.append(i[1])
else:
unique_days.remove(i[1])
for i in possible_birthdays:
if i[0] == month and i[1] in unique_days:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_034.py
|
refactory_data_question_2_correct_2_020
|
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_020.py
|
refactory_data_question_2_correct_2_042
|
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_042.py
|
refactory_data_question_2_correct_2_260
|
def unique_day(day, possible_birthdays):
"""Your solution here"""
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
|
./refactory/data/question_2/code/correct/correct_2_260.py
|
refactory_data_question_2_correct_2_263
|
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
|
./refactory/data/question_2/code/correct/correct_2_263.py
|
refactory_data_question_2_correct_2_253
|
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_253.py
|
refactory_data_question_2_correct_2_231
|
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
|
./refactory/data/question_2/code/correct/correct_2_231.py
|
refactory_data_question_2_correct_2_151
|
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
|
./refactory/data/question_2/code/correct/correct_2_151.py
|
refactory_data_question_2_correct_2_232
|
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
|
./refactory/data/question_2/code/correct/correct_2_232.py
|
refactory_data_question_2_correct_2_067
|
def unique_day(day, possible_birthdays):
count = 0
for possible_birthday in possible_birthdays:
if day == possible_birthday[1]:
count += 1
return count == 1
def unique_month(month, possible_birthdays):
count = 0
for possible_birthday in possible_birthdays:
if month == possible_birthday[0]:
count += 1
return count == 1
def contains_unique_day(month, possible_birthdays):
for possible_birthday in possible_birthdays:
if month == possible_birthday[0] and unique_day(possible_birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_067.py
|
refactory_data_question_2_correct_2_005
|
def unique_day(day, possible_birthdays):
def dayfilter(birthday):
if birthday[1] == day:
return True
else:
return False
possible = tuple(filter(dayfilter,possible_birthdays))
if len(possible) == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
def monthfilter(birthday):
if birthday[0] == month:
return True
else:
return False
possible = tuple(filter(monthfilter,possible_birthdays))
if len(possible) == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
def monthfilter(birthday):
if birthday[0]==month:
return True
else:
return False
possible = tuple(filter(monthfilter,possible_birthdays))
def daymap(birthday):
return birthday[1]
possibledays = tuple(map(daymap,possible))
result = False
for n in range(0,len(possibledays)):
if unique_day(possibledays[n],possible_birthdays):
result = True
return result
|
./refactory/data/question_2/code/correct/correct_2_005.py
|
refactory_data_question_2_correct_2_273
|
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
|
./refactory/data/question_2/code/correct/correct_2_273.py
|
refactory_data_question_2_correct_2_078
|
def unique_day(day, possible_birthdays):
unique_day_counter = 0
for i in possible_birthdays:
if day == i[1]:
unique_day_counter += 1
if unique_day_counter != 1:
return False
return True
def unique_month(month, possible_birthdays):
unique_month_counter = 0
for i in possible_birthdays:
if month == i[0]:
unique_month_counter += 1
if unique_month_counter != 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
days = ()
true_false = ()
for i in possible_birthdays:
if month == i[0]:
days += (i[1], )
for j in days:
if unique_day(j, possible_birthdays):
true_false += ('True', )
else:
true_false += ('False', )
if 'True' in true_false:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_078.py
|
refactory_data_question_2_correct_2_257
|
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_257.py
|
refactory_data_question_2_correct_2_143
|
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
|
./refactory/data/question_2/code/correct/correct_2_143.py
|
refactory_data_question_2_correct_2_183
|
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
|
./refactory/data/question_2/code/correct/correct_2_183.py
|
refactory_data_question_2_correct_2_250
|
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)
|
./refactory/data/question_2/code/correct/correct_2_250.py
|
refactory_data_question_2_correct_2_245
|
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
|
./refactory/data/question_2/code/correct/correct_2_245.py
|
refactory_data_question_2_correct_2_121
|
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
|
./refactory/data/question_2/code/correct/correct_2_121.py
|
refactory_data_question_2_correct_2_070
|
def unique_day(day, possible_birthdays):
counter = 0
for dates in possible_birthdays:
if day == dates[1]:
possible_birthdays = possible_birthdays[1:]
counter = counter + 1
if counter == 1:
return True
else:
return False
return
def unique_month(month, possible_birthdays):
counter = 0
for dates in possible_birthdays:
if month == dates[0]:
possible_birthdays = possible_birthdays[1:]
counter = counter + 1
if counter == 1:
return True
else:
return False
def keep_month(month,possible_birthdays):
new_list = ()
for date in possible_birthdays:
if month == date[0]:
new_list = new_list + (date,)
return new_list
def contains_unique_day(month, possible_birthdays):
counter = 0
revised_list = keep_month(month,possible_birthdays)
for i in revised_list:
if unique_day(i[1], possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_070.py
|
refactory_data_question_2_correct_2_180
|
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
|
./refactory/data/question_2/code/correct/correct_2_180.py
|
refactory_data_question_2_correct_2_139
|
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
|
./refactory/data/question_2/code/correct/correct_2_139.py
|
refactory_data_question_2_correct_2_060
|
def unique_day(day, possible_birthdays):
total_day = 0
for birthday in possible_birthdays:
if birthday[1] == day:
total_day += 1
if total_day == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
total_month = 0
for birthday in possible_birthdays:
if birthday[0] == month:
total_month += 1
if total_month == 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):
birthday_month = birthday[0]
if month == birthday_month:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_060.py
|
refactory_data_question_2_correct_2_283
|
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
|
./refactory/data/question_2/code/correct/correct_2_283.py
|
refactory_data_question_2_correct_2_286
|
def unique_day(day, possible_birthdays):
a = 0
for item in possible_birthdays:
for i in item:
if i == day:
a += 1
if a == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
a = 0
for item in possible_birthdays:
for i in item:
if i == month:
a += 1
if a == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
a = 0
b = 0
for item in possible_birthdays:
if month in item:
a = item
if unique_day(item[1],possible_birthdays) == True:
b += 1
if b >= 1:
return True
else:
return False
|
./refactory/data/question_2/code/correct/correct_2_286.py
|
refactory_data_question_2_correct_2_003
|
def unique_day(day, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[1] == day:
count += 1
return count == 1
def unique_month(month, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[0] == month:
count += 1
return count == 1
def contains_unique_day(month, 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_003.py
|
refactory_data_question_2_correct_2_285
|
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_285.py
|
refactory_data_question_2_correct_2_204
|
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
|
./refactory/data/question_2/code/correct/correct_2_204.py
|
refactory_data_question_2_correct_2_118
|
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_118.py
|
refactory_data_question_2_correct_2_200
|
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
|
./refactory/data/question_2/code/correct/correct_2_200.py
|
refactory_data_question_2_correct_2_291
|
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 contains_unique_day(month, possible_birthdays):
b=0
for i in range(len(possible_birthdays)):
if month==possible_birthdays[i][0]:
b+=unique_day(possible_birthdays[i][1],possible_birthdays)
if b==0:
return False
else:
return True
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
|
./refactory/data/question_2/code/correct/correct_2_291.py
|
refactory_data_question_2_correct_2_159
|
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_159.py
|
refactory_data_question_2_correct_2_164
|
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_164.py
|
refactory_data_question_2_correct_2_103
|
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_103.py
|
refactory_data_question_2_correct_2_215
|
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_215.py
|
refactory_data_question_2_correct_2_276
|
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
|
./refactory/data/question_2/code/correct/correct_2_276.py
|
refactory_data_question_2_correct_2_004
|
def unique_day(day, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[1] == day:
count += 1
return count == 1
def unique_month(month, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[0] == month:
count += 1
return count == 1
def contains_unique_day(month, 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_004.py
|
refactory_data_question_2_correct_2_277
|
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
|
./refactory/data/question_2/code/correct/correct_2_277.py
|
refactory_data_question_2_correct_2_063
|
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_063.py
|
refactory_data_question_2_correct_2_187
|
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
|
./refactory/data/question_2/code/correct/correct_2_187.py
|
refactory_data_question_2_correct_2_107
|
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_107.py
|
refactory_data_question_2_correct_2_176
|
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
|
./refactory/data/question_2/code/correct/correct_2_176.py
|
refactory_data_question_2_correct_2_081
|
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_081.py
|
refactory_data_question_2_correct_2_084
|
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_084.py
|
refactory_data_question_2_correct_2_013
|
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_013.py
|
refactory_data_question_2_correct_2_167
|
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
|
./refactory/data/question_2/code/correct/correct_2_167.py
|
refactory_data_question_2_correct_2_146
|
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
|
./refactory/data/question_2/code/correct/correct_2_146.py
|
refactory_data_question_2_correct_2_280
|
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
|
./refactory/data/question_2/code/correct/correct_2_280.py
|
refactory_data_question_2_correct_2_226
|
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
|
./refactory/data/question_2/code/correct/correct_2_226.py
|
refactory_data_question_2_correct_2_047
|
def unique_day(day, possible_birthdays):
counter = 0
for date in possible_birthdays:
if day in date:
counter += 1
if counter != 1:
return False
return True
def unique_month(month, possible_birthdays):
counter = 0
for date in possible_birthdays:
if month in date:
counter += 1
return True if counter ==1 else False
def contains_unique_day(month, possible_birthdays):
contains = ()
for date in possible_birthdays:
if month in date and unique_day(date[1],possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_047.py
|
refactory_data_question_2_correct_2_094
|
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_094.py
|
refactory_data_question_2_correct_2_269
|
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_269.py
|
refactory_data_question_2_correct_2_166
|
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
|
./refactory/data/question_2/code/correct/correct_2_166.py
|
refactory_data_question_2_correct_2_275
|
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
|
./refactory/data/question_2/code/correct/correct_2_275.py
|
refactory_data_question_2_correct_2_156
|
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
|
./refactory/data/question_2/code/correct/correct_2_156.py
|
refactory_data_question_2_correct_2_186
|
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_186.py
|
refactory_data_question_2_correct_2_240
|
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
|
./refactory/data/question_2/code/correct/correct_2_240.py
|
refactory_data_question_2_correct_2_239
|
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
|
./refactory/data/question_2/code/correct/correct_2_239.py
|
refactory_data_question_2_correct_2_205
|
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_205.py
|
refactory_data_question_2_correct_2_124
|
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_124.py
|
refactory_data_question_2_correct_2_058
|
def unique_day(day, possible_birthdays):
total_day = 0
for birthday in possible_birthdays:
if birthday[1] == day:
total_day += 1
if total_day == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
total_month = 0
for birthday in possible_birthdays:
if birthday[0] == month:
total_month += 1
if total_month == 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):
birthday_month = birthday[0]
if month == birthday_month:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_058.py
|
refactory_data_question_2_correct_2_282
|
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_282.py
|
refactory_data_question_2_correct_2_030
|
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_030.py
|
refactory_data_question_2_correct_2_194
|
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
|
./refactory/data/question_2/code/correct/correct_2_194.py
|
refactory_data_question_2_correct_2_271
|
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
|
./refactory/data/question_2/code/correct/correct_2_271.py
|
refactory_data_question_2_correct_2_229
|
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_229.py
|
refactory_data_question_2_correct_2_161
|
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
|
./refactory/data/question_2/code/correct/correct_2_161.py
|
refactory_data_question_2_correct_2_219
|
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_219.py
|
refactory_data_question_2_correct_2_190
|
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_190.py
|
refactory_data_question_2_correct_2_055
|
def map(fn, seq):
res = ()
for ele in seq:
res = res + (fn(ele), )
return res
def filter(pred, seq):
res = ()
for ele in seq:
if pred(ele):
res = res + (ele, )
return res
def unique_day(day, possible_birthdays):
possible_days=map(lambda x:x[1],possible_birthdays)
def count(day,possible_days):
count_day=0
for i in possible_days:
if i==day:
count_day=count_day+1
return count_day
return count(day,possible_days)==1
def unique_month(month, possible_birthdays):
possible_months=map(lambda x:x[0],possible_birthdays)
def count(month,possible_months):
count_month=0
for i in possible_months:
if i==month:
count_month=count_month+1
return count_month
return count(month,possible_months)==1
def contains_unique_day(month, possible_birthdays):
tuple_with_unique_day=filter(lambda x:unique_day(x[1],possible_birthdays)==True,possible_birthdays)
month_with_unique_day=map(lambda x:x[0],tuple_with_unique_day)
return month in month_with_unique_day
|
./refactory/data/question_2/code/correct/correct_2_055.py
|
refactory_data_question_2_correct_2_142
|
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
|
./refactory/data/question_2/code/correct/correct_2_142.py
|
refactory_data_question_2_correct_2_261
|
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
|
./refactory/data/question_2/code/correct/correct_2_261.py
|
refactory_data_question_2_correct_2_210
|
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
|
./refactory/data/question_2/code/correct/correct_2_210.py
|
refactory_data_question_2_correct_2_255
|
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_255.py
|
refactory_data_question_2_correct_2_278
|
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
|
./refactory/data/question_2/code/correct/correct_2_278.py
|
refactory_data_question_2_correct_2_033
|
def unique_day(date, possible_birthdays):
flag = 0
for i in possible_birthdays:
if i[1] == date:
flag += 1
return True if flag == 1 else False
def unique_month(month, possible_birthdays):
flag = 0
for i in possible_birthdays:
if i[0] == month:
flag += 1
return True if flag == 1 else False
def contains_unique_day(month, possible_birthdays):
flag = 0
unique_days = []
for i in possible_birthdays:
if i[1] not in unique_days:
unique_days.append(i[1])
else:
unique_days.remove(i[1])
for i in possible_birthdays:
if i[0] == month and i[1] in unique_days:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_033.py
|
refactory_data_question_2_correct_2_031
|
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_031.py
|
refactory_data_question_2_correct_2_099
|
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_099.py
|
refactory_data_question_2_correct_2_007
|
def unique_day(date, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[1] == date:
count += 1
return count == 1
def unique_month(month, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if birthday[0] == month:
count += 1
return count == 1
def contains_unique_day(month, 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_007.py
|
refactory_data_question_2_correct_2_090
|
def unique_day(day, possible_birthdays):
count = 0
for i in possible_birthdays:
if day in i:
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 in i:
count += 1
if count == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
for i in possible_birthdays:
if month in i:
if unique_day(i[1],possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_090.py
|
refactory_data_question_2_correct_2_048
|
def unique_day(day, possible_birthdays):
days = ()
for birthdays in possible_birthdays:
days += (birthdays[1],)
a = 0
for dates in days:
if day == dates:
a +=1
if a !=1:
return False
return True
def unique_month(month, possible_birthdays):
months = ()
for birthdays in possible_birthdays:
months += (birthdays[0],)
a = 0
for dates in months:
if month == dates:
a +=1
if a !=1:
return False
return True
def contains_unique_day(month, possible_birthdays):
dates =()
for birthdays in possible_birthdays:
if unique_day(birthdays[1], possible_birthdays):
dates += (birthdays[0],)
for days in dates:
if month in dates:
return True
break
return False
|
./refactory/data/question_2/code/correct/correct_2_048.py
|
refactory_data_question_2_correct_2_238
|
def unique_day(day, possible_birthdays):
"""Your solution here"""
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
|
./refactory/data/question_2/code/correct/correct_2_238.py
|
refactory_data_question_2_correct_2_198
|
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_198.py
|
refactory_data_question_2_correct_2_052
|
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_052.py
|
refactory_data_question_2_correct_2_082
|
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 birthday in possible_birthdays:
if month == birthday[0]:
count += 1
return count == 1
def contains_unique_day(month, possible_birthdays):
singlemonthbirthday = ()
for birthmonth in possible_birthdays:
if month == birthmonth[0]:
singlemonthbirthday += (birthmonth,)
for birthday in singlemonthbirthday:
if unique_day(birthday[1], possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/correct/correct_2_082.py
|
refactory_data_question_2_correct_2_203
|
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
|
./refactory/data/question_2/code/correct/correct_2_203.py
|
refactory_data_question_2_correct_2_169
|
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_169.py
|
refactory_data_question_2_correct_2_032
|
def unique_day(day, possible_birthdays):
count = 0
for possible_birthday in possible_birthdays:
if possible_birthday[1] == day:
count += 1
continue
if count == 1:
return True
return False
def unique_month(month, possible_birthdays):
count = 0
for possible_birthday in possible_birthdays:
if possible_birthday[0] == month:
count += 1
continue
if count == 1:
return True
return False
def contains_unique_day(month, possible_birthdays):
days_in_month = ()
for possible_birthday in possible_birthdays:
if possible_birthday[0] == month:
days_in_month += (possible_birthday[1],)
continue
for day in days_in_month:
if unique_day(day, possible_birthdays) == True:
return True
continue
return False
|
./refactory/data/question_2/code/correct/correct_2_032.py
|
refactory_data_question_2_correct_2_095
|
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_095.py
|
refactory_data_question_2_correct_2_175
|
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_175.py
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.