task_id
stringlengths 11
13
| docstring
stringlengths 56
1.28k
| prompt
stringlengths 118
1.38k
| canonical_solution
stringlengths 16
864
| test
stringlengths 117
1.8k
| entry_point
stringlengths 1
30
| signature
stringlengths 4
68
| context
stringlengths 9
459
| instruction
stringlengths 123
1.34k
| instruction_noexamples
stringlengths 90
1.2k
| prompt_noexamples
stringlengths 69
1.22k
|
|---|---|---|---|---|---|---|---|---|---|---|
HumanEval/100 | Дано положительное целое число n, вы должны сложить груду камней из n уровней.
На первом уровне есть n камней.
Количество камней на следующем уровне определяется правилом:
- следующее нечетное число, если n нечетно.
- следующее четное число, если n четно.
Возвращает количество камней на каждом уровне в списке, где элемент с индексом i представляет количество камней на уровне (i+1).
Примеры:
>>> make_a_pile(3)
[3, 5, 7] | def make_a_pile(n):
"""
Дано положительное целое число n, вы должны сложить груду камней из n уровней.
На первом уровне есть n камней.
Количество камней на следующем уровне определяется правилом:
- следующее нечетное число, если n нечетно.
- следующее четное число, если n четно.
Возвращает количество камней на каждом уровне в списке, где элемент с индексом i представляет количество камней на уровне (i+1).
Примеры:
>>> make_a_pile(3)
[3, 5, 7]
"""
| return [n + 2*i for i in range(n)]
| def check(candidate):
# Check some simple cases
assert candidate(3) == [3, 5, 7], "Test 3"
assert candidate(4) == [4,6,8,10], "Test 4"
assert candidate(5) == [5, 7, 9, 11, 13]
assert candidate(6) == [6, 8, 10, 12, 14, 16]
assert candidate(8) == [8, 10, 12, 14, 16, 18, 20, 22]
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| make_a_pile | make_a_pile(n) | def make_a_pile(n): | Напишите функцию make_a_pile(n) для решения следующей задачи: Дано положительное целое число n, вы должны сложить груду камней из n уровней.
На первом уровне есть n камней.
Количество камней на следующем уровне определяется правилом:
- следующее нечетное число, если n нечетно.
- следующее четное число, если n четно.
Возвращает количество камней на каждом уровне в списке, где элемент с индексом i представляет количество камней на уровне (i+1).
Примеры:
>>> make_a_pile(3)
[3, 5, 7] | Напишите функцию make_a_pile(n) для решения следующей задачи: Дано положительное целое число n, вы должны сложить груду камней из n уровней.
На первом уровне есть n камней.
Количество камней на следующем уровне определяется правилом:
- следующее нечетное число, если n нечетно.
- следующее четное число, если n четно.
Возвращает количество камней на каждом уровне в списке, где элемент с индексом i представляет количество камней на уровне (i+1).
Примеры: | def make_a_pile(n):
"""
Дано положительное целое число n, вы должны сложить груду камней из n уровней.
На первом уровне есть n камней.
Количество камней на следующем уровне определяется правилом:
- следующее нечетное число, если n нечетно.
- следующее четное число, если n четно.
Возвращает количество камней на каждом уровне в списке, где элемент с индексом i представляет количество камней на уровне (i+1).
Примеры:
"""
|
HumanEval/101 | Вам дана строка слов, разделенных запятыми или пробелами. Ваша задача состоит в том, чтобы разбить строку на слова и вернуть массив слов.
Примеры:
words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"] | def words_string(s):
"""
Вам дана строка слов, разделенных запятыми или пробелами. Ваша задача состоит в том, чтобы разбить строку на слова и вернуть массив слов.
Примеры:
words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
"""
| if not s:
return []
s_list = []
for letter in s:
if letter == ',':
s_list.append(' ')
else:
s_list.append(letter)
s_list = "".join(s_list)
return s_list.split()
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
assert candidate("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
assert candidate("Hi, my name") == ["Hi", "my", "name"]
assert candidate("One,, two, three, four, five, six,") == ["One", "two", "three", "four", "five", "six"]
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate("") == []
assert candidate("ahmed , gamal") == ["ahmed", "gamal"]
| words_string | words_string(s) | def words_string(s): | Напишите функцию words_string(s) для решения следующей задачи: Вам дана строка слов, разделенных запятыми или пробелами. Ваша задача состоит в том, чтобы разбить строку на слова и вернуть массив слов.
Примеры:
words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"] | Напишите функцию words_string(s) для решения следующей задачи: Вам дана строка слов, разделенных запятыми или пробелами. Ваша задача состоит в том, чтобы разбить строку на слова и вернуть массив слов. | def words_string(s):
"""
Вам дана строка слов, разделенных запятыми или пробелами. Ваша задача состоит в том, чтобы разбить строку на слова и вернуть массив слов.
"""
|
HumanEval/102 | Функция принимает два положительных числа x и y и возвращает наибольшее четное целое число, находящееся в диапазоне [x, y] включительно. Если такого числа нет, то функция должна возвращать -1.
Примеры:
choose_num(12, 15) = 14
choose_num(13, 12) = -1 | def choose_num(x, y):
"""
Функция принимает два положительных числа x и y и возвращает наибольшее четное целое число, находящееся в диапазоне [x, y] включительно. Если такого числа нет, то функция должна возвращать -1.
Примеры:
choose_num(12, 15) = 14
choose_num(13, 12) = -1
"""
| if x > y:
return -1
if y % 2 == 0:
return y
if x == y:
return -1
return y - 1
| def check(candidate):
# Check some simple cases
assert candidate(12, 15) == 14
assert candidate(13, 12) == -1
assert candidate(33, 12354) == 12354
assert candidate(5234, 5233) == -1
assert candidate(6, 29) == 28
assert candidate(27, 10) == -1
# Check some edge cases that are easy to work out by hand.
assert candidate(7, 7) == -1
assert candidate(546, 546) == 546
| choose_num | choose_num(x, y) | def choose_num(x, y): | Напишите функцию choose_num(x, y) для решения следующей задачи: Функция принимает два положительных числа x и y и возвращает наибольшее четное целое число, находящееся в диапазоне [x, y] включительно. Если такого числа нет, то функция должна возвращать -1.
Примеры:
choose_num(12, 15) = 14
choose_num(13, 12) = -1 | Напишите функцию choose_num(x, y) для решения следующей задачи: Функция принимает два положительных числа x и y и возвращает наибольшее четное целое число, находящееся в диапазоне [x, y] включительно. Если такого числа нет, то функция должна возвращать -1. | def choose_num(x, y):
"""
Функция принимает два положительных числа x и y и возвращает наибольшее четное целое число, находящееся в диапазоне [x, y] включительно. Если такого числа нет, то функция должна возвращать -1.
"""
|
HumanEval/103 | Вам даны два натуральных числа n и m, и ваша задача состоит в том, чтобы вычислить среднее значение целых чисел от n до m (включая n и m).
Округлите ответ до ближайшего целого числа и преобразуйте его в двоичный код.
Если n больше m, верните значение -1.
Примеры:
rounded_avg(1, 5) => "0b11"
rounded_avg(7, 5) => -1
rounded_avg(10, 20) => "0b1111"
rounded_avg(20, 33) => "0b11010" | def rounded_avg(n, m):
"""
Вам даны два натуральных числа n и m, и ваша задача состоит в том, чтобы вычислить среднее значение целых чисел от n до m (включая n и m).
Округлите ответ до ближайшего целого числа и преобразуйте его в двоичный код.
Если n больше m, верните значение -1.
Примеры:
rounded_avg(1, 5) => "0b11"
rounded_avg(7, 5) => -1
rounded_avg(10, 20) => "0b1111"
rounded_avg(20, 33) => "0b11010"
"""
| if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1)))
| def check(candidate):
# Check some simple cases
assert candidate(1, 5) == "0b11"
assert candidate(7, 13) == "0b1010"
assert candidate(964,977) == "0b1111001010"
assert candidate(996,997) == "0b1111100100"
assert candidate(560,851) == "0b1011000010"
assert candidate(185,546) == "0b101101110"
assert candidate(362,496) == "0b110101101"
assert candidate(350,902) == "0b1001110010"
assert candidate(197,233) == "0b11010111"
# Check some edge cases that are easy to work out by hand.
assert candidate(7, 5) == -1
assert candidate(5, 1) == -1
assert candidate(5, 5) == "0b101"
| rounded_avg | rounded_avg(n, m) | def rounded_avg(n, m): | Напишите функцию rounded_avg(n, m) для решения следующей задачи: Вам даны два натуральных числа n и m, и ваша задача состоит в том, чтобы вычислить среднее значение целых чисел от n до m (включая n и m).
Округлите ответ до ближайшего целого числа и преобразуйте его в двоичный код.
Если n больше m, верните значение -1.
Примеры:
rounded_avg(1, 5) => "0b11"
rounded_avg(7, 5) => -1
rounded_avg(10, 20) => "0b1111"
rounded_avg(20, 33) => "0b11010" | Напишите функцию rounded_avg(n, m) для решения следующей задачи: Вам даны два натуральных числа n и m, и ваша задача состоит в том, чтобы вычислить среднее значение целых чисел от n до m (включая n и m).
Округлите ответ до ближайшего целого числа и преобразуйте его в двоичный код.
Если n больше m, верните значение -1. | def rounded_avg(n, m):
"""
Вам даны два натуральных числа n и m, и ваша задача состоит в том, чтобы вычислить среднее значение целых чисел от n до m (включая n и m).
Округлите ответ до ближайшего целого числа и преобразуйте его в двоичный код.
Если n больше m, верните значение -1.
"""
|
HumanEval/104 | Дан список целых положительных чисел x. возвращает отсортированный список всех элементов, в котором нет ни одной четной цифры.
Примечание: Возвращаемый список должен быть отсортирован в порядке возрастания.
Например:
>>> unique_digits([15, 33, 1422, 1])
[1, 15, 33]
>>> unique_digits([152, 323, 1422, 10])
[] | def unique_digits(x):
"""
Дан список целых положительных чисел x. возвращает отсортированный список всех элементов, в котором нет ни одной четной цифры.
Примечание: Возвращаемый список должен быть отсортирован в порядке возрастания.
Например:
>>> unique_digits([15, 33, 1422, 1])
[1, 15, 33]
>>> unique_digits([152, 323, 1422, 10])
[]
"""
| odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements)
| def check(candidate):
# Check some simple cases
assert candidate([15, 33, 1422, 1]) == [1, 15, 33]
assert candidate([152, 323, 1422, 10]) == []
assert candidate([12345, 2033, 111, 151]) == [111, 151]
assert candidate([135, 103, 31]) == [31, 135]
# Check some edge cases that are easy to work out by hand.
assert True
| unique_digits | unique_digits(x) | def unique_digits(x): | Напишите функцию unique_digits(x) для решения следующей задачи: Дан список целых положительных чисел x. возвращает отсортированный список всех элементов, в котором нет ни одной четной цифры.
Примечание: Возвращаемый список должен быть отсортирован в порядке возрастания.
Например:
>>> unique_digits([15, 33, 1422, 1])
[1, 15, 33]
>>> unique_digits([152, 323, 1422, 10])
[] | Напишите функцию unique_digits(x) для решения следующей задачи: Дан список целых положительных чисел x. возвращает отсортированный список всех элементов, в котором нет ни одной четной цифры.
Примечание: Возвращаемый список должен быть отсортирован в порядке возрастания.
Например: | def unique_digits(x):
"""
Дан список целых положительных чисел x. возвращает отсортированный список всех элементов, в котором нет ни одной четной цифры.
Примечание: Возвращаемый список должен быть отсортирован в порядке возрастания.
Например:
"""
|
HumanEval/105 | Дан массив целых чисел, отсортируйте целые числа от 1 до 9 включительно,
разверните результирующий массив, а затем замените каждую цифру соответствующим именем из "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
Примеры:
arr = [2, 1, 1, 4, 5, 8, 2, 3]
-> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
-> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
Если массив пустой верните пустой массив:
arr = []
return []
Если встречаются невалидные элементы, игнорируйте их:
arr = [1, -1 , 55]
-> sort arr -> [-1, 1, 55]
-> reverse arr -> [55, 1, -1]
return = ['One'] | def by_length(arr):
"""
Дан массив целых чисел, отсортируйте целые числа от 1 до 9 включительно,
разверните результирующий массив, а затем замените каждую цифру соответствующим именем из "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
Примеры:
arr = [2, 1, 1, 4, 5, 8, 2, 3]
-> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
-> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
Если массив пустой верните пустой массив:
arr = []
return []
Если встречаются невалидные элементы, игнорируйте их:
arr = [1, -1 , 55]
-> sort arr -> [-1, 1, 55]
-> reverse arr -> [55, 1, -1]
return = ['One']
"""
| dic = {
1: "One",
2: "Two",
3: "Three",
4: "Four",
5: "Five",
6: "Six",
7: "Seven",
8: "Eight",
9: "Nine",
}
sorted_arr = sorted(arr, reverse=True)
new_arr = []
for var in sorted_arr:
try:
new_arr.append(dic[var])
except:
pass
return new_arr
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([2, 1, 1, 4, 5, 8, 2, 3]) == ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"], "Error"
assert candidate([]) == [], "Error"
assert candidate([1, -1 , 55]) == ['One'], "Error"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([1, -1, 3, 2]) == ["Three", "Two", "One"]
assert candidate([9, 4, 8]) == ["Nine", "Eight", "Four"]
| by_length | by_length(arr) | def by_length(arr): | Напишите функцию by_length(arr) для решения следующей задачи: Дан массив целых чисел, отсортируйте целые числа от 1 до 9 включительно,
разверните результирующий массив, а затем замените каждую цифру соответствующим именем из "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
Примеры:
arr = [2, 1, 1, 4, 5, 8, 2, 3]
-> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
-> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
Если массив пустой верните пустой массив:
arr = []
return []
Если встречаются невалидные элементы, игнорируйте их:
arr = [1, -1 , 55]
-> sort arr -> [-1, 1, 55]
-> reverse arr -> [55, 1, -1]
return = ['One'] | Напишите функцию by_length(arr) для решения следующей задачи: Дан массив целых чисел, отсортируйте целые числа от 1 до 9 включительно,
разверните результирующий массив, а затем замените каждую цифру соответствующим именем из "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine". | def by_length(arr):
"""
Дан массив целых чисел, отсортируйте целые числа от 1 до 9 включительно,
разверните результирующий массив, а затем замените каждую цифру соответствующим именем из "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
"""
|
HumanEval/106 | Реализуйте функцию f, которая принимает n в качестве параметра
и возвращает список размера n таким образом, чтобы значение элемента с индексом i было факториалом i, если i четно, или суммой чисел от 1 до i в противном случае.
i начинается с 1.
факториал i - это умножение чисел от 1 до i (1 * 2 * ... * i).
Примеры:
f(5) == [1, 2, 6, 24, 15] | def f(n):
"""
Реализуйте функцию f, которая принимает n в качестве параметра
и возвращает список размера n таким образом, чтобы значение элемента с индексом i было факториалом i, если i четно, или суммой чисел от 1 до i в противном случае.
i начинается с 1.
факториал i - это умножение чисел от 1 до i (1 * 2 * ... * i).
Примеры:
f(5) == [1, 2, 6, 24, 15]
"""
| ret = []
for i in range(1,n+1):
if i%2 == 0:
x = 1
for j in range(1,i+1): x *= j
ret += [x]
else:
x = 0
for j in range(1,i+1): x += j
ret += [x]
return ret
| def check(candidate):
assert candidate(5) == [1, 2, 6, 24, 15]
assert candidate(7) == [1, 2, 6, 24, 15, 720, 28]
assert candidate(1) == [1]
assert candidate(3) == [1, 2, 6]
| f | f(n) | def f(n): | Напишите функцию f(n) для решения следующей задачи: Реализуйте функцию f, которая принимает n в качестве параметра
и возвращает список размера n таким образом, чтобы значение элемента с индексом i было факториалом i, если i четно, или суммой чисел от 1 до i в противном случае.
i начинается с 1.
факториал i - это умножение чисел от 1 до i (1 * 2 * ... * i).
Примеры:
f(5) == [1, 2, 6, 24, 15] | Напишите функцию f(n) для решения следующей задачи: Реализуйте функцию f, которая принимает n в качестве параметра
и возвращает список размера n таким образом, чтобы значение элемента с индексом i было факториалом i, если i четно, или суммой чисел от 1 до i в противном случае.
i начинается с 1.
факториал i - это умножение чисел от 1 до i (1 * 2 * ... * i). | def f(n):
"""
Реализуйте функцию f, которая принимает n в качестве параметра
и возвращает список размера n таким образом, чтобы значение элемента с индексом i было факториалом i, если i четно, или суммой чисел от 1 до i в противном случае.
i начинается с 1.
факториал i - это умножение чисел от 1 до i (1 * 2 * ... * i).
"""
|
HumanEval/107 | Дано положительное целое число n, верните кортеж, содержащий количество четных и нечетных палиндромов-целых чисел, которые попадают в диапазон (1, n) включительно.
Примеры:
1:
Input: 3
Output: (1, 2)
Explanation:
Палиндромами являются 1, 2, 3. один из них четный, два нечетные 2:
Input: 12
Output: (4, 6)
Explanation:
Палиндромами являются 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. четыре из них четные, 6 нечетные.
Примечание:
1. 1 <= n <= 10^3 | def even_odd_palindrome(n):
"""
Дано положительное целое число n, верните кортеж, содержащий количество четных и нечетных палиндромов-целых чисел, которые попадают в диапазон (1, n) включительно.
Примеры:
1:
Input: 3
Output: (1, 2)
Explanation:
Палиндромами являются 1, 2, 3. один из них четный, два нечетные 2:
Input: 12
Output: (4, 6)
Explanation:
Палиндромами являются 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. четыре из них четные, 6 нечетные.
Примечание:
1. 1 <= n <= 10^3
"""
| def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
even_palindrome_count += 1
return (even_palindrome_count, odd_palindrome_count)
| def check(candidate):
# Check some simple cases
assert candidate(123) == (8, 13)
assert candidate(12) == (4, 6)
assert candidate(3) == (1, 2)
assert candidate(63) == (6, 8)
assert candidate(25) == (5, 6)
assert candidate(19) == (4, 6)
assert candidate(9) == (4, 5), "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == (0, 1), "This prints if this assert fails 2 (also good for debugging!)"
| even_odd_palindrome | even_odd_palindrome(n) | def even_odd_palindrome(n): | Напишите функцию even_odd_palindrome(n) для решения следующей задачи: Дано положительное целое число n, верните кортеж, содержащий количество четных и нечетных палиндромов-целых чисел, которые попадают в диапазон (1, n) включительно.
Примеры:
1:
Input: 3
Output: (1, 2)
Explanation:
Палиндромами являются 1, 2, 3. один из них четный, два нечетные 2:
Input: 12
Output: (4, 6)
Explanation:
Палиндромами являются 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. четыре из них четные, 6 нечетные.
Примечание:
1. 1 <= n <= 10^3 | Напишите функцию even_odd_palindrome(n) для решения следующей задачи: Дано положительное целое число n, верните кортеж, содержащий количество четных и нечетных палиндромов-целых чисел, которые попадают в диапазон (1, n) включительно. | def even_odd_palindrome(n):
"""
Дано положительное целое число n, верните кортеж, содержащий количество четных и нечетных палиндромов-целых чисел, которые попадают в диапазон (1, n) включительно.
"""
|
HumanEval/108 | Напишите функцию count_nums, которая принимает массив целых чисел и возвращает количество элементов, сумма цифр которых > 0.
Если число отрицательное, то его первая цифра со знаком будет отрицательной:
например, -123 имеет цифры со знаком -1, 2 и 3.
>>> count_nums([]) == 0
>>> count_nums([-1, 11, -11]) == 1
>>> count_nums([1, 1, 2]) == 3 | def count_nums(arr):
"""
Напишите функцию count_nums, которая принимает массив целых чисел и возвращает количество элементов, сумма цифр которых > 0.
Если число отрицательное, то его первая цифра со знаком будет отрицательной:
например, -123 имеет цифры со знаком -1, 2 и 3.
>>> count_nums([]) == 0
>>> count_nums([-1, 11, -11]) == 1
>>> count_nums([1, 1, 2]) == 3
"""
| def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr])))
| def check(candidate):
# Check some simple cases
assert candidate([]) == 0
assert candidate([-1, -2, 0]) == 0
assert candidate([1, 1, 2, -2, 3, 4, 5]) == 6
assert candidate([1, 6, 9, -6, 0, 1, 5]) == 5
assert candidate([1, 100, 98, -7, 1, -1]) == 4
assert candidate([12, 23, 34, -45, -56, 0]) == 5
assert candidate([-0, 1**0]) == 1
assert candidate([1]) == 1
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| count_nums | count_nums(arr) | def count_nums(arr): | Напишите функцию count_nums(arr) для решения следующей задачи: Напишите функцию count_nums, которая принимает массив целых чисел и возвращает количество элементов, сумма цифр которых > 0.
Если число отрицательное, то его первая цифра со знаком будет отрицательной:
например, -123 имеет цифры со знаком -1, 2 и 3.
>>> count_nums([]) == 0
>>> count_nums([-1, 11, -11]) == 1
>>> count_nums([1, 1, 2]) == 3 | Напишите функцию count_nums(arr) для решения следующей задачи: Напишите функцию count_nums, которая принимает массив целых чисел и возвращает количество элементов, сумма цифр которых > 0.
Если число отрицательное, то его первая цифра со знаком будет отрицательной:
например, -123 имеет цифры со знаком -1, 2 и 3. | def count_nums(arr):
"""
Напишите функцию count_nums, которая принимает массив целых чисел и возвращает количество элементов, сумма цифр которых > 0.
Если число отрицательное, то его первая цифра со знаком будет отрицательной:
например, -123 имеет цифры со знаком -1, 2 и 3.
"""
|
HumanEval/109 | У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N].Числа в массиве упорядочены случайным образом. Ваша задача состоит в том, чтобы определить, возможно ли отсортировать массив в порядке неубывания, выполнив следующую операцию над данным массивом:
Вам разрешается выполнять операцию сдвига вправо любое количество раз.
Одна операция сдвига вправо означает сдвиг всех элементов массива на одну позицию в правильном направлении. Последний элемент массива будет перемещен в начальную позицию в массиве, т.е. с 0-м индексом.
Если возможно получить отсортированный массив, выполнив описанную выше операцию, то верните True, иначе верните False.
Если данный массив пуст, то верните значение True.
Примечание: Данный список гарантированно содержит уникальные элементы.
Примеры:
move_one_ball([3, 4, 5, 1, 2])==>True Explanation: 2 сдвига
move_one_ball([3, 5, 4, 1, 2])==>False | def move_one_ball(arr):
"""
У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N].Числа в массиве упорядочены случайным образом. Ваша задача состоит в том, чтобы определить, возможно ли отсортировать массив в порядке неубывания, выполнив следующую операцию над данным массивом:
Вам разрешается выполнять операцию сдвига вправо любое количество раз.
Одна операция сдвига вправо означает сдвиг всех элементов массива на одну позицию в правильном направлении. Последний элемент массива будет перемещен в начальную позицию в массиве, т.е. с 0-м индексом.
Если возможно получить отсортированный массив, выполнив описанную выше операцию, то верните True, иначе верните False.
Если данный массив пуст, то верните значение True.
Примечание: Данный список гарантированно содержит уникальные элементы.
Примеры:
move_one_ball([3, 4, 5, 1, 2])==>True Explanation: 2 сдвига
move_one_ball([3, 5, 4, 1, 2])==>False
"""
| if len(arr)==0:
return True
sorted_array=sorted(arr)
my_arr=[]
min_value=min(arr)
min_index=arr.index(min_value)
my_arr=arr[min_index:]+arr[0:min_index]
for i in range(len(arr)):
if my_arr[i]!=sorted_array[i]:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate([3, 4, 5, 1, 2])==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([3, 5, 10, 1, 2])==True
assert candidate([4, 3, 1, 2])==False
# Check some edge cases that are easy to work out by hand.
assert candidate([3, 5, 4, 1, 2])==False, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([])==True
| move_one_ball | move_one_ball(arr) | def move_one_ball(arr): | Напишите функцию move_one_ball(arr) для решения следующей задачи: У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N].Числа в массиве упорядочены случайным образом. Ваша задача состоит в том, чтобы определить, возможно ли отсортировать массив в порядке неубывания, выполнив следующую операцию над данным массивом:
Вам разрешается выполнять операцию сдвига вправо любое количество раз.
Одна операция сдвига вправо означает сдвиг всех элементов массива на одну позицию в правильном направлении. Последний элемент массива будет перемещен в начальную позицию в массиве, т.е. с 0-м индексом.
Если возможно получить отсортированный массив, выполнив описанную выше операцию, то верните True, иначе верните False.
Если данный массив пуст, то верните значение True.
Примечание: Данный список гарантированно содержит уникальные элементы.
Примеры:
move_one_ball([3, 4, 5, 1, 2])==>True Explanation: 2 сдвига
move_one_ball([3, 5, 4, 1, 2])==>False | Напишите функцию move_one_ball(arr) для решения следующей задачи: У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N].Числа в массиве упорядочены случайным образом. Ваша задача состоит в том, чтобы определить, возможно ли отсортировать массив в порядке неубывания, выполнив следующую операцию над данным массивом:
Вам разрешается выполнять операцию сдвига вправо любое количество раз.
Одна операция сдвига вправо означает сдвиг всех элементов массива на одну позицию в правильном направлении. Последний элемент массива будет перемещен в начальную позицию в массиве, т.е. с 0-м индексом.
Если возможно получить отсортированный массив, выполнив описанную выше операцию, то верните True, иначе верните False.
Если данный массив пуст, то верните значение True.
Примечание: Данный список гарантированно содержит уникальные элементы. | def move_one_ball(arr):
"""
У нас есть массив 'arr' из N целых чисел arr[1], arr[2], ..., arr[N].Числа в массиве упорядочены случайным образом. Ваша задача состоит в том, чтобы определить, возможно ли отсортировать массив в порядке неубывания, выполнив следующую операцию над данным массивом:
Вам разрешается выполнять операцию сдвига вправо любое количество раз.
Одна операция сдвига вправо означает сдвиг всех элементов массива на одну позицию в правильном направлении. Последний элемент массива будет перемещен в начальную позицию в массиве, т.е. с 0-м индексом.
Если возможно получить отсортированный массив, выполнив описанную выше операцию, то верните True, иначе верните False.
Если данный массив пуст, то верните значение True.
Примечание: Данный список гарантированно содержит уникальные элементы.
"""
|
HumanEval/110 | Реализовывать функцию, которая принимает два списка чисел
и определяет, возможно ли выполнить обмен элементами между ними, чтобы сделать lst1 списком только четных чисел.
Количество обмениваемых элементов между lst1 и lst2 не ограничено.
Если возможно поменять местами элементы между lst1 и lst2, чтобы все элементы lst1 были четными, верните "YES".
В противном случае верните "NO".
Примеры:
exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
Предполагается, что списки не пусты. | def exchange(lst1, lst2):
"""
Реализовывать функцию, которая принимает два списка чисел
и определяет, возможно ли выполнить обмен элементами между ними, чтобы сделать lst1 списком только четных чисел.
Количество обмениваемых элементов между lst1 и lst2 не ограничено.
Если возможно поменять местами элементы между lst1 и lst2, чтобы все элементы lst1 были четными, верните "YES".
В противном случае верните "NO".
Примеры:
exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
Предполагается, что списки не пусты.
"""
| odd = 0
even = 0
for i in lst1:
if i%2 == 1:
odd += 1
for i in lst2:
if i%2 == 0:
even += 1
if even >= odd:
return "YES"
return "NO"
| def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4], [1, 2, 3, 4]) == "YES"
assert candidate([1, 2, 3, 4], [1, 5, 3, 4]) == "NO"
assert candidate([1, 2, 3, 4], [2, 1, 4, 3]) == "YES"
assert candidate([5, 7, 3], [2, 6, 4]) == "YES"
assert candidate([5, 7, 3], [2, 6, 3]) == "NO"
assert candidate([3, 2, 6, 1, 8, 9], [3, 5, 5, 1, 1, 1]) == "NO"
# Check some edge cases that are easy to work out by hand.
assert candidate([100, 200], [200, 200]) == "YES"
| exchange | exchange(lst1, lst2) | def exchange(lst1, lst2): | Напишите функцию exchange(lst1, lst2) для решения следующей задачи: Реализовывать функцию, которая принимает два списка чисел
и определяет, возможно ли выполнить обмен элементами между ними, чтобы сделать lst1 списком только четных чисел.
Количество обмениваемых элементов между lst1 и lst2 не ограничено.
Если возможно поменять местами элементы между lst1 и lst2, чтобы все элементы lst1 были четными, верните "YES".
В противном случае верните "NO".
Примеры:
exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
Предполагается, что списки не пусты. | Напишите функцию exchange(lst1, lst2) для решения следующей задачи: Реализовывать функцию, которая принимает два списка чисел
и определяет, возможно ли выполнить обмен элементами между ними, чтобы сделать lst1 списком только четных чисел.
Количество обмениваемых элементов между lst1 и lst2 не ограничено.
Если возможно поменять местами элементы между lst1 и lst2, чтобы все элементы lst1 были четными, верните "YES".
В противном случае верните "NO". | def exchange(lst1, lst2):
"""
Реализовывать функцию, которая принимает два списка чисел
и определяет, возможно ли выполнить обмен элементами между ними, чтобы сделать lst1 списком только четных чисел.
Количество обмениваемых элементов между lst1 и lst2 не ограничено.
Если возможно поменять местами элементы между lst1 и lst2, чтобы все элементы lst1 были четными, верните "YES".
В противном случае верните "NO".
"""
|
HumanEval/111 | Дана строка, представляющая собой разделенные пробелом строчные буквы, верните словарь букв с наибольшим количеством повторений и содержащий соответствующее количество.
Если несколько букв имеют одинаковое вхождение, верните их все.
Примеры:
histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
histogram('a b b a') == {'a': 2, 'b': 2}
histogram('a b c a b') == {'a': 2, 'b': 2}
histogram('b b b b a') == {'b': 4}
histogram('') == {} | def histogram(test):
"""
Дана строка, представляющая собой разделенные пробелом строчные буквы, верните словарь букв с наибольшим количеством повторений и содержащий соответствующее количество.
Если несколько букв имеют одинаковое вхождение, верните их все.
Примеры:
histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
histogram('a b b a') == {'a': 2, 'b': 2}
histogram('a b c a b') == {'a': 2, 'b': 2}
histogram('b b b b a') == {'b': 4}
histogram('') == {}
"""
| dict1={}
list1=test.split(" ")
t=0
for i in list1:
if(list1.count(i)>t) and i!='':
t=list1.count(i)
if t>0:
for i in list1:
if(list1.count(i)==t):
dict1[i]=t
return dict1
| def check(candidate):
# Check some simple cases
assert candidate('a b b a') == {'a':2,'b': 2}, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('a b c a b') == {'a': 2, 'b': 2}, "This prints if this assert fails 2 (good for debugging!)"
assert candidate('a b c d g') == {'a': 1, 'b': 1, 'c': 1, 'd': 1, 'g': 1}, "This prints if this assert fails 3 (good for debugging!)"
assert candidate('r t g') == {'r': 1,'t': 1,'g': 1}, "This prints if this assert fails 4 (good for debugging!)"
assert candidate('b b b b a') == {'b': 4}, "This prints if this assert fails 5 (good for debugging!)"
assert candidate('r t g') == {'r': 1,'t': 1,'g': 1}, "This prints if this assert fails 6 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate('') == {}, "This prints if this assert fails 7 (also good for debugging!)"
assert candidate('a') == {'a': 1}, "This prints if this assert fails 8 (also good for debugging!)"
| histogram | histogram(test) | def histogram(test): | Напишите функцию histogram(test) для решения следующей задачи: Дана строка, представляющая собой разделенные пробелом строчные буквы, верните словарь букв с наибольшим количеством повторений и содержащий соответствующее количество.
Если несколько букв имеют одинаковое вхождение, верните их все.
Примеры:
histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
histogram('a b b a') == {'a': 2, 'b': 2}
histogram('a b c a b') == {'a': 2, 'b': 2}
histogram('b b b b a') == {'b': 4}
histogram('') == {} | Напишите функцию histogram(test) для решения следующей задачи: Дана строка, представляющая собой разделенные пробелом строчные буквы, верните словарь букв с наибольшим количеством повторений и содержащий соответствующее количество.
Если несколько букв имеют одинаковое вхождение, верните их все. | def histogram(test):
"""
Дана строка, представляющая собой разделенные пробелом строчные буквы, верните словарь букв с наибольшим количеством повторений и содержащий соответствующее количество.
Если несколько букв имеют одинаковое вхождение, верните их все.
"""
|
HumanEval/112 | Задача: даны две строки s и c, вы должны удалить все символы в s, которые равны любому символу в c, затем проверить, является ли результирующая строка палиндромом.
Строка называется палиндромом, если она читается как в обратном, так и в прямом направлении.
Вы должны вернуть кортеж, содержащий строку результата и значение True/False Примеры:
For s = "abcde", c = "ae", the result should be (\'bcd\',False)
For s = "abcdef", c = "b" the result should be (\'acdef\',False)
For s = "abcdedcba", c = "ab", the result should be (\'cdedc\',True) | def reverse_delete(s,c):
"""
Задача: даны две строки s и c, вы должны удалить все символы в s, которые равны любому символу в c, затем проверить, является ли результирующая строка палиндромом.
Строка называется палиндромом, если она читается как в обратном, так и в прямом направлении.
Вы должны вернуть кортеж, содержащий строку результата и значение True/False Примеры:
For s = "abcde", c = "ae", the result should be (\'bcd\',False)
For s = "abcdef", c = "b" the result should be (\'acdef\',False)
For s = "abcdedcba", c = "ab", the result should be (\'cdedc\',True)
"""
| s = ''.join([char for char in s if char not in c])
return (s,s[::-1] == s)
| def check(candidate):
assert candidate("abcde","ae") == ('bcd',False)
assert candidate("abcdef", "b") == ('acdef',False)
assert candidate("abcdedcba","ab") == ('cdedc',True)
assert candidate("dwik","w") == ('dik',False)
assert candidate("a","a") == ('',True)
assert candidate("abcdedcba","") == ('abcdedcba',True)
assert candidate("abcdedcba","v") == ('abcdedcba',True)
assert candidate("vabba","v") == ('abba',True)
assert candidate("mamma", "mia") == ("", True)
| reverse_delete | reverse_delete(s,c) | def reverse_delete(s,c): | Напишите функцию reverse_delete(s,c) для решения следующей задачи: Задача: даны две строки s и c, вы должны удалить все символы в s, которые равны любому символу в c, затем проверить, является ли результирующая строка палиндромом.
Строка называется палиндромом, если она читается как в обратном, так и в прямом направлении.
Вы должны вернуть кортеж, содержащий строку результата и значение True/False Примеры:
For s = "abcde", c = "ae", the result should be (\'bcd\',False)
For s = "abcdef", c = "b" the result should be (\'acdef\',False)
For s = "abcdedcba", c = "ab", the result should be (\'cdedc\',True) | Напишите функцию reverse_delete(s,c) для решения следующей задачи: Задача: даны две строки s и c, вы должны удалить все символы в s, которые равны любому символу в c, затем проверить, является ли результирующая строка палиндромом.
Строка называется палиндромом, если она читается как в обратном, так и в прямом направлении.
Вы должны вернуть кортеж, содержащий строку результата и значение True/False Примеры:
For s = "abcde", c = "ae", the result should be (\'bcd\',False)
For s = "abcdef", c = "b" the result should be (\'acdef\',False)
For s = "abcdedcba", c = "ab", the result should be (\'cdedc\',True) | def reverse_delete(s,c):
"""
Задача: даны две строки s и c, вы должны удалить все символы в s, которые равны любому символу в c, затем проверить, является ли результирующая строка палиндромом.
Строка называется палиндромом, если она читается как в обратном, так и в прямом направлении.
Вы должны вернуть кортеж, содержащий строку результата и значение True/False Примеры:
For s = "abcde", c = "ae", the result should be (\'bcd\',False)
For s = "abcdef", c = "b" the result should be (\'acdef\',False)
For s = "abcdedcba", c = "ab", the result should be (\'cdedc\',True)
"""
|
HumanEval/113 | Дан список строк, где каждая строка состоит только из цифр, верните список.
Каждый элемент i выходных данных должен быть "числом нечетных элементов в строке i входных данных". где все i должны быть заменены количеством нечетных цифр в i-й строке входных данных.
>>> odd_count(['1234567'])
["the number of odd elements 4n the str4ng 4 of the 4nput."]
>>> odd_count([\'3\',"11111111"])
["the number of odd elements 1n the str1ng 1 of the 1nput.",
"the number of odd elements 8n the str8ng 8 of the 8nput."] | def odd_count(lst):
"""
Дан список строк, где каждая строка состоит только из цифр, верните список.
Каждый элемент i выходных данных должен быть "числом нечетных элементов в строке i входных данных". где все i должны быть заменены количеством нечетных цифр в i-й строке входных данных.
>>> odd_count(['1234567'])
["the number of odd elements 4n the str4ng 4 of the 4nput."]
>>> odd_count([\'3\',"11111111"])
["the number of odd elements 1n the str1ng 1 of the 1nput.",
"the number of odd elements 8n the str8ng 8 of the 8nput."]
"""
| res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res
| def check(candidate):
# Check some simple cases
assert candidate(['1234567']) == ["the number of odd elements 4n the str4ng 4 of the 4nput."], "Test 1"
assert candidate(['3',"11111111"]) == ["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."], "Test 2"
assert candidate(['271', '137', '314']) == [
'the number of odd elements 2n the str2ng 2 of the 2nput.',
'the number of odd elements 3n the str3ng 3 of the 3nput.',
'the number of odd elements 2n the str2ng 2 of the 2nput.'
]
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| odd_count | odd_count(lst) | def odd_count(lst): | Напишите функцию odd_count(lst) для решения следующей задачи: Дан список строк, где каждая строка состоит только из цифр, верните список.
Каждый элемент i выходных данных должен быть "числом нечетных элементов в строке i входных данных". где все i должны быть заменены количеством нечетных цифр в i-й строке входных данных.
>>> odd_count(['1234567'])
["the number of odd elements 4n the str4ng 4 of the 4nput."]
>>> odd_count([\'3\',"11111111"])
["the number of odd elements 1n the str1ng 1 of the 1nput.",
"the number of odd elements 8n the str8ng 8 of the 8nput."] | Напишите функцию odd_count(lst) для решения следующей задачи: Дан список строк, где каждая строка состоит только из цифр, верните список.
Каждый элемент i выходных данных должен быть "числом нечетных элементов в строке i входных данных". где все i должны быть заменены количеством нечетных цифр в i-й строке входных данных. | def odd_count(lst):
"""
Дан список строк, где каждая строка состоит только из цифр, верните список.
Каждый элемент i выходных данных должен быть "числом нечетных элементов в строке i входных данных". где все i должны быть заменены количеством нечетных цифр в i-й строке входных данных.
"""
|
HumanEval/114 | Дан массив целых чисел nums, найдите минимальную сумму любого непустого подмассива nums.
Примеры:
minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
minSubArraySum([-1, -2, -3]) == -6 | def minSubArraySum(nums):
"""
Дан массив целых чисел nums, найдите минимальную сумму любого непустого подмассива nums.
Примеры:
minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
minSubArraySum([-1, -2, -3]) == -6
"""
| max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum
| def check(candidate):
# Check some simple cases
assert candidate([2, 3, 4, 1, 2, 4]) == 1, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-1, -2, -3]) == -6
assert candidate([-1, -2, -3, 2, -10]) == -14
assert candidate([-9999999999999999]) == -9999999999999999
assert candidate([0, 10, 20, 1000000]) == 0
assert candidate([-1, -2, -3, 10, -5]) == -6
assert candidate([100, -1, -2, -3, 10, -5]) == -6
assert candidate([10, 11, 13, 8, 3, 4]) == 3
assert candidate([100, -33, 32, -1, 0, -2]) == -33
# Check some edge cases that are easy to work out by hand.
assert candidate([-10]) == -10, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([7]) == 7
assert candidate([1, -1]) == -1
| minSubArraySum | minSubArraySum(nums) | def minSubArraySum(nums): | Напишите функцию minSubArraySum(nums) для решения следующей задачи: Дан массив целых чисел nums, найдите минимальную сумму любого непустого подмассива nums.
Примеры:
minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
minSubArraySum([-1, -2, -3]) == -6 | Напишите функцию minSubArraySum(nums) для решения следующей задачи: Дан массив целых чисел nums, найдите минимальную сумму любого непустого подмассива nums. | def minSubArraySum(nums):
"""
Дан массив целых чисел nums, найдите минимальную сумму любого непустого подмассива nums.
"""
|
HumanEval/115 | Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой один колодец,
и каждая 1 в строке представляет собой одну единицу воды.
У каждого колодца есть ведро, которое можно использовать для извлечения воды из него,
и все ведра имеют одинаковую вместимость.
Ваша задача состоит в том, чтобы использовать ведра для опорожнения колодцев.
Выведите количество раз, которое вам нужно опустить ведра.
Примеры:
1:
Input:
grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
bucket_capacity : 1
Output: 6
2:
Input:
grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
bucket_capacity : 2
Output: 5
3:
Input:
grid : [[0,0,0], [0,0,0]]
bucket_capacity : 5
Output: 0
Ограничения:
* все колодцы имеют одинковую длину * 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10 | def max_fill(grid, capacity):
import math
"""
Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой один колодец,
и каждая 1 в строке представляет собой одну единицу воды.
У каждого колодца есть ведро, которое можно использовать для извлечения воды из него,
и все ведра имеют одинаковую вместимость.
Ваша задача состоит в том, чтобы использовать ведра для опорожнения колодцев.
Выведите количество раз, которое вам нужно опустить ведра.
Примеры:
1:
Input:
grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
bucket_capacity : 1
Output: 6
2:
Input:
grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
bucket_capacity : 2
Output: 5
3:
Input:
grid : [[0,0,0], [0,0,0]]
bucket_capacity : 5
Output: 0
Ограничения:
* все колодцы имеют одинковую длину * 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
"""
| return sum([math.ceil(sum(arr)/capacity) for arr in grid])
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([[0,0,1,0], [0,1,0,0], [1,1,1,1]], 1) == 6, "Error"
assert candidate([[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]], 2) == 5, "Error"
assert candidate([[0,0,0], [0,0,0]], 5) == 0, "Error"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([[1,1,1,1], [1,1,1,1]], 2) == 4, "Error"
assert candidate([[1,1,1,1], [1,1,1,1]], 9) == 2, "Error"
| max_fill | max_fill(grid, capacity):
import math | def max_fill(grid, capacity):
import math | Напишите функцию max_fill(grid, capacity):
import math для решения следующей задачи: Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой один колодец,
и каждая 1 в строке представляет собой одну единицу воды.
У каждого колодца есть ведро, которое можно использовать для извлечения воды из него,
и все ведра имеют одинаковую вместимость.
Ваша задача состоит в том, чтобы использовать ведра для опорожнения колодцев.
Выведите количество раз, которое вам нужно опустить ведра.
Примеры:
1:
Input:
grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
bucket_capacity : 1
Output: 6
2:
Input:
grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
bucket_capacity : 2
Output: 5
3:
Input:
grid : [[0,0,0], [0,0,0]]
bucket_capacity : 5
Output: 0
Ограничения:
* все колодцы имеют одинковую длину * 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10 | Напишите функцию max_fill(grid, capacity):
import math для решения следующей задачи: Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой один колодец,
и каждая 1 в строке представляет собой одну единицу воды.
У каждого колодца есть ведро, которое можно использовать для извлечения воды из него,
и все ведра имеют одинаковую вместимость.
Ваша задача состоит в том, чтобы использовать ведра для опорожнения колодцев.
Выведите количество раз, которое вам нужно опустить ведра.
| def max_fill(grid, capacity):
import math
"""
Вам дана прямоугольная сетка колодцев. Каждая строка представляет собой один колодец,
и каждая 1 в строке представляет собой одну единицу воды.
У каждого колодца есть ведро, которое можно использовать для извлечения воды из него,
и все ведра имеют одинаковую вместимость.
Ваша задача состоит в том, чтобы использовать ведра для опорожнения колодцев.
Выведите количество раз, которое вам нужно опустить ведра.
"""
|
HumanEval/116 | Вы должны отсортировать массив неотрицательных целых чисел в соответствии с количеством единиц в их двоичном представлении в порядке возрастания.
Для чисел с одинаковым количеством единиц выполните сортировку на основе десятичного значения.
Примеры:
>>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
>>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
>>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4] | def sort_array(arr):
"""
Вы должны отсортировать массив неотрицательных целых чисел в соответствии с количеством единиц в их двоичном представлении в порядке возрастания.
Для чисел с одинаковым количеством единиц выполните сортировку на основе десятичного значения.
Примеры:
>>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
>>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
>>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
"""
| return sorted(sorted(arr), key=lambda x: bin(x)[2:].count('1'))
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,5,2,3,4]) == [1, 2, 4, 3, 5]
assert candidate([-2,-3,-4,-5,-6]) == [-4, -2, -6, -5, -3]
assert candidate([1,0,2,3,4]) == [0, 1, 2, 4, 3]
assert candidate([]) == []
assert candidate([2,5,77,4,5,3,5,7,2,3,4]) == [2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77]
assert candidate([3,6,44,12,32,5]) == [32, 3, 5, 6, 12, 44]
assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]
assert candidate([2,4,8,16,32]) == [2, 4, 8, 16, 32]
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| sort_array | sort_array(arr) | def sort_array(arr): | Напишите функцию sort_array(arr) для решения следующей задачи: Вы должны отсортировать массив неотрицательных целых чисел в соответствии с количеством единиц в их двоичном представлении в порядке возрастания.
Для чисел с одинаковым количеством единиц выполните сортировку на основе десятичного значения.
Примеры:
>>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
>>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
>>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4] | Напишите функцию sort_array(arr) для решения следующей задачи: Вы должны отсортировать массив неотрицательных целых чисел в соответствии с количеством единиц в их двоичном представлении в порядке возрастания.
Для чисел с одинаковым количеством единиц выполните сортировку на основе десятичного значения.
Примеры: | def sort_array(arr):
"""
Вы должны отсортировать массив неотрицательных целых чисел в соответствии с количеством единиц в их двоичном представлении в порядке возрастания.
Для чисел с одинаковым количеством единиц выполните сортировку на основе десятичного значения.
Примеры:
"""
|
HumanEval/117 | Даны строка s и натуральное число n, реализовать функцию, которая возвращает список всех слов из строки s, содержащих ровно n согласных, в порядке появления этих слов в строке s.
Если строка s пуста, то функция должна вернуть пустой список.
Примечание: входная строка содержит только буквы и пробелы.
Примеры:
select_words("Mary had a little lamb", 4) ==> ["little"]
select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
select_words("simple white space", 2) ==> []
select_words("Hello world", 4) ==> ["world"]
select_words("Uncle sam", 3) ==> ["Uncle"] | def select_words(s, n):
"""
Даны строка s и натуральное число n, реализовать функцию, которая возвращает список всех слов из строки s, содержащих ровно n согласных, в порядке появления этих слов в строке s.
Если строка s пуста, то функция должна вернуть пустой список.
Примечание: входная строка содержит только буквы и пробелы.
Примеры:
select_words("Mary had a little lamb", 4) ==> ["little"]
select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
select_words("simple white space", 2) ==> []
select_words("Hello world", 4) ==> ["world"]
select_words("Uncle sam", 3) ==> ["Uncle"]
"""
| result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a","e","i","o","u"]:
n_consonants += 1
if n_consonants == n:
result.append(word)
return result
| def check(candidate):
# Check some simple cases
assert candidate("Mary had a little lamb", 4) == ["little"], "First test error: " + str(candidate("Mary had a little lamb", 4))
assert candidate("Mary had a little lamb", 3) == ["Mary", "lamb"], "Second test error: " + str(candidate("Mary had a little lamb", 3))
assert candidate("simple white space", 2) == [], "Third test error: " + str(candidate("simple white space", 2))
assert candidate("Hello world", 4) == ["world"], "Fourth test error: " + str(candidate("Hello world", 4))
assert candidate("Uncle sam", 3) == ["Uncle"], "Fifth test error: " + str(candidate("Uncle sam", 3))
# Check some edge cases that are easy to work out by hand.
assert candidate("", 4) == [], "1st edge test error: " + str(candidate("", 4))
assert candidate("a b c d e f", 1) == ["b", "c", "d", "f"], "2nd edge test error: " + str(candidate("a b c d e f", 1))
| select_words | select_words(s, n) | def select_words(s, n): | Напишите функцию select_words(s, n) для решения следующей задачи: Даны строка s и натуральное число n, реализовать функцию, которая возвращает список всех слов из строки s, содержащих ровно n согласных, в порядке появления этих слов в строке s.
Если строка s пуста, то функция должна вернуть пустой список.
Примечание: входная строка содержит только буквы и пробелы.
Примеры:
select_words("Mary had a little lamb", 4) ==> ["little"]
select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
select_words("simple white space", 2) ==> []
select_words("Hello world", 4) ==> ["world"]
select_words("Uncle sam", 3) ==> ["Uncle"] | Напишите функцию select_words(s, n) для решения следующей задачи: Даны строка s и натуральное число n, реализовать функцию, которая возвращает список всех слов из строки s, содержащих ровно n согласных, в порядке появления этих слов в строке s.
Если строка s пуста, то функция должна вернуть пустой список.
Примечание: входная строка содержит только буквы и пробелы. | def select_words(s, n):
"""
Даны строка s и натуральное число n, реализовать функцию, которая возвращает список всех слов из строки s, содержащих ровно n согласных, в порядке появления этих слов в строке s.
Если строка s пуста, то функция должна вернуть пустой список.
Примечание: входная строка содержит только буквы и пробелы.
"""
|
HumanEval/118 | Вам дано слово. Ваша задача - найти ближайшую гласную, которая стоит между двумя согласными с правой стороны слова (с учетом регистра).
Гласные в начале и в конце не учитываются. Верните пустую строку, если вы не нашли ни одной гласной, удовлетворяющей вышеуказанному условию.
Вы можете предположить, что данная строка содержит только английские буквы.
Примеры:
get_closest_vowel("yogurt") ==> "u"
get_closest_vowel("FULL") ==> "U"
get_closest_vowel("quick") ==> ""
get_closest_vowel("ab") ==> "" | def get_closest_vowel(word):
"""
Вам дано слово. Ваша задача - найти ближайшую гласную, которая стоит между двумя согласными с правой стороны слова (с учетом регистра).
Гласные в начале и в конце не учитываются. Верните пустую строку, если вы не нашли ни одной гласной, удовлетворяющей вышеуказанному условию.
Вы можете предположить, что данная строка содержит только английские буквы.
Примеры:
get_closest_vowel("yogurt") ==> "u"
get_closest_vowel("FULL") ==> "U"
get_closest_vowel("quick") ==> ""
get_closest_vowel("ab") ==> ""
"""
| if len(word) < 3:
return ""
vowels = {"a", "e", "i", "o", "u", "A", "E", 'O', 'U', 'I'}
for i in range(len(word)-2, 0, -1):
if word[i] in vowels:
if (word[i+1] not in vowels) and (word[i-1] not in vowels):
return word[i]
return ""
| def check(candidate):
# Check some simple cases
assert candidate("yogurt") == "u"
assert candidate("full") == "u"
assert candidate("easy") == ""
assert candidate("eAsy") == ""
assert candidate("ali") == ""
assert candidate("bad") == "a"
assert candidate("most") == "o"
assert candidate("ab") == ""
assert candidate("ba") == ""
assert candidate("quick") == ""
assert candidate("anime") == "i"
assert candidate("Asia") == ""
assert candidate("Above") == "o"
# Check some edge cases that are easy to work out by hand.
assert True
| get_closest_vowel | get_closest_vowel(word) | def get_closest_vowel(word): | Напишите функцию get_closest_vowel(word) для решения следующей задачи: Вам дано слово. Ваша задача - найти ближайшую гласную, которая стоит между двумя согласными с правой стороны слова (с учетом регистра).
Гласные в начале и в конце не учитываются. Верните пустую строку, если вы не нашли ни одной гласной, удовлетворяющей вышеуказанному условию.
Вы можете предположить, что данная строка содержит только английские буквы.
Примеры:
get_closest_vowel("yogurt") ==> "u"
get_closest_vowel("FULL") ==> "U"
get_closest_vowel("quick") ==> ""
get_closest_vowel("ab") ==> "" | Напишите функцию get_closest_vowel(word) для решения следующей задачи: Вам дано слово. Ваша задача - найти ближайшую гласную, которая стоит между двумя согласными с правой стороны слова (с учетом регистра).
Гласные в начале и в конце не учитываются. Верните пустую строку, если вы не нашли ни одной гласной, удовлетворяющей вышеуказанному условию.
Вы можете предположить, что данная строка содержит только английские буквы. | def get_closest_vowel(word):
"""
Вам дано слово. Ваша задача - найти ближайшую гласную, которая стоит между двумя согласными с правой стороны слова (с учетом регистра).
Гласные в начале и в конце не учитываются. Верните пустую строку, если вы не нашли ни одной гласной, удовлетворяющей вышеуказанному условию.
Вы можете предположить, что данная строка содержит только английские буквы.
"""
|
HumanEval/119 | Дан список из двух строк, обе строки состоят только из открытых круглых скобок '(' или закрытых круглых скобок ')'.
Ваша задача состоит в том, чтобы проверить, возможно ли объединить две строки в некотором порядке, чтобы результирующая строка была хорошей.
Строка S считается хорошей тогда и только тогда, когда все круглые скобки в S сбалансированы.
Примеры:
: Строка '(())()' хорошая, а строка '())' - нет.
Верните 'Yes', если можно составить хорошую строку, 'No' иначе.
Примеры:
match_parens(['()(', ')']) == 'Yes'
match_parens([')', ')']) == 'No' | def match_parens(lst):
"""
Дан список из двух строк, обе строки состоят только из открытых круглых скобок '(' или закрытых круглых скобок ')'.
Ваша задача состоит в том, чтобы проверить, возможно ли объединить две строки в некотором порядке, чтобы результирующая строка была хорошей.
Строка S считается хорошей тогда и только тогда, когда все круглые скобки в S сбалансированы.
Примеры:
: Строка '(())()' хорошая, а строка '())' - нет.
Верните 'Yes', если можно составить хорошую строку, 'No' иначе.
Примеры:
match_parens(['()(', ')']) == 'Yes'
match_parens([')', ')']) == 'No'
"""
| def check(s):
val = 0
for i in s:
if i == '(':
val = val + 1
else:
val = val - 1
if val < 0:
return False
return True if val == 0 else False
S1 = lst[0] + lst[1]
S2 = lst[1] + lst[0]
return 'Yes' if check(S1) or check(S2) else 'No'
| def check(candidate):
# Check some simple cases
assert candidate(['()(', ')']) == 'Yes'
assert candidate([')', ')']) == 'No'
assert candidate(['(()(())', '())())']) == 'No'
assert candidate([')())', '(()()(']) == 'Yes'
assert candidate(['(())))', '(()())((']) == 'Yes'
assert candidate(['()', '())']) == 'No'
assert candidate(['(()(', '()))()']) == 'Yes'
assert candidate(['((((', '((())']) == 'No'
assert candidate([')(()', '(()(']) == 'No'
assert candidate([')(', ')(']) == 'No'
# Check some edge cases that are easy to work out by hand.
assert candidate(['(', ')']) == 'Yes'
assert candidate([')', '(']) == 'Yes'
| match_parens | match_parens(lst) | def match_parens(lst): | Напишите функцию match_parens(lst) для решения следующей задачи: Дан список из двух строк, обе строки состоят только из открытых круглых скобок '(' или закрытых круглых скобок ')'.
Ваша задача состоит в том, чтобы проверить, возможно ли объединить две строки в некотором порядке, чтобы результирующая строка была хорошей.
Строка S считается хорошей тогда и только тогда, когда все круглые скобки в S сбалансированы.
Примеры:
: Строка '(())()' хорошая, а строка '())' - нет.
Верните 'Yes', если можно составить хорошую строку, 'No' иначе.
Примеры:
match_parens(['()(', ')']) == 'Yes'
match_parens([')', ')']) == 'No' | Напишите функцию match_parens(lst) для решения следующей задачи: Дан список из двух строк, обе строки состоят только из открытых круглых скобок '(' или закрытых круглых скобок ')'.
Ваша задача состоит в том, чтобы проверить, возможно ли объединить две строки в некотором порядке, чтобы результирующая строка была хорошей.
Строка S считается хорошей тогда и только тогда, когда все круглые скобки в S сбалансированы. | def match_parens(lst):
"""
Дан список из двух строк, обе строки состоят только из открытых круглых скобок '(' или закрытых круглых скобок ')'.
Ваша задача состоит в том, чтобы проверить, возможно ли объединить две строки в некотором порядке, чтобы результирующая строка была хорошей.
Строка S считается хорошей тогда и только тогда, когда все круглые скобки в S сбалансированы.
"""
|
HumanEval/120 | Дан массив arr целых чисел и положительное целое число k, верните отсортированный список длины k с максимальными k числами из arr.
Примеры:
1:
Input: arr = [-3, -4, 5], k = 3
Output: [-4, -3, 5]
2:
Input: arr = [4, -4, 4], k = 2
Output: [4, 4]
3:
Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
Output: [2]
Примечание:
1. Длина массива в диапазоне [1, 1000].
2. Элементы массива в диапазоне [-1000, 1000].
3. 0 <= k <= len(arr) | def maximum(arr, k):
"""
Дан массив arr целых чисел и положительное целое число k, верните отсортированный список длины k с максимальными k числами из arr.
Примеры:
1:
Input: arr = [-3, -4, 5], k = 3
Output: [-4, -3, 5]
2:
Input: arr = [4, -4, 4], k = 2
Output: [4, 4]
3:
Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
Output: [2]
Примечание:
1. Длина массива в диапазоне [1, 1000].
2. Элементы массива в диапазоне [-1000, 1000].
3. 0 <= k <= len(arr)
"""
| if k == 0:
return []
arr.sort()
ans = arr[-k:]
return ans
| def check(candidate):
# Check some simple cases
assert candidate([-3, -4, 5], 3) == [-4, -3, 5]
assert candidate([4, -4, 4], 2) == [4, 4]
assert candidate([-3, 2, 1, 2, -1, -2, 1], 1) == [2]
assert candidate([123, -123, 20, 0 , 1, 2, -3], 3) == [2, 20, 123]
assert candidate([-123, 20, 0 , 1, 2, -3], 4) == [0, 1, 2, 20]
assert candidate([5, 15, 0, 3, -13, -8, 0], 7) == [-13, -8, 0, 0, 3, 5, 15]
assert candidate([-1, 0, 2, 5, 3, -10], 2) == [3, 5]
assert candidate([1, 0, 5, -7], 1) == [5]
assert candidate([4, -4], 2) == [-4, 4]
assert candidate([-10, 10], 2) == [-10, 10]
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3, -23, 243, -400, 0], 0) == []
| maximum | maximum(arr, k) | def maximum(arr, k): | Напишите функцию maximum(arr, k) для решения следующей задачи: Дан массив arr целых чисел и положительное целое число k, верните отсортированный список длины k с максимальными k числами из arr.
Примеры:
1:
Input: arr = [-3, -4, 5], k = 3
Output: [-4, -3, 5]
2:
Input: arr = [4, -4, 4], k = 2
Output: [4, 4]
3:
Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
Output: [2]
Примечание:
1. Длина массива в диапазоне [1, 1000].
2. Элементы массива в диапазоне [-1000, 1000].
3. 0 <= k <= len(arr) | Напишите функцию maximum(arr, k) для решения следующей задачи: Дан массив arr целых чисел и положительное целое число k, верните отсортированный список длины k с максимальными k числами из arr. | def maximum(arr, k):
"""
Дан массив arr целых чисел и положительное целое число k, верните отсортированный список длины k с максимальными k числами из arr.
"""
|
HumanEval/121 | Дан непустой список целых чисел, верните сумму всех нечетных элементов, которые находятся в четных позициях.
Примеры:
solution([5, 8, 7, 1]) ==> 12
solution([3, 3, 3, 3, 3]) ==> 9
solution([30, 13, 24, 321]) ==>0 | def solution(lst):
"""
Дан непустой список целых чисел, верните сумму всех нечетных элементов, которые находятся в четных позициях.
Примеры:
solution([5, 8, 7, 1]) ==> 12
solution([3, 3, 3, 3, 3]) ==> 9
solution([30, 13, 24, 321]) ==>0
"""
| return sum([x for idx, x in enumerate(lst) if idx%2==0 and x%2==1])
| def check(candidate):
# Check some simple cases
assert candidate([5, 8, 7, 1]) == 12
assert candidate([3, 3, 3, 3, 3]) == 9
assert candidate([30, 13, 24, 321]) == 0
assert candidate([5, 9]) == 5
assert candidate([2, 4, 8]) == 0
assert candidate([30, 13, 23, 32]) == 23
assert candidate([3, 13, 2, 9]) == 3
# Check some edge cases that are easy to work out by hand.
| solution | solution(lst) | def solution(lst): | Напишите функцию solution(lst) для решения следующей задачи: Дан непустой список целых чисел, верните сумму всех нечетных элементов, которые находятся в четных позициях.
Примеры:
solution([5, 8, 7, 1]) ==> 12
solution([3, 3, 3, 3, 3]) ==> 9
solution([30, 13, 24, 321]) ==>0 | Напишите функцию solution(lst) для решения следующей задачи: Дан непустой список целых чисел, верните сумму всех нечетных элементов, которые находятся в четных позициях. | def solution(lst):
"""
Дан непустой список целых чисел, верните сумму всех нечетных элементов, которые находятся в четных позициях.
"""
|
HumanEval/122 | Дан непустой массив целых чисел arr и целое число k, верните сумму элементов, содержащих не более двух цифр, из первых k элементов arr.
Примеры:
Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
Output: 24 # sum of 21 + 3
Ограничения:
1. 1 <= len(arr) <= 100
2. 1 <= k <= len(arr) | def add_elements(arr, k):
"""
Дан непустой массив целых чисел arr и целое число k, верните сумму элементов, содержащих не более двух цифр, из первых k элементов arr.
Примеры:
Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
Output: 24 # sum of 21 + 3
Ограничения:
1. 1 <= len(arr) <= 100
2. 1 <= k <= len(arr)
"""
| return sum(elem for elem in arr[:k] if len(str(elem)) <= 2)
| def check(candidate):
# Check some simple cases
assert candidate([1,-2,-3,41,57,76,87,88,99], 3) == -4
assert candidate([111,121,3,4000,5,6], 2) == 0
assert candidate([11,21,3,90,5,6,7,8,9], 4) == 125
assert candidate([111,21,3,4000,5,6,7,8,9], 4) == 24, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1], 1) == 1, "This prints if this assert fails 2 (also good for debugging!)"
| add_elements | add_elements(arr, k) | def add_elements(arr, k): | Напишите функцию add_elements(arr, k) для решения следующей задачи: Дан непустой массив целых чисел arr и целое число k, верните сумму элементов, содержащих не более двух цифр, из первых k элементов arr.
Примеры:
Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
Output: 24 # sum of 21 + 3
Ограничения:
1. 1 <= len(arr) <= 100
2. 1 <= k <= len(arr) | Напишите функцию add_elements(arr, k) для решения следующей задачи: Дан непустой массив целых чисел arr и целое число k, верните сумму элементов, содержащих не более двух цифр, из первых k элементов arr. | def add_elements(arr, k):
"""
Дан непустой массив целых чисел arr и целое число k, верните сумму элементов, содержащих не более двух цифр, из первых k элементов arr.
"""
|
HumanEval/123 | Учитывая положительное целое число n, верните отсортированный список, содержащий нечетные числа в последовательности Коллатца.
Гипотеза Коллатца - это гипотеза в математике, которая касается последовательности, определенной следующим образом: начинайте с любого положительного целого числа n. Затем каждый член получается из предыдущего члена следующим образом: если предыдущий член четный, то следующий член равен половине предыдущего члена. Если предыдущий член нечетный, то следующий член в 3 раза больше предыдущего плюс 1. Предположение состоит в том, что независимо от того, какое значение имеет n, последовательность всегда будет достигать 1.
Примечание:
1. Collatz(1) равен [1].
2. Возвращаемый список отсортирован в порядке возрастания.
Примеры:
get_odd_collatz(5) returns [1, 5] # Последовательность для 5 равна [5, 16, 8, 4, 2, 1], нечетные только 1 и 5. | def get_odd_collatz(n):
"""
Учитывая положительное целое число n, верните отсортированный список, содержащий нечетные числа в последовательности Коллатца.
Гипотеза Коллатца - это гипотеза в математике, которая касается последовательности, определенной следующим образом: начинайте с любого положительного целого числа n. Затем каждый член получается из предыдущего члена следующим образом: если предыдущий член четный, то следующий член равен половине предыдущего члена. Если предыдущий член нечетный, то следующий член в 3 раза больше предыдущего плюс 1. Предположение состоит в том, что независимо от того, какое значение имеет n, последовательность всегда будет достигать 1.
Примечание:
1. Collatz(1) равен [1].
2. Возвращаемый список отсортирован в порядке возрастания.
Примеры:
get_odd_collatz(5) returns [1, 5] # Последовательность для 5 равна [5, 16, 8, 4, 2, 1], нечетные только 1 и 5.
"""
| if n%2==0:
odd_collatz = []
else:
odd_collatz = [n]
while n > 1:
if n % 2 == 0:
n = n/2
else:
n = n*3 + 1
if n%2 == 1:
odd_collatz.append(int(n))
return sorted(odd_collatz)
| def check(candidate):
# Check some simple cases
assert candidate(14) == [1, 5, 7, 11, 13, 17]
assert candidate(5) == [1, 5]
assert candidate(12) == [1, 3, 5], "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == [1], "This prints if this assert fails 2 (also good for debugging!)"
| get_odd_collatz | get_odd_collatz(n) | def get_odd_collatz(n): | Напишите функцию get_odd_collatz(n) для решения следующей задачи: Учитывая положительное целое число n, верните отсортированный список, содержащий нечетные числа в последовательности Коллатца.
Гипотеза Коллатца - это гипотеза в математике, которая касается последовательности, определенной следующим образом: начинайте с любого положительного целого числа n. Затем каждый член получается из предыдущего члена следующим образом: если предыдущий член четный, то следующий член равен половине предыдущего члена. Если предыдущий член нечетный, то следующий член в 3 раза больше предыдущего плюс 1. Предположение состоит в том, что независимо от того, какое значение имеет n, последовательность всегда будет достигать 1.
Примечание:
1. Collatz(1) равен [1].
2. Возвращаемый список отсортирован в порядке возрастания.
Примеры:
get_odd_collatz(5) returns [1, 5] # Последовательность для 5 равна [5, 16, 8, 4, 2, 1], нечетные только 1 и 5. | Напишите функцию get_odd_collatz(n) для решения следующей задачи: Учитывая положительное целое число n, верните отсортированный список, содержащий нечетные числа в последовательности Коллатца.
Гипотеза Коллатца - это гипотеза в математике, которая касается последовательности, определенной следующим образом: начинайте с любого положительного целого числа n. Затем каждый член получается из предыдущего члена следующим образом: если предыдущий член четный, то следующий член равен половине предыдущего члена. Если предыдущий член нечетный, то следующий член в 3 раза больше предыдущего плюс 1. Предположение состоит в том, что независимо от того, какое значение имеет n, последовательность всегда будет достигать 1.
Примечание:
1. Collatz(1) равен [1].
2. Возвращаемый список отсортирован в порядке возрастания. | def get_odd_collatz(n):
"""
Учитывая положительное целое число n, верните отсортированный список, содержащий нечетные числа в последовательности Коллатца.
Гипотеза Коллатца - это гипотеза в математике, которая касается последовательности, определенной следующим образом: начинайте с любого положительного целого числа n. Затем каждый член получается из предыдущего члена следующим образом: если предыдущий член четный, то следующий член равен половине предыдущего члена. Если предыдущий член нечетный, то следующий член в 3 раза больше предыдущего плюс 1. Предположение состоит в том, что независимо от того, какое значение имеет n, последовательность всегда будет достигать 1.
Примечание:
1. Collatz(1) равен [1].
2. Возвращаемый список отсортирован в порядке возрастания.
"""
|
HumanEval/124 | Вы должны написать функцию, которая проверяет заданную строку даты и возвращает True, если дата действительна, в противном случае False.
Дата действительна, если соблюдены все следующие правила:
1. Строка даты не является пустой.
2. Количество дней должно быть не менее 1 и не более 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней должно быть не менее 1 или не более 30 дней для месяцев 4,6,9,11. И количество дней должно быть не менее 1 или не более 29 в течение месяца 2.
3. Количество месяцев не должно быть меньше 1 или больше 12.
4. Дата должна быть в формате: мм-дд-гггг
Примеры:
valid_date('03-11-2000') => True
valid_date('15-01-2012') => False
valid_date('04-0-2040') => False
valid_date('06-04-2020') => True
valid_date('06/04/2020') => False | def valid_date(date):
"""
Вы должны написать функцию, которая проверяет заданную строку даты и возвращает True, если дата действительна, в противном случае False.
Дата действительна, если соблюдены все следующие правила:
1. Строка даты не является пустой.
2. Количество дней должно быть не менее 1 и не более 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней должно быть не менее 1 или не более 30 дней для месяцев 4,6,9,11. И количество дней должно быть не менее 1 или не более 29 в течение месяца 2.
3. Количество месяцев не должно быть меньше 1 или больше 12.
4. Дата должна быть в формате: мм-дд-гггг
Примеры:
valid_date('03-11-2000') => True
valid_date('15-01-2012') => False
valid_date('04-0-2040') => False
valid_date('06-04-2020') => True
valid_date('06/04/2020') => False
"""
| try:
date = date.strip()
month, day, year = date.split('-')
month, day, year = int(month), int(day), int(year)
if month < 1 or month > 12:
return False
if month in [1,3,5,7,8,10,12] and day < 1 or day > 31:
return False
if month in [4,6,9,11] and day < 1 or day > 30:
return False
if month == 2 and day < 1 or day > 29:
return False
except:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate('03-11-2000') == True
assert candidate('15-01-2012') == False
assert candidate('04-0-2040') == False
assert candidate('06-04-2020') == True
assert candidate('01-01-2007') == True
assert candidate('03-32-2011') == False
assert candidate('') == False
assert candidate('04-31-3000') == False
assert candidate('06-06-2005') == True
assert candidate('21-31-2000') == False
assert candidate('04-12-2003') == True
assert candidate('04122003') == False
assert candidate('20030412') == False
assert candidate('2003-04') == False
assert candidate('2003-04-12') == False
assert candidate('04-2003') == False
| valid_date | valid_date(date) | def valid_date(date): | Напишите функцию valid_date(date) для решения следующей задачи: Вы должны написать функцию, которая проверяет заданную строку даты и возвращает True, если дата действительна, в противном случае False.
Дата действительна, если соблюдены все следующие правила:
1. Строка даты не является пустой.
2. Количество дней должно быть не менее 1 и не более 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней должно быть не менее 1 или не более 30 дней для месяцев 4,6,9,11. И количество дней должно быть не менее 1 или не более 29 в течение месяца 2.
3. Количество месяцев не должно быть меньше 1 или больше 12.
4. Дата должна быть в формате: мм-дд-гггг
Примеры:
valid_date('03-11-2000') => True
valid_date('15-01-2012') => False
valid_date('04-0-2040') => False
valid_date('06-04-2020') => True
valid_date('06/04/2020') => False | Напишите функцию valid_date(date) для решения следующей задачи: Вы должны написать функцию, которая проверяет заданную строку даты и возвращает True, если дата действительна, в противном случае False.
Дата действительна, если соблюдены все следующие правила:
1. Строка даты не является пустой.
2. Количество дней должно быть не менее 1 и не более 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней должно быть не менее 1 или не более 30 дней для месяцев 4,6,9,11. И количество дней должно быть не менее 1 или не более 29 в течение месяца 2.
3. Количество месяцев не должно быть меньше 1 или больше 12.
4. Дата должна быть в формате: мм-дд-гггг | def valid_date(date):
"""
Вы должны написать функцию, которая проверяет заданную строку даты и возвращает True, если дата действительна, в противном случае False.
Дата действительна, если соблюдены все следующие правила:
1. Строка даты не является пустой.
2. Количество дней должно быть не менее 1 и не более 31 дня для месяцев 1,3,5,7,8,10,12. И количество дней должно быть не менее 1 или не более 30 дней для месяцев 4,6,9,11. И количество дней должно быть не менее 1 или не более 29 в течение месяца 2.
3. Количество месяцев не должно быть меньше 1 или больше 12.
4. Дата должна быть в формате: мм-дд-гггг
"""
|
HumanEval/125 | Дана строка слов, верните список слов, разделенных пробелами, если в тексте нет пробелов, вы должны разделить их запятыми ',' если запятых нет, вы должны вернуть количество строчных букв в нечетном порядке в алфавите, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Примеры:
split_words("Hello world!") ➞ ["Hello", "world!"]
split_words("Hello,world!") ➞ ["Hello", "world!"]
split_words("abcdef") == 3 | def split_words(txt):
"""
Дана строка слов, верните список слов, разделенных пробелами, если в тексте нет пробелов, вы должны разделить их запятыми ',' если запятых нет, вы должны вернуть количество строчных букв в нечетном порядке в алфавите, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Примеры:
split_words("Hello world!") ➞ ["Hello", "world!"]
split_words("Hello,world!") ➞ ["Hello", "world!"]
split_words("abcdef") == 3
"""
| if " " in txt:
return txt.split()
elif "," in txt:
return txt.replace(',',' ').split()
else:
return len([i for i in txt if i.islower() and ord(i)%2 == 0])
| def check(candidate):
assert candidate("Hello world!") == ["Hello","world!"]
assert candidate("Hello,world!") == ["Hello","world!"]
assert candidate("Hello world,!") == ["Hello","world,!"]
assert candidate("Hello,Hello,world !") == ["Hello,Hello,world","!"]
assert candidate("abcdef") == 3
assert candidate("aaabb") == 2
assert candidate("aaaBb") == 1
assert candidate("") == 0
| split_words | split_words(txt) | def split_words(txt): | Напишите функцию split_words(txt) для решения следующей задачи: Дана строка слов, верните список слов, разделенных пробелами, если в тексте нет пробелов, вы должны разделить их запятыми ',' если запятых нет, вы должны вернуть количество строчных букв в нечетном порядке в алфавите, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
Примеры:
split_words("Hello world!") ➞ ["Hello", "world!"]
split_words("Hello,world!") ➞ ["Hello", "world!"]
split_words("abcdef") == 3 | Напишите функцию split_words(txt) для решения следующей задачи: Дана строка слов, верните список слов, разделенных пробелами, если в тексте нет пробелов, вы должны разделить их запятыми ',' если запятых нет, вы должны вернуть количество строчных букв в нечетном порядке в алфавите, ord('a') = 0, ord('b') = 1, ... ord('z') = 25 | def split_words(txt):
"""
Дана строка слов, верните список слов, разделенных пробелами, если в тексте нет пробелов, вы должны разделить их запятыми ',' если запятых нет, вы должны вернуть количество строчных букв в нечетном порядке в алфавите, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
"""
|
HumanEval/126 | Получив список чисел, проверьте, отсортированы ли они в порядке возрастания или нет. Если список содержит более 1 дубликата одного и того же числа, верните значение False. Отрицательных чисел нет, есть только целые числа.
Примеры:
is_sorted([5]) ➞ True
is_sorted([1, 2, 3, 4, 5]) ➞ True
is_sorted([1, 3, 2, 4, 5]) ➞ False
is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
is_sorted([1, 2, 2, 2, 3, 4]) ➞ False | def is_sorted(lst):
"""
Получив список чисел, проверьте, отсортированы ли они в порядке возрастания или нет. Если список содержит более 1 дубликата одного и того же числа, верните значение False. Отрицательных чисел нет, есть только целые числа.
Примеры:
is_sorted([5]) ➞ True
is_sorted([1, 2, 3, 4, 5]) ➞ True
is_sorted([1, 3, 2, 4, 5]) ➞ False
is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
"""
| count_digit = dict([(i, 0) for i in lst])
for i in lst:
count_digit[i]+=1
if any(count_digit[i] > 2 for i in lst):
return False
if all(lst[i-1] <= lst[i] for i in range(1, len(lst))):
return True
else:
return False
| def check(candidate):
# Check some simple cases
assert candidate([5]) == True
assert candidate([1, 2, 3, 4, 5]) == True
assert candidate([1, 3, 2, 4, 5]) == False
assert candidate([1, 2, 3, 4, 5, 6]) == True
assert candidate([1, 2, 3, 4, 5, 6, 7]) == True
assert candidate([1, 3, 2, 4, 5, 6, 7]) == False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([]) == True, "This prints if this assert fails 2 (good for debugging!)"
assert candidate([1]) == True, "This prints if this assert fails 3 (good for debugging!)"
assert candidate([3, 2, 1]) == False, "This prints if this assert fails 4 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 2, 2, 3, 4]) == False, "This prints if this assert fails 5 (good for debugging!)"
assert candidate([1, 2, 3, 3, 3, 4]) == False, "This prints if this assert fails 6 (good for debugging!)"
assert candidate([1, 2, 2, 3, 3, 4]) == True, "This prints if this assert fails 7 (good for debugging!)"
assert candidate([1, 2, 3, 4]) == True, "This prints if this assert fails 8 (good for debugging!)"
| is_sorted | is_sorted(lst) | def is_sorted(lst): | Напишите функцию is_sorted(lst) для решения следующей задачи: Получив список чисел, проверьте, отсортированы ли они в порядке возрастания или нет. Если список содержит более 1 дубликата одного и того же числа, верните значение False. Отрицательных чисел нет, есть только целые числа.
Примеры:
is_sorted([5]) ➞ True
is_sorted([1, 2, 3, 4, 5]) ➞ True
is_sorted([1, 3, 2, 4, 5]) ➞ False
is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
is_sorted([1, 2, 2, 2, 3, 4]) ➞ False | Напишите функцию is_sorted(lst) для решения следующей задачи: Получив список чисел, проверьте, отсортированы ли они в порядке возрастания или нет. Если список содержит более 1 дубликата одного и того же числа, верните значение False. Отрицательных чисел нет, есть только целые числа. | def is_sorted(lst):
"""
Получив список чисел, проверьте, отсортированы ли они в порядке возрастания или нет. Если список содержит более 1 дубликата одного и того же числа, верните значение False. Отрицательных чисел нет, есть только целые числа.
"""
|
HumanEval/127 | Вам даны два интервала,
где каждый интервал представлен парой целых чисел.
Например, interval = (start, end) = (1, 2).
Заданные интервалы замкнуты, что означает, что интервал (начало, конец)
включает в себя как начало, так и конец.
Для каждого заданного интервала предполагается, что его начало меньше или равно его и.\пВаша задача состоит в том, чтобы определить, является ли длина пересечения этих двуинтервалов простым числом.
Например, пересечение интервалов (1, 3), (2, 4) равно (2, 3)
, длина которого равна 1, что не простое число.
Если длина пересечения является простым числом, верните "YES",
В противном случае верните "NO".
Если два интервала не пересекаются, верните "NO".
[input/output] samples:
intersection((1, 2), (2, 3)) ==> "NO"
intersection((-1, 1), (0, 4)) ==> "NO"
intersection((-3, -1), (-5, 5)) ==> "YES" | def intersection(interval1, interval2):
"""
Вам даны два интервала,
где каждый интервал представлен парой целых чисел.
Например, interval = (start, end) = (1, 2).
Заданные интервалы замкнуты, что означает, что интервал (начало, конец)
включает в себя как начало, так и конец.
Для каждого заданного интервала предполагается, что его начало меньше или равно его и.\пВаша задача состоит в том, чтобы определить, является ли длина пересечения этих двуинтервалов простым числом.
Например, пересечение интервалов (1, 3), (2, 4) равно (2, 3)
, длина которого равна 1, что не простое число.
Если длина пересечения является простым числом, верните "YES",
В противном случае верните "NO".
Если два интервала не пересекаются, верните "NO".
[input/output] samples:
intersection((1, 2), (2, 3)) ==> "NO"
intersection((-1, 1), (0, 4)) ==> "NO"
intersection((-3, -1), (-5, 5)) ==> "YES"
"""
| def is_prime(num):
if num == 1 or num == 0:
return False
if num == 2:
return True
for i in range(2, num):
if num%i == 0:
return False
return True
l = max(interval1[0], interval2[0])
r = min(interval1[1], interval2[1])
length = r - l
if length > 0 and is_prime(length):
return "YES"
return "NO"
| def check(candidate):
# Check some simple cases
assert candidate((1, 2), (2, 3)) == "NO"
assert candidate((-1, 1), (0, 4)) == "NO"
assert candidate((-3, -1), (-5, 5)) == "YES"
assert candidate((-2, 2), (-4, 0)) == "YES"
# Check some edge cases that are easy to work out by hand.
assert candidate((-11, 2), (-1, -1)) == "NO"
assert candidate((1, 2), (3, 5)) == "NO"
assert candidate((1, 2), (1, 2)) == "NO"
assert candidate((-2, -2), (-3, -2)) == "NO"
| intersection | intersection(interval1, interval2) | def intersection(interval1, interval2): | Напишите функцию intersection(interval1, interval2) для решения следующей задачи: Вам даны два интервала,
где каждый интервал представлен парой целых чисел.
Например, interval = (start, end) = (1, 2).
Заданные интервалы замкнуты, что означает, что интервал (начало, конец)
включает в себя как начало, так и конец.
Для каждого заданного интервала предполагается, что его начало меньше или равно его и.\пВаша задача состоит в том, чтобы определить, является ли длина пересечения этих двуинтервалов простым числом.
Например, пересечение интервалов (1, 3), (2, 4) равно (2, 3)
, длина которого равна 1, что не простое число.
Если длина пересечения является простым числом, верните "YES",
В противном случае верните "NO".
Если два интервала не пересекаются, верните "NO".
[input/output] samples:
intersection((1, 2), (2, 3)) ==> "NO"
intersection((-1, 1), (0, 4)) ==> "NO"
intersection((-3, -1), (-5, 5)) ==> "YES" | Напишите функцию intersection(interval1, interval2) для решения следующей задачи: Вам даны два интервала,
где каждый интервал представлен парой целых чисел.
Например, interval = (start, end) = (1, 2).
Заданные интервалы замкнуты, что означает, что интервал (начало, конец)
включает в себя как начало, так и конец.
Для каждого заданного интервала предполагается, что его начало меньше или равно его и.\пВаша задача состоит в том, чтобы определить, является ли длина пересечения этих двуинтервалов простым числом.
Например, пересечение интервалов (1, 3), (2, 4) равно (2, 3)
, длина которого равна 1, что не простое число.
Если длина пересечения является простым числом, верните "YES",
В противном случае верните "NO".
Если два интервала не пересекаются, верните "NO".
[input/output] samples: | def intersection(interval1, interval2):
"""
Вам даны два интервала,
где каждый интервал представлен парой целых чисел.
Например, interval = (start, end) = (1, 2).
Заданные интервалы замкнуты, что означает, что интервал (начало, конец)
включает в себя как начало, так и конец.
Для каждого заданного интервала предполагается, что его начало меньше или равно его и.\пВаша задача состоит в том, чтобы определить, является ли длина пересечения этих двуинтервалов простым числом.
Например, пересечение интервалов (1, 3), (2, 4) равно (2, 3)
, длина которого равна 1, что не простое число.
Если длина пересечения является простым числом, верните "YES",
В противном случае верните "NO".
Если два интервала не пересекаются, верните "NO".
[input/output] samples:
"""
|
HumanEval/128 | Вам дан массив arr целых чисел, и вам нужно вернуть сумму значений целых чисел, умноженную на произведение всех знаков каждого числа в массиве, представленных 1, -1 или 0.
Примечание: возвращает None для пустого arr.
Пример:
>>> prod_signs([1, 2, 2, -4]) == -9
>>> prod_signs([0, 1]) == 0
>>> prod_signs([]) == None | def prod_signs(arr):
"""
Вам дан массив arr целых чисел, и вам нужно вернуть сумму значений целых чисел, умноженную на произведение всех знаков каждого числа в массиве, представленных 1, -1 или 0.
Примечание: возвращает None для пустого arr.
Пример:
>>> prod_signs([1, 2, 2, -4]) == -9
>>> prod_signs([0, 1]) == 0
>>> prod_signs([]) == None
"""
| if not arr: return None
prod = 0 if 0 in arr else (-1) ** len(list(filter(lambda x: x < 0, arr)))
return prod * sum([abs(i) for i in arr])
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1, 2, 2, -4]) == -9
assert candidate([0, 1]) == 0
assert candidate([1, 1, 1, 2, 3, -1, 1]) == -10
assert candidate([]) == None
assert candidate([2, 4,1, 2, -1, -1, 9]) == 20
assert candidate([-1, 1, -1, 1]) == 4
assert candidate([-1, 1, 1, 1]) == -4
assert candidate([-1, 1, 1, 0]) == 0
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| prod_signs | prod_signs(arr) | def prod_signs(arr): | Напишите функцию prod_signs(arr) для решения следующей задачи: Вам дан массив arr целых чисел, и вам нужно вернуть сумму значений целых чисел, умноженную на произведение всех знаков каждого числа в массиве, представленных 1, -1 или 0.
Примечание: возвращает None для пустого arr.
Пример:
>>> prod_signs([1, 2, 2, -4]) == -9
>>> prod_signs([0, 1]) == 0
>>> prod_signs([]) == None | Напишите функцию prod_signs(arr) для решения следующей задачи: Вам дан массив arr целых чисел, и вам нужно вернуть сумму значений целых чисел, умноженную на произведение всех знаков каждого числа в массиве, представленных 1, -1 или 0.
Примечание: возвращает None для пустого arr.
Пример: | def prod_signs(arr):
"""
Вам дан массив arr целых чисел, и вам нужно вернуть сумму значений целых чисел, умноженную на произведение всех знаков каждого числа в массиве, представленных 1, -1 или 0.
Примечание: возвращает None для пустого arr.
Пример:
"""
|
HumanEval/129 | Дана сетка с N строками и N столбцами (N >= 2) и положительным целым числом k,
каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N]
включительно появляется ровно один раз в ячейках сетки.
Вы должны найти минимальный путь длиной k в сетке. Вы можете начать с любой ячейки, и на каждом шаге вы можете перейти к любой из соседних ячеек,
другими словами, вы можете перейти к ячейкам, которые имеют общее ребро с вашей текущей ячейкой.
Пожалуйста, обратите внимание, что путь длиной k означает посещение ровно k ячеек (не обязательно различных).
Вы НЕ можете выйти за пределы сетки.
Путь A (длиной k) считается меньшим, чем путь B (длиной k), если после составления упорядоченных списков значений в ячейках, через которые проходят A и B (назовем их lst_A и lst_B), lst_A лексикографически меньше, чем lst_B, другими словами, существует существует целочисленный индекс i (1 <= i <= k)
таким образом, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) мы имеем lst_A[j] = lst_B[j].
Гарантируется, что ответ будет уникальным.
Возвращает упорядоченный список значений в ячейках, через которые проходит минимальный путь.
Примеры:
Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
Output: [1, 2, 1]
Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
Output: [1] | def minPath(grid, k):
"""
Дана сетка с N строками и N столбцами (N >= 2) и положительным целым числом k,
каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N]
включительно появляется ровно один раз в ячейках сетки.
Вы должны найти минимальный путь длиной k в сетке. Вы можете начать с любой ячейки, и на каждом шаге вы можете перейти к любой из соседних ячеек,
другими словами, вы можете перейти к ячейкам, которые имеют общее ребро с вашей текущей ячейкой.
Пожалуйста, обратите внимание, что путь длиной k означает посещение ровно k ячеек (не обязательно различных).
Вы НЕ можете выйти за пределы сетки.
Путь A (длиной k) считается меньшим, чем путь B (длиной k), если после составления упорядоченных списков значений в ячейках, через которые проходят A и B (назовем их lst_A и lst_B), lst_A лексикографически меньше, чем lst_B, другими словами, существует существует целочисленный индекс i (1 <= i <= k)
таким образом, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) мы имеем lst_A[j] = lst_B[j].
Гарантируется, что ответ будет уникальным.
Возвращает упорядоченный список значений в ячейках, через которые проходит минимальный путь.
Примеры:
Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
Output: [1, 2, 1]
Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
Output: [1]
"""
| n = len(grid)
val = n * n + 1
for i in range(n):
for j in range(n):
if grid[i][j] == 1:
temp = []
if i != 0:
temp.append(grid[i - 1][j])
if j != 0:
temp.append(grid[i][j - 1])
if i != n - 1:
temp.append(grid[i + 1][j])
if j != n - 1:
temp.append(grid[i][j + 1])
val = min(temp)
ans = []
for i in range(k):
if i % 2 == 0:
ans.append(1)
else:
ans.append(val)
return ans
| def check(candidate):
# Check some simple cases
print
assert candidate([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3) == [1, 2, 1]
assert candidate([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1) == [1]
assert candidate([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], 4) == [1, 2, 1, 2]
assert candidate([[6, 4, 13, 10], [5, 7, 12, 1], [3, 16, 11, 15], [8, 14, 9, 2]], 7) == [1, 10, 1, 10, 1, 10, 1]
assert candidate([[8, 14, 9, 2], [6, 4, 13, 15], [5, 7, 1, 12], [3, 10, 11, 16]], 5) == [1, 7, 1, 7, 1]
assert candidate([[11, 8, 7, 2], [5, 16, 14, 4], [9, 3, 15, 6], [12, 13, 10, 1]], 9) == [1, 6, 1, 6, 1, 6, 1, 6, 1]
assert candidate([[12, 13, 10, 1], [9, 3, 15, 6], [5, 16, 14, 4], [11, 8, 7, 2]], 12) == [1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6]
assert candidate([[2, 7, 4], [3, 1, 5], [6, 8, 9]], 8) == [1, 3, 1, 3, 1, 3, 1, 3]
assert candidate([[6, 1, 5], [3, 8, 9], [2, 7, 4]], 8) == [1, 5, 1, 5, 1, 5, 1, 5]
# Check some edge cases that are easy to work out by hand.
assert candidate([[1, 2], [3, 4]], 10) == [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
assert candidate([[1, 3], [3, 2]], 10) == [1, 3, 1, 3, 1, 3, 1, 3, 1, 3]
| minPath | minPath(grid, k) | def minPath(grid, k): | Напишите функцию minPath(grid, k) для решения следующей задачи: Дана сетка с N строками и N столбцами (N >= 2) и положительным целым числом k,
каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N]
включительно появляется ровно один раз в ячейках сетки.
Вы должны найти минимальный путь длиной k в сетке. Вы можете начать с любой ячейки, и на каждом шаге вы можете перейти к любой из соседних ячеек,
другими словами, вы можете перейти к ячейкам, которые имеют общее ребро с вашей текущей ячейкой.
Пожалуйста, обратите внимание, что путь длиной k означает посещение ровно k ячеек (не обязательно различных).
Вы НЕ можете выйти за пределы сетки.
Путь A (длиной k) считается меньшим, чем путь B (длиной k), если после составления упорядоченных списков значений в ячейках, через которые проходят A и B (назовем их lst_A и lst_B), lst_A лексикографически меньше, чем lst_B, другими словами, существует существует целочисленный индекс i (1 <= i <= k)
таким образом, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) мы имеем lst_A[j] = lst_B[j].
Гарантируется, что ответ будет уникальным.
Возвращает упорядоченный список значений в ячейках, через которые проходит минимальный путь.
Примеры:
Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
Output: [1, 2, 1]
Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
Output: [1] | Напишите функцию minPath(grid, k) для решения следующей задачи: Дана сетка с N строками и N столбцами (N >= 2) и положительным целым числом k,
каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N]
включительно появляется ровно один раз в ячейках сетки.
Вы должны найти минимальный путь длиной k в сетке. Вы можете начать с любой ячейки, и на каждом шаге вы можете перейти к любой из соседних ячеек,
другими словами, вы можете перейти к ячейкам, которые имеют общее ребро с вашей текущей ячейкой.
Пожалуйста, обратите внимание, что путь длиной k означает посещение ровно k ячеек (не обязательно различных).
Вы НЕ можете выйти за пределы сетки.
Путь A (длиной k) считается меньшим, чем путь B (длиной k), если после составления упорядоченных списков значений в ячейках, через которые проходят A и B (назовем их lst_A и lst_B), lst_A лексикографически меньше, чем lst_B, другими словами, существует существует целочисленный индекс i (1 <= i <= k)
таким образом, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) мы имеем lst_A[j] = lst_B[j].
Гарантируется, что ответ будет уникальным.
Возвращает упорядоченный список значений в ячейках, через которые проходит минимальный путь. | def minPath(grid, k):
"""
Дана сетка с N строками и N столбцами (N >= 2) и положительным целым числом k,
каждая ячейка сетки содержит значение. Каждое целое число в диапазоне [1, N * N]
включительно появляется ровно один раз в ячейках сетки.
Вы должны найти минимальный путь длиной k в сетке. Вы можете начать с любой ячейки, и на каждом шаге вы можете перейти к любой из соседних ячеек,
другими словами, вы можете перейти к ячейкам, которые имеют общее ребро с вашей текущей ячейкой.
Пожалуйста, обратите внимание, что путь длиной k означает посещение ровно k ячеек (не обязательно различных).
Вы НЕ можете выйти за пределы сетки.
Путь A (длиной k) считается меньшим, чем путь B (длиной k), если после составления упорядоченных списков значений в ячейках, через которые проходят A и B (назовем их lst_A и lst_B), lst_A лексикографически меньше, чем lst_B, другими словами, существует существует целочисленный индекс i (1 <= i <= k)
таким образом, что lst_A[i] < lst_B[i] и для любого j (1 <= j < i) мы имеем lst_A[j] = lst_B[j].
Гарантируется, что ответ будет уникальным.
Возвращает упорядоченный список значений в ячейках, через которые проходит минимальный путь.
"""
|
HumanEval/130 | Все знают последовательность Фибоначчи, она была глубоко изучена математиками за последние пару столетий. Однако чего люди не знают, так это последовательности Трибоначчи.
Последовательность Трибоначчи определяется соотношениями:
tri(1) = 3
tri(n) = 1 + n / 2, если n четно.
tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетно.
Примеры:
tri(2) = 1 + (2 / 2) = 2
tri(4) = 3
tri(3) = tri(2) + tri(1) + tri(4)
= 2 + 3 + 3 = 8
Дано неотрицательное целое число n, верните список первых n + 1 чисел последовательности Трибоначчи.
tri(3) = [1, 3, 2, 8] | def tri(n):
"""
Все знают последовательность Фибоначчи, она была глубоко изучена математиками за последние пару столетий. Однако чего люди не знают, так это последовательности Трибоначчи.
Последовательность Трибоначчи определяется соотношениями:
tri(1) = 3
tri(n) = 1 + n / 2, если n четно.
tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетно.
Примеры:
tri(2) = 1 + (2 / 2) = 2
tri(4) = 3
tri(3) = tri(2) + tri(1) + tri(4)
= 2 + 3 + 3 = 8
Дано неотрицательное целое число n, верните список первых n + 1 чисел последовательности Трибоначчи.
tri(3) = [1, 3, 2, 8]
"""
| if n == 0:
return [1]
my_tri = [1, 3]
for i in range(2, n + 1):
if i % 2 == 0:
my_tri.append(i / 2 + 1)
else:
my_tri.append(my_tri[i - 1] + my_tri[i - 2] + (i + 3) / 2)
return my_tri
| def check(candidate):
# Check some simple cases
assert candidate(3) == [1, 3, 2.0, 8.0]
assert candidate(4) == [1, 3, 2.0, 8.0, 3.0]
assert candidate(5) == [1, 3, 2.0, 8.0, 3.0, 15.0]
assert candidate(6) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0]
assert candidate(7) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0]
assert candidate(8) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0]
assert candidate(9) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0]
assert candidate(20) == [1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0, 6.0, 48.0, 7.0, 63.0, 8.0, 80.0, 9.0, 99.0, 10.0, 120.0, 11.0]
# Check some edge cases that are easy to work out by hand.
assert candidate(0) == [1]
assert candidate(1) == [1, 3]
| tri | tri(n) | def tri(n): | Напишите функцию tri(n) для решения следующей задачи: Все знают последовательность Фибоначчи, она была глубоко изучена математиками за последние пару столетий. Однако чего люди не знают, так это последовательности Трибоначчи.
Последовательность Трибоначчи определяется соотношениями:
tri(1) = 3
tri(n) = 1 + n / 2, если n четно.
tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетно.
Примеры:
tri(2) = 1 + (2 / 2) = 2
tri(4) = 3
tri(3) = tri(2) + tri(1) + tri(4)
= 2 + 3 + 3 = 8
Дано неотрицательное целое число n, верните список первых n + 1 чисел последовательности Трибоначчи.
tri(3) = [1, 3, 2, 8] | Напишите функцию tri(n) для решения следующей задачи: Все знают последовательность Фибоначчи, она была глубоко изучена математиками за последние пару столетий. Однако чего люди не знают, так это последовательности Трибоначчи.
Последовательность Трибоначчи определяется соотношениями:
tri(1) = 3
tri(n) = 1 + n / 2, если n четно.
tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетно. | def tri(n):
"""
Все знают последовательность Фибоначчи, она была глубоко изучена математиками за последние пару столетий. Однако чего люди не знают, так это последовательности Трибоначчи.
Последовательность Трибоначчи определяется соотношениями:
tri(1) = 3
tri(n) = 1 + n / 2, если n четно.
tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), если n нечетно.
"""
|
HumanEval/131 | Дано положительное целое число n, верните произведение его нечетных цифр.
Возвращает 0, если все цифры четные.
Примеры:
digits(1) == 1
digits(4) == 0
digits(235) == 15 | def digits(n):
"""
Дано положительное целое число n, верните произведение его нечетных цифр.
Возвращает 0, если все цифры четные.
Примеры:
digits(1) == 1
digits(4) == 0
digits(235) == 15
"""
| product = 1
odd_count = 0
for digit in str(n):
int_digit = int(digit)
if int_digit%2 == 1:
product= product*int_digit
odd_count+=1
if odd_count ==0:
return 0
else:
return product
| def check(candidate):
# Check some simple cases
assert candidate(5) == 5
assert candidate(54) == 5
assert candidate(120) ==1
assert candidate(5014) == 5
assert candidate(98765) == 315
assert candidate(5576543) == 2625
# Check some edge cases that are easy to work out by hand.
assert candidate(2468) == 0
| digits | digits(n) | def digits(n): | Напишите функцию digits(n) для решения следующей задачи: Дано положительное целое число n, верните произведение его нечетных цифр.
Возвращает 0, если все цифры четные.
Примеры:
digits(1) == 1
digits(4) == 0
digits(235) == 15 | Напишите функцию digits(n) для решения следующей задачи: Дано положительное целое число n, верните произведение его нечетных цифр.
Возвращает 0, если все цифры четные. | def digits(n):
"""
Дано положительное целое число n, верните произведение его нечетных цифр.
Возвращает 0, если все цифры четные.
"""
|
HumanEval/132 | Создайте функцию, которая принимает в качестве входных данных строку, содержащую только квадратные скобки.
Функция должна возвращать значение True тогда и только тогда, когда существует сбалансированная подпоследовательность скобок, в которую вложена хотя бы одна скобка в подпоследовательности.
is_nested('[[]]') ➞ True
is_nested('[]]]]]]][[[[[]') ➞ False
is_nested('[][]') ➞ False
is_nested('[]') ➞ False
is_nested('[[][]]') ➞ True
is_nested('[[]][[') ➞ True | def is_nested(string):
"""
Создайте функцию, которая принимает в качестве входных данных строку, содержащую только квадратные скобки.
Функция должна возвращать значение True тогда и только тогда, когда существует сбалансированная подпоследовательность скобок, в которую вложена хотя бы одна скобка в подпоследовательности.
is_nested('[[]]') ➞ True
is_nested('[]]]]]]][[[[[]') ➞ False
is_nested('[][]') ➞ False
is_nested('[]') ➞ False
is_nested('[[][]]') ➞ True
is_nested('[[]][[') ➞ True
"""
| opening_bracket_index = []
closing_bracket_index = []
for i in range(len(string)):
if string[i] == '[':
opening_bracket_index.append(i)
else:
closing_bracket_index.append(i)
closing_bracket_index.reverse()
cnt = 0
i = 0
l = len(closing_bracket_index)
for idx in opening_bracket_index:
if i < l and idx < closing_bracket_index[i]:
cnt += 1
i += 1
return cnt >= 2
| def check(candidate):
# Check some simple cases
assert candidate('[[]]') == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate('[]]]]]]][[[[[]') == False
assert candidate('[][]') == False
assert candidate(('[]')) == False
assert candidate('[[[[]]]]') == True
assert candidate('[]]]]]]]]]]') == False
assert candidate('[][][[]]') == True
assert candidate('[[]') == False
assert candidate('[]]') == False
assert candidate('[[]][[') == True
assert candidate('[[][]]') == True
# Check some edge cases that are easy to work out by hand.
assert candidate('') == False, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate('[[[[[[[[') == False
assert candidate(']]]]]]]]') == False
| is_nested | is_nested(string) | def is_nested(string): | Напишите функцию is_nested(string) для решения следующей задачи: Создайте функцию, которая принимает в качестве входных данных строку, содержащую только квадратные скобки.
Функция должна возвращать значение True тогда и только тогда, когда существует сбалансированная подпоследовательность скобок, в которую вложена хотя бы одна скобка в подпоследовательности.
is_nested('[[]]') ➞ True
is_nested('[]]]]]]][[[[[]') ➞ False
is_nested('[][]') ➞ False
is_nested('[]') ➞ False
is_nested('[[][]]') ➞ True
is_nested('[[]][[') ➞ True | Напишите функцию is_nested(string) для решения следующей задачи: Создайте функцию, которая принимает в качестве входных данных строку, содержащую только квадратные скобки.
Функция должна возвращать значение True тогда и только тогда, когда существует сбалансированная подпоследовательность скобок, в которую вложена хотя бы одна скобка в подпоследовательности. | def is_nested(string):
"""
Создайте функцию, которая принимает в качестве входных данных строку, содержащую только квадратные скобки.
Функция должна возвращать значение True тогда и только тогда, когда существует сбалансированная подпоследовательность скобок, в которую вложена хотя бы одна скобка в подпоследовательности.
"""
|
HumanEval/133 | Вам дан список чисел.
Вам нужно вернуть сумму чисел в квадрате в заданном списке,
сначала округлив каждый элемент в списке до верхнего значения int(Ceiling).
Примеры:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst = [1,3,5,7] the output should be 84
For lst = [1.4,4.2,0] the output should be 29
For lst = [-2.4,1,1] the output should be 6 | def sum_squares(lst):
"""
Вам дан список чисел.
Вам нужно вернуть сумму чисел в квадрате в заданном списке,
сначала округлив каждый элемент в списке до верхнего значения int(Ceiling).
Примеры:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst = [1,3,5,7] the output should be 84
For lst = [1.4,4.2,0] the output should be 29
For lst = [-2.4,1,1] the output should be 6
"""
| import math
squared = 0
for i in lst:
squared += math.ceil(i)**2
return squared
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.0,2,3])==14, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,3,5,7])==84, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1.4,4.2,0])==29, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-2.4,1,1])==6, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([100,1,15,2])==10230, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([10000,10000])==200000000, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-1.4,4.6,6.3])==75, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([-1.4,17.9,18.9,19.9])==1086, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([0])==0, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([-1])==1, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate([-1,1,0])==2, "This prints if this assert fails 2 (also good for debugging!)"
| sum_squares | sum_squares(lst) | def sum_squares(lst): | Напишите функцию sum_squares(lst) для решения следующей задачи: Вам дан список чисел.
Вам нужно вернуть сумму чисел в квадрате в заданном списке,
сначала округлив каждый элемент в списке до верхнего значения int(Ceiling).
Примеры:
For lst = [1,2,3] the output should be 14
For lst = [1,4,9] the output should be 98
For lst = [1,3,5,7] the output should be 84
For lst = [1.4,4.2,0] the output should be 29
For lst = [-2.4,1,1] the output should be 6 | Напишите функцию sum_squares(lst) для решения следующей задачи: Вам дан список чисел.
Вам нужно вернуть сумму чисел в квадрате в заданном списке,
сначала округлив каждый элемент в списке до верхнего значения int(Ceiling). | def sum_squares(lst):
"""
Вам дан список чисел.
Вам нужно вернуть сумму чисел в квадрате в заданном списке,
сначала округлив каждый элемент в списке до верхнего значения int(Ceiling).
"""
|
HumanEval/134 | Создайте функцию, которая возвращает значение True, если последний символ данной строки является буквенным символом и не является частью слова, и значение False в противном случае.
Примечание: "слово" - это группа символов, разделенных пробелом.
Примеры:
check_if_last_char_is_a_letter("apple pie") ➞ False
check_if_last_char_is_a_letter("apple pi e") ➞ True
check_if_last_char_is_a_letter("apple pi e ") ➞ False
check_if_last_char_is_a_letter("") ➞ False | def check_if_last_char_is_a_letter(txt):
"""
Создайте функцию, которая возвращает значение True, если последний символ данной строки является буквенным символом и не является частью слова, и значение False в противном случае.
Примечание: "слово" - это группа символов, разделенных пробелом.
Примеры:
check_if_last_char_is_a_letter("apple pie") ➞ False
check_if_last_char_is_a_letter("apple pi e") ➞ True
check_if_last_char_is_a_letter("apple pi e ") ➞ False
check_if_last_char_is_a_letter("") ➞ False
"""
|
check = txt.split(' ')[-1]
return True if len(check) == 1 and (97 <= ord(check.lower()) <= 122) else False
| def check(candidate):
# Check some simple cases
assert candidate("apple") == False
assert candidate("apple pi e") == True
assert candidate("eeeee") == False
assert candidate("A") == True
assert candidate("Pumpkin pie ") == False
assert candidate("Pumpkin pie 1") == False
assert candidate("") == False
assert candidate("eeeee e ") == False
assert candidate("apple pie") == False
assert candidate("apple pi e ") == False
# Check some edge cases that are easy to work out by hand.
assert True
| check_if_last_char_is_a_letter | check_if_last_char_is_a_letter(txt) | def check_if_last_char_is_a_letter(txt): | Напишите функцию check_if_last_char_is_a_letter(txt) для решения следующей задачи: Создайте функцию, которая возвращает значение True, если последний символ данной строки является буквенным символом и не является частью слова, и значение False в противном случае.
Примечание: "слово" - это группа символов, разделенных пробелом.
Примеры:
check_if_last_char_is_a_letter("apple pie") ➞ False
check_if_last_char_is_a_letter("apple pi e") ➞ True
check_if_last_char_is_a_letter("apple pi e ") ➞ False
check_if_last_char_is_a_letter("") ➞ False | Напишите функцию check_if_last_char_is_a_letter(txt) для решения следующей задачи: Создайте функцию, которая возвращает значение True, если последний символ данной строки является буквенным символом и не является частью слова, и значение False в противном случае.
Примечание: "слово" - это группа символов, разделенных пробелом. | def check_if_last_char_is_a_letter(txt):
"""
Создайте функцию, которая возвращает значение True, если последний символ данной строки является буквенным символом и не является частью слова, и значение False в противном случае.
Примечание: "слово" - это группа символов, разделенных пробелом.
"""
|
HumanEval/135 | Создайте функцию, которая возвращает наибольший индекс элемента, который меньше элемента, непосредственно предшествующему ему. Если такого элемента нет, то верните -1. Данный массив не содержит повторяющихся значений.
Примеры:
can_arrange([1,2,4,3,5]) = 3
can_arrange([1,2,3]) = -1 | def can_arrange(arr):
"""
Создайте функцию, которая возвращает наибольший индекс элемента, который меньше элемента, непосредственно предшествующему ему. Если такого элемента нет, то верните -1. Данный массив не содержит повторяющихся значений.
Примеры:
can_arrange([1,2,4,3,5]) = 3
can_arrange([1,2,3]) = -1
"""
| ind=-1
i=1
while i<len(arr):
if arr[i]<arr[i-1]:
ind=i
i+=1
return ind
| def check(candidate):
# Check some simple cases
assert candidate([1,2,4,3,5])==3
assert candidate([1,2,4,5])==-1
assert candidate([1,4,2,5,6,7,8,9,10])==2
assert candidate([4,8,5,7,3])==4
# Check some edge cases that are easy to work out by hand.
assert candidate([])==-1
| can_arrange | can_arrange(arr) | def can_arrange(arr): | Напишите функцию can_arrange(arr) для решения следующей задачи: Создайте функцию, которая возвращает наибольший индекс элемента, который меньше элемента, непосредственно предшествующему ему. Если такого элемента нет, то верните -1. Данный массив не содержит повторяющихся значений.
Примеры:
can_arrange([1,2,4,3,5]) = 3
can_arrange([1,2,3]) = -1 | Напишите функцию can_arrange(arr) для решения следующей задачи: Создайте функцию, которая возвращает наибольший индекс элемента, который меньше элемента, непосредственно предшествующему ему. Если такого элемента нет, то верните -1. Данный массив не содержит повторяющихся значений. | def can_arrange(arr):
"""
Создайте функцию, которая возвращает наибольший индекс элемента, который меньше элемента, непосредственно предшествующему ему. Если такого элемента нет, то верните -1. Данный массив не содержит повторяющихся значений.
"""
|
HumanEval/136 | Создайте функцию, которая возвращает кортеж (a, b), где 'a' - самое большое из отрицательных целых чисел, а 'b' - наименьшее из положительных целых чисел в списке.
Если нет отрицательных или положительных целых чисел, верните их как None.
Примеры:
largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
largest_smallest_integers([]) == (None, None)
largest_smallest_integers([0]) == (None, None) | def largest_smallest_integers(lst):
"""
Создайте функцию, которая возвращает кортеж (a, b), где 'a' - самое большое из отрицательных целых чисел, а 'b' - наименьшее из положительных целых чисел в списке.
Если нет отрицательных или положительных целых чисел, верните их как None.
Примеры:
largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
largest_smallest_integers([]) == (None, None)
largest_smallest_integers([0]) == (None, None)
"""
| smallest = list(filter(lambda x: x < 0, lst))
largest = list(filter(lambda x: x > 0, lst))
return (max(smallest) if smallest else None, min(largest) if largest else None)
| def check(candidate):
# Check some simple cases
assert candidate([2, 4, 1, 3, 5, 7]) == (None, 1)
assert candidate([2, 4, 1, 3, 5, 7, 0]) == (None, 1)
assert candidate([1, 3, 2, 4, 5, 6, -2]) == (-2, 1)
assert candidate([4, 5, 3, 6, 2, 7, -7]) == (-7, 2)
assert candidate([7, 3, 8, 4, 9, 2, 5, -9]) == (-9, 2)
assert candidate([]) == (None, None)
assert candidate([0]) == (None, None)
assert candidate([-1, -3, -5, -6]) == (-1, None)
assert candidate([-1, -3, -5, -6, 0]) == (-1, None)
assert candidate([-6, -4, -4, -3, 1]) == (-3, 1)
assert candidate([-6, -4, -4, -3, -100, 1]) == (-3, 1)
# Check some edge cases that are easy to work out by hand.
assert True
| largest_smallest_integers | largest_smallest_integers(lst) | def largest_smallest_integers(lst): | Напишите функцию largest_smallest_integers(lst) для решения следующей задачи: Создайте функцию, которая возвращает кортеж (a, b), где 'a' - самое большое из отрицательных целых чисел, а 'b' - наименьшее из положительных целых чисел в списке.
Если нет отрицательных или положительных целых чисел, верните их как None.
Примеры:
largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
largest_smallest_integers([]) == (None, None)
largest_smallest_integers([0]) == (None, None) | Напишите функцию largest_smallest_integers(lst) для решения следующей задачи: Создайте функцию, которая возвращает кортеж (a, b), где 'a' - самое большое из отрицательных целых чисел, а 'b' - наименьшее из положительных целых чисел в списке.
Если нет отрицательных или положительных целых чисел, верните их как None. | def largest_smallest_integers(lst):
"""
Создайте функцию, которая возвращает кортеж (a, b), где 'a' - самое большое из отрицательных целых чисел, а 'b' - наименьшее из положительных целых чисел в списке.
Если нет отрицательных или положительных целых чисел, верните их как None.
"""
|
HumanEval/137 | Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие действительные числа, и возвращает переменную большего размера в заданном типе переменной.
Возвращает значение None, если значения равны.
Примечание: Если действительное число представлено в виде строки, то плавающей точкой может быть . или ,
compare_one(1, 2.5) ➞ 2.5
compare_one(1, "2,3") ➞ "2,3"
сравнение_один("5,1", "6") ➞ "6"
compare_one("1", 1) ➞ None | def compare_one(a, b):
"""
Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие действительные числа, и возвращает переменную большего размера в заданном типе переменной.
Возвращает значение None, если значения равны.
Примечание: Если действительное число представлено в виде строки, то плавающей точкой может быть . или ,
compare_one(1, 2.5) ➞ 2.5
compare_one(1, "2,3") ➞ "2,3"
сравнение_один("5,1", "6") ➞ "6"
compare_one("1", 1) ➞ None
"""
| temp_a, temp_b = a, b
if isinstance(temp_a, str): temp_a = temp_a.replace(',','.')
if isinstance(temp_b, str): temp_b = temp_b.replace(',','.')
if float(temp_a) == float(temp_b): return None
return a if float(temp_a) > float(temp_b) else b
| def check(candidate):
# Check some simple cases
assert candidate(1, 2) == 2
assert candidate(1, 2.5) == 2.5
assert candidate(2, 3) == 3
assert candidate(5, 6) == 6
assert candidate(1, "2,3") == "2,3"
assert candidate("5,1", "6") == "6"
assert candidate("1", "2") == "2"
assert candidate("1", 1) == None
# Check some edge cases that are easy to work out by hand.
assert True
| compare_one | compare_one(a, b) | def compare_one(a, b): | Напишите функцию compare_one(a, b) для решения следующей задачи: Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие действительные числа, и возвращает переменную большего размера в заданном типе переменной.
Возвращает значение None, если значения равны.
Примечание: Если действительное число представлено в виде строки, то плавающей точкой может быть . или ,
compare_one(1, 2.5) ➞ 2.5
compare_one(1, "2,3") ➞ "2,3"
сравнение_один("5,1", "6") ➞ "6"
compare_one("1", 1) ➞ None | Напишите функцию compare_one(a, b) для решения следующей задачи: Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие действительные числа, и возвращает переменную большего размера в заданном типе переменной.
Возвращает значение None, если значения равны.
Примечание: Если действительное число представлено в виде строки, то плавающей точкой может быть . или , | def compare_one(a, b):
"""
Создайте функцию, которая принимает целые числа, числа с плавающей точкой или строки, представляющие действительные числа, и возвращает переменную большего размера в заданном типе переменной.
Возвращает значение None, если значения равны.
Примечание: Если действительное число представлено в виде строки, то плавающей точкой может быть . или ,
"""
|
HumanEval/138 | Проверьте, может ли данное число n быть записано как сумма ровно 4 положительных четных чисел
Примеры:
is_equal_to_sum_even(4) == False
is_equal_to_sum_even(6) == False
is_equal_to_sum_even(8) == True | def is_equal_to_sum_even(n):
"""
Проверьте, может ли данное число n быть записано как сумма ровно 4 положительных четных чисел
Примеры:
is_equal_to_sum_even(4) == False
is_equal_to_sum_even(6) == False
is_equal_to_sum_even(8) == True
"""
| return n%2 == 0 and n >= 8
| def check(candidate):
assert candidate(4) == False
assert candidate(6) == False
assert candidate(8) == True
assert candidate(10) == True
assert candidate(11) == False
assert candidate(12) == True
assert candidate(13) == False
assert candidate(16) == True
| is_equal_to_sum_even | is_equal_to_sum_even(n) | def is_equal_to_sum_even(n): | Напишите функцию is_equal_to_sum_even(n) для решения следующей задачи: Проверьте, может ли данное число n быть записано как сумма ровно 4 положительных четных чисел
Примеры:
is_equal_to_sum_even(4) == False
is_equal_to_sum_even(6) == False
is_equal_to_sum_even(8) == True | Напишите функцию is_equal_to_sum_even(n) для решения следующей задачи: Проверьте, может ли данное число n быть записано как сумма ровно 4 положительных четных чисел | def is_equal_to_sum_even(n):
"""
Проверьте, может ли данное число n быть записано как сумма ровно 4 положительных четных чисел
"""
|
HumanEval/139 | Бразильский факториал определяется как:
бразильский_факториал(n) = n! * (n-1)! * (n-2)! * ... * 1!
где n > 0
Например:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special factorial of this integer. | def special_factorial(n):
"""
Бразильский факториал определяется как:
бразильский_факториал(n) = n! * (n-1)! * (n-2)! * ... * 1!
где n > 0
Например:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special factorial of this integer.
"""
| fact_i = 1
special_fact = 1
for i in range(1, n+1):
fact_i *= i
special_fact *= fact_i
return special_fact
| def check(candidate):
# Check some simple cases
assert candidate(4) == 288, "Test 4"
assert candidate(5) == 34560, "Test 5"
assert candidate(7) == 125411328000, "Test 7"
# Check some edge cases that are easy to work out by hand.
assert candidate(1) == 1, "Test 1"
| special_factorial | special_factorial(n) | def special_factorial(n): | Напишите функцию special_factorial(n) для решения следующей задачи: Бразильский факториал определяется как:
бразильский_факториал(n) = n! * (n-1)! * (n-2)! * ... * 1!
где n > 0
Например:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special factorial of this integer. | Напишите функцию special_factorial(n) для решения следующей задачи: Бразильский факториал определяется как:
бразильский_факториал(n) = n! * (n-1)! * (n-2)! * ... * 1!
где n > 0
Например: | def special_factorial(n):
"""
Бразильский факториал определяется как:
бразильский_факториал(n) = n! * (n-1)! * (n-2)! * ... * 1!
где n > 0
Например:
"""
|
HumanEval/140 | Дана строка, замените все пробелы в ней символами подчеркивания,
и если строка содержит более 2 последовательных пробелов,
то замените все последовательные пробелы на -
fix_spaces("Example") == "Example"
fix_spaces("Example 1") == "Example_1"
fix_spaces(" Example 2") == "_Example_2"
fix_spaces(" Example 3") == "_Example-3" | def fix_spaces(text):
"""
Дана строка, замените все пробелы в ней символами подчеркивания,
и если строка содержит более 2 последовательных пробелов,
то замените все последовательные пробелы на -
fix_spaces("Example") == "Example"
fix_spaces("Example 1") == "Example_1"
fix_spaces(" Example 2") == "_Example_2"
fix_spaces(" Example 3") == "_Example-3"
"""
| new_text = ""
i = 0
start, end = 0, 0
while i < len(text):
if text[i] == " ":
end += 1
else:
if end - start > 2:
new_text += "-"+text[i]
elif end - start > 0:
new_text += "_"*(end - start)+text[i]
else:
new_text += text[i]
start, end = i+1, i+1
i+=1
if end - start > 2:
new_text += "-"
elif end - start > 0:
new_text += "_"
return new_text
| def check(candidate):
# Check some simple cases
assert candidate("Example") == "Example", "This prints if this assert fails 1 (good for debugging!)"
assert candidate("Mudasir Hanif ") == "Mudasir_Hanif_", "This prints if this assert fails 2 (good for debugging!)"
assert candidate("Yellow Yellow Dirty Fellow") == "Yellow_Yellow__Dirty__Fellow", "This prints if this assert fails 3 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate("Exa mple") == "Exa-mple", "This prints if this assert fails 4 (good for debugging!)"
assert candidate(" Exa 1 2 2 mple") == "-Exa_1_2_2_mple", "This prints if this assert fails 4 (good for debugging!)"
| fix_spaces | fix_spaces(text) | def fix_spaces(text): | Напишите функцию fix_spaces(text) для решения следующей задачи: Дана строка, замените все пробелы в ней символами подчеркивания,
и если строка содержит более 2 последовательных пробелов,
то замените все последовательные пробелы на -
fix_spaces("Example") == "Example"
fix_spaces("Example 1") == "Example_1"
fix_spaces(" Example 2") == "_Example_2"
fix_spaces(" Example 3") == "_Example-3" | Напишите функцию fix_spaces(text) для решения следующей задачи: Дана строка, замените все пробелы в ней символами подчеркивания,
и если строка содержит более 2 последовательных пробелов,
то замените все последовательные пробелы на - | def fix_spaces(text):
"""
Дана строка, замените все пробелы в ней символами подчеркивания,
и если строка содержит более 2 последовательных пробелов,
то замените все последовательные пробелы на -
"""
|
HumanEval/141 | Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает "Да", если имя файла допустимо, и возвращает "Нет" в противном случае.
Имя файла считается допустимым тогда и только тогда, когда выполняются все следующие условия:
- В имени файла не должно быть более трех цифр ('0'-'9').
- Имя файла содержит ровно одну точку '.'
- Подстрока перед точкой не должна быть пустой, и она начинается с буквы из латинского алфавита ('a'-'z' и 'A'-'Z').
- Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll']
Примеры:
file_name_check(".txt") # => \'Yes\'
file_name_check("1.dll") # => \'No\' (the name should start with a latin alphapet letter) | def file_name_check(file_name):
"""
Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает "Да", если имя файла допустимо, и возвращает "Нет" в противном случае.
Имя файла считается допустимым тогда и только тогда, когда выполняются все следующие условия:
- В имени файла не должно быть более трех цифр ('0'-'9').
- Имя файла содержит ровно одну точку '.'
- Подстрока перед точкой не должна быть пустой, и она начинается с буквы из латинского алфавита ('a'-'z' и 'A'-'Z').
- Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll']
Примеры:
file_name_check(".txt") # => \'Yes\'
file_name_check("1.dll") # => \'No\' (the name should start with a latin alphapet letter)
"""
| suf = ['txt', 'exe', 'dll']
lst = file_name.split(sep='.')
if len(lst) != 2:
return 'No'
if not lst[1] in suf:
return 'No'
if len(lst[0]) == 0:
return 'No'
if not lst[0][0].isalpha():
return 'No'
t = len([x for x in lst[0] if x.isdigit()])
if t > 3:
return 'No'
return 'Yes'
| def check(candidate):
# Check some simple cases
assert candidate("example.txt") == 'Yes'
assert candidate("1example.dll") == 'No'
assert candidate('s1sdf3.asd') == 'No'
assert candidate('K.dll') == 'Yes'
assert candidate('MY16FILE3.exe') == 'Yes'
assert candidate('His12FILE94.exe') == 'No'
assert candidate('_Y.txt') == 'No'
assert candidate('?aREYA.exe') == 'No'
assert candidate('/this_is_valid.dll') == 'No'
assert candidate('this_is_valid.wow') == 'No'
assert candidate('this_is_valid.txt') == 'Yes'
assert candidate('this_is_valid.txtexe') == 'No'
assert candidate('#this2_i4s_5valid.ten') == 'No'
assert candidate('@this1_is6_valid.exe') == 'No'
assert candidate('this_is_12valid.6exe4.txt') == 'No'
assert candidate('all.exe.txt') == 'No'
assert candidate('I563_No.exe') == 'Yes'
assert candidate('Is3youfault.txt') == 'Yes'
assert candidate('no_one#knows.dll') == 'Yes'
assert candidate('1I563_Yes3.exe') == 'No'
assert candidate('I563_Yes3.txtt') == 'No'
assert candidate('final..txt') == 'No'
assert candidate('final132') == 'No'
assert candidate('_f4indsartal132.') == 'No'
# Check some edge cases that are easy to work out by hand.
assert candidate('.txt') == 'No'
assert candidate('s.') == 'No'
| file_name_check | file_name_check(file_name) | def file_name_check(file_name): | Напишите функцию file_name_check(file_name) для решения следующей задачи: Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает "Да", если имя файла допустимо, и возвращает "Нет" в противном случае.
Имя файла считается допустимым тогда и только тогда, когда выполняются все следующие условия:
- В имени файла не должно быть более трех цифр ('0'-'9').
- Имя файла содержит ровно одну точку '.'
- Подстрока перед точкой не должна быть пустой, и она начинается с буквы из латинского алфавита ('a'-'z' и 'A'-'Z').
- Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll']
Примеры:
file_name_check(".txt") # => \'Yes\'
file_name_check("1.dll") # => \'No\' (the name should start with a latin alphapet letter) | Напишите функцию file_name_check(file_name) для решения следующей задачи: Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает "Да", если имя файла допустимо, и возвращает "Нет" в противном случае.
Имя файла считается допустимым тогда и только тогда, когда выполняются все следующие условия:
- В имени файла не должно быть более трех цифр ('0'-'9').
- Имя файла содержит ровно одну точку '.'
- Подстрока перед точкой не должна быть пустой, и она начинается с буквы из латинского алфавита ('a'-'z' и 'A'-'Z').
- Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll'] | def file_name_check(file_name):
"""
Создайте функцию, которая принимает строку, представляющую имя файла, и возвращает "Да", если имя файла допустимо, и возвращает "Нет" в противном случае.
Имя файла считается допустимым тогда и только тогда, когда выполняются все следующие условия:
- В имени файла не должно быть более трех цифр ('0'-'9').
- Имя файла содержит ровно одну точку '.'
- Подстрока перед точкой не должна быть пустой, и она начинается с буквы из латинского алфавита ('a'-'z' и 'A'-'Z').
- Подстрока после точки должна быть одной из следующих: ['txt', 'exe', 'dll']
"""
|
HumanEval/142 | "
Функция принимает на вход список целых чисел. Для всех элементов в списке функция возводит элемент в квадрат, если ее индекс кратен 3, и возводит элемент в куб, если ее индекс кратен 4, а не 3. Функция не изменит записи в списке, индексы которых не кратны 3 или 4. Затем функция должна вернуть сумму всех элементов.
Примеры:
For lst = [1,2,3] the output should be 6
For lst = [] the output should be 0
For lst = [-1,-5,2,-1,-5] the output should be -126 | def sum_squares(lst):
"""
"
Функция принимает на вход список целых чисел. Для всех элементов в списке функция возводит элемент в квадрат, если ее индекс кратен 3, и возводит элемент в куб, если ее индекс кратен 4, а не 3. Функция не изменит записи в списке, индексы которых не кратны 3 или 4. Затем функция должна вернуть сумму всех элементов.
Примеры:
For lst = [1,2,3] the output should be 6
For lst = [] the output should be 0
For lst = [-1,-5,2,-1,-5] the output should be -126
"""
| result =[]
for i in range(len(lst)):
if i %3 == 0:
result.append(lst[i]**2)
elif i % 4 == 0 and i%3 != 0:
result.append(lst[i]**3)
else:
result.append(lst[i])
return sum(result)
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3]) == 6
assert candidate([1,4,9]) == 14
assert candidate([]) == 0
assert candidate([1,1,1,1,1,1,1,1,1]) == 9
assert candidate([-1,-1,-1,-1,-1,-1,-1,-1,-1]) == -3
assert candidate([0]) == 0
assert candidate([-1,-5,2,-1,-5]) == -126
assert candidate([-56,-99,1,0,-2]) == 3030
assert candidate([-1,0,0,0,0,0,0,0,-1]) == 0
assert candidate([-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37]) == -14196
assert candidate([-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10]) == -1448
# Don't remove this line:
| sum_squares | sum_squares(lst) | def sum_squares(lst): | Напишите функцию sum_squares(lst) для решения следующей задачи: "
Функция принимает на вход список целых чисел. Для всех элементов в списке функция возводит элемент в квадрат, если ее индекс кратен 3, и возводит элемент в куб, если ее индекс кратен 4, а не 3. Функция не изменит записи в списке, индексы которых не кратны 3 или 4. Затем функция должна вернуть сумму всех элементов.
Примеры:
For lst = [1,2,3] the output should be 6
For lst = [] the output should be 0
For lst = [-1,-5,2,-1,-5] the output should be -126 | Напишите функцию sum_squares(lst) для решения следующей задачи: "
Функция принимает на вход список целых чисел. Для всех элементов в списке функция возводит элемент в квадрат, если ее индекс кратен 3, и возводит элемент в куб, если ее индекс кратен 4, а не 3. Функция не изменит записи в списке, индексы которых не кратны 3 или 4. Затем функция должна вернуть сумму всех элементов. | def sum_squares(lst):
"""
"
Функция принимает на вход список целых чисел. Для всех элементов в списке функция возводит элемент в квадрат, если ее индекс кратен 3, и возводит элемент в куб, если ее индекс кратен 4, а не 3. Функция не изменит записи в списке, индексы которых не кратны 3 или 4. Затем функция должна вернуть сумму всех элементов.
"""
|
HumanEval/143 | Дана строка, представляющая предложение,
предложение содержит несколько слов, разделенных пробелом,
и вы должны вернуть строку, содержащую слова из исходного предложения,
длины которых являются простыми числами,
порядок слов в новой строке должен быть таким же, как в исходной.
Примеры:
1:
Input: sentence = "This is a test"
Output: "is"
2:
Input: sentence = "lets go for swimming"
Output: "go for"
Ограничения:
* 1 <= len(sentence) <= 100
* предложение содержит только буквы | def words_in_sentence(sentence):
"""
Дана строка, представляющая предложение,
предложение содержит несколько слов, разделенных пробелом,
и вы должны вернуть строку, содержащую слова из исходного предложения,
длины которых являются простыми числами,
порядок слов в новой строке должен быть таким же, как в исходной.
Примеры:
1:
Input: sentence = "This is a test"
Output: "is"
2:
Input: sentence = "lets go for swimming"
Output: "go for"
Ограничения:
* 1 <= len(sentence) <= 100
* предложение содержит только буквы
"""
| new_lst = []
for word in sentence.split():
flg = 0
if len(word) == 1:
flg = 1
for i in range(2, len(word)):
if len(word)%i == 0:
flg = 1
if flg == 0 or len(word) == 2:
new_lst.append(word)
return " ".join(new_lst)
| def check(candidate):
# Check some simple cases
assert candidate("This is a test") == "is"
assert candidate("lets go for swimming") == "go for"
assert candidate("there is no place available here") == "there is no place"
assert candidate("Hi I am Hussein") == "Hi am Hussein"
assert candidate("go for it") == "go for it"
# Check some edge cases that are easy to work out by hand.
assert candidate("here") == ""
assert candidate("here is") == "is"
| words_in_sentence | words_in_sentence(sentence) | def words_in_sentence(sentence): | Напишите функцию words_in_sentence(sentence) для решения следующей задачи: Дана строка, представляющая предложение,
предложение содержит несколько слов, разделенных пробелом,
и вы должны вернуть строку, содержащую слова из исходного предложения,
длины которых являются простыми числами,
порядок слов в новой строке должен быть таким же, как в исходной.
Примеры:
1:
Input: sentence = "This is a test"
Output: "is"
2:
Input: sentence = "lets go for swimming"
Output: "go for"
Ограничения:
* 1 <= len(sentence) <= 100
* предложение содержит только буквы | Напишите функцию words_in_sentence(sentence) для решения следующей задачи: Дана строка, представляющая предложение,
предложение содержит несколько слов, разделенных пробелом,
и вы должны вернуть строку, содержащую слова из исходного предложения,
длины которых являются простыми числами,
порядок слов в новой строке должен быть таким же, как в исходной. | def words_in_sentence(sentence):
"""
Дана строка, представляющая предложение,
предложение содержит несколько слов, разделенных пробелом,
и вы должны вернуть строку, содержащую слова из исходного предложения,
длины которых являются простыми числами,
порядок слов в новой строке должен быть таким же, как в исходной.
"""
|
HumanEval/144 | Ваша задача - реализовать функцию, которая упростит выражение x * n. Функция возвращает значение True, если значение x * n равно целому числу, и значение False в противном случае. И x, и n являются строковым представлением дроби и имеют следующий формат:
<числитель>/<знаменатель>, где и числитель, и знаменатель являются целыми положительными числами.
Вы можете предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя.
simplify("1/5", "5/1") = True
simplify("1/6", "2/1") = False
simplify("7/10", "10/2") = False | def simplify(x, n):
"""
Ваша задача - реализовать функцию, которая упростит выражение x * n. Функция возвращает значение True, если значение x * n равно целому числу, и значение False в противном случае. И x, и n являются строковым представлением дроби и имеют следующий формат:
<числитель>/<знаменатель>, где и числитель, и знаменатель являются целыми положительными числами.
Вы можете предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя.
simplify("1/5", "5/1") = True
simplify("1/6", "2/1") = False
simplify("7/10", "10/2") = False
"""
| a, b = x.split("/")
c, d = n.split("/")
numerator = int(a) * int(c)
denom = int(b) * int(d)
if (numerator/denom == int(numerator/denom)):
return True
return False
| def check(candidate):
# Check some simple cases
assert candidate("1/5", "5/1") == True, 'test1'
assert candidate("1/6", "2/1") == False, 'test2'
assert candidate("5/1", "3/1") == True, 'test3'
assert candidate("7/10", "10/2") == False, 'test4'
assert candidate("2/10", "50/10") == True, 'test5'
assert candidate("7/2", "4/2") == True, 'test6'
assert candidate("11/6", "6/1") == True, 'test7'
assert candidate("2/3", "5/2") == False, 'test8'
assert candidate("5/2", "3/5") == False, 'test9'
assert candidate("2/4", "8/4") == True, 'test10'
# Check some edge cases that are easy to work out by hand.
assert candidate("2/4", "4/2") == True, 'test11'
assert candidate("1/5", "5/1") == True, 'test12'
assert candidate("1/5", "1/5") == False, 'test13'
| simplify | simplify(x, n) | def simplify(x, n): | Напишите функцию simplify(x, n) для решения следующей задачи: Ваша задача - реализовать функцию, которая упростит выражение x * n. Функция возвращает значение True, если значение x * n равно целому числу, и значение False в противном случае. И x, и n являются строковым представлением дроби и имеют следующий формат:
<числитель>/<знаменатель>, где и числитель, и знаменатель являются целыми положительными числами.
Вы можете предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя.
simplify("1/5", "5/1") = True
simplify("1/6", "2/1") = False
simplify("7/10", "10/2") = False | Напишите функцию simplify(x, n) для решения следующей задачи: Ваша задача - реализовать функцию, которая упростит выражение x * n. Функция возвращает значение True, если значение x * n равно целому числу, и значение False в противном случае. И x, и n являются строковым представлением дроби и имеют следующий формат:
<числитель>/<знаменатель>, где и числитель, и знаменатель являются целыми положительными числами.
Вы можете предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя. | def simplify(x, n):
"""
Ваша задача - реализовать функцию, которая упростит выражение x * n. Функция возвращает значение True, если значение x * n равно целому числу, и значение False в противном случае. И x, и n являются строковым представлением дроби и имеют следующий формат:
<числитель>/<знаменатель>, где и числитель, и знаменатель являются целыми положительными числами.
Вы можете предположить, что x и n являются допустимыми дробями и не имеют нуля в качестве знаменателя.
"""
|
HumanEval/145 | Напишите функцию, которая сортирует заданный список целых чисел в порядке возрастания по сумме их цифр.
Примечание: если есть несколько элементов с одинаковой суммой цифр,
упорядочьте их на основе их индекса в исходном списке.
Например:
>>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
>>> order_by_points([]) == [] | def order_by_points(nums):
"""
Напишите функцию, которая сортирует заданный список целых чисел в порядке возрастания по сумме их цифр.
Примечание: если есть несколько элементов с одинаковой суммой цифр,
упорядочьте их на основе их индекса в исходном списке.
Например:
>>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
>>> order_by_points([]) == []
"""
| def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return sorted(nums, key=digits_sum)
| def check(candidate):
# Check some simple cases
assert candidate([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
assert candidate([1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46]) == [0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]
assert candidate([]) == []
assert candidate([1, -11, -32, 43, 54, -98, 2, -3]) == [-3, -32, -98, -11, 1, 2, 43, 54]
assert candidate([1,2,3,4,5,6,7,8,9,10,11]) == [1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9]
assert candidate([0,6,6,-76,-21,23,4]) == [-76, -21, 0, 4, 23, 6, 6]
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| order_by_points | order_by_points(nums) | def order_by_points(nums): | Напишите функцию order_by_points(nums) для решения следующей задачи: Напишите функцию, которая сортирует заданный список целых чисел в порядке возрастания по сумме их цифр.
Примечание: если есть несколько элементов с одинаковой суммой цифр,
упорядочьте их на основе их индекса в исходном списке.
Например:
>>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
>>> order_by_points([]) == [] | Напишите функцию order_by_points(nums) для решения следующей задачи: Напишите функцию, которая сортирует заданный список целых чисел в порядке возрастания по сумме их цифр.
Примечание: если есть несколько элементов с одинаковой суммой цифр,
упорядочьте их на основе их индекса в исходном списке.
Например: | def order_by_points(nums):
"""
Напишите функцию, которая сортирует заданный список целых чисел в порядке возрастания по сумме их цифр.
Примечание: если есть несколько элементов с одинаковой суммой цифр,
упорядочьте их на основе их индекса в исходном списке.
Например:
"""
|
HumanEval/146 | Напишите функцию, которая принимает массив чисел в качестве входных данных и возвращает количество элементов в массиве, превышающее 10, причем как первая, так и последняя цифры числа нечетные (1, 3, 5, 7, 9).
Примеры:
specialFilter([15, -73, 14, -15]) => 1
specialFilter([33, -2, -3, 45, 21, 109]) => 2 | def specialFilter(nums):
"""
Напишите функцию, которая принимает массив чисел в качестве входных данных и возвращает количество элементов в массиве, превышающее 10, причем как первая, так и последняя цифры числа нечетные (1, 3, 5, 7, 9).
Примеры:
specialFilter([15, -73, 14, -15]) => 1
specialFilter([33, -2, -3, 45, 21, 109]) => 2
"""
|
count = 0
for num in nums:
if num > 10:
odd_digits = (1, 3, 5, 7, 9)
number_as_string = str(num)
if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:
count += 1
return count
| def check(candidate):
# Check some simple cases
assert candidate([5, -2, 1, -5]) == 0
assert candidate([15, -73, 14, -15]) == 1
assert candidate([33, -2, -3, 45, 21, 109]) == 2
assert candidate([43, -12, 93, 125, 121, 109]) == 4
assert candidate([71, -2, -33, 75, 21, 19]) == 3
# Check some edge cases that are easy to work out by hand.
assert candidate([1]) == 0
assert candidate([]) == 0
| specialFilter | specialFilter(nums) | def specialFilter(nums): | Напишите функцию specialFilter(nums) для решения следующей задачи: Напишите функцию, которая принимает массив чисел в качестве входных данных и возвращает количество элементов в массиве, превышающее 10, причем как первая, так и последняя цифры числа нечетные (1, 3, 5, 7, 9).
Примеры:
specialFilter([15, -73, 14, -15]) => 1
specialFilter([33, -2, -3, 45, 21, 109]) => 2 | Напишите функцию specialFilter(nums) для решения следующей задачи: Напишите функцию, которая принимает массив чисел в качестве входных данных и возвращает количество элементов в массиве, превышающее 10, причем как первая, так и последняя цифры числа нечетные (1, 3, 5, 7, 9). | def specialFilter(nums):
"""
Напишите функцию, которая принимает массив чисел в качестве входных данных и возвращает количество элементов в массиве, превышающее 10, причем как первая, так и последняя цифры числа нечетные (1, 3, 5, 7, 9).
"""
|
HumanEval/147 | Вам задано целое положительное число n. Вы должны создать целочисленный массив a длины n.
Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1.
Возвращает число троек (a[i], a[j], a[k]) из a, где i < j < k,
а a[i] + a[j] + a[k] кратно 3.
Примеры:
Input: n = 5
Output: 1
Explanation:
a = [1, 3, 7, 13, 21]
Единственная подходящая тройка (1, 7, 13). | def get_max_triples(n):
"""
Вам задано целое положительное число n. Вы должны создать целочисленный массив a длины n.
Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1.
Возвращает число троек (a[i], a[j], a[k]) из a, где i < j < k,
а a[i] + a[j] + a[k] кратно 3.
Примеры:
Input: n = 5
Output: 1
Explanation:
a = [1, 3, 7, 13, 21]
Единственная подходящая тройка (1, 7, 13).
"""
| A = [i*i - i + 1 for i in range(1,n+1)]
ans = []
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if (A[i]+A[j]+A[k])%3 == 0:
ans += [(A[i],A[j],A[k])]
return len(ans)
| def check(candidate):
assert candidate(5) == 1
assert candidate(6) == 4
assert candidate(10) == 36
assert candidate(100) == 53361
| get_max_triples | get_max_triples(n) | def get_max_triples(n): | Напишите функцию get_max_triples(n) для решения следующей задачи: Вам задано целое положительное число n. Вы должны создать целочисленный массив a длины n.
Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1.
Возвращает число троек (a[i], a[j], a[k]) из a, где i < j < k,
а a[i] + a[j] + a[k] кратно 3.
Примеры:
Input: n = 5
Output: 1
Explanation:
a = [1, 3, 7, 13, 21]
Единственная подходящая тройка (1, 7, 13). | Напишите функцию get_max_triples(n) для решения следующей задачи: Вам задано целое положительное число n. Вы должны создать целочисленный массив a длины n.
Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1.
Возвращает число троек (a[i], a[j], a[k]) из a, где i < j < k,
а a[i] + a[j] + a[k] кратно 3. | def get_max_triples(n):
"""
Вам задано целое положительное число n. Вы должны создать целочисленный массив a длины n.
Для каждого i (1 ≤ i ≤ n) значение a[i] = i * i - i + 1.
Возвращает число троек (a[i], a[j], a[k]) из a, где i < j < k,
а a[i] + a[j] + a[k] кратно 3.
"""
|
HumanEval/148 | В нашей Солнечной системе восемь планет: самая близкая к Солнцу - Меркурий, следующая - Венера, затем Земля, Марс, Юпитер, Сатурн,
Уран, Нептун (Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune).
Напишите функцию, которая принимает два названия планет в виде строк planet1 и planet2.
Функция должна возвращать кортеж, содержащий все планеты, орбиты которых расположены между орбитой planet1 и орбитой planet2, отсортированные по близости к Солнцу.
Функция должна возвращать пустой кортеж, если planet1 или planet2
- неправильные названия планет.
Примеры:
bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
bf("Earth", "Mercury") ==> ("Venus")
bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn") | def bf(planet1, planet2):
"""
В нашей Солнечной системе восемь планет: самая близкая к Солнцу - Меркурий, следующая - Венера, затем Земля, Марс, Юпитер, Сатурн,
Уран, Нептун (Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune).
Напишите функцию, которая принимает два названия планет в виде строк planet1 и planet2.
Функция должна возвращать кортеж, содержащий все планеты, орбиты которых расположены между орбитой planet1 и орбитой planet2, отсортированные по близости к Солнцу.
Функция должна возвращать пустой кортеж, если planet1 или planet2
- неправильные названия планет.
Примеры:
bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
bf("Earth", "Mercury") ==> ("Venus")
bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
"""
| planet_names = ("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
if planet1 not in planet_names or planet2 not in planet_names or planet1 == planet2:
return ()
planet1_index = planet_names.index(planet1)
planet2_index = planet_names.index(planet2)
if planet1_index < planet2_index:
return (planet_names[planet1_index + 1: planet2_index])
else:
return (planet_names[planet2_index + 1 : planet1_index])
| def check(candidate):
# Check some simple cases
assert candidate("Jupiter", "Neptune") == ("Saturn", "Uranus"), "First test error: " + str(len(candidate("Jupiter", "Neptune")))
assert candidate("Earth", "Mercury") == ("Venus",), "Second test error: " + str(candidate("Earth", "Mercury"))
assert candidate("Mercury", "Uranus") == ("Venus", "Earth", "Mars", "Jupiter", "Saturn"), "Third test error: " + str(candidate("Mercury", "Uranus"))
assert candidate("Neptune", "Venus") == ("Earth", "Mars", "Jupiter", "Saturn", "Uranus"), "Fourth test error: " + str(candidate("Neptune", "Venus"))
# Check some edge cases that are easy to work out by hand.
assert candidate("Earth", "Earth") == ()
assert candidate("Mars", "Earth") == ()
assert candidate("Jupiter", "Makemake") == ()
| bf | bf(planet1, planet2) | def bf(planet1, planet2): | Напишите функцию bf(planet1, planet2) для решения следующей задачи: В нашей Солнечной системе восемь планет: самая близкая к Солнцу - Меркурий, следующая - Венера, затем Земля, Марс, Юпитер, Сатурн,
Уран, Нептун (Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune).
Напишите функцию, которая принимает два названия планет в виде строк planet1 и planet2.
Функция должна возвращать кортеж, содержащий все планеты, орбиты которых расположены между орбитой planet1 и орбитой planet2, отсортированные по близости к Солнцу.
Функция должна возвращать пустой кортеж, если planet1 или planet2
- неправильные названия планет.
Примеры:
bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
bf("Earth", "Mercury") ==> ("Venus")
bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn") | Напишите функцию bf(planet1, planet2) для решения следующей задачи: В нашей Солнечной системе восемь планет: самая близкая к Солнцу - Меркурий, следующая - Венера, затем Земля, Марс, Юпитер, Сатурн,
Уран, Нептун (Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune).
Напишите функцию, которая принимает два названия планет в виде строк planet1 и planet2.
Функция должна возвращать кортеж, содержащий все планеты, орбиты которых расположены между орбитой planet1 и орбитой planet2, отсортированные по близости к Солнцу.
Функция должна возвращать пустой кортеж, если planet1 или planet2
- неправильные названия планет. | def bf(planet1, planet2):
"""
В нашей Солнечной системе восемь планет: самая близкая к Солнцу - Меркурий, следующая - Венера, затем Земля, Марс, Юпитер, Сатурн,
Уран, Нептун (Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune).
Напишите функцию, которая принимает два названия планет в виде строк planet1 и planet2.
Функция должна возвращать кортеж, содержащий все планеты, орбиты которых расположены между орбитой planet1 и орбитой planet2, отсортированные по близости к Солнцу.
Функция должна возвращать пустой кортеж, если planet1 или planet2
- неправильные названия планет.
"""
|
HumanEval/149 | Напишите функцию, которая принимает список строк в качестве параметра,
удаляет из него строки нечетной длины
и возвращает результирующий список в отсортированном порядке,
Список всегда представляет собой список строк и никогда не является массивом чисел,
и он может содержать дубликаты.
Порядок в списке должен быть по возрастанию длины каждого слова, и вы должны вернуть список, отсортированный по этому правилу.
Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке.
Функция должна возвращать список строк в отсортированном порядке.
Вы можете предположить, что все слова будут иметь одинаковую длину.
Примеры:
assert list_sort(["aa", "a", "aaa"]) => ["aa"]
assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"] | def sorted_list_sum(lst):
"""
Напишите функцию, которая принимает список строк в качестве параметра,
удаляет из него строки нечетной длины
и возвращает результирующий список в отсортированном порядке,
Список всегда представляет собой список строк и никогда не является массивом чисел,
и он может содержать дубликаты.
Порядок в списке должен быть по возрастанию длины каждого слова, и вы должны вернуть список, отсортированный по этому правилу.
Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке.
Функция должна возвращать список строк в отсортированном порядке.
Вы можете предположить, что все слова будут иметь одинаковую длину.
Примеры:
assert list_sort(["aa", "a", "aaa"]) => ["aa"]
assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
"""
| lst.sort()
new_lst = []
for i in lst:
if len(i)%2 == 0:
new_lst.append(i)
return sorted(new_lst, key=len)
| def check(candidate):
# Check some simple cases
assert candidate(["aa", "a", "aaa"]) == ["aa"]
assert candidate(["school", "AI", "asdf", "b"]) == ["AI", "asdf", "school"]
assert candidate(["d", "b", "c", "a"]) == []
assert candidate(["d", "dcba", "abcd", "a"]) == ["abcd", "dcba"]
# Check some edge cases that are easy to work out by hand.
assert candidate(["AI", "ai", "au"]) == ["AI", "ai", "au"]
assert candidate(["a", "b", "b", "c", "c", "a"]) == []
assert candidate(['aaaa', 'bbbb', 'dd', 'cc']) == ["cc", "dd", "aaaa", "bbbb"]
| sorted_list_sum | sorted_list_sum(lst) | def sorted_list_sum(lst): | Напишите функцию sorted_list_sum(lst) для решения следующей задачи: Напишите функцию, которая принимает список строк в качестве параметра,
удаляет из него строки нечетной длины
и возвращает результирующий список в отсортированном порядке,
Список всегда представляет собой список строк и никогда не является массивом чисел,
и он может содержать дубликаты.
Порядок в списке должен быть по возрастанию длины каждого слова, и вы должны вернуть список, отсортированный по этому правилу.
Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке.
Функция должна возвращать список строк в отсортированном порядке.
Вы можете предположить, что все слова будут иметь одинаковую длину.
Примеры:
assert list_sort(["aa", "a", "aaa"]) => ["aa"]
assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"] | Напишите функцию sorted_list_sum(lst) для решения следующей задачи: Напишите функцию, которая принимает список строк в качестве параметра,
удаляет из него строки нечетной длины
и возвращает результирующий список в отсортированном порядке,
Список всегда представляет собой список строк и никогда не является массивом чисел,
и он может содержать дубликаты.
Порядок в списке должен быть по возрастанию длины каждого слова, и вы должны вернуть список, отсортированный по этому правилу.
Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке.
Функция должна возвращать список строк в отсортированном порядке.
Вы можете предположить, что все слова будут иметь одинаковую длину. | def sorted_list_sum(lst):
"""
Напишите функцию, которая принимает список строк в качестве параметра,
удаляет из него строки нечетной длины
и возвращает результирующий список в отсортированном порядке,
Список всегда представляет собой список строк и никогда не является массивом чисел,
и он может содержать дубликаты.
Порядок в списке должен быть по возрастанию длины каждого слова, и вы должны вернуть список, отсортированный по этому правилу.
Если два слова имеют одинаковую длину, отсортируйте список в алфавитном порядке.
Функция должна возвращать список строк в отсортированном порядке.
Вы можете предположить, что все слова будут иметь одинаковую длину.
"""
|
HumanEval/150 | Простая программа, которая должна возвращать значение x, если n - простое число, и должна возвращать значение y в противном случае.
Примеры:
for x_or_y(7, 34, 12) == 34
for x_or_y(15, 8, 5) == 5 | def x_or_y(n, x, y):
"""
Простая программа, которая должна возвращать значение x, если n - простое число, и должна возвращать значение y в противном случае.
Примеры:
for x_or_y(7, 34, 12) == 34
for x_or_y(15, 8, 5) == 5
"""
| if n == 1:
return y
for i in range(2, n):
if n % i == 0:
return y
break
else:
return x
| def check(candidate):
# Check some simple cases
assert candidate(7, 34, 12) == 34
assert candidate(15, 8, 5) == 5
assert candidate(3, 33, 5212) == 33
assert candidate(1259, 3, 52) == 3
assert candidate(7919, -1, 12) == -1
assert candidate(3609, 1245, 583) == 583
assert candidate(91, 56, 129) == 129
assert candidate(6, 34, 1234) == 1234
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 2, 0) == 0
assert candidate(2, 2, 0) == 2
| x_or_y | x_or_y(n, x, y) | def x_or_y(n, x, y): | Напишите функцию x_or_y(n, x, y) для решения следующей задачи: Простая программа, которая должна возвращать значение x, если n - простое число, и должна возвращать значение y в противном случае.
Примеры:
for x_or_y(7, 34, 12) == 34
for x_or_y(15, 8, 5) == 5 | Напишите функцию x_or_y(n, x, y) для решения следующей задачи: Простая программа, которая должна возвращать значение x, если n - простое число, и должна возвращать значение y в противном случае. | def x_or_y(n, x, y):
"""
Простая программа, которая должна возвращать значение x, если n - простое число, и должна возвращать значение y в противном случае.
"""
|
HumanEval/151 | Дан список чисел, верните сумму квадратов нечетных чисел в списке. Игнорируйте числа, которые являются отрицательными или нецелыми.
double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
double_the_difference([-1, -2, 0]) == 0
double_the_difference([9, -2]) == 81
double_the_difference([0]) == 0
Если список ввода пуст, верните 0. | def double_the_difference(lst):
"""
Дан список чисел, верните сумму квадратов нечетных чисел в списке. Игнорируйте числа, которые являются отрицательными или нецелыми.
double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
double_the_difference([-1, -2, 0]) == 0
double_the_difference([9, -2]) == 81
double_the_difference([0]) == 0
Если список ввода пуст, верните 0.
"""
| return sum([i**2 for i in lst if i > 0 and i%2!=0 and "." not in str(i)])
| def check(candidate):
# Check some simple cases
assert candidate([]) == 0 , "This prints if this assert fails 1 (good for debugging!)"
assert candidate([5, 4]) == 25 , "This prints if this assert fails 2 (good for debugging!)"
assert candidate([0.1, 0.2, 0.3]) == 0 , "This prints if this assert fails 3 (good for debugging!)"
assert candidate([-10, -20, -30]) == 0 , "This prints if this assert fails 4 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([-1, -2, 8]) == 0, "This prints if this assert fails 5 (also good for debugging!)"
assert candidate([0.2, 3, 5]) == 34, "This prints if this assert fails 6 (also good for debugging!)"
lst = list(range(-99, 100, 2))
odd_sum = sum([i**2 for i in lst if i%2!=0 and i > 0])
assert candidate(lst) == odd_sum , "This prints if this assert fails 7 (good for debugging!)"
| double_the_difference | double_the_difference(lst) | def double_the_difference(lst): | Напишите функцию double_the_difference(lst) для решения следующей задачи: Дан список чисел, верните сумму квадратов нечетных чисел в списке. Игнорируйте числа, которые являются отрицательными или нецелыми.
double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
double_the_difference([-1, -2, 0]) == 0
double_the_difference([9, -2]) == 81
double_the_difference([0]) == 0
Если список ввода пуст, верните 0. | Напишите функцию double_the_difference(lst) для решения следующей задачи: Дан список чисел, верните сумму квадратов нечетных чисел в списке. Игнорируйте числа, которые являются отрицательными или нецелыми. | def double_the_difference(lst):
"""
Дан список чисел, верните сумму квадратов нечетных чисел в списке. Игнорируйте числа, которые являются отрицательными или нецелыми.
"""
|
HumanEval/152 | Я думаю, мы все помним это чувство, когда наконец известен результат какого-то долгожданного события. Чувства и мысли, которые вы испытываете в этот момент, определенно заслуживают того, чтобы их записать и сравнить.
Ваша задача состоит в том, чтобы определить, правильно ли человек угадал результаты ряда матчей.
Вам даны два массива оценок и предположений одинаковой длины, где каждый индекс соответсвует матчу
Возвращает массив той же длины, обозначающий, насколько ошибочным было каждое предположение. Если они угадали правильно,
то значение равно 0, а если нет, то значение представляет собой абсолютную разницу между предположением и результатом.
Примеры:
compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6] | def compare(game,guess):
"""
Я думаю, мы все помним это чувство, когда наконец известен результат какого-то долгожданного события. Чувства и мысли, которые вы испытываете в этот момент, определенно заслуживают того, чтобы их записать и сравнить.
Ваша задача состоит в том, чтобы определить, правильно ли человек угадал результаты ряда матчей.
Вам даны два массива оценок и предположений одинаковой длины, где каждый индекс соответсвует матчу
Возвращает массив той же длины, обозначающий, насколько ошибочным было каждое предположение. Если они угадали правильно,
то значение равно 0, а если нет, то значение представляет собой абсолютную разницу между предположением и результатом.
Примеры:
compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
"""
| return [abs(x-y) for x,y in zip(game,guess)]
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3,4,5,1],[1,2,3,4,2,-2])==[0,0,0,0,3,3], "This prints if this assert fails 1 (good for debugging!)"
assert candidate([0,0,0,0,0,0],[0,0,0,0,0,0])==[0,0,0,0,0,0], "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,2,3],[-1,-2,-3])==[2,4,6], "This prints if this assert fails 1 (good for debugging!)"
assert candidate([1,2,3,5],[-1,2,3,4])==[2,0,0,1], "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| compare | compare(game,guess) | def compare(game,guess): | Напишите функцию compare(game,guess) для решения следующей задачи: Я думаю, мы все помним это чувство, когда наконец известен результат какого-то долгожданного события. Чувства и мысли, которые вы испытываете в этот момент, определенно заслуживают того, чтобы их записать и сравнить.
Ваша задача состоит в том, чтобы определить, правильно ли человек угадал результаты ряда матчей.
Вам даны два массива оценок и предположений одинаковой длины, где каждый индекс соответсвует матчу
Возвращает массив той же длины, обозначающий, насколько ошибочным было каждое предположение. Если они угадали правильно,
то значение равно 0, а если нет, то значение представляет собой абсолютную разницу между предположением и результатом.
Примеры:
compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6] | Напишите функцию compare(game,guess) для решения следующей задачи: Я думаю, мы все помним это чувство, когда наконец известен результат какого-то долгожданного события. Чувства и мысли, которые вы испытываете в этот момент, определенно заслуживают того, чтобы их записать и сравнить.
Ваша задача состоит в том, чтобы определить, правильно ли человек угадал результаты ряда матчей.
Вам даны два массива оценок и предположений одинаковой длины, где каждый индекс соответсвует матчу
Возвращает массив той же длины, обозначающий, насколько ошибочным было каждое предположение. Если они угадали правильно,
то значение равно 0, а если нет, то значение представляет собой абсолютную разницу между предположением и результатом. | def compare(game,guess):
"""
Я думаю, мы все помним это чувство, когда наконец известен результат какого-то долгожданного события. Чувства и мысли, которые вы испытываете в этот момент, определенно заслуживают того, чтобы их записать и сравнить.
Ваша задача состоит в том, чтобы определить, правильно ли человек угадал результаты ряда матчей.
Вам даны два массива оценок и предположений одинаковой длины, где каждый индекс соответсвует матчу
Возвращает массив той же длины, обозначающий, насколько ошибочным было каждое предположение. Если они угадали правильно,
то значение равно 0, а если нет, то значение представляет собой абсолютную разницу между предположением и результатом.
"""
|
HumanEval/153 | Вам дано имя класса (строка) и список расширений.
Расширения должны использоваться для загрузки дополнительных классов в класс. Сила расширения определяется следующим образом: пусть CAP - количество заглавных букв в названии расширения, и пусть SM - количество строчных букв в названии расширения, сила задается дробью CAP - SM.
Вы должны найти самое сильное расширение и вернуть строку в формате: className.Имя самого сильного расширения.
Если есть два или более расширений с одинаковой мощностью, вам следует выбрать то, которое стоит первым в списке.
Примеры:
, дан класс "Slices" и список расширений: ['SErviNGSliCes', 'Cheese', 'StuFfed'] вы должны вернуть'Slices.SErviNGSliCes' , так как 'SErviNGSliCes' - само сильное (его сила равна -1).
Пример:
for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA' | def Strongest_Extension(class_name, extensions):
"""
Вам дано имя класса (строка) и список расширений.
Расширения должны использоваться для загрузки дополнительных классов в класс. Сила расширения определяется следующим образом: пусть CAP - количество заглавных букв в названии расширения, и пусть SM - количество строчных букв в названии расширения, сила задается дробью CAP - SM.
Вы должны найти самое сильное расширение и вернуть строку в формате: className.Имя самого сильного расширения.
Если есть два или более расширений с одинаковой мощностью, вам следует выбрать то, которое стоит первым в списке.
Примеры:
, дан класс "Slices" и список расширений: ['SErviNGSliCes', 'Cheese', 'StuFfed'] вы должны вернуть'Slices.SErviNGSliCes' , так как 'SErviNGSliCes' - само сильное (его сила равна -1).
Пример:
for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
"""
| strong = extensions[0]
my_val = len([x for x in extensions[0] if x.isalpha() and x.isupper()]) - len([x for x in extensions[0] if x.isalpha() and x.islower()])
for s in extensions:
val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])
if val > my_val:
strong = s
my_val = val
ans = class_name + "." + strong
return ans
| def check(candidate):
# Check some simple cases
assert candidate('Watashi', ['tEN', 'niNE', 'eIGHt8OKe']) == 'Watashi.eIGHt8OKe'
assert candidate('Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg']) == 'Boku123.YEs.WeCaNe'
assert candidate('__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321']) == '__YESIMHERE.NuLl__'
assert candidate('K', ['Ta', 'TAR', 't234An', 'cosSo']) == 'K.TAR'
assert candidate('__HAHA', ['Tab', '123', '781345', '-_-']) == '__HAHA.123'
assert candidate('YameRore', ['HhAas', 'okIWILL123', 'WorkOut', 'Fails', '-_-']) == 'YameRore.okIWILL123'
assert candidate('finNNalLLly', ['Die', 'NowW', 'Wow', 'WoW']) == 'finNNalLLly.WoW'
# Check some edge cases that are easy to work out by hand.
assert candidate('_', ['Bb', '91245']) == '_.Bb'
assert candidate('Sp', ['671235', 'Bb']) == 'Sp.671235'
| Strongest_Extension | Strongest_Extension(class_name, extensions) | def Strongest_Extension(class_name, extensions): | Напишите функцию Strongest_Extension(class_name, extensions) для решения следующей задачи: Вам дано имя класса (строка) и список расширений.
Расширения должны использоваться для загрузки дополнительных классов в класс. Сила расширения определяется следующим образом: пусть CAP - количество заглавных букв в названии расширения, и пусть SM - количество строчных букв в названии расширения, сила задается дробью CAP - SM.
Вы должны найти самое сильное расширение и вернуть строку в формате: className.Имя самого сильного расширения.
Если есть два или более расширений с одинаковой мощностью, вам следует выбрать то, которое стоит первым в списке.
Примеры:
, дан класс "Slices" и список расширений: ['SErviNGSliCes', 'Cheese', 'StuFfed'] вы должны вернуть'Slices.SErviNGSliCes' , так как 'SErviNGSliCes' - само сильное (его сила равна -1).
Пример:
for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA' | Напишите функцию Strongest_Extension(class_name, extensions) для решения следующей задачи: Вам дано имя класса (строка) и список расширений.
Расширения должны использоваться для загрузки дополнительных классов в класс. Сила расширения определяется следующим образом: пусть CAP - количество заглавных букв в названии расширения, и пусть SM - количество строчных букв в названии расширения, сила задается дробью CAP - SM.
Вы должны найти самое сильное расширение и вернуть строку в формате: className.Имя самого сильного расширения.
Если есть два или более расширений с одинаковой мощностью, вам следует выбрать то, которое стоит первым в списке. | def Strongest_Extension(class_name, extensions):
"""
Вам дано имя класса (строка) и список расширений.
Расширения должны использоваться для загрузки дополнительных классов в класс. Сила расширения определяется следующим образом: пусть CAP - количество заглавных букв в названии расширения, и пусть SM - количество строчных букв в названии расширения, сила задается дробью CAP - SM.
Вы должны найти самое сильное расширение и вернуть строку в формате: className.Имя самого сильного расширения.
Если есть два или более расширений с одинаковой мощностью, вам следует выбрать то, которое стоит первым в списке.
"""
|
HumanEval/154 | Вам дается 2 слова. Вам нужно вернуть True, если второе слово или любой из его вариантов является подстрокой в первом слове
cycpattern_check("abcd","abd") => False
cycpattern_check("hello","ell") => True
cycpattern_check("whassup","psus") => False
cycpattern_check("abab","baa") => True
cycpattern_check("efef","eeff") => False
cycpattern_check("himenss","simen") => True | def cycpattern_check(a , b):
"""
Вам дается 2 слова. Вам нужно вернуть True, если второе слово или любой из его вариантов является подстрокой в первом слове
cycpattern_check("abcd","abd") => False
cycpattern_check("hello","ell") => True
cycpattern_check("whassup","psus") => False
cycpattern_check("abab","baa") => True
cycpattern_check("efef","eeff") => False
cycpattern_check("himenss","simen") => True
"""
| l = len(b)
pat = b + b
for i in range(len(a) - l + 1):
for j in range(l + 1):
if a[i:i+l] == pat[j:j+l]:
return True
return False
| def check(candidate):
# Check some simple cases
#assert True, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
#assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate("xyzw","xyw") == False , "test #0"
assert candidate("yello","ell") == True , "test #1"
assert candidate("whattup","ptut") == False , "test #2"
assert candidate("efef","fee") == True , "test #3"
assert candidate("abab","aabb") == False , "test #4"
assert candidate("winemtt","tinem") == True , "test #5"
| cycpattern_check | cycpattern_check(a , b) | def cycpattern_check(a , b): | Напишите функцию cycpattern_check(a , b) для решения следующей задачи: Вам дается 2 слова. Вам нужно вернуть True, если второе слово или любой из его вариантов является подстрокой в первом слове
cycpattern_check("abcd","abd") => False
cycpattern_check("hello","ell") => True
cycpattern_check("whassup","psus") => False
cycpattern_check("abab","baa") => True
cycpattern_check("efef","eeff") => False
cycpattern_check("himenss","simen") => True | Напишите функцию cycpattern_check(a , b) для решения следующей задачи: Вам дается 2 слова. Вам нужно вернуть True, если второе слово или любой из его вариантов является подстрокой в первом слове | def cycpattern_check(a , b):
"""
Вам дается 2 слова. Вам нужно вернуть True, если второе слово или любой из его вариантов является подстрокой в первом слове
"""
|
HumanEval/155 | Задано целое число. возвращает кортеж, содержащий количество четных и нечетных цифр соответственно.
Примеры:
even_odd_count(-12) ==> (1, 1)
even_odd_count(123) ==> (1, 2) | def even_odd_count(num):
"""
Задано целое число. возвращает кортеж, содержащий количество четных и нечетных цифр соответственно.
Примеры:
even_odd_count(-12) ==> (1, 1)
even_odd_count(123) ==> (1, 2)
"""
| even_count = 0
odd_count = 0
for i in str(abs(num)):
if int(i)%2==0:
even_count +=1
else:
odd_count +=1
return (even_count, odd_count)
| def check(candidate):
# Check some simple cases
assert candidate(7) == (0, 1)
assert candidate(-78) == (1, 1)
assert candidate(3452) == (2, 2)
assert candidate(346211) == (3, 3)
assert candidate(-345821) == (3, 3)
assert candidate(-2) == (1, 0)
assert candidate(-45347) == (2, 3)
assert candidate(0) == (1, 0)
# Check some edge cases that are easy to work out by hand.
assert True
| even_odd_count | even_odd_count(num) | def even_odd_count(num): | Напишите функцию even_odd_count(num) для решения следующей задачи: Задано целое число. возвращает кортеж, содержащий количество четных и нечетных цифр соответственно.
Примеры:
even_odd_count(-12) ==> (1, 1)
even_odd_count(123) ==> (1, 2) | Напишите функцию even_odd_count(num) для решения следующей задачи: Задано целое число. возвращает кортеж, содержащий количество четных и нечетных цифр соответственно. | def even_odd_count(num):
"""
Задано целое число. возвращает кортеж, содержащий количество четных и нечетных цифр соответственно.
"""
|
HumanEval/156 | Дано положительное целое число, получите его эквивалент в виде римской цифры типа строка
и верните его в нижнем регистре.
Ограничения: 1 <= число <= 1000
Примеры:
>>> int_to_mini_roman(19) == 'xix'
>>> int_to_mini_roman(152) == 'clii'
>>> int_to_mini_roman(426) == 'cdxxvi' | def int_to_mini_roman(number):
"""
Дано положительное целое число, получите его эквивалент в виде римской цифры типа строка
и верните его в нижнем регистре.
Ограничения: 1 <= число <= 1000
Примеры:
>>> int_to_mini_roman(19) == 'xix'
>>> int_to_mini_roman(152) == 'clii'
>>> int_to_mini_roman(426) == 'cdxxvi'
"""
| num = [1, 4, 5, 9, 10, 40, 50, 90,
100, 400, 500, 900, 1000]
sym = ["I", "IV", "V", "IX", "X", "XL",
"L", "XC", "C", "CD", "D", "CM", "M"]
i = 12
res = ''
while number:
div = number // num[i]
number %= num[i]
while div:
res += sym[i]
div -= 1
i -= 1
return res.lower()
| def check(candidate):
# Check some simple cases
assert candidate(19) == 'xix'
assert candidate(152) == 'clii'
assert candidate(251) == 'ccli'
assert candidate(426) == 'cdxxvi'
assert candidate(500) == 'd'
assert candidate(1) == 'i'
assert candidate(4) == 'iv'
assert candidate(43) == 'xliii'
assert candidate(90) == 'xc'
assert candidate(94) == 'xciv'
assert candidate(532) == 'dxxxii'
assert candidate(900) == 'cm'
assert candidate(994) == 'cmxciv'
assert candidate(1000) == 'm'
# Check some edge cases that are easy to work out by hand.
assert True
| int_to_mini_roman | int_to_mini_roman(number) | def int_to_mini_roman(number): | Напишите функцию int_to_mini_roman(number) для решения следующей задачи: Дано положительное целое число, получите его эквивалент в виде римской цифры типа строка
и верните его в нижнем регистре.
Ограничения: 1 <= число <= 1000
Примеры:
>>> int_to_mini_roman(19) == 'xix'
>>> int_to_mini_roman(152) == 'clii'
>>> int_to_mini_roman(426) == 'cdxxvi' | Напишите функцию int_to_mini_roman(number) для решения следующей задачи: Дано положительное целое число, получите его эквивалент в виде римской цифры типа строка
и верните его в нижнем регистре.
Ограничения: 1 <= число <= 1000
Примеры: | def int_to_mini_roman(number):
"""
Дано положительное целое число, получите его эквивалент в виде римской цифры типа строка
и верните его в нижнем регистре.
Ограничения: 1 <= число <= 1000
Примеры:
"""
|
HumanEval/157 | Даны длины трех сторон треугольника. Возвращает значение True, если три стороны образуют прямоугольный треугольник, в противном случае значение False.
Прямоугольный треугольник - это треугольник, в котором один угол равен прямому углу или 90 градусам.
Примеры:
right_angle_triangle(3, 4, 5) == True
right_angle_triangle(1, 2, 3) == False | def right_angle_triangle(a, b, c):
"""
Даны длины трех сторон треугольника. Возвращает значение True, если три стороны образуют прямоугольный треугольник, в противном случае значение False.
Прямоугольный треугольник - это треугольник, в котором один угол равен прямому углу или 90 градусам.
Примеры:
right_angle_triangle(3, 4, 5) == True
right_angle_triangle(1, 2, 3) == False
"""
| return a*a == b*b + c*c or b*b == a*a + c*c or c*c == a*a + b*b
| def check(candidate):
# Check some simple cases
assert candidate(3, 4, 5) == True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1, 2, 3) == False
assert candidate(10, 6, 8) == True
assert candidate(2, 2, 2) == False
assert candidate(7, 24, 25) == True
assert candidate(10, 5, 7) == False
assert candidate(5, 12, 13) == True
assert candidate(15, 8, 17) == True
assert candidate(48, 55, 73) == True
# Check some edge cases that are easy to work out by hand.
assert candidate(1, 1, 1) == False, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(2, 2, 10) == False
| right_angle_triangle | right_angle_triangle(a, b, c) | def right_angle_triangle(a, b, c): | Напишите функцию right_angle_triangle(a, b, c) для решения следующей задачи: Даны длины трех сторон треугольника. Возвращает значение True, если три стороны образуют прямоугольный треугольник, в противном случае значение False.
Прямоугольный треугольник - это треугольник, в котором один угол равен прямому углу или 90 градусам.
Примеры:
right_angle_triangle(3, 4, 5) == True
right_angle_triangle(1, 2, 3) == False | Напишите функцию right_angle_triangle(a, b, c) для решения следующей задачи: Даны длины трех сторон треугольника. Возвращает значение True, если три стороны образуют прямоугольный треугольник, в противном случае значение False.
Прямоугольный треугольник - это треугольник, в котором один угол равен прямому углу или 90 градусам. | def right_angle_triangle(a, b, c):
"""
Даны длины трех сторон треугольника. Возвращает значение True, если три стороны образуют прямоугольный треугольник, в противном случае значение False.
Прямоугольный треугольник - это треугольник, в котором один угол равен прямому углу или 90 градусам.
"""
|
HumanEval/158 | Напишите функцию, которая принимает список строк.
Список содержит разные слова. Верните слово с максимальным количеством уникальных символов. Если несколько строк содержат максимальное количество уникальных символов, верните тот, который стоит первым в лексикографическом порядке.
find_max(["name", "of", "string"]) == "string"
find_max(["name", "enam", "game"]) == "enam"
find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa" | def find_max(words):
"""
Напишите функцию, которая принимает список строк.
Список содержит разные слова. Верните слово с максимальным количеством уникальных символов. Если несколько строк содержат максимальное количество уникальных символов, верните тот, который стоит первым в лексикографическом порядке.
find_max(["name", "of", "string"]) == "string"
find_max(["name", "enam", "game"]) == "enam"
find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
"""
| return sorted(words, key = lambda x: (-len(set(x)), x))[0]
| def check(candidate):
# Check some simple cases
assert (candidate(["name", "of", "string"]) == "string"), "t1"
assert (candidate(["name", "enam", "game"]) == "enam"), 't2'
assert (candidate(["aaaaaaa", "bb", "cc"]) == "aaaaaaa"), 't3'
assert (candidate(["abc", "cba"]) == "abc"), 't4'
assert (candidate(["play", "this", "game", "of","footbott"]) == "footbott"), 't5'
assert (candidate(["we", "are", "gonna", "rock"]) == "gonna"), 't6'
assert (candidate(["we", "are", "a", "mad", "nation"]) == "nation"), 't7'
assert (candidate(["this", "is", "a", "prrk"]) == "this"), 't8'
# Check some edge cases that are easy to work out by hand.
assert (candidate(["b"]) == "b"), 't9'
assert (candidate(["play", "play", "play"]) == "play"), 't10'
| find_max | find_max(words) | def find_max(words): | Напишите функцию find_max(words) для решения следующей задачи: Напишите функцию, которая принимает список строк.
Список содержит разные слова. Верните слово с максимальным количеством уникальных символов. Если несколько строк содержат максимальное количество уникальных символов, верните тот, который стоит первым в лексикографическом порядке.
find_max(["name", "of", "string"]) == "string"
find_max(["name", "enam", "game"]) == "enam"
find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa" | Напишите функцию find_max(words) для решения следующей задачи: Напишите функцию, которая принимает список строк.
Список содержит разные слова. Верните слово с максимальным количеством уникальных символов. Если несколько строк содержат максимальное количество уникальных символов, верните тот, который стоит первым в лексикографическом порядке. | def find_max(words):
"""
Напишите функцию, которая принимает список строк.
Список содержит разные слова. Верните слово с максимальным количеством уникальных символов. Если несколько строк содержат максимальное количество уникальных символов, верните тот, который стоит первым в лексикографическом порядке.
"""
|
HumanEval/159 | Вы голодный кролик, и вы уже съели определенное количество моркови,
но теперь вам нужно съесть еще моркови, чтобы завершить дневной рацион.
вы должны вернуть массив [общее количество съеденной моркови после приема пищи,
количество морковок, оставшихся после приема пищи ]
если оставшейся моркови недостаточно, вы съедите всю оставшуюся морковь, но все равно будете голодны.
Примеры:
* eat(5, 6, 10) -> [11, 4]
* eat(4, 8, 9) -> [12, 1]
* eat(1, 10, 10) -> [11, 0]
* eat(2, 11, 5) -> [7, 0]
Параметры:
@number : число морковок, которые вы съели.
@need : число морковок, которое вам необходимо съесть.
@remaining : число морковок в наличии
Ограничения:
* 0 <= number <= 1000
* 0 <= need <= 1000
* 0 <= remaining <= 1000 | def eat(number, need, remaining):
"""
Вы голодный кролик, и вы уже съели определенное количество моркови,
но теперь вам нужно съесть еще моркови, чтобы завершить дневной рацион.
вы должны вернуть массив [общее количество съеденной моркови после приема пищи,
количество морковок, оставшихся после приема пищи ]
если оставшейся моркови недостаточно, вы съедите всю оставшуюся морковь, но все равно будете голодны.
Примеры:
* eat(5, 6, 10) -> [11, 4]
* eat(4, 8, 9) -> [12, 1]
* eat(1, 10, 10) -> [11, 0]
* eat(2, 11, 5) -> [7, 0]
Параметры:
@number : число морковок, которые вы съели.
@need : число морковок, которое вам необходимо съесть.
@remaining : число морковок в наличии
Ограничения:
* 0 <= number <= 1000
* 0 <= need <= 1000
* 0 <= remaining <= 1000
"""
| if(need <= remaining):
return [ number + need , remaining-need ]
else:
return [ number + remaining , 0]
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(5, 6, 10) == [11, 4], "Error"
assert candidate(4, 8, 9) == [12, 1], "Error"
assert candidate(1, 10, 10) == [11, 0], "Error"
assert candidate(2, 11, 5) == [7, 0], "Error"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
assert candidate(4, 5, 7) == [9, 2], "Error"
assert candidate(4, 5, 1) == [5, 0], "Error"
| eat | eat(number, need, remaining) | def eat(number, need, remaining): | Напишите функцию eat(number, need, remaining) для решения следующей задачи: Вы голодный кролик, и вы уже съели определенное количество моркови,
но теперь вам нужно съесть еще моркови, чтобы завершить дневной рацион.
вы должны вернуть массив [общее количество съеденной моркови после приема пищи,
количество морковок, оставшихся после приема пищи ]
если оставшейся моркови недостаточно, вы съедите всю оставшуюся морковь, но все равно будете голодны.
Примеры:
* eat(5, 6, 10) -> [11, 4]
* eat(4, 8, 9) -> [12, 1]
* eat(1, 10, 10) -> [11, 0]
* eat(2, 11, 5) -> [7, 0]
Параметры:
@number : число морковок, которые вы съели.
@need : число морковок, которое вам необходимо съесть.
@remaining : число морковок в наличии
Ограничения:
* 0 <= number <= 1000
* 0 <= need <= 1000
* 0 <= remaining <= 1000 | Напишите функцию eat(number, need, remaining) для решения следующей задачи: Вы голодный кролик, и вы уже съели определенное количество моркови,
но теперь вам нужно съесть еще моркови, чтобы завершить дневной рацион.
вы должны вернуть массив [общее количество съеденной моркови после приема пищи,
количество морковок, оставшихся после приема пищи ]
если оставшейся моркови недостаточно, вы съедите всю оставшуюся морковь, но все равно будете голодны. | def eat(number, need, remaining):
"""
Вы голодный кролик, и вы уже съели определенное количество моркови,
но теперь вам нужно съесть еще моркови, чтобы завершить дневной рацион.
вы должны вернуть массив [общее количество съеденной моркови после приема пищи,
количество морковок, оставшихся после приема пищи ]
если оставшейся моркови недостаточно, вы съедите всю оставшуюся морковь, но все равно будете голодны.
"""
|
HumanEval/160 | Даны два списка операторов и операндов. Первый список содержит основные операции алгебры, а второй список - это список целых чисел. Используйте два приведенных списка для построения алгебраического выражения и возврата вычисления этого выражения.
Основные операции с алгеброй:
Дополнение ( + )
Вычитание ( - )
Умножение ( * )
Целое деление ( // )
Возведение в степень ( ** )
Примеры:
operator['+', '*', '-']
array = [2, 3, 4, 5]
result = 2 + 3 * 4 - 5
=> result = 9
Примечание:
Длина списка операторов равна длине списка операндов минус один.
Операнд - это список неотрицательных целых чисел.
Список операторов содержит по крайней мере один оператор, а список операндов содержит по крайней мере два операнда. | def do_algebra(operator, operand):
"""
Даны два списка операторов и операндов. Первый список содержит основные операции алгебры, а второй список - это список целых чисел. Используйте два приведенных списка для построения алгебраического выражения и возврата вычисления этого выражения.
Основные операции с алгеброй:
Дополнение ( + )
Вычитание ( - )
Умножение ( * )
Целое деление ( // )
Возведение в степень ( ** )
Примеры:
operator['+', '*', '-']
array = [2, 3, 4, 5]
result = 2 + 3 * 4 - 5
=> result = 9
Примечание:
Длина списка операторов равна длине списка операндов минус один.
Операнд - это список неотрицательных целых чисел.
Список операторов содержит по крайней мере один оператор, а список операндов содержит по крайней мере два операнда.
"""
| expression = str(operand[0])
for oprt, oprn in zip(operator, operand[1:]):
expression+= oprt + str(oprn)
return eval(expression)
| def check(candidate):
# Check some simple cases
assert candidate(['**', '*', '+'], [2, 3, 4, 5]) == 37
assert candidate(['+', '*', '-'], [2, 3, 4, 5]) == 9
assert candidate(['//', '*'], [7, 3, 4]) == 8, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| do_algebra | do_algebra(operator, operand) | def do_algebra(operator, operand): | Напишите функцию do_algebra(operator, operand) для решения следующей задачи: Даны два списка операторов и операндов. Первый список содержит основные операции алгебры, а второй список - это список целых чисел. Используйте два приведенных списка для построения алгебраического выражения и возврата вычисления этого выражения.
Основные операции с алгеброй:
Дополнение ( + )
Вычитание ( - )
Умножение ( * )
Целое деление ( // )
Возведение в степень ( ** )
Примеры:
operator['+', '*', '-']
array = [2, 3, 4, 5]
result = 2 + 3 * 4 - 5
=> result = 9
Примечание:
Длина списка операторов равна длине списка операндов минус один.
Операнд - это список неотрицательных целых чисел.
Список операторов содержит по крайней мере один оператор, а список операндов содержит по крайней мере два операнда. | Напишите функцию do_algebra(operator, operand) для решения следующей задачи: Даны два списка операторов и операндов. Первый список содержит основные операции алгебры, а второй список - это список целых чисел. Используйте два приведенных списка для построения алгебраического выражения и возврата вычисления этого выражения.
Основные операции с алгеброй:
Дополнение ( + )
Вычитание ( - )
Умножение ( * )
Целое деление ( // )
Возведение в степень ( ** ) | def do_algebra(operator, operand):
"""
Даны два списка операторов и операндов. Первый список содержит основные операции алгебры, а второй список - это список целых чисел. Используйте два приведенных списка для построения алгебраического выражения и возврата вычисления этого выражения.
Основные операции с алгеброй:
Дополнение ( + )
Вычитание ( - )
Умножение ( * )
Целое деление ( // )
Возведение в степень ( ** )
"""
|
HumanEval/161 | Вам дана строка s.
если s[i] - буква, измените ее регистр со строчной на заглавную или наоборот,
в противном случае оставьте все как есть.
Если строка не содержит букв, разверните строку.
Функция должна вернуть результирующую строку.
Примеры:
solve("1234") = "4321"
solve("ab") = "AB"
solve("#a@C") = "#A@c" | def solve(s):
"""
Вам дана строка s.
если s[i] - буква, измените ее регистр со строчной на заглавную или наоборот,
в противном случае оставьте все как есть.
Если строка не содержит букв, разверните строку.
Функция должна вернуть результирующую строку.
Примеры:
solve("1234") = "4321"
solve("ab") = "AB"
solve("#a@C") = "#A@c"
"""
| flg = 0
idx = 0
new_str = list(s)
for i in s:
if i.isalpha():
new_str[idx] = i.swapcase()
flg = 1
idx += 1
s = ""
for i in new_str:
s += i
if flg == 0:
return s[len(s)::-1]
return s
| def check(candidate):
# Check some simple cases
assert candidate("AsDf") == "aSdF"
assert candidate("1234") == "4321"
assert candidate("ab") == "AB"
assert candidate("#a@C") == "#A@c"
assert candidate("#AsdfW^45") == "#aSDFw^45"
assert candidate("#6@2") == "2@6#"
# Check some edge cases that are easy to work out by hand.
assert candidate("#$a^D") == "#$A^d"
assert candidate("#ccc") == "#CCC"
# Don't remove this line:
| solve | solve(s) | def solve(s): | Напишите функцию solve(s) для решения следующей задачи: Вам дана строка s.
если s[i] - буква, измените ее регистр со строчной на заглавную или наоборот,
в противном случае оставьте все как есть.
Если строка не содержит букв, разверните строку.
Функция должна вернуть результирующую строку.
Примеры:
solve("1234") = "4321"
solve("ab") = "AB"
solve("#a@C") = "#A@c" | Напишите функцию solve(s) для решения следующей задачи: Вам дана строка s.
если s[i] - буква, измените ее регистр со строчной на заглавную или наоборот,
в противном случае оставьте все как есть.
Если строка не содержит букв, разверните строку.
Функция должна вернуть результирующую строку. | def solve(s):
"""
Вам дана строка s.
если s[i] - буква, измените ее регистр со строчной на заглавную или наоборот,
в противном случае оставьте все как есть.
Если строка не содержит букв, разверните строку.
Функция должна вернуть результирующую строку.
"""
|
HumanEval/162 | Учитывая строку 'text', верните ее строку, эквивалентную хэшу md5.
Если 'text' - пустая строка, верните None.
>>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62' | def string_to_md5(text):
"""
Учитывая строку 'text', верните ее строку, эквивалентную хэшу md5.
Если 'text' - пустая строка, верните None.
>>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
"""
| import hashlib
return hashlib.md5(text.encode('ascii')).hexdigest() if text else None
| def check(candidate):
# Check some simple cases
assert candidate('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
assert candidate('') == None
assert candidate('A B C') == '0ef78513b0cb8cef12743f5aeb35f888'
assert candidate('password') == '5f4dcc3b5aa765d61d8327deb882cf99'
# Check some edge cases that are easy to work out by hand.
assert True
| string_to_md5 | string_to_md5(text) | def string_to_md5(text): | Напишите функцию string_to_md5(text) для решения следующей задачи: Учитывая строку 'text', верните ее строку, эквивалентную хэшу md5.
Если 'text' - пустая строка, верните None.
>>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62' | Напишите функцию string_to_md5(text) для решения следующей задачи: Учитывая строку 'text', верните ее строку, эквивалентную хэшу md5.
Если 'text' - пустая строка, верните None. | def string_to_md5(text):
"""
Учитывая строку 'text', верните ее строку, эквивалентную хэшу md5.
Если 'text' - пустая строка, верните None.
"""
|
HumanEval/163 | Дано два положительных целых числа a и b, верните четные цифры между a и b в порядке возрастания.
Примеры:
generate_integers(2, 8) => [2, 4, 6, 8]
generate_integers(8, 2) => [2, 4, 6, 8]
generate_integers(10, 14) => []\ | def generate_integers(a, b):
"""
Дано два положительных целых числа a и b, верните четные цифры между a и b в порядке возрастания.
Примеры:
generate_integers(2, 8) => [2, 4, 6, 8]
generate_integers(8, 2) => [2, 4, 6, 8]
generate_integers(10, 14) => []\
"""
| lower = max(2, min(a, b))
upper = min(8, max(a, b))
return [i for i in range(lower, upper+1) if i % 2 == 0]
| def check(candidate):
# Check some simple cases
assert candidate(2, 10) == [2, 4, 6, 8], "Test 1"
assert candidate(10, 2) == [2, 4, 6, 8], "Test 2"
assert candidate(132, 2) == [2, 4, 6, 8], "Test 3"
assert candidate(17,89) == [], "Test 4"
# Check some edge cases that are easy to work out by hand.
assert True, "This prints if this assert fails 2 (also good for debugging!)"
| generate_integers | generate_integers(a, b) | def generate_integers(a, b): | Напишите функцию generate_integers(a, b) для решения следующей задачи: Дано два положительных целых числа a и b, верните четные цифры между a и b в порядке возрастания.
Примеры:
generate_integers(2, 8) => [2, 4, 6, 8]
generate_integers(8, 2) => [2, 4, 6, 8]
generate_integers(10, 14) => []\ | Напишите функцию generate_integers(a, b) для решения следующей задачи: Дано два положительных целых числа a и b, верните четные цифры между a и b в порядке возрастания. | def generate_integers(a, b):
"""
Дано два положительных целых числа a и b, верните четные цифры между a и b в порядке возрастания.
"""
|