neulab/odex huggingface dataset:
# ¿Cómo obtener un dictionario `result` con las llaves `keys` y los valores `val` de un diccionario `dic`?
def f_54979(dic):
	result = defaultdict(list)
	for d in dic.values():
	    for k,v in d.items():
	        result[k].append(v)
	return result

from collections import defaultdict

def check(candidate):
    dic = {'xx': {0: 0., 1: 1., 2: 2.}, 'yy': {1: '1', 2: '2'}, 'zz': {2: 2}}
    assert dict(candidate(dic)) == {0: [0.0], 1: [1.0, '1'], 2: [2.0, '2', 2]}
# ¿Cómo encontrar el máximo de una función `y` que depende de `x`?
def f_39675(x, y):
	
	dy = diff(y)
	sol = solve(dy)

	return sol

from sympy import *

def check(candidate):
    x = symbols('x')
    y = -(x-0.4)**2+10
    assert candidate(x, y)[0] == 0.4
# ¿Cómo subir archivos a una carpeta local ubicada en `ruta` después de abrirlo?
def f_19921(file, ruta):
	
	with open(file, 'rb') as fsrc:
		a = fsrc.read()
	shutil.copyfile(file, ruta)

	return 

import os
import shutil

def check(candidate):
    file = "tmp.txt"
    with open(file, 'w') as fw: 
        fw.write("hello world!")
    ruta = "test/tmp.txt"
    os.mkdir("test")
    candidate(file, ruta)
    assert os.path.isfile(ruta) == True
# ¿Cómo duplicar los elementos de una lista `lst` excluyendo los extremos?
def f_25024(lst):
	return list(sum(zip(lst, lst[1:]), ()))

def check(candidate):
    assert candidate([1,2,3,4]) == [1,2,2,3,3,4]
# ¿Cómo contar las llamadas totales al método de una clase `C`?
def f_774():
	
	class C:
		def __init__(self):
			self.total_renombres = 0

		def _incrementa_contador_renombres(self):
			self.total_renombres += 1

	return C

def check(candidate):
    sample = candidate()()
    sample._incrementa_contador_renombres()
    assert sample.total_renombres == 1
# ¿Cómo rotar una imagen `img` en un ángulo de `x` grados en Tkinter?
def f_38658(img, x):
	im = Image.open(img)
	im.rotate(x).show()
	return 

from PIL import Image

def check(candidate):
    im = Image.new('RGBA', (200, 200), (255, 255, 255, 255))
    im.save('v.png')
    try:
        candidate('v.png', 45)
    except:
        assert False
# ¿Cómo transformar una fecha `date` en palabras a fecha en números?
def f_49642(date):
	
	def mesANumero(date):
	    m = {
	        'enero': '01',
	        'febrero': '02',
	        'marzo': '03',
	        'abril': '04',
	        'mayo': '05',
	        'junio': '06',
	        'julio': '07',
	        'agosto': '08',
	        'septiembre': '09',
	        'octubre': '10',
	        'noviembre': '11',
	        'diciembre': '12'
	        }
	
	    fecha = date.split('-')
	    dia =  fecha[0]
	    mes =  fecha[1]
	    anio = fecha[2]
	
	    try:
	        out = str(m[mes.lower()])
	        return dia + '-' +  out + '-' + anio
	    except:
	        raise ValueError('No es un mes')
	

	return mesANumero(date)

def check(candidate):
    assert candidate('13-noviembre-2007') == '13-11-2007'
# ¿Cómo crar un subproceso `proc`?
def f_2611():
	return subprocess.Popen('proc')

import subprocess
from unittest.mock import Mock

def check(candidate):
    subprocess.Popen = Mock()
    try:
        candidate()
    except:
        assert False
# ¿Cómo crear una matriz `array` de `n`x`m` matrices?
def f_71600(n, m):
	
	array = []
	for count in range(n):
		row = []
		for count in range(m):
			m = matriz()
			row.append(m)
		array.append(row)


	return array

def matriz(): return 0

def check(candidate):
    e = candidate(2, 2)
    assert len(e) == 2
    assert len(e[0]) == 2
# ¿Cómo generar permutaciones de una lista `mi_lista` permitiendo repetir elementos y sin repetirlos?
def f_37964(mi_lista):
	return [(x,y) for x in mi_lista for y in mi_lista if x!=y]

def check(candidate):
    assert candidate([5, 6, 7, 8]) == [(5, 6), (5, 7), (5, 8), (6, 5), (6, 7), (6, 8), (7, 5), (7, 6), (7, 8), (8, 5), (8, 6), (8, 7)]
# ¿Cómo crear una lista `list` de tuplas con los valores `Lon` y `Lat` de un diccionario `dic`?
def f_54164(dic):
	list = [] 
	for id,mensaje in dic.items():
	    list.append([mensaje['Lon'],mensaje['Lat']])
	return list

def check(candidate):
    dic = {3: {'Lat': 32.144, 'Lon':-112.56}, 7: {'Lat': 21.144, 'Lon': 98.56}}
    list = candidate(dic)
    assert len(list) == 2
# ¿Cómo crear una lista `list` de tuplas con los valores `Lon` y `Lat` de un diccionario `dic`?
def f_54164(dic):
	list = [[v['Lon'],v['Lat']] for k, v in dic.items()]
	return list

def check(candidate):
    dic = {3: {'Lat': 32.144, 'Lon':-112.56}, 7: {'Lat': 21.144, 'Lon': 98.56}}
    list = candidate(dic)
    assert len(list) == 2
# ¿Cómo crear una función `indextoentry` que devuelva una lista al pasarle una lista `lista` y un ìndice `index`?
def f_36164():
	def indextoentry(lista,index):
	    return [lista[index]]
	return indextoentry

def check(candidate):
    assert candidate()([1,2,3], 0) == [1]
# ¿Cómo leer una cadena de varias líneas ingresada por consola y almacenar cada línea como un elemento de una lista `lista`?
def f_59300():
	lista = []
	while True:
	    inputs = input()
	    if inputs:
	        lista.append(inputs)
	    else:
	        break
	print(lista)
	return lista

import builtins
from unittest.mock import Mock

def check(candidate):
    builtins.input = Mock(return_value="hello")
    try:
        candidate()
    except:
        return True
# ¿Cómo borrar todos los archivos .txt dentro de las subcarpetas ubicadas en la ruta `rut`?
def f_2056(rut):
	directory = rut
	os.chdir(directory)
	for filename in glob.glob('**/*.txt', recursive=True):
	    os.unlink(filename)
	return 

import os
import glob
from unittest.mock import Mock

def check(candidate):
    os.chdir = Mock()
    os.unlink = Mock()
    try:
        candidate('/')
    except:
        assert False
# ¿Cómo usar una dirección proxy `proxies` con una url `url`?
def f_59326(proxies, url):
	proxy = request.ProxyHandler(proxies)
	opener = request.build_opener(proxy)
	request.install_opener(opener)
	response=request.urlopen(url)
	return 

from urllib import request
from unittest.mock import Mock

def check(candidate):
    proxies = {'http':"218.28.112.114:809"}
    url = 'http://www.httpbin.org/ip'
    request.ProxyHandler = Mock()
    request.build_opener = Mock()
    request.install_opener = Mock()
    request.urlopen = Mock(return_value = request.urlopen('https://www.google.com'))
    try:
        candidate(proxies, url)
    except:
        assert False
# ¿Cómo implementar un fichero conf?
def f_3995(conf):
	
	config = configparser.ConfigParser()
	config.read(conf)

	return config

import configparser
from unittest.mock import Mock

def check(candidate):
    file_name = 'example.conf'
    with open(file_name, 'w') as f:
        f.write('[HORAS]\n')
        f.write('hora_ini = 14:00\n')
        f.write('hora_fin = 22:00\n')
    try:
        candidate(file_name)
    except:
        assert False
# ¿Cómo calcular la diferencia entre una hora `ingreso` en UTC y este momento?
def f_19685(ingreso):
	now = datetime.utcnow() 
	diferencia = now - ingreso
	return diferencia

from datetime import datetime

def check(candidate):
    ingreso = datetime.utcnow()
    assert candidate(ingreso).seconds - (datetime.utcnow()-ingreso).seconds < 60
# ¿Cómo calcular la diferencia entre una hora `ingreso` en UTC y este momento?
def f_19685(ingreso):
	now = datetime.utcnow()
	diferencia = now.replace(tzinfo=None) - ingreso.replace(tzinfo=None)
	return diferencia

import datetime
from unittest.mock import Mock

def check(candidate):
    datetime.utcnow = Mock(return_value = datetime.datetime(2016, 8, 1, 22, 0, 21, 979170))
    ingreso = datetime.datetime(2016, 8, 2, 22, 0, 21, 979170)
    d = candidate(ingreso)
    assert d.days == -1
# ¿Cómo encontrar las palabras de longitud menor `menores` o mayor `mayores` que la media aritmetica de una cadena `S`?
def f_2256(S):
	media = stats.mean([len(palabra) for palabra in S.split()])
	mayores = [palabra for palabra in S.split() if len(palabra) >= media]
	menores = [palabra for palabra in S.split() if len(palabra) < media]
	print('las palabras menores a la media: ', menores)
	print('las palabras mayores o iguales a la media: ', mayores)
	return mayores, menores

import statistics as stats

def check(candidate):
    S = "hello world i am a penguin"
    x, y = candidate(S)
    assert y == ['i', 'am', 'a']
    assert x == ['hello', 'world', 'penguin']
# ¿Cómo encontrar las palabras de longitud menor `menores` o mayor `mayores` que la media aritmetica de una cadena `S`?
def f_2256(S):
	
	ls, ts = zip(*sorted([(len(x), x) for x in S.split()]))
	avlen = sum(ls) / len(ls)  
	bpoint = bisect.bisect_right(ls, avlen)  
	mayores = ts[bpoint:]
	menores = ts[:bpoint]

	return mayores, menores

import bisect
import statistics as stats

def check(candidate):
    S = "hello world i am a penguin"
    x, y = candidate(S)
    assert x == ('hello', 'world', 'penguin')
    assert y == ('a', 'i', 'am')
# ¿Cómo calcular la distancia entre un punto `P` y el segmento acotado por los puntos `A` y `B`?
def f_62209(A, B, P):
	
	if all(A==P) or all(B==P):
		return 0
	elif np.arccos(np.dot((P-A)/norm(P-A), (B-A)/norm(B-A))) > np.pi/2:
		return norm(P-A)
	elif np.arccos(np.dot((P-B)/norm(P-B), (A-B)/norm(A-B))) > np.pi/2:
		return norm(P-B)
	return norm(np.cross(B-A, A-P))/norm(B-A)

	return 

import numpy as np
from numpy.linalg import norm

def check(candidate):
    A = np.array((5,3))
    B = np.array((2,1))
    P = np.array((1,2))
    assert candidate(A, B, P) == 1.4142135623730951
# ¿Cómo encontrar las celdas adyacentes a la celda en la fila `f` y la columna `c` en una matriz `life` llena de #?
def f_62798(life, f, c):
	
	fs = life[f-1]
	fi = life[(f+1)%len(life)]
	i=(c+1)%len(life[0])
	return (fs[c-1], fs[c], fs[i], life[f][c-1], life[f][i], fi[c-1], fi[c], fi[i]).count('#')

	return 

def check(candidate):
    assert candidate((['.']), 0, 0) == 0

    assert candidate((['..', '..']), 0, 0) == 0

    assert candidate((['..', '..']), 0, 1) == 0

    assert candidate((['##', '..']), 0, 0) == 2

    assert candidate((['##', '..']), 0, 1) == 2

    assert candidate((['#.', '.#']), 0, 0) == 4

    assert candidate((['##', '##']), 0, 0) == 8

    assert candidate((['.#.', '#.#', '.#.']), 1, 1) == 4

    assert candidate((['.#.', '..#', '.#.']), 1, 1) == 3
# ¿Como conectarme con SQLALCHEMY a una basededatos `dbname` con usuario `user`, contraseña `password`, host `host` y ?
def f_34346(dbname, user, password, host):
	
	port = 3306
	engine = sqlalchemy.create_engine('mysql://'+user+':'+password+'@+'+str(host)+'/'+dbname+'?charset=utf8&use_unicode=0', pool_recycle=port)
	connection = engine.connect()

	return 

import sqlalchemy
from unittest.mock import Mock

def check(candidate):
    class my_engine:
        def __init__(self):
            pass
        def connect(self):
            return 0
    engine = my_engine()
    sqlalchemy.create_engine = Mock(return_value = engine)
    try:
        candidate('gaurishankar', 'hyena', 'hyena123', '127.0.0.1')
    except:
        assert False
# ¿Cómo calcular el máximo común divisor entre dos números `a` y `b`?
def f_26959():
	def mcd(a,b):
	    return next((i for i in range(min(a,b),0,-1) if a%i==0 and b%i==0), 0)
	return mcd

def check(candidate):
    assert candidate()(25, 30) == 5

    assert candidate()(24, 30) == 6

    assert candidate()(23, 30) == 1
# ¿Cómo capturar la salida del terminal después de ejecutar un comando `command`?
def f_44385(command):
	process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=None, shell=True)
	
	output = process.communicate()
	
	print(output[0])
	return output

import subprocess
from unittest.mock import Mock

def check(candidate):
    class Process:
        def __init__(self):
            pass
        def communicate(self):
            return [1, 2, 3]
    proc = Process()
    subprocess.Popen = Mock(return_value = proc)
    assert candidate('python3')[0] == 1
# ¿Cómo convertir un string `S` a un entero?
def f_28562(S):
	return int(S)

def check(candidate):
    assert candidate('123') == 123

    assert candidate('10000') == 10000

    assert candidate('0') == 0
# ¿Cómo renombrar un archivo con nombre `old` a `new`?
def f_17560(old, new):
	return os.rename(old, new)

import os
from unittest.mock import Mock

def check(candidate):
    os.rename = Mock()
    try:
        candidate('a.py', 'b.py')
    except:
        assert False
# ¿Cómo buscar todos los archivos con extensión `.ext` en la ruta `ruta` y buscar las coincidencias entre ellos?
def f_41536(ruta):
	
	path = ruta
	extension = '*.ext'

	def comparar_linea(file1, file2):
		data1 = [line.strip() for line in file1.readlines()]
		data2 = [line.strip() for line in file2.readlines()]
		same = set(data1).intersection(data2)
		return same

	def buscarCoincidencias(path, extension):
		with open('some_output_file.txt', 'w') as file_out:
			os.chdir(path)
			files = glob.glob(extension)
			print(files)
			for i in range(len(files)):
				for j in range(i+1, len(files)):
					with open(files[i]) as file1:
						with open(files[j], 'r') as file2:
							same = comparar_linea(file1, file2)
							file_out.write(files[i] + "-"+ files[j] + ": "+str(same)+"\n")

	buscarCoincidencias(path, extension)

	return 

import os
import glob
from unittest.mock import Mock

def check(candidate):
    file_name = 'some_output_file.txt'
    arr = ['a.ext', 'b.ext', 'c.ext']
    for file in arr:
        with open (file, 'w') as f:
            f.write('1')


    os.chdir = Mock()
    candidate('/')
    f = open('some_output_file.txt')
    lines = f.readlines()
    assert len(lines) == 3
    f.close()
# ¿Cómo sumar los valores del vector `x` a todas las columnas de la matriz `M`?
def f_40594(M, x):
	return M.transpose() + x.transpose()

import numpy as np

def check(candidate):
    M = np.array([[1,2],[3,4],[5,6]])
    x = np.array([10, 100, 1000])
    assert np.all(candidate(M, x) == np.array([[ 11, 103, 1005],[12, 104, 1006]]))
# ¿Cómo multiplicar la matriz `A` y la matriz `B`?
def f_61810(A, B):
	return [[sum(x * B[i][col] for i,x in enumerate(fila)) for col in range(len(B[0]))] for fila in A]

import numpy as np

def check(candidate):
    assert (candidate([[1,2],[3,4]], [[5,6],[7,8]]) == [[19, 22], [43, 50]]) or            (candidate(np.array([[1,2],[3,4]]), np.array([[5,6],[7,8]]))) == np.array([[19, 22], [43, 50]])
# ¿Cómo obtener la posición de un dato `x` en una lista `list`?
def f_63234(x, list):
	return list.index(x)

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

    assert candidate(0, [0,0,0,0]) == 0
# ¿Cómo concatenar un `INT` y un `STR`?
def f_57263(INT, STR):
	return repr(INT) + STR

def check(candidate):
    assert candidate(2, 'a') == '2a'

    assert candidate(-1, ' ') == '-1 '
# ¿Cómo eliminar duplicados en una lista `L`?
def f_87813(L):
	return list(set(L))

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

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

    assert candidate([]) == []
# ¿Cómo obtener el tipo de una variable `x`?
def f_15622(x):
	return type(x)

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

    assert candidate({'a': None}) == dict

    assert candidate(123) == int

    assert candidate(12.34) == float
# ¿Cómo sumar todos los elementos de una `lista`?
def f_201210(lista):
	return sum(lista)

def check(candidate):
    assert (candidate([1,2,3]) - 6) < 1e-6

    assert (candidate([0.0, 3.5, 2.7, 1.8, 2.0]) - 10.0) < 1e-6
# ¿Cómo crear una lista `L` con `n` números aleatorios?
def f_124063(n):
	L = [random.randint(0, 1000) for i in range(n)]
	return L

import random

def check(candidate):
    assert len(candidate(100)) == 100

    assert len(candidate(0)) == 0
# ¿Cómo redondear decimales hacia arriba de un número `num`?
def f_8510(num):
	return math.ceil(num)

import math

def check(candidate):
    assert candidate(3.8) == 4

    assert candidate(4.0) == 4

    assert candidate(76.4) == 77
# ¿Cómo contar las vocales en una cadena `s`?
def f_114782(s):
	return sum([int(c in 'aeiouAEIOU') for c in s])

def check(candidate):
    assert candidate('mvfbgndvsh') == 0

    assert candidate('vowel') == 2

    assert candidate('AAAAABBC') == 5
# ¿Cómo crear una matriz `matriz` con `n` filas y `m` columnas?
def f_159996(n, m):
	matriz = []
	
	for i in range(n):
	    matriz.append([])
	    for j in range(m):
	        matriz[i].append(random.randint(0, 100))
	return matriz

import random 

def check(candidate):
    matriz = candidate(2,3)
    assert len(matriz) == 2 and all(len(row)==3 for row in matriz)
# ¿Cómo crear una matriz `matriz` con `n` filas y `m` columnas?
def f_159996(n, m):
	matriz = np.random.randint(0, 100, size=(n, m))
	return matriz

import numpy as np

def check(candidate):
    matriz = candidate(2,3)
    assert len(matriz) == 2 and all(len(row)==3 for row in matriz)
# ¿Cómo seleccionar un elemento aleatorio de una lista `l`?
def f_14454(l):
	shuffle(l)
	sel = l[0]
	return sel

import random
from random import shuffle

def check(candidate):
    results = [candidate([1,2,3,4,5]) for i in range(10)]
    assert all([(x in [1,2,3,4,5]) for x in results])
    assert len(set(results)) > 1
# ¿Cómo seleccionar un elemento aleatorio de una lista `l`?
def f_14454(l):
	sel = random.sample(l, 1)
	return sel

import random

def check(candidate):
    results = [candidate([1,2,3,4,5])[0] for i in range(10)]
    assert all([(x in [1,2,3,4,5]) for x in results])
    assert len(set(results)) > 0
# ¿Cómo encontrar el mayor elemento en la posición `n` una lista de listas `l`?
def f_46558(l, n):
	return max(l, key=itemgetter(n))[n]

from operator import itemgetter 

def check(candidate):
    assert candidate([[1,2,3],[4,5,6], [-1,-2,0]], 0) == 4
# "Cómo convertir una lista `list` de tipo `str` a una de tipo `int`"
def f_213125(list):
	for i in range(len(list)):
	    list[i] = int(list[i])
	return list

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

    assert candidate(['100','444','45']) == [100, 444, 45]
# ¿Cómo hallar el numero mas repetido de una `lista`?
def f_151572(lista):
	return Counter(lista).most_common()[0][0]

from collections import Counter

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

    assert candidate([8,2,5,7,3,7]) == 7
# ¿Cómo obtener toda una columna `c` de una matriz `m`?
def f_115010(c, m):
	return np.array(m)[:, c]

import numpy as np 

def check(candidate):
    assert all(candidate(1, np.array([[1,2],[3,4],[5,6]])) == np.array([2, 4, 6]))
# ¿Cómo crear una función para eliminar un elemento `n` de una lista `L`?
def f_206450(L, n):
	L.remove(n)
	return L

def check(candidate):
    L = [i for i in range(8)]
    assert candidate(L, 3) == [0,1,2,4,5,6,7]

    L = [0,1,2,4,5,6,7]
    assert candidate(L, 5) == [0,1,2,4,6,7]

    L = [0,1,2,4,6,7]
    assert candidate(L, 0) == [1,2,4,6,7]
# ¿Cómo realizar una sumatoria de una lista `L` sin utilizar ciclos?
def f_148791(L):
	return sum(L)

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

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

    assert candidate([3.4, 5.8, 6.6, 19.2]) == 35
# ¿Cómo generar una matríz de `M`x`N` con una lista `L`?
def f_8239(L, M, N):
	return np.array(L).reshape(M,N)

import numpy as np 

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

    assert np.all(candidate([i for i in range(100)], 10, 10) == np.array([[i*10+j for j in range(10)] for i in range(10)]))
# ¿Cómo mostrar la posición de los elementos repetidos en una lista `L`?
def f_83439(L):
	return [i for i,x in enumerate(L) if L.count(x) > 1]

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

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

    assert candidate([100, 101, 102, 100]) == [0, 3]
# ¿Cómo contar cuántas veces se repite un carácter en una cadena `S`?
def f_188925(S):
	return Counter(S)

from collections import Counter

def check(candidate):
    assert candidate('apple') == Counter({'a': 1, 'e': 1, 'l': 1, 'p': 2})

    assert candidate('') == Counter({})
# ¿Cómo dividir una lista `L` en una lista de listas cada `n` datos?
def f_134908(L, n):
	return [L[i:i + n] for i in range(0, len(L), n)]

import os

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

    assert candidate([1,2,3,4],1) == [[1],[2],[3],[4]]
# ¿Cómo saber cuántas mayúsculas `M`, cuántas minúsculas `m` y cuántos números `n` tiene un string `S`?
def f_52839(S):
	M = len([c for c in S if c.isupper()])
	m = len([c for c in S if c.islower()])
	n = len([c for c in S if c.isdigit()])
	return M, m, n

def check(candidate):
    assert candidate('ceg242AABd  ') == (3,4,3)

    assert candidate('12233457') == (0,0,8)
# ¿Cómo convertir un número binario `n` a entero?
def f_50423(n):
	return int(n, 2)

def check(candidate):
    assert candidate('1100') == 12

    assert candidate('001010111') == 87

    assert candidate('0') == 0
# ¿Cómo escoger cuatro valores aleatorios `L1`, `L2`, `L3`, `L4` de una cadena `S` sin repetir?
def f_39861(S):
	L1, L2, L3, L4 = random.sample(S, 4)
	return L1, L2, L3, L4

import random 

def check(candidate):
    L1, L2, L3, L4 = candidate([1,2,3,4,5,6,7,8])
    s = set([L1,L2,L3,L4])
    assert len(s) == 4
    assert s < set([i+1 for i in range(8)])
# ¿Cómo crear una lista de tuplas de 2 valores a partir de una lista `lista`?
def f_22582(lista):
	return list(zip(*[iter(lista)]*2))

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

    assert candidate([1,'a',33.5,None]) == [(1,'a'),(33.5,None)]
# ¿Cómo obtener la raíz digital de un número `num`?
def f_1651(num):
	return sum([int(c) for c in str(num)])

def check(candidate):
    assert candidate(10) == 1

    assert candidate(100) == 1

    assert candidate(1234) == 10
# ¿Cómo obtener los dos últimos dígitos del año seguidos del día del año desde un datetime `date`?
def f_1139(date):
	return date.strftime('%y%j')

import datetime

def check(candidate):
    date = datetime.datetime.now()
    assert candidate(date) == date.strftime('%y%j')
# ¿Cómo convertir de minúsculas a mayúsculas un string `S`?
def f_15727(S):
	return S.upper()

def check(candidate):
    assert candidate('mystring') == 'MYSTRING'

    assert candidate('myString') == 'MYSTRING'

    assert candidate('MySTRinG') == 'MYSTRING'

    assert candidate('MYSTRING') == 'MYSTRING'
# ¿Cómo dividir un número entero `num` por un número `num1` decimal?
def f_47500(num, num1):
	return num / num1

def check(candidate):
    assert (candidate(1, 1.0) - 1.0) < 1e-6

    assert (candidate(10, 3.3) - 3.0303) < 0.01
# ¿Cómo calcular el número de palabras `num` que contengan la letra `ch` en un texto `S`?
def f_49118(S):
	num = sum([int('ch' in w) for w in S.split()])
	return num

def check(candidate):
    assert candidate('chain of words color cook zero chaos') == 2
# ¿Cómo puedo multiplicar dos listas de `INT` `L1` y `L2` ?
def f_96261(L1, L2):
	return list(map(operator.mul, L1, L2))

import operator

def check(candidate):
    assert candidate([3,4,2,6],[98,80,86,78]) == [294, 320, 172, 468]

    assert candidate([i for i in range(10)], [0 for i in range(10)]) == [0,0,0,0,0,0,0,0,0,0]
# ¿Cómo puedo multiplicar dos listas de `INT` `L1` y `L2` ?
def f_96261(L1, L2):
	return np.multiply(L1,L2)

import numpy as np

def check(candidate):
    assert all(candidate(np.array([3,4,2,6]),np.array([98,80,86,78])) == np.array([294, 320, 172, 468]))

    assert all(candidate(np.array([i for i in range(10)]), np.array([0 for i in range(10)])) == np.array([0,0,0,0,0,0,0,0,0,0]))
# ¿Cómo obtener las posiciones del array `L` donde encuentre un valor `x`?
def f_24577(L, x):
	return np.where(L == x)

import numpy as np

def check(candidate):
    assert candidate(np.array([1,2,3,4,5]), 4)[0].tolist() == [3]

    assert candidate(np.array([1,2,3,4,5]), 100)[0].tolist() == []
# ¿Cómo crear un dataframe `df1` a partir de otro dataframe `df` filtrando columnas que contengan únicamente datos de tipo ´type´?
def f_148266(df, type):
	df1 = df.select_dtypes(include=[type])
	return df1

import numpy as np
import pandas as pd

def check(candidate):
    assert candidate(pd.DataFrame({'a':[1,2,3], 'b':[1.,2.,3.]}), np.float).equals(pd.DataFrame({'b':[1.,2.,3.]}))