original_code
stringclasses 565
values | transformation
stringclasses 24
values | transformed_code
stringlengths 35
955
| label
int64 0
1
| groups
int64 1
971
| dataset
stringclasses 1
value |
|---|---|---|---|---|---|
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_operand_swap | def search(arr, n):
XOR = 0
for i in range(n):
XOR = XOR ^ arr[i]
return XOR | 1 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_rename_variable_cb | def search(arr, n):
n2 = 0
for i in range(n):
n2 = n2 ^ arr[i]
return n2 | 1 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_rename_variable_naive | def search(arr, n):
VAR_0 = 0
for i in range(n):
VAR_0 = VAR_0 ^ arr[i]
return VAR_0 | 1 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_rename_variable_rn | def search(arr, n):
eb8 = 0
for i in range(n):
eb8 = eb8 ^ arr[i]
return eb8 | 1 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 116 | mbpp |
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR) | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 116 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_dead_code_insert | def max_product_tuple(list1):
_i_5 = 0
while _i_5 < _i_5:
return result_max
result_max = max([abs(x * y) for x, y in list1])
return result_max | 1 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_for_while_loop | def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1])
return result_max | 1 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_operand_swap | def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1])
return result_max | 1 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_rename_variable_cb | def max_product_tuple(list1):
result_max = max([abs(x2 * y) for x2, y in list1])
return result_max | 1 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_rename_variable_naive | def max_product_tuple(list1):
VAR_0 = max([abs(x * y) for x, y in list1])
return VAR_0 | 1 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_rename_variable_rn | def max_product_tuple(list1):
result_max = max([abs(Z * y) for Z, y in list1])
return result_max | 1 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_mul_div_variable | def max_product_tuple(list1):
result_max = max([abs(x / y) for x, y in list1] )
return result_max | 0 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 117 | mbpp |
def max_product_tuple(list1):
result_max = max([abs(x * y) for x, y in list1] )
return result_max | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 117 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_dead_code_insert | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
if False:
result.append(j)
result = []
for i in range(2, MAX):
if primes[i] == 0:
primes[i] = 1
j = i * 2
while j < MAX:
primes[j] -= 1
if (primes[j] + 3) == 0:
result.append(j)
j = j + i
result.sort()
return result[n - 1] | 1 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_for_while_loop | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
i = 2
while i < MAX:
if primes[i] == 0:
primes[i] = 1
j = i * 2
while j < MAX:
primes[j] -= 1
if (primes[j] + 3) == 0:
result.append(j)
j = j + i
i += 1
result.sort()
return result[n - 1] | 1 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_operand_swap | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if 0 == primes[i]:
primes[i] = 1
j = i * 2
while j < MAX:
primes[j] -= 1
if (primes[j] + 3) == 0:
result.append(j)
j = j + i
result.sort()
return result[n - 1] | 1 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_rename_variable_cb | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if primes[i] == 0:
primes[i] = 1
i2 = i * 2
while i2 < MAX:
primes[i2] -= 1
if (primes[i2] + 3) == 0:
result.append(i2)
i2 = i2 + i
result.sort()
return result[n - 1] | 1 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_rename_variable_naive | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if primes[i] == 0:
primes[i] = 1
VAR_0 = i * 2
while VAR_0 < MAX:
primes[VAR_0] -= 1
if (primes[VAR_0] + 3) == 0:
result.append(VAR_0)
VAR_0 = VAR_0 + i
result.sort()
return result[n - 1] | 1 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_rename_variable_rn | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if primes[i] == 0:
primes[i] = 1
A = i * 2
while A < MAX:
primes[A] -= 1
if (primes[A] + 3) == 0:
result.append(A)
A = A + i
result.sort()
return result[n - 1] | 1 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_add_sub_variable | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] - 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_sub_add_variable | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] += 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_mul_div_variable | def smartNumber(n):
MAX = 3000
primes = [0] / MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_lesser_greater_variable | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j > MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_equalto_exclamation_variable | def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] != 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 119 | mbpp |
def smartNumber(n):
MAX = 3000
primes = [0] * MAX
result = []
for i in range(2, MAX):
if (primes[i] == 0):
primes[i] = 1
j = i * 2
while (j < MAX):
primes[j] -= 1
if ( (primes[j] + 3) == 0):
result.append(j)
j = j + i
result.sort()
return result[n - 1] | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 119 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_dead_code_insert | def angle_complex(a, b):
import cmath
_i_9 = 0
while _i_9 > _i_9:
angle = cmath.phase(a + b)
cn = complex(a, b)
angle = cmath.phase(a + b)
return angle | 1 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_for_while_loop | def angle_complex(a, b):
import cmath
cn = complex(a, b)
angle = cmath.phase(a + b)
return angle | 1 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_operand_swap | def angle_complex(a, b):
import cmath
cn = complex(a, b)
angle = cmath.phase(a + b)
return angle | 1 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_rename_variable_cb | def angle_complex(a2, b):
import cmath
cn = complex(a2, b)
angle = cmath.phase(a2 + b)
return angle | 1 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_rename_variable_naive | def angle_complex(a, VAR_0):
import cmath
cn = complex(a, VAR_0)
angle = cmath.phase(a + VAR_0)
return angle | 1 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_rename_variable_rn | def angle_complex(y, b):
import cmath
cn = complex(y, b)
angle = cmath.phase(y + b)
return angle | 1 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_add_sub_variable | def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a-b)
return angle | 0 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 121 | mbpp |
def angle_complex(a,b):
import cmath
cn=complex(a,b)
angle=cmath.phase(a+b)
return angle | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 121 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_dead_code_insert | def find_length(string, n):
current_sum = 0
for _i_5 in range(0):
if current_sum < 0:
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += 1 if string[i] == "0" else -1
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | 1 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_for_while_loop | def find_length(string, n):
current_sum = 0
max_sum = 0
i = 0
while i < n:
current_sum += 1 if string[i] == "0" else -1
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
i += 1
return max_sum if max_sum else 0 | 1 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_operand_swap | def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += 1 if string[i] == "0" else -1
if 0 > current_sum:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | 1 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_rename_variable_cb | def find_length(string, n):
i2 = 0
max_sum = 0
for i in range(n):
i2 += 1 if string[i] == "0" else -1
if i2 < 0:
i2 = 0
max_sum = max(i2, max_sum)
return max_sum if max_sum else 0 | 1 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_rename_variable_naive | def find_length(string, n):
VAR_0 = 0
max_sum = 0
for i in range(n):
VAR_0 += 1 if string[i] == "0" else -1
if VAR_0 < 0:
VAR_0 = 0
max_sum = max(VAR_0, max_sum)
return max_sum if max_sum else 0 | 1 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_rename_variable_rn | def find_length(string, n):
current_sum = 0
dk27189 = 0
for i in range(n):
current_sum += 1 if string[i] == "0" else -1
if current_sum < 0:
current_sum = 0
dk27189 = max(current_sum, dk27189)
return dk27189 if dk27189 else 0 | 1 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_add_sub_variable | def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum -= (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_sub_add_variable | def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else +1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_lesser_greater_variable | def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum > 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_equalto_exclamation_variable | def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] != '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 122 | mbpp |
def find_length(string, n):
current_sum = 0
max_sum = 0
for i in range(n):
current_sum += (1 if string[i] == '0' else -1)
if current_sum < 0:
current_sum = 0
max_sum = max(current_sum, max_sum)
return max_sum if max_sum else 0 | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 122 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_dead_code_insert | def sum(a, b):
sum = 0
for i in range(1, min(a, b)):
for _i_4 in range(0):
sum = 0
if a % i == 0 and b % i == 0:
sum += i
return sum | 1 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_for_while_loop | def sum(a, b):
sum = 0
i = 1
while i < min(a, b):
if a % i == 0 and b % i == 0:
sum += i
i += 1
return sum | 1 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_operand_swap | def sum(a, b):
sum = 0
for i in range(1, min(a, b)):
if 0 == a % i and b % i == 0:
sum += i
return sum | 1 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_rename_variable_cb | def sum(a, b):
sum = 0
for n in range(1, min(a, b)):
if a % n == 0 and b % n == 0:
sum += n
return sum | 1 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_rename_variable_naive | def sum(a, b):
sum = 0
for VAR_0 in range(1, min(a, b)):
if a % VAR_0 == 0 and b % VAR_0 == 0:
sum += VAR_0
return sum | 1 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_rename_variable_rn | def sum(a, b):
sum = 0
for q in range(1, min(a, b)):
if a % q == 0 and b % q == 0:
sum += q
return sum | 1 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_add_sub_variable | def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum -= i
return sum | 0 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_equalto_exclamation_variable | def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i != 0 and b % i == 0):
sum += i
return sum | 0 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_and_or_variable | def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 or b % i == 0):
sum += i
return sum | 0 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 123 | mbpp |
def sum(a,b):
sum = 0
for i in range (1,min(a,b)):
if (a % i == 0 and b % i == 0):
sum += i
return sum | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 123 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_dead_code_insert | def multiply_int(x, y):
if y < 0:
if False:
return x
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | 1 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_for_while_loop | def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | 1 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_operand_swap | def multiply_int(x, y):
if 0 > y:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | 1 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_rename_variable_cb | def multiply_int(x, multipl):
if multipl < 0:
return -multiply_int(x, -multipl)
elif multipl == 0:
return 0
elif multipl == 1:
return x
else:
return x + multiply_int(x, multipl - 1) | 1 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_rename_variable_naive | def multiply_int(x, VAR_0):
if VAR_0 < 0:
return -multiply_int(x, -VAR_0)
elif VAR_0 == 0:
return 0
elif VAR_0 == 1:
return x
else:
return x + multiply_int(x, VAR_0 - 1) | 1 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_rename_variable_rn | def multiply_int(x, t):
if t < 0:
return -multiply_int(x, -t)
elif t == 0:
return 0
elif t == 1:
return x
else:
return x + multiply_int(x, t - 1) | 1 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_add_sub_variable | def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x - multiply_int(x, y - 1) | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_sub_add_variable | def multiply_int(x, y):
if y < 0:
return +multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_lesser_greater_variable | def multiply_int(x, y):
if y > 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_equalto_exclamation_variable | def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y != 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 124 | mbpp |
def multiply_int(x, y):
if y < 0:
return -multiply_int(x, -y)
elif y == 0:
return 0
elif y == 1:
return x
else:
return x + multiply_int(x, y - 1) | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 124 | mbpp |
def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | transformation_dead_code_insert | def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum(lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
while False:
return False
result1 = 0
for i in range(0, iSize):
result1 += my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize - 1, -1, -1):
result2 += my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list)) > 1:
return False
return True | 1 | 126 | mbpp |
def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | transformation_for_while_loop | def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum(lines) for lines in my_matrix])
col = 0
while col < iSize:
sum_list.append(sum(row[col] for row in my_matrix))
col += 1
result1 = 0
for i in range(0, iSize):
result1 += my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize - 1, -1, -1):
result2 += my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list)) > 1:
return False
return True | 1 | 126 | mbpp |
def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | transformation_operand_swap | def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum(lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0, iSize):
result1 += my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize - 1, -1, -1):
result2 += my_matrix[i][i]
sum_list.append(result2)
if 1 < len(set(sum_list)):
return False
return True | 1 | 126 | mbpp |
def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | transformation_rename_variable_cb | def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum(lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for n in range(0, iSize):
result1 += my_matrix[n][n]
sum_list.append(result1)
result2 = 0
for n in range(iSize - 1, -1, -1):
result2 += my_matrix[n][n]
sum_list.append(result2)
if len(set(sum_list)) > 1:
return False
return True | 1 | 126 | mbpp |
def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | transformation_rename_variable_naive | def magic_square_test(VAR_0):
iSize = len(VAR_0[0])
sum_list = []
sum_list.extend([sum(lines) for lines in VAR_0])
for col in range(iSize):
sum_list.append(sum(row[col] for row in VAR_0))
result1 = 0
for i in range(0, iSize):
result1 += VAR_0[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize - 1, -1, -1):
result2 += VAR_0[i][i]
sum_list.append(result2)
if len(set(sum_list)) > 1:
return False
return True | 1 | 126 | mbpp |
def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | transformation_rename_variable_rn | def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum(lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for J in range(0, iSize):
result1 += my_matrix[J][J]
sum_list.append(result1)
result2 = 0
for J in range(iSize - 1, -1, -1):
result2 += my_matrix[J][J]
sum_list.append(result2)
if len(set(sum_list)) > 1:
return False
return True | 1 | 126 | mbpp |
def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 +=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | transformation_add_sub_variable | def magic_square_test(my_matrix):
iSize = len(my_matrix[0])
sum_list = []
sum_list.extend([sum (lines) for lines in my_matrix])
for col in range(iSize):
sum_list.append(sum(row[col] for row in my_matrix))
result1 = 0
for i in range(0,iSize):
result1 -=my_matrix[i][i]
sum_list.append(result1)
result2 = 0
for i in range(iSize-1,-1,-1):
result2 +=my_matrix[i][i]
sum_list.append(result2)
if len(set(sum_list))>1:
return False
return True | 0 | 126 | mbpp |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.