id int64 0 163 | question stringlengths 115 1.36k | cot_reasoning stringlengths 395 2.95k | extracted_answer stringlengths 12 1.26k ⌀ | ground_truth stringlengths 16 864 | is_correct bool 1
class | verification_method stringclasses 2
values |
|---|---|---|---|---|---|---|
0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, ... |
Here is the solution:
```python
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4... | def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
""... | for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
return True
return False
| false | code_execution |
1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace... |
Here is the solution:
```python
def separate_paren_groups(paren_string: str) -> List[str]:
# Initialize variables
result = []
current_group = []
current_depth = 0
# Iterate through each character in the string
for char in paren_string:
if char == '(':
current_depth += 1
... | def separate_paren_groups(paren_string: str) -> List[str]:
# Initialize variables
result = []
current_group = []
current_depth = 0
# Iterate through each character in the string
for char in paren_string:
if char == '(':
current_depth += 1
current_group.append(cha... | result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
... | false | code_execution |
2 |
def truncate_number(number: float) -> float:
""" Given a positive floating point number, it can be decomposed into
and integer part (largest integer smaller than given number) and decimals
(leftover part always smaller than 1).
Return the decimal part of the number.
>>> truncate_number(3.5)
0... |
Here is the solution:
```python
def truncate_number(number: float) -> float:
""" Given a positive floating point number, it can be decomposed into
and integer part (largest integer smaller than given number) and decimals
(leftover part always smaller than 1).
Return the decimal part of the number.
... | def truncate_number(number: float) -> float:
""" Given a positive floating point number, it can be decomposed into
and integer part (largest integer smaller than given number) and decimals
(leftover part always smaller than 1).
Return the decimal part of the number.
>>> truncate_number(3.5)
0.5... | return number % 1.0
| false | code_execution |
3 | from typing import List
def below_zero(operations: List[int]) -> bool:
""" You're given a list of deposit and withdrawal operations on a bank account that starts with
zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
at that point function should return Tru... |
Here is the solution:
```python
def below_zero(operations: List[int]) -> bool:
balance = 0
for operation in operations:
balance += operation
if balance < 0:
return True
return False
```
Let me explain the solution step by step:
1. Initialize a variable `balance` to keep tra... | def below_zero(operations: List[int]) -> bool:
balance = 0
for operation in operations:
balance += operation
if balance < 0:
return True
return False | balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False
| false | code_execution |
4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" For a given list of input numbers, calculate Mean Absolute Deviation
around the mean of this dataset.
Mean Absolute Deviation is the average absolute difference between each
element and a centerpoint (mean in this ... |
Here is the solution:
```python
def mean_absolute_deviation(numbers: List[float]) -> float:
""" For a given list of input numbers, calculate Mean Absolute Deviation
around the mean of this dataset.
Mean Absolute Deviation is the average absolute difference between each
element and a centerpoint (mean... | def mean_absolute_deviation(numbers: List[float]) -> float:
""" For a given list of input numbers, calculate Mean Absolute Deviation
around the mean of this dataset.
Mean Absolute Deviation is the average absolute difference between each
element and a centerpoint (mean in this case):
MAD = average |... | mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| false | code_execution |
5 | from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
|
Here is the solution:
```python
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
if not numbers:
return []
result = [numbers[0]]
for num in numbers[1:]:
result.append(delimeter)
result.append(num)
return result
```
Explanation:
* We check if the input list... | def intersperse(numbers: List[int], delimeter: int) -> List[int]:
if not numbers:
return []
result = [numbers[0]]
for num in numbers[1:]:
result.append(delimeter)
result.append(num)
return result | if not numbers:
return []
result = []
for n in numbers[:-1]:
result.append(n)
result.append(delimeter)
result.append(numbers[-1])
return result
| false | code_execution |
6 | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
For each of the group, output the deepest level of nesting of parentheses.
E.g. (()()) has maximum two levels of n... |
Here is the solution:
```python
def parse_nested_parens(paren_string: str) -> List[int]:
""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
For each of the group, output the deepest level of nesting of parentheses.
E.g. (()()) has maximum two le... | def parse_nested_parens(paren_string: str) -> List[int]:
""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
For each of the group, output the deepest level of nesting of parentheses.
E.g. (()()) has maximum two levels of nesting while ((())) has th... | def parse_paren_group(s):
depth = 0
max_depth = 0
for c in s:
if c == '(':
depth += 1
max_depth = max(depth, max_depth)
else:
depth -= 1
return max_depth
return [parse_paren_group(x) for x in paren_string.s... | false | code_execution |
7 | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" Filter an input list of strings only for ones that contain given substring
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'array'... |
Step 1: Understand the problem
The function `filter_by_substring` takes a list of strings and a substring as input. It filters the list of strings to only include those that contain the given substring.
Step 2: Consider edge cases
- Empty input list
- Substring not found in any of the input strings
- Substring fou... | return [s for s in strings if substring in s] | return [x for x in strings if substring in x]
| false | code_execution |
8 | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
Empty sum should be equal to 0 and empty product should be equal to 1.
>>> sum_product([])
(0, 1)
... |
Here is the solution:
```python
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
Empty sum should be equal to 0 and empty product should be equal to 1.
>>> sum_product([])
(0, 1)
... | def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
Empty sum should be equal to 0 and empty product should be equal to 1.
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, 3, 4])
... | sum_value = 0
prod_value = 1
for n in numbers:
sum_value += n
prod_value *= n
return sum_value, prod_value
| false | code_execution |
9 | from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" From a given list of integers, generate a list of rolling maximum element found until given moment
in the sequence.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
|
Here is the solution:
```python
def rolling_max(numbers: List[int]) -> List[int]:
""" From a given list of integers, generate a list of rolling maximum element found until given moment
in the sequence.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
max_numbers = []
curre... | def rolling_max(numbers: List[int]) -> List[int]:
""" From a given list of integers, generate a list of rolling maximum element found until given moment
in the sequence.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
max_numbers = []
current_max = numbers[0]
for number... | running_max = None
result = []
for n in numbers:
if running_max is None:
running_max = n
else:
running_max = max(running_max, n)
result.append(running_max)
return result
| false | code_execution |
10 |
def is_palindrome(string: str) -> bool:
""" Test if given string is a palindrome """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" Find the shortest palindrome that begins with a supplied string.
Algorithm idea is simple:
- Find the longest postfix of supplied string... |
Here is the solution:
```python
def is_palindrome(string: str) -> bool:
""" Test if given string is a palindrome """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" Find the shortest palindrome that begins with a supplied string.
Algorithm idea is simple:
- Find the l... | def is_palindrome(string: str) -> bool:
""" Test if given string is a palindrome """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" Find the shortest palindrome that begins with a supplied string.
Algorithm idea is simple:
- Find the longest postfix of supplied string t... | if not string:
return ''
beginning_of_suffix = 0
while not is_palindrome(string[beginning_of_suffix:]):
beginning_of_suffix += 1
return string + string[:beginning_of_suffix][::-1]
| false | code_execution |
11 | from typing import List
def string_xor(a: str, b: str) -> str:
""" Input are two strings a and b consisting only of 1s and 0s.
Perform binary XOR on these inputs and return result also as a string.
>>> string_xor('010', '110')
'100'
"""
|
Here is the solution:
```python
def string_xor(a: str, b: str) -> str:
""" Input are two strings a and b consisting only of 1s and 0s.
Perform binary XOR on these inputs and return result also as a string.
>>> string_xor('010', '110')
'100'
"""
result = ""
for i in range(len(a)):
... | def string_xor(a: str, b: str) -> str:
""" Input are two strings a and b consisting only of 1s and 0s.
Perform binary XOR on these inputs and return result also as a string.
>>> string_xor('010', '110')
'100'
"""
result = ""
for i in range(len(a)):
if a[i] == b[i]:
result... | def xor(i, j):
if i == j:
return '0'
else:
return '1'
return ''.join(xor(x, y) for x, y in zip(a, b))
| false | code_execution |
12 | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" Out of list of strings, return the longest one. Return the first one in case of multiple
strings of the same length. Return None in case the input list is empty.
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a... |
Here is the solution:
```python
def longest(strings: List[str]) -> Optional[str]:
if not strings:
return None
return max(strings, key=len)
```
Explanation:
* We check if the input list is empty. If it is, we return `None` as per the requirement.
* If the list is not empty, we use the `max()` fu... | def longest(strings: List[str]) -> Optional[str]:
if not strings:
return None
return max(strings, key=len) | if not strings:
return None
maxlen = max(len(x) for x in strings)
for s in strings:
if len(s) == maxlen:
return s
| false | code_execution |
13 |
def greatest_common_divisor(a: int, b: int) -> int:
""" Return a greatest common divisor of two integers a and b
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
Step 1: Understand the problem.
The function should return the greatest common divisor (GCD) of two integers a and b.
Step 2: Consider edge cases.
- Negative numbers: The GCD of negative numbers is the same as the GCD of their absolute values.
- Zero: The GCD of any number and zero is the number itself.
- One: The... | # Ensure a >= b to simplify the algorithm
if b > a:
a, b = b, a
# Use the Euclidean algorithm to find the GCD
while b != 0:
a, b = b, a % b
return a | while b:
a, b = b, a % b
return a
| false | code_execution |
14 | from typing import List
def all_prefixes(string: str) -> List[str]:
""" Return list of all prefixes from shortest to longest of the input string
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
|
Here is the solution:
```python
def all_prefixes(string: str) -> List[str]:
""" Return list of all prefixes from shortest to longest of the input string
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
prefixes = []
for i in range(len(string)):
prefixes.append(string[:i+1])
return p... | def all_prefixes(string: str) -> List[str]:
""" Return list of all prefixes from shortest to longest of the input string
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
prefixes = []
for i in range(len(string)):
prefixes.append(string[:i+1])
return prefixes | result = []
for i in range(len(string)):
result.append(string[:i+1])
return result
| false | code_execution |
15 |
def string_sequence(n: int) -> str:
""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
Here is the solution:
```python
def string_sequence(n: int) -> str:
""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
# Step 1: Understand the problem
# We need to generate a str... | def string_sequence(n: int) -> str:
""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
# Step 1: Understand the problem
# We need to generate a string containing numbers from 0 to n ... | return ' '.join([str(x) for x in range(n + 1)])
| false | code_execution |
16 |
def count_distinct_characters(string: str) -> int:
""" Given a string, find out how many distinct characters (regardless of case) does it consist of
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
Step 1: Understand the problem.
We need to find the number of distinct characters in a given string, regardless of case.
Step 2: Consider edge cases.
- Empty string (should return 0)
- Single character (should return 1)
- Strings with duplicate characters
- Strings with uppercase and lowercase characters
Step 3: ... | return len(set(string.lower())) | return len(set(string.lower()))
| false | code_execution |
17 | from typing import List
def parse_music(music_string: str) -> List[int]:
""" Input to this function is a string representing musical notes in a special ASCII format.
Your task is to parse this string and return list of integers corresponding to how many beats does each
not last.
Here is a legend:
... |
Here is the solution:
```python
def parse_music(music_string: str) -> List[int]:
""" Input to this function is a string representing musical notes in a special ASCII format.
Your task is to parse this string and return list of integers corresponding to how many beats does each
not last.
Here is a le... | def parse_music(music_string: str) -> List[int]:
""" Input to this function is a string representing musical notes in a special ASCII format.
Your task is to parse this string and return list of integers corresponding to how many beats does each
not last.
Here is a legend:
'o' - whole note, lasts f... | note_map = {'o': 4, 'o|': 2, '.|': 1}
return [note_map[x] for x in music_string.split(' ') if x]
| false | code_execution |
18 |
def how_many_times(string: str, substring: str) -> int:
""" Find how many times a given substring can be found in the original string. Count overlaping cases.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
Here is the solution:
```python
def how_many_times(string: str, substring: str) -> int:
""" Find how many times a given substring can be found in the original string. Count overlaping cases.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
... | def how_many_times(string: str, substring: str) -> int:
""" Find how many times a given substring can be found in the original string. Count overlaping cases.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
count = 0
for i in ... | times = 0
for i in range(len(string) - len(substring) + 1):
if string[i:i+len(substring)] == substring:
times += 1
return times
| false | code_execution |
19 | from typing import List
def sort_numbers(numbers: str) -> str:
""" Input is a space-delimited string of numberals from 'zero' to 'nine'.
Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
Return the string with numbers sorted from smallest to largest
>... |
Here is the solution:
```python
def sort_numbers(numbers: str) -> str:
# Step 1: Understand the problem
# We need to sort the numbers from smallest to largest
# Step 2: Consider edge cases
# What if the input string is empty?
# What if the input string contains invalid numbers?
# Step 3: Im... | def sort_numbers(numbers: str) -> str:
# Step 1: Understand the problem
# We need to sort the numbers from smallest to largest
# Step 2: Consider edge cases
# What if the input string is empty?
# What if the input string contains invalid numbers?
# Step 3: Implementation
# We can convert t... | value_map = {
'zero': 0,
'one': 1,
'two': 2,
'three': 3,
'four': 4,
'five': 5,
'six': 6,
'seven': 7,
'eight': 8,
'nine': 9
}
return ' '.join(sorted([x for x in numbers.split(' ') if x], key=lambda x: value_map[x]))
| false | code_execution |
20 | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
>>> find_closest_elements([... |
Here is the solution:
```python
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
>>> find_closest_elements... | def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
... | closest_pair = None
distance = None
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
... | false | code_execution |
21 | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, ... |
Here is the solution:
```python
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
... | def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.75, 1.0]
... | min_number = min(numbers)
max_number = max(numbers)
return [(x - min_number) / (max_number - min_number) for x in numbers]
| false | code_execution |
22 | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
|
Here is the solution:
```python
def filter_integers(values: List[Any]) -> List[int]:
return [value for value in values if isinstance(value, int)]
```
Explanation:
* We use a list comprehension to iterate over the `values` list.
* For each `value`, we check if it is an instance of `int` using the `isinstanc... | def filter_integers(values: List[Any]) -> List[int]:
return [value for value in values if isinstance(value, int)] | return [x for x in values if isinstance(x, int)]
| false | code_execution |
23 |
def strlen(string: str) -> int:
""" Return length of given string
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
Here is the solution:
```python
def strlen(string: str) -> int:
""" Return length of given string
>>> strlen('')
0
>>> strlen('abc')
3
"""
return len(string)
```
Explanation:
* The `strlen` function takes a string as input and returns its length.
* The `len` function is used to calc... | def strlen(string: str) -> int:
""" Return length of given string
>>> strlen('')
0
>>> strlen('abc')
3
"""
return len(string) | return len(string)
| false | code_execution |
24 |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
>>> largest_divisor(15)
5
"""
|
Here is the solution:
```python
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
>>> largest_divisor(15)
5
"""
for i in range(n-1, 1, -1):
if n % i == 0:
return i
return 1
```
Let me explain the so... | def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
>>> largest_divisor(15)
5
"""
for i in range(n-1, 1, -1):
if n % i == 0:
return i
return 1 | for i in reversed(range(n)):
if n % i == 0:
return i
| false | code_execution |
25 | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... |
Here is the solution:
```python
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to t... | def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the product of all factors
>>> f... | import math
fact = []
i = 2
while i <= int(math.sqrt(n) + 1):
if n % i == 0:
fact.append(i)
n //= i
else:
i += 1
if n > 1:
fact.append(n)
return fact
| false | code_execution |
26 | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
|
Here is the solution:
```python
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
seen = set()
resul... | def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
seen = set()
result = []
for num in numbers:
... | import collections
c = collections.Counter(numbers)
return [n for n in numbers if c[n] <= 1]
| false | code_execution |
27 |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
>>> flip_case('Hello')
'hELLO'
"""
|
Here is the solution:
```python
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
>>> flip_case('Hello')
'hELLO'
"""
return ''.join(char.swapcase() for char in string)
```
Explanation:
* We use a list comprehension to... | def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
>>> flip_case('Hello')
'hELLO'
"""
return ''.join(char.swapcase() for char in string) | return string.swapcase()
| false | code_execution |
28 | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
|
Here is the solution:
```python
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
result = ""
for string in strings:
result += string
return result
```
Let me ... | def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
result = ""
for string in strings:
result += string
return result | return ''.join(strings)
| false | code_execution |
29 | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
"""
|
Here is the solution:
```python
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
"""... | def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
"""
return [s for s in strings if ... | return [x for x in strings if x.startswith(prefix)]
| false | code_execution |
30 |
def get_positive(l: list):
"""Return only positive numbers in the list.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
Step 1: Understand the problem.
I need to return only positive numbers in the list.
Step 2: Consider edge cases.
- Empty list
- List with no positive numbers
- List with all positive numbers
- List with negative numbers
Step 3: Implementation.
I will iterate through the list and check if each number is positive.... | positive_numbers = []
for num in l:
if num > 0:
positive_numbers.append(num)
return positive_numbers | return [e for e in l if e > 0]
| false | code_execution |
31 |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
|
Here is the solution:
```python
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
```
Let me explain the solution step by step:
1. We start by checking if the number is less than 2. If it is, we return `False... | def is_prime(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True | if n < 2:
return False
for k in range(2, n - 1):
if n % k == 0:
return False
return True
| false | code_execution |
32 | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... |
Here is the solution:
```python
import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" ... | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomial... | begin, end = -1., 1.
while poly(xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
| false | code_execution |
33 |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
>>> sort_t... |
Here is the solution:
```python
def sort_third(l: list):
# Step 1: Understand the problem
# We need to sort the elements at indices that are divisible by 3
# Step 2: Consider edge cases
# What if the list is empty?
if not l:
return []
# Step 3: Implementation
# Create a new list... | def sort_third(l: list):
# Step 1: Understand the problem
# We need to sort the elements at indices that are divisible by 3
# Step 2: Consider edge cases
# What if the list is empty?
if not l:
return []
# Step 3: Implementation
# Create a new list to store the sorted elements
s... | l = list(l)
l[::3] = sorted(l[::3])
return l
| false | code_execution |
34 |
def unique(l: list):
"""Return sorted unique elements in a list
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
Here is the solution:
```python
def unique(l: list):
"""Return sorted unique elements in a list
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
return sorted(set(l))
```
Explanation:
* The `set` function is used to remove duplicates from the list.
* The `sorted` function ... | def unique(l: list):
"""Return sorted unique elements in a list
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
return sorted(set(l)) | return sorted(list(set(l)))
| false | code_execution |
35 |
def max_element(l: list):
"""Return maximum element in the list.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
Step 1: Understand the problem.
The function should return the maximum element in a list of integers.
Step 2: Consider edge cases.
- Empty list (should return None or raise an exception)
- List with negative numbers
- List with single element
- List with duplicate max values
Step 3: Implementation approach.
Iter... | max_val = None
for num in l:
if max_val is None or num > max_val:
max_val = num
return max_val | m = l[0]
for e in l:
if e > m:
m = e
return m
| false | code_execution |
36 |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
Here is the solution:
```python
def fizz_buzz(n: int):
count = 0
for i in range(1, n):
if (i % 11 == 0 or i % 13 == 0) and '7' in str(i):
count += 1
return count
```
Explanation:
* We initialize a count variable to keep track of the number of times the digit 7 appears in integers ... | def fizz_buzz(n: int):
count = 0
for i in range(1, n):
if (i % 11 == 0 or i % 13 == 0) and '7' in str(i):
count += 1
return count | ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
| false | code_execution |
37 |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
... |
Here is the solution:
```python
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
>>> sort_even([1, 2, 3])
[1, 2, 3]... | def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
... | evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []
for e, o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
| false | code_execution |
38 |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... |
Here is the solution:
```python
def decode_cyclic(s: str):
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# decode each group by moving the last element to the front.
groups = [group[-1] + group[:-1] for group in groups]
... | def decode_cyclic(s: str):
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# decode each group by moving the last element to the front.
groups = [group[-1] + group[:-1] for group in groups]
return "".join(groups) | return encode_cyclic(encode_cyclic(s))
| false | code_execution |
39 |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
Step 1: Understand the problem
The function `prime_fib` takes an integer `n` as input and returns the `n`th number that is both a Fibonacci number and a prime number.
Step 2: Consider edge cases
- What if `n` is less than 1?
- What if `n` is a large number?
Step 3: Implementation approach
To solve this problem, ... | def prime_fib(n: int):
# Initialize the Fibonacci sequence with the first two numbers
fib_sequence = [0, 1]
# Generate Fibonacci numbers until we find n prime Fibonacci numbers
while len(fib_sequence) < n:
# Calculate the next Fibonacci number
next_fib = fib_sequence[-1] + fib_sequence[... | import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
... | false | code_execution |
40 |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero takes a list of integers as an input.
it returns True if there are three distinct elements in the list that
sum to zero, and False otherwise.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
Tr... |
Here is the solution:
```python
def triples_sum_to_zero(l: list):
for i in range(len(l)):
for j in range(i + 1, len(l)):
for k in range(j + 1, len(l)):
if l[i] + l[j] + l[k] == 0:
return True
return False
```
This function iterates through all possible... | def triples_sum_to_zero(l: list):
for i in range(len(l)):
for j in range(i + 1, len(l)):
for k in range(j + 1, len(l)):
if l[i] + l[j] + l[k] == 0:
return True
return False | for i in range(len(l)):
for j in range(i + 1, len(l)):
for k in range(j + 1, len(l)):
if l[i] + l[j] + l[k] == 0:
return True
return False
| false | code_execution |
41 |
def car_race_collision(n: int):
"""
Imagine a road that's a perfectly straight infinitely long line.
n cars are driving left to right; simultaneously, a different set of n cars
are driving right to left. The two sets of cars start out being very far from
each other. All cars move in the same s... |
Step 1: Understand the problem
In this problem, we have two sets of cars moving in opposite directions on an infinitely long road. The goal is to find the number of collisions that occur between the cars.
Step 2: Consider edge cases
Here are some edge cases to consider:
* What if there are no cars in either set?
... | return n * n | return n**2
| false | code_execution |
42 |
def incr_list(l: list):
"""Return list with elements incremented by 1.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
Step 1: Understand the problem.
I need to create a function that takes a list of integers as input and returns a new list with each element incremented by 1.
Step 2: Consider edge cases.
- Empty list
- Negative numbers
- Floating point numbers
Step 3: Implementation.
I can use a list comprehension to iterate ove... | return [x + 1 for x in l] | return [(e + 1) for e in l]
| false | code_execution |
43 |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero takes a list of integers as an input.
it returns True if there are two distinct elements in the list that
sum to zero, and False otherwise.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs... |
Here is the solution:
```python
def pairs_sum_to_zero(l):
# Create a set to store the numbers we've seen
seen = set()
# Iterate through the list
for num in l:
# Check if the complement of the current number is in the set
if -num in seen:
return True
# Add the curr... | def pairs_sum_to_zero(l):
# Create a set to store the numbers we've seen
seen = set()
# Iterate through the list
for num in l:
# Check if the complement of the current number is in the set
if -num in seen:
return True
# Add the current number to the set
seen.... | for i, l1 in enumerate(l):
for j in range(i + 1, len(l)):
if l1 + l[j] == 0:
return True
return False
| false | code_execution |
44 |
def change_base(x: int, base: int):
"""Change numerical base of input number x to base.
return string representation after the conversion.
base numbers are less than 10.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
Step 1: Understand the problem
In this problem, we need to convert a number from its current base to a new base. The input number is an integer, and the base is also an integer.
Step 2: Consider edge cases
Here are some edge cases to consider:
* What if the input number is negative?
* What if the input number is ... | # Initialize an empty list to store remainders
remainders = []
# Repeatedly divide the input number by the base and store remainders
while x > 0:
remainders.append(str(x % base))
x //= base
# Reverse the list and concatenate the remainders to get the string representation
return ''... | ret = ""
while x > 0:
ret = str(x % base) + ret
x //= base
return ret
| false | code_execution |
45 |
def triangle_area(a, h):
"""Given length of a side and high return area for a triangle.
>>> triangle_area(5, 3)
7.5
"""
|
Here is the solution:
```python
def triangle_area(a, h):
"""Given length of a side and high return area for a triangle.
>>> triangle_area(5, 3)
7.5
"""
return 0.5 * a * h
```
Let me think through this step by step.
Step 1: Understand the problem.
Given the length of a side and the height of a t... | return 0.5 * a * h | return a * h / 2.0
| false | code_execution |
46 |
def fib4(n: int):
"""The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Please write a function to efficiently compute the n-th el... |
Here is the solution:
```python
def fib4(n: int):
if n < 0:
raise ValueError("Input must be a non-negative integer.")
if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 2
if n == 3:
return 0
fib_prev_4 = 0
fib_prev_3 = 0
fib_prev_2 = 2
... | def fib4(n: int):
if n < 0:
raise ValueError("Input must be a non-negative integer.")
if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 2
if n == 3:
return 0
fib_prev_4 = 0
fib_prev_3 = 0
fib_prev_2 = 2
fib_prev_1 = 0
fib_current =... | results = [0, 0, 2, 0]
if n < 4:
return results[n]
for _ in range(4, n + 1):
results.append(results[-1] + results[-2] + results[-3] + results[-4])
results.pop(0)
return results[-1]
| false | code_execution |
47 |
def median(l: list):
"""Return median of elements in the list l.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
Here is the solution:
```python
def median(l: list):
"""Return median of elements in the list l.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
l.sort()
n = len(l)
if n % 2 == 0:
return (l[n // 2 - 1] + l[n // 2]) / 2
else:
return ... | def median(l: list):
"""Return median of elements in the list l.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
l.sort()
n = len(l)
if n % 2 == 0:
return (l[n // 2 - 1] + l[n // 2]) / 2
else:
return l[n // 2] | l = sorted(l)
if len(l) % 2 == 1:
return l[len(l) // 2]
else:
return (l[len(l) // 2 - 1] + l[len(l) // 2]) / 2.0
| false | code_execution |
48 |
def is_palindrome(text: str):
"""
Checks if given string is a palindrome
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
Here is the solution:
```python
def is_palindrome(text: str):
"""
Checks if given string is a palindrome
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
# Step 1: Understand the problem
# ... | def is_palindrome(text: str):
"""
Checks if given string is a palindrome
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
# Step 1: Understand the problem
# We need to check if the given strin... | for i in range(len(text)):
if text[i] != text[len(text) - 1 - i]:
return False
return True
| false | code_execution |
49 |
def modp(n: int, p: int):
"""Return 2^n modulo p (be aware of numerics).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
Here is the solution:
```python
def modp(n: int, p: int):
"""Return 2^n modulo p (be aware of numerics).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
return pow(2, n, p)
```
The `pow` function in Python takes... | def modp(n: int, p: int):
"""Return 2^n modulo p (be aware of numerics).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
return pow(2, n, p) | ret = 1
for i in range(n):
ret = (2 * ret) % p
return ret
| false | code_execution |
50 |
def encode_shift(s: str):
"""
returns encoded string by shifting every character by 5 in the alphabet.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
takes as input string encoded with encode_shift function. Returns decoded str... |
Step 1: Understand the problem.
The `encode_shift` function takes a string as input and returns an encoded string by shifting each character by 5 in the alphabet.
Step 2: Consider edge cases.
- Empty string (should return an empty string)
- Strings with uppercase letters (should be preserved)
- Strings with specia... | def encode_shift(s: str):
"""
returns encoded string by shifting every character by 5 in the alphabet.
"""
result = ""
for ch in s:
if ch.isalpha():
# Shift the character by 5 in the alphabet
shifted_ch = chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a"))
res... | return "".join([chr(((ord(ch) - 5 - ord("a")) % 26) + ord("a")) for ch in s])
| false | code_execution |
51 |
def remove_vowels(text):
"""
remove_vowels is a function that takes string and returns string without vowels.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaB... |
Here is the solution:
```python
def remove_vowels(text):
vowels = "aeiouAEIOU"
result = ""
for char in text:
if char not in vowels:
result += char
return result
```
This function iterates through each character in the input string and checks if it is a vowel. If it is not a vowel... | def remove_vowels(text):
vowels = "aeiouAEIOU"
result = ""
for char in text:
if char not in vowels:
result += char
return result | return "".join([s for s in text if s.lower() not in ["a", "e", "i", "o", "u"]])
| false | code_execution |
52 |
def below_threshold(l: list, t: int):
"""Return True if all numbers in the list l are below threshold t.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
Here is the solution:
```python
def below_threshold(l: list, t: int):
"""Return True if all numbers in the list l are below threshold t.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
for num in l:
if num >= t:
return Fals... | for num in l:
if num >= t:
return False
return True | for e in l:
if e >= t:
return False
return True
| false | code_execution |
53 |
def add(x: int, y: int):
"""Add two numbers x and y
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
Here is the solution:
```python
def add(x: int, y: int):
"""Add two numbers x and y
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
return x + y
```
Let me think through this step by step.
Step 1: Understand the problem.
I need to add two numbers x and y.
Step 2: Consider edge cases.
- Adding pos... | return x + y | return x + y
| false | code_execution |
54 |
def same_chars(s0: str, s1: str):
"""
Check if two words have the same characters.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same... |
Here is the solution:
```python
def same_chars(s0: str, s1: str):
# Convert strings to lowercase
s0 = s0.lower()
s1 = s1.lower()
# Check if the lengths are different
if len(s0) != len(s1):
return False
# Sort the strings
s0 = sorted(s0)
s1 = sorted(s1)
# Compare the sor... | def same_chars(s0: str, s1: str):
# Convert strings to lowercase
s0 = s0.lower()
s1 = s1.lower()
# Check if the lengths are different
if len(s0) != len(s1):
return False
# Sort the strings
s0 = sorted(s0)
s1 = sorted(s1)
# Compare the sorted strings
return s0 == s1 | return set(s0) == set(s1)
| false | code_execution |
55 |
def fib(n: int):
"""Return n-th Fibonacci number.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
Here is the solution:
```python
def fib(n: int):
"""Return n-th Fibonacci number.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
if n <= 1:
return n
else:
return fib(n-1) + fib(n-2)
```
Let me think through this step by step.
Step 1: Understand the problem.
Th... | print(fib(10)) # Output: 55
print(fib(1)) # Output: 1
print(fib(8)) # Output: 21 | if n == 0:
return 0
if n == 1:
return 1
return fib(n - 1) + fib(n - 2)
| false | code_execution |
56 |
def correct_bracketing(brackets: str):
""" brackets is a string of "<" and ">".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketin... |
Here is the solution:
```python
def correct_bracketing(brackets: str):
""" brackets is a string of "<" and ">".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
... | def correct_bracketing(brackets: str):
""" brackets is a string of "<" and ">".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketing(... | depth = 0
for b in brackets:
if b == "<":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
| false | code_execution |
57 |
def monotonic(l: list):
"""Return True is list elements are monotonically increasing or decreasing.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
Here is the solution:
```python
def monotonic(l: list):
if len(l) < 2:
return True
increasing = (l[0] < l[1])
for i in range(1, len(l)):
if increasing and l[i-1] > l[i]:
return False
if not increasing and l[i-1] < l[i]:
return False
return True
```
Exp... | def monotonic(l: list):
if len(l) < 2:
return True
increasing = (l[0] < l[1])
for i in range(1, len(l)):
if increasing and l[i-1] > l[i]:
return False
if not increasing and l[i-1] < l[i]:
return False
return True | if l == sorted(l) or l == sorted(l, reverse=True):
return True
return False
| false | code_execution |
58 |
def common(l1: list, l2: list):
"""Return sorted unique common elements for two lists.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
Here is the solution:
```python
def common(l1: list, l2: list):
"""Return sorted unique common elements for two lists.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
return sorted(set(l1).intersection(l2))
```
Expla... | def common(l1: list, l2: list):
"""Return sorted unique common elements for two lists.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
return sorted(set(l1).intersection(l2)) | ret = set()
for e1 in l1:
for e2 in l2:
if e1 == e2:
ret.add(e1)
return sorted(list(ret))
| false | code_execution |
59 |
def largest_prime_factor(n: int):
"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
Here is the solution:
```python
def largest_prime_factor(n: int):
"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
# Initialize the largest prime factor
largest_factor = 1
# Check if ... | def largest_prime_factor(n: int):
"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
# Initialize the largest prime factor
largest_factor = 1
# Check if n is even
while n % 2 == 0:
... | def is_prime(k):
if k < 2:
return False
for i in range(2, k - 1):
if k % i == 0:
return False
return True
largest = 1
for j in range(2, n + 1):
if n % j == 0 and is_prime(j):
largest = max(largest, j)
return largest
| false | code_execution |
60 |
def sum_to_n(n: int):
"""sum_to_n is a function that sums numbers from 1 to n.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
Step 1: Understand the problem.
The function `sum_to_n` takes an integer `n` as input and returns the sum of numbers from 1 to `n`.
Step 2: Consider edge cases.
- Negative numbers: What should the function return for negative numbers?
- Zero: What should the function return for `n = 0`?
- Large numbers: What shoul... | sum = 0
for i in range(1, n + 1):
sum += i
return sum | return sum(range(n + 1))
| false | code_execution |
61 |
def correct_bracketing(brackets: str):
""" brackets is a string of "(" and ")".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketin... |
Here is the solution:
```python
def correct_bracketing(brackets: str):
""" brackets is a string of "(" and ")".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
... | def correct_bracketing(brackets: str):
""" brackets is a string of "(" and ")".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketing(... | depth = 0
for b in brackets:
if b == "(":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
| false | code_execution |
62 |
def derivative(xs: list):
""" xs represent coefficients of a polynomial.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
Return derivative of this polynomial in the same form.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
Step 1: Understand the problem
In this problem, we are given a list of coefficients representing a polynomial. The goal is to find the derivative of this polynomial and return the coefficients of the derivative in the same form.
Step 2: Consider edge cases
Here are some edge cases to consider:
* What if the list ... | def derivative(xs: list):
if len(xs) == 0:
return []
elif len(xs) == 1:
return [0]
else:
return [i * x for i, x in enumerate(xs[1:], start=1)] | return [(i * x) for i, x in enumerate(xs)][1:]
| false | code_execution |
63 |
def fibfib(n: int):
"""The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Please write a function to efficiently compute the n-th element of th... |
Here is the solution:
```python
def fibfib(n: int):
if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 1
return fibfib(n-1) + fibfib(n-2) + fibfib(n-3)
```
Explanation:
* We start by checking for the base cases, where `n` is 0, 1, or 2.
* If `n` is greater than 2,... | def fibfib(n: int):
if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 1
return fibfib(n-1) + fibfib(n-2) + fibfib(n-3) | if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 1
return fibfib(n - 1) + fibfib(n - 2) + fibfib(n - 3)
| false | code_execution |
64 |
FIX = """
Add more test cases.
"""
def vowels_count(s):
"""Write a function vowels_count which takes a string representing
a word as input and returns the number of vowels in the string.
Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
vowel, but only when it is at the end of the g... |
Here is the solution:
```python
def vowels_count(s):
vowels = "aeiouAEIOU"
count = 0
for char in s:
if char in vowels:
count += 1
if s[-1] == 'y' or s[-1] == 'Y':
count += 1
return count
```
Explanation:
1. We define a string `vowels` that contains all the vowels.
2... | def vowels_count(s):
vowels = "aeiouAEIOU"
count = 0
for char in s:
if char in vowels:
count += 1
if s[-1] == 'y' or s[-1] == 'Y':
count += 1
return count | vowels = "aeiouAEIOU"
n_vowels = sum(c in vowels for c in s)
if s[-1] == 'y' or s[-1] == 'Y':
n_vowels += 1
return n_vowels
| false | code_execution |
65 |
def circular_shift(x, shift):
"""Circular shift the digits of the integer x, shift the digits right by shift
and return the result as a string.
If shift > number of digits, return digits reversed.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
"""
|
Here is the solution:
```python
def circular_shift(x, shift):
# Convert the integer to a string
x_str = str(x)
# If shift is greater than the number of digits, return the digits reversed
if shift >= len(x_str):
return x_str[::-1]
# Perform the circular shift
shifted_str = x_str[-shi... | def circular_shift(x, shift):
# Convert the integer to a string
x_str = str(x)
# If shift is greater than the number of digits, return the digits reversed
if shift >= len(x_str):
return x_str[::-1]
# Perform the circular shift
shifted_str = x_str[-shift:] + x_str[:-shift]
# Return... | s = str(x)
if shift > len(s):
return s[::-1]
else:
return s[len(s) - shift:] + s[:len(s) - shift]
| false | code_execution |
66 |
def digitSum(s):
"""Task
Write a function that takes a string as input and returns the sum of the upper characters only'
ASCII codes.
Examples:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
... |
Here is the solution:
```python
def digitSum(s):
# Initialize the sum variable
sum = 0
# Iterate through each character in the string
for char in s:
# Check if the character is an uppercase letter
if char.isupper():
# Add the ASCII code of the character to the sum
... | def digitSum(s):
# Initialize the sum variable
sum = 0
# Iterate through each character in the string
for char in s:
# Check if the character is an uppercase letter
if char.isupper():
# Add the ASCII code of the character to the sum
sum += ord(char)
# Return... | if s == "": return 0
return sum(ord(char) if char.isupper() else 0 for char in s)
| false | code_execution |
67 |
def fruit_distribution(s,n):
"""
In this task, you will be given a string that represents a number of apples and oranges
that are distributed in a basket of fruit this basket contains
apples, oranges, and mango fruits. Given the string that represents the total number of
the oranges and apples a... |
Here is the solution:
```python
def fruit_distribution(s, n):
# Parse the string to get the number of apples and oranges
apples, oranges = map(int, re.findall(r'\d+', s))
# Calculate the number of mangoes
mangoes = n - apples - oranges
return mangoes
```
Explanation:
* We use the `re.findall(... | def fruit_distribution(s, n):
# Parse the string to get the number of apples and oranges
apples, oranges = map(int, re.findall(r'\d+', s))
# Calculate the number of mangoes
mangoes = n - apples - oranges
return mangoes | lis = list()
for i in s.split(' '):
if i.isdigit():
lis.append(int(i))
return n - sum(lis)
| false | code_execution |
68 |
def pluck(arr):
"""
"Given an array representing a branch of a tree that has non-negative integer nodes
your task is to pluck one of the nodes and return it.
The plucked node should be the node with the smallest even value.
If multiple nodes with the same smallest even value are found return the no... |
Here is the solution:
```python
def pluck(arr):
if not arr:
return []
smallest_value = float('inf')
smallest_index = float('inf')
for i, value in enumerate(arr):
if value % 2 == 0 and value < smallest_value:
smallest_value = value
smallest_index = i
retu... | def pluck(arr):
if not arr:
return []
smallest_value = float('inf')
smallest_index = float('inf')
for i, value in enumerate(arr):
if value % 2 == 0 and value < smallest_value:
smallest_value = value
smallest_index = i
return [smallest_value, smallest_index] | if(len(arr) == 0): return []
evens = list(filter(lambda x: x%2 == 0, arr))
if(evens == []): return []
return [min(evens), arr.index(min(evens))]
| false | code_execution |
69 |
def search(lst):
'''
You are given a non-empty list of positive integers. Return the greatest integer that is greater than
zero, and has a frequency greater than or equal to the value of the integer itself.
The frequency of an integer is the number of times it appears in the list.
If no such a va... |
Here is the solution:
```python
def search(lst):
# Create a dictionary to store the frequency of each integer
freq = {}
# Iterate through the list and calculate the frequency of each integer
for num in lst:
if num in freq:
freq[num] += 1
else:
freq[num] = 1
... | def search(lst):
# Create a dictionary to store the frequency of each integer
freq = {}
# Iterate through the list and calculate the frequency of each integer
for num in lst:
if num in freq:
freq[num] += 1
else:
freq[num] = 1
# Find the greatest integer with... | frq = [0] * (max(lst) + 1)
for i in lst:
frq[i] += 1;
ans = -1
for i in range(1, len(frq)):
if frq[i] >= i:
ans = i
return ans
| false | code_execution |
70 |
def strange_sort_list(lst):
'''
Given list of integers, return list in strange order.
Strange sorting, is when you start with the minimum value,
then maximum of the remaining integers, then minimum and so on.
Examples:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
strange_sort_list([5, 5... |
Here is the solution:
```python
def strange_sort_list(lst):
if len(lst) == 0:
return []
if len(lst) == 1:
return lst
if len(lst) == 2:
return [min(lst), max(lst)]
return [min(lst)] + strange_sort_list([x for x in lst if x != min(lst)])
```
Explanation:
* The function check... | def strange_sort_list(lst):
if len(lst) == 0:
return []
if len(lst) == 1:
return lst
if len(lst) == 2:
return [min(lst), max(lst)]
return [min(lst)] + strange_sort_list([x for x in lst if x != min(lst)]) | res, switch = [], True
while lst:
res.append(min(lst) if switch else max(lst))
lst.remove(res[-1])
switch = not switch
return res
| false | code_execution |
71 |
def triangle_area(a, b, c):
'''
Given the lengths of the three sides of a triangle. Return the area of
the triangle rounded to 2 decimal points if the three sides form a valid triangle.
Otherwise return -1
Three sides make a valid triangle when the sum of any two sides is greater
than the thi... |
Step 1: Understand the problem
We need to calculate the area of a triangle given the lengths of its three sides. If the three sides form a valid triangle, we should return the area rounded to 2 decimal points. Otherwise, we should return -1.
Step 2: Consider edge cases
Here are some edge cases to consider:
* What... | def triangle_area(a, b, c):
# Check if the three sides form a valid triangle
if a + b > c and a + c > b and b + c > a:
# Calculate the semi-perimeter
s = (a + b + c) / 2
# Calculate the area using Heron's formula
area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
# Round the... | if a + b <= c or a + c <= b or b + c <= a:
return -1
s = (a + b + c)/2
area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
area = round(area, 2)
return area
| false | code_execution |
72 |
def will_it_fly(q,w):
'''
Write a function that returns True if the object q will fly, and False otherwise.
The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
Example:
will_it_fly([1, 2], 5) ➞ False
... |
Here is the solution:
```python
def will_it_fly(q,w):
if sum(q) > w:
return False
if q == q[::-1]:
return True
else:
return False
```
Explanation:
* We check if the sum of the elements in the list `q` is greater than the maximum possible weight `w`. If it is, we return `False`... | def will_it_fly(q,w):
if sum(q) > w:
return False
if q == q[::-1]:
return True
else:
return False | if sum(q) > w:
return False
i, j = 0, len(q)-1
while i<j:
if q[i] != q[j]:
return False
i+=1
j-=1
return True
| false | code_execution |
73 |
def smallest_change(arr):
"""
Given an array arr of integers, find the minimum number of elements that
need to be changed to make the array palindromic. A palindromic array is an array that
is read the same backwards and forwards. In one change, you can change one element to any other element.
For... |
Here is the solution:
```python
def smallest_change(arr):
# Initialize the number of changes
changes = 0
# Iterate through the array from both ends
i = 0
j = len(arr) - 1
while i < j:
# If the elements at the current indices are not equal
if arr[i] != arr[j]:
# In... | def smallest_change(arr):
# Initialize the number of changes
changes = 0
# Iterate through the array from both ends
i = 0
j = len(arr) - 1
while i < j:
# If the elements at the current indices are not equal
if arr[i] != arr[j]:
# Increment the number of changes
... | ans = 0
for i in range(len(arr) // 2):
if arr[i] != arr[len(arr) - i - 1]:
ans += 1
return ans
| false | code_execution |
74 |
def total_match(lst1, lst2):
'''
Write a function that accepts two lists of strings and returns the list that has
total number of chars in the all strings of the list less than the other list.
if the two lists have the same number of chars, return the first list.
Examples
total_match([], [])... |
Here is the solution:
```python
def total_match(lst1, lst2):
# Calculate the total number of characters in each list
total1 = sum(len(s) for s in lst1)
total2 = sum(len(s) for s in lst2)
# Compare the totals and return the appropriate list
if total1 < total2:
return lst1
else:
... | def total_match(lst1, lst2):
# Calculate the total number of characters in each list
total1 = sum(len(s) for s in lst1)
total2 = sum(len(s) for s in lst2)
# Compare the totals and return the appropriate list
if total1 < total2:
return lst1
else:
return lst2 | l1 = 0
for st in lst1:
l1 += len(st)
l2 = 0
for st in lst2:
l2 += len(st)
if l1 <= l2:
return lst1
else:
return lst2
| false | code_execution |
75 |
def is_multiply_prime(a):
"""Write a function that returns true if the given number is the multiplication of 3 prime numbers
and false otherwise.
Knowing that (a) is less then 100.
Example:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
Here is the solution:
```python
def is_multiply_prime(a):
# Check if a is less than 100
if a < 100:
# Initialize a list of prime numbers
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
# Initialize a flag to track if a is a mul... | def is_multiply_prime(a):
# Check if a is less than 100
if a < 100:
# Initialize a list of prime numbers
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
# Initialize a flag to track if a is a multiple of 3 primes
is_multip... | def is_prime(n):
for j in range(2,n):
if n%j == 0:
return False
return True
for i in range(2,101):
if not is_prime(i): continue
for j in range(2,101):
if not is_prime(j): continue
for k in range(2,101):
if not i... | false | code_execution |
76 |
def is_simple_power(x, n):
"""Your task is to write a function that returns true if a number x is a simple
power of n and false in other cases.
x is a simple power of n if n**int=x
For example:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => true
is_... |
Here is the solution:
```python
def is_simple_power(x, n):
if n == 0 and x != 1:
return False
if n == 1 and x != 1:
return False
if n < 0 and x < 0:
return False
if n < 0 and x == 0:
return False
if n < 0 and x > 0:
return False
if n > 0 and x == 0:
... | def is_simple_power(x, n):
if n == 0 and x != 1:
return False
if n == 1 and x != 1:
return False
if n < 0 and x < 0:
return False
if n < 0 and x == 0:
return False
if n < 0 and x > 0:
return False
if n > 0 and x == 0:
return False
if n > 0 and ... | if (n == 1):
return (x == 1)
power = 1
while (power < x):
power = power * n
return (power == x)
| false | code_execution |
77 |
def iscube(a):
'''
Write a function that takes an integer a and returns True
if this ingeger is a cube of some integer number.
Note: you may assume the input is always valid.
Examples:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> ... |
Step 1: Understand the problem
We need to write a function that takes an integer `a` as input and returns `True` if `a` is a cube of some integer number.
Step 2: Consider edge cases
- Negative numbers: Can `a` be negative? If so, what should the function return for negative numbers?
- Zero: What should the functio... | import math
def iscube(a):
if a == 0:
return True
if a < 0:
return a % 3 == 0
cube_root = math.pow(a, 1/3)
return round(cube_root) == cube_root | a = abs(a)
return int(round(a ** (1. / 3))) ** 3 == a
| false | code_execution |
78 |
def hex_key(num):
"""You have been tasked to write a function that receives
a hexadecimal number as a string and counts the number of hexadecimal
digits that are primes (prime number, or a prime, is a natural number
greater than 1 that is not a product of two smaller natural numbers).
Hexadecima... |
Here is the function body:
```python
# Initialize a counter for prime digits
prime_count = 0
# Define a set of prime hexadecimal digits
prime_digits = set(['2', '3', '5', '7', 'B', 'D'])
# Iterate through each character in the hexadecimal number
for char in num:
# Check if the chara... | # Initialize a counter for prime digits
prime_count = 0
# Define a set of prime hexadecimal digits
prime_digits = set(['2', '3', '5', '7', 'B', 'D'])
# Iterate through each character in the hexadecimal number
for char in num:
# Check if the character is a prime digit
if char in pri... | primes = ('2', '3', '5', '7', 'B', 'D')
total = 0
for i in range(0, len(num)):
if num[i] in primes:
total += 1
return total
| false | code_execution |
79 |
def decimal_to_binary(decimal):
"""You will be given a number in decimal form and your task is to convert it to
binary format. The function should return a string, with each character representing a binary
number. Each character in the string will be '0' or '1'.
There will be an extra couple of charac... |
Here is the solution:
```python
def decimal_to_binary(decimal):
binary = bin(decimal)[2:]
return "db" + binary + "db"
```
Explanation:
1. The `bin()` function converts a decimal number to binary. It returns a string that starts with "0b".
2. The `[2:]` slice removes the first two characters ("0b") from t... | def decimal_to_binary(decimal):
binary = bin(decimal)[2:]
return "db" + binary + "db" | return "db" + bin(decimal)[2:] + "db"
| false | code_execution |
80 |
def is_happy(s):
"""You are given a string s.
Your task is to check if the string is happy or not.
A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
For example:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => ... |
Here is the solution:
```python
def is_happy(s):
if len(s) < 3:
return False
for i in range(len(s) - 2):
if s[i] == s[i + 1] or s[i] == s[i + 2] or s[i + 1] == s[i + 2]:
return False
return True
```
Explanation:
* We check if the length of the string is less than 3. If it ... | def is_happy(s):
if len(s) < 3:
return False
for i in range(len(s) - 2):
if s[i] == s[i + 1] or s[i] == s[i + 2] or s[i + 1] == s[i + 2]:
return False
return True | if len(s) < 3:
return False
for i in range(len(s) - 2):
if s[i] == s[i+1] or s[i+1] == s[i+2] or s[i] == s[i+2]:
return False
return True
| false | code_execution |
81 |
def numerical_letter_grade(grades):
"""It is the last week of the semester and the teacher has to give the grades
to students. The teacher has been making her own algorithm for grading.
The only problem is, she has lost the code she used for grading.
She has given you a list of GPAs for some students a... |
Here is the function body:
```python
letter_grades = []
for gpa in grades:
if gpa == 4.0:
letter_grades.append('A+')
elif gpa > 3.7:
letter_grades.append('A')
elif gpa > 3.3:
letter_grades.append('A-')
elif gpa > 3.0:
letter_grad... | letter_grades = []
for gpa in grades:
if gpa == 4.0:
letter_grades.append('A+')
elif gpa > 3.7:
letter_grades.append('A')
elif gpa > 3.3:
letter_grades.append('A-')
elif gpa > 3.0:
letter_grades.append('B+')
elif gpa > 2.7:
... |
letter_grade = []
for gpa in grades:
if gpa == 4.0:
letter_grade.append("A+")
elif gpa > 3.7:
letter_grade.append("A")
elif gpa > 3.3:
letter_grade.append("A-")
elif gpa > 3.0:
letter_grade.append("B+")
elif gpa > 2.7:
... | false | code_execution |
82 |
def prime_length(string):
"""Write a function that takes a string and returns True if the string
length is a prime number or False otherwise
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
|
Here is the solution:
```python
def prime_length(string):
"""Write a function that takes a string and returns True if the string
length is a prime number or False otherwise
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length(... | def prime_length(string):
"""Write a function that takes a string and returns True if the string
length is a prime number or False otherwise
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
# Ch... | l = len(string)
if l == 0 or l == 1:
return False
for i in range(2, l):
if l % i == 0:
return False
return True
| false | code_execution |
83 |
def starts_one_ends(n):
"""
Given a positive integer n, return the count of the numbers of n-digit
positive integers that start or end with 1.
"""
|
Here is the solution:
```python
def starts_one_ends(n):
"""
Given a positive integer n, return the count of the numbers of n-digit
positive integers that start or end with 1.
"""
if n == 1:
return 1
if n == 2:
return 19
return (10 ** (n - 2) - 1) * 18 + 10
```
Explanation... | def starts_one_ends(n):
"""
Given a positive integer n, return the count of the numbers of n-digit
positive integers that start or end with 1.
"""
if n == 1:
return 1
if n == 2:
return 19
return (10 ** (n - 2) - 1) * 18 + 10 | if n == 1: return 1
return 18 * (10 ** (n - 2))
| false | code_execution |
84 |
def solve(N):
"""Given a positive integer N, return the total sum of its digits in binary.
Example
For N = 1000, the sum of digits will be 1 the output should be "1".
For N = 150, the sum of digits will be 6 the output should be "110".
For N = 147, the sum of digits will be 12 the ... |
Step 1: Understand the problem
Given a positive integer N, return the total sum of its digits in binary.
Step 2: Consider edge cases
- N is 0
- N is a single digit
- N is a multiple of 10
Step 3: Implementation
```python
def solve(N):
# Convert N to a string
N_str = str(N)
# Calculate the sum of dig... | def solve(N):
# Convert N to a string
N_str = str(N)
# Calculate the sum of digits
sum_digits = sum(int(digit) for digit in N_str)
# Convert the sum to binary
sum_binary = bin(sum_digits)
# Remove the "0b" prefix
sum_binary = sum_binary[2:]
return sum_binary | return bin(sum(int(i) for i in str(N)))[2:]
| false | code_execution |
85 |
def add(lst):
"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
Examples:
add([4, 2, 6, 7]) ==> 2
"""
|
Here is the solution:
```python
def add(lst):
"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
Examples:
add([4, 2, 6, 7]) ==> 2
"""
result = 0
for i in range(1, len(lst), 2):
if lst[i] % 2 == 0:
result += lst[i]
return ... | def add(lst):
"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
Examples:
add([4, 2, 6, 7]) ==> 2
"""
result = 0
for i in range(1, len(lst), 2):
if lst[i] % 2 == 0:
result += lst[i]
return result | return sum([lst[i] for i in range(1, len(lst), 2) if lst[i]%2 == 0])
| false | code_execution |
86 |
def anti_shuffle(s):
"""
Write a function that takes a string and returns an ordered version of it.
Ordered version of string, is a string where all words (separated by space)
are replaced by a new word where all the characters arranged in
ascending order based on ascii value.
Note: You should ... |
Here is the solution:
```python
def anti_shuffle(s):
words = s.split()
ordered_words = []
for word in words:
ordered_word = ''.join(sorted(word))
ordered_words.append(ordered_word)
return ' '.join(ordered_words)
```
Let me explain the solution step by step:
1. We start by splitting... | def anti_shuffle(s):
words = s.split()
ordered_words = []
for word in words:
ordered_word = ''.join(sorted(word))
ordered_words.append(ordered_word)
return ' '.join(ordered_words) | return ' '.join([''.join(sorted(list(i))) for i in s.split(' ')])
| false | code_execution |
87 |
def get_row(lst, x):
"""
You are given a 2 dimensional data, as a nested lists,
which is similar to matrix, however, unlike matrices,
each row may contain a different number of columns.
Given lst, and integer x, find integers x in the list,
and return list of tuples, [(x1, y1), (x2, y2) ...] su... |
Here is the solution:
```python
def get_row(lst, x):
result = []
for i in range(len(lst)):
for j in range(len(lst[i])):
if lst[i][j] == x:
result.append((i, j))
return sorted(result, key=lambda tup: (tup[0], -tup[1]))
```
Explanation:
* We initialize an empty list ... | def get_row(lst, x):
result = []
for i in range(len(lst)):
for j in range(len(lst[i])):
if lst[i][j] == x:
result.append((i, j))
return sorted(result, key=lambda tup: (tup[0], -tup[1])) | coords = [(i, j) for i in range(len(lst)) for j in range(len(lst[i])) if lst[i][j] == x]
return sorted(sorted(coords, key=lambda x: x[1], reverse=True), key=lambda x: x[0])
| false | code_execution |
88 |
def sort_array(array):
"""
Given an array of non-negative integers, return a copy of the given array after sorting,
you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
or sort it in descending order if the sum( first index value, last index value) i... |
Here is the solution:
```python
def sort_array(array):
if len(array) == 0:
return []
elif len(array) == 1:
return [array[0]]
else:
if (array[0] + array[-1]) % 2 == 0:
return sorted(array, reverse=True)
else:
return sorted(array)
```
Explanation:
*... | def sort_array(array):
if len(array) == 0:
return []
elif len(array) == 1:
return [array[0]]
else:
if (array[0] + array[-1]) % 2 == 0:
return sorted(array, reverse=True)
else:
return sorted(array) | return [] if len(array) == 0 else sorted(array, reverse= (array[0]+array[-1]) % 2 == 0)
| false | code_execution |
89 |
def encrypt(s):
"""Create a function encrypt that takes a string as an argument and
returns a string encrypted with the alphabet being rotated.
The alphabet should be rotated in a manner such that the letters
shift down by two multiplied to two places.
For example:
encrypt('hi') returns 'lm'
... |
Here is the solution:
```python
def encrypt(s):
# Create a dictionary to map original letters to encrypted letters
encrypt_dict = {
'a': 'c', 'b': 'd', 'c': 'e', 'd': 'f', 'e': 'g', 'f': 'h', 'g': 'i', 'h': 'j', 'i': 'k', 'j': 'l', 'k': 'm', 'l': 'n', 'm': 'o', 'n': 'p', 'o': 'q', 'p': 'r', 'q': 's',... | def encrypt(s):
# Create a dictionary to map original letters to encrypted letters
encrypt_dict = {
'a': 'c', 'b': 'd', 'c': 'e', 'd': 'f', 'e': 'g', 'f': 'h', 'g': 'i', 'h': 'j', 'i': 'k', 'j': 'l', 'k': 'm', 'l': 'n', 'm': 'o', 'n': 'p', 'o': 'q', 'p': 'r', 'q': 's', 'r': 't', 's': 'u', 't': 'v', 'u':... | d = 'abcdefghijklmnopqrstuvwxyz'
out = ''
for c in s:
if c in d:
out += d[(d.index(c)+2*2) % 26]
else:
out += c
return out
| false | code_execution |
90 |
def next_smallest(lst):
"""
You are given a list of integers.
Write a function next_smallest() that returns the 2nd smallest element of the list.
Return None if there is no such element.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
... |
Step 1: Understand the problem
We are given a list of integers and need to find the 2nd smallest element in the list. If there is no such element, we should return None.
Step 2: Consider edge cases
- An empty list: If the list is empty, there is no 2nd smallest element, so we should return None.
- A list with a si... | null | lst = sorted(set(lst))
return None if len(lst) < 2 else lst[1]
| false | extraction_failed |
91 |
def is_bored(S):
"""
You'll be given a string of words, and your task is to count the number
of boredoms. A boredom is a sentence that starts with the word "I".
Sentences are delimited by '.', '?' or '!'.
For example:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The ... |
Here is the solution:
```python
def is_bored(S):
sentences = S.split('.')
boredoms = 0
for sentence in sentences:
if sentence.strip().lower().startswith('i'):
boredoms += 1
return boredoms
```
Explanation:
1. We split the input string into sentences using the `split` method.
2.... | def is_bored(S):
sentences = S.split('.')
boredoms = 0
for sentence in sentences:
if sentence.strip().lower().startswith('i'):
boredoms += 1
return boredoms | import re
sentences = re.split(r'[.?!]\s*', S)
return sum(sentence[0:2] == 'I ' for sentence in sentences)
| false | code_execution |
92 |
def any_int(x, y, z):
'''
Create a function that takes 3 numbers.
Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
Returns false in any other cases.
Examples
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
any_int(3, -2, ... |
Here is the solution:
```python
def any_int(x, y, z):
if (x == y + z) or (y == x + z) or (z == x + y):
return True
else:
return False
```
Explanation:
* We check if any of the three numbers is equal to the sum of the other two.
* If so, we return `True`.
* Otherwise, we return `False`... | def any_int(x, y, z):
if (x == y + z) or (y == x + z) or (z == x + y):
return True
else:
return False |
if isinstance(x,int) and isinstance(y,int) and isinstance(z,int):
if (x+y==z) or (x+z==y) or (y+z==x):
return True
return False
return False
| false | code_execution |
93 |
def encode(message):
"""
Write a function that takes a message, and encodes in such a
way that it swaps case of all letters, replaces all vowels in
the message with the letter that appears 2 places ahead of that
vowel in the english alphabet.
Assume only letters.
Examples:
>>>... |
Here is the solution:
```python
def encode(message):
vowels = "aeiouAEIOU"
vowels_map = {
"a": "c", "e": "g", "i": "k", "o": "n", "u": "r",
"A": "C", "E": "G", "I": "K", "O": "N", "U": "R"
}
encoded_message = ""
for char in message:
if char in vowels:
encoded_m... | def encode(message):
vowels = "aeiouAEIOU"
vowels_map = {
"a": "c", "e": "g", "i": "k", "o": "n", "u": "r",
"A": "C", "E": "G", "I": "K", "O": "N", "U": "R"
}
encoded_message = ""
for char in message:
if char in vowels:
encoded_message += vowels_map[char]
... | vowels = "aeiouAEIOU"
vowels_replace = dict([(i, chr(ord(i) + 2)) for i in vowels])
message = message.swapcase()
return ''.join([vowels_replace[i] if i in vowels else i for i in message])
| false | code_execution |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 17