neulab/odex huggingface dataset:
# 2次元配列`arr`の要素となっている1次元配列から先頭の値のみを抜き出す
def f_37146(arr):
	return arr[:, 0]

import numpy as np

def check(candidate):
    arr = np.array([[1,2],[3,4]])
    assert all(candidate(arr) == np.array([1,3]))

    arr = np.array([[3,4,5]])
    assert all(candidate(arr) == np.array([3]))
# データフレームを辞書型オブジェクトに変換する
def f_25263(df):
	return df.to_dict()

import pandas as pd

def check(candidate):
    df = pd.DataFrame([[1,2,3], [4,5,6], [6,5,4], [2,1,0]], columns=["AA", "b", "3"])
    assert candidate(df) == {'AA': {0: 1, 1: 4, 2: 6, 3: 2},
                             'b': {0: 2, 1: 5, 2: 5, 3: 1},
                             '3': {0: 3, 1: 6, 2: 4, 3: 0}}

    df = pd.DataFrame([[1,2,3], [4,5,6], [6,5,4], [2,1,0]])
    assert candidate(df) == {0: {0: 1, 1: 4, 2: 6, 3: 2},
                             1: {0: 2, 1: 5, 2: 5, 3: 1},
                             2: {0: 3, 1: 6, 2: 4, 3: 0}}
# HTMLテーブルから各行を取得する
def f_28178(soup):
	return soup.find('tbody').find_all('tr')

from bs4 import BeautifulSoup

def check(candidate):
    soup = BeautifulSoup("<td><b>Address:</b></td><tbody><tr>My home address</tr></tbody>")
    result = candidate(soup)
    assert len(result) == 1
    assert result[0].contents == ['My home address']
# POSTデータをcgi.FieldStrageで受け取る
def f_8656():
	class handler(http.server.BaseHTTPRequestHandler):
	    def do_POST(self):
	        os.environ['REQUEST_METHOD'] = 'POST'
	        form = cgi.FieldStorage(self.rfile, self.headers)
	return handler

import cgi
import http.server

def check(candidate):
    try:
        handler = candidate()
        srvr = http.server.HTTPServer(('127.0.0.1', 8889), handler)
    except:
        assert False
# リスト`li`の中からランダムに一つの要素を選択する
def f_9836(li):
	return random.choice(li)

import random

def check(candidate):
    assert candidate([1,2,3]) in [1,2,3]
# 要素が数値のリスト型データ`d`をバイナリデータ`binaryVrc.bin`として保存する
def f_1589(d):
	X = np.array(d, dtype='float32')
	X.tofile('binaryVec.bin')
	return 

import numpy as np

def check(candidate):
    f = open('binaryVec.bin', 'w')
    f.close()
    
    d = np.array([1., 2., 3.])
    candidate(d)
    d1 = np.fromfile('binaryVec.bin', dtype='float32')
    assert np.all(d == d1)
# 開いているファイル'f'を閉じる
def f_38532(f):
	f.close()
	return 

def check(candidate):
    f = open('tmp.txt', 'w')
    candidate(f)
    assert f.closed
# multipartのリクエストで複数のデータ`files`, `data`を`url'にPOSTする
def f_37696(files, url, data):
	return requests.post(url, files=files, data=data)

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')
    files = {'file': open(file_path, 'rb')}
    assert candidate(files, 'https://def.xyz', {'key':'value'}).status_code == 200
# クラス数の比率を保ったままデータを分割する
def f_29368(X, y):
	sss = StratifiedShuffleSplit()
	sss.get_n_splits(X, y)
	return sss

import numpy as np
import sklearn
from sklearn.model_selection import StratifiedShuffleSplit

def check(candidate):
    X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
    y = np.array([0, 0, 0, 1, 1, 1])
    assert candidate(X, y).__class__ == sklearn.model_selection._split.StratifiedShuffleSplit
# y軸のプロットの範囲を下限`low`、上限`high`に設定する
def f_40699(low, high):
	return plt.yticks(range(low,high))

import matplotlib.pyplot as plt

def check(candidate):
    assert len(candidate(20, 50)[0]) == 30

    assert len(candidate(0, 10)[0]) == 10
# グラフ上で選択されたデータの座標を表示する
def f_11011(fig, onclick):
	fig.canvas.mpl_connect('pick_event', onclick)
	return 

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

def check(candidate):
    def onclick(event):
        pass
    fig = plt.figure()
    X = [[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5]]
    Y = [[1,1,1,1,1],[2,2,2,2,2],[3,3,3,3,3]]
    Z = [[10,11,13,14,16],[5,8,7,7,7,],[0,0,0,9,8]]
    ax = Axes3D(fig)
    ax.scatter3D(np.ravel(X),np.ravel(Y),np.ravel(Z))
    try:
        candidate(fig, onclick)
    except:
        assert False
# 日本語（ひらがな、カタカナ、漢字）の判別をする正規表現を得る
def f_42344():
	return re.compile('[ぁ-んァ-ン一-龥]+')

import re

def check(candidate):
    pattern = candidate()
    words = ['あいうえお', '546', 'たぬき', '饅頭', 'abdf', '#%&', '    ']
    ja_words = [pattern.findall(w) for w in words]
    ja_words = [a for jw in ja_words for a in jw]
    assert ja_words == ['あいうえお', 'たぬき', '饅頭']
# ブラウザオブジェクト`br`からsubmitした際の返り値を読みこむ
def f_17145(br):
	return br.submit().read()

import mechanize
import urllib.request
from unittest.mock import Mock

def check(candidate):
    br = mechanize.Browser()
    x = urllib.request.urlopen('https://www.wikipedia.org')
    br.submit = Mock(return_value = x)
    assert b'Wikipedia' in candidate(br)
# タプル`data`を空白区切りで表示する
def f_38824(data):
	return [print(*i) for i in data]

import sys
from io import StringIO

def check(candidate):
    stdout = sys.stdout
    s = StringIO()
    sys.stdout = s
    candidate([[1],[2],[3],[4],[5],[6]])
    sys.stdout = stdout    
    s.seek(0)
    assert len(s.read()) == 12
# タプル`data`を空白区切りで表示する
def f_38824(data):
	for i in data:
	     print(' '.join(str(j) for j in i))
	return 

import sys
from io import StringIO

def check(candidate):
    stdout = sys.stdout
    s = StringIO()
    sys.stdout = s
    candidate([[1],[2],[3],[4],[5],[6]])
    sys.stdout = stdout    
    s.seek(0)
    assert len(s.read()) == 12
# タプル`data`を空白区切りで表示する
def f_38824(data):
	for i in data:
	     print(' '.join(map(str, i)))
	return 

import sys
from io import StringIO

def check(candidate):
    stdout = sys.stdout
    s = StringIO()
    sys.stdout = s
    candidate([[1],[2],[3],[4],[5],[6]])
    sys.stdout = stdout    
    s.seek(0)
    assert len(s.read()) == 12
# `n`×`n`のテンソルの要素のうち0以上の値の和を計算する
def f_35299(n):
	
	t = 5
	z = tf.constant(0, shape=[n, n], dtype=tf.int32)
	abs = tf.maximum(t, z)
	result = tf.reduce_sum(abs)

	return result

import tensorflow as tf

def check(candidate):
    assert str(type(candidate(4))).split(' ')[1] == "'tensorflow.python.framework.ops.EagerTensor'>"
# データフレーム`df`の列ラベル`x`の各行のデータに対して正規表現`pat`を適用する
def f_38328(df, pat):
	return df.x.str.extract(pat)

import pandas as pd

def check(candidate):
    df = pd.DataFrame({'x': ['車5(0.8km)', '5', '車27(8.6km)']}, index=[1, 2, 3])
    pat = r'車(\d*)'
    ref = df.x.str.extract(pat)
    assert candidate(df, pat).count()[0] == 2
# ファイル`file`を上書きモードで開く
def f_37418(file):
	return open(file, 'w')

def check(candidate):
    f = candidate('test.txt')
    assert f.name == 'test.txt'
    assert f.mode == 'w'
# データ`x_list`、`y_list`からなるグラフを描画する指定する
def f_41200(x_list, y_list):
	return plt.plot(x_list, y_list)

import matplotlib.pyplot as plt

def check(candidate):
    assert isinstance(candidate([1, 3, 5], [2, 4, 6]), list)
# 2つのデータフレーム`a`と`b`を行方向に結合する
def f_43369(a, b):
	return pd.DataFrame([a, b])

import numpy as np
import pandas as pd

def check(candidate):
    assert candidate([1,1,1], [2,2,2]).equals(pd.DataFrame([[1,1,1], [2,2,2]]))

    assert candidate([1,2,1], [2,3,4]).equals(pd.DataFrame([[1,2,1], [2,3,4]]))

    assert candidate([0], [1]).equals(pd.DataFrame([[0], [1]]))
# 文字コードをutf-8に指定してファイル`file`を開く
def f_24438(file):
	return codecs.open(file, 'r', 'utf-8')

import codecs

def check(candidate):
    with open('test.txt', 'w') as fw:
        fw.write('hello world!')
    fr = candidate('test.txt')
    assert fr.name == 'test.txt'
# ファイル`file`をバイナリデータとして開く
def f_10215(file):
	with open(file, 'rb') as f:
	    data = f.read()
	return data

def check(candidate):
    with open('tmp.pkl', 'wb') as fw:
        fw.write(b"hello world!")
    assert candidate('tmp.pkl') == b"hello world!"
# オブジェクト`x`をファイル`hoge.pkl`に保存する
def f_18992(x):
	return pickle.dump(x, open('hoge.pkl', 'wb'))

import pickle

def check(candidate):
    x = [100, 435, 56, 2, 99]
    candidate(x)
    with open('hoge.pkl', 'rb') as fr:
        data = pickle.load(fr)
        assert data == x
# データフレーム`df`の複数の異なる要素を辞書型オブジェクト`change_dict`のキーと要素のペアに従って置き換える
def f_38400(df, change_dict):
	return df.replace(change_dict)

import pandas as pd

def check(candidate):
    df = pd.DataFrame({'kai': ['2', 'B1', '23-49', 'M2']}, index=[1, 2, 3, 4])
    change_dict = {'2': '22', 'B1': 'B2'}
    assert candidate(df, change_dict).equals(df.replace(change_dict))
# 連番になっている100個のCSVファイル'file_%d'をリストに取り込む
def f_35793():
	data = []
	i = 0
	while(i<100):
	    data.append(pd.read_csv('file_%d.csv'%i))
	    i+=1
	return data

import pandas as pd

def check(candidate):
    for i in range(0, 100):
        with open ('file_'+str(i)+'.csv', 'w') as f:
            f.write(str(i))
    
    assert len(candidate()) == 100
# 学習データのベクトル`vectorized`をファイル'my_vector.npy`に保存する
def f_20549(vectorized):
	numpy.save('my_vector.npy', vectorized.toarray())
	return 

import os
import numpy
from sklearn.feature_extraction import DictVectorizer

def check(candidate):
    measurements = [
        {'city': 'Dubai', 'temperature': 33.},
        {'city': 'London', 'temperature': 12.},
        {'city': 'San Francisco', 'temperature': 18.},
    ]
    vec = DictVectorizer()
    candidate(vec.fit_transform(measurements))
    assert os.path.exists('my_vector.npy')
# リスト'li'のインデックスと要素に繰り返し処理を行って表示する
def f_9518(li):
	for i, name in enumerate(li):
	    print(i, name)
	return 

import sys

def check(candidate):
    file_name = 'output.txt'
    f = open(file_name, 'w')
    sys.stdout = f
    candidate([1, 3])
    f.close()
    with open (file_name, 'r') as f:
        lines = f.readlines()
        assert lines[0] == '0 1\n'
        assert lines[1] == '1 3\n'
        
    f = open(file_name, 'w')
    sys.stdout = f
    candidate(['abc', 'def'])
    f.close()
    with open (file_name, 'r') as f:
        lines = f.readlines()
        assert lines[0] == '0 abc\n'
        assert lines[1] == '1 def\n'
# numpy配列`arr`に対して数値`n`より大きい要素の合計及び個数を求めて表示する
def f_38760(arr, n):
	return arr[arr > n].sum(), numpy.sum(arr > n)

import numpy
import numpy as np 

def check(candidate):
    assert candidate(np.array([1,2,3,4]), 3) == (4, 1)
# イテラブルオブジェクト`data`の要素から文字列`area_code`と`prefecture`を探し、それぞれキーと要素に持つ辞書`results`を作る
def f_35102(data):
	results = {}
	for item in data:
	    results[item.find('areacode').text] = item.find('prefecture').text
	return results

import xml.etree.ElementTree as ET

def check(candidate):
    data_temp = [
        '<?xml version="1.0" encoding="UTF-8" ?><root><areacode>area1</areacode><prefecture>prefecture1</prefecture></root>', 
        '<?xml version="1.0" encoding="UTF-8" ?><root><areacode>area2</areacode><prefecture>prefecture2</prefecture></root>'
    ]
    data = []
    for tr in data_temp:
        data.append(ET.ElementTree(ET.fromstring(tr)))
    
    res = candidate(data)
    assert "area1" in res
    assert "area2" in res
    assert "prefecture1" == res["area1"]
    assert "prefecture2" == res["area2"]
# 要素がNumPy配列のリスト`arr_list`を2次元のNumPy配列に変換する
def f_41440(arr_list):
	return np.stack(arr_list)

import numpy as np 

def check(candidate):
    arr_list = [np.array([1,2]), np.array([3,4]), np.array([5,6])]
    assert candidate(arr_list).tolist() == [[1, 2], [3, 4], [5, 6]]
# HTMLをパースしたオブジェクト`soup`からタグ`p`をすべて見つける
def f_35741(soup):
	return soup.find_all('p')

from bs4 import BeautifulSoup

def check(candidate):
    soup = BeautifulSoup('<p>text</p>')
    assert candidate(soup)[0].contents == ['text']
# データフレーム`df`の列`c_label`をGroupbyでまとめたデータの最後の行を取り出す
def f_40444(df, c_label):
	return df.groupby([c_label]).last()

import pandas as pd

def check(candidate):
    df = pd.DataFrame({'利用者ID': [1, 2], 'コンテンツID': ['a', 'b'], '値': [170, 45]})
    c_label = ['利用者ID', 'コンテンツID']
    assert candidate(df, c_label).equals(df.groupby([c_label]).last())
# リスト`a_list`の要素の中のリスト`b_list`の要素と一致するものを表示する
def f_39240(a_list, b_list):
	return [i for i in b_list if i in a_list]

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

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

    assert candidate([1,2,3], []) == []
# 英名の月を含む日付フォーマット'%d%b%Y'の文字列`dt_s`をdatetime型に変換する
def f_39375(dt_s):
	return datetime.strptime(dt_s,'%d%b%Y')

from datetime import datetime

def check(candidate):
    assert candidate('10OCT2017') == datetime.strptime('10OCT2017','%d%b%Y')
# 数値`n`を分割してリストに格納する
def f_38960(n):
	return [int(c) for c in n]

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

    assert candidate('') == []

    assert candidate('0') == [0]
# seleniumtでFirefox仕様時にjavascriptを無効にする
def f_33908():
	profile = webdriver.FirefoxProfile()
	profile.DEFAULT_PREFERENCES['frozen']['javascript.enabled'] = False
	profile.set_preference("app.update.auto", False)
	profile.set_preference("app.update.enabled", False)
	profile.update_preferences()
	return profile

import selenium
from selenium import webdriver
from selenium.webdriver.firefox.options import Options

def check(candidate):
    profile = candidate()
    assert profile.__class__ == selenium.webdriver.firefox.firefox_profile.FirefoxProfile
# seleniumtでFirefox仕様時にjavascriptを無効にする
def f_33908():
	
	options = Options()
	options.set_preference('javascript.enabled', False)

	return options

import selenium
from selenium import webdriver
from selenium.webdriver.firefox.options import Options

def check(candidate):
    options = candidate()
    assert options.preferences == {'javascript.enabled': False}
# 文字列`s`が数を表す文字かどうか判定する
def f_19770(s):
	return s.isnumeric()

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

    assert candidate('a') == False
# ソケット情報を保存する
def f_29614():
	return socket.socket()

import socket

def check(candidate):
    assert candidate().__class__ == socket.socket
# ディレクトリ`dir`内にあるファイルのリストを取得する
def f_41032(dir):
	return os.listdir(dir)

import os

def check(candidate):
    assert candidate('.') == os.listdir('.')
# 画像`img`が空かどうかを判定する
def f_37709(img):
	return img is None

import cv2
import numpy as np 

def check(candidate):
    assert candidate(None) == True
    blank_image = np.zeros((10,5,3), np.uint8)
    assert candidate(blank_image) == False
# `x`に関する多項式`f`の各次数の係数を求めてリストにする `coeffs`
def f_33677(f):
	
	p = Poly(f, x)
	coeffs = p.coeffs()

	return coeffs

from sympy import Poly, var

def check(candidate):
    var('x a b')
    f = a*(2*x**2 - 1) + 4*x**3 + x*(b - 3)
    co = candidate(f)
    assert co == [4, 2*a, b - 3, -a]
# 変数`a`と`b`のビット演算
def f_37449(a, b):
	return a & b

def check(candidate):
    assert candidate(22, 56678) == 6

    assert candidate(0, -1) == 0

    assert candidate(1000, 1) == 0

    assert candidate(479, 234) == 202
# グローバル変数の一覧を得る
def f_42442():
	return globals()

def check(candidate):
    assert candidate() == globals()
# リスト`word_list'内に出現する単語を数える
def f_38030(word_list):
	return Counter(word_list)

from collections import Counter

def check(candidate):
    assert candidate(['this', 'is', 'a', 'word', 'List']) == Counter({'List': 1, 'a': 1, 'is': 1, 'this': 1, 'word': 1})

    assert candidate(['List']) == Counter({'List': 1})

    assert candidate(['this', 'this', 'this', 'this', 'this']) == Counter({'this': 5})

    assert candidate([]) == Counter({})
# 関数`f`と`g`を受け取って関数同士の和を計算する関数`add_functions`を定義する
def f_38724(f, g):
	def add_functions(f, g):
	    return lambda x: f(x) + g(x)
	return add_functions

def check(candidate):
    def f(x): return x
    def g(y): return 1
    assert candidate(f,g)(f,g)(3) == 4
# オブジェクト`obj`のクラスを得る
def f_22439(obj):
	return type(obj)

def check(candidate):
    assert candidate('this is a string') == str

    assert candidate(123.4) == float

    assert candidate(400) == int

    assert candidate({}) == dict 

    assert candidate([{}]) == list
# オブジェクト`obj`のクラスを得る
def f_22439(obj):
	return obj.__class__

def check(candidate):
    assert candidate('this is a string') == str

    assert candidate(123.4) == float

    assert candidate(400) == int

    assert candidate({}) == dict 

    assert candidate([{}]) == list
# 指定したURL`url`の内容を表示する
def f_39340(url):
	return urllib.request.urlopen(url).read()

import urllib

def check(candidate):
    url = "http://www.google.com"
    text = b"google"
    assert text in candidate(url)
# フォルダ名`foldername'とファイル名`filename`を結合したパスを得る
def f_39589(foldername, filename):
	return os.path.join(foldername, filename)

import os

def check(candidate):
    assert candidate('folder', 'file') == 'folder/file'

    assert candidate('', 'file') == 'file'

    assert candidate('.', 'file') == './file'
# X軸の範囲を下限`l`と上限`h`に指定する
def f_23577(ax, l, h):
	return ax.set_xlim(l, h)

import matplotlib.pyplot as plt

def check(candidate):
    fig, ax = plt.subplots()
    assert candidate(ax, 10, 100) == (10.0, 100.0)
# 整数`src`を特定の範囲`range`の倍数で切り上げる
def f_41087(src, range):
	return int(math.ceil(src/float(range)) * range)

import math

def check(candidate):
    assert candidate(22, 50) == 50

    assert candidate(100, 23) == 115

    assert candidate(0, 13) == 0

    assert candidate(12, 1) == 12

    assert candidate(34, 23) == 46
# 整数`src`を特定の範囲`range`の倍数で切り上げる
def f_41087(src, range):
	return src if src % range == 0 else src + range - src % range

def check(candidate):
    assert candidate(22, 50) == 50

    assert candidate(100, 23) == 115

    assert candidate(0, 13) == 0

    assert candidate(12, 1) == 12

    assert candidate(34, 23) == 46
# 要素数の総和が`N`となる制約の下、`n`次元のランダムベクトル`answer`を生成する
def f_40711(n, N):
	random_numbers = np.random.rand(n)
	answer = N * random_numbers / np.sum(random_numbers)
	return answer

import numpy as np 

def check(candidate):
    answer = candidate(20, 5)
    assert answer.shape == (20,)
    assert max(answer) < 5
# 要素数の総和が`N`となる制約の下、`n`次元のランダムベクトル`answer`を生成する
def f_40711(n, N):
	answer = np.random.dirichlet(np.ones(n)) * N
	return answer

import numpy as np 

def check(candidate):
    answer = candidate(20, 5)
    assert answer.shape == (20,)
# リスト`li`をランダムに並び替える
def f_31924(li):
	random.shuffle(li)
	return li

import random

def check(candidate):
    li_a = [i for i in range(10)]
    li_a = candidate(li_a)
    assert sorted(li_a) == [i for i in range(10)]
# 複数のリスト`a`と`b`の直積（デカルト積）を生成し、要素の組み合わせの結果を得る
def f_40343(a, b):
	return itertools.product(a,b)

import itertools

def check(candidate):
    assert list(candidate([1,2],[3,4])) == [(1, 3), (1, 4), (2, 3), (2, 4)]
# データフレーム`df`の列`a`を正規表現`reg'で抽出する
def f_36217(df, reg):
	return df['a'].str.extract(reg, expand=True)

import pandas as pd

def check(candidate):
    df = pd.DataFrame([['abc def'],['123 567'], ['qqq eee']], columns=['a'])
    reg = r'(.{3})$'
    assert candidate(df, reg).equals(df['a'].str.extract(reg, expand=True))
# 2つのリスト`factories'と`shops`の要素の組み合わせをキーとし、タプル`costs`各要素を要素等する辞書型オブジェクトを作る
def f_27871(factories, shops, costs):
	return {f+s : cost for ((f,s), cost) in zip(product(factories,shops), costs)}

from itertools import product

def check(candidate):
    assert candidate(['A', 'B'], ['1', '2'], [8, 10, 12, 16]) == {'A1': 8, 'A2': 10, 'B1': 12, 'B2': 16}
# 2つのリスト`factories'と`shops`の要素の組み合わせをキーとし、タプル`costs`各要素を要素等する辞書型オブジェクトを作る
def f_27871(factories, shops, cost):
	root = [''.join((x, y)) for x, y in itertools.product(factories, shops)]
	d = dict(zip(root, cost))
	return d

import itertools

def check(candidate):
    factories = ['A', 'B', 'C', 'D']
    shops = ['1', '2', '3', '4', '5']
    costs = ( 8, 10, 12, 16, 20,
             12,  8,  6, 10, 16,
             18,  7,  4,  3,  4,
             12, 10, 12, 16, 20 )    
    res_dict = candidate(factories, shops, costs)
    assert list(res_dict.items()) == [
        ('A1', 8), ('A2', 10), ('A3', 12), ('A4', 16), ('A5', 20), 
        ('B1', 12), ('B2', 8), ('B3', 6), ('B4', 10), ('B5', 16), 
        ('C1', 18), ('C2', 7), ('C3', 4), ('C4', 3), ('C5', 4), 
        ('D1', 12), ('D2', 10), ('D3', 12), ('D4', 16), ('D5', 20), 
    ]
# キーワード引数として用いる事ができないHTML5のdata-属性、例えば`data-locel`が`address`に一致するものをオブジェクト`soup`から検索する
def f_40676(soup):
	return soup.find_all(attrs={"data-locate": "address"})

from bs4 import BeautifulSoup

def check(candidate):
    soup = BeautifulSoup('<div data-locate="address">foo!</div>')
    res = candidate(soup)
    assert len(res) == 1
    assert res[0].attrs == {'data-locate': 'address'} 
    assert res[0].text == "foo!"
# 文字列を要素に持つリスト`li`の頭文字を結合した文字列`s`を得る
def f_42256(li):
	s = ''.join(i[0] for i in li)
	return s

def check(candidate):
    assert candidate(['sda', 'dahkdja', 'uehjkw', 'ebhjda']) == 'sdue'

    assert candidate(['happy', 'apple', 'pear', 'pie', 'yummy']) == 'happy'

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

    assert candidate([str(i) for i in range(10)]) == '0123456789'
# 文字列を要素に持つリスト`li`の頭文字を結合した文字列`s`を得る
def f_42256(li):
	
	s = ''
	for line in li:
		s += line[0]

	return s

def check(candidate):
    assert candidate(['sda', 'dahkdja', 'uehjkw', 'ebhjda']) == 'sdue'

    assert candidate(['happy', 'apple', 'pear', 'pie', 'yummy']) == 'happy'

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

    assert candidate([str(i) for i in range(10)]) == '0123456789'
# リスト`li`の中に要素`i`が含まれていない条件分岐を行う
def f_18967(li, i):
	return i not in li

def check(candidate):
    assert candidate(['sda', 'dahkdja', 'uehjkw'], "sda") == False

    assert candidate(['happy', 'apple', 'pear', 'pie', 'yummy'], "dog") == True

    assert candidate([str(i) for i in range(10)], 10) == True
# サーバーに送信するデータ`req_data`をUTF-8で符号化する
def f_37648(req_data):
	return json.dumps(req_data).encode('utf-8')

import json

def check(candidate):
    assert candidate({'test': 'just a test'}) == b'{"test": "just a test"}'
# 文字列`str`内の、日本語で挟まれた空白を削除する
def f_39502(str):
	return re.sub('([あ-んア-ン一-鿐ー])\s+((?=[あ-んア-ン一-鿐ー]))',r'\1\2', str)

import re

def check(candidate):
    assert candidate('日 本 語 で 挟 ま れ た 空 白 を 削 除 す る') == '日本語で挟まれた空白を削除する'
# 文字列の変数`s`と`n`をUTF-8に変換して結合する
def f_16805(s, n):
	return u'{0}{1}'.format(s, n)

def check(candidate):
    assert candidate('abd', 35) == 'abd35'

    assert candidate('', 12.34) == '12.34'

    assert candidate([1,2,3], 'string') == '[1, 2, 3]string'
# 1が`N`個, 2が`N`個, ..., `M`が`N`個並ぶリストを生成する
def f_40978(M, N):
	return [x+1 for x in range(M) for y in range(N)]

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

    assert candidate(2, 1) == [1,2]
# 1が`N`個, 2が`N`個, ..., `M`が`N`個並ぶリストを生成する
def f_40978(M, N):
	return [i // N + 1 for i in range(N * M)]

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

    assert candidate(2, 1) == [1,2]
# distplotで表示したデータ`x`に関するヒストグラム上のピンの高さをリストとして得る
def f_39379(x):
	return [h.get_height() for h in sns.distplot(x).patches]

import seaborn as sns
import numpy as np
sns.set()
np.random.seed(0)

def check(candidate):
      x = np.random.rand(100)
      res = candidate(x)
      assert res == [
          1.2707405677074517,
          0.8132739633327691,
          1.0674220768742593,
          1.0674220768742597,
          0.8641035860410673
      ]
# グラフの描画範囲`ax`を正方形にする
def f_38415():
	ax=plt.subplot(aspect='equal')
	return ax

import matplotlib.pyplot as plt 

def check(candidate):
    res_ax = candidate()
    assert res_ax.get_xlim() == res_ax.get_ylim()
# 文字列型変数`string`の値を数値型のインスタンス変数として評価する
def f_37757(string):
	return eval(string)

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

    assert candidate("[1,2]") == [1,2]
# JSONを表す文字列`s_json`から辞書型オブジェクト`d`を得る
def f_34422(s_json):
	d = json.loads(s_json)
	return d

import json

def check(candidate):
    assert candidate('{"a":123,"b":45.6}') == {'a':123, 'b':45.6}
# HTMLパースオブジェクト`soup`の中でHTMLタグの`a_id`の属性値を取得する
def f_27686(soup):
	return soup.get('a_id')

from bs4 import BeautifulSoup

def check(candidate):
    soup = BeautifulSoup('<p>riginsf</p>')
    soup['a_id'] = 'some value'
    assert candidate(soup) == 'some value'
# カレントディレクトリにある特定の拡張子`.dat`をもつファイルの拡張子を`.gui`にすべて書き換える
def f_41054():
	return [os.rename(f, f.replace('.dat', '.gui')) for f in os.listdir('.') if not f.startswith('.')]

import os

def check(candidate):
    assert all([((item is None) or item.endswiths('.gui')) for item in candidate()])
# データフレーム`df`のインデックスをリセットした新たなデータフレーム`df2`を得る
def f_43303(df):
	df2 = df.reset_index(drop=True)
	return df2

import pandas as pd

def check(candidate):
    df = pd.DataFrame(data={'col1':[0,1,2,3], 'col2': pd.Series([2,3], index=[2,3])}, index=[0,2,1,3])
    assert candidate(df).equals(pd.DataFrame(data={'col1': [0,1,2,3], 'col2': pd.Series([2,3], index=[1,3])}, index=[0,1,2,3]))