question
stringlengths 104
2.09k
| test_list
listlengths 3
3
| test_time_limit
int64 1
1
| test_method
stringclasses 1
value | prefix
stringclasses 1
value |
|---|---|---|---|---|
Write a function to convert the given snake case string to camel case string by using regex.
Your code should pass the test:
assert snake_to_camel('android_tv') == 'AndroidTv'
|
[
"assert snake_to_camel('android_tv') == 'AndroidTv'",
"assert snake_to_camel('google_pixel') == 'GooglePixel'",
"assert snake_to_camel('apple_watch') == 'AppleWatch'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to remove odd numbers from a given list.
Your code should pass the test:
assert remove_odd([1,2,3]) == [2]
|
[
"assert remove_odd([1,2,3]) == [2]",
"assert remove_odd([2,4,6]) == [2,4,6]",
"assert remove_odd([10,20,3]) == [10,20]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to extract the nth element from a given list of tuples.
Your code should pass the test:
assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,0)==['Greyson Fulton', 'Brady Kent', 'Wyatt Knott', 'Beau Turnbull']
|
[
"assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,0)==['Greyson Fulton', 'Brady Kent', 'Wyatt Knott', 'Beau Turnbull']",
"assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,2)==[99, 96, 94, 98]",
"assert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)],1)==[98, 97, 91, 94]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to check whether the value exists in a sequence or not.
Your code should pass the test:
assert overlapping([1,2,3,4,5],[6,7,8,9]) == False
|
[
"assert overlapping([1,2,3,4,5],[6,7,8,9]) == False",
"assert overlapping([1,2,3],[4,5,6]) == False",
"assert overlapping([1,4,5],[1,4,5]) == True"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find a pair with highest product from a given array of integers.
Your code should pass the test:
assert max_Product([1,2,3,4,7,0,8,4]) == (7,8)
|
[
"assert max_Product([1,2,3,4,7,0,8,4]) == (7,8)",
"assert max_Product([0,-1,-2,-4,5,0,-6]) == (-4,-6)",
"assert max_Product([1,2,3]) == (2,3)"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the maximum sum we can make by dividing number in three parts recursively and summing them up together for the given number.
Your code should pass the test:
assert breakSum(12) == 13
|
[
"assert breakSum(12) == 13",
"assert breakSum(24) == 27",
"assert breakSum(23) == 23"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find common first element in given list of tuple.
Your code should pass the test:
assert group_tuples([('x', 'y'), ('x', 'z'), ('w', 't')]) == [('x', 'y', 'z'), ('w', 't')]
|
[
"assert group_tuples([('x', 'y'), ('x', 'z'), ('w', 't')]) == [('x', 'y', 'z'), ('w', 't')]",
"assert group_tuples([('a', 'b'), ('a', 'c'), ('d', 'e')]) == [('a', 'b', 'c'), ('d', 'e')]",
"assert group_tuples([('f', 'g'), ('f', 'g'), ('h', 'i')]) == [('f', 'g', 'g'), ('h', 'i')]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the sublist having maximum length.
Your code should pass the test:
assert Find_Max([['A'],['A','B'],['A','B','C']]) == ['A','B','C']
|
[
"assert Find_Max([['A'],['A','B'],['A','B','C']]) == ['A','B','C']",
"assert Find_Max([[1],[1,2],[1,2,3]]) == [1,2,3]",
"assert Find_Max([[1,1],[1,2,3],[1,5,6,1]]) == [1,5,6,1]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to round every number of a given list of numbers and print the total sum multiplied by the length of the list.
Your code should pass the test:
assert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50])==243
|
[
"assert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50])==243",
"assert round_and_sum([5,2,9,24.3,29])==345",
"assert round_and_sum([25.0,56.7,89.2])==513"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the cube sum of first n even natural numbers.
Your code should pass the test:
assert cube_Sum(2) == 72
|
[
"assert cube_Sum(2) == 72",
"assert cube_Sum(3) == 288",
"assert cube_Sum(4) == 800"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to concatenate each element of tuple by the delimiter.
Your code should pass the test:
assert concatenate_tuple(("ID", "is", 4, "UTS") ) == 'ID-is-4-UTS'
|
[
"assert concatenate_tuple((\"ID\", \"is\", 4, \"UTS\") ) == 'ID-is-4-UTS'",
"assert concatenate_tuple((\"QWE\", \"is\", 4, \"RTY\") ) == 'QWE-is-4-RTY'",
"assert concatenate_tuple((\"ZEN\", \"is\", 4, \"OP\") ) == 'ZEN-is-4-OP'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the average of cubes of first n natural numbers.
Your code should pass the test:
assert find_Average_Of_Cube(2) == 4.5
|
[
"assert find_Average_Of_Cube(2) == 4.5",
"assert find_Average_Of_Cube(3) == 12",
"assert find_Average_Of_Cube(1) == 1"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to solve gold mine problem.
Your code should pass the test:
assert get_maxgold([[1, 3, 1, 5],[2, 2, 4, 1],[5, 0, 2, 3],[0, 6, 1, 2]],4,4)==16
|
[
"assert get_maxgold([[1, 3, 1, 5],[2, 2, 4, 1],[5, 0, 2, 3],[0, 6, 1, 2]],4,4)==16",
"assert get_maxgold([[10,20],[30,40]],2,2)==70",
"assert get_maxgold([[4,9],[3,7]],2,2)==13"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to extract only the rear index element of each string in the given tuple.
Your code should pass the test:
assert extract_rear(('Mers', 'for', 'Vers') ) == ['s', 'r', 's']
|
[
"assert extract_rear(('Mers', 'for', 'Vers') ) == ['s', 'r', 's']",
"assert extract_rear(('Avenge', 'for', 'People') ) == ['e', 'r', 'e']",
"assert extract_rear(('Gotta', 'get', 'go') ) == ['a', 't', 'o']"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to count the number of sublists containing a particular element.
Your code should pass the test:
assert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]],1)==3
|
[
"assert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]],1)==3",
"assert count_element_in_list([['A', 'B'], ['A', 'C'], ['A', 'D', 'E'], ['B', 'C', 'D']],'A')==3",
"assert count_element_in_list([['A', 'B'], ['A', 'C'], ['A', 'D', 'E'], ['B', 'C', 'D']],'E')==1"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to filter odd numbers using lambda function.
Your code should pass the test:
assert filter_oddnumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9]
|
[
"assert filter_oddnumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9]",
"assert filter_oddnumbers([10,20,45,67,84,93])==[45,67,93]",
"assert filter_oddnumbers([5,7,9,8,6,4,3])==[5,7,9,3]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format by using regex.
Your code should pass the test:
assert change_date_format("2026-01-02") == '02-01-2026'
|
[
"assert change_date_format(\"2026-01-02\") == '02-01-2026'",
"assert change_date_format(\"2020-11-13\") == '13-11-2020'",
"assert change_date_format(\"2021-04-26\") == '26-04-2021'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to sort the given array by using shell sort.
Your code should pass the test:
assert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]
|
[
"assert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]",
"assert shell_sort([24, 22, 39, 34, 87, 73, 68]) == [22, 24, 34, 39, 68, 73, 87]",
"assert shell_sort([32, 30, 16, 96, 82, 83, 74]) == [16, 30, 32, 74, 82, 83, 96]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to extract the elementwise and tuples from the given two tuples.
Your code should pass the test:
assert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)
|
[
"assert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)",
"assert and_tuples((1, 2, 3, 4), (5, 6, 7, 8)) == (1, 2, 3, 0)",
"assert and_tuples((8, 9, 11, 12), (7, 13, 14, 17)) == (0, 9, 10, 0)"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the directrix of a parabola.
Your code should pass the test:
assert parabola_directrix(5,3,2)==-198
|
[
"assert parabola_directrix(5,3,2)==-198",
"assert parabola_directrix(9,8,4)==-2336",
"assert parabola_directrix(2,4,6)==-130"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function that takes two lists and returns true if they have at least one common element.
Your code should pass the test:
assert common_element([1,2,3,4,5], [5,6,7,8,9])==True
|
[
"assert common_element([1,2,3,4,5], [5,6,7,8,9])==True",
"assert common_element([1,2,3,4,5], [6,7,8,9])==None",
"assert common_element(['a','b','c'], ['d','b','e'])==True"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the median of a trapezium.
Your code should pass the test:
assert median_trapezium(15,25,35)==20
|
[
"assert median_trapezium(15,25,35)==20",
"assert median_trapezium(10,20,30)==15",
"assert median_trapezium(6,9,4)==7.5"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to check whether the entered number is greater than the elements of the given array.
Your code should pass the test:
assert check_greater([1, 2, 3, 4, 5], 4) == 'No, entered number is less than those in the array'
|
[
"assert check_greater([1, 2, 3, 4, 5], 4) == 'No, entered number is less than those in the array'",
"assert check_greater([2, 3, 4, 5, 6], 8) == 'Yes, the entered number is greater than those in the array'",
"assert check_greater([9, 7, 4, 8, 6, 1], 11) == 'Yes, the entered number is greater than those in the array'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function that matches a string that has an a followed by one or more b's.
Your code should pass the test:
assert text_match_one("ac")==('Not matched!')
|
[
"assert text_match_one(\"ac\")==('Not matched!')",
"assert text_match_one(\"dc\")==('Not matched!')",
"assert text_match_one(\"abba\")==('Found a match!')"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the last digit of a given number.
Your code should pass the test:
assert last_Digit(123) == 3
|
[
"assert last_Digit(123) == 3",
"assert last_Digit(25) == 5",
"assert last_Digit(30) == 0"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to print negative numbers in a list.
Your code should pass the test:
assert neg_nos([-1,4,5,-6]) == -1,-6
|
[
"assert neg_nos([-1,4,5,-6]) == -1,-6",
"assert neg_nos([-1,-2,3,4]) == -1,-2",
"assert neg_nos([-7,-6,8,9]) == -7,-6"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to remove odd characters in a string.
Your code should pass the test:
assert remove_odd("python")==("yhn")
|
[
"assert remove_odd(\"python\")==(\"yhn\")",
"assert remove_odd(\"program\")==(\"rga\")",
"assert remove_odd(\"language\")==(\"agae\")"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to count bidirectional tuple pairs.
Your code should pass the test:
assert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 1), (6, 5), (2, 1)] ) == '3'
|
[
"assert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 1), (6, 5), (2, 1)] ) == '3'",
"assert count_bidirectional([(5, 6), (1, 3), (6, 5), (9, 1), (6, 5), (2, 1)] ) == '2'",
"assert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 2), (6, 5), (2, 1)] ) == '4'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to convert a list of multiple integers into a single integer.
Your code should pass the test:
assert multiple_to_single([11, 33, 50])==113350
|
[
"assert multiple_to_single([11, 33, 50])==113350",
"assert multiple_to_single([-1,2,3,4,5,6])==-123456",
"assert multiple_to_single([10,15,20,25])==10152025"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find all adverbs and their positions in a given sentence.
Your code should pass the test:
assert find_adverb_position("clearly!! we can see the sky")==(0, 7, 'clearly')
|
[
"assert find_adverb_position(\"clearly!! we can see the sky\")==(0, 7, 'clearly')",
"assert find_adverb_position(\"seriously!! there are many roses\")==(0, 9, 'seriously')",
"assert find_adverb_position(\"unfortunately!! sita is going to home\")==(0, 13, 'unfortunately')"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the surface area of a cube.
Your code should pass the test:
assert surfacearea_cube(5)==150
|
[
"assert surfacearea_cube(5)==150",
"assert surfacearea_cube(3)==54",
"assert surfacearea_cube(10)==600"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the ration of positive numbers in an array of integers.
Your code should pass the test:
assert positive_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.54
|
[
"assert positive_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.54",
"assert positive_count([2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==0.69",
"assert positive_count([2, 4, -6, -9, 11, -12, 14, -5, 17])==0.56"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the largest negative number from the given list.
Your code should pass the test:
assert largest_neg([1,2,3,-4,-6]) == -6
|
[
"assert largest_neg([1,2,3,-4,-6]) == -6",
"assert largest_neg([1,2,3,-8,-9]) == -9",
"assert largest_neg([1,2,3,4,-1]) == -1"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to trim each tuple by k in the given tuple list.
Your code should pass the test:
assert trim_tuple([(5, 3, 2, 1, 4), (3, 4, 9, 2, 1),(9, 1, 2, 3, 5), (4, 8, 2, 1, 7)], 2) == '[(2,), (9,), (2,), (2,)]'
|
[
"assert trim_tuple([(5, 3, 2, 1, 4), (3, 4, 9, 2, 1),(9, 1, 2, 3, 5), (4, 8, 2, 1, 7)], 2) == '[(2,), (9,), (2,), (2,)]'",
"assert trim_tuple([(5, 3, 2, 1, 4), (3, 4, 9, 2, 1), (9, 1, 2, 3, 5), (4, 8, 2, 1, 7)], 1) == '[(3, 2, 1), (4, 9, 2), (1, 2, 3), (8, 2, 1)]'",
"assert trim_tuple([(7, 8, 4, 9), (11, 8, 12, 4),(4, 1, 7, 8), (3, 6, 9, 7)], 1) == '[(8, 4), (8, 12), (1, 7), (6, 9)]'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to perform index wise multiplication of tuple elements in the given two tuples.
Your code should pass the test:
assert index_multiplication(((1, 3), (4, 5), (2, 9), (1, 10)),((6, 7), (3, 9), (1, 1), (7, 3)) ) == ((6, 21), (12, 45), (2, 9), (7, 30))
|
[
"assert index_multiplication(((1, 3), (4, 5), (2, 9), (1, 10)),((6, 7), (3, 9), (1, 1), (7, 3)) ) == ((6, 21), (12, 45), (2, 9), (7, 30))",
"assert index_multiplication(((2, 4), (5, 6), (3, 10), (2, 11)),((7, 8), (4, 10), (2, 2), (8, 4)) ) == ((14, 32), (20, 60), (6, 20), (16, 44))",
"assert index_multiplication(((3, 5), (6, 7), (4, 11), (3, 12)),((8, 9), (5, 11), (3, 3), (9, 5)) ) == ((24, 45), (30, 77), (12, 33), (27, 60))"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to count the occurence of all elements of list in a tuple.
Your code should pass the test:
assert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b'] ) == 3
|
[
"assert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b'] ) == 3",
"assert count_Occurrence((1, 2, 3, 1, 4, 6, 7, 1, 4),[1, 4, 7]) == 6",
"assert count_Occurrence((1,2,3,4,5,6),[1,2]) == 2"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find cubes of individual elements in a list using lambda function.
Your code should pass the test:
assert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
|
[
"assert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]",
"assert cube_nums([10,20,30])==([1000, 8000, 27000])",
"assert cube_nums([12,15])==([1728, 3375])"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to calculate the sum of perrin numbers.
Your code should pass the test:
assert cal_sum(9) == 49
|
[
"assert cal_sum(9) == 49",
"assert cal_sum(10) == 66",
"assert cal_sum(11) == 88"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to check whether the triangle is valid or not if 3 points are given.
Your code should pass the test:
assert check_Triangle(1,5,2,5,4,6) == 'Yes'
|
[
"assert check_Triangle(1,5,2,5,4,6) == 'Yes'",
"assert check_Triangle(1,1,1,4,1,5) == 'No'",
"assert check_Triangle(1,1,1,1,1,1) == 'No'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to extract specified size of strings from a give list of string values.
Your code should pass the test:
assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,8)==['practice', 'solution']
|
[
"assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,8)==['practice', 'solution']",
"assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,6)==['Python']",
"assert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,9)==['exercises']"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to remove all whitespaces from the given string using regex.
Your code should pass the test:
assert remove_whitespaces(' Google Flutter ') == 'GoogleFlutter'
|
[
"assert remove_whitespaces(' Google Flutter ') == 'GoogleFlutter'",
"assert remove_whitespaces(' Google Dart ') == 'GoogleDart'",
"assert remove_whitespaces(' iOS Swift ') == 'iOSSwift'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function that gives loss amount if the given amount has loss else return none.
Your code should pass the test:
assert loss_amount(1500,1200)==None
|
[
"assert loss_amount(1500,1200)==None",
"assert loss_amount(100,200)==100",
"assert loss_amount(2000,5000)==3000"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the sum of even factors of a number.
Your code should pass the test:
assert sumofFactors(18) == 26
|
[
"assert sumofFactors(18) == 26",
"assert sumofFactors(30) == 48",
"assert sumofFactors(6) == 8"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function that matches a word containing 'z'.
Your code should pass the test:
assert text_match_wordz("pythonz.")==('Found a match!')
|
[
"assert text_match_wordz(\"pythonz.\")==('Found a match!')",
"assert text_match_wordz(\"xyz.\")==('Found a match!')",
"assert text_match_wordz(\" lang .\")==('Not matched!')"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to check whether the given month number contains 31 days or not.
Your code should pass the test:
assert check_monthnumb_number(5)==True
|
[
"assert check_monthnumb_number(5)==True",
"assert check_monthnumb_number(2)==False",
"assert check_monthnumb_number(6)==False"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to reverse strings in a given list of string values.
Your code should pass the test:
assert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black'])==['deR', 'neerG', 'eulB', 'etihW', 'kcalB']
|
[
"assert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black'])==['deR', 'neerG', 'eulB', 'etihW', 'kcalB']",
"assert reverse_string_list(['john','amal','joel','george'])==['nhoj','lama','leoj','egroeg']",
"assert reverse_string_list(['jack','john','mary'])==['kcaj','nhoj','yram']"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the sublist having minimum length.
Your code should pass the test:
assert Find_Min([[1],[1,2],[1,2,3]]) == [1]
|
[
"assert Find_Min([[1],[1,2],[1,2,3]]) == [1]",
"assert Find_Min([[1,1],[1,1,1],[1,2,7,8]]) == [1,1]",
"assert Find_Min([['x'],['x','y'],['x','y','z']]) == ['x']"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the area of a rectangle.
Your code should pass the test:
assert rectangle_area(10,20)==200
|
[
"assert rectangle_area(10,20)==200",
"assert rectangle_area(10,5)==50",
"assert rectangle_area(4,2)==8"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to remove uppercase substrings from a given string by using regex.
Your code should pass the test:
assert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'
|
[
"assert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'",
"assert remove_uppercase('wAtchTheinTernEtrAdIo') == 'wtchheinerntrdo'",
"assert remove_uppercase('VoicESeaRchAndreComMendaTionS') == 'oiceachndreomendaion'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to get the first element of each sublist.
Your code should pass the test:
assert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]
|
[
"assert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]",
"assert Extract([[1,2,3],[4, 5]]) == [1,4]",
"assert Extract([[9,8,1],[1,2]]) == [9,1]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to count the upper case characters in a given string.
Your code should pass the test:
assert upper_ctr('PYthon') == 1
|
[
"assert upper_ctr('PYthon') == 1",
"assert upper_ctr('BigData') == 1",
"assert upper_ctr('program') == 0"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find all possible combinations of the elements of a given list.
Your code should pass the test:
assert combinations_list(['orange', 'red', 'green', 'blue'])==[[], ['orange'], ['red'], ['red', 'orange'], ['green'], ['green', 'orange'], ['green', 'red'], ['green', 'red', 'orange'], ['blue'], ['blue', 'orange'], ['blue', 'red'], ['blue', 'red', 'orange'], ['blue', 'green'], ['blue', 'green', 'orange'], ['blue', 'green', 'red'], ['blue', 'green', 'red', 'orange']]
|
[
"assert combinations_list(['orange', 'red', 'green', 'blue'])==[[], ['orange'], ['red'], ['red', 'orange'], ['green'], ['green', 'orange'], ['green', 'red'], ['green', 'red', 'orange'], ['blue'], ['blue', 'orange'], ['blue', 'red'], ['blue', 'red', 'orange'], ['blue', 'green'], ['blue', 'green', 'orange'], ['blue', 'green', 'red'], ['blue', 'green', 'red', 'orange']]",
"assert combinations_list(['red', 'green', 'blue', 'white', 'black', 'orange'])==[[], ['red'], ['green'], ['green', 'red'], ['blue'], ['blue', 'red'], ['blue', 'green'], ['blue', 'green', 'red'], ['white'], ['white', 'red'], ['white', 'green'], ['white', 'green', 'red'], ['white', 'blue'], ['white', 'blue', 'red'], ['white', 'blue', 'green'], ['white', 'blue', 'green', 'red'], ['black'], ['black', 'red'], ['black', 'green'], ['black', 'green', 'red'], ['black', 'blue'], ['black', 'blue', 'red'], ['black', 'blue', 'green'], ['black', 'blue', 'green', 'red'], ['black', 'white'], ['black', 'white', 'red'], ['black', 'white', 'green'], ['black', 'white', 'green', 'red'], ['black', 'white', 'blue'], ['black', 'white', 'blue', 'red'], ['black', 'white', 'blue', 'green'], ['black', 'white', 'blue', 'green', 'red'], ['orange'], ['orange', 'red'], ['orange', 'green'], ['orange', 'green', 'red'], ['orange', 'blue'], ['orange', 'blue', 'red'], ['orange', 'blue', 'green'], ['orange', 'blue', 'green', 'red'], ['orange', 'white'], ['orange', 'white', 'red'], ['orange', 'white', 'green'], ['orange', 'white', 'green', 'red'], ['orange', 'white', 'blue'], ['orange', 'white', 'blue', 'red'], ['orange', 'white', 'blue', 'green'], ['orange', 'white', 'blue', 'green', 'red'], ['orange', 'black'], ['orange', 'black', 'red'], ['orange', 'black', 'green'], ['orange', 'black', 'green', 'red'], ['orange', 'black', 'blue'], ['orange', 'black', 'blue', 'red'], ['orange', 'black', 'blue', 'green'], ['orange', 'black', 'blue', 'green', 'red'], ['orange', 'black', 'white'], ['orange', 'black', 'white', 'red'], ['orange', 'black', 'white', 'green'], ['orange', 'black', 'white', 'green', 'red'], ['orange', 'black', 'white', 'blue'], ['orange', 'black', 'white', 'blue', 'red'], ['orange', 'black', 'white', 'blue', 'green'], ['orange', 'black', 'white', 'blue', 'green', 'red']]",
"assert combinations_list(['red', 'green', 'black', 'orange'])==[[], ['red'], ['green'], ['green', 'red'], ['black'], ['black', 'red'], ['black', 'green'], ['black', 'green', 'red'], ['orange'], ['orange', 'red'], ['orange', 'green'], ['orange', 'green', 'red'], ['orange', 'black'], ['orange', 'black', 'red'], ['orange', 'black', 'green'], ['orange', 'black', 'green', 'red']]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the maximum product subarray of the given array.
Your code should pass the test:
assert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112
|
[
"assert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112",
"assert max_subarray_product([6, -3, -10, 0, 2]) == 180 ",
"assert max_subarray_product([-2, -40, 0, -2, -3]) == 80"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to check if all values are same in a dictionary.
Your code should pass the test:
assert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},10)==False
|
[
"assert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},10)==False",
"assert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},12)==True",
"assert check_value({'Cierra Vega': 12, 'Alden Cantrell': 12, 'Kierra Gentry': 12, 'Pierre Cox': 12},5)==False"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to drop empty items from a given dictionary.
Your code should pass the test:
assert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3':None})=={'c1': 'Red', 'c2': 'Green'}
|
[
"assert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3':None})=={'c1': 'Red', 'c2': 'Green'}",
"assert drop_empty({'c1': 'Red', 'c2': None, 'c3':None})=={'c1': 'Red'}",
"assert drop_empty({'c1': None, 'c2': 'Green', 'c3':None})=={ 'c2': 'Green'}"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the peak element in the given array.
Your code should pass the test:
assert find_peak([1, 3, 20, 4, 1, 0], 6) == 2
|
[
"assert find_peak([1, 3, 20, 4, 1, 0], 6) == 2",
"assert find_peak([2, 3, 4, 5, 6], 5) == 4",
"assert find_peak([8, 9, 11, 12, 14, 15], 6) == 5 "
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to convert decimal number to octal number.
Your code should pass the test:
assert decimal_to_Octal(10) == 12
|
[
"assert decimal_to_Octal(10) == 12",
"assert decimal_to_Octal(2) == 2",
"assert decimal_to_Octal(33) == 41"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the maximum product formed by multiplying numbers of an increasing subsequence of that array.
Your code should pass the test:
assert max_product([3, 100, 4, 5, 150, 6], 6) == 45000
|
[
"assert max_product([3, 100, 4, 5, 150, 6], 6) == 45000 ",
"assert max_product([4, 42, 55, 68, 80], 5) == 50265600",
"assert max_product([10, 22, 9, 33, 21, 50, 41, 60], 8) == 21780000 "
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the maximum profit earned from a maximum of k stock transactions
Your code should pass the test:
assert max_profit([1, 5, 2, 3, 7, 6, 4, 5], 3) == 10
|
[
"assert max_profit([1, 5, 2, 3, 7, 6, 4, 5], 3) == 10",
"assert max_profit([2, 4, 7, 5, 4, 3, 5], 2) == 7",
"assert max_profit([10, 6, 8, 4, 2], 2) == 2"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the pairwise addition of the elements of the given tuples.
Your code should pass the test:
assert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18)
|
[
"assert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18)",
"assert add_pairwise((2, 6, 8, 9, 11)) == (8, 14, 17, 20)",
"assert add_pairwise((3, 7, 9, 10, 12)) == (10, 16, 19, 22)"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find remainder of array multiplication divided by n.
Your code should pass the test:
assert find_remainder([ 100, 10, 5, 25, 35, 14 ],6,11) ==9
|
[
"assert find_remainder([ 100, 10, 5, 25, 35, 14 ],6,11) ==9",
"assert find_remainder([1,1,1],3,1) == 0",
"assert find_remainder([1,2,1],3,2) == 0"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to check whether the given list contains consecutive numbers or not.
Your code should pass the test:
assert check_Consecutive([1,2,3,4,5]) == True
|
[
"assert check_Consecutive([1,2,3,4,5]) == True",
"assert check_Consecutive([1,2,3,5,6]) == False",
"assert check_Consecutive([1,2,1]) == False"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the tuple intersection of elements in the given tuple list irrespective of their order.
Your code should pass the test:
assert tuple_intersection([(3, 4), (5, 6), (9, 10), (4, 5)] , [(5, 4), (3, 4), (6, 5), (9, 11)]) == {(4, 5), (3, 4), (5, 6)}
|
[
"assert tuple_intersection([(3, 4), (5, 6), (9, 10), (4, 5)] , [(5, 4), (3, 4), (6, 5), (9, 11)]) == {(4, 5), (3, 4), (5, 6)}",
"assert tuple_intersection([(4, 1), (7, 4), (11, 13), (17, 14)] , [(1, 4), (7, 4), (16, 12), (10, 13)]) == {(4, 7), (1, 4)}",
"assert tuple_intersection([(2, 1), (3, 2), (1, 3), (1, 4)] , [(11, 2), (2, 3), (6, 2), (1, 3)]) == {(1, 3), (2, 3)}"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to replace characters in a string.
Your code should pass the test:
assert replace_char("polygon",'y','l')==("pollgon")
|
[
"assert replace_char(\"polygon\",'y','l')==(\"pollgon\")",
"assert replace_char(\"character\",'c','a')==(\"aharaater\")",
"assert replace_char(\"python\",'l','a')==(\"python\")"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to sort counter by value.
Your code should pass the test:
assert sort_counter({'Math':81, 'Physics':83, 'Chemistry':87})==[('Chemistry', 87), ('Physics', 83), ('Math', 81)]
|
[
"assert sort_counter({'Math':81, 'Physics':83, 'Chemistry':87})==[('Chemistry', 87), ('Physics', 83), ('Math', 81)]",
"assert sort_counter({'Math':400, 'Physics':300, 'Chemistry':250})==[('Math', 400), ('Physics', 300), ('Chemistry', 250)]",
"assert sort_counter({'Math':900, 'Physics':1000, 'Chemistry':1250})==[('Chemistry', 1250), ('Physics', 1000), ('Math', 900)]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the sum of the largest and smallest value in a given array.
Your code should pass the test:
assert big_sum([1,2,3]) == 4
|
[
"assert big_sum([1,2,3]) == 4",
"assert big_sum([-1,2,3,4]) == 3",
"assert big_sum([2,3,6]) == 8"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to convert the given string to lower case.
Your code should pass the test:
assert is_lower("InValid") == "invalid"
|
[
"assert is_lower(\"InValid\") == \"invalid\"",
"assert is_lower(\"TruE\") == \"true\"",
"assert is_lower(\"SenTenCE\") == \"sentence\""
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to remove lowercase substrings from a given string.
Your code should pass the test:
assert remove_lowercase("PYTHon")==('PYTH')
|
[
"assert remove_lowercase(\"PYTHon\")==('PYTH')",
"assert remove_lowercase(\"FInD\")==('FID')",
"assert remove_lowercase(\"STRinG\")==('STRG')"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the first digit of a given number.
Your code should pass the test:
assert first_Digit(123) == 1
|
[
"assert first_Digit(123) == 1",
"assert first_Digit(456) == 4",
"assert first_Digit(12) == 1"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the maximum occurring character in a given string.
Your code should pass the test:
assert get_max_occuring_char("data") == "a"
|
[
"assert get_max_occuring_char(\"data\") == \"a\"",
"assert get_max_occuring_char(\"create\") == \"e\"",
"assert get_max_occuring_char(\"brilliant girl\") == \"i\""
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to determine if there is a subset of the given set with sum equal to the given sum.
Your code should pass the test:
assert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 9) == True
|
[
"assert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 9) == True",
"assert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 30) == False",
"assert is_subset_sum([3, 34, 4, 12, 5, 2], 6, 15) == True"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find sequences of one upper case letter followed by lower case letters in the given string by using regex.
Your code should pass the test:
assert match("Geeks") == 'Yes'
|
[
"assert match(\"Geeks\") == 'Yes'",
"assert match(\"geeksforGeeks\") == 'Yes'",
"assert match(\"geeks\") == 'No'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the first natural number whose factorial is divisible by x.
Your code should pass the test:
assert first_Factorial_Divisible_Number(10) == 5
|
[
"assert first_Factorial_Divisible_Number(10) == 5",
"assert first_Factorial_Divisible_Number(15) == 5",
"assert first_Factorial_Divisible_Number(5) == 4"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to remove the matching tuples from the given two tuples.
Your code should pass the test:
assert remove_matching_tuple([('Hello', 'dude'), ('How', 'are'), ('you', '?')], [('Hello', 'dude'), ('How', 'are')]) == [('you', '?')]
|
[
"assert remove_matching_tuple([('Hello', 'dude'), ('How', 'are'), ('you', '?')], [('Hello', 'dude'), ('How', 'are')]) == [('you', '?')]",
"assert remove_matching_tuple([('Part', 'of'), ('the', 'journey'), ('is ', 'end')], [('Journey', 'the'), ('is', 'end')]) == [('Part', 'of'), ('the', 'journey'), ('is ', 'end')]",
"assert remove_matching_tuple([('Its', 'been'), ('a', 'long'), ('day', 'without')], [('a', 'long'), ('my', 'friend')]) == [('Its', 'been'), ('day', 'without')]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the largest palindromic number in the given array.
Your code should pass the test:
assert largest_palindrome([1, 232, 54545, 999991], 4) == 54545
|
[
"assert largest_palindrome([1, 232, 54545, 999991], 4) == 54545",
"assert largest_palindrome([1, 2, 3, 4, 5, 50], 6) == 5",
"assert largest_palindrome([1, 3, 7, 9, 45], 5) == 9"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to compute binomial probability for the given number.
Your code should pass the test:
assert binomial_probability(10, 5, 1.0/3) == 0.13656454808718185
|
[
"assert binomial_probability(10, 5, 1.0/3) == 0.13656454808718185",
"assert binomial_probability(11, 6, 2.0/4) == 0.2255859375",
"assert binomial_probability(12, 7, 3.0/5) == 0.227030335488"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to sort a list of tuples in increasing order by the last element in each tuple.
Your code should pass the test:
assert sort_tuple([(1, 3), (3, 2), (2, 1)] ) == [(2, 1), (3, 2), (1, 3)]
|
[
"assert sort_tuple([(1, 3), (3, 2), (2, 1)] ) == [(2, 1), (3, 2), (1, 3)]",
"assert sort_tuple([(2, 4), (3, 3), (1, 1)] ) == [(1, 1), (3, 3), (2, 4)]",
"assert sort_tuple([(3, 9), (6, 7), (4, 3)] ) == [(4, 3), (6, 7), (3, 9)]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the area of a pentagon.
Your code should pass the test:
assert area_pentagon(5)==43.01193501472417
|
[
"assert area_pentagon(5)==43.01193501472417",
"assert area_pentagon(10)==172.0477400588967",
"assert area_pentagon(15)==387.10741513251753"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the frequency of the largest value in a given array.
Your code should pass the test:
assert frequency_Of_Largest(5,[1,2,3,4,4]) == 2
|
[
"assert frequency_Of_Largest(5,[1,2,3,4,4]) == 2",
"assert frequency_Of_Largest(3,[5,6,5]) == 1",
"assert frequency_Of_Largest(4,[2,7,7,7]) == 3"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to extract all the pairs which are symmetric in the given tuple list.
Your code should pass the test:
assert extract_symmetric([(6, 7), (2, 3), (7, 6), (9, 8), (10, 2), (8, 9)] ) == {(8, 9), (6, 7)}
|
[
"assert extract_symmetric([(6, 7), (2, 3), (7, 6), (9, 8), (10, 2), (8, 9)] ) == {(8, 9), (6, 7)}",
"assert extract_symmetric([(7, 8), (3, 4), (8, 7), (10, 9), (11, 3), (9, 10)] ) == {(9, 10), (7, 8)}",
"assert extract_symmetric([(8, 9), (4, 5), (9, 8), (11, 10), (12, 4), (10, 11)] ) == {(8, 9), (10, 11)}"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the sum of geometric progression series.
Your code should pass the test:
assert sum_gp(1,5,2)==31
|
[
"assert sum_gp(1,5,2)==31",
"assert sum_gp(1,5,4)==341",
"assert sum_gp(2,6,3)==728"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to search an element in the given array by using binary search.
Your code should pass the test:
assert binary_search([1,2,3,5,8], 6) == False
|
[
"assert binary_search([1,2,3,5,8], 6) == False",
"assert binary_search([7, 8, 9, 10, 13], 10) == True",
"assert binary_search([11, 13, 14, 19, 22, 36], 23) == False"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to calculate a grid of hexagon coordinates where function returns a list of lists containing 6 tuples of x, y point coordinates.
Your code should pass the test:
assert calculate_polygons(1,1, 4, 4, 3)==[[(-5.0, -4.196152422706632), (-5.0, -0.7320508075688767), (-2.0, 1.0), (1.0, -0.7320508075688767), (1.0, -4.196152422706632), (-2.0, -5.928203230275509), (-5.0, -4.196152422706632)], [(1.0, -4.196152422706632), (1.0, -0.7320508075688767), (4.0, 1.0), (7.0, -0.7320508075688767), (7.0, -4.196152422706632), (4.0, -5.928203230275509), (1.0, -4.196152422706632)], [(7.0, -4.196152422706632), (7.0, -0.7320508075688767), (10.0, 1.0), (13.0, -0.7320508075688767), (13.0, -4.196152422706632), (10.0, -5.928203230275509), (7.0, -4.196152422706632)], [(-2.0, 1.0000000000000004), (-2.0, 4.464101615137755), (1.0, 6.196152422706632), (4.0, 4.464101615137755), (4.0, 1.0000000000000004), (1.0, -0.7320508075688767), (-2.0, 1.0000000000000004)], [(4.0, 1.0000000000000004), (4.0, 4.464101615137755), (7.0, 6.196152422706632), (10.0, 4.464101615137755), (10.0, 1.0000000000000004), (7.0, -0.7320508075688767), (4.0, 1.0000000000000004)], [(-5.0, 6.196152422706632), (-5.0, 9.660254037844387), (-2.0, 11.392304845413264), (1.0, 9.660254037844387), (1.0, 6.196152422706632), (-2.0, 4.464101615137755), (-5.0, 6.196152422706632)], [(1.0, 6.196152422706632), (1.0, 9.660254037844387), (4.0, 11.392304845413264), (7.0, 9.660254037844387), (7.0, 6.196152422706632), (4.0, 4.464101615137755), (1.0, 6.196152422706632)], [(7.0, 6.196152422706632), (7.0, 9.660254037844387), (10.0, 11.392304845413264), (13.0, 9.660254037844387), (13.0, 6.196152422706632), (10.0, 4.464101615137755), (7.0, 6.196152422706632)], [(-2.0, 11.392304845413264), (-2.0, 14.85640646055102), (1.0, 16.588457268119896), (4.0, 14.85640646055102), (4.0, 11.392304845413264), (1.0, 9.660254037844387), (-2.0, 11.392304845413264)], [(4.0, 11.392304845413264), (4.0, 14.85640646055102), (7.0, 16.588457268119896), (10.0, 14.85640646055102), (10.0, 11.392304845413264), (7.0, 9.660254037844387), (4.0, 11.392304845413264)]]
|
[
"assert calculate_polygons(1,1, 4, 4, 3)==[[(-5.0, -4.196152422706632), (-5.0, -0.7320508075688767), (-2.0, 1.0), (1.0, -0.7320508075688767), (1.0, -4.196152422706632), (-2.0, -5.928203230275509), (-5.0, -4.196152422706632)], [(1.0, -4.196152422706632), (1.0, -0.7320508075688767), (4.0, 1.0), (7.0, -0.7320508075688767), (7.0, -4.196152422706632), (4.0, -5.928203230275509), (1.0, -4.196152422706632)], [(7.0, -4.196152422706632), (7.0, -0.7320508075688767), (10.0, 1.0), (13.0, -0.7320508075688767), (13.0, -4.196152422706632), (10.0, -5.928203230275509), (7.0, -4.196152422706632)], [(-2.0, 1.0000000000000004), (-2.0, 4.464101615137755), (1.0, 6.196152422706632), (4.0, 4.464101615137755), (4.0, 1.0000000000000004), (1.0, -0.7320508075688767), (-2.0, 1.0000000000000004)], [(4.0, 1.0000000000000004), (4.0, 4.464101615137755), (7.0, 6.196152422706632), (10.0, 4.464101615137755), (10.0, 1.0000000000000004), (7.0, -0.7320508075688767), (4.0, 1.0000000000000004)], [(-5.0, 6.196152422706632), (-5.0, 9.660254037844387), (-2.0, 11.392304845413264), (1.0, 9.660254037844387), (1.0, 6.196152422706632), (-2.0, 4.464101615137755), (-5.0, 6.196152422706632)], [(1.0, 6.196152422706632), (1.0, 9.660254037844387), (4.0, 11.392304845413264), (7.0, 9.660254037844387), (7.0, 6.196152422706632), (4.0, 4.464101615137755), (1.0, 6.196152422706632)], [(7.0, 6.196152422706632), (7.0, 9.660254037844387), (10.0, 11.392304845413264), (13.0, 9.660254037844387), (13.0, 6.196152422706632), (10.0, 4.464101615137755), (7.0, 6.196152422706632)], [(-2.0, 11.392304845413264), (-2.0, 14.85640646055102), (1.0, 16.588457268119896), (4.0, 14.85640646055102), (4.0, 11.392304845413264), (1.0, 9.660254037844387), (-2.0, 11.392304845413264)], [(4.0, 11.392304845413264), (4.0, 14.85640646055102), (7.0, 16.588457268119896), (10.0, 14.85640646055102), (10.0, 11.392304845413264), (7.0, 9.660254037844387), (4.0, 11.392304845413264)]]",
"assert calculate_polygons(5,4,7,9,8)==[[(-11.0, -9.856406460551018), (-11.0, -0.6188021535170058), (-3.0, 4.0), (5.0, -0.6188021535170058), (5.0, -9.856406460551018), (-3.0, -14.475208614068023), (-11.0, -9.856406460551018)], [(5.0, -9.856406460551018), (5.0, -0.6188021535170058), (13.0, 4.0), (21.0, -0.6188021535170058), (21.0, -9.856406460551018), (13.0, -14.475208614068023), (5.0, -9.856406460551018)], [(21.0, -9.856406460551018), (21.0, -0.6188021535170058), (29.0, 4.0), (37.0, -0.6188021535170058), (37.0, -9.856406460551018), (29.0, -14.475208614068023), (21.0, -9.856406460551018)], [(-3.0, 4.0), (-3.0, 13.237604307034012), (5.0, 17.856406460551018), (13.0, 13.237604307034012), (13.0, 4.0), (5.0, -0.6188021535170058), (-3.0, 4.0)], [(13.0, 4.0), (13.0, 13.237604307034012), (21.0, 17.856406460551018), (29.0, 13.237604307034012), (29.0, 4.0), (21.0, -0.6188021535170058), (13.0, 4.0)], [(-11.0, 17.856406460551018), (-11.0, 27.09401076758503), (-3.0, 31.712812921102035), (5.0, 27.09401076758503), (5.0, 17.856406460551018), (-3.0, 13.237604307034012), (-11.0, 17.856406460551018)], [(5.0, 17.856406460551018), (5.0, 27.09401076758503), (13.0, 31.712812921102035), (21.0, 27.09401076758503), (21.0, 17.856406460551018), (13.0, 13.237604307034012), (5.0, 17.856406460551018)], [(21.0, 17.856406460551018), (21.0, 27.09401076758503), (29.0, 31.712812921102035), (37.0, 27.09401076758503), (37.0, 17.856406460551018), (29.0, 13.237604307034012), (21.0, 17.856406460551018)], [(-3.0, 31.712812921102035), (-3.0, 40.95041722813605), (5.0, 45.569219381653056), (13.0, 40.95041722813605), (13.0, 31.712812921102035), (5.0, 27.09401076758503), (-3.0, 31.712812921102035)], [(13.0, 31.712812921102035), (13.0, 40.95041722813605), (21.0, 45.569219381653056), (29.0, 40.95041722813605), (29.0, 31.712812921102035), (21.0, 27.09401076758503), (13.0, 31.712812921102035)]]",
"assert calculate_polygons(9,6,4,3,2)==[[(5.0, 2.5358983848622456), (5.0, 4.8452994616207485), (7.0, 6.0), (9.0, 4.8452994616207485), (9.0, 2.5358983848622456), (7.0, 1.3811978464829942), (5.0, 2.5358983848622456)], [(7.0, 6.0), (7.0, 8.309401076758503), (9.0, 9.464101615137753), (11.0, 8.309401076758503), (11.0, 6.0), (9.0, 4.8452994616207485), (7.0, 6.0)]]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to convert the given binary tuple to integer.
Your code should pass the test:
assert binary_to_integer((1, 1, 0, 1, 0, 0, 1)) == '105'
|
[
"assert binary_to_integer((1, 1, 0, 1, 0, 0, 1)) == '105'",
"assert binary_to_integer((0, 1, 1, 0, 0, 1, 0, 1)) == '101'",
"assert binary_to_integer((1, 1, 0, 1, 0, 1)) == '53'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to remove lowercase substrings from a given string by using regex.
Your code should pass the test:
assert remove_lowercase('KDeoALOklOOHserfLoAJSIskdsf') == 'KDALOOOHLAJSI'
|
[
"assert remove_lowercase('KDeoALOklOOHserfLoAJSIskdsf') == 'KDALOOOHLAJSI'",
"assert remove_lowercase('ProducTnamEstreAmIngMediAplAYer') == 'PTEAIMAAY'",
"assert remove_lowercase('maNufacTuredbYSheZenTechNolOGIes') == 'NTYSZTNOGI'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the smallest integers from a given list of numbers using heap queue algorithm.
Your code should pass the test:
assert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 25, 58],3)==[14, 22, 25]
|
[
"assert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 25, 58],3)==[14, 22, 25] ",
"assert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 25, 58],2)==[14, 22]",
"assert heap_queue_smallest( [25, 35, 22, 85, 14, 65, 75, 22, 58],5)==[14, 22, 22, 25, 35]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the surface area of a cone.
Your code should pass the test:
assert surfacearea_cone(5,12)==282.7433388230814
|
[
"assert surfacearea_cone(5,12)==282.7433388230814",
"assert surfacearea_cone(10,15)==880.5179353159282",
"assert surfacearea_cone(19,17)==2655.923961165254"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find gcd of two positive integers.
Your code should pass the test:
assert gcd(12, 17) == 1
|
[
"assert gcd(12, 17) == 1",
"assert gcd(4,6) == 2",
"assert gcd(2,9) == 1"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the diameter of a circle.
Your code should pass the test:
assert diameter_circle(10)==20
|
[
"assert diameter_circle(10)==20",
"assert diameter_circle(40)==80",
"assert diameter_circle(15)==30"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to concatenate all elements of the given list into a string.
Your code should pass the test:
assert concatenate_elements(['hello','there','have','a','rocky','day'] ) == ' hello there have a rocky day'
|
[
"assert concatenate_elements(['hello','there','have','a','rocky','day'] ) == ' hello there have a rocky day'",
"assert concatenate_elements([ 'Hi', 'there', 'How','are', 'you'] ) == ' Hi there How are you'",
"assert concatenate_elements([ 'Part', 'of', 'the','journey', 'is', 'end'] ) == ' Part of the journey is end'"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find common divisor between two numbers in a given pair.
Your code should pass the test:
assert num_comm_div(2,4) == 2
|
[
"assert num_comm_div(2,4) == 2",
"assert num_comm_div(2,8) == 2",
"assert num_comm_div(12,24) == 6"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find remainder of two numbers.
Your code should pass the test:
assert find(3,3) == 0
|
[
"assert find(3,3) == 0",
"assert find(10,3) == 1",
"assert find(16,5) == 1"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to add consecutive numbers of a given list.
Your code should pass the test:
assert add_consecutive_nums([1, 1, 3, 4, 4, 5, 6, 7])==[2, 4, 7, 8, 9, 11, 13]
|
[
"assert add_consecutive_nums([1, 1, 3, 4, 4, 5, 6, 7])==[2, 4, 7, 8, 9, 11, 13]",
"assert add_consecutive_nums([4, 5, 8, 9, 6, 10])==[9, 13, 17, 15, 16]",
"assert add_consecutive_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[3, 5, 7, 9, 11, 13, 15, 17, 19]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the cube sum of first n natural numbers.
Your code should pass the test:
assert sum_Of_Series(5) == 225
|
[
"assert sum_Of_Series(5) == 225",
"assert sum_Of_Series(2) == 9",
"assert sum_Of_Series(3) == 36"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to move all zeroes to the end of the given array.
Your code should pass the test:
assert re_order([6, 0, 8, 2, 3, 0, 4, 0, 1]) == [6, 8, 2, 3, 4, 1, 0, 0, 0]
|
[
"assert re_order([6, 0, 8, 2, 3, 0, 4, 0, 1]) == [6, 8, 2, 3, 4, 1, 0, 0, 0]",
"assert re_order([4, 0, 2, 7, 0, 9, 0, 12, 0]) == [4, 2, 7, 9, 12, 0, 0, 0, 0]",
"assert re_order([3, 11, 0, 74, 14, 0, 1, 0, 2]) == [3, 11, 74, 14, 1, 2, 0, 0, 0]"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to calculate the permutation coefficient of given p(n, k).
Your code should pass the test:
assert permutation_coefficient(10, 2) == 90
|
[
"assert permutation_coefficient(10, 2) == 90",
"assert permutation_coefficient(10, 3) == 720",
"assert permutation_coefficient(10, 1) == 10"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to remove specific words from a given list.
Your code should pass the test:
assert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['white', 'orange'])==['red', 'green', 'blue', 'black']
|
[
"assert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['white', 'orange'])==['red', 'green', 'blue', 'black']",
"assert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['black', 'orange'])==['red', 'green', 'blue', 'white']",
"assert remove_words(['red', 'green', 'blue', 'white', 'black', 'orange'],['blue', 'white'])==['red', 'green', 'black', 'orange']"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to check if the common elements between two given lists are in the same order or not.
Your code should pass the test:
assert same_order(["red","green","black","orange"],["red","pink","green","white","black"])==True
|
[
"assert same_order([\"red\",\"green\",\"black\",\"orange\"],[\"red\",\"pink\",\"green\",\"white\",\"black\"])==True",
"assert same_order([\"red\",\"pink\",\"green\",\"white\",\"black\"],[\"white\",\"orange\",\"pink\",\"black\"])==False",
"assert same_order([\"red\",\"green\",\"black\",\"orange\"],[\"red\",\"pink\",\"green\",\"white\",\"black\"])==True"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a python function to find the average of odd numbers till a given odd number.
Your code should pass the test:
assert average_Odd(9) == 5
|
[
"assert average_Odd(9) == 5",
"assert average_Odd(5) == 3",
"assert average_Odd(11) == 6"
] | 1
|
function
|
Here is the completed code:
```python
|
Write a function to find the number of subsequences having product smaller than k for the given non negative array.
Your code should pass the test:
assert no_of_subsequences([1,2,3,4], 10) == 11
|
[
"assert no_of_subsequences([1,2,3,4], 10) == 11",
"assert no_of_subsequences([4,8,7,2], 50) == 9",
"assert no_of_subsequences([5,6,7,8], 15) == 4"
] | 1
|
function
|
Here is the completed code:
```python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.