Datasets:

Pav17

/

T3-gen-dataset-4

like 0

Write a function to find the equilibrium index of the given array.

def equilibrium_index(arr): total_sum = sum(arr) left_sum=0 for i, num in enumerate(arr): total_sum -= num if left_sum == total_sum: return i left_sum += num return -1

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def equilibrium_index(arr): total_sum = sum(arr) left_sum=0 for i, num in enumerate(arr): total_sum -= num if left_sum == total_sum: return i left_sum += num return -1 [/INST] [TESTS] Test case #1 assert equilibrium_index([1, 2, 3, 4, 1, 2, 3]) == 3 Test case #2 assert equilibrium_index([-7, 1, 5, 2, -4, 3, 0]) == 3 Test case #3 assert equilibrium_index([1, 2, 3]) == -1 [/TESTS]</s>

Write a function to find the minimum number of elements that should be removed such that amax-amin<=k.

def find_ind(key, i, n, k, arr): ind = -1 start = i + 1 end = n - 1; while (start < end): mid = int(start + (end - start) / 2) if (arr[mid] - key <= k): ind = mid start = mid + 1 else: end = mid return ind def removals(arr, n, k): ans = n - 1 arr.sort() for i in range(0, n): j = find_ind(arr[i], i, n, k, arr) if (j != -1): ans = min(ans, n - (j - i + 1)) return ans

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def find_ind(key, i, n, k, arr): ind = -1 start = i + 1 end = n - 1; while (start < end): mid = int(start + (end - start) / 2) if (arr[mid] - key <= k): ind = mid start = mid + 1 else: end = mid return ind def removals(arr, n, k): ans = n - 1 arr.sort() for i in range(0, n): j = find_ind(arr[i], i, n, k, arr) if (j != -1): ans = min(ans, n - (j - i + 1)) return ans [/INST] [TESTS] Test case #1 assert removals([1, 3, 4, 9, 10,11, 12, 17, 20], 9, 4) == 5 Test case #2 assert removals([1, 5, 6, 2, 8], 5, 2) == 3 Test case #3 assert removals([1, 2, 3 ,4, 5, 6], 6, 3) == 2 [/TESTS]</s>

Write a function to check whether the given key is present in the dictionary or not.

def is_key_present(d,x): if x in d: return True else: return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def is_key_present(d,x): if x in d: return True else: return False [/INST] [TESTS] Test case #1 assert is_key_present({1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60},5)==True Test case #2 assert is_key_present({1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60},6)==True Test case #3 assert is_key_present({1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60},10)==False [/TESTS]</s>

Write a function to calculate the harmonic sum of n-1.

def harmonic_sum(n): if n < 2: return 1 else: return 1 / n + (harmonic_sum(n - 1))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def harmonic_sum(n): if n < 2: return 1 else: return 1 / n + (harmonic_sum(n - 1)) [/INST] [TESTS] Test case #1 assert harmonic_sum(10)==2.9289682539682538 Test case #2 assert harmonic_sum(4)==2.083333333333333 Test case #3 assert harmonic_sum(7)==2.5928571428571425 [/TESTS]</s>

Write a function to sort a list of lists by length and value.

def sort_sublists(list1): list1.sort() list1.sort(key=len) return list1

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def sort_sublists(list1): list1.sort() list1.sort(key=len) return list1 [/INST] [TESTS] Test case #1 assert sort_sublists([[2], [0], [1, 3], [0, 7], [9, 11], [13, 15, 17]])==[[0], [2], [0, 7], [1, 3], [9, 11], [13, 15, 17]] Test case #2 assert sort_sublists([[1], [2, 3], [4, 5, 6], [7], [10, 11]])==[[1], [7], [2, 3], [10, 11], [4, 5, 6]] Test case #3 assert sort_sublists([["python"],["java","C","C++"],["DBMS"],["SQL","HTML"]])==[['DBMS'], ['python'], ['SQL', 'HTML'], ['java', 'C', 'C++']] [/TESTS]</s>

Write a function to find whether an array is subset of another array.

def is_subset(arr1, m, arr2, n): hashset = set() for i in range(0, m): hashset.add(arr1[i]) for i in range(0, n): if arr2[i] in hashset: continue else: return False return True

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def is_subset(arr1, m, arr2, n): hashset = set() for i in range(0, m): hashset.add(arr1[i]) for i in range(0, n): if arr2[i] in hashset: continue else: return False return True [/INST] [TESTS] Test case #1 assert is_subset([11, 1, 13, 21, 3, 7], 6, [11, 3, 7, 1], 4) == True Test case #2 assert is_subset([1, 2, 3, 4, 5, 6], 6, [1, 2, 4], 3) == True Test case #3 assert is_subset([10, 5, 2, 23, 19], 5, [19, 5, 3], 3) == False [/TESTS]</s>

Write a python function to count the total set bits from 1 to n.

def count_Set_Bits(n) : n += 1; powerOf2 = 2; cnt = n // 2; while (powerOf2 <= n) : totalPairs = n // powerOf2; cnt += (totalPairs // 2) * powerOf2; if (totalPairs & 1) : cnt += (n % powerOf2) else : cnt += 0 powerOf2 <<= 1; return cnt;

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def count_Set_Bits(n) : n += 1; powerOf2 = 2; cnt = n // 2; while (powerOf2 <= n) : totalPairs = n // powerOf2; cnt += (totalPairs // 2) * powerOf2; if (totalPairs & 1) : cnt += (n % powerOf2) else : cnt += 0 powerOf2 <<= 1; return cnt; [/INST] [TESTS] Test case #1 assert count_Set_Bits(16) == 33 Test case #2 assert count_Set_Bits(2) == 2 Test case #3 assert count_Set_Bits(14) == 28 [/TESTS]</s>

Write a python function to convert a string to a list.

def Convert(string): li = list(string.split(" ")) return li

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def Convert(string): li = list(string.split(" ")) return li [/INST] [TESTS] Test case #1 assert Convert('python program') == ['python','program'] Test case #2 assert Convert('Data Analysis') ==['Data','Analysis'] Test case #3 assert Convert('Hadoop Training') == ['Hadoop','Training'] [/TESTS]</s>

Write a function to count unique keys for each value present in the tuple.

from collections import defaultdict def get_unique(test_list): res = defaultdict(list) for sub in test_list: res[sub[1]].append(sub[0]) res = dict(res) res_dict = dict() for key in res: res_dict[key] = len(list(set(res[key]))) return (str(res_dict))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: from collections import defaultdict def get_unique(test_list): res = defaultdict(list) for sub in test_list: res[sub[1]].append(sub[0]) res = dict(res) res_dict = dict() for key in res: res_dict[key] = len(list(set(res[key]))) return (str(res_dict)) [/INST] [TESTS] Test case #1 assert get_unique([(3, 4), (1, 2), (2, 4), (8, 2), (7, 2), (8, 1), (9, 1), (8, 4), (10, 4)] ) == '{4: 4, 2: 3, 1: 2}' Test case #2 assert get_unique([(4, 5), (2, 3), (3, 5), (9, 3), (8, 3), (9, 2), (10, 2), (9, 5), (11, 5)] ) == '{5: 4, 3: 3, 2: 2}' Test case #3 assert get_unique([(6, 5), (3, 4), (2, 6), (11, 1), (8, 22), (8, 11), (4, 3), (14, 3), (11, 6)] ) == '{5: 1, 4: 1, 6: 2, 1: 1, 22: 1, 11: 1, 3: 2}' [/TESTS]</s>

Write a function to access the initial and last data of the given tuple record.

def front_and_rear(test_tup): res = (test_tup[0], test_tup[-1]) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def front_and_rear(test_tup): res = (test_tup[0], test_tup[-1]) return (res) [/INST] [TESTS] Test case #1 assert front_and_rear((10, 4, 5, 6, 7)) == (10, 7) Test case #2 assert front_and_rear((1, 2, 3, 4, 5)) == (1, 5) Test case #3 assert front_and_rear((6, 7, 8, 9, 10)) == (6, 10) [/TESTS]</s>

Write a python function to check whether the product of digits of a number at even and odd places is equal or not.

def product_Equal(n): if n < 10: return False prodOdd = 1; prodEven = 1 while n > 0: digit = n % 10 prodOdd *= digit n = n//10 if n == 0: break; digit = n % 10 prodEven *= digit n = n//10 if prodOdd == prodEven: return True return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def product_Equal(n): if n < 10: return False prodOdd = 1; prodEven = 1 while n > 0: digit = n % 10 prodOdd *= digit n = n//10 if n == 0: break; digit = n % 10 prodEven *= digit n = n//10 if prodOdd == prodEven: return True return False [/INST] [TESTS] Test case #1 assert product_Equal(2841) == True Test case #2 assert product_Equal(1234) == False Test case #3 assert product_Equal(1212) == False [/TESTS]</s>

Write a function to remove duplicates from a list of lists.

import itertools def remove_duplicate(list1): list.sort(list1) remove_duplicate = list(list1 for list1,_ in itertools.groupby(list1)) return remove_duplicate

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import itertools def remove_duplicate(list1): list.sort(list1) remove_duplicate = list(list1 for list1,_ in itertools.groupby(list1)) return remove_duplicate [/INST] [TESTS] Test case #1 assert remove_duplicate([[10, 20], [40], [30, 56, 25], [10, 20], [33], [40]])==[[10, 20], [30, 56, 25], [33], [40]] Test case #2 assert remove_duplicate(["a", "b", "a", "c", "c"] )==["a", "b", "c"] Test case #3 assert remove_duplicate([1, 3, 5, 6, 3, 5, 6, 1] )==[1, 3, 5, 6] [/TESTS]</s>

Write a function to check if the given tuple contains all valid values or not.

def check_valid(test_tup): res = not any(map(lambda ele: not ele, test_tup)) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def check_valid(test_tup): res = not any(map(lambda ele: not ele, test_tup)) return (res) [/INST] [TESTS] Test case #1 assert check_valid((True, True, True, True) ) == True Test case #2 assert check_valid((True, False, True, True) ) == False Test case #3 assert check_valid((True, True, True, True) ) == True [/TESTS]</s>

Write a python function to count the number of distinct power of prime factor of given number.

def count_Fac(n): m = n count = 0 i = 2 while((i * i) <= m): total = 0 while (n % i == 0): n /= i total += 1 temp = 0 j = 1 while((temp + j) <= total): temp += j count += 1 j += 1 i += 1 if (n != 1): count += 1 return count

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def count_Fac(n): m = n count = 0 i = 2 while((i * i) <= m): total = 0 while (n % i == 0): n /= i total += 1 temp = 0 j = 1 while((temp + j) <= total): temp += j count += 1 j += 1 i += 1 if (n != 1): count += 1 return count [/INST] [TESTS] Test case #1 assert count_Fac(24) == 3 Test case #2 assert count_Fac(12) == 2 Test case #3 assert count_Fac(4) == 1 [/TESTS]</s>

Write a function to convert the given string of integers into a tuple.

def str_to_tuple(test_str): res = tuple(map(int, test_str.split(', '))) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def str_to_tuple(test_str): res = tuple(map(int, test_str.split(', '))) return (res) [/INST] [TESTS] Test case #1 assert str_to_tuple("1, -5, 4, 6, 7") == (1, -5, 4, 6, 7) Test case #2 assert str_to_tuple("1, 2, 3, 4, 5") == (1, 2, 3, 4, 5) Test case #3 assert str_to_tuple("4, 6, 9, 11, 13, 14") == (4, 6, 9, 11, 13, 14) [/TESTS]</s>

Write a function to find the perimeter of a rombus.

def rombus_perimeter(a): perimeter=4*a return perimeter

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def rombus_perimeter(a): perimeter=4*a return perimeter [/INST] [TESTS] Test case #1 assert rombus_perimeter(10)==40 Test case #2 assert rombus_perimeter(5)==20 Test case #3 assert rombus_perimeter(4)==16 [/TESTS]</s>

Write a function to calculate the standard deviation.

import math import sys def sd_calc(data): n = len(data) if n <= 1: return 0.0 mean, sd = avg_calc(data), 0.0 for el in data: sd += (float(el) - mean)**2 sd = math.sqrt(sd / float(n-1)) return sd def avg_calc(ls): n, mean = len(ls), 0.0 if n <= 1: return ls[0] for el in ls: mean = mean + float(el) mean = mean / float(n) return mean

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import math import sys def sd_calc(data): n = len(data) if n <= 1: return 0.0 mean, sd = avg_calc(data), 0.0 for el in data: sd += (float(el) - mean)**2 sd = math.sqrt(sd / float(n-1)) return sd def avg_calc(ls): n, mean = len(ls), 0.0 if n <= 1: return ls[0] for el in ls: mean = mean + float(el) mean = mean / float(n) return mean [/INST] [TESTS] Test case #1 assert sd_calc([4, 2, 5, 8, 6])== 2.23606797749979 Test case #2 assert sd_calc([1,2,3,4,5,6,7])==2.160246899469287 Test case #3 assert sd_calc([5,9,10,15,6,4])==4.070217029430577 [/TESTS]</s>

Write a function to create a list taking alternate elements from another given list.

def alternate_elements(list1): result=[] for item in list1[::2]: result.append(item) return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def alternate_elements(list1): result=[] for item in list1[::2]: result.append(item) return result [/INST] [TESTS] Test case #1 assert alternate_elements(["red", "black", "white", "green", "orange"])==['red', 'white', 'orange'] Test case #2 assert alternate_elements([2, 0, 3, 4, 0, 2, 8, 3, 4, 2])==[2, 3, 0, 8, 4] Test case #3 assert alternate_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9] [/TESTS]</s>

Write a function that matches a string that has an a followed by zero or more b's.

import re def text_match(text): patterns = 'ab*?' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!')

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def text_match(text): patterns = 'ab*?' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!') [/INST] [TESTS] Test case #1 assert text_match("ac")==('Found a match!') Test case #2 assert text_match("dc")==('Not matched!') Test case #3 assert text_match("abba")==('Found a match!') [/TESTS]</s>

Write a function to add a dictionary to the tuple.

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)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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) [/INST] [TESTS] Test case #1 assert add_dict_to_tuple((4, 5, 6), {"MSAM" : 1, "is" : 2, "best" : 3} ) == (4, 5, 6, {'MSAM': 1, 'is': 2, 'best': 3}) Test case #2 assert add_dict_to_tuple((1, 2, 3), {"UTS" : 2, "is" : 3, "Worst" : 4} ) == (1, 2, 3, {'UTS': 2, 'is': 3, 'Worst': 4}) Test case #3 assert add_dict_to_tuple((8, 9, 10), {"POS" : 3, "is" : 4, "Okay" : 5} ) == (8, 9, 10, {'POS': 3, 'is': 4, 'Okay': 5}) [/TESTS]</s>

Write a function to find a path with the maximum average over all existing paths for the given square matrix of size n*n.

M = 100 def maxAverageOfPath(cost, N): dp = [[0 for i in range(N + 1)] for j in range(N + 1)] dp[0][0] = cost[0][0] for i in range(1, N): dp[i][0] = dp[i - 1][0] + cost[i][0] for j in range(1, N): dp[0][j] = dp[0][j - 1] + cost[0][j] for i in range(1, N): for j in range(1, N): dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + cost[i][j] return dp[N - 1][N - 1] / (2 * N - 1)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: M = 100 def maxAverageOfPath(cost, N): dp = [[0 for i in range(N + 1)] for j in range(N + 1)] dp[0][0] = cost[0][0] for i in range(1, N): dp[i][0] = dp[i - 1][0] + cost[i][0] for j in range(1, N): dp[0][j] = dp[0][j - 1] + cost[0][j] for i in range(1, N): for j in range(1, N): dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + cost[i][j] return dp[N - 1][N - 1] / (2 * N - 1) [/INST] [TESTS] Test case #1 assert maxAverageOfPath([[1, 2, 3], [6, 5, 4], [7, 3, 9]], 3) == 5.2 Test case #2 assert maxAverageOfPath([[2, 3, 4], [7, 6, 5], [8, 4, 10]], 3) == 6.2 Test case #3 assert maxAverageOfPath([[3, 4, 5], [8, 7, 6], [9, 5, 11]], 3) == 7.2 [/TESTS]</s>

Write a function to filter the height and width of students which are stored in a dictionary.

def filter_data(students,h,w): result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w} return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def filter_data(students,h,w): result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w} return result [/INST] [TESTS] Test case #1 assert filter_data({'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},6.0,70)=={'Cierra Vega': (6.2, 70)} Test case #2 assert filter_data({'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},5.9,67)=={'Cierra Vega': (6.2, 70),'Kierra Gentry': (6.0, 68)} Test case #3 assert filter_data({'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},5.7,64)=={'Cierra Vega': (6.2, 70),'Alden Cantrell': (5.9, 65),'Kierra Gentry': (6.0, 68),'Pierre Cox': (5.8, 66)} [/TESTS]</s>

Write a function to count the same pair in two given lists using map function.

from operator import eq def count_same_pair(nums1, nums2): result = sum(map(eq, nums1, nums2)) return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: from operator import eq def count_same_pair(nums1, nums2): result = sum(map(eq, nums1, nums2)) return result [/INST] [TESTS] Test case #1 assert count_same_pair([1, 2, 3, 4, 5, 6, 7, 8],[2, 2, 3, 1, 2, 6, 7, 9])==4 Test case #2 assert count_same_pair([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8],[2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==11 Test case #3 assert count_same_pair([2, 4, -6, -9, 11, -12, 14, -5, 17],[2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==1 [/TESTS]</s>

Write a function to calculate the sum of all digits of the base to the specified power.

def power_base_sum(base, power): return sum([int(i) for i in str(pow(base, power))])

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def power_base_sum(base, power): return sum([int(i) for i in str(pow(base, power))]) [/INST] [TESTS] Test case #1 assert power_base_sum(2,100)==115 Test case #2 assert power_base_sum(8,10)==37 Test case #3 assert power_base_sum(8,15)==62 [/TESTS]</s>

Write a function to extract values between quotation marks of the given string by using regex.

import re def extract_quotation(text1): return (re.findall(r'"(.*?)"', text1))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def extract_quotation(text1): return (re.findall(r'"(.*?)"', text1)) [/INST] [TESTS] Test case #1 assert extract_quotation('Cortex "A53" Based "multi" tasking "Processor"') == ['A53', 'multi', 'Processor'] Test case #2 assert extract_quotation('Cast your "favorite" entertainment "apps"') == ['favorite', 'apps'] Test case #3 assert extract_quotation('Watch content "4k Ultra HD" resolution with "HDR 10" Support') == ['4k Ultra HD', 'HDR 10'] [/TESTS]</s>

Write a function to multiply the adjacent elements of the given tuple.

def multiply_elements(test_tup): res = tuple(i * j for i, j in zip(test_tup, test_tup[1:])) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def multiply_elements(test_tup): res = tuple(i * j for i, j in zip(test_tup, test_tup[1:])) return (res) [/INST] [TESTS] Test case #1 assert multiply_elements((1, 5, 7, 8, 10)) == (5, 35, 56, 80) Test case #2 assert multiply_elements((2, 4, 5, 6, 7)) == (8, 20, 30, 42) Test case #3 assert multiply_elements((12, 13, 14, 9, 15)) == (156, 182, 126, 135) [/TESTS]</s>

Write a function to remove all characters except letters and numbers using regex

import re def remove_char(S): result = re.sub('[\W_]+', '', S) return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def remove_char(S): result = re.sub('[\W_]+', '', S) return result [/INST] [TESTS] Test case #1 assert remove_char("123abcjw:, .@! eiw") == '123abcjweiw' Test case #2 assert remove_char("Hello1234:, ! Howare33u") == 'Hello1234Howare33u' Test case #3 assert remove_char("Cool543Triks@:, Make@987Trips") == 'Cool543TriksMake987Trips' [/TESTS]</s>

Write a function to sum elements in two lists.

def sum_list(lst1,lst2): res_list = [lst1[i] + lst2[i] for i in range(len(lst1))] return res_list

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def sum_list(lst1,lst2): res_list = [lst1[i] + lst2[i] for i in range(len(lst1))] return res_list [/INST] [TESTS] Test case #1 assert sum_list([10,20,30],[15,25,35])==[25,45,65] Test case #2 assert sum_list([1,2,3],[5,6,7])==[6,8,10] Test case #3 assert sum_list([15,20,30],[15,45,75])==[30,65,105] [/TESTS]</s>

Write a function to add two lists using map and lambda function.

def add_list(nums1,nums2): result = map(lambda x, y: x + y, nums1, nums2) return list(result)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def add_list(nums1,nums2): result = map(lambda x, y: x + y, nums1, nums2) return list(result) [/INST] [TESTS] Test case #1 assert add_list([1, 2, 3],[4,5,6])==[5, 7, 9] Test case #2 assert add_list([1,2],[3,4])==[4,6] Test case #3 assert add_list([10,20],[50,70])==[60,90] [/TESTS]</s>

Write a function to remove consecutive duplicates of a given list.

from itertools import groupby def consecutive_duplicates(nums): return [key for key, group in groupby(nums)]

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: from itertools import groupby def consecutive_duplicates(nums): return [key for key, group in groupby(nums)] [/INST] [TESTS] Test case #1 assert consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4 ])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4] Test case #2 assert consecutive_duplicates([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10])==[10, 15, 19, 18, 17, 26, 17, 18, 10] Test case #3 assert consecutive_duplicates(['a', 'a', 'b', 'c', 'd', 'd'])==['a', 'b', 'c', 'd'] [/TESTS]</s>

Write a function to find the lateral surface area of a cone.

import math def lateralsurface_cone(r,h): l = math.sqrt(r * r + h * h) LSA = math.pi * r * l return LSA

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import math def lateralsurface_cone(r,h): l = math.sqrt(r * r + h * h) LSA = math.pi * r * l return LSA [/INST] [TESTS] Test case #1 assert lateralsurface_cone(5,12)==204.20352248333654 Test case #2 assert lateralsurface_cone(10,15)==566.3586699569488 Test case #3 assert lateralsurface_cone(19,17)==1521.8090132193388 [/TESTS]</s>

Write a function to replace all occurrences of spaces, commas, or dots with a colon.

import re def replace_specialchar(text): return (re.sub("[ ,.]", ":", text))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def replace_specialchar(text): return (re.sub("[ ,.]", ":", text)) [/INST] [TESTS] Test case #1 assert replace_specialchar('Python language, Programming language.')==('Python:language::Programming:language:') Test case #2 assert replace_specialchar('a b c,d e f')==('a:b:c:d:e:f') Test case #3 assert replace_specialchar('ram reshma,ram rahim')==('ram:reshma:ram:rahim') [/TESTS]</s>

Write a function to find the index of the first occurrence of a given number in a sorted array.

def find_first_occurrence(A, x): (left, right) = (0, len(A) - 1) result = -1 while left <= right: mid = (left + right) // 2 if x == A[mid]: result = mid right = mid - 1 elif x < A[mid]: right = mid - 1 else: left = mid + 1 return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def find_first_occurrence(A, x): (left, right) = (0, len(A) - 1) result = -1 while left <= right: mid = (left + right) // 2 if x == A[mid]: result = mid right = mid - 1 elif x < A[mid]: right = mid - 1 else: left = mid + 1 return result [/INST] [TESTS] Test case #1 assert find_first_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 1 Test case #2 assert find_first_occurrence([2, 3, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 2 Test case #3 assert find_first_occurrence([2, 4, 1, 5, 6, 6, 8, 9, 9, 9], 6) == 4 [/TESTS]</s>

Write a python function to find sum of products of all possible subarrays.

def sum_Of_Subarray_Prod(arr,n): ans = 0 res = 0 i = n - 1 while (i >= 0): incr = arr[i]*(1 + res) ans += incr res = incr i -= 1 return (ans)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def sum_Of_Subarray_Prod(arr,n): ans = 0 res = 0 i = n - 1 while (i >= 0): incr = arr[i]*(1 + res) ans += incr res = incr i -= 1 return (ans) [/INST] [TESTS] Test case #1 assert sum_Of_Subarray_Prod([1,2,3],3) == 20 Test case #2 assert sum_Of_Subarray_Prod([1,2],2) == 5 Test case #3 assert sum_Of_Subarray_Prod([1,2,3,4],4) == 84 [/TESTS]</s>

Write a python function to toggle bits of the number except the first and the last bit.

def set_middle_bits(n): n |= n >> 1; n |= n >> 2; n |= n >> 4; n |= n >> 8; n |= n >> 16; return (n >> 1) ^ 1 def toggle_middle_bits(n): if (n == 1): return 1 return n ^ set_middle_bits(n)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def set_middle_bits(n): n |= n >> 1; n |= n >> 2; n |= n >> 4; n |= n >> 8; n |= n >> 16; return (n >> 1) ^ 1 def toggle_middle_bits(n): if (n == 1): return 1 return n ^ set_middle_bits(n) [/INST] [TESTS] Test case #1 assert toggle_middle_bits(9) == 15 Test case #2 assert toggle_middle_bits(10) == 12 Test case #3 assert toggle_middle_bits(11) == 13 [/TESTS]</s>

Write a function to locate the left insertion point for a specified value in sorted order.

import bisect def left_insertion(a, x): i = bisect.bisect_left(a, x) return i

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import bisect def left_insertion(a, x): i = bisect.bisect_left(a, x) return i [/INST] [TESTS] Test case #1 assert left_insertion([1,2,4,5],6)==4 Test case #2 assert left_insertion([1,2,4,5],3)==2 Test case #3 assert left_insertion([1,2,4,5],7)==4 [/TESTS]</s>

Write a function to check whether the given string is starting with a vowel or not using regex.

import re regex = '^[aeiouAEIOU][A-Za-z0-9_]*' def check_str(string): if(re.search(regex, string)): return ("Valid") else: return ("Invalid")

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re regex = '^[aeiouAEIOU][A-Za-z0-9_]*' def check_str(string): if(re.search(regex, string)): return ("Valid") else: return ("Invalid") [/INST] [TESTS] Test case #1 assert check_str("annie") == 'Valid' Test case #2 assert check_str("dawood") == 'Invalid' Test case #3 assert check_str("Else") == 'Valid' [/TESTS]</s>

Write a function to calculate the geometric sum of n-1.

def geometric_sum(n): if n < 0: return 0 else: return 1 / (pow(2, n)) + geometric_sum(n - 1)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def geometric_sum(n): if n < 0: return 0 else: return 1 / (pow(2, n)) + geometric_sum(n - 1) [/INST] [TESTS] Test case #1 assert geometric_sum(7) == 1.9921875 Test case #2 assert geometric_sum(4) == 1.9375 Test case #3 assert geometric_sum(8) == 1.99609375 [/TESTS]</s>

Write a python function to find the index of smallest triangular number with n digits.

import math def find_Index(n): x = math.sqrt(2 * math.pow(10,(n - 1))); return round(x);

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import math def find_Index(n): x = math.sqrt(2 * math.pow(10,(n - 1))); return round(x); [/INST] [TESTS] Test case #1 assert find_Index(2) == 4 Test case #2 assert find_Index(3) == 14 Test case #3 assert find_Index(4) == 45 [/TESTS]</s>

Write a function to convert the given tuple to a key-value dictionary using adjacent elements.

def tuple_to_dict(test_tup): res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2)) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def tuple_to_dict(test_tup): res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2)) return (res) [/INST] [TESTS] Test case #1 assert tuple_to_dict((1, 5, 7, 10, 13, 5)) == {1: 5, 7: 10, 13: 5} Test case #2 assert tuple_to_dict((1, 2, 3, 4, 5, 6)) == {1: 2, 3: 4, 5: 6} Test case #3 assert tuple_to_dict((7, 8, 9, 10, 11, 12)) == {7: 8, 9: 10, 11: 12} [/TESTS]</s>

Write a python function to check whether all the characters are same or not.

def all_Characters_Same(s) : n = len(s) for i in range(1,n) : if s[i] != s[0] : return False return True

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def all_Characters_Same(s) : n = len(s) for i in range(1,n) : if s[i] != s[0] : return False return True [/INST] [TESTS] Test case #1 assert all_Characters_Same("python") == False Test case #2 assert all_Characters_Same("aaa") == True Test case #3 assert all_Characters_Same("data") == False [/TESTS]</s>

Write a function to caluclate the area of a tetrahedron.

import math def area_tetrahedron(side): area = math.sqrt(3)*(side*side) return area

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import math def area_tetrahedron(side): area = math.sqrt(3)*(side*side) return area [/INST] [TESTS] Test case #1 assert area_tetrahedron(3)==15.588457268119894 Test case #2 assert area_tetrahedron(20)==692.8203230275509 Test case #3 assert area_tetrahedron(10)==173.20508075688772 [/TESTS]</s>

Write a function to rotate a given list by specified number of items to the right direction.

def rotate_right(list1,m,n): result = list1[-(m):]+list1[:-(n)] return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def rotate_right(list1,m,n): result = list1[-(m):]+list1[:-(n)] return result [/INST] [TESTS] Test case #1 assert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],3,4)==[8, 9, 10, 1, 2, 3, 4, 5, 6] Test case #2 assert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],2,2)==[9, 10, 1, 2, 3, 4, 5, 6, 7, 8] Test case #3 assert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],5,2)==[6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8] [/TESTS]</s>

Write a function to check if the given tuple has any none value or not.

def check_none(test_tup): res = any(map(lambda ele: ele is None, test_tup)) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def check_none(test_tup): res = any(map(lambda ele: ele is None, test_tup)) return (res) [/INST] [TESTS] Test case #1 assert check_none((10, 4, 5, 6, None)) == True Test case #2 assert check_none((7, 8, 9, 11, 14)) == False Test case #3 assert check_none((1, 2, 3, 4, None)) == True [/TESTS]</s>

Write a function to find numbers within a given range where every number is divisible by every digit it contains.

def divisible_by_digits(startnum, endnum): return [n for n in range(startnum, endnum+1) \ if not any(map(lambda x: int(x) == 0 or n%int(x) != 0, str(n)))]

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def divisible_by_digits(startnum, endnum): return [n for n in range(startnum, endnum+1) \ if not any(map(lambda x: int(x) == 0 or n%int(x) != 0, str(n)))] [/INST] [TESTS] Test case #1 assert divisible_by_digits(1,22)==[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22] Test case #2 assert divisible_by_digits(1,15)==[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15] Test case #3 assert divisible_by_digits(20,25)==[22, 24] [/TESTS]</s>

Write a function to find area of a sector.

def sector_area(r,a): pi=22/7 if a >= 360: return None sectorarea = (pi*r**2) * (a/360) return sectorarea

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def sector_area(r,a): pi=22/7 if a >= 360: return None sectorarea = (pi*r**2) * (a/360) return sectorarea [/INST] [TESTS] Test case #1 assert sector_area(4,45)==6.285714285714286 Test case #2 assert sector_area(9,45)==31.82142857142857 Test case #3 assert sector_area(9,360)==None [/TESTS]</s>

Write a function to find the longest common subsequence for the given three string sequence.

def lcs_of_three(X, Y, Z, m, n, o): L = [[[0 for i in range(o+1)] for j in range(n+1)] for k in range(m+1)] for i in range(m+1): for j in range(n+1): for k in range(o+1): if (i == 0 or j == 0 or k == 0): L[i][j][k] = 0 elif (X[i-1] == Y[j-1] and X[i-1] == Z[k-1]): L[i][j][k] = L[i-1][j-1][k-1] + 1 else: L[i][j][k] = max(max(L[i-1][j][k], L[i][j-1][k]), L[i][j][k-1]) return L[m][n][o]

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def lcs_of_three(X, Y, Z, m, n, o): L = [[[0 for i in range(o+1)] for j in range(n+1)] for k in range(m+1)] for i in range(m+1): for j in range(n+1): for k in range(o+1): if (i == 0 or j == 0 or k == 0): L[i][j][k] = 0 elif (X[i-1] == Y[j-1] and X[i-1] == Z[k-1]): L[i][j][k] = L[i-1][j-1][k-1] + 1 else: L[i][j][k] = max(max(L[i-1][j][k], L[i][j-1][k]), L[i][j][k-1]) return L[m][n][o] [/INST] [TESTS] Test case #1 assert lcs_of_three('AGGT12', '12TXAYB', '12XBA', 6, 7, 5) == 2 Test case #2 assert lcs_of_three('Reels', 'Reelsfor', 'ReelsforReels', 5, 8, 13) == 5 Test case #3 assert lcs_of_three('abcd1e2', 'bc12ea', 'bd1ea', 7, 6, 5) == 3 [/TESTS]</s>

Write a function to put spaces between words starting with capital letters in a given string by using regex.

import re def capital_words_spaces(str1): return re.sub(r"(\w)([A-Z])", r"\1 \2", str1)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def capital_words_spaces(str1): return re.sub(r"(\w)([A-Z])", r"\1 \2", str1) [/INST] [TESTS] Test case #1 assert capital_words_spaces("Python") == 'Python' Test case #2 assert capital_words_spaces("PythonProgrammingExamples") == 'Python Programming Examples' Test case #3 assert capital_words_spaces("GetReadyToBeCodingFreak") == 'Get Ready To Be Coding Freak' [/TESTS]</s>

Write a function to sort a given list of strings of numbers numerically.

def sort_numeric_strings(nums_str): result = [int(x) for x in nums_str] result.sort() return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def sort_numeric_strings(nums_str): result = [int(x) for x in nums_str] result.sort() return result [/INST] [TESTS] Test case #1 assert sort_numeric_strings( ['4','12','45','7','0','100','200','-12','-500'])==[-500, -12, 0, 4, 7, 12, 45, 100, 200] Test case #2 assert sort_numeric_strings(['2','3','8','4','7','9','8','2','6','5','1','6','1','2','3','4','6','9','1','2'])==[1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8, 9, 9] Test case #3 assert sort_numeric_strings(['1','3','5','7','1', '3','13', '15', '17','5', '7 ','9','1', '11'])==[1, 1, 1, 3, 3, 5, 5, 7, 7, 9, 11, 13, 15, 17] [/TESTS]</s>

Write a function to add the given tuple to the given list.

def add_tuple(test_list, test_tup): test_list += test_tup return (test_list)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def add_tuple(test_list, test_tup): test_list += test_tup return (test_list) [/INST] [TESTS] Test case #1 assert add_tuple([5, 6, 7], (9, 10)) == [5, 6, 7, 9, 10] Test case #2 assert add_tuple([6, 7, 8], (10, 11)) == [6, 7, 8, 10, 11] Test case #3 assert add_tuple([7, 8, 9], (11, 12)) == [7, 8, 9, 11, 12] [/TESTS]</s>

Write a function to check if the given array represents min heap or not.

def check_min_heap(arr, i): if 2 * i + 2 > len(arr): return True left_child = (arr[i] <= arr[2 * i + 1]) and check_min_heap(arr, 2 * i + 1) right_child = (2 * i + 2 == len(arr)) or (arr[i] <= arr[2 * i + 2] and check_min_heap(arr, 2 * i + 2)) return left_child and right_child

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def check_min_heap(arr, i): if 2 * i + 2 > len(arr): return True left_child = (arr[i] <= arr[2 * i + 1]) and check_min_heap(arr, 2 * i + 1) right_child = (2 * i + 2 == len(arr)) or (arr[i] <= arr[2 * i + 2] and check_min_heap(arr, 2 * i + 2)) return left_child and right_child [/INST] [TESTS] Test case #1 assert check_min_heap([1, 2, 3, 4, 5, 6], 0) == True Test case #2 assert check_min_heap([2, 3, 4, 5, 10, 15], 0) == True Test case #3 assert check_min_heap([2, 10, 4, 5, 3, 15], 0) == False [/TESTS]</s>

Write a function to find the nth jacobsthal number.

def jacobsthal_num(n): dp = [0] * (n + 1) dp[0] = 0 dp[1] = 1 for i in range(2, n+1): dp[i] = dp[i - 1] + 2 * dp[i - 2] return dp[n]

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def jacobsthal_num(n): dp = [0] * (n + 1) dp[0] = 0 dp[1] = 1 for i in range(2, n+1): dp[i] = dp[i - 1] + 2 * dp[i - 2] return dp[n] [/INST] [TESTS] Test case #1 assert jacobsthal_num(5) == 11 Test case #2 assert jacobsthal_num(2) == 1 Test case #3 assert jacobsthal_num(4) == 5 [/TESTS]</s>

Write a function to find minimum k records from tuple list.

def min_k(test_list, K): res = sorted(test_list, key = lambda x: x[1])[:K] return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def min_k(test_list, K): res = sorted(test_list, key = lambda x: x[1])[:K] return (res) [/INST] [TESTS] Test case #1 assert min_k([('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)], 2) == [('Akash', 2), ('Akshat', 4)] Test case #2 assert min_k([('Sanjeev', 11), ('Angat', 5), ('Akash', 3), ('Nepin', 9)], 3) == [('Akash', 3), ('Angat', 5), ('Nepin', 9)] Test case #3 assert min_k([('tanmay', 14), ('Amer', 11), ('Ayesha', 9), ('SKD', 16)], 1) == [('Ayesha', 9)] [/TESTS]</s>

Write a function to find common index elements from three lists.

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

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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 [/INST] [TESTS] Test case #1 assert extract_index_list([1, 1, 3, 4, 5, 6, 7],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[1, 7] Test case #2 assert extract_index_list([1, 1, 3, 4, 5, 6, 7],[0, 1, 2, 3, 4, 6, 5],[0, 1, 2, 3, 4, 6, 7])==[1, 6] Test case #3 assert extract_index_list([1, 1, 3, 4, 6, 5, 6],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[1, 5] [/TESTS]</s>

Write a function to find the second smallest number in a list.

def second_smallest(numbers): if (len(numbers)<2): return if ((len(numbers)==2) and (numbers[0] == numbers[1]) ): return dup_items = set() uniq_items = [] for x in numbers: if x not in dup_items: uniq_items.append(x) dup_items.add(x) uniq_items.sort() return uniq_items[1]

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def second_smallest(numbers): if (len(numbers)<2): return if ((len(numbers)==2) and (numbers[0] == numbers[1]) ): return dup_items = set() uniq_items = [] for x in numbers: if x not in dup_items: uniq_items.append(x) dup_items.add(x) uniq_items.sort() return uniq_items[1] [/INST] [TESTS] Test case #1 assert second_smallest([1, 2, -8, -2, 0, -2])==-2 Test case #2 assert second_smallest([1, 1, -0.5, 0, 2, -2, -2])==-0.5 Test case #3 assert second_smallest([2,2])==None [/TESTS]</s>

Write a function that matches a string that has an a followed by zero or one 'b'.

import re def text_match_zero_one(text): patterns = 'ab?' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!')

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def text_match_zero_one(text): patterns = 'ab?' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!') [/INST] [TESTS] Test case #1 assert text_match_zero_one("ac")==('Found a match!') Test case #2 assert text_match_zero_one("dc")==('Not matched!') Test case #3 assert text_match_zero_one("abbbba")==('Found a match!') [/TESTS]</s>

Write a function to count the pairs of reverse strings in the given string list.

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 str(res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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 str(res) [/INST] [TESTS] Test case #1 assert count_reverse_pairs(["julia", "best", "tseb", "for", "ailuj"])== '2' Test case #2 assert count_reverse_pairs(["geeks", "best", "for", "skeeg"]) == '1' Test case #3 assert count_reverse_pairs(["makes", "best", "sekam", "for", "rof"]) == '2' [/TESTS]</s>

Write a function to count number of unique lists within a list.

def unique_sublists(list1): result ={} for l in list1: result.setdefault(tuple(l), list()).append(1) for a, b in result.items(): result[a] = sum(b) return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def unique_sublists(list1): result ={} for l in list1: result.setdefault(tuple(l), list()).append(1) for a, b in result.items(): result[a] = sum(b) return result [/INST] [TESTS] Test case #1 assert unique_sublists([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]] )=={(1, 3): 2, (5, 7): 2, (13, 15, 17): 1, (9, 11): 1} Test case #2 assert unique_sublists([['green', 'orange'], ['black'], ['green', 'orange'], ['white']])=={('green', 'orange'): 2, ('black',): 1, ('white',): 1} Test case #3 assert unique_sublists([[10, 20, 30, 40], [60, 70, 50, 50], [90, 100, 200]])=={(10, 20, 30, 40): 1, (60, 70, 50, 50): 1, (90, 100, 200): 1} [/TESTS]</s>

Write a function to check a decimal with a precision of 2.

def is_decimal(num): import re dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""") result = dnumre.search(num) return bool(result)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def is_decimal(num): import re dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""") result = dnumre.search(num) return bool(result) [/INST] [TESTS] Test case #1 assert is_decimal('123.11')==True Test case #2 assert is_decimal('e666.86')==False Test case #3 assert is_decimal('3.124587')==False [/TESTS]</s>

Write a python function to check whether an array contains only one distinct element or not.

def unique_Element(arr,n): s = set(arr) if (len(s) == 1): return ('YES') else: return ('NO')

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def unique_Element(arr,n): s = set(arr) if (len(s) == 1): return ('YES') else: return ('NO') [/INST] [TESTS] Test case #1 assert unique_Element([1,1,1],3) == 'YES' Test case #2 assert unique_Element([1,2,1,2],4) == 'NO' Test case #3 assert unique_Element([1,2,3,4,5],5) == 'NO' [/TESTS]</s>

Write a function to caluclate arc length of an angle.

def arc_length(d,a): pi=22/7 if a >= 360: return None arclength = (pi*d) * (a/360) return arclength

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def arc_length(d,a): pi=22/7 if a >= 360: return None arclength = (pi*d) * (a/360) return arclength [/INST] [TESTS] Test case #1 assert arc_length(9,45)==3.5357142857142856 Test case #2 assert arc_length(9,480)==None Test case #3 assert arc_length(5,270)==11.785714285714285 [/TESTS]</s>

Write a function to check whether the given month number contains 30 days or not.

def check_monthnumber_number(monthnum3): if(monthnum3==4 or monthnum3==6 or monthnum3==9 or monthnum3==11): return True else: return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def check_monthnumber_number(monthnum3): if(monthnum3==4 or monthnum3==6 or monthnum3==9 or monthnum3==11): return True else: return False [/INST] [TESTS] Test case #1 assert check_monthnumber_number(6)==True Test case #2 assert check_monthnumber_number(2)==False Test case #3 assert check_monthnumber_number(12)==False [/TESTS]</s>

Write a python function to find the minimum difference between any two elements in a given array.

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

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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 [/INST] [TESTS] Test case #1 assert find_Min_Diff((1,5,3,19,18,25),6) == 1 Test case #2 assert find_Min_Diff((4,3,2,6),4) == 1 Test case #3 assert find_Min_Diff((30,5,20,9),4) == 4 [/TESTS]</s>

Write a python function to count numeric values in a given string.

def number_ctr(str): number_ctr= 0 for i in range(len(str)): if str[i] >= '0' and str[i] <= '9': number_ctr += 1 return number_ctr

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def number_ctr(str): number_ctr= 0 for i in range(len(str)): if str[i] >= '0' and str[i] <= '9': number_ctr += 1 return number_ctr [/INST] [TESTS] Test case #1 assert number_ctr('program2bedone') == 1 Test case #2 assert number_ctr('3wonders') ==1 Test case #3 assert number_ctr('123') == 3 [/TESTS]</s>

Write a function to find nth polite number.

import math def is_polite(n): n = n + 1 return (int)(n+(math.log((n + math.log(n, 2)), 2)))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import math def is_polite(n): n = n + 1 return (int)(n+(math.log((n + math.log(n, 2)), 2))) [/INST] [TESTS] Test case #1 assert is_polite(7) == 11 Test case #2 assert is_polite(4) == 7 Test case #3 assert is_polite(9) == 13 [/TESTS]</s>

Write a function to iterate over all pairs of consecutive items in a given list.

def pair_wise(l1): temp = [] for i in range(len(l1) - 1): current_element, next_element = l1[i], l1[i + 1] x = (current_element, next_element) temp.append(x) return temp

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def pair_wise(l1): temp = [] for i in range(len(l1) - 1): current_element, next_element = l1[i], l1[i + 1] x = (current_element, next_element) temp.append(x) return temp [/INST] [TESTS] Test case #1 assert pair_wise([1,1,2,3,3,4,4,5])==[(1, 1), (1, 2), (2, 3), (3, 3), (3, 4), (4, 4), (4, 5)] Test case #2 assert pair_wise([1,5,7,9,10])==[(1, 5), (5, 7), (7, 9), (9, 10)] Test case #3 assert pair_wise([1,2,3,4,5,6,7,8,9,10])==[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10)] [/TESTS]</s>

Write a python function to count the number of pairs whose sum is equal to ‘sum’.

def get_Pairs_Count(arr,n,sum): count = 0 for i in range(0,n): for j in range(i + 1,n): if arr[i] + arr[j] == sum: count += 1 return count

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def get_Pairs_Count(arr,n,sum): count = 0 for i in range(0,n): for j in range(i + 1,n): if arr[i] + arr[j] == sum: count += 1 return count [/INST] [TESTS] Test case #1 assert get_Pairs_Count([1,1,1,1],4,2) == 6 Test case #2 assert get_Pairs_Count([1,5,7,-1,5],5,6) == 3 Test case #3 assert get_Pairs_Count([1,-2,3],3,1) == 1 [/TESTS]</s>

Write a python function to check for odd parity of a given number.

def check_Odd_Parity(x): parity = 0 while (x != 0): x = x & (x - 1) parity += 1 if (parity % 2 == 1): return True else: return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def check_Odd_Parity(x): parity = 0 while (x != 0): x = x & (x - 1) parity += 1 if (parity % 2 == 1): return True else: return False [/INST] [TESTS] Test case #1 assert check_Odd_Parity(13) == True Test case #2 assert check_Odd_Parity(21) == True Test case #3 assert check_Odd_Parity(18) == False [/TESTS]</s>

Write a python function to get the difference between two lists.

def Diff(li1,li2): return (list(list(set(li1)-set(li2)) + list(set(li2)-set(li1))))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def Diff(li1,li2): return (list(list(set(li1)-set(li2)) + list(set(li2)-set(li1)))) [/INST] [TESTS] Test case #1 assert (Diff([10, 15, 20, 25, 30, 35, 40], [25, 40, 35])) == [10, 20, 30, 15] Test case #2 assert (Diff([1,2,3,4,5], [6,7,1])) == [2,3,4,5,6,7] Test case #3 assert (Diff([1,2,3], [6,7,1])) == [2,3,6,7] [/TESTS]</s>

Write a python function to find the sum of fourth power of first n odd natural numbers.

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

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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 [/INST] [TESTS] Test case #1 assert odd_Num_Sum(2) == 82 Test case #2 assert odd_Num_Sum(3) == 707 Test case #3 assert odd_Num_Sum(4) == 3108 [/TESTS]</s>

Write a function to check if the given expression is balanced or not.

from collections import deque def check_expression(exp): if len(exp) & 1: return False stack = deque() for ch in exp: if ch == '(' or ch == '{' or ch == '[': stack.append(ch) if ch == ')' or ch == '}' or ch == ']': if not stack: return False top = stack.pop() if (top == '(' and ch != ')') or (top == '{' and ch != '}' or (top == '[' and ch != ']')): return False return not stack

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: from collections import deque def check_expression(exp): if len(exp) & 1: return False stack = deque() for ch in exp: if ch == '(' or ch == '{' or ch == '[': stack.append(ch) if ch == ')' or ch == '}' or ch == ']': if not stack: return False top = stack.pop() if (top == '(' and ch != ')') or (top == '{' and ch != '}' or (top == '[' and ch != ']')): return False return not stack [/INST] [TESTS] Test case #1 assert check_expression("{()}[{}]") == True Test case #2 assert check_expression("{()}[{]") == False Test case #3 assert check_expression("{()}[{}][]({})") == True [/TESTS]</s>

Write a function to remove all the words with k length in the given string.

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)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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) [/INST] [TESTS] Test case #1 assert remove_length('The person is most value tet', 3) == 'person is most value' Test case #2 assert remove_length('If you told me about this ok', 4) == 'If you me about ok' Test case #3 assert remove_length('Forces of darkeness is come into the play', 4) == 'Forces of darkeness is the' [/TESTS]</s>

Write a function to find the occurrence and position of the substrings within a string.

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)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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) [/INST] [TESTS] Test case #1 assert occurance_substring('python programming, python language','python')==('python', 0, 6) Test case #2 assert occurance_substring('python programming,programming language','programming')==('programming', 7, 18) Test case #3 assert occurance_substring('python programming,programming language','language')==('language', 31, 39) [/TESTS]</s>

Write a function to check if the string is a valid email address or not using regex.

import re regex = '^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$' def check_email(email): if(re.search(regex,email)): return ("Valid Email") else: return ("Invalid Email")

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re regex = '^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$' def check_email(email): if(re.search(regex,email)): return ("Valid Email") else: return ("Invalid Email") [/INST] [TESTS] Test case #1 assert check_email("ankitrai326@gmail.com") == 'Valid Email' Test case #2 assert check_email("my.ownsite@ourearth.org") == 'Valid Email' Test case #3 assert check_email("ankitaoie326.com") == 'Invalid Email' [/TESTS]</s>

Write a python function to check whether every odd index contains odd numbers of a given list.

def odd_position(nums): return all(nums[i]%2==i%2 for i in range(len(nums)))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def odd_position(nums): return all(nums[i]%2==i%2 for i in range(len(nums))) [/INST] [TESTS] Test case #1 assert odd_position([2,1,4,3,6,7,6,3]) == True Test case #2 assert odd_position([4,1,2]) == True Test case #3 assert odd_position([1,2,3]) == False [/TESTS]</s>

Write a function to count those characters which have vowels as their neighbors in the given string.

def count_vowels(test_str): res = 0 vow_list = ['a', 'e', 'i', 'o', 'u'] for idx in range(1, len(test_str) - 1): if test_str[idx] not in vow_list and (test_str[idx - 1] in vow_list or test_str[idx + 1] in vow_list): res += 1 if test_str[0] not in vow_list and test_str[1] in vow_list: res += 1 if test_str[-1] not in vow_list and test_str[-2] in vow_list: res += 1 return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def count_vowels(test_str): res = 0 vow_list = ['a', 'e', 'i', 'o', 'u'] for idx in range(1, len(test_str) - 1): if test_str[idx] not in vow_list and (test_str[idx - 1] in vow_list or test_str[idx + 1] in vow_list): res += 1 if test_str[0] not in vow_list and test_str[1] in vow_list: res += 1 if test_str[-1] not in vow_list and test_str[-2] in vow_list: res += 1 return (res) [/INST] [TESTS] Test case #1 assert count_vowels('bestinstareels') == 7 Test case #2 assert count_vowels('partofthejourneyistheend') == 12 Test case #3 assert count_vowels('amazonprime') == 5 [/TESTS]</s>

Write a python function to find the sum of non-repeated elements in a given array.

def find_Sum(arr,n): arr.sort() sum = arr[0] for i in range(0,n-1): if (arr[i] != arr[i+1]): sum = sum + arr[i+1] return sum

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def find_Sum(arr,n): arr.sort() sum = arr[0] for i in range(0,n-1): if (arr[i] != arr[i+1]): sum = sum + arr[i+1] return sum [/INST] [TESTS] Test case #1 assert find_Sum([1,2,3,1,1,4,5,6],8) == 21 Test case #2 assert find_Sum([1,10,9,4,2,10,10,45,4],9) == 71 Test case #3 assert find_Sum([12,10,9,45,2,10,10,45,10],9) == 78 [/TESTS]</s>

Write a function to pack consecutive duplicates of a given list elements into sublists.

from itertools import groupby def pack_consecutive_duplicates(list1): return [list(group) for key, group in groupby(list1)]

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: from itertools import groupby def pack_consecutive_duplicates(list1): return [list(group) for key, group in groupby(list1)] [/INST] [TESTS] Test case #1 assert pack_consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4])==[[0, 0], [1], [2], [3], [4, 4], [5], [6, 6, 6], [7], [8], [9], [4, 4]] Test case #2 assert pack_consecutive_duplicates([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10])==[[10, 10], [15], [19], [18, 18], [17], [26, 26], [17], [18], [10]] Test case #3 assert pack_consecutive_duplicates(['a', 'a', 'b', 'c', 'd', 'd'])==[['a', 'a'], ['b'], ['c'], ['d', 'd']] [/TESTS]</s>

Write a function to count the number of unique lists within a list.

def unique_sublists(list1): result ={} for l in list1: result.setdefault(tuple(l), list()).append(1) for a, b in result.items(): result[a] = sum(b) return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def unique_sublists(list1): result ={} for l in list1: result.setdefault(tuple(l), list()).append(1) for a, b in result.items(): result[a] = sum(b) return result [/INST] [TESTS] Test case #1 assert unique_sublists([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]])=={(1, 3): 2, (5, 7): 2, (13, 15, 17): 1, (9, 11): 1} Test case #2 assert unique_sublists([['green', 'orange'], ['black'], ['green', 'orange'], ['white']])=={('green', 'orange'): 2, ('black',): 1, ('white',): 1} Test case #3 assert unique_sublists([[1, 2], [3, 4], [4, 5], [6, 7]])=={(1, 2): 1, (3, 4): 1, (4, 5): 1, (6, 7): 1} [/TESTS]</s>

Write a function to find the combinations of sums with tuples in the given tuple list.

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)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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) [/INST] [TESTS] Test case #1 assert find_combinations([(2, 4), (6, 7), (5, 1), (6, 10)]) == [(8, 11), (7, 5), (8, 14), (11, 8), (12, 17), (11, 11)] Test case #2 assert find_combinations([(3, 5), (7, 8), (6, 2), (7, 11)]) == [(10, 13), (9, 7), (10, 16), (13, 10), (14, 19), (13, 13)] Test case #3 assert find_combinations([(4, 6), (8, 9), (7, 3), (8, 12)]) == [(12, 15), (11, 9), (12, 18), (15, 12), (16, 21), (15, 15)] [/TESTS]</s>

Write a python function to check whether the count of divisors is even or odd.

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 if (count % 2 == 0) : return ("Even") else : return ("Odd")

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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 if (count % 2 == 0) : return ("Even") else : return ("Odd") [/INST] [TESTS] Test case #1 assert count_Divisors(10) == "Even" Test case #2 assert count_Divisors(100) == "Odd" Test case #3 assert count_Divisors(125) == "Even" [/TESTS]</s>

Write a python function to find the sum of all odd length subarrays.

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

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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 [/INST] [TESTS] Test case #1 assert Odd_Length_Sum([1,2,4]) == 14 Test case #2 assert Odd_Length_Sum([1,2,1,2]) == 15 Test case #3 assert Odd_Length_Sum([1,7]) == 8 [/TESTS]</s>

Write a function to convert rgb color to hsv color.

def rgb_to_hsv(r, g, b): r, g, b = r/255.0, g/255.0, b/255.0 mx = max(r, g, b) mn = min(r, g, b) df = mx-mn if mx == mn: h = 0 elif mx == r: h = (60 * ((g-b)/df) + 360) % 360 elif mx == g: h = (60 * ((b-r)/df) + 120) % 360 elif mx == b: h = (60 * ((r-g)/df) + 240) % 360 if mx == 0: s = 0 else: s = (df/mx)*100 v = mx*100 return h, s, v

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def rgb_to_hsv(r, g, b): r, g, b = r/255.0, g/255.0, b/255.0 mx = max(r, g, b) mn = min(r, g, b) df = mx-mn if mx == mn: h = 0 elif mx == r: h = (60 * ((g-b)/df) + 360) % 360 elif mx == g: h = (60 * ((b-r)/df) + 120) % 360 elif mx == b: h = (60 * ((r-g)/df) + 240) % 360 if mx == 0: s = 0 else: s = (df/mx)*100 v = mx*100 return h, s, v [/INST] [TESTS] Test case #1 assert rgb_to_hsv(255, 255, 255)==(0, 0.0, 100.0) Test case #2 assert rgb_to_hsv(0, 215, 0)==(120.0, 100.0, 84.31372549019608) Test case #3 assert rgb_to_hsv(10, 215, 110)==(149.26829268292684, 95.34883720930233, 84.31372549019608) [/TESTS]</s>

Write a function to find the product of first even and odd number of a given list.

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)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: 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) [/INST] [TESTS] Test case #1 assert mul_even_odd([1,3,5,7,4,1,6,8])==4 Test case #2 assert mul_even_odd([1,2,3,4,5,6,7,8,9,10])==2 Test case #3 assert mul_even_odd([1,5,7,9,10])==10 [/TESTS]</s>

Write a function to convert tuple string to integer tuple.

def tuple_str_int(test_str): res = tuple(int(num) for num in test_str.replace('(', '').replace(')', '').replace('...', '').split(', ')) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def tuple_str_int(test_str): res = tuple(int(num) for num in test_str.replace('(', '').replace(')', '').replace('...', '').split(', ')) return (res) [/INST] [TESTS] Test case #1 assert tuple_str_int("(7, 8, 9)") == (7, 8, 9) Test case #2 assert tuple_str_int("(1, 2, 3)") == (1, 2, 3) Test case #3 assert tuple_str_int("(4, 5, 6)") == (4, 5, 6) [/TESTS]</s>

Write a function to locate the right insertion point for a specified value in sorted order.

import bisect def right_insertion(a, x): i = bisect.bisect_right(a, x) return i

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import bisect def right_insertion(a, x): i = bisect.bisect_right(a, x) return i [/INST] [TESTS] Test case #1 assert right_insertion([1,2,4,5],6)==4 Test case #2 assert right_insertion([1,2,4,5],3)==2 Test case #3 assert right_insertion([1,2,4,5],7)==4 [/TESTS]</s>

Write a function that matches a string that has an a followed by three 'b'.

import re def text_match_three(text): patterns = 'ab{3}?' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!')

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def text_match_three(text): patterns = 'ab{3}?' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!') [/INST] [TESTS] Test case #1 assert text_match_three("ac")==('Not matched!') Test case #2 assert text_match_three("dc")==('Not matched!') Test case #3 assert text_match_three("abbbba")==('Found a match!') [/TESTS]</s>

Write a function to create a new tuple from the given string and list.

def new_tuple(test_list, test_str): res = tuple(test_list + [test_str]) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def new_tuple(test_list, test_str): res = tuple(test_list + [test_str]) return (res) [/INST] [TESTS] Test case #1 assert new_tuple(["WEB", "is"], "best") == ('WEB', 'is', 'best') Test case #2 assert new_tuple(["We", "are"], "Developers") == ('We', 'are', 'Developers') Test case #3 assert new_tuple(["Part", "is"], "Wrong") == ('Part', 'is', 'Wrong') [/TESTS]</s>

Write a function to calculate the perimeter of a regular polygon.

from math import tan, pi def perimeter_polygon(s,l): perimeter = s*l return perimeter

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: from math import tan, pi def perimeter_polygon(s,l): perimeter = s*l return perimeter [/INST] [TESTS] Test case #1 assert perimeter_polygon(4,20)==80 Test case #2 assert perimeter_polygon(10,15)==150 Test case #3 assert perimeter_polygon(9,7)==63 [/TESTS]</s>

Write a python function to check whether every even index contains even numbers of a given list.

def even_position(nums): return all(nums[i]%2==i%2 for i in range(len(nums)))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def even_position(nums): return all(nums[i]%2==i%2 for i in range(len(nums))) [/INST] [TESTS] Test case #1 assert even_position([3,2,1]) == False Test case #2 assert even_position([1,2,3]) == False Test case #3 assert even_position([2,1,4]) == True [/TESTS]</s>

Write a function to remove the nested record from the given tuple.

def remove_nested(test_tup): res = tuple() for count, ele in enumerate(test_tup): if not isinstance(ele, tuple): res = res + (ele, ) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def remove_nested(test_tup): res = tuple() for count, ele in enumerate(test_tup): if not isinstance(ele, tuple): res = res + (ele, ) return (res) [/INST] [TESTS] Test case #1 assert remove_nested((1, 5, 7, (4, 6), 10)) == (1, 5, 7, 10) Test case #2 assert remove_nested((2, 6, 8, (5, 7), 11)) == (2, 6, 8, 11) Test case #3 assert remove_nested((3, 7, 9, (6, 8), 12)) == (3, 7, 9, 12) [/TESTS]</s>

Write a python function to count the number of lists in a given number of lists.

def count_list(input_list): return len(input_list)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def count_list(input_list): return len(input_list) [/INST] [TESTS] Test case #1 assert count_list([[1, 3], [5, 7], [9, 11], [13, 15, 17]]) == 4 Test case #2 assert count_list([[1,2],[2,3],[4,5]]) == 3 Test case #3 assert count_list([[1,0],[2,0]]) == 2 [/TESTS]</s>

Write a python function to find the last position of an element in a sorted array.

def last(arr,x,n): 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

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def last(arr,x,n): 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 [/INST] [TESTS] Test case #1 assert last([1,2,3],1,3) == 0 Test case #2 assert last([1,1,1,2,3,4],1,6) == 2 Test case #3 assert last([2,3,2,3,6,8,9],3,8) == 3 [/TESTS]</s>

Write a function that matches a string that has an 'a' followed by anything, ending in 'b'.

import re def text_starta_endb(text): patterns = 'a.*?b$' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!')

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def text_starta_endb(text): patterns = 'a.*?b$' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!') [/INST] [TESTS] Test case #1 assert text_starta_endb("aabbbb")==('Found a match!') Test case #2 assert text_starta_endb("aabAbbbc")==('Not matched!') Test case #3 assert text_starta_endb("accddbbjjj")==('Not matched!') [/TESTS]</s>

Write a function to find the n - cheap price items from a given dataset using heap queue algorithm.

import heapq def cheap_items(items,n): cheap_items = heapq.nsmallest(n, items, key=lambda s: s['price']) return cheap_items

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import heapq def cheap_items(items,n): cheap_items = heapq.nsmallest(n, items, key=lambda s: s['price']) return cheap_items [/INST] [TESTS] Test case #1 assert cheap_items([{'name': 'Item-1', 'price': 101.1},{'name': 'Item-2', 'price': 555.22}],1)==[{'name': 'Item-1', 'price': 101.1}] Test case #2 assert cheap_items([{'name': 'Item-1', 'price': 101.1},{'name': 'Item-2', 'price': 555.22}],2)==[{'name': 'Item-1', 'price': 101.1},{'name': 'Item-2', 'price': 555.22}] Test case #3 assert cheap_items([{'name': 'Item-1', 'price': 101.1},{'name': 'Item-2', 'price': 555.22}, {'name': 'Item-3', 'price': 45.09},{'name': 'Item-4', 'price': 22.75}],1)==[{'name': 'Item-4', 'price': 22.75}] [/TESTS]</s>

Write function to find the sum of all items in the given dictionary.

def return_sum(dict): sum = 0 for i in dict.values(): sum = sum + i return sum

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def return_sum(dict): sum = 0 for i in dict.values(): sum = sum + i return sum [/INST] [TESTS] Test case #1 assert return_sum({'a': 100, 'b':200, 'c':300}) == 600 Test case #2 assert return_sum({'a': 25, 'b':18, 'c':45}) == 88 Test case #3 assert return_sum({'a': 36, 'b':39, 'c':49}) == 124 [/TESTS]</s>

Write a python function to find the sum of all odd natural numbers within the range l and r.

def sum_Odd(n): terms = (n + 1)//2 sum1 = terms * terms return sum1 def sum_in_Range(l,r): return sum_Odd(r) - sum_Odd(l - 1)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def sum_Odd(n): terms = (n + 1)//2 sum1 = terms * terms return sum1 def sum_in_Range(l,r): return sum_Odd(r) - sum_Odd(l - 1) [/INST] [TESTS] Test case #1 assert sum_in_Range(2,5) == 8 Test case #2 assert sum_in_Range(5,7) == 12 Test case #3 assert sum_in_Range(7,13) == 40 [/TESTS]</s>

Write a python function to find the sum of an array.

def _sum(arr): sum=0 for i in arr: sum = sum + i return(sum)

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: def _sum(arr): sum=0 for i in arr: sum = sum + i return(sum) [/INST] [TESTS] Test case #1 assert _sum([1, 2, 3]) == 6 Test case #2 assert _sum([15, 12, 13, 10]) == 50 Test case #3 assert _sum([0, 1, 2]) == 3 [/TESTS]</s>

Write a python function to left rotate the bits of a given number.

INT_BITS = 32 def left_Rotate(n,d): return (n << d)|(n >> (INT_BITS - d))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: INT_BITS = 32 def left_Rotate(n,d): return (n << d)|(n >> (INT_BITS - d)) [/INST] [TESTS] Test case #1 assert left_Rotate(16,2) == 64 Test case #2 assert left_Rotate(10,2) == 40 Test case #3 assert left_Rotate(99,3) == 792 [/TESTS]</s>

Write a function to remove all whitespaces from a string.

import re def remove_all_spaces(text): return (re.sub(r'\s+', '',text))

<s> [INST] Your task is to write 3 tests to check the correctness of a function code that solves a programming problem. The tests must be between [TESTS] and [/TESTS] tags. You must write the comment "#Test case n:" on a separate line directly above each assert statement, where n represents the test case number, starting from 1 and increasing by one for each subsequent test case. Code: def get_unique_elements(list1): # insert the list to the set list_set = set(list1) # convert the set to the list unique_list = (list(list_set)) return unique_list [/INST] [TESTS] # Test case 1: assert get_unique_elements([]) == [] # Test case 2: assert get_unique_elements([1]) == [1] # Test case 3: assert get_unique_elements([1, 2, 3, 2, 1]) == [1, 2, 3] [/TESTS] [INST] Code: import re def remove_all_spaces(text): return (re.sub(r'\s+', '',text)) [/INST] [TESTS] Test case #1 assert remove_all_spaces('python program')==('pythonprogram') Test case #2 assert remove_all_spaces('python programming language')==('pythonprogramminglanguage') Test case #3 assert remove_all_spaces('python program')==('pythonprogram') [/TESTS]</s>