Datasets:

Pav17

/

T3-gen-dataset-2

like 0

Write a function to find the smallest multiple of the first n numbers.

def smallest_multiple(n): if (n<=2): return n i = n * 2 factors = [number for number in range(n, 1, -1) if number * 2 > n] while True: for a in factors: if i % a != 0: i += n break if (a == factors[-1] and i % a == 0): return i

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the smallest multiple of the first n numbers.[/INST][TESTS] Test case #1 assert smallest_multiple(13)==360360 Test case #2 assert smallest_multiple(2)==2 Test case #3 assert smallest_multiple(1)==1 [/TESTS]</s>

Write a function to combine two dictionaries by adding values for common keys.

from collections import Counter def add_dict(d1,d2): add_dict = Counter(d1) + Counter(d2) return add_dict

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to combine two dictionaries by adding values for common keys.[/INST][TESTS] Test case #1 assert add_dict({'a': 100, 'b': 200, 'c':300},{'a': 300, 'b': 200, 'd':400})==({'b': 400, 'd': 400, 'a': 400, 'c': 300}) Test case #2 assert add_dict({'a': 500, 'b': 700, 'c':900},{'a': 500, 'b': 600, 'd':900})==({'b': 1300, 'd': 900, 'a': 1000, 'c': 900}) Test case #3 assert add_dict({'a':900,'b':900,'d':900},{'a':900,'b':900,'d':900})==({'b': 1800, 'd': 1800, 'a': 1800}) [/TESTS]</s>

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

def count_Unset_Bits(n) : cnt = 0; for i in range(1,n + 1) : temp = i; while (temp) : if (temp % 2 == 0) : cnt += 1; temp = temp // 2; return cnt;

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to count the total unset bits from 1 to n.[/INST][TESTS] Test case #1 assert count_Unset_Bits(2) == 1 Test case #2 assert count_Unset_Bits(5) == 4 Test case #3 assert count_Unset_Bits(14) == 17 [/TESTS]</s>

Write a function to return true if the given number is even else return false.

def even_num(x): if x%2==0: return True else: return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to return true if the given number is even else return false.[/INST][TESTS] Test case #1 assert even_num(13.5)==False Test case #2 assert even_num(0)==True Test case #3 assert even_num(-9)==False [/TESTS]</s>

Write a python function to find the sum of squares of binomial co-efficients.

def factorial(start,end): res = 1 for i in range(start,end + 1): res *= i return res def sum_of_square(n): return int(factorial(n + 1, 2 * n) /factorial(1, n))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to find the sum of squares of binomial co-efficients.[/INST][TESTS] Test case #1 assert sum_of_square(4) == 70 Test case #2 assert sum_of_square(5) == 252 Test case #3 assert sum_of_square(2) == 6 [/TESTS]</s>

Write a function to extract year, month and date from a url by using regex.

import re def extract_date(url): return re.findall(r'/(\d{4})/(\d{1,2})/(\d{1,2})/', url)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to extract year, month and date from a url by using regex.[/INST][TESTS] Test case #1 assert extract_date("https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/") == [('2016', '09', '02')] Test case #2 assert extract_date("https://www.indiatoday.in/movies/celebrities/story/wp/2020/11/03/odeof-sushant-singh-rajput-s-death-his-brother-in-law-shares-advice-for-fans-1749646/") == [('2020', '11', '03')] Test case #3 assert extract_date("https://economictimes.indiatimes.com/news/economy/2020/12/29/finance/pension-assets-under-pfrda-touch-rs-5-32-lakh-crore/articleshow/79736619.cms") == [('2020', '12', '29')] [/TESTS]</s>

Write a function to print the first n lucky numbers.

def lucky_num(n): List=range(-1,n*n+9,2) i=2 while List[i:]:List=sorted(set(List)-set(List[List[i]::List[i]]));i+=1 return List[1:n+1]

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to print the first n lucky numbers.[/INST][TESTS] Test case #1 assert lucky_num(10)==[1, 3, 7, 9, 13, 15, 21, 25, 31, 33] Test case #2 assert lucky_num(5)==[1, 3, 7, 9, 13] Test case #3 assert lucky_num(8)==[1, 3, 7, 9, 13, 15, 21, 25] [/TESTS]</s>

Write a function to find the fixed point in the given array.

def find_fixed_point(arr, n): for i in range(n): if arr[i] is i: return i return -1

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the fixed point in the given array.[/INST][TESTS] Test case #1 assert find_fixed_point([-10, -1, 0, 3, 10, 11, 30, 50, 100],9) == 3 Test case #2 assert find_fixed_point([1, 2, 3, 4, 5, 6, 7, 8],8) == -1 Test case #3 assert find_fixed_point([0, 2, 5, 8, 17],5) == 0 [/TESTS]</s>

Write a function to find the previous palindrome of a specified number.

def previous_palindrome(num): for x in range(num-1,0,-1): if str(x) == str(x)[::-1]: return x

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the previous palindrome of a specified number.[/INST][TESTS] Test case #1 assert previous_palindrome(99)==88 Test case #2 assert previous_palindrome(1221)==1111 Test case #3 assert previous_palindrome(120)==111 [/TESTS]</s>

Write a function to validate a gregorian date.

import datetime def check_date(m, d, y): try: m, d, y = map(int, (m, d, y)) datetime.date(y, m, d) return True except ValueError: return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to validate a gregorian date.[/INST][TESTS] Test case #1 assert check_date(11,11,2002)==True Test case #2 assert check_date(13,11,2002)==False Test case #3 assert check_date('11','11','2002')==True [/TESTS]</s>

Write a function to compute maximum product of three numbers of a given array of integers using heap queue algorithm.

def maximum_product(nums): import heapq a, b = heapq.nlargest(3, nums), heapq.nsmallest(2, nums) return max(a[0] * a[1] * a[2], a[0] * b[0] * b[1])

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to compute maximum product of three numbers of a given array of integers using heap queue algorithm.[/INST][TESTS] Test case #1 assert maximum_product( [12, 74, 9, 50, 61, 41])==225700 Test case #2 assert maximum_product([25, 35, 22, 85, 14, 65, 75, 25, 58])==414375 Test case #3 assert maximum_product([18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1])==2520 [/TESTS]</s>

Write a function to find ln, m lobb number.

def binomial_coeff(n, k): C = [[0 for j in range(k + 1)] for i in range(n + 1)] for i in range(0, n + 1): for j in range(0, min(i, k) + 1): if (j == 0 or j == i): C[i][j] = 1 else: C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) return C[n][k] def lobb_num(n, m): return (((2 * m + 1) * binomial_coeff(2 * n, m + n)) / (m + n + 1))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find ln, m lobb number.[/INST][TESTS] Test case #1 assert int(lobb_num(5, 3)) == 35 Test case #2 assert int(lobb_num(3, 2)) == 5 Test case #3 assert int(lobb_num(4, 2)) == 20 [/TESTS]</s>

Write a function to check for a number at the end of a string.

import re def end_num(string): text = re.compile(r".*[0-9]$") if text.match(string): return True else: return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to check for a number at the end of a string.[/INST][TESTS] Test case #1 assert end_num('abcdef')==False Test case #2 assert end_num('abcdef7')==True Test case #3 assert end_num('abc')==False [/TESTS]</s>

Write a python function to check whether the given string is made up of two alternating characters or not.

def is_Two_Alter(s): for i in range (len( s) - 2) : if (s[i] != s[i + 2]) : return False if (s[0] == s[1]): return False return True

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to check whether the given string is made up of two alternating characters or not.[/INST][TESTS] Test case #1 assert is_Two_Alter("abab") == True Test case #2 assert is_Two_Alter("aaaa") == False Test case #3 assert is_Two_Alter("xyz") == False [/TESTS]</s>

Write a function to rearrange positive and negative numbers in a given array using lambda function.

def rearrange_numbs(array_nums): result = sorted(array_nums, key = lambda i: 0 if i == 0 else -1 / i) return result

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to rearrange positive and negative numbers in a given array using lambda function.[/INST][TESTS] Test case #1 assert rearrange_numbs([-1, 2, -3, 5, 7, 8, 9, -10])==[2, 5, 7, 8, 9, -10, -3, -1] Test case #2 assert rearrange_numbs([10,15,14,13,-18,12,-20])==[10, 12, 13, 14, 15, -20, -18] Test case #3 assert rearrange_numbs([-20,20,-10,10,-30,30])==[10, 20, 30, -30, -20, -10] [/TESTS]</s>

Write a function to find if there is a triplet in the array whose sum is equal to a given value.

def find_triplet_array(A, arr_size, sum): for i in range( 0, arr_size-2): for j in range(i + 1, arr_size-1): for k in range(j + 1, arr_size): if A[i] + A[j] + A[k] == sum: return A[i],A[j],A[k] return True return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find if there is a triplet in the array whose sum is equal to a given value.[/INST][TESTS] Test case #1 assert find_triplet_array([1, 4, 45, 6, 10, 8], 6, 22) == (4, 10, 8) Test case #2 assert find_triplet_array([12, 3, 5, 2, 6, 9], 6, 24) == (12, 3, 9) Test case #3 assert find_triplet_array([1, 2, 3, 4, 5], 5, 9) == (1, 3, 5) [/TESTS]</s>

Write a function to find the sequences of one upper case letter followed by lower case letters.

import re def text_uppercase_lowercase(text): patterns = '[A-Z]+[a-z]+$' 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 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the sequences of one upper case letter followed by lower case letters.[/INST][TESTS] Test case #1 assert text_uppercase_lowercase("AaBbGg")==('Found a match!') Test case #2 assert text_uppercase_lowercase("aA")==('Not matched!') Test case #3 assert text_uppercase_lowercase("PYTHON")==('Not matched!') [/TESTS]</s>

Write a function to count coin change.

def coin_change(S, m, n): table = [[0 for x in range(m)] for x in range(n+1)] for i in range(m): table[0][i] = 1 for i in range(1, n+1): for j in range(m): x = table[i - S[j]][j] if i-S[j] >= 0 else 0 y = table[i][j-1] if j >= 1 else 0 table[i][j] = x + y return table[n][m-1]

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to count coin change.[/INST][TESTS] Test case #1 assert coin_change([1, 2, 3],3,4)==4 Test case #2 assert coin_change([4,5,6,7,8,9],6,9)==2 Test case #3 assert coin_change([4,5,6,7,8,9],6,4)==1 [/TESTS]</s>

Write a python function to multiply all items in the list.

def multiply_list(items): tot = 1 for x in items: tot *= x return tot

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to multiply all items in the list.[/INST][TESTS] Test case #1 assert multiply_list([1,-2,3]) == -6 Test case #2 assert multiply_list([1,2,3,4]) == 24 Test case #3 assert multiply_list([3,1,2,3]) == 18 [/TESTS]</s>

Write a function to remove all tuples with all none values in the given tuple list.

def remove_tuple(test_list): res = [sub for sub in test_list if not all(ele == None for ele in sub)] return (str(res))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to remove all tuples with all none values in the given tuple list.[/INST][TESTS] Test case #1 assert remove_tuple([(None, 2), (None, None), (3, 4), (12, 3), (None, )] ) == '[(None, 2), (3, 4), (12, 3)]' Test case #2 assert remove_tuple([(None, None), (None, None), (3, 6), (17, 3), (None,1 )] ) == '[(3, 6), (17, 3), (None, 1)]' Test case #3 assert remove_tuple([(1, 2), (2, None), (3, None), (24, 3), (None, None )] ) == '[(1, 2), (2, None), (3, None), (24, 3)]' [/TESTS]</s>

Write a function to perform chunking of tuples each of size n.

def chunk_tuples(test_tup, N): res = [test_tup[i : i + N] for i in range(0, len(test_tup), N)] return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to perform chunking of tuples each of size n.[/INST][TESTS] Test case #1 assert chunk_tuples((10, 4, 5, 6, 7, 6, 8, 3, 4), 3) == [(10, 4, 5), (6, 7, 6), (8, 3, 4)] Test case #2 assert chunk_tuples((1, 2, 3, 4, 5, 6, 7, 8, 9), 2) == [(1, 2), (3, 4), (5, 6), (7, 8), (9,)] Test case #3 assert chunk_tuples((11, 14, 16, 17, 19, 21, 22, 25), 4) == [(11, 14, 16, 17), (19, 21, 22, 25)] [/TESTS]</s>

Write a function to find a pair with the highest product from a given array of integers.

def max_product(arr): arr_len = len(arr) if (arr_len < 2): return None x = arr[0]; y = arr[1] for i in range(0, arr_len): for j in range(i + 1, arr_len): if (arr[i] * arr[j] > x * y): x = arr[i]; y = arr[j] return x,y

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find a pair with the highest product from a given array of integers.[/INST][TESTS] Test case #1 assert max_product([1, 2, 3, 4, 7, 0, 8, 4])==(7, 8) Test case #2 assert max_product([0, -1, -2, -4, 5, 0, -6])==(-4, -6) Test case #3 assert max_product([1, 3, 5, 6, 8, 9])==(8,9) [/TESTS]</s>

Write a function to find the length of the shortest string that has both str1 and str2 as subsequences.

def super_seq(X, Y, m, n): if (not m): return n if (not n): return m if (X[m - 1] == Y[n - 1]): return 1 + super_seq(X, Y, m - 1, n - 1) return 1 + min(super_seq(X, Y, m - 1, n), super_seq(X, Y, m, n - 1))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the length of the shortest string that has both str1 and str2 as subsequences.[/INST][TESTS] Test case #1 assert super_seq("AGGTAB", "GXTXAYB", 6, 7) == 9 Test case #2 assert super_seq("feek", "eke", 4, 3) == 5 Test case #3 assert super_seq("PARRT", "RTA", 5, 3) == 6 [/TESTS]</s>

Write a function to find maximum of two numbers.

def max_of_two( x, y ): if x > y: return x return y

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find maximum of two numbers.[/INST][TESTS] Test case #1 assert max_of_two(10,20)==20 Test case #2 assert max_of_two(19,15)==19 Test case #3 assert max_of_two(-10,-20)==-10 [/TESTS]</s>

Write a python function to calculate the product of all the numbers of a given tuple.

def mutiple_tuple(nums): temp = list(nums) product = 1 for x in temp: product *= x return product

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to calculate the product of all the numbers of a given tuple.[/INST][TESTS] Test case #1 assert mutiple_tuple((4, 3, 2, 2, -1, 18)) == -864 Test case #2 assert mutiple_tuple((1,2,3)) == 6 Test case #3 assert mutiple_tuple((-2,-4,-6)) == -48 [/TESTS]</s>

Write a function to find n-th rencontres number.

def binomial_coeffi(n, k): if (k == 0 or k == n): return 1 return (binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k)) def rencontres_number(n, m): if (n == 0 and m == 0): return 1 if (n == 1 and m == 0): return 0 if (m == 0): return ((n - 1) * (rencontres_number(n - 1, 0)+ rencontres_number(n - 2, 0))) return (binomial_coeffi(n, m) * rencontres_number(n - m, 0))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find n-th rencontres number.[/INST][TESTS] Test case #1 assert rencontres_number(7, 2) == 924 Test case #2 assert rencontres_number(3, 0) == 2 Test case #3 assert rencontres_number(3, 1) == 3 [/TESTS]</s>

Write a function to calculate the height of the given binary tree.

class Node: def __init__(self, data): self.data = data self.left = None self.right = None def max_height(node): if node is None: return 0 ; else : left_height = max_height(node.left) right_height = max_height(node.right) if (left_height > right_height): return left_height+1 else: return right_height+1

root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) root1 = Node(1); root1.left = Node(2); root1.right = Node(3); root1.left.left = Node(4); root1.right.left = Node(5); root1.right.right = Node(6); root1.right.right.right= Node(7); root1.right.right.right.right = Node(8) root2 = Node(1) root2.left = Node(2) root2.right = Node(3) root2.left.left = Node(4) root2.left.right = Node(5) root2.left.left.left = Node(6) root2.left.left.right = Node(7)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to calculate the height of the given binary tree.[/INST][TESTS] Test case #1 assert (max_height(root)) == 3 Test case #2 assert (max_height(root1)) == 5 Test case #3 assert (max_height(root2)) == 4 [/TESTS]</s>

Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.

import re def change_date_format(dt): return re.sub(r'(\d{4})-(\d{1,2})-(\d{1,2})', '\\3-\\2-\\1', dt) return change_date_format(dt)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.[/INST][TESTS] Test case #1 assert change_date_format('2026-01-02')=='02-01-2026' Test case #2 assert change_date_format('2021-01-04')=='04-01-2021' Test case #3 assert change_date_format('2030-06-06')=='06-06-2030' [/TESTS]</s>

Write a function to count repeated items of a tuple.

def count_tuplex(tuplex,value): count = tuplex.count(value) return count

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to count repeated items of a tuple.[/INST][TESTS] Test case #1 assert count_tuplex((2, 4, 5, 6, 2, 3, 4, 4, 7),4)==3 Test case #2 assert count_tuplex((2, 4, 5, 6, 2, 3, 4, 4, 7),2)==2 Test case #3 assert count_tuplex((2, 4, 7, 7, 7, 3, 4, 4, 7),7)==4 [/TESTS]</s>

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

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 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function that matches a string that has an a followed by zero or more b's by using regex.[/INST][TESTS] Test case #1 assert text_match("msb") == 'Not matched!' Test case #2 assert text_match("a0c") == 'Found a match!' Test case #3 assert text_match("abbc") == 'Found a match!' [/TESTS]</s>

Write a function to calculate the sum of series 1³+2³+3³+….+n³.

import math def sum_series(number): total = 0 total = math.pow((number * (number + 1)) /2, 2) return total

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to calculate the sum of series 1³+2³+3³+….+n³.[/INST][TESTS] Test case #1 assert sum_series(7)==784 Test case #2 assert sum_series(5)==225 Test case #3 assert sum_series(15)==14400 [/TESTS]</s>

Write a function to remove duplicate words from a given list of strings.

def remove_duplic_list(l): temp = [] for x in l: if x not in temp: temp.append(x) return temp

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to remove duplicate words from a given list of strings.[/INST][TESTS] Test case #1 assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises"])==['Python', 'Exercises', 'Practice', 'Solution'] Test case #2 assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises","Java"])==['Python', 'Exercises', 'Practice', 'Solution', 'Java'] Test case #3 assert remove_duplic_list(["Python", "Exercises", "Practice", "Solution", "Exercises","C++","C","C++"])==['Python', 'Exercises', 'Practice', 'Solution','C++','C'] [/TESTS]</s>

Write a function to convert camel case string to snake case string by using regex.

import re def camel_to_snake(text): str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text) return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower()

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to convert camel case string to snake case string by using regex.[/INST][TESTS] Test case #1 assert camel_to_snake('GoogleAssistant') == 'google_assistant' Test case #2 assert camel_to_snake('ChromeCast') == 'chrome_cast' Test case #3 assert camel_to_snake('QuadCore') == 'quad_core' [/TESTS]</s>

Write a function to find the nth delannoy number.

def dealnnoy_num(n, m): if (m == 0 or n == 0) : return 1 return dealnnoy_num(m - 1, n) + dealnnoy_num(m - 1, n - 1) + dealnnoy_num(m, n - 1)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the nth delannoy number.[/INST][TESTS] Test case #1 assert dealnnoy_num(3, 4) == 129 Test case #2 assert dealnnoy_num(3, 3) == 63 Test case #3 assert dealnnoy_num(4, 5) == 681 [/TESTS]</s>

Write a function to calculate the sum of series 1²+2²+3²+….+n².

def series_sum(number): total = 0 total = (number * (number + 1) * (2 * number + 1)) / 6 return total

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to calculate the sum of series 1²+2²+3²+….+n².[/INST][TESTS] Test case #1 assert series_sum(6)==91 Test case #2 assert series_sum(7)==140 Test case #3 assert series_sum(12)==650 [/TESTS]</s>

Write a function to re-arrange the given tuples based on the given ordered list.

def re_arrange_tuples(test_list, ord_list): temp = dict(test_list) res = [(key, temp[key]) for key in ord_list] return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to re-arrange the given tuples based on the given ordered list.[/INST][TESTS] Test case #1 assert re_arrange_tuples([(4, 3), (1, 9), (2, 10), (3, 2)], [1, 4, 2, 3]) == [(1, 9), (4, 3), (2, 10), (3, 2)] Test case #2 assert re_arrange_tuples([(5, 4), (2, 10), (3, 11), (4, 3)], [3, 4, 2, 3]) == [(3, 11), (4, 3), (2, 10), (3, 11)] Test case #3 assert re_arrange_tuples([(6, 3), (3, 8), (5, 7), (2, 4)], [2, 5, 3, 6]) == [(2, 4), (5, 7), (3, 8), (6, 3)] [/TESTS]</s>

Write a function to count the most common character in a given string.

from collections import Counter def max_char(str1): temp = Counter(str1) max_char = max(temp, key = temp.get) return max_char

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to count the most common character in a given string.[/INST][TESTS] Test case #1 assert max_char("hello world")==('l') Test case #2 assert max_char("hello ")==('l') Test case #3 assert max_char("python pr")==('p') [/TESTS]</s>

Write a function to find three closest elements from three sorted arrays.

import sys def find_closet(A, B, C, p, q, r): diff = sys.maxsize res_i = 0 res_j = 0 res_k = 0 i = 0 j = 0 k = 0 while(i < p and j < q and k < r): minimum = min(A[i], min(B[j], C[k])) maximum = max(A[i], max(B[j], C[k])); if maximum-minimum < diff: res_i = i res_j = j res_k = k diff = maximum - minimum; if diff == 0: break if A[i] == minimum: i = i+1 elif B[j] == minimum: j = j+1 else: k = k+1 return A[res_i],B[res_j],C[res_k]

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find three closest elements from three sorted arrays.[/INST][TESTS] Test case #1 assert find_closet([1, 4, 10],[2, 15, 20],[10, 12],3,3,2) == (10, 15, 10) Test case #2 assert find_closet([20, 24, 100],[2, 19, 22, 79, 800],[10, 12, 23, 24, 119],3,5,5) == (24, 22, 23) Test case #3 assert find_closet([2, 5, 11],[3, 16, 21],[11, 13],3,3,2) == (11, 16, 11) [/TESTS]</s>

Write a function to sort a list of dictionaries using lambda function.

def sorted_models(models): sorted_models = sorted(models, key = lambda x: x['color']) return sorted_models

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to sort a list of dictionaries using lambda function.[/INST][TESTS] Test case #1 assert sorted_models([{'make':'Nokia', 'model':216, 'color':'Black'}, {'make':'Mi Max', 'model':2, 'color':'Gold'}, {'make':'Samsung', 'model': 7, 'color':'Blue'}])==[{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}, {'make': 'Mi Max', 'model': 2, 'color': 'Gold'}] Test case #2 assert sorted_models([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}])==([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}]) Test case #3 assert sorted_models([{'make':'micromax','model':40,'color':'grey'},{'make':'poco','model':60,'color':'blue'}])==([{'make':'poco','model':60,'color':'blue'},{'make':'micromax','model':40,'color':'grey'}]) [/TESTS]</s>

Write a function to sort the given array by using heap sort.

def heap_sort(arr): heapify(arr) end = len(arr) - 1 while end > 0: arr[end], arr[0] = arr[0], arr[end] shift_down(arr, 0, end - 1) end -= 1 return arr def heapify(arr): start = len(arr) // 2 while start >= 0: shift_down(arr, start, len(arr) - 1) start -= 1 def shift_down(arr, start, end): root = start while root * 2 + 1 <= end: child = root * 2 + 1 if child + 1 <= end and arr[child] < arr[child + 1]: child += 1 if child <= end and arr[root] < arr[child]: arr[root], arr[child] = arr[child], arr[root] root = child else: return

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to sort the given array by using heap sort.[/INST][TESTS] Test case #1 assert heap_sort([12, 2, 4, 5, 2, 3]) == [2, 2, 3, 4, 5, 12] Test case #2 assert heap_sort([32, 14, 5, 6, 7, 19]) == [5, 6, 7, 14, 19, 32] Test case #3 assert heap_sort([21, 15, 29, 78, 65]) == [15, 21, 29, 65, 78] [/TESTS]</s>

Write a function to count the elements in a list until an element is a tuple.

def count_elim(num): count_elim = 0 for n in num: if isinstance(n, tuple): break count_elim += 1 return count_elim

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to count the elements in a list until an element is a tuple.[/INST][TESTS] Test case #1 assert count_elim([10,20,30,(10,20),40])==3 Test case #2 assert count_elim([10,(20,30),(10,20),40])==1 Test case #3 assert count_elim([(10,(20,30,(10,20),40))])==0 [/TESTS]</s>

Write a function to check if any list element is present in the given list.

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

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to check if any list element is present in the given list.[/INST][TESTS] Test case #1 assert check_element((4, 5, 7, 9, 3), [6, 7, 10, 11]) == True Test case #2 assert check_element((1, 2, 3, 4), [4, 6, 7, 8, 9]) == True Test case #3 assert check_element((3, 2, 1, 4, 5), [9, 8, 7, 6]) == False [/TESTS]</s>

Write a function to combine two given sorted lists using heapq module.

from heapq import merge def combine_lists(num1,num2): combine_lists=list(merge(num1, num2)) return combine_lists

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to combine two given sorted lists using heapq module.[/INST][TESTS] Test case #1 assert combine_lists([1, 3, 5, 7, 9, 11],[0, 2, 4, 6, 8, 10])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] Test case #2 assert combine_lists([1, 3, 5, 6, 8, 9], [2, 5, 7, 11])==[1,2,3,5,5,6,7,8,9,11] Test case #3 assert combine_lists([1,3,7],[2,4,6])==[1,2,3,4,6,7] [/TESTS]</s>

Write a function to separate and print the numbers and their position of a given string.

import re def num_position(text): for m in re.finditer("\d+", text): return m.start()

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to separate and print the numbers and their position of a given string.[/INST][TESTS] Test case #1 assert num_position("there are 70 flats in this apartment")==10 Test case #2 assert num_position("every adult have 32 teeth")==17 Test case #3 assert num_position("isha has 79 chocolates in her bag")==9 [/TESTS]</s>

Write a function to convert the given tuples into set.

def tuple_to_set(t): s = set(t) return (s)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to convert the given tuples into set.[/INST][TESTS] Test case #1 assert tuple_to_set(('x', 'y', 'z') ) == {'y', 'x', 'z'} Test case #2 assert tuple_to_set(('a', 'b', 'c') ) == {'c', 'a', 'b'} Test case #3 assert tuple_to_set(('z', 'd', 'e') ) == {'d', 'e', 'z'} [/TESTS]</s>

Write a function to find the most common elements and their counts of a specified text.

from collections import Counter def most_common_elem(s,a): most_common_elem=Counter(s).most_common(a) return most_common_elem

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the most common elements and their counts of a specified text.[/INST][TESTS] Test case #1 assert most_common_elem('lkseropewdssafsdfafkpwe',3)==[('s', 4), ('e', 3), ('f', 3)] Test case #2 assert most_common_elem('lkseropewdssafsdfafkpwe',2)==[('s', 4), ('e', 3)] Test case #3 assert most_common_elem('lkseropewdssafsdfafkpwe',7)==[('s', 4), ('e', 3), ('f', 3), ('k', 2), ('p', 2), ('w', 2), ('d', 2)] [/TESTS]</s>

Write a python function to find the length of the shortest word.

def len_log(list1): min=len(list1[0]) for i in list1: if len(i)<min: min=len(i) return min

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to find the length of the shortest word.[/INST][TESTS] Test case #1 assert len_log(["win","lose","great"]) == 3 Test case #2 assert len_log(["a","ab","abc"]) == 1 Test case #3 assert len_log(["12","12","1234"]) == 2 [/TESTS]</s>

Write a function to get an item of a tuple.

def get_item(tup1,index): item = tup1[index] return item

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to get an item of a tuple.[/INST][TESTS] Test case #1 assert get_item(("w", 3, "r", "e", "s", "o", "u", "r", "c", "e"),3)==('e') Test case #2 assert get_item(("w", 3, "r", "e", "s", "o", "u", "r", "c", "e"),-4)==('u') Test case #3 assert get_item(("w", 3, "r", "e", "s", "o", "u", "r", "c", "e"),-3)==('r') [/TESTS]</s>

Write a function to sort the given tuple list basis the total digits in tuple.

def count_digs(tup): return sum([len(str(ele)) for ele in tup ]) def sort_list(test_list): test_list.sort(key = count_digs) return (str(test_list))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to sort the given tuple list basis the total digits in tuple.[/INST][TESTS] Test case #1 assert sort_list([(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)] ) == '[(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]' Test case #2 assert sort_list([(3, 4, 8), (1, 2), (1234335,), (1345, 234, 334)] ) == '[(1, 2), (3, 4, 8), (1234335,), (1345, 234, 334)]' Test case #3 assert sort_list([(34, 4, 61, 723), (1, 2), (145,), (134, 23)] ) == '[(1, 2), (145,), (134, 23), (34, 4, 61, 723)]' [/TESTS]</s>

Write a function to display sign of the chinese zodiac for given year.

def chinese_zodiac(year): if (year - 2000) % 12 == 0: sign = 'Dragon' elif (year - 2000) % 12 == 1: sign = 'Snake' elif (year - 2000) % 12 == 2: sign = 'Horse' elif (year - 2000) % 12 == 3: sign = 'sheep' elif (year - 2000) % 12 == 4: sign = 'Monkey' elif (year - 2000) % 12 == 5: sign = 'Rooster' elif (year - 2000) % 12 == 6: sign = 'Dog' elif (year - 2000) % 12 == 7: sign = 'Pig' elif (year - 2000) % 12 == 8: sign = 'Rat' elif (year - 2000) % 12 == 9: sign = 'Ox' elif (year - 2000) % 12 == 10: sign = 'Tiger' else: sign = 'Hare' return sign

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to display sign of the chinese zodiac for given year.[/INST][TESTS] Test case #1 assert chinese_zodiac(1997)==('Ox') Test case #2 assert chinese_zodiac(1998)==('Tiger') Test case #3 assert chinese_zodiac(1994)==('Dog') [/TESTS]</s>

Write a function to find the maximum of similar indices in two lists of tuples.

def max_similar_indices(test_list1, test_list2): res = [(max(x[0], y[0]), max(x[1], y[1])) for x, y in zip(test_list1, test_list2)] return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the maximum of similar indices in two lists of tuples.[/INST][TESTS] Test case #1 assert max_similar_indices([(2, 4), (6, 7), (5, 1)],[(5, 4), (8, 10), (8, 14)]) == [(5, 4), (8, 10), (8, 14)] Test case #2 assert max_similar_indices([(3, 5), (7, 8), (6, 2)],[(6, 5), (9, 11), (9, 15)]) == [(6, 5), (9, 11), (9, 15)] Test case #3 assert max_similar_indices([(4, 6), (8, 9), (7, 3)],[(7, 6), (10, 12), (10, 16)]) == [(7, 6), (10, 12), (10, 16)] [/TESTS]</s>

Write a function to compute the value of ncr mod p.

def nCr_mod_p(n, r, p): if (r > n- r): r = n - r C = [0 for i in range(r + 1)] C[0] = 1 for i in range(1, n + 1): for j in range(min(i, r), 0, -1): C[j] = (C[j] + C[j-1]) % p return C[r]

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to compute the value of ncr mod p.[/INST][TESTS] Test case #1 assert nCr_mod_p(10, 2, 13) == 6 Test case #2 assert nCr_mod_p(11, 3, 14) == 11 Test case #3 assert nCr_mod_p(18, 14, 19) == 1 [/TESTS]</s>

Write a python function to find the minimun number of subsets with distinct elements.

def subset(ar, n): res = 0 ar.sort() for i in range(0, n) : count = 1 for i in range(n - 1): if ar[i] == ar[i + 1]: count+=1 else: break res = max(res, count) return res

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to find the minimun number of subsets with distinct elements.[/INST][TESTS] Test case #1 assert subset([1, 2, 3, 4],4) == 1 Test case #2 assert subset([5, 6, 9, 3, 4, 3, 4],7) == 2 Test case #3 assert subset([1, 2, 3 ],3) == 1 [/TESTS]</s>

Write a function that gives profit amount if the given amount has profit else return none.

def profit_amount(actual_cost,sale_amount): if(actual_cost > sale_amount): amount = actual_cost - sale_amount return amount else: return None

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function that gives profit amount if the given amount has profit else return none.[/INST][TESTS] Test case #1 assert profit_amount(1500,1200)==300 Test case #2 assert profit_amount(100,200)==None Test case #3 assert profit_amount(2000,5000)==None [/TESTS]</s>

Write a function to find out, if the given number is abundant.

def is_abundant(n): fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0]) return fctrsum > n

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find out, if the given number is abundant.[/INST][TESTS] Test case #1 assert is_abundant(12)==True Test case #2 assert is_abundant(13)==False Test case #3 assert is_abundant(9)==False [/TESTS]</s>

Write a function to split the given string at uppercase letters by using regex.

import re def split_list(text): return (re.findall('[A-Z][^A-Z]*', text))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to split the given string at uppercase letters by using regex.[/INST][TESTS] Test case #1 assert split_list("LearnToBuildAnythingWithGoogle") == ['Learn', 'To', 'Build', 'Anything', 'With', 'Google'] Test case #2 assert split_list("ApmlifyingTheBlack+DeveloperCommunity") == ['Apmlifying', 'The', 'Black+', 'Developer', 'Community'] Test case #3 assert split_list("UpdateInTheGoEcoSystem") == ['Update', 'In', 'The', 'Go', 'Eco', 'System'] [/TESTS]</s>

Write a python function to get the position of rightmost set bit.

import math def get_First_Set_Bit_Pos(n): return math.log2(n&-n)+1

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to get the position of rightmost set bit.[/INST][TESTS] Test case #1 assert get_First_Set_Bit_Pos(12) == 3 Test case #2 assert get_First_Set_Bit_Pos(18) == 2 Test case #3 assert get_First_Set_Bit_Pos(16) == 5 [/TESTS]</s>

Write a function to convert an integer into a roman numeral.

def int_to_roman( num): val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1] syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"] roman_num = '' i = 0 while num > 0: for _ in range(num // val[i]): roman_num += syb[i] num -= val[i] i += 1 return roman_num

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to convert an integer into a roman numeral.[/INST][TESTS] Test case #1 assert int_to_roman(1)==("I") Test case #2 assert int_to_roman(50)==("L") Test case #3 assert int_to_roman(4)==("IV") [/TESTS]</s>

Write a python function to find the average of a list.

def Average(lst): return sum(lst) / len(lst)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to find the average of a list.[/INST][TESTS] Test case #1 assert Average([15, 9, 55, 41, 35, 20, 62, 49]) == 35.75 Test case #2 assert Average([4, 5, 1, 2, 9, 7, 10, 8]) == 5.75 Test case #3 assert Average([1,2,3]) == 2 [/TESTS]</s>

Write a function to solve tiling problem.

def get_noOfways(n): if (n == 0): return 0; if (n == 1): return 1; return get_noOfways(n - 1) + get_noOfways(n - 2);

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to solve tiling problem.[/INST][TESTS] Test case #1 assert get_noOfways(4)==3 Test case #2 assert get_noOfways(3)==2 Test case #3 assert get_noOfways(5)==5 [/TESTS]</s>

Write a function to convert a roman numeral to an integer.

def roman_to_int(s): rom_val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000} int_val = 0 for i in range(len(s)): if i > 0 and rom_val[s[i]] > rom_val[s[i - 1]]: int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]] else: int_val += rom_val[s[i]] return int_val

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to convert a roman numeral to an integer.[/INST][TESTS] Test case #1 assert roman_to_int('MMMCMLXXXVI')==3986 Test case #2 assert roman_to_int('MMMM')==4000 Test case #3 assert roman_to_int('C')==100 [/TESTS]</s>

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

def sum_Natural(n): sum = (n * (n + 1)) return int(sum) def sum_Even(l,r): return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to find the sum of all even natural numbers within the range l and r.[/INST][TESTS] Test case #1 assert sum_Even(2,5) == 6 Test case #2 assert sum_Even(3,8) == 18 Test case #3 assert sum_Even(4,6) == 10 [/TESTS]</s>

Write a function to calculate the discriminant value.

def discriminant_value(x,y,z): discriminant = (y**2) - (4*x*z) if discriminant > 0: return ("Two solutions",discriminant) elif discriminant == 0: return ("one solution",discriminant) elif discriminant < 0: return ("no real solution",discriminant)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to calculate the discriminant value.[/INST][TESTS] Test case #1 assert discriminant_value(4,8,2)==("Two solutions",32) Test case #2 assert discriminant_value(5,7,9)==("no real solution",-131) Test case #3 assert discriminant_value(0,0,9)==("one solution",0) [/TESTS]</s>

Write a python function to check whether the length of the word is even or not.

def word_len(s): s = s.split(' ') for word in s: if len(word)%2==0: return True else: return False

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to check whether the length of the word is even or not.[/INST][TESTS] Test case #1 assert word_len("program") == False Test case #2 assert word_len("solution") == True Test case #3 assert word_len("data") == True [/TESTS]</s>

Write a function to convert camel case string to snake case string.

def camel_to_snake(text): import re str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text) return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower()

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to convert camel case string to snake case string.[/INST][TESTS] Test case #1 assert camel_to_snake('PythonProgram')==('python_program') Test case #2 assert camel_to_snake('pythonLanguage')==('python_language') Test case #3 assert camel_to_snake('ProgrammingLanguage')==('programming_language') [/TESTS]</s>

Write a function to remove an empty tuple from a list of tuples.

def remove_empty(tuple1): #L = [(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')] tuple1 = [t for t in tuple1 if t] return tuple1

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to remove an empty tuple from a list of tuples.[/INST][TESTS] Test case #1 assert remove_empty([(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')])==[('',), ('a', 'b'), ('a', 'b', 'c'), 'd'] Test case #2 assert remove_empty([(), (), ('',), ("python"), ("program")])==[('',), ("python"), ("program")] Test case #3 assert remove_empty([(), (), ('',), ("java")])==[('',),("java") ] [/TESTS]</s>

Write a python function to accept the strings which contains all vowels.

def check(string): if len(set(string).intersection("AEIOUaeiou"))>=5: return ('accepted') else: return ("not accepted")

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to accept the strings which contains all vowels.[/INST][TESTS] Test case #1 assert check("SEEquoiaL") == 'accepted' Test case #2 assert check('program') == "not accepted" Test case #3 assert check('fine') == "not accepted" [/TESTS]</s>

Write a python function to find maximum possible value for the given periodic function.

def floor_Max(A,B,N): x = min(B - 1,N) return (A*x) // B

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to find maximum possible value for the given periodic function.[/INST][TESTS] Test case #1 assert floor_Max(11,10,9) == 9 Test case #2 assert floor_Max(5,7,4) == 2 Test case #3 assert floor_Max(2,2,1) == 1 [/TESTS]</s>

Write a function to join the tuples if they have similar initial elements.

def join_tuples(test_list): res = [] for sub in test_list: if res and res[-1][0] == sub[0]: res[-1].extend(sub[1:]) else: res.append([ele for ele in sub]) res = list(map(tuple, res)) return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to join the tuples if they have similar initial elements.[/INST][TESTS] Test case #1 assert join_tuples([(5, 6), (5, 7), (6, 8), (6, 10), (7, 13)] ) == [(5, 6, 7), (6, 8, 10), (7, 13)] Test case #2 assert join_tuples([(6, 7), (6, 8), (7, 9), (7, 11), (8, 14)] ) == [(6, 7, 8), (7, 9, 11), (8, 14)] Test case #3 assert join_tuples([(7, 8), (7, 9), (8, 10), (8, 12), (9, 15)] ) == [(7, 8, 9), (8, 10, 12), (9, 15)] [/TESTS]</s>

Write a function to find minimum of two numbers.

def min_of_two( x, y ): if x < y: return x return y

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find minimum of two numbers.[/INST][TESTS] Test case #1 assert min_of_two(10,20)==10 Test case #2 assert min_of_two(19,15)==15 Test case #3 assert min_of_two(-10,-20)==-20 [/TESTS]</s>

Write a function to find the maximum number of segments of lengths a, b and c that can be formed from n.

def maximum_segments(n, a, b, c) : dp = [-1] * (n + 10) dp[0] = 0 for i in range(0, n) : if (dp[i] != -1) : if(i + a <= n ): dp[i + a] = max(dp[i] + 1, dp[i + a]) if(i + b <= n ): dp[i + b] = max(dp[i] + 1, dp[i + b]) if(i + c <= n ): dp[i + c] = max(dp[i] + 1, dp[i + c]) return dp[n]

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the maximum number of segments of lengths a, b and c that can be formed from n.[/INST][TESTS] Test case #1 assert maximum_segments(7, 5, 2, 5) == 2 Test case #2 assert maximum_segments(17, 2, 1, 3) == 17 Test case #3 assert maximum_segments(18, 16, 3, 6) == 6 [/TESTS]</s>

Write a function to concatenate the given two tuples to a nested tuple.

def concatenate_nested(test_tup1, test_tup2): res = test_tup1 + test_tup2 return (res)

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to concatenate the given two tuples to a nested tuple.[/INST][TESTS] Test case #1 assert concatenate_nested((3, 4), (5, 6)) == (3, 4, 5, 6) Test case #2 assert concatenate_nested((1, 2), (3, 4)) == (1, 2, 3, 4) Test case #3 assert concatenate_nested((4, 5), (6, 8)) == (4, 5, 6, 8) [/TESTS]</s>

Write a python function to left rotate the string.

def left_rotate(s,d): tmp = s[d : ] + s[0 : d] return tmp

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a python function to left rotate the string.[/INST][TESTS] Test case #1 assert left_rotate("python",2) == "thonpy" Test case #2 assert left_rotate("bigdata",3 ) == "databig" Test case #3 assert left_rotate("hadoop",1 ) == "adooph" [/TESTS]</s>

Write a function to find the minimum total path sum in the given triangle.

def min_sum_path(A): memo = [None] * len(A) n = len(A) - 1 for i in range(len(A[n])): memo[i] = A[n][i] for i in range(len(A) - 2, -1,-1): for j in range( len(A[i])): memo[j] = A[i][j] + min(memo[j], memo[j + 1]) return memo[0]

<s> [INST] Your task is to write 3 tests to check the correctness of a function 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. Problem: Write a Python function to get the unique elements of a 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] Problem:Write a function to find the minimum total path sum in the given triangle.[/INST][TESTS] Test case #1 assert min_sum_path([[ 2 ], [3, 9 ], [1, 6, 7 ]]) == 6 Test case #2 assert min_sum_path([[ 2 ], [3, 7 ], [8, 5, 6 ]]) == 10 Test case #3 assert min_sum_path([[ 3 ], [6, 4 ], [5, 2, 7 ]]) == 9 [/TESTS]</s>