Datasets:

Pav17

/

T3-gen-dataset

like 0

Write a python function to count the number of equal numbers from three given integers.

def test_three_equal(x,y,z): result= set([x,y,z]) if len(result)==3: return 0 else: return (4-len(result))

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to count the number of equal numbers from three given integers. def test_three_equal(x,y,z): result= set([x,y,z]) if len(result)==3: return 0 else: return (4-len(result))[/INST]assert test_three_equal(1,1,1) == 3 assert test_three_equal(-1,-2,-3) == 0 assert test_three_equal(1,2,2) == 2</s>

Write a python function to count the number of rotations required to generate a sorted array.

def count_Rotation(arr,n): for i in range (1,n): if (arr[i] < arr[i - 1]): return i return 0

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to count the number of rotations required to generate a sorted array. def count_Rotation(arr,n): for i in range (1,n): if (arr[i] < arr[i - 1]): return i return 0[/INST]assert count_Rotation([3,2,1],3) == 1 assert count_Rotation([4,5,1,2,3],5) == 2 assert count_Rotation([7,8,9,1,2,3],6) == 3</s>

Write a python function to check whether the given number is a perfect square or not.

def is_Perfect_Square(n) : i = 1 while (i * i<= n): if ((n % i == 0) and (n / i == i)): return True i = i + 1 return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the given number is a perfect square or not. def is_Perfect_Square(n) : i = 1 while (i * i<= n): if ((n % i == 0) and (n / i == i)): return True i = i + 1 return False[/INST]assert is_Perfect_Square(10) == False assert is_Perfect_Square(36) == True assert is_Perfect_Square(14) == False</s>

Write a python function to check whether the product of numbers is even or not.

def is_Product_Even(arr,n): for i in range(0,n): if ((arr[i] & 1) == 0): return True return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the product of numbers is even or not. def is_Product_Even(arr,n): for i in range(0,n): if ((arr[i] & 1) == 0): return True return False[/INST]assert is_Product_Even([1,2,3],3) == True assert is_Product_Even([1,2,1,4],4) == True assert is_Product_Even([1,1],2) == False</s>

Write a function to find the list in a list of lists whose sum of elements is the highest.

def max_sum_list(lists): return max(lists, key=sum)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the list in a list of lists whose sum of elements is the highest. def max_sum_list(lists): return max(lists, key=sum)[/INST]assert max_sum_list([[1,2,3], [4,5,6], [10,11,12], [7,8,9]])==[10, 11, 12] assert max_sum_list([[3,2,1], [6,5,4], [12,11,10]])==[12,11,10] assert max_sum_list([[2,3,1]])==[2,3,1] </s>

Write a function to find maximum run of uppercase characters in the given string.

def max_run_uppercase(test_str): cnt = 0 res = 0 for idx in range(0, len(test_str)): if test_str[idx].isupper(): cnt += 1 else: res = cnt cnt = 0 if test_str[len(test_str) - 1].isupper(): res = cnt return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find maximum run of uppercase characters in the given string. def max_run_uppercase(test_str): cnt = 0 res = 0 for idx in range(0, len(test_str)): if test_str[idx].isupper(): cnt += 1 else: res = cnt cnt = 0 if test_str[len(test_str) - 1].isupper(): res = cnt return (res)[/INST]assert max_run_uppercase('GeMKSForGERksISBESt') == 5 assert max_run_uppercase('PrECIOusMOVemENTSYT') == 6 assert max_run_uppercase('GooGLEFluTTER') == 4</s>

Write a python function to find the first odd number in a given list of numbers.

def first_odd(nums): first_odd = next((el for el in nums if el%2!=0),-1) return first_odd

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find the first odd number in a given list of numbers. def first_odd(nums): first_odd = next((el for el in nums if el%2!=0),-1) return first_odd[/INST]assert first_odd([1,3,5]) == 1 assert first_odd([2,4,1,3]) == 1 assert first_odd ([8,9,1]) == 9</s>

Write a function to check if the given tuples contain the k or not.

def check_K(test_tup, K): res = False for ele in test_tup: if ele == K: res = True break return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check if the given tuples contain the k or not. def check_K(test_tup, K): res = False for ele in test_tup: if ele == K: res = True break return (res) [/INST]assert check_K((10, 4, 5, 6, 8), 6) == True assert check_K((1, 2, 3, 4, 5, 6), 7) == False assert check_K((7, 8, 9, 44, 11, 12), 11) == True</s>

Write a function to check if each element of second tuple is smaller than its corresponding index in first tuple.

def check_smaller(test_tup1, test_tup2): res = all(x > y for x, y in zip(test_tup1, test_tup2)) return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check if each element of second tuple is smaller than its corresponding index in first tuple. def check_smaller(test_tup1, test_tup2): res = all(x > y for x, y in zip(test_tup1, test_tup2)) return (res) [/INST]assert check_smaller((1, 2, 3), (2, 3, 4)) == False assert check_smaller((4, 5, 6), (3, 4, 5)) == True assert check_smaller((11, 12, 13), (10, 11, 12)) == True</s>

Write a function to iterate over elements repeating each as many times as its count.

from collections import Counter def count_variable(a,b,c,d): c = Counter(p=a, q=b, r=c, s=d) return list(c.elements())

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to iterate over elements repeating each as many times as its count. from collections import Counter def count_variable(a,b,c,d): c = Counter(p=a, q=b, r=c, s=d) return list(c.elements())[/INST]assert count_variable(4,2,0,-2)==['p', 'p', 'p', 'p', 'q', 'q'] assert count_variable(0,1,2,3)==['q', 'r', 'r', 's', 's', 's'] assert count_variable(11,15,12,23)==['p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'q', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's', 's']</s>

Write a function to check if two lists of tuples are identical or not.

def check_identical(test_list1, test_list2): res = test_list1 == test_list2 return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check if two lists of tuples are identical or not. def check_identical(test_list1, test_list2): res = test_list1 == test_list2 return (res) [/INST]assert check_identical([(10, 4), (2, 5)], [(10, 4), (2, 5)]) == True assert check_identical([(1, 2), (3, 7)], [(12, 14), (12, 45)]) == False assert check_identical([(2, 14), (12, 25)], [(2, 14), (12, 25)]) == True</s>

Write a function to abbreviate 'road' as 'rd.' in a given string.

import re def road_rd(street): return (re.sub('Road$', 'Rd.', street))

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to abbreviate 'road' as 'rd.' in a given string. import re def road_rd(street): return (re.sub('Road$', 'Rd.', street))[/INST]assert road_rd("ravipadu Road")==('ravipadu Rd.') assert road_rd("palnadu Road")==('palnadu Rd.') assert road_rd("eshwar enclave Road")==('eshwar enclave Rd.')</s>

Write a function to find length of the string.

def string_length(str1): count = 0 for char in str1: count += 1 return count

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find length of the string. def string_length(str1): count = 0 for char in str1: count += 1 return count[/INST]assert string_length('python')==6 assert string_length('program')==7 assert string_length('language')==8</s>

Write a function to find the area of a rombus.

def rombus_area(p,q): area=(p*q)/2 return area

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the area of a rombus. def rombus_area(p,q): area=(p*q)/2 return area[/INST]assert rombus_area(10,20)==100 assert rombus_area(10,5)==25 assert rombus_area(4,2)==4</s>

Write a function to sort the given array without using any sorting algorithm. the given array consists of only 0, 1, and 2.

def sort_by_dnf(arr, n): low=0 mid=0 high=n-1 while mid <= high: if arr[mid] == 0: arr[low], arr[mid] = arr[mid], arr[low] low = low + 1 mid = mid + 1 elif arr[mid] == 1: mid = mid + 1 else: arr[mid], arr[high] = arr[high], arr[mid] high = high - 1 return arr

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to sort the given array without using any sorting algorithm. the given array consists of only 0, 1, and 2. def sort_by_dnf(arr, n): low=0 mid=0 high=n-1 while mid <= high: if arr[mid] == 0: arr[low], arr[mid] = arr[mid], arr[low] low = low + 1 mid = mid + 1 elif arr[mid] == 1: mid = mid + 1 else: arr[mid], arr[high] = arr[high], arr[mid] high = high - 1 return arr[/INST]assert sort_by_dnf([1,2,0,1,0,1,2,1,1], 9) == [0, 0, 1, 1, 1, 1, 1, 2, 2] assert sort_by_dnf([1,0,0,1,2,1,2,2,1,0], 10) == [0, 0, 0, 1, 1, 1, 1, 2, 2, 2] assert sort_by_dnf([2,2,1,0,0,0,1,1,2,1], 10) == [0, 0, 0, 1, 1, 1, 1, 2, 2, 2]</s>

Write a function to clear the values of the given tuples.

def clear_tuple(test_tup): temp = list(test_tup) temp.clear() test_tup = tuple(temp) return (test_tup)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to clear the values of the given tuples. def clear_tuple(test_tup): temp = list(test_tup) temp.clear() test_tup = tuple(temp) return (test_tup) [/INST]assert clear_tuple((1, 5, 3, 6, 8)) == () assert clear_tuple((2, 1, 4 ,5 ,6)) == () assert clear_tuple((3, 2, 5, 6, 8)) == ()</s>

Write a function to find numbers divisible by m or n from a list of numbers using lambda function.

def div_of_nums(nums,m,n): result = list(filter(lambda x: (x % m == 0 or x % n == 0), nums)) return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find numbers divisible by m or n from a list of numbers using lambda function. def div_of_nums(nums,m,n): result = list(filter(lambda x: (x % m == 0 or x % n == 0), nums)) return result[/INST]assert div_of_nums([19, 65, 57, 39, 152, 639, 121, 44, 90, 190],19,13)==[19, 65, 57, 39, 152, 190] assert div_of_nums([1, 2, 3, 5, 7, 8, 10],2,5)==[2, 5, 8, 10] assert div_of_nums([10,15,14,13,18,12,20],10,5)==[10, 15, 20]</s>

Write a python function to count lower case letters in a given string.

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

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to count lower case letters in a given string. def lower_ctr(str): lower_ctr= 0 for i in range(len(str)): if str[i] >= 'a' and str[i] <= 'z': lower_ctr += 1 return lower_ctr[/INST]assert lower_ctr('abc') == 3 assert lower_ctr('string') == 6 assert lower_ctr('Python') == 5</s>

Write a function to count the frequency of consecutive duplicate elements in a given list of numbers.

def count_duplic(lists): element = [] frequency = [] if not lists: return element running_count = 1 for i in range(len(lists)-1): if lists[i] == lists[i+1]: running_count += 1 else: frequency.append(running_count) element.append(lists[i]) running_count = 1 frequency.append(running_count) element.append(lists[i+1]) return element,frequency

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to count the frequency of consecutive duplicate elements in a given list of numbers. def count_duplic(lists): element = [] frequency = [] if not lists: return element running_count = 1 for i in range(len(lists)-1): if lists[i] == lists[i+1]: running_count += 1 else: frequency.append(running_count) element.append(lists[i]) running_count = 1 frequency.append(running_count) element.append(lists[i+1]) return element,frequency [/INST]assert count_duplic([1,2,2,2,4,4,4,5,5,5,5])==([1, 2, 4, 5], [1, 3, 3, 4]) assert count_duplic([2,2,3,1,2,6,7,9])==([2, 3, 1, 2, 6, 7, 9], [2, 1, 1, 1, 1, 1, 1]) assert count_duplic([2,1,5,6,8,3,4,9,10,11,8,12])==([2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])</s>

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

def check_monthnum_number(monthnum1): if monthnum1 == 2: return True else: return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check whether the given month number contains 28 days or not. def check_monthnum_number(monthnum1): if monthnum1 == 2: return True else: return False[/INST]assert check_monthnum_number(2)==True assert check_monthnum_number(1)==False assert check_monthnum_number(3)==False</s>

Write a function to merge two dictionaries into a single expression.

import collections as ct def merge_dictionaries(dict1,dict2): merged_dict = dict(ct.ChainMap({}, dict1, dict2)) return merged_dict

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to merge two dictionaries into a single expression. import collections as ct def merge_dictionaries(dict1,dict2): merged_dict = dict(ct.ChainMap({}, dict1, dict2)) return merged_dict[/INST]assert merge_dictionaries({ "R": "Red", "B": "Black", "P": "Pink" }, { "G": "Green", "W": "White" })=={'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White'} assert merge_dictionaries({ "R": "Red", "B": "Black", "P": "Pink" },{ "O": "Orange", "W": "White", "B": "Black" })=={'O': 'Orange', 'P': 'Pink', 'B': 'Black', 'W': 'White', 'R': 'Red'} assert merge_dictionaries({ "G": "Green", "W": "White" },{ "O": "Orange", "W": "White", "B": "Black" })=={'W': 'White', 'O': 'Orange', 'G': 'Green', 'B': 'Black'}</s>

Write a function to return true if the password is valid.

import re def pass_validity(p): x = True while x: if (len(p)<6 or len(p)>12): break elif not re.search("[a-z]",p): break elif not re.search("[0-9]",p): break elif not re.search("[A-Z]",p): break elif not re.search("[$#@]",p): break elif re.search("\s",p): break else: return True x=False break if x: return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to return true if the password is valid. import re def pass_validity(p): x = True while x: if (len(p)<6 or len(p)>12): break elif not re.search("[a-z]",p): break elif not re.search("[0-9]",p): break elif not re.search("[A-Z]",p): break elif not re.search("[$#@]",p): break elif re.search("\s",p): break else: return True x=False break if x: return False[/INST]assert pass_validity("password")==False assert pass_validity("Password@10")==True assert pass_validity("password@10")==False</s>

Write a function to check if the given string starts with a substring using regex.

import re def check_substring(string, sample) : if (sample in string): y = "\A" + sample x = re.search(y, string) if x : return ("string starts with the given substring") else : return ("string doesnt start with the given substring") else : return ("entered string isnt a substring")

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check if the given string starts with a substring using regex. import re def check_substring(string, sample) : if (sample in string): y = "\A" + sample x = re.search(y, string) if x : return ("string starts with the given substring") else : return ("string doesnt start with the given substring") else : return ("entered string isnt a substring")[/INST]assert check_substring("dreams for dreams makes life fun", "makes") == 'string doesnt start with the given substring' assert check_substring("Hi there how are you Hi alex", "Hi") == 'string starts with the given substring' assert check_substring("Its been a long day", "been") == 'string doesnt start with the given substring'</s>

Write a python function to remove even numbers from a given list.

def remove_even(l): for i in l: if i % 2 == 0: l.remove(i) return l

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to remove even numbers from a given list. def remove_even(l): for i in l: if i % 2 == 0: l.remove(i) return l[/INST]assert remove_even([1,3,5,2]) == [1,3,5] assert remove_even([5,6,7]) == [5,7] assert remove_even([1,2,3,4]) == [1,3]</s>

Write a python function to access multiple elements of specified index from a given list.

def access_elements(nums, list_index): result = [nums[i] for i in list_index] return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to access multiple elements of specified index from a given list. def access_elements(nums, list_index): result = [nums[i] for i in list_index] return result[/INST]assert access_elements([2,3,8,4,7,9],[0,3,5]) == [2, 4, 9] assert access_elements([1, 2, 3, 4, 5],[1,2]) == [2,3] assert access_elements([1,0,2,3],[0,1]) == [1,0]</s>

Write a python function to find the type of triangle from the given sides.

def check_Type_Of_Triangle(a,b,c): sqa = pow(a,2) sqb = pow(b,2) sqc = pow(c,2) if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb): return ("Right-angled Triangle") elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb): return ("Obtuse-angled Triangle") else: return ("Acute-angled Triangle")

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find the type of triangle from the given sides. def check_Type_Of_Triangle(a,b,c): sqa = pow(a,2) sqb = pow(b,2) sqc = pow(c,2) if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb): return ("Right-angled Triangle") elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb): return ("Obtuse-angled Triangle") else: return ("Acute-angled Triangle") [/INST]assert check_Type_Of_Triangle(1,2,3) == "Obtuse-angled Triangle" assert check_Type_Of_Triangle(2,2,2) == "Acute-angled Triangle" assert check_Type_Of_Triangle(1,0,1) == "Right-angled Triangle"</s>

Write a function to sum a specific column of a list in a given list of lists.

def sum_column(list1, C): result = sum(row[C] for row in list1) return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to sum a specific column of a list in a given list of lists. def sum_column(list1, C): result = sum(row[C] for row in list1) return result[/INST]assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],0)==12 assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],1)==15 assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],3)==9</s>

Write a function to count alphabets,digits and special charactes in a given string.

def count_alpha_dig_spl(string): alphabets=digits = special = 0 for i in range(len(string)): if(string[i].isalpha()): alphabets = alphabets + 1 elif(string[i].isdigit()): digits = digits + 1 else: special = special + 1 return (alphabets,digits,special)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to count alphabets,digits and special charactes in a given string. def count_alpha_dig_spl(string): alphabets=digits = special = 0 for i in range(len(string)): if(string[i].isalpha()): alphabets = alphabets + 1 elif(string[i].isdigit()): digits = digits + 1 else: special = special + 1 return (alphabets,digits,special) [/INST]assert count_alpha_dig_spl("abc!@#123")==(3,3,3) assert count_alpha_dig_spl("dgsuy@#$%&1255")==(5,4,5) assert count_alpha_dig_spl("fjdsif627348#%$^&")==(6,6,5)</s>

Write a function to find out the second most repeated (or frequent) string in the given sequence.

from collections import Counter def second_frequent(input): dict = Counter(input) value = sorted(dict.values(), reverse=True) second_large = value[1] for (key, val) in dict.items(): if val == second_large: return (key)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find out the second most repeated (or frequent) string in the given sequence. from collections import Counter def second_frequent(input): dict = Counter(input) value = sorted(dict.values(), reverse=True) second_large = value[1] for (key, val) in dict.items(): if val == second_large: return (key) [/INST]assert second_frequent(['aaa','bbb','ccc','bbb','aaa','aaa']) == 'bbb' assert second_frequent(['abc','bcd','abc','bcd','bcd','bcd']) == 'abc' assert second_frequent(['cdma','gsm','hspa','gsm','cdma','cdma']) == 'gsm'</s>

Write a function to round up a number to specific digits.

import math def round_up(a, digits): n = 10**-digits return round(math.ceil(a / n) * n, digits)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to round up a number to specific digits. import math def round_up(a, digits): n = 10**-digits return round(math.ceil(a / n) * n, digits)[/INST]assert round_up(123.01247,0)==124 assert round_up(123.01247,1)==123.1 assert round_up(123.01247,2)==123.02</s>

Write a python function to count equal element pairs from the given array.

def count_Pairs(arr,n): cnt = 0; for i in range(n): for j in range(i + 1,n): if (arr[i] == arr[j]): cnt += 1; return cnt;

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to count equal element pairs from the given array. def count_Pairs(arr,n): cnt = 0; for i in range(n): for j in range(i + 1,n): if (arr[i] == arr[j]): cnt += 1; return cnt; [/INST]assert count_Pairs([1,1,1,1],4) == 6 assert count_Pairs([1,5,1],3) == 1 assert count_Pairs([3,2,1,7,8,9],6) == 0</s>

Write a function to extract the maximum numeric value from a string by using regex.

import re def extract_max(input): numbers = re.findall('\d+',input) numbers = map(int,numbers) return max(numbers)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to extract the maximum numeric value from a string by using regex. import re def extract_max(input): numbers = re.findall('\d+',input) numbers = map(int,numbers) return max(numbers)[/INST]assert extract_max('100klh564abc365bg') == 564 assert extract_max('hello300how546mer231') == 546 assert extract_max('its233beenalong343journey234') == 343</s>

Write a function to get dictionary keys as a list.

def get_key(dict): list = [] for key in dict.keys(): list.append(key) return list

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to get dictionary keys as a list. def get_key(dict): list = [] for key in dict.keys(): list.append(key) return list[/INST]assert get_key({1:'python',2:'java'})==[1,2] assert get_key({10:'red',20:'blue',30:'black'})==[10,20,30] assert get_key({27:'language',39:'java',44:'little'})==[27,39,44]</s>

Write a function to generate a square matrix filled with elements from 1 to n raised to the power of 2 in spiral order.

def generate_matrix(n): if n<=0: return [] matrix=[row[:] for row in [[0]*n]*n] row_st=0 row_ed=n-1 col_st=0 col_ed=n-1 current=1 while (True): if current>n*n: break for c in range (col_st, col_ed+1): matrix[row_st][c]=current current+=1 row_st+=1 for r in range (row_st, row_ed+1): matrix[r][col_ed]=current current+=1 col_ed-=1 for c in range (col_ed, col_st-1, -1): matrix[row_ed][c]=current current+=1 row_ed-=1 for r in range (row_ed, row_st-1, -1): matrix[r][col_st]=current current+=1 col_st+=1 return matrix

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to generate a square matrix filled with elements from 1 to n raised to the power of 2 in spiral order. def generate_matrix(n): if n<=0: return [] matrix=[row[:] for row in [[0]*n]*n] row_st=0 row_ed=n-1 col_st=0 col_ed=n-1 current=1 while (True): if current>n*n: break for c in range (col_st, col_ed+1): matrix[row_st][c]=current current+=1 row_st+=1 for r in range (row_st, row_ed+1): matrix[r][col_ed]=current current+=1 col_ed-=1 for c in range (col_ed, col_st-1, -1): matrix[row_ed][c]=current current+=1 row_ed-=1 for r in range (row_ed, row_st-1, -1): matrix[r][col_st]=current current+=1 col_st+=1 return matrix[/INST]assert generate_matrix(3)==[[1, 2, 3], [8, 9, 4], [7, 6, 5]] assert generate_matrix(2)==[[1,2],[4,3]] assert generate_matrix(7)==[[1, 2, 3, 4, 5, 6, 7], [24, 25, 26, 27, 28, 29, 8], [23, 40, 41, 42, 43, 30, 9], [22, 39, 48, 49, 44, 31, 10], [21, 38, 47, 46, 45, 32, 11], [20, 37, 36, 35, 34, 33, 12], [19, 18, 17, 16, 15, 14, 13]]</s>

Write a python function to find the slope of a line.

def slope(x1,y1,x2,y2): return (float)(y2-y1)/(x2-x1)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find the slope of a line. def slope(x1,y1,x2,y2): return (float)(y2-y1)/(x2-x1) [/INST]assert slope(4,2,2,5) == -1.5 assert slope(2,4,4,6) == 1 assert slope(1,2,4,2) == 0</s>

Write a function to find length of the subarray having maximum sum.

from sys import maxsize def max_sub_array_sum(a,size): max_so_far = -maxsize - 1 max_ending_here = 0 start = 0 end = 0 s = 0 for i in range(0,size): max_ending_here += a[i] if max_so_far < max_ending_here: max_so_far = max_ending_here start = s end = i if max_ending_here < 0: max_ending_here = 0 s = i+1 return (end - start + 1)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find length of the subarray having maximum sum. from sys import maxsize def max_sub_array_sum(a,size): max_so_far = -maxsize - 1 max_ending_here = 0 start = 0 end = 0 s = 0 for i in range(0,size): max_ending_here += a[i] if max_so_far < max_ending_here: max_so_far = max_ending_here start = s end = i if max_ending_here < 0: max_ending_here = 0 s = i+1 return (end - start + 1)[/INST]assert max_sub_array_sum([-2, -3, 4, -1, -2, 1, 5, -3],8) == 5 assert max_sub_array_sum([1, -2, 1, 1, -2, 1],6) == 2 assert max_sub_array_sum([-1, -2, 3, 4, 5],5) == 3</s>

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

def cube_Sum(n): sum = 0 for i in range(0,n) : sum += (2*i+1)*(2*i+1)*(2*i+1) return sum

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find the cube sum of first n odd natural numbers. def cube_Sum(n): sum = 0 for i in range(0,n) : sum += (2*i+1)*(2*i+1)*(2*i+1) return sum[/INST]assert cube_Sum(2) == 28 assert cube_Sum(3) == 153 assert cube_Sum(4) == 496</s>

Write a python function to find minimum number swaps required to make two binary strings equal.

def min_Swaps(s1,s2) : c0 = 0; c1 = 0; for i in range(len(s1)) : if (s1[i] == '0' and s2[i] == '1') : c0 += 1; elif (s1[i] == '1' and s2[i] == '0') : c1 += 1; result = c0 // 2 + c1 // 2; if (c0 % 2 == 0 and c1 % 2 == 0) : return result; elif ((c0 + c1) % 2 == 0) : return result + 2; else : return -1;

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find minimum number swaps required to make two binary strings equal. def min_Swaps(s1,s2) : c0 = 0; c1 = 0; for i in range(len(s1)) : if (s1[i] == '0' and s2[i] == '1') : c0 += 1; elif (s1[i] == '1' and s2[i] == '0') : c1 += 1; result = c0 // 2 + c1 // 2; if (c0 % 2 == 0 and c1 % 2 == 0) : return result; elif ((c0 + c1) % 2 == 0) : return result + 2; else : return -1; [/INST]assert min_Swaps("0011","1111") == 1 assert min_Swaps("00011","01001") == 2 assert min_Swaps("111","111") == 0</s>

Write a function to sort the tuples alphabetically by the first item of each tuple.

def sort_tuple(tup): n = len(tup) for i in range(n): for j in range(n-i-1): if tup[j][0] > tup[j + 1][0]: tup[j], tup[j + 1] = tup[j + 1], tup[j] return tup

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to sort the tuples alphabetically by the first item of each tuple. def sort_tuple(tup): n = len(tup) for i in range(n): for j in range(n-i-1): if tup[j][0] > tup[j + 1][0]: tup[j], tup[j + 1] = tup[j + 1], tup[j] return tup[/INST]assert sort_tuple([("Amana", 28), ("Zenat", 30), ("Abhishek", 29),("Nikhil", 21), ("B", "C")]) == [('Abhishek', 29), ('Amana', 28), ('B', 'C'), ('Nikhil', 21), ('Zenat', 30)] assert sort_tuple([("aaaa", 28), ("aa", 30), ("bab", 29), ("bb", 21), ("csa", "C")]) == [('aa', 30), ('aaaa', 28), ('bab', 29), ('bb', 21), ('csa', 'C')] assert sort_tuple([("Sarala", 28), ("Ayesha", 30), ("Suman", 29),("Sai", 21), ("G", "H")]) == [('Ayesha', 30), ('G', 'H'), ('Sai', 21), ('Sarala', 28), ('Suman', 29)]</s>

Write a python function to check whether the roots of a quadratic equation are numerically equal but opposite in sign or not.

def Check_Solution(a,b,c): if b == 0: return ("Yes") else: return ("No")

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the roots of a quadratic equation are numerically equal but opposite in sign or not. def Check_Solution(a,b,c): if b == 0: return ("Yes") else: return ("No") [/INST]assert Check_Solution(2,0,-1) == "Yes" assert Check_Solution(1,-5,6) == "No" assert Check_Solution(2,0,2) == "Yes"</s>

Write a function to count the number of inversions in the given array.

def get_inv_count(arr, n): inv_count = 0 for i in range(n): for j in range(i + 1, n): if (arr[i] > arr[j]): inv_count += 1 return inv_count

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to count the number of inversions in the given array. def get_inv_count(arr, n): inv_count = 0 for i in range(n): for j in range(i + 1, n): if (arr[i] > arr[j]): inv_count += 1 return inv_count [/INST]assert get_inv_count([1, 20, 6, 4, 5], 5) == 5 assert get_inv_count([8, 4, 2, 1], 4) == 6 assert get_inv_count([3, 1, 2], 3) == 2</s>

Write a function to find the number which occurs for odd number of times in the given array.

def get_odd_occurence(arr, arr_size): for i in range(0, arr_size): count = 0 for j in range(0, arr_size): if arr[i] == arr[j]: count += 1 if (count % 2 != 0): return arr[i] return -1

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the number which occurs for odd number of times in the given array. def get_odd_occurence(arr, arr_size): for i in range(0, arr_size): count = 0 for j in range(0, arr_size): if arr[i] == arr[j]: count += 1 if (count % 2 != 0): return arr[i] return -1[/INST]assert get_odd_occurence([2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2], 13) == 5 assert get_odd_occurence([1, 2, 3, 2, 3, 1, 3], 7) == 3 assert get_odd_occurence([5, 7, 2, 7, 5, 2, 5], 7) == 5</s>

Write a function to find the nth super ugly number from a given prime list of size k using heap queue algorithm.

import heapq def nth_super_ugly_number(n, primes): uglies = [1] def gen(prime): for ugly in uglies: yield ugly * prime merged = heapq.merge(*map(gen, primes)) while len(uglies) < n: ugly = next(merged) if ugly != uglies[-1]: uglies.append(ugly) return uglies[-1]

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the nth super ugly number from a given prime list of size k using heap queue algorithm. import heapq def nth_super_ugly_number(n, primes): uglies = [1] def gen(prime): for ugly in uglies: yield ugly * prime merged = heapq.merge(*map(gen, primes)) while len(uglies) < n: ugly = next(merged) if ugly != uglies[-1]: uglies.append(ugly) return uglies[-1][/INST]assert nth_super_ugly_number(12,[2,7,13,19])==32 assert nth_super_ugly_number(10,[2,7,13,19])==26 assert nth_super_ugly_number(100,[2,7,13,19])==5408</s>

Write a python function to find the kth element in an array containing odd elements first and then even elements.

def get_Number(n, k): arr = [0] * n; i = 0; odd = 1; while (odd <= n): arr[i] = odd; i += 1; odd += 2; even = 2; while (even <= n): arr[i] = even; i += 1; even += 2; return arr[k - 1];

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find the kth element in an array containing odd elements first and then even elements. def get_Number(n, k): arr = [0] * n; i = 0; odd = 1; while (odd <= n): arr[i] = odd; i += 1; odd += 2; even = 2; while (even <= n): arr[i] = even; i += 1; even += 2; return arr[k - 1]; [/INST]assert get_Number(8,5) == 2 assert get_Number(7,2) == 3 assert get_Number(5,2) == 3</s>

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

import math def find_Digits(n): if (n < 0): return 0; if (n <= 1): return 1; x = ((n * math.log10(n / math.e) + math.log10(2 * math.pi * n) /2.0)); return math.floor(x) + 1;

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to count the number of digits in factorial of a given number. import math def find_Digits(n): if (n < 0): return 0; if (n <= 1): return 1; x = ((n * math.log10(n / math.e) + math.log10(2 * math.pi * n) /2.0)); return math.floor(x) + 1; [/INST]assert find_Digits(7) == 4 assert find_Digits(5) == 3 assert find_Digits(4) == 2</s>

Write a function to find the minimum number of platforms required for a railway/bus station.

def find_platform(arr, dep, n): arr.sort() dep.sort() plat_needed = 1 result = 1 i = 1 j = 0 while (i < n and j < n): if (arr[i] <= dep[j]): plat_needed+= 1 i+= 1 elif (arr[i] > dep[j]): plat_needed-= 1 j+= 1 if (plat_needed > result): result = plat_needed return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the minimum number of platforms required for a railway/bus station. def find_platform(arr, dep, n): arr.sort() dep.sort() plat_needed = 1 result = 1 i = 1 j = 0 while (i < n and j < n): if (arr[i] <= dep[j]): plat_needed+= 1 i+= 1 elif (arr[i] > dep[j]): plat_needed-= 1 j+= 1 if (plat_needed > result): result = plat_needed return result[/INST]assert find_platform([900, 940, 950, 1100, 1500, 1800],[910, 1200, 1120, 1130, 1900, 2000],6)==3 assert find_platform([100,200,300,400],[700,800,900,1000],4)==4 assert find_platform([5,6,7,8],[4,3,2,1],4)==1</s>

Write a python function to copy a list from a singleton tuple.

def lcopy(xs): return xs[:]

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to copy a list from a singleton tuple. def lcopy(xs): return xs[:] [/INST]assert lcopy([1, 2, 3]) == [1, 2, 3] assert lcopy([4, 8, 2, 10, 15, 18]) == [4, 8, 2, 10, 15, 18] assert lcopy([4, 5, 6]) == [4, 5, 6] </s>

Write a function to find the area of a trapezium.

def area_trapezium(base1,base2,height): area = 0.5 * (base1 + base2) * height return area

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the area of a trapezium. def area_trapezium(base1,base2,height): area = 0.5 * (base1 + base2) * height return area[/INST]assert area_trapezium(6,9,4)==30 assert area_trapezium(10,20,30)==450 assert area_trapezium(15,25,35)==700</s>

Write a python function to find sum of all prime divisors of a given number.

def Sum(N): SumOfPrimeDivisors = [0]*(N + 1) for i in range(2,N + 1) : if (SumOfPrimeDivisors[i] == 0) : for j in range(i,N + 1,i) : SumOfPrimeDivisors[j] += i return SumOfPrimeDivisors[N]

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find sum of all prime divisors of a given number. def Sum(N): SumOfPrimeDivisors = [0]*(N + 1) for i in range(2,N + 1) : if (SumOfPrimeDivisors[i] == 0) : for j in range(i,N + 1,i) : SumOfPrimeDivisors[j] += i return SumOfPrimeDivisors[N] [/INST]assert Sum(60) == 10 assert Sum(39) == 16 assert Sum(40) == 7</s>

Write a function to check if a triangle of positive area is possible with the given angles.

def is_triangleexists(a,b,c): if(a != 0 and b != 0 and c != 0 and (a + b + c)== 180): if((a + b)>= c or (b + c)>= a or (a + c)>= b): return True else: return False else: return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check if a triangle of positive area is possible with the given angles. def is_triangleexists(a,b,c): if(a != 0 and b != 0 and c != 0 and (a + b + c)== 180): if((a + b)>= c or (b + c)>= a or (a + c)>= b): return True else: return False else: return False[/INST]assert is_triangleexists(50,60,70)==True assert is_triangleexists(90,45,45)==True assert is_triangleexists(150,30,70)==False</s>

Write a python function to find sum of inverse of divisors.

def Sum_of_Inverse_Divisors(N,Sum): ans = float(Sum)*1.0 /float(N); return round(ans,2);

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find sum of inverse of divisors. def Sum_of_Inverse_Divisors(N,Sum): ans = float(Sum)*1.0 /float(N); return round(ans,2); [/INST]assert Sum_of_Inverse_Divisors(6,12) == 2 assert Sum_of_Inverse_Divisors(9,13) == 1.44 assert Sum_of_Inverse_Divisors(1,4) == 4</s>

Write a python function to remove negative numbers from a list.

def remove_negs(num_list): for item in num_list: if item < 0: num_list.remove(item) return num_list

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to remove negative numbers from a list. def remove_negs(num_list): for item in num_list: if item < 0: num_list.remove(item) return num_list[/INST]assert remove_negs([1,-2,3,-4]) == [1,3] assert remove_negs([1,2,3,-4]) == [1,2,3] assert remove_negs([4,5,-6,7,-8]) == [4,5,7]</s>

Write a python function to find sum of odd factors of a number.

import math def sum_of_odd_Factors(n): res = 1 while n % 2 == 0: n = n // 2 for i in range(3,int(math.sqrt(n) + 1)): count = 0 curr_sum = 1 curr_term = 1 while n % i == 0: count+=1 n = n // i curr_term *= i curr_sum += curr_term res *= curr_sum if n >= 2: res *= (1 + n) return res

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find sum of odd factors of a number. import math def sum_of_odd_Factors(n): res = 1 while n % 2 == 0: n = n // 2 for i in range(3,int(math.sqrt(n) + 1)): count = 0 curr_sum = 1 curr_term = 1 while n % i == 0: count+=1 n = n // i curr_term *= i curr_sum += curr_term res *= curr_sum if n >= 2: res *= (1 + n) return res [/INST]assert sum_of_odd_Factors(30) == 24 assert sum_of_odd_Factors(18) == 13 assert sum_of_odd_Factors(2) == 1</s>

Write a function which accepts an arbitrary list and converts it to a heap using heap queue algorithm.

import heapq as hq def raw_heap(rawheap): hq.heapify(rawheap) return rawheap

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function which accepts an arbitrary list and converts it to a heap using heap queue algorithm. import heapq as hq def raw_heap(rawheap): hq.heapify(rawheap) return rawheap[/INST]assert raw_heap([25, 44, 68, 21, 39, 23, 89])==[21, 25, 23, 44, 39, 68, 89] assert raw_heap([25, 35, 22, 85, 14, 65, 75, 25, 58])== [14, 25, 22, 25, 35, 65, 75, 85, 58] assert raw_heap([4, 5, 6, 2])==[2, 4, 6, 5]</s>

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

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

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check for even parity of a given number. def check_Even_Parity(x): parity = 0 while (x != 0): x = x & (x - 1) parity += 1 if (parity % 2 == 0): return True else: return False[/INST]assert check_Even_Parity(10) == True assert check_Even_Parity(11) == False assert check_Even_Parity(18) == True</s>

Write a python function to find minimum adjacent swaps required to sort binary array.

def find_Min_Swaps(arr,n) : noOfZeroes = [0] * n count = 0 noOfZeroes[n - 1] = 1 - arr[n - 1] for i in range(n-2,-1,-1) : noOfZeroes[i] = noOfZeroes[i + 1] if (arr[i] == 0) : noOfZeroes[i] = noOfZeroes[i] + 1 for i in range(0,n) : if (arr[i] == 1) : count = count + noOfZeroes[i] return count

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find minimum adjacent swaps required to sort binary array. def find_Min_Swaps(arr,n) : noOfZeroes = [0] * n count = 0 noOfZeroes[n - 1] = 1 - arr[n - 1] for i in range(n-2,-1,-1) : noOfZeroes[i] = noOfZeroes[i + 1] if (arr[i] == 0) : noOfZeroes[i] = noOfZeroes[i] + 1 for i in range(0,n) : if (arr[i] == 1) : count = count + noOfZeroes[i] return count [/INST]assert find_Min_Swaps([1,0,1,0],4) == 3 assert find_Min_Swaps([0,1,0],3) == 1 assert find_Min_Swaps([0,0,1,1,0],5) == 2</s>

Write a function to list out the list of given strings individually using map function.

def listify_list(list1): result = list(map(list,list1)) return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to list out the list of given strings individually using map function. def listify_list(list1): result = list(map(list,list1)) return result [/INST]assert listify_list(['Red', 'Blue', 'Black', 'White', 'Pink'])==[['R', 'e', 'd'], ['B', 'l', 'u', 'e'], ['B', 'l', 'a', 'c', 'k'], ['W', 'h', 'i', 't', 'e'], ['P', 'i', 'n', 'k']] assert listify_list(['python'])==[['p', 'y', 't', 'h', 'o', 'n']] assert listify_list([' red ', 'green',' black', 'blue ',' orange', 'brown'])==[[' ', 'r', 'e', 'd', ' '], ['g', 'r', 'e', 'e', 'n'], [' ', 'b', 'l', 'a', 'c', 'k'], ['b', 'l', 'u', 'e', ' '], [' ', 'o', 'r', 'a', 'n', 'g', 'e'], ['b', 'r', 'o', 'w', 'n']]</s>

Write a function to count number of lists in a given list of lists and square the count.

def count_list(input_list): return (len(input_list))**2

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to count number of lists in a given list of lists and square the count. def count_list(input_list): return (len(input_list))**2[/INST]assert count_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==25 assert count_list([[1, 3], [5, 7], [9, 11], [13, 15, 17]] )==16 assert count_list([[2, 4], [[6,8], [4,5,8]], [10, 12, 14]])==9</s>

Write a function to generate all sublists of a given list.

from itertools import combinations def sub_lists(my_list): subs = [] for i in range(0, len(my_list)+1): temp = [list(x) for x in combinations(my_list, i)] if len(temp)>0: subs.extend(temp) return subs

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to generate all sublists of a given list. from itertools import combinations def sub_lists(my_list): subs = [] for i in range(0, len(my_list)+1): temp = [list(x) for x in combinations(my_list, i)] if len(temp)>0: subs.extend(temp) return subs[/INST]assert sub_lists([10, 20, 30, 40])==[[], [10], [20], [30], [40], [10, 20], [10, 30], [10, 40], [20, 30], [20, 40], [30, 40], [10, 20, 30], [10, 20, 40], [10, 30, 40], [20, 30, 40], [10, 20, 30, 40]] assert sub_lists(['X', 'Y', 'Z'])==[[], ['X'], ['Y'], ['Z'], ['X', 'Y'], ['X', 'Z'], ['Y', 'Z'], ['X', 'Y', 'Z']] assert sub_lists([1,2,3])==[[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]</s>

Write a function to check whether the given string is ending with only alphanumeric characters or not using regex.

import re regex = '[a-zA-z0-9]$' def check_alphanumeric(string): if(re.search(regex, string)): return ("Accept") else: return ("Discard")

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check whether the given string is ending with only alphanumeric characters or not using regex. import re regex = '[a-zA-z0-9]$' def check_alphanumeric(string): if(re.search(regex, string)): return ("Accept") else: return ("Discard") [/INST]assert check_alphanumeric("dawood@") == 'Discard' assert check_alphanumeric("skdmsam326") == 'Accept' assert check_alphanumeric("cooltricks@") == 'Discard'</s>

Write a function to find all anagrams of a string in a given list of strings using lambda function.

from collections import Counter def anagram_lambda(texts,str): result = list(filter(lambda x: (Counter(str) == Counter(x)), texts)) return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find all anagrams of a string in a given list of strings using lambda function. from collections import Counter def anagram_lambda(texts,str): result = list(filter(lambda x: (Counter(str) == Counter(x)), texts)) return result[/INST]assert anagram_lambda(["bcda", "abce", "cbda", "cbea", "adcb"],"abcd")==['bcda', 'cbda', 'adcb'] assert anagram_lambda(["recitals"," python"], "articles" )==["recitals"] assert anagram_lambda([" keep"," abcdef"," xyz"]," peek")==[" keep"]</s>

Write a function to find the occurrences of n most common words in a given text.

from collections import Counter import re def n_common_words(text,n): words = re.findall('\w+',text) n_common_words= Counter(words).most_common(n) return list(n_common_words)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the occurrences of n most common words in a given text. from collections import Counter import re def n_common_words(text,n): words = re.findall('\w+',text) n_common_words= Counter(words).most_common(n) return list(n_common_words)[/INST]assert n_common_words("python is a programming language",1)==[('python', 1)] assert n_common_words("python is a programming language",1)==[('python', 1)] assert n_common_words("python is a programming language",5)==[('python', 1),('is', 1), ('a', 1), ('programming', 1), ('language', 1)]</s>

Write a function to find the length of the longest sub-sequence such that elements in the subsequences are consecutive integers.

def find_longest_conseq_subseq(arr, n): ans = 0 count = 0 arr.sort() v = [] v.append(arr[0]) for i in range(1, n): if (arr[i] != arr[i - 1]): v.append(arr[i]) for i in range(len(v)): if (i > 0 and v[i] == v[i - 1] + 1): count += 1 else: count = 1 ans = max(ans, count) return ans

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the length of the longest sub-sequence such that elements in the subsequences are consecutive integers. def find_longest_conseq_subseq(arr, n): ans = 0 count = 0 arr.sort() v = [] v.append(arr[0]) for i in range(1, n): if (arr[i] != arr[i - 1]): v.append(arr[i]) for i in range(len(v)): if (i > 0 and v[i] == v[i - 1] + 1): count += 1 else: count = 1 ans = max(ans, count) return ans [/INST]assert find_longest_conseq_subseq([1, 2, 2, 3], 4) == 3 assert find_longest_conseq_subseq([1, 9, 3, 10, 4, 20, 2], 7) == 4 assert find_longest_conseq_subseq([36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42], 11) == 5</s>

Write a function to find palindromes in a given list of strings using lambda function.

def palindrome_lambda(texts): result = list(filter(lambda x: (x == "".join(reversed(x))), texts)) return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find palindromes in a given list of strings using lambda function. def palindrome_lambda(texts): result = list(filter(lambda x: (x == "".join(reversed(x))), texts)) return result[/INST]assert palindrome_lambda(["php", "res", "Python", "abcd", "Java", "aaa"])==['php', 'aaa'] assert palindrome_lambda(["abcd", "Python", "abba", "aba"])==['abba', 'aba'] assert palindrome_lambda(["abcd", "abbccbba", "abba", "aba"])==['abbccbba', 'abba', 'aba']</s>

Write a function to print n-times a list using map function.

def ntimes_list(nums,n): result = map(lambda x:n*x, nums) return list(result)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to print n-times a list using map function. def ntimes_list(nums,n): result = map(lambda x:n*x, nums) return list(result)[/INST]assert ntimes_list([1, 2, 3, 4, 5, 6, 7],3)==[3, 6, 9, 12, 15, 18, 21] assert ntimes_list([1, 2, 3, 4, 5, 6, 7],4)==[4, 8, 12, 16, 20, 24, 28] assert ntimes_list([1, 2, 3, 4, 5, 6, 7],10)==[10, 20, 30, 40, 50, 60, 70]</s>

Write a function to check whether the given month name contains 31 days or not.

def check_monthnumb(monthname2): if(monthname2=="January" or monthname2=="March"or monthname2=="May" or monthname2=="July" or monthname2=="Augest" or monthname2=="October" or monthname2=="December"): return True else: return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check whether the given month name contains 31 days or not. def check_monthnumb(monthname2): if(monthname2=="January" or monthname2=="March"or monthname2=="May" or monthname2=="July" or monthname2=="Augest" or monthname2=="October" or monthname2=="December"): return True else: return False[/INST]assert check_monthnumb("February")==False assert check_monthnumb("January")==True assert check_monthnumb("March")==True</s>

Write a python function to add a minimum number such that the sum of array becomes even.

def min_Num(arr,n): odd = 0 for i in range(n): if (arr[i] % 2): odd += 1 if (odd % 2): return 1 return 2

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to add a minimum number such that the sum of array becomes even. def min_Num(arr,n): odd = 0 for i in range(n): if (arr[i] % 2): odd += 1 if (odd % 2): return 1 return 2[/INST]assert min_Num([1,2,3,4,5,6,7,8,9],9) == 1 assert min_Num([1,2,3,4,5,6,7,8],8) == 2 assert min_Num([1,2,3],3) == 2</s>

Write a python function to find the length of the last word in a given string.

def length_Of_Last_Word(a): l = 0 x = a.strip() for i in range(len(x)): if x[i] == " ": l = 0 else: l += 1 return l

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find the length of the last word in a given string. def length_Of_Last_Word(a): l = 0 x = a.strip() for i in range(len(x)): if x[i] == " ": l = 0 else: l += 1 return l [/INST]assert length_Of_Last_Word("python language") == 8 assert length_Of_Last_Word("PHP") == 3 assert length_Of_Last_Word("") == 0</s>

Write a function to remove sublists from a given list of lists, which are outside a given range.

def remove_list_range(list1, leftrange, rigthrange): result = [i for i in list1 if (min(i)>=leftrange and max(i)<=rigthrange)] return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to remove sublists from a given list of lists, which are outside a given range. def remove_list_range(list1, leftrange, rigthrange): result = [i for i in list1 if (min(i)>=leftrange and max(i)<=rigthrange)] return result[/INST]assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],13,17)==[[13, 14, 15, 17]] assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],1,3)==[[2], [1, 2, 3]] assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],0,7)==[[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7]]</s>

Write a function to calculate the sum of the positive numbers of a given list of numbers using lambda function.

def sum_positivenum(nums): sum_positivenum = list(filter(lambda nums:nums>0,nums)) return sum(sum_positivenum)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to calculate the sum of the positive numbers of a given list of numbers using lambda function. def sum_positivenum(nums): sum_positivenum = list(filter(lambda nums:nums>0,nums)) return sum(sum_positivenum)[/INST]assert sum_positivenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==48 assert sum_positivenum([10,15,-14,13,-18,12,-20])==50 assert sum_positivenum([19, -65, 57, 39, 152,-639, 121, 44, 90, -190])==522</s>

Write a python function to check whether the given strings are rotations of each other or not.

def are_Rotations(string1,string2): size1 = len(string1) size2 = len(string2) temp = '' if size1 != size2: return False temp = string1 + string1 if (temp.count(string2)> 0): return True else: return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the given strings are rotations of each other or not. def are_Rotations(string1,string2): size1 = len(string1) size2 = len(string2) temp = '' if size1 != size2: return False temp = string1 + string1 if (temp.count(string2)> 0): return True else: return False[/INST]assert are_Rotations("abc","cba") == False assert are_Rotations("abcd","cdba") == False assert are_Rotations("abacd","cdaba") == True</s>

Write a function to check if a nested list is a subset of another nested list.

def check_subset(list1,list2): return all(map(list1.__contains__,list2))

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check if a nested list is a subset of another nested list. def check_subset(list1,list2): return all(map(list1.__contains__,list2)) [/INST]assert check_subset([[1, 3], [5, 7], [9, 11], [13, 15, 17]] ,[[1, 3],[13,15,17]])==True assert check_subset([[1, 2], [2, 3], [3, 4], [5, 6]],[[3, 4], [5, 6]])==True assert check_subset([[[1, 2], [2, 3]], [[3, 4], [5, 7]]],[[[3, 4], [5, 6]]])==False</s>

Write a function to solve the fibonacci sequence using recursion.

def fibonacci(n): if n == 1 or n == 2: return 1 else: return (fibonacci(n - 1) + (fibonacci(n - 2)))

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to solve the fibonacci sequence using recursion. def fibonacci(n): if n == 1 or n == 2: return 1 else: return (fibonacci(n - 1) + (fibonacci(n - 2)))[/INST]assert fibonacci(7) == 13 assert fibonacci(8) == 21 assert fibonacci(9) == 34</s>

Write a python function to check if the string is a concatenation of another string.

def check_Concat(str1,str2): N = len(str1) M = len(str2) if (N % M != 0): return False for i in range(N): if (str1[i] != str2[i % M]): return False return True

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check if the string is a concatenation of another string. def check_Concat(str1,str2): N = len(str1) M = len(str2) if (N % M != 0): return False for i in range(N): if (str1[i] != str2[i % M]): return False return True[/INST]assert check_Concat("abcabcabc","abc") == True assert check_Concat("abcab","abc") == False assert check_Concat("aba","ab") == False</s>

Write a function to find the minimum difference in the tuple pairs of given tuples.

def min_difference(test_list): temp = [abs(b - a) for a, b in test_list] res = min(temp) return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the minimum difference in the tuple pairs of given tuples. def min_difference(test_list): temp = [abs(b - a) for a, b in test_list] res = min(temp) return (res) [/INST]assert min_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 1 assert min_difference([(4, 6), (12, 8), (11, 4), (2, 13)]) == 2 assert min_difference([(5, 17), (3, 9), (12, 5), (3, 24)]) == 6</s>

Write a python function to find lcm of two positive integers.

def lcm(x, y): if x > y: z = x else: z = y while(True): if((z % x == 0) and (z % y == 0)): lcm = z break z += 1 return lcm

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find lcm of two positive integers. def lcm(x, y): if x > y: z = x else: z = y while(True): if((z % x == 0) and (z % y == 0)): lcm = z break z += 1 return lcm[/INST]assert lcm(4,6) == 12 assert lcm(15,17) == 255 assert lcm(2,6) == 6</s>

Write a python function to sort the given string.

def sort_String(str) : str = ''.join(sorted(str)) return (str)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to sort the given string. def sort_String(str) : str = ''.join(sorted(str)) return (str) [/INST]assert sort_String("cba") == "abc" assert sort_String("data") == "aadt" assert sort_String("zxy") == "xyz"</s>

Write a function to check if the given tuple contains only k elements.

def check_tuples(test_tuple, K): res = all(ele in K for ele in test_tuple) return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to check if the given tuple contains only k elements. def check_tuples(test_tuple, K): res = all(ele in K for ele in test_tuple) return (res) [/INST]assert check_tuples((3, 5, 6, 5, 3, 6),[3, 6, 5]) == True assert check_tuples((4, 5, 6, 4, 6, 5),[4, 5, 6]) == True assert check_tuples((9, 8, 7, 6, 8, 9),[9, 8, 1]) == False</s>

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

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

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function that matches a string that has an 'a' followed by anything, ending in 'b' by using regex. import re def text_match(text): patterns = 'a.*?b$' if re.search(patterns, text): return ('Found a match!') else: return ('Not matched!')[/INST]assert text_match("aabbbbd") == 'Not matched!' assert text_match("aabAbbbc") == 'Not matched!' assert text_match("accddbbjjjb") == 'Found a match!'</s>

Write a python function to find number of solutions in quadratic equation.

def Check_Solution(a,b,c) : if ((b*b) - (4*a*c)) > 0 : return ("2 solutions") elif ((b*b) - (4*a*c)) == 0 : return ("1 solution") else : return ("No solutions")

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find number of solutions in quadratic equation. def Check_Solution(a,b,c) : if ((b*b) - (4*a*c)) > 0 : return ("2 solutions") elif ((b*b) - (4*a*c)) == 0 : return ("1 solution") else : return ("No solutions") [/INST]assert Check_Solution(2,5,2) == "2 solutions" assert Check_Solution(1,1,1) == "No solutions" assert Check_Solution(1,2,1) == "1 solution"</s>

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

def sum_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]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the sum of first even and odd number of a given list. def sum_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]assert sum_even_odd([1,3,5,7,4,1,6,8])==5 assert sum_even_odd([1,2,3,4,5,6,7,8,9,10])==3 assert sum_even_odd([1,5,7,9,10])==11</s>

Write a function to caluclate perimeter of a parallelogram.

def parallelogram_perimeter(b,h): perimeter=2*(b*h) return perimeter

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to caluclate perimeter of a parallelogram. def parallelogram_perimeter(b,h): perimeter=2*(b*h) return perimeter[/INST]assert parallelogram_perimeter(10,20)==400 assert parallelogram_perimeter(15,20)==600 assert parallelogram_perimeter(8,9)==144</s>

Write a function to find numbers divisible by m and n from a list of numbers using lambda function.

def div_of_nums(nums,m,n): result = list(filter(lambda x: (x % m == 0 and x % n == 0), nums)) return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find numbers divisible by m and n from a list of numbers using lambda function. def div_of_nums(nums,m,n): result = list(filter(lambda x: (x % m == 0 and x % n == 0), nums)) return result[/INST]assert div_of_nums([19, 65, 57, 39, 152, 639, 121, 44, 90, 190],2,4)==[ 152,44] assert div_of_nums([1, 2, 3, 5, 7, 8, 10],2,5)==[10] assert div_of_nums([10,15,14,13,18,12,20],10,5)==[10,20]</s>

Write a python function to check whether all the bits are within a given range or not.

def all_Bits_Set_In_The_Given_Range(n,l,r): num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1) new_num = n & num if (num == new_num): return True return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether all the bits are within a given range or not. def all_Bits_Set_In_The_Given_Range(n,l,r): num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1) new_num = n & num if (num == new_num): return True return False[/INST]assert all_Bits_Set_In_The_Given_Range(10,2,1) == True assert all_Bits_Set_In_The_Given_Range(5,2,4) == False assert all_Bits_Set_In_The_Given_Range(22,2,3) == True </s>

Write a python function to check whether the two given strings are isomorphic to each other or not.

def is_Isomorphic(str1,str2): dict_str1 = {} dict_str2 = {} for i, value in enumerate(str1): dict_str1[value] = dict_str1.get(value,[]) + [i] for j, value in enumerate(str2): dict_str2[value] = dict_str2.get(value,[]) + [j] if sorted(dict_str1.values()) == sorted(dict_str2.values()): return True else: return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the two given strings are isomorphic to each other or not. def is_Isomorphic(str1,str2): dict_str1 = {} dict_str2 = {} for i, value in enumerate(str1): dict_str1[value] = dict_str1.get(value,[]) + [i] for j, value in enumerate(str2): dict_str2[value] = dict_str2.get(value,[]) + [j] if sorted(dict_str1.values()) == sorted(dict_str2.values()): return True else: return False[/INST]assert is_Isomorphic("paper","title") == True assert is_Isomorphic("ab","ba") == True assert is_Isomorphic("ab","aa") == False</s>

Write a function to add all the numbers in a list and divide it with the length of the list.

def sum_num(numbers): total = 0 for x in numbers: total += x return total/len(numbers)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to add all the numbers in a list and divide it with the length of the list. def sum_num(numbers): total = 0 for x in numbers: total += x return total/len(numbers) [/INST]assert sum_num((8, 2, 3, 0, 7))==4.0 assert sum_num((-10,-20,-30))==-20.0 assert sum_num((19,15,18))==17.333333333333332</s>

Write a python function to check whether the given number is odd or not using bitwise operator.

def is_odd(n) : if (n^1 == n-1) : return True; else : return False;

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the given number is odd or not using bitwise operator. def is_odd(n) : if (n^1 == n-1) : return True; else : return False; [/INST]assert is_odd(5) == True assert is_odd(6) == False assert is_odd(7) == True</s>

Write a function to substract the elements of the given nested tuples.

def substract_elements(test_tup1, test_tup2): res = tuple(tuple(a - b for a, b in zip(tup1, tup2)) for tup1, tup2 in zip(test_tup1, test_tup2)) return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to substract the elements of the given nested tuples. def substract_elements(test_tup1, test_tup2): res = tuple(tuple(a - b for a, b in zip(tup1, tup2)) for tup1, tup2 in zip(test_tup1, test_tup2)) return (res) [/INST]assert substract_elements(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((-5, -4), (1, -4), (1, 8), (-6, 7)) assert substract_elements(((13, 4), (14, 6), (13, 10), (12, 11)), ((19, 8), (14, 10), (12, 2), (18, 4))) == ((-6, -4), (0, -4), (1, 8), (-6, 7)) assert substract_elements(((19, 5), (18, 7), (19, 11), (17, 12)), ((12, 9), (17, 11), (13, 3), (19, 5))) == ((7, -4), (1, -4), (6, 8), (-2, 7))</s>

Write a function to reverse each list in a given list of lists.

def reverse_list_lists(lists): for l in lists: l.sort(reverse = True) return lists

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to reverse each list in a given list of lists. def reverse_list_lists(lists): for l in lists: l.sort(reverse = True) return lists [/INST]assert reverse_list_lists([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])==[[4, 3, 2, 1], [8, 7, 6, 5], [12, 11, 10, 9], [16, 15, 14, 13]] assert reverse_list_lists([[1,2],[2,3],[3,4]])==[[2,1],[3,2],[4,3]] assert reverse_list_lists([[10,20],[30,40]])==[[20,10],[40,30]]</s>

Write a python function to find the index of an extra element present in one sorted array.

def find_Extra(arr1,arr2,n) : for i in range(0, n) : if (arr1[i] != arr2[i]) : return i return n

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to find the index of an extra element present in one sorted array. def find_Extra(arr1,arr2,n) : for i in range(0, n) : if (arr1[i] != arr2[i]) : return i return n [/INST]assert find_Extra([1,2,3,4],[1,2,3],3) == 3 assert find_Extra([2,4,6,8,10],[2,4,6,8],4) == 4 assert find_Extra([1,3,5,7,9,11],[1,3,5,7,9],5) == 5</s>

Write a python function to check whether the given two numbers have same number of digits or not.

def same_Length(A,B): while (A > 0 and B > 0): A = A / 10; B = B / 10; if (A == 0 and B == 0): return True; return False;

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the given two numbers have same number of digits or not. def same_Length(A,B): while (A > 0 and B > 0): A = A / 10; B = B / 10; if (A == 0 and B == 0): return True; return False; [/INST]assert same_Length(12,1) == False assert same_Length(2,2) == True assert same_Length(10,20) == True</s>

Write a function to remove multiple spaces in a string.

import re def remove_spaces(text): return (re.sub(' +',' ',text))

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to remove multiple spaces in a string. import re def remove_spaces(text): return (re.sub(' +',' ',text))[/INST]assert remove_spaces('python program')==('python program') assert remove_spaces('python programming language')==('python programming language') assert remove_spaces('python program')==('python program')</s>

Write a python function to get the last element of each sublist.

def Extract(lst): return [item[-1] for item in lst]

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to get the last element of each sublist. def Extract(lst): return [item[-1] for item in lst] [/INST]assert Extract([[1, 2, 3], [4, 5], [6, 7, 8, 9]]) == [3, 5, 9] assert Extract([['x', 'y', 'z'], ['m'], ['a', 'b'], ['u', 'v']]) == ['z', 'm', 'b', 'v'] assert Extract([[1, 2, 3], [4, 5]]) == [3, 5]</s>

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

def float_to_tuple(test_str): res = tuple(map(float, test_str.split(', '))) return (res)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to convert the given string of float type into tuple. def float_to_tuple(test_str): res = tuple(map(float, test_str.split(', '))) return (res) [/INST]assert float_to_tuple("1.2, 1.3, 2.3, 2.4, 6.5") == (1.2, 1.3, 2.3, 2.4, 6.5) assert float_to_tuple("2.3, 2.4, 5.6, 5.4, 8.9") == (2.3, 2.4, 5.6, 5.4, 8.9) assert float_to_tuple("0.3, 0.5, 7.8, 9.4") == (0.3, 0.5, 7.8, 9.4)</s>

Write a function to find the maximum sum of subsequences of given array with no adjacent elements.

def max_sum_subseq(A): n = len(A) if n == 1: return A[0] look_up = [None] * n look_up[0] = A[0] look_up[1] = max(A[0], A[1]) for i in range(2, n): look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i]) look_up[i] = max(look_up[i], A[i]) return look_up[n - 1]

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to find the maximum sum of subsequences of given array with no adjacent elements. def max_sum_subseq(A): n = len(A) if n == 1: return A[0] look_up = [None] * n look_up[0] = A[0] look_up[1] = max(A[0], A[1]) for i in range(2, n): look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i]) look_up[i] = max(look_up[i], A[i]) return look_up[n - 1][/INST]assert max_sum_subseq([1, 2, 9, 4, 5, 0, 4, 11, 6]) == 26 assert max_sum_subseq([1, 2, 9, 5, 6, 0, 5, 12, 7]) == 28 assert max_sum_subseq([1, 3, 10, 5, 6, 0, 6, 14, 21]) == 44</s>

Write a function to sort a list in increasing order by the last element in each tuple from a given list of non-empty tuples.

def last(n): return n[-1] def sort_list_last(tuples): return sorted(tuples, key=last)

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to sort a list in increasing order by the last element in each tuple from a given list of non-empty tuples. def last(n): return n[-1] def sort_list_last(tuples): return sorted(tuples, key=last)[/INST]assert sort_list_last([(2, 5), (1, 2), (4, 4), (2, 3), (2, 1)])==[(2, 1), (1, 2), (2, 3), (4, 4), (2, 5)] assert sort_list_last([(9,8), (4, 7), (3,5), (7,9), (1,2)])==[(1,2), (3,5), (4,7), (9,8), (7,9)] assert sort_list_last([(20,50), (10,20), (40,40)])==[(10,20),(40,40),(20,50)] </s>

Write a python function to check whether the word is present in a given sentence or not.

def is_Word_Present(sentence,word): s = sentence.split(" ") for i in s: if (i == word): return True return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether the word is present in a given sentence or not. def is_Word_Present(sentence,word): s = sentence.split(" ") for i in s: if (i == word): return True return False[/INST]assert is_Word_Present("machine learning","machine") == True assert is_Word_Present("easy","fun") == False assert is_Word_Present("python language","code") == False</s>

Write a function to extract specified number of elements from a given list, which follow each other continuously.

from itertools import groupby def extract_elements(numbers, n): result = [i for i, j in groupby(numbers) if len(list(j)) == n] return result

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function to extract specified number of elements from a given list, which follow each other continuously. from itertools import groupby def extract_elements(numbers, n): result = [i for i, j in groupby(numbers) if len(list(j)) == n] return result[/INST]assert extract_elements([1, 1, 3, 4, 4, 5, 6, 7],2)==[1, 4] assert extract_elements([0, 1, 2, 3, 4, 4, 4, 4, 5, 7],4)==[4] assert extract_elements([0,0,0,0,0],5)==[0]</s>

Write a python function to check whether an array can be sorted or not by picking only the corner elements.

def check(arr,n): g = 0 for i in range(1,n): if (arr[i] - arr[i - 1] > 0 and g == 1): return False if (arr[i] - arr[i] < 0): g = 1 return True

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a python function to check whether an array can be sorted or not by picking only the corner elements. def check(arr,n): g = 0 for i in range(1,n): if (arr[i] - arr[i - 1] > 0 and g == 1): return False if (arr[i] - arr[i] < 0): g = 1 return True[/INST]assert check([3,2,1,2,3,4],6) == True assert check([2,1,4,5,1],5) == True assert check([1,2,2,1,2,3],6) == True</s>

Write a function where a string will start with a specific number.

import re def match_num(string): text = re.compile(r"^5") if text.match(string): return True else: return False

<s>[INST]<<SYS>>Given a task and its code, generate test cases for the code.<</SYS>>Write a function where a string will start with a specific number. import re def match_num(string): text = re.compile(r"^5") if text.match(string): return True else: return False[/INST]assert match_num('5-2345861')==True assert match_num('6-2345861')==False assert match_num('78910')==False</s>