id
stringlengths 35
39
| content
stringlengths 44
3.85k
| max_stars_repo_path
stringlengths 52
57
|
|---|---|---|
refactory_data_question_2_wrong_2_422
|
def unique_day(date, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if str(date) == birthdate[1]:
counter += 1
if counter > 1 or counter == 0:
return False
else:
return True
def unique_month(month, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if month == birthdate[0]:
counter += 1
if counter > 1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if month == birthdate[0]:
r = unique_day(birthdate[1], possible_birthdays)
if r == True:
counter += 1
if counter >= 1:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_422.py
|
refactory_data_question_2_wrong_2_203
|
def unique_day(day, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[1]==day:
counter=counter+1
if counter<=1:
return true
else:
return False
return True
def unique_month(month, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[0]==month:
counter=counter+1
if counter<=1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
temp=()
for i in possible_birthdays:
if i[0]==month:
temp=temp+(i,)
for i in temp:
if unique_day(i[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_203.py
|
refactory_data_question_2_wrong_2_131
|
def unique_day(day, possible_birthdays):
days = ()
for all_days in possible_birthdays:
days = days + (all_days[1],)
i = 0
for all_days in days:
if all_days == day:
i = i+1
if i == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
months = ()
for all_months in possible_birthdays:
months = months + (all_months[0],)
i = 0
for all_months in months:
if all_months == month:
i = i+1
if i == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
May_days = ()
June_days = ()
July_days = ()
August_days = ()
May_dates = possible_birthdays[:3]
for all_days in May_dates:
May_days = May_days + (all_days[1],)
June_dates = possible_birthdays[3:5]
for all_days in June_dates:
June_days = June_days + (all_days[1],)
July_dates = possible_birthdays[5:7]
for all_days in July_dates:
July_days = July_days + (all_days[1],)
August_dates = possible_birthdays[7:]
for all_days in August_dates:
August_days = August_days + (all_days[1],)
if month == 'May':
for days in May_days:
found_repeated = 0
for check_day in June_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in July_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in August_days:
if days == check_day:
found_repeated = 1
break
elif month == 'June':
for days in June_days:
found_repeated = 0
for check_day in May_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in July_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in August_days:
if days == check_day:
found_repeated = 1
break
elif month == 'July':
for days in July_days:
found_repeated = 0
for check_day in May_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in June_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in August_days:
if days == check_day:
found_repeated = 1
break
else:
for days in August_days:
found_repeated = 0
for check_day in May_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in June_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
for check_day in July_days:
if days == check_day:
found_repeated = 1
break
if found_repeated == 0:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_131.py
|
refactory_data_question_2_wrong_2_212
|
def unique_day(date, possible_birthdays):
count=0
for i in range(len(possible_birthdays)):
if date==possible_birthdays[i][1]:
count=count+1
if count>=2:
return False
return True
def unique_month(month, possible_birthdays):
count=0
for i in range(len(possible_birthdays)):
if month==possible_birthdays[i][0]:
count=count+1
if count>=2:
return False
return True
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):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_212.py
|
refactory_data_question_2_wrong_2_011
|
def unique_day(date, 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 i in range(len(possible_birthdays)):
if possible_birthdays[i][0] == month:
months = months + 1
if months == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
x = ()
for i in range(len(possible_birthdays)):
if possible_birthdays[i][0] == month:
x = x + (possible_birthdays[i],)
for j in range(len(x)):
if unique_day(x[j][1], possible_birthdays):
return True
else:
continue
return False
|
./refactory/data/question_2/code/wrong/wrong_2_011.py
|
refactory_data_question_2_wrong_2_339
|
def unique_day(date, possible_birthdays):
counter = 0
for i in possible_birthdays:
if date in i:
counter +=1
if counter >1:
return False
else:
return True
def unique_month(month, possible_birthdays):
counter = 0
for i in possible_birthdays:
if month in i:
counter += 1
if counter > 1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
birthdays = ()
for i in possible_birthdays:
if month in i:
birthdays += (i,)
for i in birthdays:
if not unique_day(i[1], possible_birthdays):
result = False
else:
result = True
break
return result
|
./refactory/data/question_2/code/wrong/wrong_2_339.py
|
refactory_data_question_2_wrong_2_038
|
def unique_day(date, possible_birthdays):
tup = ()
for i in possible_birthdays:
if i[1] == day:
tup += (i[1],)
if len(tup) == 1:
return True
elif len(tup) > 1:
return False
elif len(tup) == 0:
return None
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/wrong/wrong_2_038.py
|
refactory_data_question_2_wrong_2_273
|
def unique_day(day, possible_birthdays):
num=0
for i in possible_birthdays:
if i[1]==day: num+=1
return num==1
def unique_month(month, possible_birthdays):
num=0
for i in possible_birthdays:
if i[1]==month: num+=1
return num==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/wrong/wrong_2_273.py
|
refactory_data_question_2_wrong_2_335
|
def unique_day(date, possible_birthdays):
bdaylist = possible_birthdays
count = 0
while len(bdaylist) > 0:
single = bdaylist[0]
if single[1] == day:
count = count + 1
if count == 2:
return False
break
bdaylist = bdaylist[1:]
return True
def unique_month(month, possible_birthdays):
bdaylist = possible_birthdays
count = 0
while len(bdaylist) > 0:
single = bdaylist[0]
if single[0] == month:
count = count + 1
if count == 2:
return False
break
bdaylist = bdaylist[1:]
return True
def contains_unique_day(month, possible_birthdays):
month_list = ()
bday_list = possible_birthdays
while len(bday_list)>0:
if bday_list[0][0]==month:
month_list = month_list + (bday_list[0],)
bday_list = bday_list[1:]
while len(month_list)>0:
if unique_day(month_list[0][1],possible_birthdays):
return True
month_list = month_list[1:]
return False
|
./refactory/data/question_2/code/wrong/wrong_2_335.py
|
refactory_data_question_2_wrong_2_048
|
def unique_day(day, possible_birthdays):
counter = 0
result = 0
while counter < len(possible_birthdays):
date = possible_birthdays[counter][1]
if date == day:
result = result + 1
counter = counter + 1
if result > 1:
return False
return True
def unique_month(month, possible_birthdays):
counter = 0
result = 0
while counter < len(possible_birthdays):
chosen_month = possible_birthdays[counter][0]
if chosen_month == month:
result = result + 1
counter = counter + 1
if result > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
counter = 0
while counter < len(possible_birthdays):
get_month = possible_birthdays[counter][0]
if get_month == month:
test_date = possible_birthdays[counter][1]
if unique_day(test_date, possible_birthdays) == True:
return True
counter = counter + 1
return False
|
./refactory/data/question_2/code/wrong/wrong_2_048.py
|
refactory_data_question_2_wrong_2_164
|
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 possible_birthdays:
if i[0] == month:
days_in_month += (i[1],)
return days_in_month
def contains_unique_day(month, possible_birthdays):
for x in range(len(days(month, possible_birthdays))):
if unique_day(x, possible_birthdays) == False:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_164.py
|
refactory_data_question_2_wrong_2_186
|
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 contains_unique_day(month, possible_birthdays):
days_in_month = ()
for i in possible_birthdays:
if i[0] == month:
days_in_month += (i,)
for x in range(len(days_in_month)):
if unique_day(days_in_month[x][1], possible_birthdays) == False:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_186.py
|
refactory_data_question_2_wrong_2_114
|
def unique_day(day, possible_birthdays):
check = 0
for birthday in possible_birthdays:
if birthday[1] == day:
check = check + 1
if check > 1 :
return False
else:
return True
def unique_month(month, possible_birthdays):
check = 0
for birthday in possible_birthdays:
if birthday[0] == month:
check = check + 1
if check > 1 :
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
for birthday in possible_birthdays:
if month == birthday[0] and unique_day(birthday[1], possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_114.py
|
refactory_data_question_2_wrong_2_121
|
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 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:
return False
else:
continue
|
./refactory/data/question_2/code/wrong/wrong_2_121.py
|
refactory_data_question_2_wrong_2_250
|
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):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_250.py
|
refactory_data_question_2_wrong_2_348
|
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
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/wrong/wrong_2_348.py
|
refactory_data_question_2_wrong_2_041
|
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):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_041.py
|
refactory_data_question_2_wrong_2_123
|
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):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_123.py
|
refactory_data_question_2_wrong_2_423
|
def unique_day(date, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if date == birthdate[1]:
counter += 1
if counter > 1 or counter == 0:
return False
else:
return True
def unique_month(month, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if month == birthdate[0]:
counter += 1
if counter > 1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if month == birthdate[0]:
r = unique_day(birthdate[1], possible_birthdays)
if r == True:
counter += 1
if counter >= 1:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_423.py
|
refactory_data_question_2_wrong_2_117
|
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 contains_unique_day(month, possible_birthdays):
for i in possible_birthdays:
if i[0] == month:
if unique_day(x, possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_117.py
|
refactory_data_question_2_wrong_2_410
|
def unique_day(date, possible_birthdays):
i=0
count=0
while i<=len(possible_birthdays):
if possible_birthdays[i][1]==date:
count+=1
i+=1
if count==1:
return True
else:
return False
def unique_month(month, possible_birthdays):
i=0
count=0
while i<=len(possible_birthdays):
if possible_birthdays[i][0]==month:
count+=1
i+=1
if count==1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
if month=='June':
return True
elif month=='May':
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_410.py
|
refactory_data_question_2_wrong_2_368
|
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 counter == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_368.py
|
refactory_data_question_2_wrong_2_129
|
def unique_day(day, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[1] == day:
counter = counter + 1
if counter > 1:
return False
else:
return True
def unique_month(month, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[0] == month:
counter = counter + 1
if counter > 1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
x = ()
for i in possible_birthdays:
if i[0] == month:
x = x + (i,)
total = 0
for i in x:
total = total + unique_day(i[1], possible_birthdays)
if total != 0:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_129.py
|
refactory_data_question_2_wrong_2_272
|
def unique_day(day, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
if birthday[1] == day:
counter = counter + 1
if counter <= 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
if birthday[0]== month:
counter = counter + 1
if counter <= 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
a =()
for birthday in possible_birthdays:
if birthday[0] == month:
a = a + (birthday,)
for birthday in a:
if unique_day(birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_272.py
|
refactory_data_question_2_wrong_2_187
|
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 contains_unique_day(month, possible_birthdays):
days_in_month = ()
for i in possible_birthdays:
if i[0] == month:
days_in_month += (i,)
for x in days_in_month:
if unique_day(x[1], possible_birthdays) == False:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_187.py
|
refactory_data_question_2_wrong_2_352
|
def unique_day(date, possible_birthdays):
lenth=len(possible_birthdays)
count=0
for i in range(0,lenth):
if date==possible_birthday[i][1]:
count=count+1
if count==1:
return True
else:
return False
def unique_month(month, possible_birthdays):
lenth=len(possible_birthdays)
count=0
for i in range(0,lenth):
if month==possible_birthday[i][0]:
count=count+1
if count==1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
count=()
for i in possible_birthdays:
if i[0]==month:
count=count+i
for j in count:
if unique_day(j[1], possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_352.py
|
refactory_data_question_2_wrong_2_163
|
def unique_day(day, possible_birthdays):
count=0
for i in possible_birthdays:
if i[1]==day:
count+=1
if count>1:
check=False
else:
check=True
return check
def unique_month(month, possible_birthdays):
count=0
for i in possible_birthdays:
if i[0]==month:
count+=1
if count>1:
check=False
else:
check=True
return check
def contains_unique_day(month, possible_birthdays):
birthdays=()
for i in possible_birthdays:
if i[0]==month:
birthdays+=(i,)
for j in birthdays:
if unique_day(j[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_163.py
|
refactory_data_question_2_wrong_2_281
|
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):
focus = ()
unique_days = ()
for i in possible_birthdays:
if month == i[0]:
focus += (i,)
for j in focus:
testday = j[1]
if unique_day(testday, possible_birthdays) == True:
unique_days += (testday,)
for k in unique_days:
for l in focus:
if k == l[1]:
break
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_281.py
|
refactory_data_question_2_wrong_2_277
|
def unique_day(date, possible_birthdays):
if day in possible_birthdays:
return True
else:
return False
def unique_month(month, possible_birthdays):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_277.py
|
refactory_data_question_2_wrong_2_319
|
def unique_day(day, possible_birthdays):
count = 0
for i in possible_birthdays:
if day in i:
count += 1
if count > 1:
return False
return True
def unique_month(month, possible_birthdays):
count = 0
for i in possible_birthdays:
if month in i:
count += 1
if count > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
days = ()
for i in possible_birthdays:
if month in i:
days += (i[1],)
for j in days:
if unique_day(j, possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_319.py
|
refactory_data_question_2_wrong_2_136
|
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 contains_unique_day(month, possible_birthdays):
for i in possible_birthdays:
if i[0] == month:
if unique_day(i[1], possible_birthdays):
return True
continue
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_136.py
|
refactory_data_question_2_wrong_2_388
|
def unique_day(day, possible_birthdays):
count = 0
for month_day in possible_birthdays:
date = month_day[1]
if day == date:
count+= 1
return count == 1
def unique_month(month, possible_birthdays):
count = 0
for month_day in possible_birthdays:
mont = month_day[0]
if month == mont:
count+= 1
return count == 1
def contains_unique_day(month, possible_birthdays):
condition = False
for month_day in possible_birthdays:
if month == month_day[0]:
condition = unique_day(month_day[1],possible_birthdays)
return condition
|
./refactory/data/question_2/code/wrong/wrong_2_388.py
|
refactory_data_question_2_wrong_2_176
|
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 contains_unique_day(month, possible_birthdays):
days_in_month = ()
for i in possible_birthdays:
if i[0] == month:
days_in_month += (i[1],)
for i in range(len(days(month, possible_birthdays))):
if unique_day(i, possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_176.py
|
refactory_data_question_2_wrong_2_008
|
def unique_day(date, possible_birthdays):
days = 0
for i in range(len(possible_birthdays)):
if possible_birthdays[i][1] == days:
day = day + 1
if days == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
months = 0
for i in range(len(possible_birthdays)):
if possible_birthdays[i][0] == month:
months = months + 1
if months == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
x = ()
for i in range(len(possible_birthdays)):
if possible_birthdays[i][0] == month:
x = x + (possible_birthdays[i],)
for j in range(len(x)):
if unique_day(x[j][1], possible_birthdays):
return True
else:
continue
return False
|
./refactory/data/question_2/code/wrong/wrong_2_008.py
|
refactory_data_question_2_wrong_2_146
|
def unique_day(day, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if day == birthday[1]:
count += 1
if count > 1:
return False
return True
def unique_month(month, possible_birthdays):
count = 0
for birthday in possible_birthdays:
if month == birthday[0]:
count += 1
if count > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
birthdays_month = ()
for birthday in possible_birthdays:
if month == birthday[0]:
birthdays_month += (birthday,)
for birthday in birthdays_month:
if unique_day(birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_146.py
|
refactory_data_question_2_wrong_2_231
|
def unique_day(day, possible_birthdays):
result = ()
for p in possible_birthdays:
pd = p[1]
if day == pd:
result = result + (day,)
if len(result) > 1:
return False
return True
def unique_month(month, possible_birthdays):
result = ()
for p in possible_birthdays:
pm = p[0]
if month == pm:
result = result + (month,)
if len(result) > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_231.py
|
refactory_data_question_2_wrong_2_194
|
def unique_day(day, possible_birthdays):
x = 1
for i in possible_birthdays:
if day == i[1]:
x = x + 1
else:
x = x
if x > 2:
return False
else:
return True
def unique_month(month, possible_birthdays):
x = 1
for i in possible_birthdays:
if month == i[0]:
x = x + 1
else:
x = x
if x > 2:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
y = ()
for i in possible_birthdays:
if i[0] == month:
y = y + (i, )
for a in y:
if unique_day(a[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_194.py
|
refactory_data_question_2_wrong_2_274
|
def unique_day(day, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
if birthday[1] == day:
counter = counter + 1
if counter <= 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
if birthday[0]== month:
counter = counter + 1
if counter <= 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
a =()
for birthday in possible_birthdays:
if birthday[0] == month:
a = a + (birthday,)
for birthday in a:
if unique_day(birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_274.py
|
refactory_data_question_2_wrong_2_119
|
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 contains_unique_day(month, possible_birthdays):
for i in possible_birthdays:
if i[0] == month:
if unique_day(i, possible_birthdays):
return True
else:
return False
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_119.py
|
refactory_data_question_2_wrong_2_110
|
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 unique_month(month, possible_birthdays):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_110.py
|
refactory_data_question_2_wrong_2_249
|
def unique_day(day, possible_birthdays):
counter = 0
for days in range(len(possible_birthdays)):
if str(day) == possible_birthdays[days][1]:
counter += 1
return True if counter == 1 else False
def unique_month(month, possible_birthdays):
counter = 0
for mth in range(len(possible_birthdays)):
if month == possible_birthdays[mth][0]:
counter += 1
return True if counter == 1 else False
def contains_unique_day(month, possible_birthdays):
daystoconsider = ()
i = 0
while i < len(possible_birthdays):
if month == possible_birthdays[i][0]:
daystoconsider += (possible_birthdays[i][1],)
i += 1
monthcontaininguniqueday = ()
for a in range(len(possible_birthdays)):
if possible_birthdays[a][1] in daystoconsider:
monthcontaininguniqueday += (possible_birthdays[a][0],)
for mth in range(len(monthcontaininguniqueday)):
if monthcontaininguniqueday[mth] == month:
return True
break
return False
|
./refactory/data/question_2/code/wrong/wrong_2_249.py
|
refactory_data_question_2_wrong_2_433
|
def unique_day(date, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[1] == date:
counter += 1
if counter > 1:
return False
return True
def unique_month(month, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[0] == month:
counter += 1
if counter > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
new_tuple = ()
for i in possible_birthdays:
if i[0] == month:
new_tuple += (i,)
print(new_tuple)
for i in range(0,len(new_tuple)):
if unique_day(new_tuple[i][1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_433.py
|
refactory_data_question_2_wrong_2_142
|
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 possible_birthdays:
if i[0] == month:
days_in_month += (i[1],)
return days_in_month
def contains_unique_day(month, possible_birthdays):
for x in days(month, possible_birthdays):
if unique_day(x, possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_142.py
|
refactory_data_question_2_wrong_2_334
|
def unique_day(date, possible_birthdays):
bdaylist = possible_birthdays
count = 0
while len(bdaylist) > 0:
single = bdaylist[0]
if single[1] == day:
count = count + 1
if count == 2:
return False
break
bdaylist = bdaylist[1:]
return True
def unique_month(month, possible_birthdays):
bdaylist = possible_birthdays
count = 0
while len(bdaylist) > 0:
single = bdaylist[0]
if single[0] == month:
count = count + 1
if count == 2:
return False
break
bdaylist = bdaylist[1:]
return True
def contains_unique_day(month, possible_birthdays):
month_list = ()
bday_list = possible_birthdays
while len(bday_list)>0:
if bday_list[0][0]==month:
month_list = month_list + (bday_list[0],)
bday_list = bday_list[1:]
while len(month_list)>0:
if unique_day(month_list[0][1],possible_birthdays):
return True
month_list = month_list[1:]
return False
|
./refactory/data/question_2/code/wrong/wrong_2_334.py
|
refactory_data_question_2_wrong_2_232
|
def unique_day(day, possible_birthdays):
result = ()
for p in possible_birthdays:
pd = p[1]
if day == pd:
result = result + (day,)
if len(result) > 1:
return False
return True
def unique_month(month, possible_birthdays):
result = ()
for p in possible_birthdays:
pm = p[0]
if month == pm:
result = result + (month,)
if len(result) > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
result = ()
for p in possible_birthdays:
if month == p[0]:
result = result + (p,)
for r in result:
if unique_day(r[1], possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_232.py
|
refactory_data_question_2_wrong_2_218
|
def unique_day(date, possible_birthdays):
j = 0
for i in possible_birthdays:
if day == i[1]:
j = j+1
else:
j = j
if j == 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_218.py
|
refactory_data_question_2_wrong_2_156
|
def unique_day(day, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[1]==day:
counter=counter+1
if counter<=1:
return true
else:
return False
return True
def unique_month(month, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[0]==month:
counter=counter+1
if counter<=1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_156.py
|
refactory_data_question_2_wrong_2_322
|
def unique_day(day, possible_birthdays):
counter=0
for dates in possible_birthdays:
if day==dates[1]:
counter=counter+1
else:
continue
if counter>1:
return False
else:
return True
def unique_month(month, possible_birthdays):
counter=0
for dates in possible_birthdays:
if month==dates[0]:
counter=counter+1
else:
continue
if counter>1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
def month_tuple(month,possible_birthdays):
new_tuple=()
for dates in possible_birthdays:
if month==dates[0]:
new_tuple=new_tuple+(dates,)
else:
continue
return new_tuple
new_tuple=month_tuple(month,possible_birthdays)
for dates2 in new_tuple:
counter=0
for dates in possible_birthdays:
if dates2[1]==dates[1]:
counter=counter+1
else:
continue
if counter>1:
return False
else:
return True
|
./refactory/data/question_2/code/wrong/wrong_2_322.py
|
refactory_data_question_2_wrong_2_387
|
def unique_day(date, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if str(date) == birthdate[1]:
counter += 1
if counter > 1:
return False
else:
return True
def unique_month(month, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if month == birthdate[0]:
counter += 1
if counter > 1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
counter = 0
for birthdate in possible_birthdays:
if month == birthdate[0]:
tp = unique_day(birthdate[1], possible_birthdays)
if tp == True:
counter += 1
if counter >= 1:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_387.py
|
refactory_data_question_2_wrong_2_086
|
def unique_day(day, possible_birthdays):
counted = ()
for birthdays in possible_birthdays:
if birthdays[1] == day:
if day not in counted:
counted += (day,)
else:
return False
return True
|
./refactory/data/question_2/code/wrong/wrong_2_086.py
|
refactory_data_question_2_wrong_2_252
|
def unique_day(date, possible_birthdays):
counter = 0
for i in range(len(possible_birthdays)):
if possible_birthdays[i][1] == day:
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/wrong/wrong_2_252.py
|
refactory_data_question_2_wrong_2_049
|
def unique_day(date, possible_birthdays):
for x in range(len(1,possible_birthdays + 1)):
for i in possible_birthdays[x][1]:
if i == possible_birthdays[0][1]:
return False
else:
return i == unique_day(date,possible_birthdays[1:][1])
def unique_month(month, possible_birthdays):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_049.py
|
refactory_data_question_2_wrong_2_040
|
def unique_day(date, possible_birthdays):
num = 0
for birthday in possible_birthdays:
if day == 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/wrong/wrong_2_040.py
|
refactory_data_question_2_wrong_2_305
|
def unique_day(date, possible_birthdays):
count=0
for i in possible_birthdays:
if i[1]==date:
count+=1
if count==1:
return True
def unique_month(month, possible_birthdays):
if month in possible_birthdays[0]:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
if not unique_day and not unique_month:
return False
else:
return True
|
./refactory/data/question_2/code/wrong/wrong_2_305.py
|
refactory_data_question_2_wrong_2_411
|
def unique_day(day, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[1]==day:
counter+=1
return counter<=1
def unique_month(month, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[0]==month:
counter+=1
return counter<=1
def contains_unique_day(month, possible_birthdays):
value=()
for i in possible_birthdays:
if i[0]==month:
value+=(i,)
for i in value:
if unique_day(i[1],possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_411.py
|
refactory_data_question_2_wrong_2_153
|
def unique_day(day, possible_birthdays):
count=0
for i in possible_birthdays:
if i[1]==day:
count+=1
if count>1:
check=False
else:
check=True
return check
def unique_month(month, possible_birthdays):
count=0
for i in possible_birthdays:
if i[0]==month:
count+=1
if count>1:
check=False
else:
check=True
return check
def contains_unique_day(month, possible_birthdays):
birthdays=()
for i in possible_birthdays:
if i[0]==month:
birthdays+=(i,)
for j in birthdays:
if unique_day(j[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_153.py
|
refactory_data_question_2_wrong_2_224
|
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):
return
|
./refactory/data/question_2/code/wrong/wrong_2_224.py
|
refactory_data_question_2_wrong_2_254
|
def unique_day(date, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
if birthday[1]== day:
counter = counter + 1
if counter <= 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
counter = 0
for birthday in possible_birthdays:
if birthday[0]== month:
counter = counter + 1
if counter <= 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
a =()
for birthday in possible_birthdays:
if birthday[0] == month:
a = a + (birthday,)
for birthday in a:
if unique_day(birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_254.py
|
refactory_data_question_2_wrong_2_269
|
def unique_day(day, possible_birthdays):
total = ()
for i in possible_birthdays:
total += (i[1],)
if total.count(day) > 1:
return False
else:
return True
def unique_month(month, possible_birthdays):
total = ()
for i in possible_birthdays:
total += (i[0],)
if total.count(month) > 1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
uniquedays = ()
daysinmonth = ()
for i in possible_birthdays:
if unique_day(i[1], possible_birthdays)== True:
uniquedays += (i[1],)
for i in possible_birthdays:
if i[0] == month:
daysinmonth += (i[1],)
for each in uniquedays:
if each in daysinmonth:
return True
else:
continue
return False
|
./refactory/data/question_2/code/wrong/wrong_2_269.py
|
refactory_data_question_2_wrong_2_133
|
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):
return
|
./refactory/data/question_2/code/wrong/wrong_2_133.py
|
refactory_data_question_2_wrong_2_302
|
def unique_day(day, possible_birthdays):
num=0
for i in possible_birthdays:
if i[1]==day: num+=1
return num==1
def unique_month(month, possible_birthdays):
num=0
for i in possible_birthdays:
if i[1]==month: num+=1
return num==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/wrong/wrong_2_302.py
|
refactory_data_question_2_wrong_2_357
|
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):
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:
tf=tf or unique_day(i[1],possible_birthdays)
return tf
|
./refactory/data/question_2/code/wrong/wrong_2_357.py
|
refactory_data_question_2_wrong_2_139
|
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 possible_birthdays:
if i[0] == month:
days_in_month += (i[1],)
return days_in_month
def contains_unique_day(month, possible_birthdays):
for x in days:
if unique_day(x, possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_139.py
|
refactory_data_question_2_wrong_2_063
|
def unique_day(day, possible_birthdays):
bag = ()
for date in possible_birthdays:
if date[1] == day:
bag += (date[1],)
if len(bag) >= 2:
return False
return True
def unique_month(month, possible_birthdays):
bag = ()
for date in possible_birthdays:
if date[0] == month:
bag += (date[0],)
if len(bag) >= 2:
return False
return True
def contains_unique_day(month, possible_birthdays):
for date in possible_birthdays:
if date[0] == month:
day = date[1]
if unique_day(day, possible_birthdays):
return True
else:
continue
return False
|
./refactory/data/question_2/code/wrong/wrong_2_063.py
|
refactory_data_question_2_wrong_2_409
|
def unique_day(day, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[1]==day:
counter+=1
return counter<=1
def unique_month(month, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[0]==month:
counter+=1
return counter<=1
def contains_unique_day(month, possible_birthdays):
temp=()
for i in possible_birthdays:
if i[0]==month:
temp+=(i,)
for i in temp:
if unique_day(i[1],possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_409.py
|
refactory_data_question_2_wrong_2_061
|
def unique_day(day, possible_birthdays):
days = tuple(filter(lambda x: x[1] == day, possible_birthdays))
if len(days) <= 1:
return True
else:
return False
def unique_month(month, possible_birthdays):
months = tuple(filter(lambda x: x[0] == month, possible_birthdays))
if len(months) <= 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
dates = ()
for date in possible_birthdays:
if date[0] == month:
dates += (date,)
for dated in dates:
if unique_day(dated[1], possible_birthdays) == True:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_061.py
|
refactory_data_question_2_wrong_2_108
|
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 == 0:
return True
else:
return False
def unique_month(month, possible_birthdays):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_108.py
|
refactory_data_question_2_wrong_2_389
|
def unique_day(day, possible_birthdays):
count = 0
for item in possible_birthdays:
if day == item[1]:
count +=1
else:
continue
if count >=2:
return False
else:
return True
def unique_month(month, possible_birthdays):
count = 0
for item in possible_birthdays:
if motnh == item[0]:
count +=1
else:
continue
if count >=2:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_389.py
|
refactory_data_question_2_wrong_2_039
|
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
elif len(tup) > 1:
return False
elif len(tup) == 0:
return None
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/wrong/wrong_2_039.py
|
refactory_data_question_2_wrong_2_215
|
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):
a = map(lambda x : x[1], possible_birthdays)
for i in a:
if i == day:
b = filter(lambda x: x == i, a)
if len(b) > 1:
return False
else:
return True
def unique_month(month, possible_birthdays):
a = map(lambda x : x[0], possible_birthdays)
for i in a:
if i == month:
b = filter(lambda x: x == i, a)
if len(b) > 1:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
a = map(lambda x : x[0], possible_birthdays)
b = map(lambda x : x[1], possible_birthdays)
k = ()
for i in range(len(a)):
if month == a[i]:
k += (b[i],)
for f in range(len(k)):
if len(filter(lambda x: x == k[f],b)) == 1:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_215.py
|
refactory_data_question_2_wrong_2_080
|
def unique_day(date, possible_birthdays):
result=()
counter=0
for i in possible_birthdays:
if day==i[1]:
result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
break
else:
counter+=1
continue
for i in result:
if day==i[1]:
return False
return True
def unique_month(month, possible_birthdays):
result=()
counter=0
for i in possible_birthdays:
if month==i[0]:
result=result+(possible_birthdays[:counter]+possible_birthdays[counter+1:])
break
else:
counter+=1
continue
for i in result:
if month==i[0]:
return False
return True
def contains_unique_day(month, possible_birthdays):
result=()
for i in possible_birthdays:
if i[0]==month:
result+=(i,) #result should contain all the birthdays with the specified month.
for i in result:
if unique_day(i[1],possible_birthdays)==True:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_080.py
|
refactory_data_question_2_wrong_2_431
|
def unique_day(date, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[1] == date:
counter += 1
if counter > 1:
return False
return True
def unique_month(month, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[0] == month:
counter += 1
if counter > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
new_tuple = ()
for i in possible_birthdays:
if i[0] == month:
new_tuple += (i,)
if len(new_tuple)>1:
return False
else:
return unique_day(new_tupl[0][1], possible_birthdays)
|
./refactory/data/question_2/code/wrong/wrong_2_431.py
|
refactory_data_question_2_wrong_2_285
|
def unique_day(date, possible_birthdays):
counter = 0
for i in possible_birthdays:
if i[1] == day:
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 i[1] == day:
counter += 1
else:
continue
if counter == 1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
tup = ()
for i in possible_birthdays:
if i[0] == month:
tup += ((i),)
else:
continue
for i in tup:
if unique_day(i[1], possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_285.py
|
refactory_data_question_2_wrong_2_312
|
def unique_day(day, possible_birthdays):
counter=0
for date in possible_birthdays:
if date[1]==day:
conter+=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[1]==month:
conter+=1
else:
counter=counter
if counter==1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_312.py
|
refactory_data_question_2_wrong_2_074
|
def unique_day(date, possible_birthdays):
no_of_days = 0
for i in possible_birthdays:
if i[1] == day:
no_of_days += 1
if no_of_days != 1:
return False
return True
def unique_month(month, possible_birthdays):
no_of_months = 0
for i in possible_birthdays:
if i[0] == month:
no_of_months += 1
if no_of_months != 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
birthdays_with_month = ()
for i in possible_birthdays:
if i[0] == month:
birthdays_with_month += (i[1],)
counter = 0
for i in birthdays_with_month:
if unique_day(i, possible_birthdays) == True:
counter += 1
if counter == 1:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_074.py
|
refactory_data_question_2_wrong_2_279
|
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):
for day in possible_birthdays:
if unique_day(day[1], possible_birthdays) == True and month == day[0]:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_279.py
|
refactory_data_question_2_wrong_2_314
|
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_date(i, possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_314.py
|
refactory_data_question_2_wrong_2_062
|
def filter(pred, seq):
res = ()
for ele in seq:
if pred(ele):
res = res + (ele, )
return res
def unique_day(day, possible_birthdays):
store = ()
for birthday in possible_birthdays:
if birthday[1] == day:
store += (birthday[1],)
n = len(store)
if n >1:
return False
return True
def unique_month(month, possible_birthdays):
store= ()
for birthday in possible_birthdays:
if birthday[0] == month:
store += (birthday[0],)
n = len(store)
if n >1:
return False
return True
def contains_unique_day(month, possible_birthdays):
month1 = filter(lambda x: x[0] == month, possible_birthdays)
for birthday in month1:
x = unique_day(birthday[1], possible_birthdays)
if x == True:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_062.py
|
refactory_data_question_2_wrong_2_325
|
def unique_day(date, possible_birthdays):
count = 0
for i in range (len(possible_birthdays)):
if date == 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):
return
|
./refactory/data/question_2/code/wrong/wrong_2_325.py
|
refactory_data_question_2_wrong_2_005
|
def unique_day(date, 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/wrong/wrong_2_005.py
|
refactory_data_question_2_wrong_2_070
|
def unique_day(day, possible_birthdays):
unique = False
for i in possible_birthdays:
if day == i[1]:
if unique:
return False
else:
unique = True
return True
def unique_month(month, possible_birthdays):
unique = False
for i in possible_birthdays:
if month == i[0]:
if unique:
return False
else:
unique = True
return True
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/wrong/wrong_2_070.py
|
refactory_data_question_2_wrong_2_401
|
def unique_day(date, possible_birthdays):
i=0
count=0
while i <= len(possible_birthdays):
if possible_birthdays[i][1]==date:
count+=1
i+=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):
if month=='June':
return True
elif month=='May':
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_401.py
|
refactory_data_question_2_wrong_2_023
|
def unique_day(day, possible_birthdays):
count = 0
for birthdays in possible_birthdays:
if birthdays[1] == day:
count +=1
if count == 2:
return False
return True
def unique_month(month, possible_birthdays):
count = 0
for birthdays in possible_birthdays:
if birthdays[0] == month:
count +=1
if count == 2:
return False
return True
def contains_unique_day(month, possible_birthdays):
count = ()
for birthdays in possible_birthdays:
if birthdays[0] == month:
count += (birthdays,)
for sub_birthday in count:
if unique_day(sub_birthday[1], possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_023.py
|
refactory_data_question_2_wrong_2_227
|
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):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_227.py
|
refactory_data_question_2_wrong_2_026
|
def unique_day(day, possible_birthdays):
checker = []
for bday in possible_birthdays:
if day == bday[1] and day not in checker:
checker.append(day)
elif day == bday[1] and day in checker:
return False
return True
def unique_month(month, possible_birthdays):
checker = []
for bday in possible_birthdays:
if month == bday[0] and month not in checker:
checker.append(month)
elif month == bday[0] and month in checker:
return False
return True
def contains_unique_day(month, possible_birthdays):
for bday in possible_birthdays:
if bday[0] == month:
if unique_day(bday[1], possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_026.py
|
refactory_data_question_2_wrong_2_155
|
def unique_day(day, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[1]==day:
counter=counter+1
if counter<=1:
return true
else:
return False
return True
def unique_month(month, possible_birthdays):
for i in possible_birthdays:
if i[0]==month:
counter=counter+1
if counter<=1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_155.py
|
refactory_data_question_2_wrong_2_257
|
def unique_day(date, possible_birthdays):
if date in possible_birthdays[1]:
return False
else:
return True
def unique_month(month, possible_birthdays):
if month in possible_birthdays[0]:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
if x and y:
return False
else:
return True
|
./refactory/data/question_2/code/wrong/wrong_2_257.py
|
refactory_data_question_2_wrong_2_030
|
def unique_day(date, possible_birthdays):
tpl = ()
for i in possible_birthdays:
tpl += (i[1],)
if tpl.count(date) > 1:
return False
return True
def unique_month(month, possible_birthdays):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_030.py
|
refactory_data_question_2_wrong_2_075
|
def unique_day(date, possible_birthdays):
no_of_days = 0
for i in possible_birthdays:
if i[1] == date:
no_of_days += 1
if no_of_days != 1:
return False
return True
def unique_month(month, possible_birthdays):
no_of_months = 0
for i in possible_birthdays:
if i[0] == month:
no_of_months += 1
if no_of_months != 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
birthdays_with_month = ()
for i in possible_birthdays:
if i[0] == month:
birthdays_with_month += (i[1],)
counter = 0
for i in birthdays_with_month:
if unique_day(i, possible_birthdays) == True:
counter += 1
if counter == 1:
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_075.py
|
refactory_data_question_2_wrong_2_017
|
def unique_day(day, possible_birthdays):
count_day = 0
for birthday in possible_birthdays:
if day == birthday[1]:
if count_day == 0: count_day += 1
else: return False
return True
def unique_month(month, possible_birthdays):
count_month = 0
for birthday in possible_birthdays:
if month == birthday[0]:
if count_month == 0: count_month += 1
else: return False
return True
def contains_unique_day(month, possible_birthdays):
for birthday in possible_birthdays:
if month == birthday[0]:
day = birthday[1]
if unique_day(day, possible_birthdays): return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_017.py
|
refactory_data_question_2_wrong_2_169
|
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 possible_birthdays:
if i[0] == month:
days_in_month += (i[1],)
return days_in_month
def contains_unique_day(month, possible_birthdays):
for x in len(days(month, possible_birthdays)):
if unique_day(days(month, possible_birthdays)[x], possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_169.py
|
refactory_data_question_2_wrong_2_382
|
def statement1(birthday, possible_birthdays):
A = unique_month(birthday[0],possible_birthdays)
B = contains_unique_day(birthday[0], possible_birthdays)
if A == False and B == False:
return True
return False
def statement2(birthday, possible_birthdays):
C = unique_day(birthday[1],possible_birthdays)
if C == True:
return True
return False
def statement3(birthday, possible_birthdays):
D = unique_month(birthday[0],possible_birthdays)
if D == True:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_382.py
|
refactory_data_question_2_wrong_2_137
|
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 contains_unique_day(month, possible_birthdays):
for i in possible_birthdays:
if i[0] == month:
if unique_day(i[1], possible_birthdays):
return True
continue
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_137.py
|
refactory_data_question_2_wrong_2_204
|
def unique_day(day, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[1]==day:
counter=counter+1
if counter<=1:
return true
else:
return False
return True
def unique_month(month, possible_birthdays):
counter=0
for i in possible_birthdays:
if i[0]==month:
counter=counter+1
if counter<=1:
return True
else:
return False
def contains_unique_day(month, possible_birthdays):
temp=()
for i in possible_birthdays:
if i[0]==month:
temp=temp+(i,)
for i in temp:
if unique_day(i[1],possible_birthdays):
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_204.py
|
refactory_data_question_2_wrong_2_280
|
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):
focus = ()
unique_days = ()
for i in possible_birthdays:
if month == i[0]:
focus += (i,)
for j in focus:
testday = j[1]
if unique_day(testday, possible_birthdays) == True:
unique_days += (testday,)
for k in unique_days:
for l in focus:
if k == l[1]:
break
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_280.py
|
refactory_data_question_2_wrong_2_417
|
def unique_day(day, possible_birthdays):
n=0
for i in range (len(possible_birthdays)):
if day == possible_birthdays[i][1]:
n+=1
else:
n=n
return n == 1
def unique_month(month, possible_birthdays):
n=0
for i in range (len(possible_birthdays)):
if month == possible_birthdays[i][0]:
n+=1
else:
n=n
return n == 1
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_417.py
|
refactory_data_question_2_wrong_2_246
|
def unique_day(day, possible_birthdays):
x = 1
for i in possible_birthdays:
if day == i[1]:
x = x + 1
else:
x = x
if x > 2:
return False
else:
return True
def unique_month(month, possible_birthdays):
x = 1
for i in possible_birthdays:
if month == i[0]:
x = x + 1
else:
x = x
if x > 2:
return False
else:
return True
def contains_unique_day(month, possible_birthdays):
x = ()
for i in possible_birthdays:
if i[0] == month:
x = x + (i, )
for a in x:
if unique_day(a[1], possible_birthdays):
return True
else:
return False
|
./refactory/data/question_2/code/wrong/wrong_2_246.py
|
refactory_data_question_2_wrong_2_029
|
def unique_day(date, possible_birthdays):
tpl = ()
for i in possible_birthdays:
tpl += (i[1],)
if tpl.count(date) > 1:
return False
return True
def unique_month(month, possible_birthdays):
tpl = ()
for j in possible_birthdays:
tpl += (j[0],)
if tpl.count(month) > 1:
return False
return True
def contains_unique_day(month, possible_birthdays):
tpl = ()
for k in possible_birthdays:
if k[0] == month:
tpl += (k[1],)
for l in tpl:
if unique_day(l, possible_birthdays) == True:
return True
return False
|
./refactory/data/question_2/code/wrong/wrong_2_029.py
|
refactory_data_question_2_wrong_2_420
|
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/wrong/wrong_2_420.py
|
refactory_data_question_2_wrong_2_370
|
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):
return
def contains_unique_day(month, possible_birthdays):
return
|
./refactory/data/question_2/code/wrong/wrong_2_370.py
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.