task_id
int64 19.3k
41.9M
| prompt
stringlengths 17
68
| suffix
stringlengths 0
22
| canonical_solution
stringlengths 6
153
| test_start
stringlengths 22
198
| test
list | entry_point
stringlengths 7
10
| intent
stringlengths 19
200
| library
list |
|---|---|---|---|---|---|---|---|---|
638,048 |
def f_638048(list_of_pairs):
return
|
sum([pair[0] for pair in list_of_pairs])
|
def check(candidate):
|
[
"\n assert candidate([(5, 9), (-1, -2), (4, 2)]) == 8\n"
] |
f_638048
|
sum the first value in each tuple in a list of tuples `list_of_pairs` in python
|
[] |
|
14,950,260 |
def f_14950260():
return
|
ast.literal_eval("{'code1':1,'code2':1}")
|
import ast
def check(candidate):
|
[
"\n d = candidate()\n exp_result = {'code1' : 1, 'code2': 1}\n for key in d:\n if key not in exp_result:\n assert False\n else:\n assert d[key] == exp_result[key]\n"
] |
f_14950260
|
convert unicode string u"{'code1':1,'code2':1}" into dictionary
|
[
"ast"
] |
|
11,416,772 |
def f_11416772(mystring):
return
|
[word for word in mystring.split() if word.startswith('$')]
|
def check(candidate):
|
[
"\n str = \"$abc def $efg $hij klm $\"\n exp_result = ['$abc', '$efg', '$hij', '$']\n assert sorted(candidate(str)) == sorted(exp_result)\n"
] |
f_11416772
|
find all words in a string `mystring` that start with the `$` sign
|
[] |
|
11,331,982 |
def f_11331982(text):
|
return text
|
text = re.sub('^https?:\\/\\/.*[\\r\\n]*', '', text, flags=re.MULTILINE)
|
import re
def check(candidate):
|
[
"\n assert candidate(\"https://www.wikipedia.org/ click at\") == \"\"\n"
] |
f_11331982
|
remove any url within string `text`
|
[
"re"
] |
34,945,274 |
def f_34945274(A):
return
|
np.where(np.in1d(A, [1, 3, 4]).reshape(A.shape), A, 0)
|
import numpy as np
def check(candidate):
|
[
"\n A = np.array([[6, 8, 1, 3, 4], [-1, 0, 3, 5, 1]])\n B = np.array([[0, 0, 1, 3, 4], [0, 0, 3, 0, 1]])\n assert np.array_equal(candidate(A), B)\n"
] |
f_34945274
|
replace all elements in array `A` that are not present in array `[1, 3, 4]` with zeros
|
[
"numpy"
] |
|
15,819,980 |
def f_15819980(a):
return
|
np.mean(a, axis=1)
|
import numpy as np
def check(candidate):
|
[
"\n A = np.array([[6, 8, 1, 3, 4], [-1, 0, 3, 5, 1]])\n B = np.array([4.4, 1.6])\n assert np.array_equal(candidate(A), B)\n"
] |
f_15819980
|
calculate mean across dimension in a 2d array `a`
|
[
"numpy"
] |
|
19,894,365 |
def f_19894365():
return
|
subprocess.call(['/usr/bin/Rscript', '--vanilla', '/pathto/MyrScript.r'])
|
from unittest.mock import Mock
import subprocess
def check(candidate):
|
[
"\n subprocess.call = Mock(return_value = 0)\n assert candidate() == 0\n"
] |
f_19894365
|
running r script '/pathto/MyrScript.r' from python
|
[
"subprocess"
] |
|
19,894,365 |
def f_19894365():
return
|
subprocess.call('/usr/bin/Rscript --vanilla /pathto/MyrScript.r', shell=True)
|
from unittest.mock import Mock
import subprocess
def check(candidate):
|
[
"\n subprocess.call = Mock(return_value = 0)\n assert candidate() == 0\n"
] |
f_19894365
|
run r script '/usr/bin/Rscript --vanilla /pathto/MyrScript.r'
|
[
"subprocess"
] |
|
33,058,590 |
def f_33058590(df):
return
|
df.fillna(df.mean(axis=0))
|
import pandas as pd
import numpy as np
def check(candidate):
|
[
"\n df = pd.DataFrame([[1,2,3],[4,5,6],[7.0,np.nan,9.0]], columns=[\"c1\",\"c2\",\"c3\"]) \n res = pd.DataFrame([[1,2,3],[4,5,6],[7.0,3.5,9.0]], columns=[\"c1\",\"c2\",\"c3\"])\n assert candidate(df).equals(res)\n"
] |
f_33058590
|
replacing nan in the dataframe `df` with row average
|
[
"numpy",
"pandas"
] |
|
12,400,256 |
def f_12400256():
return
|
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1347517370))
|
import time
def check(candidate):
|
[
"\n assert candidate() == \"2012-09-13 06:22:50\"\n"
] |
f_12400256
|
Convert unix timestamp '1347517370' to formatted string '%Y-%m-%d %H:%M:%S'
|
[
"time"
] |
|
23,359,886 |
def f_23359886(a):
return
|
a[np.where((a[:, (0)] == 0) * (a[:, (1)] == 1))]
|
import numpy as np
def check(candidate):
|
[
"\n a = np.array([[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11], [12, 13, 14]])\n res = np.array([[0, 1, 2]])\n assert np.array_equal(candidate(a), res)\n"
] |
f_23359886
|
selecting rows in Numpy ndarray 'a', where the value in the first column is 0 and value in the second column is 1
|
[
"numpy"
] |
|
4,383,082 |
def f_4383082(words):
return
|
re.split(' +', words)
|
import regex as re
def check(candidate):
|
[
"\n s = \"hello world sample text\"\n res = [\"hello\", \"world\", \"sample\", \"text\"]\n assert candidate(s) == res\n"
] |
f_4383082
|
separate words delimited by one or more spaces into a list
|
[
"regex"
] |
|
14,637,696 |
def f_14637696(words):
return
|
len(max(words, key=len))
|
def check(candidate):
|
[
"\n assert candidate([\"hello\", \"world\", \"sample\", \"text\", \"superballer\"]) == 11\n"
] |
f_14637696
|
length of longest element in list `words`
|
[] |
|
3,933,478 |
def f_3933478(result):
return
|
result[0]['from_user']
|
def check(candidate):
|
[
"\n Contents = [{\"hi\": 7, \"bye\": 4, \"from_user\": 0}, {1: 2, 3: 4, 5: 6}]\n assert candidate(Contents) == 0\n"
] |
f_3933478
|
get the value associated with unicode key 'from_user' of first dictionary in list `result`
|
[] |
|
39,112,645 |
def f_39112645():
return
|
[line.split() for line in open('File.txt')]
|
def check(candidate):
|
[
"\n with open('File.txt','w') as fw:\n fw.write(\"hi hello cat dog\")\n assert candidate() == [['hi', 'hello', 'cat', 'dog']]\n"
] |
f_39112645
|
Retrieve each line from a file 'File.txt' as a list
|
[] |
|
1,031,851 |
def f_1031851(a):
return
|
dict((v, k) for k, v in a.items())
|
def check(candidate):
|
[
"\n a = {\"one\": 1, \"two\": 2}\n assert candidate(a) == {1: \"one\", 2: \"two\"}\n"
] |
f_1031851
|
swap keys with values in a dictionary `a`
|
[] |
|
8,577,137 |
def f_8577137():
return
|
open('path/to/FILE_NAME.ext', 'w')
|
import os
def check(candidate):
|
[
"\n path1 = os.path.join(\"\", \"path\")\n os.mkdir(path1)\n path2 = os.path.join(\"path\", \"to\")\n os.mkdir(path2)\n candidate()\n assert os.path.exists('path/to/FILE_NAME.ext')\n"
] |
f_8577137
|
Open a file `path/to/FILE_NAME.ext` in write mode
|
[
"os"
] |
|
17,926,273 |
def f_17926273(df):
return
|
df.groupby(['col1', 'col2'])['col3'].nunique().reset_index()
|
import pandas as pd
def check(candidate):
|
[
"\n data = [[1, 1, 1], [1, 1, 1], [1, 1, 2], [1, 2, 3], [1, 2, 3], [1, 2, 3], \n [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 2, 3], [2, 2, 3], [2, 2, 3]]\n expected = [[1, 1, 2], [1, 2, 1], [2, 1, 3], [2, 2, 1]]\n df = pd.DataFrame(data, columns = ['col1', 'col2', 'col3'])\n expected_df = pd.DataFrame(expected, columns = ['col1', 'col2', 'col3'])\n df1 = candidate(df)\n assert pd.DataFrame.equals(expected_df, df1)\n"
] |
f_17926273
|
count distinct values in a column 'col3' of a pandas dataframe `df` group by objects in 'col1' and 'col2'
|
[
"pandas"
] |
|
3,735,814 |
def f_3735814(dict1):
return
|
any(key.startswith('EMP$$') for key in dict1)
|
def check(candidate):
|
[
"\n assert candidate({'EMP$$': 1, 'EMP$$112': 4}) == True\n",
"\n assert candidate({'EMP$$': 1, 'EM$$112': 4}) == True\n",
"\n assert candidate({'EMP$33': 0}) == False\n"
] |
f_3735814
|
Check if any key in the dictionary `dict1` starts with the string `EMP$$`
|
[] |
|
3,735,814 |
def f_3735814(dict1):
return
|
[value for key, value in list(dict1.items()) if key.startswith('EMP$$')]
|
def check(candidate):
|
[
"\n assert sorted(candidate({'EMP$$': 1, 'EMP$$112': 4})) == [1, 4]\n",
"\n assert sorted(candidate({'EMP$$': 1, 'EM$$112': 4})) == [1]\n",
"\n assert sorted(candidate({'EMP$33': 0})) == []\n"
] |
f_3735814
|
create list of values from dictionary `dict1` that have a key that starts with 'EMP$$'
|
[] |
|
26,097,916 |
def f_26097916(sf):
|
return df
|
df = pd.DataFrame({'email': sf.index, 'list': sf.values})
|
import pandas as pd
def check(candidate):
|
[
"\n dict = {'email1': [1.0, 5.0, 7.0], 'email2': [4.2, 3.6, -0.9]}\n sf = pd.Series(dict)\n k = [['email1', [1.0, 5.0, 7.0]], ['email2', [4.2, 3.6, -0.9]]]\n df1 = pd.DataFrame(k, columns=['email', 'list'])\n df2 = candidate(sf)\n assert pd.DataFrame.equals(df1, df2)\n"
] |
f_26097916
|
convert a pandas series `sf` into a pandas dataframe `df` with columns `email` and `list`
|
[
"pandas"
] |
4,048,964 |
def f_4048964(list):
return
|
'\t'.join(map(str, list))
|
def check(candidate):
|
[
"\n assert candidate(['hello', 'world', '!']) == 'hello\\tworld\\t!'\n",
"\n assert candidate([]) == \"\"\n",
"\n assert candidate([\"mconala\"]) == \"mconala\"\n",
"\n assert candidate([\"MCoNaLa\"]) == \"MCoNaLa\"\n"
] |
f_4048964
|
concatenate elements of list `list` by tabs ` `
|
[] |
|
3,182,716 |
def f_3182716():
return
|
'\xd0\xbf\xd1\x80\xd0\xb8'.encode('raw_unicode_escape')
|
def check(candidate):
|
[
"\n assert candidate() == b'\\xd0\\xbf\\xd1\\x80\\xd0\\xb8'\n"
] |
f_3182716
|
print unicode string '\xd0\xbf\xd1\x80\xd0\xb8' with utf-8
|
[] |
|
3,182,716 |
def f_3182716():
return
|
'Sopet\xc3\xb3n'.encode('latin-1').decode('utf-8')
|
def check(candidate):
|
[
"\n assert candidate() == \"Sopetón\"\n"
] |
f_3182716
|
Encode a latin character in string `Sopet\xc3\xb3n` properly
|
[] |
|
35,622,945 |
def f_35622945(s):
return
|
re.findall('n(?<=[^n]n)n+(?=[^n])(?i)', s)
|
import re
def check(candidate):
|
[
"\n assert candidate(\"ncnnnne\") == ['nnnn']\n",
"\n assert candidate(\"nn\") == []\n",
"\n assert candidate(\"ask\") == []\n"
] |
f_35622945
|
regex, find "n"s only in the middle of string `s`
|
[
"re"
] |
|
5,306,756 |
def f_5306756():
return
|
'{0:.0f}%'.format(1.0 / 3 * 100)
|
def check(candidate):
|
[
"\n assert(candidate() == \"33%\")\n"
] |
f_5306756
|
display the float `1/3*100` as a percentage
|
[] |
|
2,878,084 |
def f_2878084(mylist):
|
return mylist
|
mylist.sort(key=lambda x: x['title'])
|
def check(candidate):
|
[
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] |
f_2878084
|
sort a list of dictionary `mylist` by the key `title`
|
[] |
2,878,084 |
def f_2878084(l):
|
return l
|
l.sort(key=lambda x: x['title'])
|
def check(candidate):
|
[
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] |
f_2878084
|
sort a list `l` of dicts by dict value 'title'
|
[] |
2,878,084 |
def f_2878084(l):
|
return l
|
l.sort(key=lambda x: (x['title'], x['title_url'], x['id']))
|
def check(candidate):
|
[
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] |
f_2878084
|
sort a list of dictionaries by the value of keys 'title', 'title_url', 'id' in ascending order.
|
[] |
9,323,159 |
def f_9323159(l1, l2):
return
|
heapq.nlargest(10, range(len(l1)), key=lambda i: abs(l1[i] - l2[i]))
|
import heapq
def check(candidate):
|
[
"\n l1 = [99, 86, 90, 70, 86, 95, 56, 98, 80, 81]\n l2 = [21, 11, 21, 1, 26, 40, 4, 50, 34, 37]\n res = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n assert candidate(l1, l2) == res\n"
] |
f_9323159
|
find 10 largest differences between each respective elements of list `l1` and list `l2`
|
[
"heapq"
] |
|
29,877,663 |
def f_29877663(soup):
return
|
soup.find_all('span', {'class': 'starGryB sp'})
|
import bs4
def check(candidate):
|
[
"\n html = '''<span class=\"starBig sp\">4.1</span>\n <span class=\"starGryB sp\">2.9</span>\n <span class=\"sp starGryB\">2.9</span>\n <span class=\"sp starBig\">22</span>'''\n soup = bs4.BeautifulSoup(html, features=\"html5lib\")\n res = '''[<span class=\"starGryB sp\">2.9</span>]'''\n assert(str(candidate(soup)) == res)\n"
] |
f_29877663
|
BeautifulSoup find all 'span' elements in HTML string `soup` with class of 'starGryB sp'
|
[
"bs4"
] |
|
24,189,150 |
def f_24189150(df, engine):
|
return
|
df.to_sql('test', engine)
|
import pandas as pd
from sqlalchemy import create_engine
def check(candidate):
|
[
"\n engine = create_engine('sqlite://', echo=False)\n df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})\n candidate(df, engine)\n result = pd.read_sql('SELECT name FROM test', engine)\n assert result.equals(df)\n"
] |
f_24189150
|
write records in dataframe `df` to table 'test' in schema 'a_schema' with `engine`
|
[
"pandas",
"sqlalchemy"
] |
30,766,151 |
def f_30766151(s):
return
|
re.sub('[^(){}[\]]', '', s)
|
import re
def check(candidate):
|
[
"\n assert candidate(\"(a(vdwvndw){}]\") == \"((){}]\"\n",
"\n assert candidate(\"12345\") == \"\"\n"
] |
f_30766151
|
Extract brackets from string `s`
|
[
"re"
] |
|
1,143,379 |
def f_1143379(L):
return
|
list(dict((x[0], x) for x in L).values())
|
def check(candidate):
|
[
"\n L = [['14', '65', 76], ['2', '5', 6], ['7', '12', 33], ['14', '22', 46]]\n res = [['14', '22', 46], ['2', '5', 6], ['7', '12', 33]]\n assert(candidate(L) == res)\n",
"\n assert candidate([\"a\", \"aa\", \"abc\", \"bac\"]) == [\"abc\", \"bac\"]\n"
] |
f_1143379
|
remove duplicate elements from list 'L'
|
[] |
|
12,330,522 |
def f_12330522(file):
return
|
[line.rstrip('\n') for line in file]
|
def check(candidate):
|
[
"\n res = ['1', '2', '3']\n f = open(\"myfile.txt\", \"a\")\n f.write(\"1\\n2\\n3\")\n f.close()\n f = open(\"myfile.txt\", \"r\")\n assert candidate(f) == res\n"
] |
f_12330522
|
read a file `file` without newlines
|
[] |
|
364,621 |
def f_364621(testlist):
return
|
[i for (i, x) in enumerate(testlist) if (x == 1)]
|
def check(candidate):
|
[
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist) == [0, 5, 7]\n",
"\n testlist = [0, -1]\n assert candidate(testlist) == []\n"
] |
f_364621
|
get the position of item 1 in `testlist`
|
[] |
|
364,621 |
def f_364621(testlist):
return
|
[i for (i, x) in enumerate(testlist) if (x == 1)]
|
def check(candidate):
|
[
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist) == [0, 5, 7]\n",
"\n testlist = [0, -1]\n assert candidate(testlist) == []\n"
] |
f_364621
|
get the position of item 1 in `testlist`
|
[] |
|
364,621 |
def f_364621(testlist, element):
return
|
testlist.index(element)
|
def check(candidate):
|
[
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist, 1) == 0\n",
"\n testlist = [1,2,3,5,3,1,2,1,6]\n try:\n candidate(testlist, 14)\n except:\n assert True\n"
] |
f_364621
|
get the position of item `element` in list `testlist`
|
[] |
|
13,145,368 |
def f_13145368(lis):
return
|
max(lis, key=lambda item: item[1])[0]
|
def check(candidate):
|
[
"\n lis = [(101, 153), (255, 827), (361, 961)]\n assert candidate(lis) == 361\n"
] |
f_13145368
|
find the first element of the tuple with the maximum second element in a list of tuples `lis`
|
[] |
|
13,145,368 |
def f_13145368(lis):
return
|
max(lis, key=itemgetter(1))[0]
|
from operator import itemgetter
def check(candidate):
|
[
"\n lis = [(101, 153), (255, 827), (361, 961)]\n assert candidate(lis) == 361\n"
] |
f_13145368
|
get the item at index 0 from the tuple that has maximum value at index 1 in list `lis`
|
[
"operator"
] |
|
2,689,189 |
def f_2689189():
|
return
|
time.sleep(1)
|
import time
def check(candidate):
|
[
"\n t1 = time.time()\n candidate()\n t2 = time.time()\n assert t2 - t1 > 1\n"
] |
f_2689189
|
Make a delay of 1 second
|
[
"time"
] |
12,485,244 |
def f_12485244(L):
return
|
""", """.join('(' + ', '.join(i) + ')' for i in L)
|
def check(candidate):
|
[
"\n L = [(\"abc\", \"def\"), (\"hij\", \"klm\")]\n assert candidate(L) == '(abc, def), (hij, klm)'\n"
] |
f_12485244
|
convert list of tuples `L` to a string
|
[] |
|
755,857 |
def f_755857():
|
return b
|
b = models.CharField(max_length=7, default='0000000', editable=False)
|
from django.db import models
def check(candidate):
|
[
"\n assert candidate().get_default() == '0000000'\n"
] |
f_755857
|
Django set default value of field `b` equal to '0000000'
|
[
"django"
] |
16,193,578 |
def f_16193578(list5):
return
|
sorted(list5, key = lambda x: (degrees(x), x))
|
from math import degrees
def check(candidate):
|
[
"\n list5 = [4, 1, 2, 3, 9, 5]\n assert candidate(list5) == [1, 2, 3, 4, 5, 9]\n"
] |
f_16193578
|
Sort lis `list5` in ascending order based on the degrees value of its elements
|
[
"math"
] |
|
16,041,405 |
def f_16041405(l):
return
|
(n for n in l)
|
def check(candidate):
|
[
"\n generator = candidate([1,2,3,5])\n assert str(type(generator)) == \"<class 'generator'>\"\n assert [x for x in generator] == [1, 2, 3, 5]\n"
] |
f_16041405
|
convert a list `l` into a generator object
|
[] |
|
18,837,607 |
def f_18837607(oldlist, removelist):
return
|
[v for i, v in enumerate(oldlist) if i not in removelist]
|
def check(candidate):
|
[
"\n assert candidate([\"asdf\",\"ghjk\",\"qwer\",\"tyui\"], [1,3]) == ['asdf', 'qwer']\n",
"\n assert candidate([1,2,3,4,5], [0,4]) == [2,3,4]\n"
] |
f_18837607
|
remove elements from list `oldlist` that have an index number mentioned in list `removelist`
|
[] |
|
4,710,067 |
def f_4710067():
return
|
open('yourfile.txt', 'w')
|
def check(candidate):
|
[
"\n fw = candidate()\n assert fw.name == \"yourfile.txt\"\n assert fw.mode == 'w'\n"
] |
f_4710067
|
Open a file `yourfile.txt` in write mode
|
[] |
|
7,373,219 |
def f_7373219(obj, attr):
return
|
getattr(obj, attr)
|
def check(candidate):
|
[
"\n class Student:\n student_id = \"\"\n student_name = \"\"\n\n def __init__(self, student_id=101, student_name=\"Adam\"):\n self.student_id = student_id\n self.student_name = student_name\n\n student = Student()\n\n assert(candidate(student, 'student_name') == \"Adam\")\n assert(candidate(student, 'student_id') == 101)\n",
"\n class Student:\n student_id = \"\"\n student_name = \"\"\n\n def __init__(self, student_id=101, student_name=\"Adam\"):\n self.student_id = student_id\n self.student_name = student_name\n\n student = Student()\n\n try:\n value = candidate(student, 'student_none')\n except: \n assert True\n"
] |
f_7373219
|
get attribute 'attr' from object `obj`
|
[] |
|
8,171,751 |
def f_8171751():
return
|
reduce(lambda a, b: a + b, (('aa',), ('bb',), ('cc',)))
|
from functools import reduce
def check(candidate):
|
[
"\n assert candidate() == ('aa', 'bb', 'cc')\n"
] |
f_8171751
|
convert tuple of tuples `(('aa',), ('bb',), ('cc',))` to tuple
|
[
"functools"
] |
|
8,171,751 |
def f_8171751():
return
|
list(map(lambda a: a[0], (('aa',), ('bb',), ('cc',))))
|
def check(candidate):
|
[
"\n assert candidate() == ['aa', 'bb', 'cc']\n"
] |
f_8171751
|
convert tuple of tuples `(('aa',), ('bb',), ('cc',))` to list in one line
|
[] |
|
28,986,489 |
def f_28986489(df):
|
return df
|
df['range'].replace(',', '-', inplace=True)
|
import pandas as pd
def check(candidate):
|
[
"\n df = pd.DataFrame({'range' : [\",\", \"(50,290)\", \",,,\"]})\n res = pd.DataFrame({'range' : [\"-\", \"(50,290)\", \",,,\"]})\n assert candidate(df).equals(res)\n"
] |
f_28986489
|
replace a characters in a column of a dataframe `df`
|
[
"pandas"
] |
19,339 |
def f_19339():
return
|
zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
|
def check(candidate):
|
[
"\n assert [a for a in candidate()] == [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]\n"
] |
f_19339
|
unzip the list `[('a', 1), ('b', 2), ('c', 3), ('d', 4)]`
|
[] |
|
19,339 |
def f_19339(original):
return
|
([a for (a, b) in original], [b for (a, b) in original])
|
def check(candidate):
|
[
"\n original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]\n assert candidate(original) == (['a', 'b', 'c', 'd'], [1, 2, 3, 4])\n",
"\n original2 = [([], 1), ([], 2), (5, 3), (6, 4)]\n assert candidate(original2) == ([[], [], 5, 6], [1, 2, 3, 4])\n"
] |
f_19339
|
unzip list `original`
|
[] |
|
19,339 |
def f_19339(original):
return
|
((a for (a, b) in original), (b for (a, b) in original))
|
def check(candidate):
|
[
"\n original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]\n result = candidate(original)\n assert [a for gen in result for a in gen] == ['a','b','c','d',1,2,3,4]\n",
"\n original2 = [([], 1), ([], 2), (5, 3), (6, 4)]\n result2 = candidate(original2)\n assert [a for gen in result2 for a in gen] == [[], [], 5, 6, 1, 2, 3, 4]\n"
] |
f_19339
|
unzip list `original` and return a generator
|
[] |
|
19,339 |
def f_19339():
return
|
zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e',)])
|
def check(candidate):
|
[
"\n assert list(candidate()) == [('a', 'b', 'c', 'd', 'e')]\n"
] |
f_19339
|
unzip list `[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )]`
|
[] |
|
19,339 |
def f_19339():
return
|
list(zip_longest(('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e',)))
|
from itertools import zip_longest
def check(candidate):
|
[
"\n assert(candidate() == [('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, None)])\n"
] |
f_19339
|
unzip list `[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )]` and fill empty results with None
|
[
"itertools"
] |
|
1,960,516 |
def f_1960516():
return
|
json.dumps('3.9')
|
import json
def check(candidate):
|
[
"\n data = candidate()\n assert json.loads(data) == '3.9'\n"
] |
f_1960516
|
encode `Decimal('3.9')` to a JSON string
|
[
"json"
] |
|
1,024,847 |
def f_1024847(d):
|
return d
|
d['mynewkey'] = 'mynewvalue'
|
def check(candidate):
|
[
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'mynewkey': 'mynewvalue'}\n"
] |
f_1024847
|
Add key "mynewkey" to dictionary `d` with value "mynewvalue"
|
[] |
1,024,847 |
def f_1024847(data):
|
return data
|
data.update({'a': 1, })
|
def check(candidate):
|
[
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] |
f_1024847
|
Add key 'a' to dictionary `data` with value 1
|
[] |
1,024,847 |
def f_1024847(data):
|
return data
|
data.update(dict(a=1))
|
def check(candidate):
|
[
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] |
f_1024847
|
Add key 'a' to dictionary `data` with value 1
|
[] |
1,024,847 |
def f_1024847(data):
|
return data
|
data.update(a=1)
|
def check(candidate):
|
[
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] |
f_1024847
|
Add key 'a' to dictionary `data` with value 1
|
[] |
35,837,346 |
def f_35837346(matrix):
return
|
max([max(i) for i in matrix])
|
def check(candidate):
|
[
"\n assert candidate([[1,2,3],[4,5,6],[7,8,9]]) == 9\n",
"\n assert candidate([[1.3,2.8],[4.2,10],[7.9,8.1,5]]) == 10\n"
] |
f_35837346
|
find maximal value in matrix `matrix`
|
[] |
|
20,457,038 |
def f_20457038(answer):
|
return answer
|
answer = str(round(answer, 2))
|
def check(candidate):
|
[
"\n assert candidate(2.34351) == \"2.34\"\n",
"\n assert candidate(99.375) == \"99.38\"\n",
"\n assert candidate(4.1) == \"4.1\"\n",
"\n assert candidate(3) == \"3\"\n"
] |
f_20457038
|
Round number `answer` to 2 precision after the decimal point
|
[] |
2,890,896 |
def f_2890896(s):
|
return ip
|
ip = re.findall('[0-9]+(?:\\.[0-9]+){3}', s)
|
import re
def check(candidate):
|
[
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 165.91.15.131</body></html>\") == [\"165.91.15.131\"]\n",
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 165.91.15.131 and this is not a IP Address: 165.91.15</body></html>\") == [\"165.91.15.131\"]\n",
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 192.168.1.1 & this is another IP address: 192.168.1.2</body></html>\") == [\"192.168.1.1\", \"192.168.1.2\"]\n"
] |
f_2890896
|
extract ip address `ip` from an html string `s`
|
[
"re"
] |
29,836,836 |
def f_29836836(df):
return
|
df.groupby('A').filter(lambda x: len(x) > 1)
|
import pandas as pd
def check(candidate):
|
[
"\n assert candidate(pd.DataFrame([[1, 2], [1, 4], [5, 6]], columns=['A', 'B'])).equals(pd.DataFrame([[1, 2], [1, 4]], columns=['A', 'B'])) is True\n",
"\n assert candidate(pd.DataFrame([[1, 2], [1, 4], [1, 6]], columns=['A', 'B'])).equals(pd.DataFrame([[1, 2], [1, 4], [1, 6]], columns=['A', 'B'])) is True\n"
] |
f_29836836
|
filter dataframe `df` by values in column `A` that appear more than once
|
[
"pandas"
] |
|
2,545,397 |
def f_2545397(myfile):
return
|
[x for x in myfile if x != '']
|
def check(candidate):
|
[
"\n with open('./tmp.txt', 'w') as fw: \n for s in [\"hello\", \"world\", \"!!!\"]:\n fw.write(f\"{s}\\n\")\n\n with open('./tmp.txt', 'r') as myfile:\n lines = candidate(myfile)\n assert isinstance(lines, list)\n assert len(lines) == 3\n assert lines[0].strip() == \"hello\"\n"
] |
f_2545397
|
append each line in file `myfile` into a list
|
[] |
|
2,545,397 |
def f_2545397():
|
return lst
|
lst = list(map(int, open('filename.txt').readlines()))
|
import pandas as pd
def check(candidate):
|
[
"\n with open('./filename.txt', 'w') as fw: \n for s in [\"1\", \"2\", \"100\"]:\n fw.write(f\"{s}\\n\")\n\n assert candidate() == [1, 2, 100]\n"
] |
f_2545397
|
Get a list of integers `lst` from a file `filename.txt`
|
[
"pandas"
] |
35,420,052 |
def f_35420052(plt, mappable, ax3):
|
return plt
|
plt.colorbar(mappable=mappable, cax=ax3)
|
import numpy as np
import matplotlib.pyplot as plt
from obspy.core.trace import Trace
from obspy.imaging.spectrogram import spectrogram
def check(candidate):
|
[
"\n spl1 = Trace(data=np.arange(0, 10))\n fig = plt.figure()\n ax1 = fig.add_axes([0.1, 0.75, 0.7, 0.2]) #[left bottom width height]\n ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.60], sharex=ax1)\n ax3 = fig.add_axes([0.83, 0.1, 0.03, 0.6])\n\n #make time vector\n t = np.arange(spl1.stats.npts) / spl1.stats.sampling_rate\n\n #plot waveform (top subfigure) \n ax1.plot(t, spl1.data, 'k')\n\n #plot spectrogram (bottom subfigure)\n spl2 = spl1\n fig = spl2.spectrogram(show=False, axes=ax2, wlen=10)\n mappable = ax2.images[0]\n candidate(plt, mappable, ax3)\n \n im=ax2.images\n assert im[-1].colorbar is not None\n"
] |
f_35420052
|
add color bar with image `mappable` to plot `plt`
|
[
"matplotlib",
"numpy",
"obspy"
] |
29,903,025 |
def f_29903025(df):
return
|
Counter(' '.join(df['text']).split()).most_common(100)
|
import pandas as pd
from collections import Counter
def check(candidate):
|
[
"\n df = pd.DataFrame({\"text\": [\n 'Python is a high-level, general-purpose programming language.', \n 'Its design philosophy emphasizes code readability with the use of significant indentation. Python is dynamically-typed and garbage-collected.'\n ]})\n assert candidate(df) == [('Python', 2),('is', 2),('a', 1),('high-level,', 1),('general-purpose', 1),\n ('programming', 1),('language.', 1),('Its', 1),('design', 1),('philosophy', 1),('emphasizes', 1),\n ('code', 1),('readability', 1),('with', 1), ('the', 1),('use', 1),('of', 1),('significant', 1),\n ('indentation.', 1),('dynamically-typed', 1),('and', 1),('garbage-collected.', 1)]\n"
] |
f_29903025
|
count most frequent 100 words in column 'text' of dataframe `df`
|
[
"collections",
"pandas"
] |
|
7,378,180 |
def f_7378180():
return
|
list(itertools.combinations((1, 2, 3), 2))
|
import itertools
def check(candidate):
|
[
"\n assert candidate() == [(1, 2), (1, 3), (2, 3)]\n"
] |
f_7378180
|
generate all 2-element subsets of tuple `(1, 2, 3)`
|
[
"itertools"
] |
|
4,530,069 |
def f_4530069():
return
|
datetime.now(pytz.utc)
|
import pytz
import time
from datetime import datetime, timezone
def check(candidate):
|
[
"\n assert (candidate() - datetime(1970, 1, 1).replace(tzinfo=timezone.utc)).total_seconds() - time.time() <= 1\n"
] |
f_4530069
|
get a value of datetime.today() in the UTC time zone
|
[
"datetime",
"pytz",
"time"
] |
|
4,842,956 |
def f_4842956(list1):
|
return list2
|
list2 = [x for x in list1 if x != []]
|
def check(candidate):
|
[
"\n assert candidate([[\"a\"], [], [\"b\"]]) == [[\"a\"], [\"b\"]]\n",
"\n assert candidate([[], [1,2,3], [], [\"b\"]]) == [[1,2,3], [\"b\"]]\n"
] |
f_4842956
|
Get a new list `list2`by removing empty list from a list of lists `list1`
|
[] |
4,842,956 |
def f_4842956(list1):
|
return list2
|
list2 = [x for x in list1 if x]
|
def check(candidate):
|
[
"\n assert candidate([[\"a\"], [], [\"b\"]]) == [[\"a\"], [\"b\"]]\n",
"\n assert candidate([[], [1,2,3], [], [\"b\"]]) == [[1,2,3], [\"b\"]]\n"
] |
f_4842956
|
Create `list2` to contain the lists from list `list1` excluding the empty lists from `list1`
|
[] |
9,262,278 |
def f_9262278(data):
return
|
HttpResponse(data, content_type='application/json')
|
import os
import json
from django.http import HttpResponse
from django.conf import settings
if not settings.configured:
settings.configure(DEBUG=True)
def check(candidate):
|
[
"\n if settings.DEBUG:\n assert candidate(json.dumps({\"Sample-Key\": \"Sample-Value\"})).content == b'{\"Sample-Key\": \"Sample-Value\"}'\n",
"\n if settings.DEBUG:\n assert candidate(json.dumps({\"Sample-Key\": \"Sample-Value\"}))['content-type'] == 'application/json'\n"
] |
f_9262278
|
Django response with JSON `data`
|
[
"django",
"json",
"os"
] |
|
17,284,947 |
def f_17284947(example_str):
return
|
re.findall('(.*?)\\[.*?\\]', example_str)
|
import re
def check(candidate):
|
[
"\n list_elems = candidate(\"Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]\")\n assert \"\".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'\n"
] |
f_17284947
|
get all text that is not enclosed within square brackets in string `example_str`
|
[
"re"
] |
|
17,284,947 |
def f_17284947(example_str):
return
|
re.findall('(.*?)(?:\\[.*?\\]|$)', example_str)
|
import re
def check(candidate):
|
[
"\n list_elems = candidate(\"Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]\")\n assert \"\".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'\n"
] |
f_17284947
|
Use a regex to get all text in a string `example_str` that is not surrounded by square brackets
|
[
"re"
] |
|
14,182,339 |
def f_14182339():
return
|
re.findall('\\(.+?\\)|\\w', '(zyx)bc')
|
import re
def check(candidate):
|
[
"\n assert candidate() == ['(zyx)', 'b', 'c']\n"
] |
f_14182339
|
get whatever is between parentheses as a single match, and any char outside as an individual match in string '(zyx)bc'
|
[
"re"
] |
|
14,182,339 |
def f_14182339():
return
|
re.findall('\\((.*?)\\)|(\\w)', '(zyx)bc')
|
import re
def check(candidate):
|
[
"\n assert candidate() == [('zyx', ''), ('', 'b'), ('', 'c')]\n"
] |
f_14182339
|
match regex '\\((.*?)\\)|(\\w)' with string '(zyx)bc'
|
[
"re"
] |
|
14,182,339 |
def f_14182339():
return
|
re.findall('\\(.*?\\)|\\w', '(zyx)bc')
|
import re
def check(candidate):
|
[
"\n assert candidate() == ['(zyx)', 'b', 'c']\n"
] |
f_14182339
|
match multiple regex patterns with the alternation operator `|` in a string `(zyx)bc`
|
[
"re"
] |
|
7,126,916 |
def f_7126916(elements):
|
return elements
|
elements = ['%{0}%'.format(element) for element in elements]
|
def check(candidate):
|
[
"\n elements = ['abc', 'def', 'ijk', 'mno']\n assert candidate(elements) == ['%abc%', '%def%', '%ijk%', '%mno%']\n",
"\n elements = [1, 2, 3, 4, 500]\n assert candidate(elements) == ['%1%', '%2%', '%3%', '%4%', '%500%']\n"
] |
f_7126916
|
formate each string cin list `elements` into pattern '%{0}%'
|
[] |
3,595,685 |
def f_3595685():
return
|
subprocess.Popen(['background-process', 'arguments'])
|
import subprocess
from unittest.mock import Mock
def check(candidate):
|
[
"\n subprocess.Popen = Mock(return_value = 0)\n assert candidate() == 0\n"
] |
f_3595685
|
Open a background process 'background-process' with arguments 'arguments'
|
[
"subprocess"
] |
|
18,453,566 |
def f_18453566(mydict, mykeys):
return
|
[mydict[x] for x in mykeys]
|
def check(candidate):
|
[
"\n mydict = {'one': 1, 'two': 2, 'three': 3}\n mykeys = ['three', 'one']\n assert candidate(mydict, mykeys) == [3, 1]\n",
"\n mydict = {'one': 1.0, 'two': 2.0, 'three': 3.0}\n mykeys = ['one']\n assert candidate(mydict, mykeys) == [1.0]\n"
] |
f_18453566
|
get list of values from dictionary 'mydict' w.r.t. list of keys 'mykeys'
|
[] |
|
12,692,135 |
def f_12692135():
return
|
dict([('Name', 'Joe'), ('Age', 22)])
|
def check(candidate):
|
[
"\n assert candidate() == {'Name': 'Joe', 'Age': 22}\n"
] |
f_12692135
|
convert list `[('Name', 'Joe'), ('Age', 22)]` into a dictionary
|
[] |
|
14,401,047 |
def f_14401047(data):
return
|
data.mean(axis=1).reshape(data.shape[0], -1)
|
import numpy as np
def check(candidate):
|
[
"\n data = np.array([[1, 2, 3, 4, 4, 3, 7, 1], [6, 2, 3, 4, 3, 4, 4, 1]])\n expected_res = np.array([[3.125], [3.375]])\n assert np.array_equal(candidate(data), expected_res)\n"
] |
f_14401047
|
average each two columns of array `data`
|
[
"numpy"
] |
|
18,886,596 |
def f_18886596(s):
return
|
s.replace('"', '\"')
|
def check(candidate):
|
[
"\n s = 'This sentence has some \"quotes\" in it'\n assert candidate(s) == 'This sentence has some \\\"quotes\\\" in it'\n"
] |
f_18886596
|
double backslash escape all double quotes in string `s`
|
[] |
|
5,932,059 |
def f_5932059(s):
return
|
re.split('(\\W+)', s)
|
import re
def check(candidate):
|
[
"\n s = \"this is a\\nsentence\"\n assert candidate(s) == ['this', ' ', 'is', ' ', 'a', '\\n', 'sentence']\n"
] |
f_5932059
|
split a string `s` into a list of words and whitespace
|
[
"re"
] |
|
9,938,130 |
def f_9938130(df):
return
|
df.plot(kind='barh', stacked=True)
|
import pandas as pd
def check(candidate):
|
[
"\n data = [[1, 3], [2, 5], [4, 8]]\n df = pd.DataFrame(data, columns = ['a', 'b'])\n assert str(candidate(df)).split('(')[0] == 'AxesSubplot'\n"
] |
f_9938130
|
plotting stacked barplots on a panda data frame `df`
|
[
"pandas"
] |
|
35,945,473 |
def f_35945473(myDictionary):
return
|
{i[1]: i[0] for i in list(myDictionary.items())}
|
def check(candidate):
|
[
"\n assert candidate({'a' : 'b', 'c' : 'd'}) == {'b': 'a', 'd': 'c'}\n"
] |
f_35945473
|
reverse the keys and values in a dictionary `myDictionary`
|
[] |
|
30,729,735 |
def f_30729735(myList):
return
|
[i for i, j in enumerate(myList) if 'how' in j.lower() or 'what' in j.lower()]
|
def check(candidate):
|
[
"\n assert candidate(['abc', 'how', 'what', 'def']) == [1, 2]\n"
] |
f_30729735
|
finding the index of elements containing substring 'how' and 'what' in a list of strings 'myList'.
|
[] |
|
1,303,243 |
def f_1303243(obj):
return
|
isinstance(obj, str)
|
def check(candidate):
|
[
"\n assert candidate('python3') == True\n",
"\n assert candidate(1.23) == False\n"
] |
f_1303243
|
check if object `obj` is a string
|
[] |
|
1,303,243 |
def f_1303243(o):
return
|
isinstance(o, str)
|
def check(candidate):
|
[
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] |
f_1303243
|
check if object `o` is a string
|
[] |
|
1,303,243 |
def f_1303243(o):
return
|
(type(o) is str)
|
def check(candidate):
|
[
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] |
f_1303243
|
check if object `o` is a string
|
[] |
|
1,303,243 |
def f_1303243(obj_to_test):
return
|
isinstance(obj_to_test, str)
|
def check(candidate):
|
[
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] |
f_1303243
|
check if `obj_to_test` is a string
|
[] |
|
8,177,079 |
def f_8177079(list1, list2):
|
return
|
list2.extend(list1)
|
def check(candidate):
|
[
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] |
f_8177079
|
append list `list1` to `list2`
|
[] |
8,177,079 |
def f_8177079(mylog, list1):
|
return
|
list1.extend(mylog)
|
def check(candidate):
|
[
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] |
f_8177079
|
append list `mylog` to `list1`
|
[] |
8,177,079 |
def f_8177079(a, c):
|
return
|
c.extend(a)
|
def check(candidate):
|
[
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] |
f_8177079
|
append list `a` to `c`
|
[] |
8,177,079 |
def f_8177079(mylog, list1):
|
return
|
for line in mylog:
list1.append(line)
|
def check(candidate):
|
[
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] |
f_8177079
|
append items in list `mylog` to `list1`
|
[] |
4,126,227 |
def f_4126227(a, b):
|
return
|
b.append((a[0][0], a[0][2]))
|
def check(candidate):
|
[
"\n a = [(1,2,3),(4,5,6)]\n b = [(0,0)]\n candidate(a, b)\n assert(b == [(0, 0), (1, 3)])\n"
] |
f_4126227
|
append a tuple of elements from list `a` with indexes '[0][0] [0][2]' to list `b`
|
[] |
34,902,378 |
def f_34902378(app):
|
return
|
app.config['SECRET_KEY'] = 'Your_secret_string'
|
from flask import Flask
def check(candidate):
|
[
"\n app = Flask(\"test\")\n candidate(app)\n assert app.config['SECRET_KEY'] == 'Your_secret_string'\n"
] |
f_34902378
|
Initialize `SECRET_KEY` in flask config with `Your_secret_string `
|
[
"flask"
] |
22,799,300 |
def f_22799300(out):
return
|
pd.DataFrame(out.tolist(), columns=['out-1', 'out-2'], index=out.index)
|
import numpy as np
import pandas as pd
from scipy import stats
def check(candidate):
|
[
"\n df = pd.DataFrame(dict(x=np.random.randn(100), y=np.repeat(list(\"abcd\"), 25)))\n out = df.groupby(\"y\").x.apply(stats.ttest_1samp, 0)\n test = pd.DataFrame(out.tolist())\n test.columns = ['out-1', 'out-2']\n test.index = out.index\n res = candidate(out)\n assert(test.equals(res))\n"
] |
f_22799300
|
unpack a series of tuples in pandas `out` into a DataFrame with column names 'out-1' and 'out-2'
|
[
"numpy",
"pandas",
"scipy"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.