neulab/odex huggingface dataset:
# Выделить дробную часть числа `num`
def f_757454(num):
	return math.modf(num)[0]

import math

def check(candidate):
    assert (candidate(123.45) - 0.45) < 1e-6

    assert (candidate(123.4445) - 0.4445) < 1e-6

    assert (candidate(-0.01) - 0.01) < 1e-6

    assert (candidate(0.) - 0.0) < 1e-6

    assert (candidate(1000000) - 0.0) < 1e-6
# Выделить дробную часть числа `num`
def f_757454(num):
	return num % 1

def check(candidate):
    assert (candidate(123.45) - 0.45) < 1e-6

    assert (candidate(123.4445) - 0.4445) < 1e-6

    assert (candidate(-0.01) - 0.99) < 1e-6

    assert (candidate(0.) - 0.0) < 1e-6

    assert (candidate(1000000) - 0.0) < 1e-6
# Вычислить сколько процентов составляет число `part` от числа `whole`
def f_247377(whole, part):
	return 100 / whole * part

def check(candidate):
    assert (candidate(54, 100) - 185.185) < 0.02

    assert (candidate(100, 1) - 1.0) < 1e-6

    assert (candidate(4, 24) - 600.0) < 1e-6
# Сделать заглавной первую букву каждого слова в строке `s`
def f_712792(s):
	return s.title()

def check(candidate):
    assert candidate('test') == 'Test'

    assert candidate('Test') == 'Test'

    assert candidate('TEST') == 'Test'

    assert candidate('  ') == '  '
# Измерить время выполнения `time_work` функции `func`
def f_775089(func):
	t = time.time()

	func()

	time_work = time.time()-t
	return time_work

import time 

def check(candidate):
    def print_str(): return "hello world!"
    assert candidate(print_str) < 10

    def sleep_one_sec(): time.sleep(1)
    assert 1 < candidate(sleep_one_sec) < 10
# Найти числа в строке `s`
def f_157675(s):
	return re.findall('(\d+)', s)

import re

def check(candidate):
    assert candidate('123abc456') == ['123', '456']

    assert candidate('123456') == ['123456'] 

    assert candidate('afbnjig') == []
# Записать число `nums` в файл `file_path`
def f_210870(num, file_path):
	file_1 = open(file_path, "w")

	file_1.write(str(num))
	file_1.close()
	return 

def check(candidate):
    candidate(12.34, "tmp.txt")
    with open('tmp.txt', 'r') as fr:
        lines = fr.readlines()
    assert len(lines) == 1 and lines[0] == '12.34'

    candidate(0, "tmp.txt")
    with open('tmp.txt', 'r') as fr:
        lines = fr.readlines()
    assert len(lines) == 1 and lines[0] == '0'
# Записать число `nums` в файл `file_path`
def f_210870(num, file_path):
	
	with open(file_path, 'w') as f:
		print(str(num), file=f)

	return 

def check(candidate):
    candidate(12.34, "tmp.txt")
    with open('tmp.txt', 'r') as fr:
        lines = fr.readlines()
    assert len(lines) == 1 and lines[0] == '12.34\n'
# Отправить POST-запрос `res` c JSON данными `data` на `url`
def f_681594(url, data):
	return requests.post(url, json=data)

import requests

def check(candidate):
    url = 'https://www.google.com/'
    myobj = {'somekey': 'somevalue'}
    x = candidate(url, myobj)
    assert x.request.body == b'{"somekey": "somevalue"}'
    assert x.request.url == url
# Преобразовать русскоязычный словарь `my_dict` в JSON 
def f_584129(my_dict):
	return json.dumps(my_dict, ensure_ascii=False)

import json

def check(candidate):
    assert candidate({'a': 123, 'Bb': None}) == json.dumps({'a': 123, 'Bb': None}, ensure_ascii=False)

    assert candidate({123: 123, 'Bb': None}) == json.dumps({123: 123, 'Bb': None}, ensure_ascii=False)

    assert candidate({}) == json.dumps({}, ensure_ascii=False)
# Найти общие элементы `common_items` списка `my_list1` и списка `my_list2` 
def f_37137(my_list1, my_list2):
	count_values_l1 = Counter(my_list1)

	count_values_l2 = Counter(my_list2)

	keys1 = count_values_l1.keys()

	keys2 = count_values_l2.keys()

	common_items = []

	for key in keys1:

		if key in keys2:

			common_items += [key] * min(count_values_l1[key], count_values_l2[key])
	
	return common_items

from collections import Counter 

def check(candidate):
    assert set(candidate([1,2,3.5,'a'], [3.4, 'bb', 'a', 1])) == set([1, 'a']) 

    assert set(candidate([1,2,3], [4,5,6])) == set([]) 

    assert set(candidate(['ger','ferags',34.56], ['ger','ferags',34.56])) == set(['ger','ferags',34.56])
# Найти общие элементы `common_items` списка `my_list1` и списка `my_list2` 
def f_37137(my_list1, my_list2):
	return list(set(my_list1) & set(my_list2))

def check(candidate):
    assert set(candidate([1,2,3.5,'a'], [3.4, 'bb', 'a', 1])) == set([1, 'a']) 

    assert set(candidate([1,2,3], [4,5,6])) == set([]) 

    assert set(candidate(['ger','ferags',34.56], ['ger','ferags',34.56])) == set(['ger','ferags',34.56])
# Разложить число `n` на простые множители `factors`
def f_645227(n):
	
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while (n % i) == 0:
			factors.append(i)
			n = n // i
	if n > 2: 
 		factors.append(n)

	return factors

import math

def check(candidate):
    assert candidate(17) == [17]

    assert sorted(candidate(10)) == [2, 5]

    assert sorted(candidate(100)) == [2, 2, 5, 5]
# Сгенерировать спискок `my_list` длинной `N` случайных значений в диапазоне от `val1` до `val2`
def f_565846(val1, val2, N):
	my_list = [random.randint(val1, val2) for i in range(N)]
	return my_list

import random

def check(candidate):
    result = candidate(0, 18, 10)
    assert len(result) == 10
    assert min(result) >= 0
    assert max(result) <= 18
    assert all([isinstance(a, int) for a in result])
# Поменять местами элементы списка `my_list` с индексами `i` и `j`
def f_925879(my_list, i, j):
	my_list[i], my_list[j] = my_list[j], my_list[i]
	return my_list

def check(candidate):
    assert candidate([1,2,3,4,5], 2, 4) == [1,2,5,4,3]

    assert candidate([1,2,3,4,5], 2, 0) == [3,2,1,4,5]

    assert candidate([1,2,3,4,5], 0, 0) == [1,2,3,4,5]
# Ввести с клавиатуры через пробел список строк `my_list`
def f_649828():
	my_list = input().split()
	return my_list

import builtins
from unittest.mock import Mock

def check(candidate):
    builtins.input = Mock(return_value = '6 6')
    assert candidate() == ['6', '6']

    builtins.input = Mock(return_value = 'hello world !')
    assert candidate() == ["hello", "world", "!"]
# Проверить наличие ключа `my_key` в словаре `my_dict`
def f_752179(my_dict, my_key):
	return my_key in my_dict

def check(candidate):
    assert candidate({'k': 123}, 'k') == True

    assert candidate({'k': 123}, 'aa') == False
# Получить расширение `file_extension` файла `file_path`
def f_540082(file_path):
	filename, file_extension = os.path.splitext(file_path)
	return file_extension

import os

def check(candidate):
    assert candidate('file_name.txt') == '.txt'

    assert candidate('file_name') == ''

    assert candidate('test.json') == '.json'
# Получить расширение `file_extension` файла `file_path`
def f_540082(file_path):
	file_extension= file_path.split('.')[-1]
	return file_extension

def check(candidate):
    assert candidate('file_name.txt') == 'txt'
# Удалить все символы в строке `s` после символа `symbol`
def f_502573(s, symbol):
	s = s[:s.find(symbol)]
	return s

def check(candidate):
    assert candidate('123abcyyl', 'cy') == '123ab'

    assert candidate('123abcyyl', '123') == ''
# Удалить все символы в строке `s` после символа `symbol`
def f_502573(s, symbol):
	s = s.split(symbol)[0]
	return s

def check(candidate):
    assert candidate('123abcyyl', 'cy') == '123ab'

    assert candidate('123abcyyl', '234') == '123abcyyl'
# Найти разницу `diff_list` списков `my_list1` и `my_list2`
def f_21825(my_list1, my_list2):
	count_values1 = Counter(my_list1)

	count_values2 = Counter(my_list2)

	
	keys1 = list(count_values1.keys())

	keys2 = list(count_values2.keys())

	
	diff_list = []

	for key in set(keys1 + keys2):

		if key in keys1 and key in keys2:

			diff_list += [key] * abs(count_values1[key] - count_values2[key])

		elif key in keys1:

			diff_list += [key] * count_values1[key]

		elif key in keys2:

			diff_list += [key] * count_values2[key]

	return diff_list

from collections import Counter

def check(candidate):
    list1 = [1, 3, 4]
    list2 = [5, 4, 9]
    assert candidate(list1, list2) == [1, 3, 5, 9]

    list1 = ['abc', 'klm']
    list2= ['pqr', 'xyz']
    assert len(candidate(list1, list2)) == 4
# Найти разницу `diff_list` списков `my_list1` и `my_list2`
def f_21825(my_list1, my_list2):
	diff_list = list(set(my_list1)-set(my_list2)) + list(set(my_list2)-set(my_list1))
	return diff_list

def check(candidate):
    assert sorted(candidate([1,2,3,4],[2,3,4,5])) == [1,5]

    assert sorted(candidate([1,2,3,4],[])) == [1,2,3,4]
# Найти позицию символа `my_char` в строке `s`
def f_513149(s, my_char):
	return  s.index(my_char)

def check(candidate):
    assert candidate('123abc456', 'ab') == 3

    assert candidate('123abc456', 'bc') == 4

    assert candidate('23abc123', '2') == 0
# Найти позицию символа `my_char` в строке `s`
def f_513149(s, my_char):
	return  s.find(my_char)

def check(candidate):
    assert candidate('123abc456', 'ab') == 3

    assert candidate('123abc456', 'bc') == 4

    assert candidate('23abc123', '2') == 0
# Ввести с клавиатуры числа через пробел в список `my_list`
def f_934453():
	my_list = list(map(int, input().split()))
	return my_list

import builtins
from unittest.mock import Mock

def check(candidate):
    builtins.input = Mock(return_value = '3 2')
    my_list = candidate()
    assert my_list == [3, 2]

    builtins.input = Mock(return_value = '300 2')
    my_list = candidate()
    assert my_list == [300, 2]
# Ввести с клавиатуры числа через пробел в список `my_list`
def f_934453():
	my_list = [int(a) for a in input().split()]
	return my_list

import builtins
from unittest.mock import Mock

def check(candidate):
    builtins.input = Mock(return_value = '3 2')
    my_list = candidate()
    assert my_list == [3, 2]

    builtins.input = Mock(return_value = '100 2 200 3')
    my_list = candidate()
    assert my_list == [100, 2, 200, 3]
# Сгненировать word документ `output_file_path` по шаблону из word файла `template_path` с JSON данными data
def f_515513(template_path, output_file_path):
	#python-docx-template

	doc = DocxTemplate(template_path)

	data = { 'var_name' : "HELLO WORLD!" }

	doc.render(data)

	doc.save(output_file_path)
	return 

import os
import aspose.words as aw
from docxtpl import DocxTemplate

def check(candidate):
    # create document object
    doc = aw.Document()

    # create a document builder object
    builder = aw.DocumentBuilder(doc)

    # add text to the document
    builder.write("Hello world!")

    # save document
    doc.save("out.docx")
    candidate("out.docx", "new.docx")
    assert os.path.exists("new.docx")
# Проверить пустой ли список `my_list`
def f_524081(my_list):
	return not my_list

def check(candidate):
    assert candidate([]) == True

    assert candidate(['rehg tg', 325]) == False
# Сгенерировать таблицу умножения до числа `num`
def f_766573(num):
	for i in range(1, num):

		print(*range(i, i*num+1, i), sep='	')

	return 

import sys

def check(candidate):
    f = open('output.txt', 'w')
    old = sys.stdout
    sys.stdout = f
    candidate(5)
    sys.stdout = old
    f.close()
    with open ('output.txt', 'r') as f1:
        lines = f1.readlines()
        assert int(lines[-1].split()[-1]) == 20
# Отправить POST-запрос с JSON данными `data` и файлом `file_path` на `url`
def f_724582(file_path, url, data):
	files = {

	    'file': open(file_path, 'rb')
	}
	
	r = requests.post(url, data=data, files=files)
	return r

import requests
from unittest.mock import Mock

def check(candidate):
    r = requests.Response()
    r.status_code = 200
    requests.post = Mock(return_value = r)
    file_path = 'a.txt'
    with open (file_path, 'w') as f:
        f.write('abc')
    assert candidate(file_path, 'https://def.xyz', {'key':'value'}).status_code == 200
# Посчитать символы в строке `s`
def f_735924(s):
	return Counter(s)

from collections import Counter

def check(candidate):
    assert candidate('123abccb') == Counter({'1': 1, '2': 1, '3': 1, 'a': 1, 'b': 2, 'c': 2})

    assert candidate('111abccb') == Counter({'1': 3, 'a': 1, 'b': 2, 'c': 2})
# Посчитать символы в строке `s`
def f_735924(s):
	return {c:s.count(c) for c in set(s)}

def check(candidate):
    assert candidate('123abccb') == {'1': 1, '2': 1, '3': 1, 'a': 1, 'b': 2, 'c': 2}

    assert candidate('111abaab') == {'1': 3, 'a': 3, 'b': 2}
# Получить значение словаря `my_dict` по ключу `my_key`
def f_504426(my_dict, my_key):
	return my_dict[my_key]

def check(candidate):
    assert candidate({'a': 123, 'b': 'aas'}, 'a') == 123

    assert candidate({'a': 123, 'b': 'aas'}, 'b') == "aas"
# Установить кодировку utf-8 для файла
def f_387249():
	# -*- coding: utf-8 -*-
	return 

def check(candidate):
    candidate()
    s = "Привет"
    assert s == "Привет"
# Преобразовать список `my_list` в строку `s` c разделителем `sep` 
def f_66490(my_list, sep):
	s = sep.join(my_list)
	return s

def check(candidate):
    assert candidate(['a','b','c'], '-') == 'a-b-c'

    assert candidate(['aa','bb','cc'], '-') == 'aa-bb-cc'
# Преобразовать список `my_list` в строку `s` c разделителем `sep` 
def f_66490(my_list, sep):
	s = sep.join(map(str, my_list))
	return s

def check(candidate):
    assert candidate(['a','b','c'], '-') == 'a-b-c'

    assert candidate(['a','b','c'], '.') == 'a.b.c'
# Удалить все цифры из строки `s`
def f_363427(s):
	return re.sub(r'[^\w\s]+|[\d]+', r'',s)

import re

def check(candidate):
    assert candidate('1a2b34c') == 'abc'

    assert candidate('hello world') == 'hello world'

    assert candidate('1234567890') == ''
# Получить коды символов строки `s`
def f_224298(s):
	return [ord(c) for c in s]

def check(candidate):
    assert candidate('example string') == [101, 120, 97, 109, 112, 108, 101, 32, 115, 116, 114, 105, 110, 103]

    assert candidate('hello world!') == [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33]
# Спарсить HTML-код страницы `code` по ссылке `url`
def f_182910(url):
	with urllib.request.urlopen(url) as res:
	    code = res.read()
	return code

import urllib

def check(candidate):
    assert candidate("https://www.google.com/").find(b"title")
# Сериализовать объект `my_obj` класса `My_class`
def f_850118(my_obj, My_class):
	
	class ClassEncoder(json.JSONEncoder):
		def default(self, obj):
			if isinstance(obj, My_class):
				return obj.__dict__
			return json.JSONEncoder.default(self, obj)
	result = json.dumps(my_obj, cls=ClassEncoder)

	return result

import json

def check(candidate):
    obj = {'name': 'hall', 'id': 344}
    assert str(candidate(obj, dict)) == '{"name": "hall", "id": 344}'
# Разделить строку `s` на слова `words`
def f_673692(s):
	words = s.split()
	return words

def check(candidate):
    assert candidate('first second third') == ['first', 'second', 'third']

    assert candidate('first-second-third') == ['first-second-third']
# Проверить является ли `s` строкой
def f_843929(s):
	return isinstance(s, str)

def check(candidate):
    assert candidate('1a2b34c') == True

    assert candidate(123) == False
# Преобразовать список `my_list` в множество `my_set`
def f_705331(my_list):
	my_set = set(my_list)
	return my_set

def check(candidate):
    assert candidate(['a', 12, '45.6', 45.6]) == set(['a', 12, '45.6', 45.6])

    assert candidate([1,2,3,12,123,12,123]) == set([1,2,3,12,123])
# Разбить число `num` на разряды
def f_262786(num):
	return list(str(num))

def check(candidate):
    assert candidate(43524) == ['4', '3', '5', '2', '4']

    assert candidate("hello, world!") == ['h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
# Разбить число `num` на разряды
def f_262786(num):
	return [int(i) for i in str(num)]

def check(candidate):
    assert candidate('43524') == [4,3,5,2,4]
# Измерить время выполнения `time_work` функции `func`
def f_313184(func):
	t = time.time()

	func()

	time_work = time.time()-t
	return time_work

import time

def check(candidate):
    def func(): print('Hello World!')
    assert (candidate(func) - 8.368492126464844e-05) < 1e-6
# Проверить есть ли числа в строке `s`
def f_678639(s):
	return any(map(str.isdigit, s))

def check(candidate):
    assert candidate('124dhe5') == True

    assert candidate('absbf') == False
# Проверить есть ли числа в строке `s`
def f_678639(s):
	return re.search('\d+', s)

import re 

def check(candidate):
    assert candidate('124dhe5').group() == '124'

    assert candidate('absbf') is None
# Считать с клавиатуры число в переменную `num`
def f_830473():
	num = int(input().strip())
	return num

import builtins
from unittest.mock import Mock

def check(candidate):
    builtins.input = Mock(return_value = '8')
    assert candidate() == 8

    builtins.input = Mock(return_value = '80   ')
    assert candidate() == 80
# Сгенерировать спискок `my_list` случайных значений в диапазоне от `val1` до `val2` длинной `N`
def f_773920(val1, val2, N):
	my_list = [random.randint(val1, val2) for i in range(N)]
	return my_list

import random 

def check(candidate):
    my_list = candidate(0, 10, 4) 
    assert len(my_list) == 4
    assert all([isinstance(a, int) for a in my_list])
    assert min(my_list) >= 0
    assert max(my_list) <= 10
# Разбить список `my_list` на список списков `splitted` по разделителю `sep`
def f_115592(my_list, sep):
	splitted = [[]]

	for item in my_list:

		if item == sep:

			splitted.append([])

		else:

			splitted[-1].append(item)
	return splitted

def check(candidate):
    assert candidate(['ab', '-', 'c', '24v', '-', 'vd', '33', '-', '000'], '-') == [['ab'], ['c', '24v'], ['vd', '33'], ['000']]
# Сгенерировать список `my_list` размера `M`x`N` заполненный значением `val`
def f_158145(M, N, val):
	my_list = [[val for _ in range(N)] for _ in range(M)]
	return my_list

def check(candidate):
    assert candidate(2, 3, 0.5) == [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5]]

    assert candidate(1, 1, None) == [[None]]
# Посчитать сумму `n` членов арифметической прогрессии с членом заданным функцией `f(x)`
def f_592250(n, f):
	s = 0

	for x in range(1, n+ 1):

		s += f(x)

	return s

def check(candidate):
    def f(a): return a + 1
    assert candidate(2, f) == 5

    def g(a): return a * a + 1
    assert candidate(5, g) == 60
# Посчитать сумму `n` членов арифметической прогрессии с членом заданным функцией `f(x)`
def f_592250(n, f):
	s = 0

	x = 0

	while True:

		x+= 1

		s += f(x)

		if x == n:

			break

	return s

def check(candidate):
    def f(a): return a + 1
    assert candidate(2, f) == 5

    def g(a): return a * a + 1
    assert candidate(5, g) == 60
# Преобразовать строковое предствление даты `old_date` в строковое представление `new_date` формата `date_format` с использованием библиотеки datetime 
def f_419321(old_date, date_format):
	new_date = datetime.strptime(old_date, date_format)
	return new_date

from datetime import datetime

def check(candidate):
    time_data = "25/05/99 02:35:5.523"
    format_data = "%d/%m/%y %H:%M:%S.%f"
    date = candidate(time_data, format_data)
    assert date.microsecond == 523000
# Преобразовать строковое предствление даты `old_date` в строковое представление `new_date` формата `date_format` с использованием библиотеки datetime 
def f_419321(old_date, date_format):
	locale.setlocale(locale.LC_TIME, 'ru_RU.UTF-8')

	new_date = datetime.strptime(old_date, date_format).date()
	return new_date

import locale
from datetime import datetime
from unittest.mock import Mock

def check(candidate):
    locale.setlocale =Mock()
    time_data = "25/05/99 02:35:5.523"
    format_data = "%d/%m/%y %H:%M:%S.%f"
    date = candidate(time_data, format_data)
    assert str(date) == '1999-05-25'
# Найти количество перекрывающих вхождений `count` подстроки `sub` в строку `s`
def f_404985(sub, s):
	count = 0

	i = -1

	while True:

		i = s.find(sub, i+1)

		if i == -1:

			break

		count += 1
	return count

def check(candidate):
    assert candidate('ab', 'abcccccabcca') == 2
# Перевернуть список `my_list`
def f_427051(my_list):
	my_list.reverse()
	return my_list

def check(candidate):
    assert candidate([1,2,3]) == [3,2,1]

    assert candidate([1,3,2,3,1]) == [1,3,2,3,1]
# Перевернуть список `my_list`
def f_427051(my_list):
	my_list = my_list[::-1]
	return my_list

def check(candidate):
    assert candidate([1,2,3]) == [3,2,1]

    assert candidate([1,2,3,4,1]) == [1,4,3,2,1]
# Перевернуть список `my_list`
def f_427051(my_list):
	my_list = list(reversed(my_list))
	return my_list

def check(candidate):
    assert candidate([1,2,3]) == [3,2,1]
# Объединить список ключей `list_key` и список значений `list_value` в словарь `my_dict`
def f_789625(list_key, list_value):
	my_dict = dict(zip(list_key, list_value))
	return my_dict

def check(candidate):
    assert candidate(['a','b','c'], [1,2,3]) == {'a':1, 'b':2, 'c':3}

    assert candidate(
        ['green','happy','sunny'], ["red","sad","rainy"]
    ) == {"green":"red", "happy":"sad", "sunny":"rainy"}
# Объединить список ключей `list_key` и список значений `list_value` в словарь `my_dict`
def f_789625(list_key, list_value):
	my_dict = {list_key[i]: list_value[i] for i in range(len(list_key))}
	return my_dict

def check(candidate):
    assert candidate(['a','b','c'], [1,2,3]) == {'a':1, 'b':2, 'c':3}

    assert candidate(
        ['green','happy','sunny'], ["red","sad","rainy"]
    ) == {"green":"red", "happy":"sad", "sunny":"rainy"}
# Вывести строку `s` `n` раз через разделитель `sep`
def f_477678(s, n, sep):
	return sep.join([s] * n)

def check(candidate):
    assert candidate('abk', 3, ';') == 'abk;abk;abk'

    assert candidate('', 3, ';') == ';;'
# Выбрать столбцы `cols` с индекасами `list_indexes` pandas датафрейма `df`
def f_635319(df, list_indexes):
	cols = df.iloc[:, list_indexes]
	return cols

import pandas as pd

def check(candidate):
    df = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6], 'c': [7,8,9]})
    assert candidate(df, [1,2]).shape == (3, 2)
# Найти сумму чисел `total` списка `my_list`
def f_1085344(my_list):
	total = sum(my_list)
	return total

def check(candidate):
    assert candidate([345, 576, 12]) == 933

    assert candidate([1.0, 2.2, 3.5]) == 6.7
# Найти сумму чисел `total` списка `my_list`
def f_1085344(my_list):
	total = 0

	for i in my_list:

		total += i

	return total

def check(candidate):
    assert candidate([345, 576, 12]) == 933
# Найти максимальное знаечние `max_value` в словаре `my_list`
def f_759476(my_list):
	max_value = {x: y for x, y in filter(lambda x: my_list[x[0]] == max(my_list.values()), my_list.items())}
	return max_value

def check(candidate):
    assert candidate({'a':3, 'b':2, 'r':36}) == {'r': 36}
# Найти максимальное знаечние `max_value` в словаре `my_list`
def f_759476(my_list):
	max_value = max(my_list.values())
	return max_value

def check(candidate):
    assert candidate({'a':3, 'b':2, 'r':36}) == 36
# Вывести `n` слов из списка `my_list` в случайном порядке без повторений
def f_407127(my_list, n):
	return random.sample(set(my_list),n)

import random 

def check(candidate):
    data = [i for i in range(10)]
    s1 = candidate(data, 3)
    assert len(s1) == 3
    assert all([(a in data) for a in s1])

    data = [i//2 for i in range(10)]
    s2 = candidate(data, 4)
    assert len(s2) == 4
    assert all([(a in data) for a in s2])
    assert len(set(s2)) == 4
# Добавить кортеж `my_tuple` к списку `my_list`
def f_446920(my_list, my_tuple):
	my_list.extend(my_tuple)
	return my_list

def check(candidate):
    assert candidate([1,2,3], (2,3)) == [1,2,3,2,3]

    assert candidate([1,2,3], (2,)) == [1,2,3,2]
# Заменить в строке `s` символ на позиции `i` на символ `symbol`
def f_103581(s, i, symbol):
	return s[:i] + symbol + s[i + 1:]

def check(candidate):
    assert candidate('dsgfjksdlh', 3, 'abc') == 'dsgabcjksdlh'

    assert candidate('dsgfjksdlh', 3, '.') == 'dsg.jksdlh'
# Отсортировать список `my_list`
def f_28096(my_list):
	my_list = sorted(my_list)
	return my_list

def check(candidate):
    assert candidate([3,2,1]) == [1,2,3]

    assert candidate([1,1,1]) == [1,1,1]

    assert candidate(['a', 'b', 'c']) == ['a', 'b', 'c']
# Отсортировать список `my_list`
def f_28096(my_list):
	my_list.sort()
	return my_list

def check(candidate):
    assert candidate([3,2,1]) == [1,2,3]

    assert candidate([1,1,1]) == [1,1,1]

    assert candidate(['a', 'b', 'c']) == ['a', 'b', 'c']