prompt
stringlengths 108
530
| output
stringclasses 3
values | code
stringlengths 47
388
|
|---|---|---|
def first_repeated_char(str1): #1
for index,c in enumerate(str1): #2
if str1[:index+1].count(c) > 1: #3
return c #4
<data_flow_edges>
index--2 and index--3 are related by | last read | def first_repeated_char(str1):
for index,c in enumerate(str1):
if str1[:index+1].count(c) > 1:
return c |
def get_ludic(n): #1
ludics = [] #2
for i in range(1, n + 1): #3
ludics.append(i) #4
index = 1 #5
while(index != len(ludics)): #6
first_ludic = ludics[index] #7
remove_index = index + first_ludic #8
while(remove_index < len(ludics)): #9
ludics.remove(ludics[remove_index]) #10
remove_index = remove_index + first_ludic - 1 #11
index += 1 #12
return ludics #13
<data_flow_edges>
first_ludic--7 and ludics--7 are related by | computed from | def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics |
def reverse_words(s): #1
return ' '.join(reversed(s.split())) #2
<data_flow_edges>
s--2 and s--1 are related by | last wrote | def reverse_words(s):
return ' '.join(reversed(s.split())) |
def prime_num(num): #1
if num >=1: #2
for i in range(2, num//2): #3
if (num % i) == 0: #4
return False #5
else: #6
return True #7
else: #8
return False #9
<data_flow_edges>
num--3 and num--1 are related by | last wrote | def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False |
import math #1
def radian_degree(degree): #2
radian = degree*(math.pi/180) #3
return radian #4
<data_flow_edges>
degree--3 and degree--2 are related by | last wrote | import math
def radian_degree(degree):
radian = degree*(math.pi/180)
return radian |
import re #1
#2
def find_literals(text, pattern): #3
match = re.search(pattern, text) #4
s = match.start() #5
e = match.end() #6
return (match.re.pattern, s, e) #7
<data_flow_edges>
match--6 and match--5 are related by | last read | import re
def find_literals(text, pattern):
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e) |
def remove_kth_element(list1, L): #1
return list1[:L-1] + list1[L:] #2
<data_flow_edges>
L--2 and L--2 are related by | last read | def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:] |
def max_of_nth(test_list, N): #1
res = max([sub[N] for sub in test_list]) #2
return (res) #3
<data_flow_edges>
sub--2 and sub--2 are related by | last read | def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res) |
def merge(lst): #1
return [list(ele) for ele in list(zip(*lst))] #2
<data_flow_edges>
ele--2 and ele--2 are related by | last read | def merge(lst):
return [list(ele) for ele in list(zip(*lst))] |
def cummulative_sum(test_list): #1
res = sum(map(sum, test_list)) #2
return (res) #3
<data_flow_edges>
res--2 and test_list--2 are related by | computed from | def cummulative_sum(test_list):
res = sum(map(sum, test_list))
return (res) |
def average_tuple(nums): #1
result = [sum(x) / len(x) for x in zip(*nums)] #2
return result #3
<data_flow_edges>
result--2 and nums--2 are related by | computed from | def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result |
def tuple_modulo(test_tup1, test_tup2): #1
res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2)) #2
return (res) #3
<data_flow_edges>
res--2 and ele2--2 are related by | computed from | def tuple_modulo(test_tup1, test_tup2):
res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res) |
def div_list(nums1,nums2): #1
result = map(lambda x, y: x / y, nums1, nums2) #2
return list(result) #3
<data_flow_edges>
x--2 and x--2 are related by | last wrote | def div_list(nums1,nums2):
result = map(lambda x, y: x / y, nums1, nums2)
return list(result) |
def move_num(test_str): #1
res = '' #2
dig = '' #3
for ele in test_str: #4
if ele.isdigit(): #5
dig += ele #6
else: #7
res += ele #8
res += dig #9
return (res) #10
<data_flow_edges>
ele--4 and ele--6 are related by | last read | def move_num(test_str):
res = ''
dig = ''
for ele in test_str:
if ele.isdigit():
dig += ele
else:
res += ele
res += dig
return (res) |
def get_median(arr1, arr2, n): #1
i = 0 #2
j = 0 #3
m1 = -1 #4
m2 = -1 #5
count = 0 #6
while count < n + 1: #7
count += 1 #8
if i == n: #9
m1 = m2 #10
m2 = arr2[0] #11
break #12
elif j == n: #13
m1 = m2 #14
m2 = arr1[0] #15
break #16
if arr1[i] <= arr2[j]: #17
m1 = m2 #18
m2 = arr1[i] #19
i += 1 #20
else: #21
m1 = m2 #22
m2 = arr2[j] #23
j += 1 #24
return (m1 + m2)/2 #25
<data_flow_edges>
m2--25 and m2--10 are related by | last read | def get_median(arr1, arr2, n):
i = 0
j = 0
m1 = -1
m2 = -1
count = 0
while count < n + 1:
count += 1
if i == n:
m1 = m2
m2 = arr2[0]
break
elif j == n:
m1 = m2
m2 = arr1[0]
break
if arr1[i] <= arr2[j]:
m1 = m2
m2 = arr1[i]
i += 1
else:
m1 = m2
m2 = arr2[j]
j += 1
return (m1 + m2)/2 |
def nth_nums(nums,n): #1
nth_nums = list(map(lambda x: x ** n, nums)) #2
return nth_nums #3
<data_flow_edges>
nth_nums--2 and x--2 are related by | computed from | def nth_nums(nums,n):
nth_nums = list(map(lambda x: x ** n, nums))
return nth_nums |
def is_upper(string): #1
return (string.upper()) #2
<data_flow_edges>
string--2 and string--1 are related by | last wrote | def is_upper(string):
return (string.upper()) |
def triangle_area(r) : #1
if r < 0 : #2
return None #3
return r * r #4
<data_flow_edges>
r--2 and r--1 are related by | last wrote | def triangle_area(r) :
if r < 0 :
return None
return r * r |
def replace_spaces(string): #1
return string.replace(" ", "%20") #2
<data_flow_edges>
string--2 and string--1 are related by | last wrote | def replace_spaces(string):
return string.replace(" ", "%20") |
def Split(list): #1
return [num for num in list if num % 2 == 0] #2
<data_flow_edges>
num--2 and num--2 are related by | last read | def Split(list):
return [num for num in list if num % 2 == 0] |
def adjac(ele, sub = []): #1
if not ele: #2
yield sub #3
else: #4
yield from [idx for j in range(ele[0] - 1, ele[0] + 2) #5
for idx in adjac(ele[1:], sub + [j])] #6
def get_coordinates(test_tup): #7
return list(adjac(test_tup)) #8
<data_flow_edges>
sub--6 and sub--1 are related by | last wrote | def adjac(ele, sub = []):
if not ele:
yield sub
else:
yield from [idx for j in range(ele[0] - 1, ele[0] + 2)
for idx in adjac(ele[1:], sub + [j])]
def get_coordinates(test_tup):
return list(adjac(test_tup)) |
def replace_spaces(text): #1
return "".join(" " if c == "_" else ("_" if c == " " else c) for c in text) #2
<data_flow_edges>
c--2 and c--2 are related by | last read | def replace_spaces(text):
return "".join(" " if c == "_" else ("_" if c == " " else c) for c in text) |
def move_zero(num_list): #1
a = [0 for i in range(num_list.count(0))] #2
x = [i for i in num_list if i != 0] #3
return x + a #4
<data_flow_edges>
num_list--2 and num_list--1 are related by | last wrote | def move_zero(num_list):
a = [0 for i in range(num_list.count(0))]
x = [i for i in num_list if i != 0]
return x + a |
def pair_xor_Sum(arr,n) : #1
ans = 0 #2
for i in range(0,n) : #3
for j in range(i + 1,n) : #4
ans = ans + (arr[i] ^ arr[j]) #5
return ans #6
<data_flow_edges>
ans--5 and arr--5 are related by | computed from | def pair_xor_Sum(arr,n) :
ans = 0
for i in range(0,n) :
for j in range(i + 1,n) :
ans = ans + (arr[i] ^ arr[j])
return ans |
import heapq as hq #1
def heap_sort(iterable): #2
h = [] #3
for value in iterable: #4
hq.heappush(h, value) #5
return [hq.heappop(h) for i in range(len(h))] #6
<data_flow_edges>
h--6 and h--3 are related by | last wrote | import heapq as hq
def heap_sort(iterable):
h = []
for value in iterable:
hq.heappush(h, value)
return [hq.heappop(h) for i in range(len(h))] |
def noprofit_noloss(actual_cost,sale_amount): #1
if(sale_amount == actual_cost): #2
return True #3
else: #4
return False #5
<data_flow_edges>
actual_cost--2 and actual_cost--1 are related by | last wrote | def noprofit_noloss(actual_cost,sale_amount):
if(sale_amount == actual_cost):
return True
else:
return False |
import math #1
def wind_chill(v,t): #2
windchill = 13.12 + 0.6215*t - 11.37*math.pow(v, 0.16) + 0.3965*t*math.pow(v, 0.16) #3
return int(round(windchill, 0)) #4
<data_flow_edges>
windchill--3 and v--3 are related by | computed from | import math
def wind_chill(v,t):
windchill = 13.12 + 0.6215*t - 11.37*math.pow(v, 0.16) + 0.3965*t*math.pow(v, 0.16)
return int(round(windchill, 0)) |
import re #1
def remove_parenthesis(items): #2
for item in items: #3
return (re.sub(r" ?\([^)]+\)", "", item)) #4
<data_flow_edges>
item--4 and item--3 are related by | last wrote | import re
def remove_parenthesis(items):
for item in items:
return (re.sub(r" ?\([^)]+\)", "", item)) |
def is_nonagonal(n): #1
return int(n * (7 * n - 5) / 2) #2
<data_flow_edges>
n--2 and n--2 are related by | last read | def is_nonagonal(n):
return int(n * (7 * n - 5) / 2) |
import re #1
def text_match_wordz_middle(text): #2
return bool(re.search(r'\Bz\B', text)) #3
<data_flow_edges>
text--3 and text--2 are related by | last wrote | import re
def text_match_wordz_middle(text):
return bool(re.search(r'\Bz\B', text)) |
def reverse_Array_Upto_K(input, k): #1
return (input[k-1::-1] + input[k:]) #2
<data_flow_edges>
k--2 and k--1 are related by | last wrote | def reverse_Array_Upto_K(input, k):
return (input[k-1::-1] + input[k:]) |
def add_dict_to_tuple(test_tup, test_dict): #1
test_tup = list(test_tup) #2
test_tup.append(test_dict) #3
test_tup = tuple(test_tup) #4
return (test_tup) #5
<data_flow_edges>
test_tup--4 and test_tup--4 are related by | last read | def add_dict_to_tuple(test_tup, test_dict):
test_tup = list(test_tup)
test_tup.append(test_dict)
test_tup = tuple(test_tup)
return (test_tup) |
from operator import eq #1
def count_same_pair(nums1, nums2): #2
result = sum(map(eq, nums1, nums2)) #3
return result #4
<data_flow_edges>
result--3 and nums2--3 are related by | computed from | from operator import eq
def count_same_pair(nums1, nums2):
result = sum(map(eq, nums1, nums2))
return result |
def power_base_sum(base, power): #1
return sum([int(i) for i in str(pow(base, power))]) #2
<data_flow_edges>
i--2 and i--2 are related by | last read | def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) |
import re #1
def extract_quotation(text1): #2
return (re.findall(r'"(.*?)"', text1)) #3
<data_flow_edges>
text1--3 and text1--2 are related by | last wrote | import re
def extract_quotation(text1):
return (re.findall(r'"(.*?)"', text1)) |
def multiply_elements(test_tup): #1
res = tuple(i * j for i, j in zip(test_tup, test_tup[1:])) #2
return (res) #3
<data_flow_edges>
res--2 and test_tup--2 are related by | computed from | def multiply_elements(test_tup):
res = tuple(i * j for i, j in zip(test_tup, test_tup[1:]))
return (res) |
def sum_list(lst1,lst2): #1
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))] #2
return res_list #3
<data_flow_edges>
res_list--2 and lst2--2 are related by | computed from | def sum_list(lst1,lst2):
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
return res_list |
from itertools import groupby #1
def consecutive_duplicates(nums): #2
return [key for key, group in groupby(nums)] #3
<data_flow_edges>
key--3 and key--3 are related by | last read | from itertools import groupby
def consecutive_duplicates(nums):
return [key for key, group in groupby(nums)] |
import math #1
def lateralsurface_cone(r,h): #2
l = math.sqrt(r * r + h * h) #3
LSA = math.pi * r * l #4
return LSA #5
<data_flow_edges>
h--3 and h--3 are related by | last read | import math
def lateralsurface_cone(r,h):
l = math.sqrt(r * r + h * h)
LSA = math.pi * r * l
return LSA |
import re #1
def replace_specialchar(text): #2
return (re.sub("[ ,.]", ":", text)) #3
#4
<data_flow_edges>
text--3 and text--2 are related by | last wrote | import re
def replace_specialchar(text):
return (re.sub("[ ,.]", ":", text))
|
def sum_Of_Subarray_Prod(arr): #1
ans = 0 #2
res = 0 #3
i = len(arr) - 1 #4
while (i >= 0): #5
incr = arr[i]*(1 + res) #6
ans += incr #7
res = incr #8
i -= 1 #9
return (ans) #10
<data_flow_edges>
i--9 and i--4 are related by | last wrote | def sum_Of_Subarray_Prod(arr):
ans = 0
res = 0
i = len(arr) - 1
while (i >= 0):
incr = arr[i]*(1 + res)
ans += incr
res = incr
i -= 1
return (ans) |
import bisect #1
def left_insertion(a, x): #2
i = bisect.bisect_left(a, x) #3
return i #4
<data_flow_edges>
i--4 and i--3 are related by | last wrote | import bisect
def left_insertion(a, x):
i = bisect.bisect_left(a, x)
return i |
import re #1
regex = '^[aeiouAEIOU][A-Za-z0-9_]*' #2
def check_str(string): #3
return re.search(regex, string) #4
<data_flow_edges>
string--4 and string--3 are related by | last wrote | import re
regex = '^[aeiouAEIOU][A-Za-z0-9_]*'
def check_str(string):
return re.search(regex, string) |
import math #1
def find_Index(n): #2
x = math.sqrt(2 * math.pow(10,(n - 1))) #3
return round(x) #4
<data_flow_edges>
x--3 and math--3 are related by | computed from | import math
def find_Index(n):
x = math.sqrt(2 * math.pow(10,(n - 1)))
return round(x) |
def tuple_to_dict(test_tup): #1
res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2)) #2
return (res) #3
<data_flow_edges>
res--3 and res--2 are related by | last wrote | def tuple_to_dict(test_tup):
res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2))
return (res) |
def all_Characters_Same(s) : #1
n = len(s) #2
for i in range(1,n) : #3
if s[i] != s[0] : #4
return False #5
return True #6
<data_flow_edges>
i--4 and i--3 are related by | last wrote | def all_Characters_Same(s) :
n = len(s)
for i in range(1,n) :
if s[i] != s[0] :
return False
return True |
import math #1
def area_tetrahedron(side): #2
area = math.sqrt(3)*(side*side) #3
return area #4
<data_flow_edges>
area--3 and side--3 are related by | computed from | import math
def area_tetrahedron(side):
area = math.sqrt(3)*(side*side)
return area |
def rotate_right(list, m): #1
result = list[-m:] + list[:-m] #2
return result #3
<data_flow_edges>
m--2 and m--1 are related by | last wrote | def rotate_right(list, m):
result = list[-m:] + list[:-m]
return result |
def check_none(test_tup): #1
res = any(map(lambda ele: ele is None, test_tup)) #2
return res #3
<data_flow_edges>
res--3 and res--2 are related by | last wrote | def check_none(test_tup):
res = any(map(lambda ele: ele is None, test_tup))
return res |
import math #1
def sector_area(r,a): #2
if a > 360: #3
return None #4
return (math.pi*r**2) * (a/360) #5
<data_flow_edges>
a--5 and a--3 are related by | last read | import math
def sector_area(r,a):
if a > 360:
return None
return (math.pi*r**2) * (a/360) |
import re #1
def capital_words_spaces(str1): #2
return re.sub(r"(\w)([A-Z])", r"\1 \2", str1) #3
<data_flow_edges>
str1--3 and str1--2 are related by | last wrote | import re
def capital_words_spaces(str1):
return re.sub(r"(\w)([A-Z])", r"\1 \2", str1) |
def sort_numeric_strings(nums_str): #1
result = [int(x) for x in nums_str] #2
result.sort() #3
return result #4
<data_flow_edges>
result--2 and nums_str--2 are related by | computed from | def sort_numeric_strings(nums_str):
result = [int(x) for x in nums_str]
result.sort()
return result |
def add_tuple(test_list, test_tup): #1
test_list += test_tup #2
return test_list #3
<data_flow_edges>
test_list--2 and test_list--1 are related by | last wrote | def add_tuple(test_list, test_tup):
test_list += test_tup
return test_list |
def min_k(test_list, K): #1
res = sorted(test_list, key = lambda x: x[1])[:K] #2
return (res) #3
<data_flow_edges>
test_list--2 and test_list--1 are related by | last wrote | def min_k(test_list, K):
res = sorted(test_list, key = lambda x: x[1])[:K]
return (res) |
def extract_index_list(l1, l2, l3): #1
result = [] #2
for m, n, o in zip(l1, l2, l3): #3
if (m == n == o): #4
result.append(m) #5
return result #6
<data_flow_edges>
m--4 and m--5 are related by | last read | def extract_index_list(l1, l2, l3):
result = []
for m, n, o in zip(l1, l2, l3):
if (m == n == o):
result.append(m)
return result |
def second_smallest(numbers): #1
unique_numbers = list(set(numbers)) #2
unique_numbers.sort() #3
if len(unique_numbers) < 2: #4
return None #5
else: #6
return unique_numbers[1] #7
<data_flow_edges>
numbers--2 and numbers--1 are related by | last wrote | def second_smallest(numbers):
unique_numbers = list(set(numbers))
unique_numbers.sort()
if len(unique_numbers) < 2:
return None
else:
return unique_numbers[1] |
import re #1
def text_match_zero_one(text): #2
patterns = 'ab+?' #3
if re.search(patterns, text): #4
return True #5
else: #6
return False #7
<data_flow_edges>
text--4 and text--2 are related by | last wrote | import re
def text_match_zero_one(text):
patterns = 'ab+?'
if re.search(patterns, text):
return True
else:
return False |
def count_reverse_pairs(test_list): #1
res = sum([1 for idx in range(0, len(test_list)) for idxn in range(idx, len( #2
test_list)) if test_list[idxn] == str(''.join(list(reversed(test_list[idx]))))]) #3
return res #4
<data_flow_edges>
test_list--3 and test_list--3 are related by | last read | def count_reverse_pairs(test_list):
res = sum([1 for idx in range(0, len(test_list)) for idxn in range(idx, len(
test_list)) if test_list[idxn] == str(''.join(list(reversed(test_list[idx]))))])
return res |
def is_decimal(num): #1
import re #2
dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""") #3
result = dnumre.search(num) #4
return bool(result) #5
<data_flow_edges>
num--4 and num--1 are related by | last wrote | def is_decimal(num):
import re
dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = dnumre.search(num)
return bool(result) |
def unique_Element(arr): #1
s = set(arr) #2
return len(s) == 1 #3
<data_flow_edges>
arr--2 and arr--1 are related by | last wrote | def unique_Element(arr):
s = set(arr)
return len(s) == 1 |
def find_min_diff(arr,n): #1
arr = sorted(arr) #2
diff = 10**20 #3
for i in range(n-1): #4
if arr[i+1] - arr[i] < diff: #5
diff = arr[i+1] - arr[i] #6
return diff #7
<data_flow_edges>
diff--6 and diff--5 are related by | last read | def find_min_diff(arr,n):
arr = sorted(arr)
diff = 10**20
for i in range(n-1):
if arr[i+1] - arr[i] < diff:
diff = arr[i+1] - arr[i]
return diff |
import math #1
def is_polite(n): #2
n = n + 1 #3
return (int)(n+(math.log((n + math.log(n, 2)), 2))) #4
<data_flow_edges>
n--3 and n--2 are related by | last wrote | import math
def is_polite(n):
n = n + 1
return (int)(n+(math.log((n + math.log(n, 2)), 2))) |
def get_pairs_count(arr, sum): #1
count = 0 #2
for i in range(len(arr)): #3
for j in range(i + 1,len(arr)): #4
if arr[i] + arr[j] == sum: #5
count += 1 #6
return count #7
<data_flow_edges>
arr--4 and arr--3 are related by | last read | def get_pairs_count(arr, sum):
count = 0
for i in range(len(arr)):
for j in range(i + 1,len(arr)):
if arr[i] + arr[j] == sum:
count += 1
return count |
def Diff(li1,li2): #1
return list(set(li1)-set(li2)) + list(set(li2)-set(li1)) #2
#3
<data_flow_edges>
li1--2 and li1--1 are related by | last wrote | def Diff(li1,li2):
return list(set(li1)-set(li2)) + list(set(li2)-set(li1))
|
def odd_num_sum(n) : #1
j = 0 #2
sm = 0 #3
for i in range(1,n + 1) : #4
j = (2*i-1) #5
sm = sm + (j*j*j*j) #6
return sm #7
<data_flow_edges>
i--5 and i--4 are related by | last wrote | def odd_num_sum(n) :
j = 0
sm = 0
for i in range(1,n + 1) :
j = (2*i-1)
sm = sm + (j*j*j*j)
return sm |
def remove_length(test_str, K): #1
temp = test_str.split() #2
res = [ele for ele in temp if len(ele) != K] #3
res = ' '.join(res) #4
return (res) #5
<data_flow_edges>
res--4 and res--3 are related by | last wrote | def remove_length(test_str, K):
temp = test_str.split()
res = [ele for ele in temp if len(ele) != K]
res = ' '.join(res)
return (res) |
import re #1
def occurance_substring(text,pattern): #2
for match in re.finditer(pattern, text): #3
s = match.start() #4
e = match.end() #5
return (text[s:e], s, e) #6
<data_flow_edges>
s--6 and s--4 are related by | last wrote | import re
def occurance_substring(text,pattern):
for match in re.finditer(pattern, text):
s = match.start()
e = match.end()
return (text[s:e], s, e) |
def odd_position(nums): #1
return all(nums[i]%2==i%2 for i in range(len(nums))) #2
<data_flow_edges>
nums--2 and nums--1 are related by | last wrote | def odd_position(nums):
return all(nums[i]%2==i%2 for i in range(len(nums))) |
def find_sum(arr): #1
arr.sort() #2
sum = arr[0] #3
for i in range(len(arr)-1): #4
if (arr[i] != arr[i+1]): #5
sum = sum + arr[i+1] #6
return sum #7
<data_flow_edges>
arr--4 and arr--3 are related by | last read | def find_sum(arr):
arr.sort()
sum = arr[0]
for i in range(len(arr)-1):
if (arr[i] != arr[i+1]):
sum = sum + arr[i+1]
return sum |
from itertools import groupby #1
def pack_consecutive_duplicates(list1): #2
return [list(group) for key, group in groupby(list1)] #3
<data_flow_edges>
list1--3 and list1--2 are related by | last wrote | from itertools import groupby
def pack_consecutive_duplicates(list1):
return [list(group) for key, group in groupby(list1)] |
from itertools import combinations #1
def find_combinations(test_list): #2
res = [(b1 + a1, b2 + a2) for (a1, a2), (b1, b2) in combinations(test_list, 2)] #3
return (res) #4
<data_flow_edges>
res--3 and a2--3 are related by | computed from | from itertools import combinations
def find_combinations(test_list):
res = [(b1 + a1, b2 + a2) for (a1, a2), (b1, b2) in combinations(test_list, 2)]
return (res) |
import math #1
def count_divisors(n) : #2
count = 0 #3
for i in range(1, (int)(math.sqrt(n)) + 2) : #4
if (n % i == 0) : #5
if( n // i == i) : #6
count = count + 1 #7
else : #8
count = count + 2 #9
return count % 2 == 0 #10
<data_flow_edges>
count--7 and count--7 are related by | last read | import math
def count_divisors(n) :
count = 0
for i in range(1, (int)(math.sqrt(n)) + 2) :
if (n % i == 0) :
if( n // i == i) :
count = count + 1
else :
count = count + 2
return count % 2 == 0 |
def odd_length_sum(arr): #1
Sum = 0 #2
l = len(arr) #3
for i in range(l): #4
Sum += ((((i + 1) *(l - i) + 1) // 2) * arr[i]) #5
return Sum #6
<data_flow_edges>
arr--5 and arr--1 are related by | last wrote | def odd_length_sum(arr):
Sum = 0
l = len(arr)
for i in range(l):
Sum += ((((i + 1) *(l - i) + 1) // 2) * arr[i])
return Sum |
def mul_even_odd(list1): #1
first_even = next((el for el in list1 if el%2==0),-1) #2
first_odd = next((el for el in list1 if el%2!=0),-1) #3
return (first_even*first_odd) #4
<data_flow_edges>
first_odd--3 and el--3 are related by | computed from | def mul_even_odd(list1):
first_even = next((el for el in list1 if el%2==0),-1)
first_odd = next((el for el in list1 if el%2!=0),-1)
return (first_even*first_odd) |
def tuple_str_int(test_str): #1
res = tuple(int(num) for num in test_str.replace('(', '').replace(')', '').replace('...', '').split(', ')) #2
return (res) #3
<data_flow_edges>
res--2 and num--2 are related by | computed from | def tuple_str_int(test_str):
res = tuple(int(num) for num in test_str.replace('(', '').replace(')', '').replace('...', '').split(', '))
return (res) |
import bisect #1
def right_insertion(a, x): #2
return bisect.bisect_right(a, x) #3
<data_flow_edges>
a--3 and a--2 are related by | last wrote | import bisect
def right_insertion(a, x):
return bisect.bisect_right(a, x) |
import re #1
def text_match_three(text): #2
patterns = 'ab{3}?' #3
return re.search(patterns, text) #4
<data_flow_edges>
patterns--4 and patterns--3 are related by | last wrote | import re
def text_match_three(text):
patterns = 'ab{3}?'
return re.search(patterns, text) |
def new_tuple(test_list, test_str): #1
return tuple(test_list + [test_str]) #2
<data_flow_edges>
test_str--2 and test_str--1 are related by | last wrote | def new_tuple(test_list, test_str):
return tuple(test_list + [test_str]) |
def even_position(nums): #1
return all(nums[i]%2==i%2 for i in range(len(nums))) #2
<data_flow_edges>
i--2 and i--2 are related by | last read | def even_position(nums):
return all(nums[i]%2==i%2 for i in range(len(nums))) |
def remove_nested(test_tup): #1
res = tuple() #2
for count, ele in enumerate(test_tup): #3
if not isinstance(ele, tuple): #4
res = res + (ele, ) #5
return (res) #6
<data_flow_edges>
res--6 and res--5 are related by | last wrote | def remove_nested(test_tup):
res = tuple()
for count, ele in enumerate(test_tup):
if not isinstance(ele, tuple):
res = res + (ele, )
return (res) |
def count_list(input_list): #1
return len(input_list) #2
<data_flow_edges>
input_list--2 and input_list--1 are related by | last wrote | def count_list(input_list):
return len(input_list) |
def last(arr,x): #1
n = len(arr) #2
low = 0 #3
high = n - 1 #4
res = -1 #5
while (low <= high): #6
mid = (low + high) // 2 #7
if arr[mid] > x: #8
high = mid - 1 #9
elif arr[mid] < x: #10
low = mid + 1 #11
else: #12
res = mid #13
low = mid + 1 #14
return res #15
<data_flow_edges>
mid--9 and mid--7 are related by | last wrote | def last(arr,x):
n = len(arr)
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res |
import re #1
def text_starta_endb(text): #2
patterns = 'a.*?b$' #3
return re.search(patterns, text) #4
<data_flow_edges>
patterns--4 and patterns--3 are related by | last wrote | import re
def text_starta_endb(text):
patterns = 'a.*?b$'
return re.search(patterns, text) |
def return_sum(dict): #1
sum = 0 #2
for i in dict.values(): #3
sum = sum + i #4
return sum #5
<data_flow_edges>
i--4 and i--3 are related by | last wrote | def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum |
def _sum(arr): #1
sum=0 #2
for i in arr: #3
sum = sum + i #4
return(sum) #5
<data_flow_edges>
i--3 and i--4 are related by | last read | def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum) |
def left_rotate(n,d): #1
INT_BITS = 32 #2
return (n << d)|(n >> (INT_BITS - d)) #3
<data_flow_edges>
d--3 and d--1 are related by | last wrote | def left_rotate(n,d):
INT_BITS = 32
return (n << d)|(n >> (INT_BITS - d)) |
import re #1
def remove_all_spaces(text): #2
return (re.sub(r'\s+', '',text)) #3
<data_flow_edges>
text--3 and text--2 are related by | last wrote | import re
def remove_all_spaces(text):
return (re.sub(r'\s+', '',text)) |
def test_three_equal(x,y,z): #1
result = set([x,y,z]) #2
if len(result)==3: #3
return 0 #4
else: #5
return 4-len(result) #6
<data_flow_edges>
z--2 and z--1 are related by | last wrote | def test_three_equal(x,y,z):
result = set([x,y,z])
if len(result)==3:
return 0
else:
return 4-len(result) |
def count_rotation(arr): #1
for i in range (1,len(arr)): #2
if (arr[i] < arr[i - 1]): #3
return i #4
return 0 #5
<data_flow_edges>
i--4 and i--2 are related by | last wrote | def count_rotation(arr):
for i in range (1,len(arr)):
if (arr[i] < arr[i - 1]):
return i
return 0 |
def is_product_even(arr): #1
for i in range(len(arr)): #2
if (arr[i] & 1) == 0: #3
return True #4
return False #5
<data_flow_edges>
arr--3 and arr--1 are related by | last wrote | def is_product_even(arr):
for i in range(len(arr)):
if (arr[i] & 1) == 0:
return True
return False |
def max_sum_list(lists): #1
return max(lists, key=sum) #2
<data_flow_edges>
lists--2 and lists--1 are related by | last wrote | def max_sum_list(lists):
return max(lists, key=sum) |
def max_run_uppercase(test_str): #1
cnt = 0 #2
res = 0 #3
for idx in range(0, len(test_str)): #4
if test_str[idx].isupper(): #5
cnt += 1 #6
else: #7
res = cnt #8
cnt = 0 #9
if test_str[len(test_str) - 1].isupper(): #10
res = cnt #11
return (res) #12
<data_flow_edges>
test_str--5 and test_str--4 are related by | last read | def max_run_uppercase(test_str):
cnt = 0
res = 0
for idx in range(0, len(test_str)):
if test_str[idx].isupper():
cnt += 1
else:
res = cnt
cnt = 0
if test_str[len(test_str) - 1].isupper():
res = cnt
return (res) |
def first_odd(nums): #1
first_odd = next((el for el in nums if el%2!=0),-1) #2
return first_odd #3
<data_flow_edges>
first_odd--2 and el--2 are related by | computed from | def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd |
def check_K(test_tup, K): #1
res = False #2
for ele in test_tup: #3
if ele == K: #4
res = True #5
break #6
return res #7
<data_flow_edges>
res--7 and res--5 are related by | last wrote | def check_K(test_tup, K):
res = False
for ele in test_tup:
if ele == K:
res = True
break
return res |
def check_smaller(test_tup1, test_tup2): #1
return all(x > y for x, y in zip(test_tup1, test_tup2)) #2
<data_flow_edges>
test_tup1--2 and test_tup1--1 are related by | last wrote | def check_smaller(test_tup1, test_tup2):
return all(x > y for x, y in zip(test_tup1, test_tup2)) |
- Downloads last month
- 0