source_id int64 1.31k 685k | source_row int64 0 157 | source_revision stringclasses 1
value | source_seed_sha1 stringlengths 40 40 | source_url stringclasses 1
value | instruction stringlengths 149 1.85k | original_response stringlengths 89 1.53k | prompt stringlengths 178 1.92k | completion stringlengths 28 680 | token_count int64 94 816 | body_sha256 stringlengths 64 64 | split stringclasses 1
value | validation_status stringclasses 1
value | loss_mask stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
165,808 | 0 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | f35b008f8b8ce16c456068d0066447b71244c41b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function named `get_value` that takes a matrix (represented by a list of lists) and a tuple of indices, and returns the value at that index in the matrix. The function should handle index out of range errors by returning None. | To handle the index out of range errors, we need to check if the indices are valid before accessing the matrix. We can do this by checking if the indices are within the bounds of the matrix dimensions. If they are not valid, we can return None. If they are valid, we can access the matrix and return the value at that in... | def get_value(matrix, indices):
'Write a Python function named `get_value` that takes a matrix (represented by a list of lists) and a tuple of indices, and returns the value at that index in the matrix. The function should handle index out of range errors by returning None.'
| row_index, col_index = indices
if row_index < 0 or row_index >= len(matrix) or col_index < 0 or (col_index >= len(matrix[row_index])):
return None
return matrix[row_index][col_index]
| 149 | 9e7bdc46d214c75ca1d6e017d08ac1ef8c225013e8e763e9e743f697e1d34e67 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
533,341 | 1 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | c2ab70d6100ff7ee18de97027618a6cad3fe9fe6 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `check_collision` that takes a list of `rectangles` as input and checks if there are any collisions between any two rectangles. A rectangle is represented as a tuple (x, y, w, h) where (x, y) is the top-left corner of the rectangle, `w` is the width, and `h` is the height.
The function should r... | Here's how you could implement the `check_collision` function:
```python
def check_collision(rectangles):
for i in range(len(rectangles)):
for j in range(i + 1, len(rectangles)):
x1, y1, w1, h1 = rectangles[i]
x2, y2, w2, h2 = rectangles[j]
if x1 + w1 > x2 and x1 < x2 +... | def check_collision(rectangles):
'Write a Python function `check_collision` that takes a list of `rectangles` as input and checks if there are any collisions between any two rectangles. A rectangle is represented as a tuple (x, y, w, h) where (x, y) is the top-left corner of the rectangle, `w` is the width, and `h`... | for i in range(len(rectangles)):
for j in range(i + 1, len(rectangles)):
x1, y1, w1, h1 = rectangles[i]
x2, y2, w2, h2 = rectangles[j]
if x1 + w1 > x2 and x1 < x2 + w2 and (y1 + h1 > y2) and (y1 < y2 + h2):
return True
return False
| 324 | 1dff8a71069b7a767469ec77b8c8d90802d8e7e867fe617554d190bb383b20c2 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
219,475 | 4 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0d414e66e9959250b88f5419355616d128759bd5 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes two lists `A` and `B`, each representing a matrix, and returns their sum in the form of a new list. The matrices are of the same size, and each element of the output matrix is the sum of the corresponding elements in `A` and `B`. | You can create a Python function that takes two lists `A` and `B` as input. Both lists represent matrices of the same size. Each element of the output matrix is the sum of the corresponding elements in `A` and `B`.
Here's how you could do it:
```python
def matrix_sum(A, B):
rows = len(A)
cols = len(A[0])
... | def matrix_sum(A, B):
'Write a Python function that takes two lists `A` and `B`, each representing a matrix, and returns their sum in the form of a new list. The matrices are of the same size, and each element of the output matrix is the sum of the corresponding elements in `A` and `B`.'
| rows = len(A)
cols = len(A[0])
C = []
for i in range(rows):
row = []
for j in range(cols):
row.append(A[i][j] + B[i][j])
C.append(row)
return C
| 197 | 4712777cb9205f3f1f1101fd5c0b8c1a7b8161a9d9521c2d1733916585e13844 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
81,575 | 5 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 7d5eb4016d6a12ba12a343bbf02c37d4029e65f2 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Given a list of dictionaries, your goal is to traverse the list and create a new list with the value of the key `'id'` for each dictionary. For example, given `[{'id': 1, 'name': 'John'}, {'id': 2, 'name': 'Bob'}]`, the desired output would be `[1, 2]`. Make use of list comprehension and dictionary lookup to solve the ... | To achieve the desired result, we can use list comprehension in Python to iterate over the list of dictionaries and extract the `'id'` value for each dictionary. This allows us to create a new list with the extracted `'id'` values. Additionally, we can use dictionary lookup to retrieve the `'id'` value for each diction... | def extract_id_values(data: list) -> list:
"Given a list of dictionaries, your goal is to traverse the list and create a new list with the value of the key `'id'` for each dictionary. For example, given `[{'id': 1, 'name': 'John'}, {'id': 2, 'name': 'Bob'}]`, the desired output would be `[1, 2]`. Make use of list c... | return [dictionary['id'] for dictionary in data]
| 136 | 30b450aca858eeeb5e81aeb03532b3b8e900a08823cc03a844ab8c79f58b69e3 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
444,447 | 6 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | cc029e11d2de9c2ccedb4e60fbf030478468d9a9 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a list of strings and a special string, and returns a list of strings sorted using a lexicographic comparison. However, the special string should be treated as smaller than all other strings. The function should return a sorted list of strings in the same order as the input.
For exam... | To write a Python function that sorts a list of strings in lexicographic order while treating a special string as smaller than all other strings, you can follow these steps:
1. Create a list of strings that includes the special string as the first element.
2. Use the built-in `sorted` function to sort the list of stri... | def sort_strings(strings, special_string):
"Write a Python function that takes a list of strings and a special string, and returns a list of strings sorted using a lexicographic comparison. However, the special string should be treated as smaller than all other strings. The function should return a sorted list of s... | strings_with_special = [special_string] + [string for string in strings if string != special_string]
sorted_strings = sorted(strings_with_special)
sorted_strings.remove(special_string)
sorted_strings.insert(0, special_string)
return sorted_strings
| 216 | a4c6677ab226f7efbc7bdd278aa164eb85dc8f5c978a584629fd8acd0d4fc471 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
203,341 | 8 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0eb7c9940f38acc0cd148a8b54c99d9cd1e8cfb1 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Implement a Python function to convert a positive integer number from its decimal representation to its binary (base 2) representation as a string. Your function should recursively convert the integer number by repeatedly dividing it by 2 and adding the remainder to the result string. If the integer number is 0, return... | Here is a Python function that implements this approach:
```python
def decimal_to_binary(num: int) -> str:
"""
Converts a positive integer number from its decimal representation to its binary (base 2) representation.
"""
if num == 0:
return ""
return decimal_to_binary(num // 2) + str(num %... | def decimal_to_binary(num: int) -> str:
'Implement a Python function to convert a positive integer number from its decimal representation to its binary (base 2) representation as a string. Your function should recursively convert the integer number by repeatedly dividing it by 2 and adding the remainder to the resu... | if num == 0:
return ''
return decimal_to_binary(num // 2) + str(num % 2)
| 163 | 73322b0aaac92ce412693dbb9cbe4786a600e7f8371f6ac95dbdc1ca78f17697 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
348,373 | 9 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | d6bd365dcc69a4036248171931422b19c52c1745 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that returns the factorial of a given natural number. The function should support recursion and should be properly commented. The function should check for valid input and return an error message if the input is not a natural number.
Here is an example of a factorial function:
```python
def fa... | Here is a Python function that implements a factorial function using recursion:
```python
def factorial_recursive(n):
"""
Recursively calculates the factorial of a natural number.
Args:
n (int): The natural number.
Returns:
int: The factorial of n.
Raises:
ValueError: If ... | def factorial_recursive(n):
'Write a Python function that returns the factorial of a given natural number. The function should support recursion and should be properly commented. The function should check for valid input and return an error message if the input is not a natural number.\n\nHere is an example of a fa... | if n < 0:
raise ValueError('The input must be a natural number.')
elif n == 0:
return 1
else:
return n * factorial_recursive(n - 1)
| 358 | a401b142fac019cec82f9645b36f45399f8942d15d6b9bb320a444f81f49dd93 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
488,041 | 10 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 3edda847b270f1d013c9cb06731d220d7d629081 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a list of numbers and modifies it in place by squaring all the elements that are divisible by 3. You can do this by modifying the input list directly without returning a new list.
### Instruction (2)
Modify the function you wrote in the previous prompt to also modify the input list s... | To modify the input list in place, we can iterate over the list using a for loop, and update the elements that are divisible by 3 and 5. We can use the modulus operator (`%`) to check if an element is divisible by 3 or 5, and assign the appropriate value. For example, if the element is divisible by 3 but not 5, we can ... | def modify_list(nums):
'Write a Python function that takes a list of numbers and modifies it in place by squaring all the elements that are divisible by 3. You can do this by modifying the input list directly without returning a new list.\n\n### Instruction (2)\nModify the function you wrote in the previous prompt ... | for i in range(len(nums)):
if nums[i] % 3 == 0 and nums[i] % 5 != 0:
nums[i] = nums[i] ** 2
elif nums[i] % 5 == 0:
nums[i] = -1
| 283 | f8a3e0eb78f73505bf330e9c20906188421e6366bd014332d2f74f179e4db931 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
664,621 | 11 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 10fe03ab2ddb1a5602e816dac398e6ce57fca082 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to encode a list of integers into a string of characters. Convert each integer to its corresponding ASCII character and concatenate all characters together to form the final encoded string.
For example, given the list `[65, 66, 67]`, the function should return the string `'ABC'`. | To encode a list of integers into a string of characters, you need to convert each integer to its corresponding ASCII character and concatenate all characters together to form the final encoded string.
Python provides the `chr()` function to convert an integer to its corresponding ASCII character. You can use a list c... | def encode_list(input_list):
"Write a Python function to encode a list of integers into a string of characters. Convert each integer to its corresponding ASCII character and concatenate all characters together to form the final encoded string.\n\nFor example, given the list `[65, 66, 67]`, the function should retur... | return ''.join((chr(i) for i in input_list))
| 106 | 2f222d388bcac039a769d42c99cbb6412b61f6cee64a715d5247a289fba8e238 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
633,087 | 13 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 83c7445e1c4c2c034f609f19da0d9638b3d9dbf3 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to convert a list of keys and values into a dictionary. Keys must be unique and values may be duplicated. The function should transform the dictionary by grouping duplicate values into a set for each key. For example, given keys=[1, 2, 3, 4], values=[10, 20, 30, 40], the function should return {... | To transform the dictionary into the desired format by grouping duplicate values into a set for each key, we must iterate through each key-value pair and add the value to the corresponding set in the output dictionary. Since the keys must be unique, we can use a `dict` to represent the output, where the keys are the un... | def transform_dictionary(keys, values):
'Write a Python function to convert a list of keys and values into a dictionary. Keys must be unique and values may be duplicated. The function should transform the dictionary by grouping duplicate values into a set for each key. For example, given keys=[1, 2, 3, 4], values=[... | output = dict()
for key, value in zip(keys, values):
if key in output:
output[key].add(value)
else:
output[key] = {value}
return output
| 210 | 63c31573ebb75a7a21798c999d5a890afdfe5cb3b4013bec30a26227e15eb69b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
83,645 | 14 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1c8c98aea22c880aed2b2269b4077118b0782ab5 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `unwrap_string` that takes in a wrapped string and unwrapped it into a single string. Each line of the wrapped string is separated by a newline character, and the words in the wrapped string are separated by a single space.
For example, given the wrapped string `"Hello\nWorld"`, the output shou... | Here is an implementation of the `unwrap_string` function in Python:
```python
def unwrap_string(wrapped_string: str) -> str:
unwrapped_string = ''
for line in wrapped_string.split('\n'):
for word in line.split(' '):
unwrapped_string += word + ' '
return unwrapped_string.strip()
```
Th... | def unwrap_string(wrapped_string: str) -> str:
'Write a Python function `unwrap_string` that takes in a wrapped string and unwrapped it into a single string. Each line of the wrapped string is separated by a newline character, and the words in the wrapped string are separated by a single space.\n\nFor example, give... | unwrapped_string = ''
for line in wrapped_string.split('\n'):
for word in line.split(' '):
unwrapped_string += word + ' '
return unwrapped_string.strip()
| 187 | 05a21f03f41033df63fec413eaa42ed36e032f871505bd4479feb1a041ba32ec | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
685,252 | 16 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | ce93cdeeacd8de5eb1d752300c738212ed84bd25 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to calculate the sum of the first `n` natural numbers. Implement the function using a list comprehension and arithmetic operations.
Your code should pass the following assertions:
```python
assert sum_of_natural_numbers(1) == 1
assert sum_of_natural_numbers(5) == 15
``` | Here's how you can implement this:
```python
def sum_of_natural_numbers(n):
return sum(x for x in range(1, n + 1))
```
The `sum()` function calculates the sum of the elements in the range generated by the `range()` function, which is a list comprehension. | def sum_of_natural_numbers(n):
'Write a Python function to calculate the sum of the first `n` natural numbers. Implement the function using a list comprehension and arithmetic operations.\n\nYour code should pass the following assertions:\n```python\nassert sum_of_natural_numbers(1) == 1\nassert sum_of_natural_numb... | return sum((x for x in range(1, n + 1)))
| 119 | fd797b73349d8afa27b9b5556c3977fe857f68ab9ff21a11daba1d5655c38ac9 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
308,607 | 17 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | e71011b4ab911714ad4758a54fdc40814c9f65ec | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function that takes two strings, `s1` and `s2`, and return their numerical difference. If either string cannot be converted to a valid number, return 0.
Your code should pass the following assertions:
```python
assert numerical_difference("123", "100") == 23
assert numerical_difference("abc", "100") ==... | You can use the `int()` function to convert strings to integers and the `try-except` block to catch the `ValueError` exception when a string cannot be converted to an integer. A simple way to find the numerical difference is to subtract `s2` from `s1`.
Here's how you can do it in Python:
```python
def numerical_diffe... | def numerical_difference(s1, s2):
'Create a Python function that takes two strings, `s1` and `s2`, and return their numerical difference. If either string cannot be converted to a valid number, return 0.\n\nYour code should pass the following assertions:\n```python\nassert numerical_difference("123", "100") == 23\n... | try:
num1 = int(s1)
num2 = int(s2)
return num1 - num2
except ValueError:
return 0
| 178 | b20d5cf02122f6af7c1b2827566e72db81afb383de1d19c45078b1958cf2edab | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
341,460 | 19 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | cb0cf03efa3e97bfae8f62f0a1c9c0a1332240b9 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a function `sum_dict` that takes two dictionaries, `d1` and `d2`, as input, and returns a new dictionary that contains the sum of the values of the two dictionaries. If a key exists in both dictionaries, then the value of the key in the resulting dictionary should be the sum of the values from the two dictionarie... | To create a new dictionary that contains the sum of the values of the two input dictionaries, you can follow these steps:
1. Create an empty dictionary to store the resulting dictionary.
2. Iterate through each key-value pair in the first dictionary, `d1`.
3. If the key exists in the second dictionary, `d2`, then add ... | def sum_dict(d1, d2):
'Write a function `sum_dict` that takes two dictionaries, `d1` and `d2`, as input, and returns a new dictionary that contains the sum of the values of the two dictionaries. If a key exists in both dictionaries, then the value of the key in the resulting dictionary should be the sum of the valu... | result = {}
for key, value in d1.items():
if key in d2:
result[key] = value + d2[key]
else:
result[key] = value
for key, value in d2.items():
if key not in d1:
result[key] = value
return result
| 415 | c61697bb4b4aff04f6e55d32c9d716159eb62ae4ed7793d4b36251467e3efcf8 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
573,825 | 21 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 8c5e07915785588e3f17774111e7eadc3641eb89 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | I have a Python script that generates a nested data structure to represent a company's organizational structure. The data structure is a dictionary where each key-value pair represents a department and its employees, respectively. Here's an example:
```python
{
'Engineering': [
'Alice',
'Bob',
... | Here's a Python function that implements this approach:
```python
def get_all_employees(departments):
employees = []
for department, employees_list in departments.items():
employees.extend(employees_list)
for employee in employees_list:
if isinstance(employee, dict):
... | def get_all_employees(departments):
"I have a Python script that generates a nested data structure to represent a company's organizational structure. The data structure is a dictionary where each key-value pair represents a department and its employees, respectively. Here's an example:\n\n```python\n{\n 'Enginee... | employees = []
for department, employees_list in departments.items():
employees.extend(employees_list)
for employee in employees_list:
if isinstance(employee, dict):
employees.extend(get_all_employees(employee))
return employees
| 422 | 99fc971f6b71e990f35d20d5a329e3a507f3101d4c56aa6a1994450026369bd5 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
405,938 | 22 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | bd4d372abdd2b338538c17f55bc115ba001974ba | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to calculate the intersection of union (IoU) metric between two bounding boxes represented as dictionaries with the following structure: `{ 'x': <float>, 'y': <float>, 'width': <float>, 'height': <float> }`. | Here is how you could implement the IoU metric function in Python:
```python
def calculate_iou(box1, box2):
x1 = max(box1['x'], box2['x'])
y1 = max(box1['y'], box2['y'])
x2 = min(box1['x'] + box1['width'], box2['x'] + box2['width'])
y2 = min(box1['y'] + box1['height'], box2['y'] + box2['height'])
i... | def calculate_iou(box1, box2):
"Write a Python function to calculate the intersection of union (IoU) metric between two bounding boxes represented as dictionaries with the following structure: `{ 'x': <float>, 'y': <float>, 'width': <float>, 'height': <float> }`."
| x1 = max(box1['x'], box2['x'])
y1 = max(box1['y'], box2['y'])
x2 = min(box1['x'] + box1['width'], box2['x'] + box2['width'])
y2 = min(box1['y'] + box1['height'], box2['y'] + box2['height'])
if x1 > x2 or y1 > y2:
return 0.0
intersection_area = (x2 - x1) * (y2 - y1)
box1_area = box1['... | 320 | 3da01bfbb8dd5efbdd5428d2e125d8b665ed94bc22b704192387fbd39d2a9a8a | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
308,824 | 23 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | bba510fc27918e09f10ee5d5825828fd7421eb2b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to initialize a table of 0s, where the table size is determined by the input. The input is a list of two integers, `row` and `col`, indicating the number of rows and columns of the table.
For example, if the input is `[2, 3]`, the function should return `[[0, 0, 0], [0, 0, 0]]`. | Here is the implementation:
```python
def initialize_table(row, col):
return [[0 for _ in range(col)] for _ in range(row)]
``` | def initialize_table(row, col):
'Write a Python function to initialize a table of 0s, where the table size is determined by the input. The input is a list of two integers, `row` and `col`, indicating the number of rows and columns of the table.\n\nFor example, if the input is `[2, 3]`, the function should return `[... | return [[0 for _ in range(col)] for _ in range(row)]
| 125 | 0ae2d1feb3dc4e08a3702bb5a9ddc99debb7d7be65cc165043e561ff2965887d | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
499,120 | 26 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | b528d132ac85fa1b81bd872360a8f6e946e50252 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Given a list that contains some empty elements, write a Python function to filter out these empty elements and return a new list with only non-empty elements.
Your code should pass the following test case:
```python
lst = [1, 2, 3, None, 4, None, 5]
expected_result = [1, 2, 3, 4, 5]
assert remove_empty(lst) == expecte... | To filter out empty elements from a list in Python, we can leverage the `filter` function and provide a predicate function that checks if the element is not empty. The `filter` function will return a generator object, which we can convert into a list using the `list` function.
Here is the implementation of the `remove... | def remove_empty(lst: list) -> list:
'Given a list that contains some empty elements, write a Python function to filter out these empty elements and return a new list with only non-empty elements.\n\nYour code should pass the following test case:\n```python\nlst = [1, 2, 3, None, 4, None, 5]\nexpected_result = [1, ... | return list(filter(None, lst))
| 136 | d4b5fd9bde792a8eba0d6840cfde305e3c461348f57e5415ba4005844d23da6b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
286,053 | 28 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | c16fa2f74d00d030f4822f8187d11b1eeefa1ecf | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a non-negative integer, representing a number of seconds, and converts it to a string representing the time in hours:minutes:seconds format.
For example, 120 seconds should be converted to "0:02:00". | To accomplish this, we'll need to divide the given number of seconds into hours, minutes, and seconds. Then, we'll convert each component to a string and concatenate them with ":" between them.
Here's a possible implementation:
```python
def seconds_to_time(seconds):
hours = seconds // 3600
seconds %= 3600
... | def seconds_to_time(seconds):
'Write a Python function that takes a non-negative integer, representing a number of seconds, and converts it to a string representing the time in hours:minutes:seconds format.\n\nFor example, 120 seconds should be converted to "0:02:00".'
| hours = seconds // 3600
seconds %= 3600
minutes = seconds // 60
seconds %= 60
return f'{hours}:{minutes:02}:{seconds:02}'
| 131 | 988aaf27b1e8c6bb5990a25f627b1539832fa031ca0b06e57367bda7fa240898 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
425,915 | 29 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 49506f86c0c41810308f6a1f73bf13251a32ee60 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Given a dictionary `d`, write a Python function that returns a shallow copy of `d` by omitting entries with missing keys. Let's call this new dictionary `d_copy`.
If any of the entries of `d_copy` has a value type of dictionary, then delete the entire dictionary entry from `d_copy`. For example, if `d = {'a': 1, 'b': ... | To solve this problem, we can use a dictionary comprehension to iterate over the keys and values of the given dictionary `d`. We can check if the value of each entry is a dictionary and delete it from the dictionary comprehension, otherwise return the value. Finally, we can use the dictionary comprehension to return th... | def copy_omit_missing(d: dict) -> dict:
"Given a dictionary `d`, write a Python function that returns a shallow copy of `d` by omitting entries with missing keys. Let's call this new dictionary `d_copy`.\n\nIf any of the entries of `d_copy` has a value type of dictionary, then delete the entire dictionary entry fro... | return {k: v for k, v in d.items() if not isinstance(v, dict)}
| 173 | aac394ef39cc596a429d7c0aca585e824ab609298a6f1d2753ab743c4909904c | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
138,396 | 31 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | daaa898afff0d0476adf8e258089073555ec1565 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function named `filter_and_update_dict`. This function takes two dictionaries as input parameters: `input_dict` and `update_dict`. The function filters the `update_dict` based on the keys that exist in `input_dict` and updates the values of the `input_dict` with the filtered `update_dict`. The function s... | To implement this function, we can iterate through the keys of `input_dict` and check if they exist in `update_dict`. If they do, we update the corresponding values in `input_dict` with the values from `update_dict`. We can use a `for` loop to iterate through the keys of `input_dict`, and use the `in` operator to check... | def filter_and_update_dict(input_dict, update_dict):
"Write a Python function named `filter_and_update_dict`. This function takes two dictionaries as input parameters: `input_dict` and `update_dict`. The function filters the `update_dict` based on the keys that exist in `input_dict` and updates the values of the `i... | for key in input_dict:
if key in update_dict:
input_dict[key] = update_dict[key]
return input_dict
| 279 | 4f7b883c48c9a94f9da9ac8153dd23a26367b4e2ceac440d4f32de6d697e631b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
678,255 | 32 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 059f200a22ca2c6cfa40e5562f7a9beb12222a8f | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `intersection` that takes two lists `A` and `B` and returns a new list `C` that contains only the elements that are common between the two lists. Use a list comprehension to construct the list `C`. The function should not modify the input lists. | Here is the implementation of the `intersection` function:
```python
def intersection(A, B):
C = [x for x in A if x in B]
return C
```
This implementation uses a list comprehension to construct the desired list `C`. The list comprehension iterates over elements `x` in `A` and checks if `x` is also present in ... | def intersection(A, B):
'Write a Python function `intersection` that takes two lists `A` and `B` and returns a new list `C` that contains only the elements that are common between the two lists. Use a list comprehension to construct the list `C`. The function should not modify the input lists.'
| C = [x for x in A if x in B]
return C
| 97 | b43fdb494305c0bc1141a5d0b72b7e1350bc2e4945ca8fc8050568b3e6f45cb2 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
194,606 | 33 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | f1bd02ac89c24f44bfff990e4ca278d175e92938 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Implement a Python function `compare_integers(n1, n2)` that compares two integers and returns their comparison status as a string. The input integers can be of any type (int, float, or string). The function should handle input validation to ensure that the inputs are valid integers (or can be converted to valid integer... | ```python
def compare_integers(n1, n2):
if not isinstance(n1, (int, float)) or not isinstance(n2, (int, float)):
try:
n1 = int(n1)
n2 = int(n2)
except ValueError:
raise ValueError("Inputs must be integers or convertible to integers.")
if n1 == n2:
ret... | def compare_integers(n1, n2):
'Implement a Python function `compare_integers(n1, n2)` that compares two integers and returns their comparison status as a string. The input integers can be of any type (int, float, or string). The function should handle input validation to ensure that the inputs are valid integers (o... | if not isinstance(n1, (int, float)) or not isinstance(n2, (int, float)):
try:
n1 = int(n1)
n2 = int(n2)
except ValueError:
raise ValueError('Inputs must be integers or convertible to integers.')
if n1 == n2:
return 'equal'
elif n1 > n2:
ret... | 310 | f309c7739a5f8c6fbcae44c3c1f0bd54d44fd1e1b89a7e4029dd65fcbe875e90 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
564,393 | 34 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1fd6596e16af1e73525efa7b8fe37c5b48c08996 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Develop a Python function `is_prime` that determines whether a given integer `n` is prime. The function should return a Boolean value indicating whether `n` is prime or not.
Your code should pass the following assertions:
```python
assert is_prime(8) == False
assert is_prime(2) == True
assert is_prime(3) == True
``` | To check if a given number `n` is prime, we can follow a well-known algorithm that checks for divisibility by all numbers between 2 and `n**0.5`. This is because any number greater than `n**0.5` will have a corresponding divisor less than or equal to `n**0.5`.
Here is the implementation of the `is_prime` function:
``... | def is_prime(n):
'Develop a Python function `is_prime` that determines whether a given integer `n` is prime. The function should return a Boolean value indicating whether `n` is prime or not.\n\nYour code should pass the following assertions:\n```python\nassert is_prime(8) == False\nassert is_prime(2) == True\nasse... | if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
| 182 | 00e4bbaeb31ab3ebb5fa5b8b2c8b2a437ae4ed6f0e14cd968e096c0688a22482 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
562,005 | 36 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 24e3b16ef8344ba3799fffb896060bc621939d75 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to convert temperature data between Celsius and Fahrenheit. The function takes two arguments: the temperature value and the unit, which is either `'C'` for Celsius or `'F'` for Fahrenheit. The function should return the converted temperature in the chosen unit.
Here's the conversion formula:
$... | To satisfy the given instruction, you could write a Python function that takes two arguments, the temperature value and the unit. The function should return the converted temperature in the desired unit. Here is how you could achieve that:
1. Define a function `convert_temperature(value, unit)`
2. Check if the unit is... | def convert_temperature(value, unit):
"Write a Python function to convert temperature data between Celsius and Fahrenheit. The function takes two arguments: the temperature value and the unit, which is either `'C'` for Celsius or `'F'` for Fahrenheit. The function should return the converted temperature in the chos... | if unit == 'C':
return value * 9 / 5 + 32
elif unit == 'F':
return (value - 32) * 5 / 9
else:
raise ValueError("Invalid unit: must be 'C' or 'F'")
| 243 | 763881e5b2186ca7f200541fea8f957c01e9e1d771f6a5ba6dc4ba9b4032cb26 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
231,456 | 37 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | e546bbfe95b22c3f1a000584c94a7592a248a483 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function to convert a tuple of HSV (Hue, Saturation, Value) color values to a tuple of RGB (Red, Green, Blue) color values. The input tuple consists of 3 values between 0 and 1, where the first value represents the hue, the second the saturation, and the third the value. The output tuple should consist ... | The HSV color space is a cylindrical color model, while the RGB color space is a Cartesian color model. The HSV model is used in color selection tools such as color wheels and sliders.
To convert a tuple of HSV color values to RGB, you can use the following steps:
1. Normalize the input HSV values between 0 and 1.
2. ... | def hsv_to_rgb(h, s, v):
'Create a Python function to convert a tuple of HSV (Hue, Saturation, Value) color values to a tuple of RGB (Red, Green, Blue) color values. The input tuple consists of 3 values between 0 and 1, where the first value represents the hue, the second the saturation, and the third the value. Th... | h = h / 360.0
s = s / 100.0
v = v / 100.0
c = v * s
x = c * (1 - abs(h * 6.0 % 2 - 1))
m = v - c
if h < 1 / 6:
r, g, b = (c, x, 0)
elif h < 2 / 6:
r, g, b = (x, c, 0)
elif h < 3 / 6:
r, g, b = (0, c, x)
elif h < 4 / 6:
r, g, b = (0, x, c)
elif ... | 473 | aab2300964898063ad78934ee16d140f595749edda9b10f2fae804a75130d8a5 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
46,719 | 40 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 351ec07ed8e9c12728a6ae033eaaba7585ccf29d | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that calculates the interest rate on a loan. Your function should take as input the loan amount, interest rate, and number of years and return the interest.
Your code should pass the following test case:
```python
loan_amount = 10000
interest_rate = 5
number_of_years = 3
assert calculate_intere... | Here's how we can implement this in Python:
```python
def calculate_interest(loan_amount, interest_rate, number_of_years):
interest = loan_amount * (interest_rate / 100) * number_of_years
return interest
```
In this implementation, the `calculate_interest` function takes three arguments: `loan_amount`, `inter... | def calculate_interest(loan_amount, interest_rate, number_of_years):
'Write a Python function that calculates the interest rate on a loan. Your function should take as input the loan amount, interest rate, and number of years and return the interest.\n\nYour code should pass the following test case:\n```python\nloa... | interest = loan_amount * (interest_rate / 100) * number_of_years
return interest
| 161 | f28725fde8fe7cc29e8bc3e989e5ef3ee71409afbd966482fa057bcfbdb5a55d | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
352,426 | 41 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 6621d6a12ed2b43038bf5fc59278f3148557b5a0 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function that returns a list of all the keys in a dictionary that start with a given prefix. For instance, given prefix "a", the function should return ["apple", "aardvark", "avocado"] for the following dictionary:
```python
{"apple": 1, "aardvark": 3, "avocado": 2, "banana": 5}
```
Your code should p... | To create a function that returns a list of all keys in a dictionary that start with a given prefix, you can iterate over the dictionary keys and check if each key starts with the prefix.
Here's how you could do it:
```python
def get_keys_with_prefix(dictionary, prefix):
keys_with_prefix = []
for key in dict... | def get_keys_with_prefix(dictionary, prefix):
'Create a Python function that returns a list of all the keys in a dictionary that start with a given prefix. For instance, given prefix "a", the function should return ["apple", "aardvark", "avocado"] for the following dictionary:\n\n```python\n{"apple": 1, "aardvark":... | keys_with_prefix = []
for key in dictionary:
if key.startswith(prefix):
keys_with_prefix.append(key)
return keys_with_prefix
| 272 | 320ced5012c214d80651028eb4f7964d0b12e3329caa27a7c2b476d2ef6a55f2 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
98,467 | 42 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0b5ade96aa4b5fd3c55969aa22a0501549600d6b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that checks if an object is a subclass of a given class. The function should safely handle exceptions and return `False` if an exception is raised. | To check if an object is a subclass of a given class, we can use the `issubclass()` function. This function checks if a given object is a subclass of another class. It returns `True` if it is a subclass, and `False` otherwise.
However, there is a potential corner case where an exception can be raised when checking if ... | def is_subclass(object, class_):
'Write a Python function that checks if an object is a subclass of a given class. The function should safely handle exceptions and return `False` if an exception is raised.'
| try:
return issubclass(object, class_)
except TypeError:
return False
| 94 | a2fa1edaf4df5cda1baeb443832ddb5caa7696bc19337b80f2df69e140b0562f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
153,541 | 43 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 888a92fdec286699e9582be367fe64681ee4de3d | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that accepts a single parameter `tuple_of_lists` representing a tuple of lists. The function should merge these lists into a single list, preserving the order of elements from the original lists. If a list is None or empty, it should be ignored. The function should return the merged list. | To merge a tuple of lists into a single list, we can use a loop to traverse each list in the tuple and add its elements to the merged list. We need to check if the list is not None or empty, and only add its elements if it is valid.
```python
def merge_lists(tuple_of_lists):
merged_list = []
for lst in tuple_... | def merge_lists(tuple_of_lists):
'Write a Python function that accepts a single parameter `tuple_of_lists` representing a tuple of lists. The function should merge these lists into a single list, preserving the order of elements from the original lists. If a list is None or empty, it should be ignored. The function... | merged_list = []
for lst in tuple_of_lists:
if lst is not None and len(lst) > 0:
merged_list.extend(lst)
return merged_list
| 160 | bf0e3f3a1c7df62c369bd5c965369db211a5ca0c6ea095e70ccf463eed72907c | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
439,509 | 46 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0dfe72b32b05cba042da4e0c58957da7a32ed5b8 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Code a Python function that takes a string as input and returns an integer denoting the total number of times the string's first character occurs anywhere in the string.
For example, given the string `aaab`, the function should return `3` because the first character `a` occurs three times in the string. | Here's a Python implementation of a function that takes a string as input and returns the total number of times the string's first character occurs anywhere in the string:
```python
def count_first_character(string):
first_char = string[0]
count = 0
for char in string:
if char == first_char:
... | def count_first_character(string):
"Code a Python function that takes a string as input and returns an integer denoting the total number of times the string's first character occurs anywhere in the string.\n\nFor example, given the string `aaab`, the function should return `3` because the first character `a` occurs... | first_char = string[0]
count = 0
for char in string:
if char == first_char:
count += 1
return count
| 147 | 9138aeefc97f00c94e8d77de2c9cc16052fb46c8e19073e09d67dbd7dc7add31 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
373,709 | 52 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 44233f41e689443e44f401ce518e7e1ef4cc4023 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Define a Python function `sum_ints_as_strings` that takes two strings representing integers, and returns their sum. It should handle input errors like non-numeric inputs, integer overflow, and handle all possible exceptions. | ```python
def sum_ints_as_strings(s1, s2):
try:
i1 = int(s1)
i2 = int(s2)
return str(i1 + i2)
except ValueError:
raise ValueError('Invalid input, non-numeric value')
except OverflowError:
raise OverflowError('Integer overflow')
```
This function uses `int()` to conve... | def sum_ints_as_strings(s1, s2):
'Define a Python function `sum_ints_as_strings` that takes two strings representing integers, and returns their sum. It should handle input errors like non-numeric inputs, integer overflow, and handle all possible exceptions.'
| try:
i1 = int(s1)
i2 = int(s2)
return str(i1 + i2)
except ValueError:
raise ValueError('Invalid input, non-numeric value')
except OverflowError:
raise OverflowError('Integer overflow')
| 178 | 9c730bb38b35b15ac709a95d87bfd6af441335dd14fa53d00f41910900565468 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
667,865 | 53 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 84bcb62a73a13f10aafea59772d2186013e2fe0b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `query_replace` that replaces the values in an object that contains a mix of strings, integers, and floats. The function should take two arguments: `query_obj`, an object that contains objects, strings, and arrays, and `replacement`, the string to replace with. The function should recursively tr... | To write a Python function `query_replace` that replaces the values in an object that contains a mix of strings, integers, and floats, we can leverage the power of Python's dynamic typing and recursion. Python provides us with the flexibility to handle different data types dynamically, and as a language, it is particul... | def query_replace(query_obj, replacement):
'Write a Python function `query_replace` that replaces the values in an object that contains a mix of strings, integers, and floats. The function should take two arguments: `query_obj`, an object that contains objects, strings, and arrays, and `replacement`, the string to ... | if isinstance(query_obj, str):
return replacement
elif isinstance(query_obj, list):
return [query_replace(item, replacement) for item in query_obj]
elif isinstance(query_obj, dict):
return {key: query_replace(value, replacement) for key, value in query_obj.items()}
else:
... | 281 | 98c4a9c2a7bfb03a71f534665a8d8eb996aadbaaf20f2cab87b1749008406fbd | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
205,886 | 54 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 7ec98ea81252e692cc20d3204ef7346a0a573174 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes an array and returns `True` if all its elements are unique, or `False` if there is at least one duplicate.
Your code should pass the following test case:
```python
arr1 = [1, 2, 3, 4, 5]
arr2 = [1, 1, 2, 2, 3]
assert has_duplicates(arr1) == False
assert has_duplicates(arr2) == True
`... | Here's how we can implement this using a set:
```python
def has_duplicates(arr):
unique_elements = set(arr)
return len(arr) != len(unique_elements)
``` | def has_duplicates(arr):
'Write a Python function that takes an array and returns `True` if all its elements are unique, or `False` if there is at least one duplicate.\n\nYour code should pass the following test case:\n```python\narr1 = [1, 2, 3, 4, 5]\narr2 = [1, 1, 2, 2, 3]\nassert has_duplicates(arr1) == False\n... | unique_elements = set(arr)
return len(arr) != len(unique_elements)
| 160 | b1eff1ca592469f777d46c1024449a0ebf03ee45328fe659ae582a6f10a4ef6b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
265,257 | 55 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 9e5c2c417969f293ee4d89119cd173b512e2ff2b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function named `simple_cmp` that compares two objects by the result of a custom comparison function.
Input: Two objects to compare, and a comparison function that takes two objects as arguments and returns -1, 0, or 1 depending on whether the first object is less than, equal to, or greater than the seco... | To compare two objects by the result of a custom comparison function, you can define a function named `simple_cmp` that takes two objects and a comparison function as arguments. The function will then call the comparison function on the two objects and return the result.
Here's how you could implement the `simple_cmp`... | def simple_cmp(obj1, obj2, cmp_func):
'Write a Python function named `simple_cmp` that compares two objects by the result of a custom comparison function.\n\nInput: Two objects to compare, and a comparison function that takes two objects as arguments and returns -1, 0, or 1 depending on whether the first object is ... | return cmp_func(obj1, obj2)
| 145 | 9aa16baa707110b552fe1e334dfc0b7c201b55d42b7b060a8ee1b468931d4f4c | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
231,465 | 56 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0b9098b026b4fa2a96c7eb24c4e6bedd12cb5853 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `process_data` to process a list of data objects, each of which has a `name` and a `value` property, into a single string. The string should concatenate the `name` and `value` properties for each object, separated by colons and then a newline. | This is how you can implement the function in Python:
```python
def process_data(data_list):
processed_data = []
for data in data_list:
processed_data.append(f"{data.name}:{data.value}")
return "\n".join(processed_data)
```
The function iterates through the list of data objects, extracts the `name... | def process_data(data_list):
'Write a Python function `process_data` to process a list of data objects, each of which has a `name` and a `value` property, into a single string. The string should concatenate the `name` and `value` properties for each object, separated by colons and then a newline.'
| processed_data = []
for data in data_list:
processed_data.append(f'{data.name}:{data.value}')
return '\n'.join(processed_data)
| 145 | 5db9af0403de41e579e03a94935274bdac9b556e75fd51f81dabc5e8efa6a8d4 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
502,052 | 57 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1874d20da5f44587fb292ae8a899d0eadffe32dd | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a dictionary d and a list l as parameters and returns a dictionary containing all the key-value pairs from d whose keys are in l. That is, the function should return a dictionary with keys from l and the corresponding values from d. The function should return an empty dictionary if d ... | For this task, we want to create a Python function that takes a dictionary `d` and a list `l` as parameters and returns a dictionary containing all the key-value pairs from `d` whose keys are in `l`.
To accomplish this, we can use a dictionary comprehension to construct the result dictionary. We can iterate over the k... | def filter_dict_by_keys(d: dict, l: list) -> dict:
'Write a Python function that takes a dictionary d and a list l as parameters and returns a dictionary containing all the key-value pairs from d whose keys are in l. That is, the function should return a dictionary with keys from l and the corresponding values from... | if not d or not l:
return {}
return {k: d[k] for k in l if k in d}
| 146 | 831fc0cd062e981bd3fa61929801c1061d18abd5b140c8a59421d99ed092be3f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
517,200 | 58 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 9e0728f0a1881fd40e9f754f8745c0ef35d28b90 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | I am writing a bittorrent client, and I need a function to encode an integer into a byte string in bencode format. Here are the rules:
- if the value is an integer, it is represented as `i{value}e`.
- if the value is a string, it is represented as `{length}:{value}`, where `{length}` is the length of the string in byt... | For the bittorrent client, you need to encode an integer into a byte string in bencode format. Bencode is a binary-based encoding format used in the BitTorrent protocol to represent different data types, including integers, strings, lists, and dictionaries. Here's how to encode an integer in bencode format:
1. Determi... | def encode_integer(value: int) -> bytes:
'I am writing a bittorrent client, and I need a function to encode an integer into a byte string in bencode format. Here are the rules:\n\n- if the value is an integer, it is represented as `i{value}e`.\n- if the value is a string, it is represented as `{length}:{value}`, wh... | if not isinstance(value, int):
raise TypeError('Value must be an integer')
return f'i{value}e'.encode()
| 228 | d5aa43b7772ee210ceb99fc8093e321b534c702da82acf1cfc7b48fecd12e1ab | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
157,454 | 60 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 3df28fbc71a64c5c51c4a6ea9b0f8e98d001b04f | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `all_true` that accepts a list or tuple of boolean values and returns True if and only if all values are True. You should solve this problem using only one line of code and without using any conditional statements (if, else, and/or for-loops). Your solution should use Python's `all` function as ... | Here is the implementation of the `all_true` function using only one line of code and without using any conditional statements:
```python
def all_true(values):
return all(value is True for value in values)
``` | def all_true(values):
"Write a Python function `all_true` that accepts a list or tuple of boolean values and returns True if and only if all values are True. You should solve this problem using only one line of code and without using any conditional statements (if, else, and/or for-loops). Your solution should use ... | return all((value is True for value in values))
| 222 | ea2d68cc3bca999555f7b80dda69092b71646bbf79fb69fbe2ae100232a907f0 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
447,357 | 63 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 53c3b3d1659832d3c4ac7bc8aae6e98786874ca6 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Develop a Python function named `sum_of_numbers()` that calculates the sum of all numbers in a given input list (either list of numbers or list of lists of numbers) recursively. The input can be a nested list containing integers and other nested lists.
Your task is to return the sum of all numbers in the input list. I... | Here is the implementation of the `sum_of_numbers()` function:
```python
def sum_of_numbers(input_list):
total = 0
for element in input_list:
if isinstance(element, list):
total += sum_of_numbers(element)
elif isinstance(element, int):
total += element
else:
... | def sum_of_numbers(input_list):
'Develop a Python function named `sum_of_numbers()` that calculates the sum of all numbers in a given input list (either list of numbers or list of lists of numbers) recursively. The input can be a nested list containing integers and other nested lists.\n\nYour task is to return the ... | total = 0
for element in input_list:
if isinstance(element, list):
total += sum_of_numbers(element)
elif isinstance(element, int):
total += element
else:
total += 0
return total
| 237 | 73946dab1261687d05bbe507659b558898f345c261272dbe8e001b60193f0144 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
45,658 | 64 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | dbb41e4d490bb6495fa1e3440472b72614a47075 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `convert` that accepts two arguments: `number` and `base` (a number between 2 and 16). The function should convert the given number to the corresponding value in the given base. Your solution should not use built-in functions that directly convert numbers to other bases, like `int.to_base()` or ... | You can create a Python function that takes in a `number` and `base` as arguments. The function should convert the given number to the corresponding value in the given base without using built-in functions that directly convert numbers to other bases.
Here's an implementation of the `convert` function:
```python
def ... | def convert(number, base):
"Write a Python function `convert` that accepts two arguments: `number` and `base` (a number between 2 and 16). The function should convert the given number to the corresponding value in the given base. Your solution should not use built-in functions that directly convert numbers to other... | digit_map = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, 'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15}
result = ''
quotient = number
while quotient > 0:
remainder = quotient % base
digit = digit_map[str(remainder)]
result = str(digit) +... | 385 | 3e7b6886cc72228b45e60fbabe8d83c56885d97e617fd9af92b586bdbd89f518 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
455,476 | 65 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | b8d15873c30ef8d412d242dfec7f3c1e01e9c628 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Implement a recursive quick sort algorithm in Python. If the input is already sorted, it should return the input without modification. If the input is not sorted, it should sort the input using a recursive algorithm. If the input is empty, it should return an empty list. If the input is invalid, it should raise a `Valu... | Here's an implementation of the quick sort algorithm using Python:
```python
def quick_sort(arr):
if len(arr) <= 1: # Base case: the array is already sorted
return arr
pivot = arr[0] # Choose the first element as the pivot
left = [x for x in arr[1:] if x < pivot] # Elements less than the pivot
... | def quick_sort(arr):
'Implement a recursive quick sort algorithm in Python. If the input is already sorted, it should return the input without modification. If the input is not sorted, it should sort the input using a recursive algorithm. If the input is empty, it should return an empty list. If the input is invali... | if len(arr) <= 1:
return arr
pivot = arr[0]
left = [x for x in arr[1:] if x < pivot]
right = [x for x in arr[1:] if x >= pivot]
return quick_sort(left) + [pivot] + quick_sort(right)
| 322 | 72b539e07724a6eea3d8b5412429a9afcc5cd1b8ee04c04b4dbb8766ff743e7d | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
252,539 | 68 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 046253aa6efec87af56ddf2d13710b9fbe3cc6a7 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `binarize_array` to binarize an array. The function takes a 2D array and a threshold value as the input. The function should return a binary array of the same shape as the input, where each element is either 0 or 1. An element in the output array is 1 if the corresponding element in the input ar... | To binarize an array, we need to validate its dimension and element values. If the array is not a 2D array, we raise an `InvalidArrayDimensionError` with a custom error message. If the array contains non-numeric values, we raise an `InvalidArrayElementError` with a custom error message indicating the invalid element va... | def binarize_array(array, threshold):
'Write a Python function `binarize_array` to binarize an array. The function takes a 2D array and a threshold value as the input. The function should return a binary array of the same shape as the input, where each element is either 0 or 1. An element in the output array is 1 i... | if not isinstance(array, list) or len(array) == 0 or (not all((isinstance(subarray, list) and len(subarray) == len(array[0]) for subarray in array))):
raise InvalidArrayDimensionError(f'Expected 2D array, got {type(array)}.')
for i, row in enumerate(array):
for j, element in enumerate(row):
... | 816 | bc909bd382110be54161836d3c2db2d98cc512c2002d9703a4c44425170c0cb5 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
246,348 | 72 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 2d615bd5c0869c487bcc19677db26f85ccd6487b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `flatten_paths` that takes a dictionary of paths and values and flattens it into a list of tuples, where each tuple consists of a single path string and its corresponding value. The path strings should be created by joining the dictionary's nested keys with a forward slash (/) separator. For exa... | To flatten a dictionary of paths and values, we can recursively traverse the dictionary and build the path strings as we go. When we encounter a leaf node (a value instead of a dictionary), we can add the path tuple to the result.
Here's a recursive implementation:
```python
def flatten_paths(input_dict, path=""):
... | def flatten_paths(input_dict, path=''):
"Write a Python function `flatten_paths` that takes a dictionary of paths and values and flattens it into a list of tuples, where each tuple consists of a single path string and its corresponding value. The path strings should be created by joining the dictionary's nested key... | result = []
for key, value in input_dict.items():
if isinstance(value, dict):
result.extend(flatten_paths(value, path + key + '/'))
else:
result.append((path + key, value))
return result
| 281 | 16aea31dddb4479d44127bd87e6e9008ff75610c0f16c5ed72ea7afa56a5783b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
345,145 | 73 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 51f13e51e0a4f3e4281d1593e13079943febeda1 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | For a given dictionary, recursively flatten all nested dictionaries to a single dictionary. For example, given `{'a': 1, 'b': {'c': 2, 'd': 3}}`, the output should be `{'a': 1, 'b.c': 2, 'b.d': 3}`. | To recursively flatten a nested dictionary, we can use a recursive function to traverse the dictionary and handle nested dictionaries. The function can take a dictionary as input and return a flattened dictionary.
Here is a Python function that implements this approach:
```python
def flatten_dictionary(d):
"""
... | def flatten_dictionary(d):
"For a given dictionary, recursively flatten all nested dictionaries to a single dictionary. For example, given `{'a': 1, 'b': {'c': 2, 'd': 3}}`, the output should be `{'a': 1, 'b.c': 2, 'b.d': 3}`."
| def _flatten(d, parent_key):
items = []
for k, v in d.items():
new_key = f'{parent_key}.{k}' if parent_key else k
if isinstance(v, dict):
items.extend(_flatten(v, new_key))
else:
items.append((new_key, v))
return items
r... | 278 | 181c4462aec08dcdd3187f40d4a0436992a246f5c2ce637a4b19a3eecd1d5868 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
426,811 | 74 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 05dc2f49a8319a7a9fabc1dc0a61262390d5ed98 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `select_only_allowed` that takes two arguments: `iterable`, a list of tuples of strings and integers, and `allowed`, a list of integers. The function should iterate through the tuples in `iterable` and return a list of the elements in the second position of each tuple if they are allowed by the ... | To solve this problem, we can use a set to keep track of the allowed integers and a list to store the second elements of the tuples that have allowed integers. Then, we can iterate through the tuples in `iterable`, and for each tuple, if the second element is in the allowed set, we add it to the list. Finally, we can r... | def select_only_allowed(iterable, allowed):
"Write a Python function `select_only_allowed` that takes two arguments: `iterable`, a list of tuples of strings and integers, and `allowed`, a list of integers. The function should iterate through the tuples in `iterable` and return a list of the elements in the second p... | allowed_set = set([i for i in allowed])
result = []
for i in iterable:
if i[1] in allowed_set:
result.append(i[1])
result = list(set(result))
result.sort()
return result
| 305 | 0f8bd2920f1686470711ed813799e6c55c27852af760969e073f924ec53bf691 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
61,100 | 75 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 5d3ddb24979d0718397d5160af37e0e1776d7ffb | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Define a Python function that takes a string and an optional parameter `sep` with a default value of `' '`. If `sep` is provided, the function should return the string split by the separator, otherwise the function should return a list of individual characters in the string.
Your code should pass the following asserti... | Here's how you can do it in two lines of Python code:
```python
def split_string(s, sep=' '):
return s.split(sep) if sep else list(s)
``` | def split_string(s, sep=' '):
"Define a Python function that takes a string and an optional parameter `sep` with a default value of `' '`. If `sep` is provided, the function should return the string split by the separator, otherwise the function should return a list of individual characters in the string.\n\nYour c... | return s.split(sep) if sep else list(s)
| 147 | 27c600dbff8fb6c4d3620d546870249bb0fd214e704173a821adbcfaee5582b5 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
547,095 | 77 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | a285e8f7391cdd5b6b83d0d80a06244297fe3e7f | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function that takes in a list of integers, sorts them in ascending order, and returns a new list containing the sorted elements. Write the docstring in the following format:
```
Parameters:
num_list (list): A list of integers.
Returns:
list: A sorted list of integers, with the smallest element... | You can create a Python function that uses the built-in `sorted()` function to sort the list in ascending order.
Here's how you could do it:
```python
def sort_list(num_list):
"""
Sorts a given list of integers in ascending order.
Parameters:
num_list (list): A list of integers.
Returns:
... | def sort_list(num_list):
'Create a Python function that takes in a list of integers, sorts them in ascending order, and returns a new list containing the sorted elements. Write the docstring in the following format:\n\n```\nParameters:\n num_list (list): A list of integers.\n\nReturns:\n list: A sorted list o... | return sorted(num_list)
| 204 | 12c0be1179f87d93f8b815aca5953b8482351c72957f410f495a47189a4f1f70 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
516,863 | 82 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1ce35acde732b76619444637770a6c2a6868e07b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function, `clean_text(text, stopwords)`, that takes two arguments: `text` (a string) and `stopwords` (a list of stopwords). The function should return a cleaned string without any stopwords. The stopwords should be removed from the string and the remaining words should be joined together with spaces. | Here's the basic idea:
1. Split the text into individual words using `text.split()`
2. Filter out the stopwords from the list of words using `list comprehension`
3. Join the remaining words together with spaces
Here's a possible implementation of the function using this approach:
```python
def clean_text(text, stopwo... | def clean_text(text, stopwords):
'Write a Python function, `clean_text(text, stopwords)`, that takes two arguments: `text` (a string) and `stopwords` (a list of stopwords). The function should return a cleaned string without any stopwords. The stopwords should be removed from the string and the remaining words shou... | words = text.split()
cleaned_words = [word for word in words if word not in stopwords]
cleaned_text = ' '.join(cleaned_words)
return cleaned_text
| 145 | a38562fe348e598e115c2b4c7eb31378d5d870ee28d674cabb582f5a6d4c7d37 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
210,083 | 85 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | d15c6c0305c1abda21e97761ae8d8be5945ff032 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a list of JSON objects, each representing a user with a name, email, and a list of friends. The function should return a list of objects sorted by the number of friends, from the most friends to the least.
Here's an example input and the expected output (formatted for readability):
... | To solve this problem, you can use the `sorted()` function in Python with a custom key function that counts the number of friends for each user.
Here's how you can implement it:
```python
def sort_users_by_friends(users):
def count_friends(user):
return len(user['friends'])
return sorted(users, key=c... | def sort_users_by_friends(users):
'Write a Python function that takes a list of JSON objects, each representing a user with a name, email, and a list of friends. The function should return a list of objects sorted by the number of friends, from the most friends to the least.\n\nHere\'s an example input and the expe... | def count_friends(user):
return len(user['friends'])
return sorted(users, key=count_friends, reverse=True)
| 507 | aedecd62eea90e11d8bd7242e23785d030fe2c2abaeb8c95be7700565823ef10 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
308,810 | 90 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 242ca84d414f5cc4e95d6a8e67e1fde8da96b7ea | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function to convert a nested list with specific patterns into a nested tuple. For instance, given the following input list:
```python
input_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
```
The function should return a nested tuple as follows:
```python
output_tuple = ((1, 2, 3), (4, 5), (6, 7, 8, 9))
``` | Here's how you can implement the conversion function:
```python
def convert_list_to_tuple(nested_list):
if not isinstance(nested_list, list):
return nested_list
return tuple(convert_list_to_tuple(item) for item in nested_list)
```
This function uses a recursive approach to convert a nested list into ... | def convert_list_to_tuple(nested_list):
'Create a Python function to convert a nested list with specific patterns into a nested tuple. For instance, given the following input list:\n\n```python\ninput_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]\n```\n\nThe function should return a nested tuple as follows:\n\n```python... | if not isinstance(nested_list, list):
return nested_list
return tuple((convert_list_to_tuple(item) for item in nested_list))
| 192 | 1ffbc4947b21ad3e21d7c170381d0de95fd617af7f59eb0006fc0396075d0e91 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
97,448 | 91 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 58fb775aa90fe83f6678435a6dbe2a5a347ed679 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `convert_hex_to_dec` to convert an input string of hexadecimal numbers into a list of decimal numbers. The input string is a sequence of hexadecimal numbers separated by commas (','). Each hexadecimal number is between 0 and 255 (both inclusive), and the output list must have the same length as ... | Here's how we can implement this:
```python
def convert_hex_to_dec(input_string):
hex_numbers = input_string.split(',')
dec_numbers = []
for hex_number in hex_numbers:
dec_number = int(hex_number, base=16)
dec_numbers.append(dec_number)
return dec_numbers
```
In this implementation, w... | def convert_hex_to_dec(input_string):
'Write a Python function `convert_hex_to_dec` to convert an input string of hexadecimal numbers into a list of decimal numbers. The input string is a sequence of hexadecimal numbers separated by commas (\',\'). Each hexadecimal number is between 0 and 255 (both inclusive), and ... | hex_numbers = input_string.split(',')
dec_numbers = []
for hex_number in hex_numbers:
dec_number = int(hex_number, base=16)
dec_numbers.append(dec_number)
return dec_numbers
| 275 | 3f2070996cc12d83b9d81a48cbdcb8a800be204ca2c0d8363cdd4a727938e964 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
598,661 | 92 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | b4e20d7e6ae8c1824ba1350dacb7b266a9e7f96d | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Given a list of tuples `(index, value)` representing indexed values, create a dictionary such that for each unique value present in the list, a new entry is created in the dictionary, with the key being the unique value and the value a list of the indices corresponding to that value.
For example, given the list `[(0, ... | Here's an example implementation:
```python
def create_dictionary(tuples):
constructed_dictionary = {}
for index, value in tuples:
if value not in constructed_dictionary:
constructed_dictionary[value] = []
constructed_dictionary[value].append(index)
return constructed_dictionary... | def create_dictionary(tuples):
'Given a list of tuples `(index, value)` representing indexed values, create a dictionary such that for each unique value present in the list, a new entry is created in the dictionary, with the key being the unique value and the value a list of the indices corresponding to that value.... | constructed_dictionary = {}
for index, value in tuples:
if value not in constructed_dictionary:
constructed_dictionary[value] = []
constructed_dictionary[value].append(index)
return constructed_dictionary
| 238 | 4fe8777665bf83ee38ff46caebe5e3029e3bb5b583c20303a0ae14ef644e5fe5 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
469,148 | 94 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | f77fcf734a2b2b85dabd40c651aac77b82000d20 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function to update a dictionary with new keys and values. The function should take two parameters: the dictionary to be updated and a list of tuples, where each tuple contains a key and a value. The keys in the list should be checked against the dictionary's keys to see whether they already exist. If a ... | Here's a Python function that implements this logic:
```python
def update_dictionary(my_dict, tuples_list):
for key, value in tuples_list:
if key in my_dict:
my_dict[key] = value
else:
my_dict[key] = value
return my_dict
```
In this implementation:
- We iterate through ... | def update_dictionary(my_dict, tuples_list):
"Create a Python function to update a dictionary with new keys and values. The function should take two parameters: the dictionary to be updated and a list of tuples, where each tuple contains a key and a value. The keys in the list should be checked against the dictiona... | for key, value in tuples_list:
if key in my_dict:
my_dict[key] = value
else:
my_dict[key] = value
return my_dict
| 290 | 31dab338910c1c4dd7a47167baf8769619c7249749f6ce8438dca824ff0a9ec6 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
1,305 | 95 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0068931868e214896f6263e58fc09215352d502c | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes an array of strings as input and returns a single string with the first letter of each string capitalized. Include documentation that describes the function, its parameters, and its return value. Be sure to use meaningful variable names, as well as a conditional expression to handle t... | ```python
def capitalize_first(strings):
"""
Capitalize the first letter of each string in the given list of strings.
Args:
strings (list): A list of strings to be capitalized.
Returns:
str: A string with the first letter of each string capitalized, separated by spaces.
"""
cap... | def capitalize_first(strings):
'Write a Python function that takes an array of strings as input and returns a single string with the first letter of each string capitalized. Include documentation that describes the function, its parameters, and its return value. Be sure to use meaningful variable names, as well as ... | capitalized_strings = [string.capitalize() for string in strings]
return ' '.join(capitalized_strings)
| 110 | 9cef45be75b7e050a3a163a16620c8b3c05256e5f1cc382281664ebc2cd154c8 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
646,808 | 98 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 576f2f0df6d7f54c659a1a315920e748d784f4be | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that concatenates two strings. If one of the strings is `None` or empty, return the other string.
Your code should pass the following assertions:
```python
assert concatenate_strings(None, "World") == "World"
assert concatenate_strings("Hello", None) == "Hello"
assert concatenate_strings("Hello... | Here is a Python function that implements this approach:
```python
def concatenate_strings(s1: str, s2: str) -> str:
if s1 is None or not s1:
return s2
elif s2 is None or not s2:
return s1
else:
return s1 + s2
```
This implementation checks whether `s1` or `s2` is `None` or empty. ... | def concatenate_strings(s1: str, s2: str) -> str:
'Write a Python function that concatenates two strings. If one of the strings is `None` or empty, return the other string.\n\nYour code should pass the following assertions:\n```python\nassert concatenate_strings(None, "World") == "World"\nassert concatenate_strings... | if s1 is None or not s1:
return s2
elif s2 is None or not s2:
return s1
else:
return s1 + s2
| 201 | fee0945509c24869ebba344148b290f75bb6e4c19b21f756f2c9119a15f84c10 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
119,170 | 99 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | dab7b6a0765dee718a562dbde62f011082e8ea84 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `is_int(s)` that takes a string `s` and returns `True` if `s` can be parsed as an integer, and `False` otherwise. Utilize exception handling to handle any potential errors and return `False` if an exception occurs.
Your code should pass the following assertions:
```python
assert is_int('123') i... | Here is a Python function that implements this functionality:
```python
def is_int(s):
try:
int(s)
return True
except ValueError:
return False
```
In this implementation:
- We use `int(s)` to try to convert the string to an integer.
- If the conversion is successful, the string can be ... | def is_int(s):
"Write a Python function `is_int(s)` that takes a string `s` and returns `True` if `s` can be parsed as an integer, and `False` otherwise. Utilize exception handling to handle any potential errors and return `False` if an exception occurs.\n\nYour code should pass the following assertions:\n```python... | try:
int(s)
return True
except ValueError:
return False
| 177 | 30f726b8532d7e6c6b636bfd6fcaa8d708e60327b524939d017e0efd1551a257 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
118,820 | 100 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 894649a98d12d88f7543e5ede9383ec3703148b3 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | You are given a nested dictionary where each key is a string and each value is either a string or a nested dictionary. Write a function that flattens the hierarchy of keys by joining them with a period ('.') and returns a new dictionary with the flattened keys and the same values. | Here is a Python implementation of the DFS approach:
```python
def flatten_dict(dictionary: dict) -> dict:
"""Flattens a dictionary with nested keys and returns a new dictionary with the flattened keys."""
flattened_dict = {}
def dfs(dictionary, current_key, flattened_dict):
for key, value in dict... | def flatten_dict(dictionary: dict) -> dict:
"You are given a nested dictionary where each key is a string and each value is either a string or a nested dictionary. Write a function that flattens the hierarchy of keys by joining them with a period ('.') and returns a new dictionary with the flattened keys and the sa... | flattened_dict = {}
def dfs(dictionary, current_key, flattened_dict):
for key, value in dictionary.items():
new_key = current_key + '.' + key if current_key else key
if isinstance(value, dict):
dfs(value, new_key, flattened_dict)
else:
... | 266 | 627e1954ed3b71c18387575d33db6a76f8f5f7c04e2324bc84839aaf012bfad3 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
546,674 | 102 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | f11ba457c6bd9c930cb6b90b97a5dbf5657d908e | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `flatten_dictionary` that takes a dictionary (possibly nested) as input and flattens it into a single-level dictionary, where the keys are dot-separated (e.g., 'a.b.c' for the key 'c' in sub-dictionary 'b' in dictionary 'a'). You can assume that the input dictionary will have string keys and val... | Here is a Python function that implements this approach:
```python
def flatten_dictionary(d):
"""
Flattens a nested dictionary into a single-level dictionary. The nested keys are separated by dots.
For example, a dictionary {'a': {'b': 1, 'c': 2}, 'd': 3} will be flattened to {'a.b': 1, 'a.c': 2, 'd': 3}.
... | def flatten_dictionary(d):
"Write a Python function `flatten_dictionary` that takes a dictionary (possibly nested) as input and flattens it into a single-level dictionary, where the keys are dot-separated (e.g., 'a.b.c' for the key 'c' in sub-dictionary 'b' in dictionary 'a'). You can assume that the input dictiona... | flattened = {}
for key, value in d.items():
if isinstance(value, dict):
nested_flattened = flatten_dictionary(value)
flattened.update({f'{key}.{nested_key}': nested_value for nested_key, nested_value in nested_flattened.items()})
else:
flattened[key] = value
... | 333 | 420c4b410c3212642c6b56803f13a7948197b87e1639de6db6b4962d438848bb | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
4,908 | 103 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | df3dc6507b8eae9d148ec9b2e664a427813d93a7 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `permute_data` for the purpose of data permuting in dimensionality reduction and other machine learning tasks. The function takes two arguments: `data`, an array of data points with shape (n, d), where n is the number of data points and d is the dimensionality of each point; and `permute_idx`, a... | Here's how you could implement this function in Python:
```python
def permute_data(data, permute_idx):
permuted_data = data[:, permute_idx]
return permuted_data
```
The `permute_data` function takes two arguments: `data`, an array of data points with shape (n, d) where n is the number of data points and d is ... | def permute_data(data, permute_idx):
'Write a Python function `permute_data` for the purpose of data permuting in dimensionality reduction and other machine learning tasks. The function takes two arguments: `data`, an array of data points with shape (n, d), where n is the number of data points and d is the dimensio... | permuted_data = data[:, permute_idx]
return permuted_data
| 162 | f4cbf303e86fa98ca9c376393c5ea734436873473660bd4c40fb628fd02aa99b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
444,584 | 104 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1d78b23875df12cef8c8356bfdbb879c67656d65 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | I have a list of objects `x_list`. Each object has an `x` attribute that can be accessed with `obj.x`. Write a Python function `my_func(x_list)` that returns a list containing the `x` attributes of all objects in `x_list`. If the `x` attribute for a given object is odd, you should double it, and if it is even, you shou... | The goal is to write a Python function `my_func` that takes a list of objects `x_list` as input and returns a list containing the `x` attributes of all objects in `x_list`. If the `x` attribute for a given object is odd, you should double it; if it is even, you should divide it by 2.
To achieve this, we'll create a ne... | def my_func(x_list):
'I have a list of objects `x_list`. Each object has an `x` attribute that can be accessed with `obj.x`. Write a Python function `my_func(x_list)` that returns a list containing the `x` attributes of all objects in `x_list`. If the `x` attribute for a given object is odd, you should double it, a... | assert x_list, 'x_list must not be empty'
assert all((obj.x > 0 and isinstance(obj.x, int) for obj in x_list)), 'x values must be positive integers'
transformed_list = []
for obj in x_list:
if obj.x % 2 == 1:
transformed_list.append(obj.x * 2)
else:
transformed_li... | 288 | 065c38294a89d1184415775f9bdfa3b6e03966c1c5118c07291ecb4a80a27596 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
444,500 | 109 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 47b33e7bf9d3e9bc1728d16d639be27004f517db | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `get_value_at(obj, path)` that takes an object and a path (a list of keys) as input. The function should traverse through the object by following the path and return the value located at the end.
If an error is encountered during traversal, raise a `KeyError` with the appropriate message. If a ... | Here is how you could implement such a function:
```python
def get_value_at(obj, path):
current = obj
for key in path:
if isinstance(current, dict):
if key not in current:
raise KeyError("Key not found: {}".format(key))
current = current[key]
elif isinsta... | def get_value_at(obj, path):
'Write a Python function `get_value_at(obj, path)` that takes an object and a path (a list of keys) as input. The function should traverse through the object by following the path and return the value located at the end.\n\nIf an error is encountered during traversal, raise a `KeyError`... | current = obj
for key in path:
if isinstance(current, dict):
if key not in current:
raise KeyError('Key not found: {}'.format(key))
current = current[key]
elif isinstance(current, list):
try:
key = int(key)
except Va... | 430 | 90d56289ee52cd67c4808dfddc959f38ddd3ceb60690f70083d706d1ba905551 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
190,830 | 111 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1dd37261802ac72540a93f5ea9f2fdbf4344cfc1 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a string and returns its integer representation. Return `None` if the given string does not represent a valid integer. The function should support negative integers and ignore any leading and trailing spaces.
For example, `my_atoi("42")` should return `42`, `my_atoi(" -42")` should ... | You can create a Python function that iterates through each character of the given string to convert it to an integer. The function should also support negative integers, ignore any leading and trailing spaces, and return `None` if the given string does not represent a valid integer.
Here's how you could implement thi... | def my_atoi(string):
'Write a Python function that takes a string and returns its integer representation. Return `None` if the given string does not represent a valid integer. The function should support negative integers and ignore any leading and trailing spaces.\n\nFor example, `my_atoi("42")` should return `42`... | string = string.strip()
if not string:
return None
is_negative = string[0] == '-'
if is_negative:
string = string[1:]
for char in string:
if not char.isdigit():
return None
integer = int(string)
if is_negative:
integer = -integer
return integer... | 258 | 1154163edf663fce131c8d34cdf191711cc44a49334bbdd27bf6c3404393186c | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
191,582 | 112 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | b6a3f4bd0a73a3792bb7a9f839e73b7dedcfc6d2 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `error_measure(a, b)` that returns the absolute difference between two numbers without using any built-in math functions. The function should also be annotated for type hints. The function's docstring should make the reader understand the function's purpose.
Your code should pass the following ... | Here is an example implementation of the `error_measure` function, using type hints and a docstring to explain its purpose:
```python
def error_measure(a: float, b: float) -> float:
"""Return the absolute difference between two numbers without using any built-in math functions."""
if a > b:
return a - ... | def error_measure(a: float, b: float) -> float:
"Write a Python function `error_measure(a, b)` that returns the absolute difference between two numbers without using any built-in math functions. The function should also be annotated for type hints. The function's docstring should make the reader understand the func... | if a > b:
return a - b
else:
return b - a
| 170 | 6f37ffeb3583847df656ef6fabc4f1c66ed1a56327db93429bbeb72c86f4665b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
486,933 | 113 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 49c469381630ced54b5ff52f34ed9d8af98c100e | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes in a positive integer as an argument and returns a string that represents the integer in its binary form. The string should be padded with zeros to the left so that it always has 32 characters.
Your code should pass the following assertions:
```python
assert int_to_bin(10) == "000000... | Here's how you can implement this:
```python
def int_to_bin(num):
if not isinstance(num, int) or num < 0:
raise ValueError("Input must be a positive integer.")
bin_str = ""
while num > 0:
bin_str = str(num % 2) + bin_str
num //= 2
bin_str = (32 - len(bin_str)) * "0" + bin_str
... | def int_to_bin(num):
'Write a Python function that takes in a positive integer as an argument and returns a string that represents the integer in its binary form. The string should be padded with zeros to the left so that it always has 32 characters.\n\nYour code should pass the following assertions:\n```python\nas... | if not isinstance(num, int) or num < 0:
raise ValueError('Input must be a positive integer.')
bin_str = ''
while num > 0:
bin_str = str(num % 2) + bin_str
num //= 2
bin_str = (32 - len(bin_str)) * '0' + bin_str
return bin_str
| 242 | f3306b3cba4feadd8c62629896b9884108e963abe8ff717567a64444a9701ec0 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
6,877 | 115 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | ecf54fa40195ba4de7db13874e44388a04527bed | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | A code is a string of five characters. It is valid if it starts with "X" and contains only letters and numbers. Write a Python function to check if a code is valid.
Your code should pass the following assertions:
```python
assert is_valid_code("XABC5")
assert not is_valid_code("XABC5!")
assert not is_valid_code("Y1234... | To check if a code is valid, we need to check if it starts with "X" and contains only letters and numbers.
We can use the `startswith()` method of the `str` class to check if the code starts with "X" and the `isalnum()` method of the `str` class to check if the code contains only letters and numbers. Here's the implem... | def is_valid_code(code):
'A code is a string of five characters. It is valid if it starts with "X" and contains only letters and numbers. Write a Python function to check if a code is valid.\n\nYour code should pass the following assertions:\n```python\nassert is_valid_code("XABC5")\nassert not is_valid_code("XABC5... | return code.startswith('X') and code[1:].isalnum()
| 152 | 46d8f6ba7d47bbcf62270d3a1ad74e673275aa880b9de14130ff54d9a3093a35 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
579,931 | 116 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | c6d3fde49662b1a83bc07655c9a3e914b27a60ff | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function `find_substrings(string, n)` that returns all substrings of length `n` from a given input `string`. For example, `find_substrings('abcde', 2)` should return `['ab', 'bc', 'cd', 'de']`. | Here's how you can do it in Python:
```python
def find_substrings(string, n):
return [string[i:i+n] for i in range(len(string)-n+1)]
```
The `range` function generates the starting indices for the substrings, and the list comprehension slices the string at each index to extract the substring of the desired length... | def find_substrings(string, n):
"Create a Python function `find_substrings(string, n)` that returns all substrings of length `n` from a given input `string`. For example, `find_substrings('abcde', 2)` should return `['ab', 'bc', 'cd', 'de']`."
| return [string[i:i + n] for i in range(len(string) - n + 1)]
| 109 | 0cf18377eb3b3b4bb7936f131332223117748e1eeb2ad2541d57c850ec3069ea | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
3,509 | 118 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 264f8cde11879be8ace938c777f546974383122c | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a dictionary and returns a list of unique values. If a key maps to an empty list, you should output an empty list. | To write a function that takes a dictionary and returns a list of unique values, you can follow these steps:
1. Create an empty list to store unique values.
2. Iterate over each key-value pair in the dictionary.
3. Check if the value is an empty list. If so, continue to the next iteration.
4. For non-empty values, ite... | def unique_values(d):
'Write a Python function that takes a dictionary and returns a list of unique values. If a key maps to an empty list, you should output an empty list.'
| unique_list = []
for key, value in d.items():
if not value:
continue
for element in value:
if element not in unique_list:
unique_list.append(element)
return unique_list
| 158 | 1e48da7719008bf38083361fdbd704182b73bf1955ccb3822d1da52c601aecc3 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
471,380 | 120 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 33551b91d854af6d07f8fa1c43bc7ba45b0bdeeb | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `convert_roman_numeral_to_number` that takes a Roman numeral as input and converts it to a number. The Roman numerals are represented with a combination of letters, each representing a unique number. The possible letters and their corresponding numbers are: I = 1, V = 5, X = 10, L = 50, C = 100,... | To solve this problem, we can follow the given conversion logic: read each character from left to right and add its value to the running total. If the current character has a smaller value than the previous character, subtract its value from the running total.
Here is a Python implementation of the `convert_roman_nume... | def convert_roman_numeral_to_number(roman_numeral: str) -> int:
'Write a Python function `convert_roman_numeral_to_number` that takes a Roman numeral as input and converts it to a number. The Roman numerals are represented with a combination of letters, each representing a unique number. The possible letters and th... | roman_dict = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
result = 0
prev_char = ''
for char in roman_numeral:
curr_num = roman_dict[char]
if prev_char and curr_num > roman_dict[prev_char]:
result = result - 2 * roman_dict[prev_char] + curr_num
el... | 390 | 484bc3c6e908a94fbec3e12a2ef0cbc939b0d908e49ab322f6964537922e369f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
432,635 | 121 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | c6f2be8576e870d56c1125b98462d026f8206ade | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `get_encoding_count` that takes a string as input and returns the number of bytes required to encode the string by the UTF-8 encoding.
Your code should pass the following test case:
```python
input_string = "Hello, world!"
expected_encoding_count = 13
actual_encoding_count = get_encoding_count(... | Here's how you can implement the `get_encoding_count` function in Python:
```python
def get_encoding_count(input_string):
return len(input_string.encode('utf-8'))
```
The `encode` method of a string encodes the string using the specified encoding, and returns a byte string. The number of bytes in the byte string ... | def get_encoding_count(input_string):
'Write a Python function `get_encoding_count` that takes a string as input and returns the number of bytes required to encode the string by the UTF-8 encoding.\n\nYour code should pass the following test case:\n```python\ninput_string = "Hello, world!"\nexpected_encoding_count ... | return len(input_string.encode('utf-8'))
| 179 | 920f6aac22168da1d0936b60226bb63d9eef6a3e8f7052bce9b44fdfdae639b2 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
26,478 | 122 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | bfb94655afabea3674105884d4d9b4da7eb861f3 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Design a Python function that takes a string of comma-separated key-value pairs as input and returns a dictionary representation of the same string. The input string is of the format `"key1=value1,key2=value2,...,keyn=valuen"`. The function should split the string into an array of pairs, clean each pair to remove any u... | ```python
def get_dictionary(string):
pairs = string.split(',')
dictionary = {}
for pair in pairs:
pair = pair.strip()
if '=' in pair:
key, value = pair.split('=')
dictionary[key] = value
return dictionary
```
This implementation separates the key-value pairs int... | def get_dictionary(string):
'Design a Python function that takes a string of comma-separated key-value pairs as input and returns a dictionary representation of the same string. The input string is of the format `"key1=value1,key2=value2,...,keyn=valuen"`. The function should split the string into an array of pairs... | pairs = string.split(',')
dictionary = {}
for pair in pairs:
pair = pair.strip()
if '=' in pair:
key, value = pair.split('=')
dictionary[key] = value
return dictionary
| 225 | 2daeea6111249647c0676df0e18caef53cacca51749d1d2a9e71270985851c96 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
337,226 | 123 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 72a4f5ea1ebbe9b0734cb3f6b4890e7e18c3e601 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a function `f`, a string `s`, and a variable number of arguments `*args`, and return a new function that calls `f` with the argument `s` concatenated to the string representation of each argument in `*args`. Note that the `*args` arguments may not be strings, so you'll need to convert... | ```python
def curry(f, s):
return lambda *args: f(s, *(str(arg) for arg in args))
``` | def curry(f, s):
'Write a Python function that takes a function `f`, a string `s`, and a variable number of arguments `*args`, and return a new function that calls `f` with the argument `s` concatenated to the string representation of each argument in `*args`. Note that the `*args` arguments may not be strings, so ... | return lambda *args: f(s, *(str(arg) for arg in args))
| 233 | e119f71a7c9b2f450cd767eeea984fec73e2193708d5284e1ff2ab785b6b22a4 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
546,364 | 124 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 75f186d696283701060d91dbc91b1ab8b8ab15fc | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Design a Python function to check if a list of numbers is sorted in ascending order. It should return `True` if the list is sorted and `False` if it is not. The function should take a list of numbers and return a boolean value. The function should not modify the input list.
Here is the code skeleton:
```python
def is... | To check if a list of numbers is sorted in ascending order, you can use a linear scan to compare the current number with the previous one. If you find a number that is less than the previous one, you can immediately return `False` since the list is not sorted.
Here is how you could implement the function:
```python
d... | def is_sorted(nums):
'Design a Python function to check if a list of numbers is sorted in ascending order. It should return `True` if the list is sorted and `False` if it is not. The function should take a list of numbers and return a boolean value. The function should not modify the input list.\n\nHere is the code... | assert isinstance(nums, list)
if len(nums) == 0:
return True
for i in range(1, len(nums)):
if nums[i] < nums[i - 1]:
return False
return True
| 379 | d0fa9ffd83ffb69f4c882e8013d44a6c2617686e34b8a6ec49b56d4c794f6685 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
111,544 | 125 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 442db43f4fdeb4d563f38b384a2ffa00cf0233ec | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Implement a function `same_attr` that takes two XML attributes as input and returns a boolean indicating whether they are equal. It should ignore the namespace prefix and consider only the local name and value. It should also ignore leading and trailing spaces in the value.
The function should return `True` if the att... | Here is the code for the `same_attr` function:
```python
def same_attr(attr1, attr2):
if attr1 is attr2:
return True
local_name1 = attr1.split('}')[-1]
local_name2 = attr2.split('}')[-1]
value1 = attr1[len(local_name1) + 1:]
value2 = attr2[len(local_name2) + 1:]
value1 = value1.strip()
... | def same_attr(attr1, attr2):
'Implement a function `same_attr` that takes two XML attributes as input and returns a boolean indicating whether they are equal. It should ignore the namespace prefix and consider only the local name and value. It should also ignore leading and trailing spaces in the value.\n\nThe func... | if attr1 is attr2:
return True
local_name1 = attr1.split('}')[-1]
local_name2 = attr2.split('}')[-1]
value1 = attr1[len(local_name1) + 1:]
value2 = attr2[len(local_name2) + 1:]
value1 = value1.strip()
value2 = value2.strip()
return local_name1 == local_name2 and value1 == value2
| 376 | 9d01c83f0faa8a01188655f976da528d7bdf4f8e3fa45fd70dce50559fbfc95b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
219,859 | 126 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | c875bb6175c811a94614cbc68c00fbf961b25cc6 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | How would you sort this list of dictionaries based on the values of the name key?
```python
[
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 30},
{'name': 'Charlie', 'age': 25},
{'name': 'Dave', 'age': 35},
]
```
Write a Python function to sort a list of dictionaries based on the values of a spe... | To sort a list of dictionaries by the values of a specific key, you can use the `sorted` function with a key function that returns the value of the desired key for each dictionary.
Here's how you can sort a list of dictionaries based on the values of a specific key using Python:
```python
def sort_by_key(input_list, ... | def sort_by_key(input_list, key):
"How would you sort this list of dictionaries based on the values of the name key?\n\n```python\n[\n {'name': 'Alice', 'age': 25},\n {'name': 'Bob', 'age': 30},\n {'name': 'Charlie', 'age': 25},\n {'name': 'Dave', 'age': 35},\n]\n```\n\nWrite a Python function to sort a... | return sorted(input_list, key=lambda x: x[key])
| 178 | 68d55175e0d9dfd87c4936ea51c53e5d3ed101ee31bef96e08d4aa0a4429de56 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
515,164 | 128 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | c5203087476a3d697cd38f43fe2fb209881a0bb2 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function `get_fitness_score` that receives a `Person` object and returns the person's fitness score based on their age and height. The function should enforce the following criteria:
- If the person is less than 18 years old, their fitness score is 0.
- If the person is between 18 and 25 years old (inc... | ```python
def get_fitness_score(person):
fitness_score = 0
if person.age < 18:
return fitness_score
if person.age <= 25:
fitness_score += 5
elif person.age <= 35:
fitness_score += 10
elif person.age <= 45:
fitness_score += 15
elif person.age <= 55:
fitne... | def get_fitness_score(person):
"Create a Python function `get_fitness_score` that receives a `Person` object and returns the person's fitness score based on their age and height. The function should enforce the following criteria:\n\n- If the person is less than 18 years old, their fitness score is 0.\n- If the per... | fitness_score = 0
if person.age < 18:
return fitness_score
if person.age <= 25:
fitness_score += 5
elif person.age <= 35:
fitness_score += 10
elif person.age <= 45:
fitness_score += 15
elif person.age <= 55:
fitness_score += 20
else:
fitness_sc... | 469 | 3ced95976dfa97c2f16d49c4aa410dc8405260573f43e8d25c80aef9ea8f020b | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
408,562 | 130 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | d8a9548c9b1a312f9789a4e9f3bdbe41507b4a69 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Implement a Python function `indices` that takes a list of booleans and returns the indices of the list elements that are `True`. Do this using list comprehension and `enumerate`. For example, `indices([True, False, True])` should return `[0, 2]`. | Here is an example implementation that implements the above steps:
```python
def indices(bool_list):
indices = []
for i, bool_value in enumerate(bool_list):
if bool_value:
indices.append(i)
return indices
```
The `enumerate` function is used to get both the index and the value of each ... | def indices(bool_list):
'Implement a Python function `indices` that takes a list of booleans and returns the indices of the list elements that are `True`. Do this using list comprehension and `enumerate`. For example, `indices([True, False, True])` should return `[0, 2]`.'
| indices = []
for i, bool_value in enumerate(bool_list):
if bool_value:
indices.append(i)
return indices
| 141 | 2c442f06da808fdae1f1e5c81ae736ab8eda1af4e3927ca57ba77a65d9429f25 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
303,574 | 133 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 9659f22b7acf40e6d593407d5c0dd7f3a12fc8f5 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to calculate the average of a list of numbers. If the length of the list is 0, return `None`.
Your code should pass the following assertions:
```python
assert average([]) is None
assert average([1, 2, 3]) == 2
``` | Here is a Python function that implements this approach:
```python
def average(lst):
if len(lst) == 0:
return None
return sum(lst) / len(lst)
``` | def average(lst):
'Write a Python function to calculate the average of a list of numbers. If the length of the list is 0, return `None`.\n\nYour code should pass the following assertions:\n```python\nassert average([]) is None\nassert average([1, 2, 3]) == 2\n```'
| if len(lst) == 0:
return None
return sum(lst) / len(lst)
| 121 | 8e0b78dc1f3fde9d8297eb48448b60968f7ff515ca4c9b4f130f1f2459c5c769 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
405,006 | 134 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1f0c144c98fc3e1ba73249b0e9d97edc1a89913b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to create a list of integers of length `n` that starts with `1` and increments by `1` each time until it reaches `n`. The function should also ensure that `n` is a positive integer.
If `n` is a negative integer, the function should return an empty list. If `n` is `0`, the function should return... | Here is the implementation:
```python
def create_list(n):
if n < 0:
return []
elif n == 0:
return [1]
result = []
for i in range(1, n + 1):
result.append(i)
return result
``` | def create_list(n):
'Write a Python function to create a list of integers of length `n` that starts with `1` and increments by `1` each time until it reaches `n`. The function should also ensure that `n` is a positive integer.\n\nIf `n` is a negative integer, the function should return an empty list. If `n` is `0`,... | if n < 0:
return []
elif n == 0:
return [1]
result = []
for i in range(1, n + 1):
result.append(i)
return result
| 252 | b393658f3873293e2e66dec18239407920a8b1b726092927dd9f93efe74aa58f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
407,531 | 136 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0662edc81901ff31380ab75dc93e49c8a3115f5b | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function, `custom_max`, that takes a list of numbers as an argument and returns the maximum value using a recursive algorithm. The function should support multiple input types, such as lists, tuples, and arrays, and should handle empty input gracefully. The function should not use built-in Python functio... | To write a recursive function to find the maximum value in a list of numbers, we can use the following steps:
1. Define the `custom_max` function with a single argument, which is a list of numbers.
2. Check if the list is empty. If it is, return `None`.
3. Otherwise, if the list has only one element, return that eleme... | def custom_max(lst):
"Write a Python function, `custom_max`, that takes a list of numbers as an argument and returns the maximum value using a recursive algorithm. The function should support multiple input types, such as lists, tuples, and arrays, and should handle empty input gracefully. The function should not u... | if not lst:
return None
if len(lst) == 1:
return float(lst[0])
left = custom_max(lst[:len(lst) // 2])
right = custom_max(lst[len(lst) // 2:])
return max(left, right)
| 318 | c4a46d37f45ae93ad4f2bcb802c60d3a42db204d3940da81da56286892dd4b7c | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
603,941 | 141 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | e78d3755a953d9249cf8d943cb298b64b0b2b0a3 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function that takes a list of strings and returns a dictionary of the form `{'string_1': 1, 'string_2': 2, ...}`. The keys of the dictionary are the strings in the list, and the values are the corresponding indices (starting from 1). | Here's a Python function that implements this logic:
```python
def str_list_to_dict(str_list):
str_dict = {}
for i, string in enumerate(str_list, 1):
str_dict[string] = i
return str_dict
```
The function `str_list_to_dict` takes a list of strings `str_list` as an argument. It initializes an empty ... | def str_list_to_dict(str_list):
"Write a Python function that takes a list of strings and returns a dictionary of the form `{'string_1': 1, 'string_2': 2, ...}`. The keys of the dictionary are the strings in the list, and the values are the corresponding indices (starting from 1)."
| str_dict = {}
for i, string in enumerate(str_list, 1):
str_dict[string] = i
return str_dict
| 131 | 2fec2323513f928ba4593d1fbd6d101eea12c16a165868d553e26ae7c215af3f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
685,390 | 143 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | fa681e9a8a0bf8b8a82d955e6ffb565264b145e5 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Design a Python function to return the intersection of two sets of strings. The function should accept two arguments, `set_1` and `set_2`, which are sets of strings. It should return a new set containing strings that are present in both sets. The function should handle invalid inputs (such as non-set arguments) by retu... | Here's how we can define the function:
```python
def set_intersection(set_1, set_2):
if not set_1 or not set_2:
return set()
if not isinstance(set_1, set) or not isinstance(set_2, set):
return set()
return set_1.intersection(set_2)
``` | def set_intersection(set_1, set_2):
'Design a Python function to return the intersection of two sets of strings. The function should accept two arguments, `set_1` and `set_2`, which are sets of strings. It should return a new set containing strings that are present in both sets. The function should handle invalid i... | if not set_1 or not set_2:
return set()
if not isinstance(set_1, set) or not isinstance(set_2, set):
return set()
return set_1.intersection(set_2)
| 381 | 485dcd0c9964d22d9e1186d91e7a53dd272a0fd25f80ac25dd2dc62c88daf0e0 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
558,258 | 145 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 1c9e711b671a33a2bcffde106fae3693c35e4086 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Given a list of dictionaries, each of which has a key `acc_id` and a value `level` specifying the level of the player, create a new dictionary where the key is the level and the value is a list of the corresponding `acc_id`s. The dictionary should be sorted by key. | Here is the implementation using Python:
```python
def create_level_dict(player_dict_list):
level_dict = {}
for player_dict in player_dict_list:
acc_id = player_dict.get('acc_id')
level = player_dict.get('level')
if acc_id and level:
if level not in level_dict:
... | def create_level_dict(player_dict_list):
'Given a list of dictionaries, each of which has a key `acc_id` and a value `level` specifying the level of the player, create a new dictionary where the key is the level and the value is a list of the corresponding `acc_id`s. The dictionary should be sorted by key.'
| level_dict = {}
for player_dict in player_dict_list:
acc_id = player_dict.get('acc_id')
level = player_dict.get('level')
if acc_id and level:
if level not in level_dict:
level_dict[level] = [acc_id]
else:
level_dict[level].append(ac... | 262 | af8af72cb181599773404dba8ed31bcc65a187135013c388d60922e1b64febc8 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
385,850 | 147 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 2a2f08474c09dfe9db19ae21f6e3c1bedc8d0981 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Implement a Python function `run_func` which takes a function `f` and a sequence of arguments `args` as input and returns the result of calling `f` with the provided arguments. If the result is a string, it should be returned as-is. For all other types, it should be converted to a string by calling the `str()` function... | Here is how you could implement the `run_func` function:
```python
def run_func(f, *args):
result = f(*args)
if isinstance(result, str):
return result
else:
return str(result)
``` | def run_func(f, *args):
'Implement a Python function `run_func` which takes a function `f` and a sequence of arguments `args` as input and returns the result of calling `f` with the provided arguments. If the result is a string, it should be returned as-is. For all other types, it should be converted to a string by... | result = f(*args)
if isinstance(result, str):
return result
else:
return str(result)
| 145 | 9ce0d5e40a47cc8f1c325413ff442ed8c444de23da2c38d5a648eed5bee6598e | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
422,192 | 148 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | e45375eb21409869c0e05121b9a5715cf1957635 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Assume you have a list of names and want to display them in a given template as name1, name2, etc., but if it's just one name, then it should be displayed as name, otherwise name1 and name2, etc. Can you write a Python function that accepts a list of names and returns a formatted string that meets the above requirement... | ```python
def format_names(names):
if len(names) == 1:
return names[0]
elif len(names) == 2:
return f"{names[0]} and {names[1]}"
else:
formatted_names = []
for i, name in enumerate(names[:-1]):
formatted_names.append(name)
formatted_names.append(f"and {nam... | def format_names(names):
"Assume you have a list of names and want to display them in a given template as name1, name2, etc., but if it's just one name, then it should be displayed as name, otherwise name1 and name2, etc. Can you write a Python function that accepts a list of names and returns a formatted string th... | if len(names) == 1:
return names[0]
elif len(names) == 2:
return f'{names[0]} and {names[1]}'
else:
formatted_names = []
for i, name in enumerate(names[:-1]):
formatted_names.append(name)
formatted_names.append(f'and {names[-1]}')
return ', '.join(... | 252 | fb05575de3d51ac2e377389d9e76ac294228c43f863dd1375ef7fe7b0d5fed8f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
45,347 | 149 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | b6f8e07b6d708f78d616f4a357e94ec3249676b4 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function that calculates the scaling factor for the Discrete Cosine Transform (DCT) and the Discrete Sine Transform (DST) types I, II, III, and IV. The function should take an integer "size" and a string "dct_type" as input, where "size" represents the input size, and "dct_type" indicates the type of DC... | To calculate the scaling factor for the DCT and DST types I, II, III, and IV, we need to take into account the input size, the type of transform, and the normalization parameter. For DCT type I, the scaling factor is always 1/√n, where n is the input size. For DCT type II, the scaling factor is always 1/√(2n), where n ... | def scaling_factor(size, dct_type, normalized=True):
'Create a Python function that calculates the scaling factor for the Discrete Cosine Transform (DCT) and the Discrete Sine Transform (DST) types I, II, III, and IV. The function should take an integer "size" and a string "dct_type" as input, where "size" represen... | if size <= 0:
raise ValueError('Input size must be a positive integer.')
if dct_type not in ['I', 'II', 'III', 'IV']:
raise ValueError('Invalid dct_type. Please choose one of: I, II, III, IV.')
if dct_type == 'I':
return 1.0 / size ** 0.5
elif dct_type == 'II':
return 1.0... | 582 | 81455f21de65d4d020bf2169331e35c91901a68c762fdf1a874761b8105102e3 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
480,572 | 150 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 5926dbbf548a6d5d74a9985d05d6937be4265aff | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to parse a string of comma-separated integers, sort them numerically, and return a new string of sorted integers. Your function should handle invalid inputs gracefully.
Examples:
```python
parse_sorted_ints("1,2,3,4,5") # returns "1,2,3,4,5"
parse_sorted_ints("6,4,11,7,10") # returns "4,6,7,10... | To write a function to parse comma-separated integers, sort them numerically, and return a new string of sorted integers, we need to first parse the input string into a list of integers. Then, we can sort the list of integers and return a new string of sorted integers. However, we need to handle invalid inputs graceful... | def parse_sorted_ints(input_str):
'Write a Python function to parse a string of comma-separated integers, sort them numerically, and return a new string of sorted integers. Your function should handle invalid inputs gracefully.\n\nExamples:\n\n```python\nparse_sorted_ints("1,2,3,4,5") # returns "1,2,3,4,5"\nparse_s... | try:
input_str = input_str.replace(' ', '')
int_list = [int(x) for x in input_str.split(',')]
int_list.sort()
result_str = ','.join((str(x) for x in int_list))
return result_str
except ValueError:
print('Invalid input: non-integer value found')
return ''
| 317 | b42cdee3355ce53b83d87bd5181ad85f32ccf93d8d7ef158afd64a8dfcd474ef | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
78,765 | 151 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 6aed6748274df4b967059bac478b2370859f1606 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | I want to write a Python function that converts a class instance into a string representation suitable for logging purposes. The string should be in the form:
```
[class name] [attribute name]=[attribute value], [attribute name]=[attribute value], ...
```
The function should take a class instance as input and return ... | To create such a function, we can utilize the built-in `vars` function to retrieve the attributes of the given class instance. Then, we can iterate through the attributes and format them according to the required string representation.
```python
def class_to_string(obj):
attributes = vars(obj).items()
formatte... | def class_to_string(obj):
'I want to write a Python function that converts a class instance into a string representation suitable for logging purposes. The string should be in the form:\n\n```\n[class name] [attribute name]=[attribute value], [attribute name]=[attribute value], ...\n```\n\nThe function should take ... | attributes = vars(obj).items()
formatted_attributes = ', '.join((f'{attr}={value}' for attr, value in attributes))
class_name = obj.__class__.__name__
return f'[{class_name} {formatted_attributes}]'
| 177 | 14e2de994fdada85a09068ab92f8ad03d56418a6cff04aa57593afb9dd3fc341 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
190,969 | 152 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | c957e86ba3a0d55fa739578ac3755afaa9661d39 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function to determine if a string contains a number. The function should return a boolean value indicating if the string contains at least one number. Numbers can be integers or floating-point numbers. For example, the string "I am 12 years old" should return True, while the string "My name is Tom" shoul... | Here's how you can implement this function:
```python
def contains_number(s: str) -> bool:
return any(c.isdigit() or c == '.' for c in s)
``` | def contains_number(s: str) -> bool:
'Write a Python function to determine if a string contains a number. The function should return a boolean value indicating if the string contains at least one number. Numbers can be integers or floating-point numbers. For example, the string "I am 12 years old" should return Tru... | return any((c.isdigit() or c == '.' for c in s))
| 111 | b5ac532f01d3a725d8ea934d0b3bf651e29fedffb5ecb3e7e294b83512bc88e6 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
239,948 | 153 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | eaadd8187cf8ad947e627a706baebd166b6c70b0 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Create a Python function `execute_sql_query` that takes three arguments: `connection`, a SQL connection object; `table_name`, a string specifying the name of the table; and `columns`, a list of column names. The function should construct an SQL query to select columns from the table, execute the query, and return the r... | Here's how we can implement this:
```python
def execute_sql_query(connection, table_name, columns):
sql = f"SELECT {', '.join(columns)} FROM {table_name};"
cursor = connection.execute(sql)
result = cursor.fetchall()
return result
```
In this implementation, we construct the SQL query using a format st... | def execute_sql_query(connection, table_name, columns):
'Create a Python function `execute_sql_query` that takes three arguments: `connection`, a SQL connection object; `table_name`, a string specifying the name of the table; and `columns`, a list of column names. The function should construct an SQL query to selec... | sql = f"SELECT {', '.join(columns)} FROM {table_name};"
cursor = connection.execute(sql)
result = cursor.fetchall()
return result
| 162 | 00c082f9cb1e1a3ffd35562e4d2b305a14553f91e7c1eed745b2e6d65cd82e8f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
122,123 | 154 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | 0adc59c490ae18f64f4b281ed59a86cfa6e99cc4 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a recursive Python function to calculate the GCD of two positive integers. Use the Euclidean algorithm, and for your base case, return the greater integer if one of them is zero.
Your code should pass the following assertion:
```python
assert gcd(8, 12) == 4
``` | Here's how you could implement the recursive function in Python:
```python
def gcd(a, b):
if a == 0:
return b
elif b == 0:
return a
else:
return gcd(b, a % b)
``` | def gcd(a, b):
'Write a recursive Python function to calculate the GCD of two positive integers. Use the Euclidean algorithm, and for your base case, return the greater integer if one of them is zero.\n\nYour code should pass the following assertion:\n```python\nassert gcd(8, 12) == 4\n```'
| if a == 0:
return b
elif b == 0:
return a
else:
return gcd(b, a % b)
| 150 | b1c5246d542711a0a134b19f9d490d335a3ce4c27f3308937ffcdf2c94986e41 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
437,552 | 155 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | be129eb2e429c6a80927002f3c87032896f49ceb | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | We have a dictionary of dictionaries, where the keys are `user_id`s and the values are dictionaries containing `name` and `age` keys. I want to write a Python function that takes such a dictionary and converts it to a new dictionary of lists, where the keys are `name` and `age` and the values are lists of the correspon... | Based on the given instruction, we need to write a Python function that takes a dictionary of dictionaries as input and returns a new dictionary of lists based on the values of the original dictionary. To achieve this, we can use a `for` loop to iterate over the keys of the original dictionary, extract the values of `n... | def convert_dictionary_of_dictionaries_to_dictionary_of_lists(dictionary_of_dictionaries):
'We have a dictionary of dictionaries, where the keys are `user_id`s and the values are dictionaries containing `name` and `age` keys. I want to write a Python function that takes such a dictionary and converts it to a new di... | new_dictionary = {key: [] for key in ['name', 'age']}
for user_id, user_info in dictionary_of_dictionaries.items():
new_dictionary['name'].append(user_info['name'])
new_dictionary['age'].append(user_info['age'])
return new_dictionary
| 225 | c9b75c06a05eaefaef51e7ae7a6d61c8ceb523bce37747c345e4bc360c793384 | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
509,427 | 156 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | d9c7480f5d81f966d91e6da62a6adefc23c79568 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Design a Python function that takes a string containing parentheses and returns `True` if the parentheses are balanced. The function should handle all types of parentheses, including curly braces (`{}`), brackets (`[]`), and parentheses (`()`) by counting the number of opening and closing parentheses for each type.
Fo... | Here's a function that implements this approach:
```python
def is_balanced(parens):
stack = []
for char in parens:
if char in ['(', '[', '{']:
stack.append(char)
else:
if not stack:
return False
if char == ')' and stack[-1] != '(':
... | def is_balanced(parens):
'Design a Python function that takes a string containing parentheses and returns `True` if the parentheses are balanced. The function should handle all types of parentheses, including curly braces (`{}`), brackets (`[]`), and parentheses (`()`) by counting the number of opening and closing ... | stack = []
for char in parens:
if char in ['(', '[', '{']:
stack.append(char)
else:
if not stack:
return False
if char == ')' and stack[-1] != '(':
return False
if char == ']' and stack[-1] != '[':
re... | 403 | 0e29ba4cc3170e6f1f36067b48d9360078b76f3dbf95b0014c836440b4d4701f | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
626,204 | 157 | 356bb069eee815daa6e23e9a282eeefe1490ad44 | d4d73c75cb72179256e0c8401ddb7ad1fa21c1d9 | https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/tree/356bb069eee815daa6e23e9a282eeefe1490ad44 | Write a Python function `binary_search` that takes an array `nums` and a target value `target` as parameters and returns the index of the target if it is present in the array, otherwise it returns `-1`. The input array is guaranteed to be sorted in ascending order.
If the input array is empty, print an error message a... | To implement a binary search, we need to consider the following steps:
1. **Verify the input**: We need to check if the input array is empty, if the target value is within the range of the array, and if the array is sorted in ascending order. If any of these conditions is not met, we should exit the program gracefully... | def binary_search(nums, target):
'Write a Python function `binary_search` that takes an array `nums` and a target value `target` as parameters and returns the index of the target if it is present in the array, otherwise it returns `-1`. The input array is guaranteed to be sorted in ascending order.\n\nIf the input ... | if len(nums) == 0:
print('Error: Input array is empty.')
return -1
start = 0
end = len(nums) - 1
while start <= end:
mid = (start + end) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
start = mid + 1
else:
... | 325 | ca0b55d9e7d868b8e027f562ded5d457f52ae0dab136e2be02878a5c667fe2ee | train | static_candidate_not_execution_verified | prompt=-100; completion+EOS=supervised |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.