stop_tokens
listlengths 4
4
| prompt
stringlengths 102
757
| prompt_terminology
stringclasses 1
value | doctests
stringclasses 1
value | name
stringlengths 15
44
| tests
stringlengths 204
2.01k
| original
stringlengths 106
135
| language
stringclasses 1
value |
|---|---|---|---|---|---|---|---|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//2つの正の整数nとmが与えられており、あなたのタスクはnからmまでの
// 整数（nとmを含む）の平均を計算することである。
// 答えを最も近い整数に丸め、2進数に変換せよ。
// nがmより大きい場合は-1を返す。
// 例:
// >>> rounded_avg(1, 5)
// "0b11"
// >>> rounded_avg(7, 5)
// -1
// >>> rounded_avg(10, 20)
// "0b1111"
// >>> rounded_avg(20, 33)
// "0b11010"
function rounded_avg(n: number, m: number): string | number {
|
reworded
|
transform
|
HumanEval_103_rounded_avg
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = rounded_avg;
assert.deepEqual(candidate(1, 5),"0b11");
assert.deepEqual(candidate(7, 13),"0b1010");
assert.deepEqual(candidate(964, 977),"0b1111001010");
assert.deepEqual(candidate(996, 997),"0b1111100100");
assert.deepEqual(candidate(560, 851),"0b1011000010");
assert.deepEqual(candidate(185, 546),"0b101101110");
assert.deepEqual(candidate(362, 496),"0b110101101");
assert.deepEqual(candidate(350, 902),"0b1001110010");
assert.deepEqual(candidate(197, 233),"0b11010111");
assert.deepEqual(candidate(7, 5),-1);
assert.deepEqual(candidate(5, 1),-1);
assert.deepEqual(candidate(5, 5),"0b101");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_103_rounded_avg.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//正の整数xのリストが与えられたとき、偶数桁の要素を持たない全ての
// 要素をソートしたリストを返す。
// 注意: 返されるリストは昇順にソートされていなければならない。
// 例えば:
// >>> unique_digits([15, 33, 1422, 1])
// [1, 15, 33]
// >>> unique_digits([152, 323, 1422, 10])
// []
function unique_digits(x: number[]): number[] {
|
reworded
|
transform
|
HumanEval_104_unique_digits
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = unique_digits;
assert.deepEqual(candidate([15, 33, 1422, 1]),[1, 15, 33]);
assert.deepEqual(candidate([152, 323, 1422, 10]),[]);
assert.deepEqual(candidate([12345, 2033, 111, 151]),[111, 151]);
assert.deepEqual(candidate([135, 103, 31]),[31, 135]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_104_unique_digits.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//整数の配列が与えられたとき、1から9までの整数をソートし、
// 得られた配列を逆順にし、各桁を以下の数字に相当する名前に置き換える。
// "One"、"Two"、"Three"、"Four"、"Five"、"Six"、"Seven"、"Eight"、"Nine "
// 例えば:
// >>> by_length([2, 1, 1, 4, 5, 8, 2, 3])
// ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
// もし空配列なら、空配列を返す:
//>>> by_length([])
// []
// もし変な数値が配列に含まれていたら無視せよ:
// >>> by_length([1, -1, 55])
// ["One"]
function by_length(arr: number[]): string[] {
|
reworded
|
transform
|
HumanEval_105_by_length
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = by_length;
assert.deepEqual(candidate([2, 1, 1, 4, 5, 8, 2, 3]),["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]);
assert.deepEqual(candidate([]),[]);
assert.deepEqual(candidate([1, -1, 55]),["One"]);
assert.deepEqual(candidate([1, -1, 3, 2]),["Three", "Two", "One"]);
assert.deepEqual(candidate([9, 4, 8]),["Nine", "Eight", "Four"]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//iは1から始まる。iの階乗は1からiまでの数の掛け算（1 * 2 * ... * i）である。
// 例:
// >>> f(5)
// [1, 2, 6, 24, 15]
function f(n: number): number[] {
|
reworded
|
transform
|
HumanEval_106_f
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = f;
assert.deepEqual(candidate(5),[1, 2, 6, 24, 15]);
assert.deepEqual(candidate(7),[1, 2, 6, 24, 15, 720, 28]);
assert.deepEqual(candidate(1),[1]);
assert.deepEqual(candidate(3),[1, 2, 6]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//与えられた正の整数 nに対して、範囲 1 から n まで（両端を含む）に存在する
// 偶数の回文数(integer palindrome)と奇数の回文数の個数をタプル形式で返す。
// 例 1:
// >>> even_odd_palindrome(3)
// [1, 2]
// 解説:
// 回文数は1、2、3であり、そのうち1つは偶数、2つは奇数である。
// 例 2:
// >>> even_odd_palindrome(12)
// [4, 6]
// 解説:
// 回文数は、1、2、3、4、5、6、7、8、9、11であり、そのうち4つは偶数、6つは奇数である。
// ノート:
// 1. 1 <= n <= 10^3
// 2. 返されるタプルは、それぞれ偶数と奇数の回文数を持つ。
function even_odd_palindrome(n: number): [number, number] {
|
reworded
|
transform
|
HumanEval_107_even_odd_palindrome
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = even_odd_palindrome;
assert.deepEqual(candidate(123),[8, 13]);
assert.deepEqual(candidate(12),[4, 6]);
assert.deepEqual(candidate(3),[1, 2]);
assert.deepEqual(candidate(63),[6, 8]);
assert.deepEqual(candidate(25),[5, 6]);
assert.deepEqual(candidate(19),[4, 6]);
assert.deepEqual(candidate(9),[4, 5]);
assert.deepEqual(candidate(1),[0, 1]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//count_nums 関数は、整数の配列を引数として受け取り、その配列内の各整数の各桁の合計が
// >0 となるような整数の個数を返す。負の数に関しては、最初の桁（符号付き桁）は負となる。
// たとえば、−123 の符号付き桁は −1, 2, 3 である。
// >>> count_nums([])
// 0
// >>> count_nums([-1, 11, -11])
// 1
// >>> count_nums([1, 1, 2])
// 3
function count_nums(arr: number[]): number {
|
reworded
|
transform
|
HumanEval_108_count_nums
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = count_nums;
assert.deepEqual(candidate([]),0);
assert.deepEqual(candidate([-1, -2, 0]),0);
assert.deepEqual(candidate([1, 1, 2, -2, 3, 4, 5]),6);
assert.deepEqual(candidate([1, 6, 9, -6, 0, 1, 5]),5);
assert.deepEqual(candidate([1, 100, 98, -7, 1, -1]),4);
assert.deepEqual(candidate([12, 23, 34, -45, -56, 0]),5);
assert.deepEqual(candidate([0, 1]),1);
assert.deepEqual(candidate([1]),1);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
// N個の整数arr[1], arr[2], ..., arr[N]なる配列 'arr' があります。
// この配列の数字はランダムな順番に並んでいます。あなたの課題は、以下の操作を何度でも行うことで、
// 配列を非減少.の順番にソートできるかどうかを判断することです。
// 操作として許されているのは「右シフト」です。
// 一回の「右シフト」操作とは、配列のすべての要素を右方向に一つずつずらすことを意味します。
// 配列の最後の要素は配列の先頭、すなわち0番目のインデックスに移動します。
// 上記の操作を行ってソートされた配列を得られる場合は true を、そうでない場合は false を返してください。
// 与えられた配列が空の場合は true を返してください。
// 注意：与えられたリストには一意の要素しか含まれていないことが保証されています。
// 例：
// >>> move_one_ball([3, 4, 5, 1, 2])
// true
// 説明：2回の右シフト操作を行うことで、与えられた配列を非減少の順序にすることができます。
// >>> move_one_ball([3, 5, 4, 1, 2])
// false
// 説明：どれだけ右シフト操作を行っても、与えられた配列を非減少の順序にすることはできません。
function move_one_ball(arr: number[]): boolean {
|
reworded
|
transform
|
HumanEval_109_move_one_ball
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = move_one_ball;
assert.deepEqual(candidate([3, 4, 5, 1, 2]),true);
assert.deepEqual(candidate([3, 5, 10, 1, 2]),true);
assert.deepEqual(candidate([4, 3, 1, 2]),false);
assert.deepEqual(candidate([3, 5, 4, 1, 2]),false);
assert.deepEqual(candidate([]),true);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//この問題では、2つの数のリストを受け取り、lst1を偶数のみのリストに
// するために、それらの間で要素の交換を行うことが可能かどうかを判断す
// る関数を実装する。
// lst1とlst2の間で交換される要素の数に制限はない。
// lst1とlst2の間で要素の交換を行い、lst1の要素をすべて偶数にすることが
// 可能であれば、"YES "を返す。
// そうでなければ "NO "を返す。
// 例えば:
// >>> exchange([1, 2, 3, 4], [1, 2, 3, 4])
// "YES"
// >>> exchange([1, 2, 3, 4], [1, 5, 3, 4])
// "NO"
// 受け取るリストは空でないと前提してよい。
function exchange(lst1: number[], lst2: number[]): string {
|
reworded
|
transform
|
HumanEval_110_exchange
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = exchange;
assert.deepEqual(candidate([1, 2, 3, 4], [1, 2, 3, 4]),"YES");
assert.deepEqual(candidate([1, 2, 3, 4], [1, 5, 3, 4]),"NO");
assert.deepEqual(candidate([1, 2, 3, 4], [2, 1, 4, 3]),"YES");
assert.deepEqual(candidate([5, 7, 3], [2, 6, 4]),"YES");
assert.deepEqual(candidate([5, 7, 3], [2, 6, 3]),"NO");
assert.deepEqual(candidate([3, 2, 6, 1, 8, 9], [3, 5, 5, 1, 1, 1]),"NO");
assert.deepEqual(candidate([100, 200], [200, 200]),"YES");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//空白で区切られた小文字を表す文字列が与えられる。最も出現回数が多い文字と
// 対応するカウントの辞書を返す。
// 複数の文字が同じ出現回数を持つ場合、それらすべてを返す。
// 例:
// >>> histogram("a b c")
// {"a": 1, "b": 1, "c": 1}
// >>> histogram("a b b a")
// {"a": 2, "b": 2}
// >>> histogram("a b c a b")
// {"a": 2, "b": 2}
// >>> histogram("b b b b a")
// {"b": 4}
// >>> histogram("")
// {}
function histogram(test: string): {[key: string]: number} {
|
reworded
|
transform
|
HumanEval_111_histogram
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = histogram;
assert.deepEqual(candidate("a b b a"),{"a": 2, "b": 2});
assert.deepEqual(candidate("a b c a b"),{"a": 2, "b": 2});
assert.deepEqual(candidate("a b c d g"),{"a": 1, "b": 1, "c": 1, "d": 1, "g": 1});
assert.deepEqual(candidate("r t g"),{"r": 1, "t": 1, "g": 1});
assert.deepEqual(candidate("b b b b a"),{"b": 4});
assert.deepEqual(candidate("r t g"),{"r": 1, "t": 1, "g": 1});
assert.deepEqual(candidate(""),{});
assert.deepEqual(candidate("a"),{"a": 1});
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//課題
// sとcの2つの文字列が与えられる。sに含まれる文字のうち、cに含まれる文字と
// 等しいものをすべて削除し、その結果の文字列が回文かどうかをチェックする。
// 文字列は、後ろから読んでも前から読んでも同じであれば回文と呼ばれる。
// 結果文字列とチェックのためのtrue/falseを含むタプルを返す必要がある。
// 例
// >>> reverse_delete("abcde", "ae")
// ["bcd", false]
// >>> reverse_delete("abcdef", "b")
// ["acdef", false]
// >>> reverse_delete("abcdedcba", "ab")
// ["cdedc", true]
function reverse_delete(s: string, c: string): [string, boolean] {
|
reworded
|
transform
|
HumanEval_112_reverse_delete
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = reverse_delete;
assert.deepEqual(candidate("abcde", "ae"),["bcd", false]);
assert.deepEqual(candidate("abcdef", "b"),["acdef", false]);
assert.deepEqual(candidate("abcdedcba", "ab"),["cdedc", true]);
assert.deepEqual(candidate("dwik", "w"),["dik", false]);
assert.deepEqual(candidate("a", "a"),["", true]);
assert.deepEqual(candidate("abcdedcba", ""),["abcdedcba", true]);
assert.deepEqual(candidate("abcdedcba", "v"),["abcdedcba", true]);
assert.deepEqual(candidate("vabba", "v"),["abba", true]);
assert.deepEqual(candidate("mamma", "mia"),["", true]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//数字のみで構成された文字列のリストを引数として受け取り、新しいリストを返します。
// 出力される新しいリストの各要素は、"the number of odd elements in the string i of the
// input."となりますが、この文字列内のすべての 'i' は、入力リストのi番目の文字列に含ま
// る奇数の数に置き換えられます。
// >>> odd_count(["1234567"])
// ["the number of odd elements 4n the str4ng 4 of the 4nput."]
// >>> odd_count(["3", "11111111"])
// ["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."]
function odd_count(lst: string[]): string[] {
|
reworded
|
transform
|
HumanEval_113_odd_count
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = odd_count;
assert.deepEqual(candidate(["1234567"]),["the number of odd elements 4n the str4ng 4 of the 4nput."]);
assert.deepEqual(candidate(["3", "11111111"]),["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."]);
assert.deepEqual(candidate(["271", "137", "314"]),["the number of odd elements 2n the str2ng 2 of the 2nput.", "the number of odd elements 3n the str3ng 3 of the 3nput.", "the number of odd elements 2n the str2ng 2 of the 2nput."]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//整数の配列 nums が与えられたとき、nums の空でない部分配列の最小和を求めよ。
// 例:
// >>> minSubArraySum([2, 3, 4, 1, 2, 4])
// 1
// >>> minSubArraySum([-1, -2, -3])
// -6
function minSubArraySum(nums: number[]): number {
|
reworded
|
transform
|
HumanEval_114_minSubArraySum
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = minSubArraySum;
assert.deepEqual(candidate([2, 3, 4, 1, 2, 4]),1);
assert.deepEqual(candidate([-1, -2, -3]),-6);
assert.deepEqual(candidate([-1, -2, -3, 2, -10]),-14);
assert.deepEqual(candidate([-9999999999999999]),-9999999999999999);
assert.deepEqual(candidate([0, 10, 20, 1000000]),0);
assert.deepEqual(candidate([-1, -2, -3, 10, -5]),-6);
assert.deepEqual(candidate([100, -1, -2, -3, 10, -5]),-6);
assert.deepEqual(candidate([10, 11, 13, 8, 3, 4]),3);
assert.deepEqual(candidate([100, -33, 32, -1, 0, -2]),-33);
assert.deepEqual(candidate([-10]),-10);
assert.deepEqual(candidate([7]),7);
assert.deepEqual(candidate([1, -1]),-1);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//長方形のグリッド状(grid)の井戸が与えられる。各行が1つの井戸を表し、
// 行の1が1単位の水を表す。
// 各井戸には，そこから水を汲み上げるのに使える対応するバケツがあり，
// すべてのバケツ容量(capacity)は同じである．
// あなたの仕事は，バケツを使って井戸を空にすることである．
// バケツを降ろす回数を出力せよ．
// 例 1:
// >>> max_fill([[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], 1)
// 6
// 例 2:
// >>> max_fill([[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], 2)
// 5
// 例 3:
// >>> max_fill([[0, 0, 0], [0, 0, 0]], 5)
// 0
// 制約:
// * すべての井戸が同じ長さ
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
function max_fill(grid: number[][], capacity: number): number {
|
reworded
|
transform
|
HumanEval_115_max_fill
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = max_fill;
assert.deepEqual(candidate([[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], 1),6);
assert.deepEqual(candidate([[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], 2),5);
assert.deepEqual(candidate([[0, 0, 0], [0, 0, 0]], 5),0);
assert.deepEqual(candidate([[1, 1, 1, 1], [1, 1, 1, 1]], 2),4);
assert.deepEqual(candidate([[1, 1, 1, 1], [1, 1, 1, 1]], 9),2);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//この問題では、非負整数の配列を2進数表現における"1"の個数を昇順でソートする。
// "1"の個数が同じ場合は，10進数に基づいてソートする。
// 次のように実装する：
// >>> sort_array([1, 5, 2, 3, 4])
// [1, 2, 3, 4, 5]
// >>> sort_array([-2, -3, -4, -5, -6])
// [-6, -5, -4, -3, -2]
// >>> sort_array([1, 0, 2, 3, 4])
// [0, 1, 2, 3, 4]
function sort_array(arr: number[]): number[] {
|
reworded
|
transform
|
HumanEval_116_sort_array
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = sort_array;
assert.deepEqual(candidate([1, 5, 2, 3, 4]),[1, 2, 4, 3, 5]);
assert.deepEqual(candidate([-2, -3, -4, -5, -6]),[-4, -2, -6, -5, -3]);
assert.deepEqual(candidate([1, 0, 2, 3, 4]),[0, 1, 2, 4, 3]);
assert.deepEqual(candidate([]),[]);
assert.deepEqual(candidate([2, 5, 77, 4, 5, 3, 5, 7, 2, 3, 4]),[2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77]);
assert.deepEqual(candidate([3, 6, 44, 12, 32, 5]),[32, 3, 5, 6, 12, 44]);
assert.deepEqual(candidate([2, 4, 8, 16, 32]),[2, 4, 8, 16, 32]);
assert.deepEqual(candidate([2, 4, 8, 16, 32]),[2, 4, 8, 16, 32]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//ある文字列sと自然数nが与えらる。あなたに課せられたタスクは、文字列s
// の中から、ちょうどn個の子音を含むすべての単語のリストを現れる順に返す
// 関数を実装することである。
// 注意：入力文字列には英文字と空白しか含まれないと仮定してもよい。
// 例:
// >>> select_words("Mary had a little lamb", 4)
// ["little"]
// >>> select_words("Mary had a little lamb", 3)
// ["Mary", "lamb"]
// >>> select_words("simple white space", 2)
// []
// >>> select_words("Hello world", 4)
// ["world"]
// >>> select_words("Uncle sam", 3)
// ["Uncle"]
function select_words(s: string, n: number): string[] {
|
reworded
|
transform
|
HumanEval_117_select_words
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = select_words;
assert.deepEqual(candidate("Mary had a little lamb", 4),["little"]);
assert.deepEqual(candidate("Mary had a little lamb", 3),["Mary", "lamb"]);
assert.deepEqual(candidate("simple white space", 2),[]);
assert.deepEqual(candidate("Hello world", 4),["world"]);
assert.deepEqual(candidate("Uncle sam", 3),["Uncle"]);
assert.deepEqual(candidate("", 4),[]);
assert.deepEqual(candidate("a b c d e f", 1),["b", "c", "d", "f"]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//単語が与えられる。あなたの仕事は、単語の右側から2つの子音（大文字と
// 小文字を区別）の間に立っている最も近い母音を見つけることである。
// 最初と最後の母音はカウントされない。上記の条件を満たす母音が見つから
// なかった場合は、空の文字列を返せ。
// 指定された文字列は英字のみを含むとみなしてよい。
// 例:
// >>> get_closest_vowel("yogurt")
// "u"
// >>> get_closest_vowel("FULL")
// "U"
// >>> get_closest_vowel("quick")
// ""
// >>> get_closest_vowel("ab")
// ""
function get_closest_vowel(word: string): string {
|
reworded
|
transform
|
HumanEval_118_get_closest_vowel
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = get_closest_vowel;
assert.deepEqual(candidate("yogurt"),"u");
assert.deepEqual(candidate("full"),"u");
assert.deepEqual(candidate("easy"),"");
assert.deepEqual(candidate("eAsy"),"");
assert.deepEqual(candidate("ali"),"");
assert.deepEqual(candidate("bad"),"a");
assert.deepEqual(candidate("most"),"o");
assert.deepEqual(candidate("ab"),"");
assert.deepEqual(candidate("ba"),"");
assert.deepEqual(candidate("quick"),"");
assert.deepEqual(candidate("anime"),"i");
assert.deepEqual(candidate("Asia"),"");
assert.deepEqual(candidate("Above"),"o");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//2つの文字列からなるリストが与えられます。両方の文字列は開き括弧 '(' または
// 閉じ括弧 ')' のみで構成されています。
// あなたの仕事は、2つの文字列を何らかの順序で結合して、「良い」文字列にすることが
// 可能かどうかを確認することです。
// 文字列Sが「良い」とは、文字列内のすべての括弧がバランスしている場合に限ります。
// 例えば、文字列 '(())()' は良いですが、文字列 '())' は良くありません。
// 良い文字列を作る方法がある場合は 'Yes' を返し、そうでない場合は 'No' を返してください。
// 例
// >>> match_parens(["()(", ")"])
// "Yes"
// >>> match_parens([")", ")"])
// "No"
function match_parens(lst: string[]): string {
|
reworded
|
transform
|
HumanEval_119_match_parens
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = match_parens;
assert.deepEqual(candidate(["()(", ")"]),"Yes");
assert.deepEqual(candidate([")", ")"]),"No");
assert.deepEqual(candidate(["(()(())", "())())"]),"No");
assert.deepEqual(candidate([")())", "(()()("]),"Yes");
assert.deepEqual(candidate(["(())))", "(()())(("]),"Yes");
assert.deepEqual(candidate(["()", "())"]),"No");
assert.deepEqual(candidate(["(()(", "()))()"]),"Yes");
assert.deepEqual(candidate(["((((", "((())"]),"No");
assert.deepEqual(candidate([")(()", "(()("]),"No");
assert.deepEqual(candidate([")(", ")("]),"No");
assert.deepEqual(candidate(["(", ")"]),"Yes");
assert.deepEqual(candidate([")", "("]),"Yes");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//整数の配列 arr と正の整数 k が与えられる。arr に含まれる大きい方から k 個の数を含む
// 長さ k のソート済みリストを返す。
// 例 1:
// >>> maximum([-3, -4, 5], 3)
// [-4, -3, 5]
// 例 2:
// >>> maximum([4, -4, 4], 2)
// [4, 4]
// 例 3:
// >>> maximum([-3, 2, 1, 2, -1, -2, 1], 1)
// [2]
// ノート:
// 1. 配列の長さは[1, 1000]の範囲とする。
// 2. 配列の要素は [-1000, 1000] の範囲にある。
// 3. 0 <= k <= len(arr)
function maximum(arr: number[], k: number): number[] {
|
reworded
|
transform
|
HumanEval_120_maximum
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = maximum;
assert.deepEqual(candidate([-3, -4, 5], 3),[-4, -3, 5]);
assert.deepEqual(candidate([4, -4, 4], 2),[4, 4]);
assert.deepEqual(candidate([-3, 2, 1, 2, -1, -2, 1], 1),[2]);
assert.deepEqual(candidate([123, -123, 20, 0, 1, 2, -3], 3),[2, 20, 123]);
assert.deepEqual(candidate([-123, 20, 0, 1, 2, -3], 4),[0, 1, 2, 20]);
assert.deepEqual(candidate([5, 15, 0, 3, -13, -8, 0], 7),[-13, -8, 0, 0, 3, 5, 15]);
assert.deepEqual(candidate([-1, 0, 2, 5, 3, -10], 2),[3, 5]);
assert.deepEqual(candidate([1, 0, 5, -7], 1),[5]);
assert.deepEqual(candidate([4, -4], 2),[-4, 4]);
assert.deepEqual(candidate([-10, 10], 2),[-10, 10]);
assert.deepEqual(candidate([1, 2, 3, -23, 243, -400, 0], 0),[]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//整数の空でないリストが与えられた時、偶数の位置にある奇数の要素の合計を返す。
// 例
// >>> solution([5, 8, 7, 1])
// 12
// >>> solution([3, 3, 3, 3, 3])
// 9
// >>> solution([30, 13, 24, 321])
// 0
function solution(lst: number[]): number {
|
reworded
|
transform
|
HumanEval_121_solution
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = solution;
assert.deepEqual(candidate([5, 8, 7, 1]),12);
assert.deepEqual(candidate([3, 3, 3, 3, 3]),9);
assert.deepEqual(candidate([30, 13, 24, 321]),0);
assert.deepEqual(candidate([5, 9]),5);
assert.deepEqual(candidate([2, 4, 8]),0);
assert.deepEqual(candidate([30, 13, 23, 32]),23);
assert.deepEqual(candidate([3, 13, 2, 9]),3);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//整数の空でない配列 arr と整数 k が与えられたとき、
// arr の最初の k 個の要素から高々 2 桁までの要素の和を返す。
// 例:
// >>> add_elements([111, 21, 3, 4000, 5, 6, 7, 8, 9], 4)
// 24
// # 21 + 3 の話
// 制約:
// 1. 1 <= len(arr) <= 100
// 2. 1 <= k <= len(arr)
function add_elements(arr: number[], k: number): number {
|
reworded
|
transform
|
HumanEval_122_add_elements
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = add_elements;
assert.deepEqual(candidate([1, -2, -3, 41, 57, 76, 87, 88, 99], 3),-4);
assert.deepEqual(candidate([111, 121, 3, 4000, 5, 6], 2),0);
assert.deepEqual(candidate([11, 21, 3, 90, 5, 6, 7, 8, 9], 4),125);
assert.deepEqual(candidate([111, 21, 3, 4000, 5, 6, 7, 8, 9], 4),24);
assert.deepEqual(candidate([1], 1),1);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//正の整数nが与えられたとき、コラッツ数列の奇数を持つソートされたリストを返す。
// コラッツ予想とは数学の予想で、次のように定義される数列に関するものである：
// 任意の正の整数nから始め、各項は前の項から次のように求められる。
// 前の項が偶数なら、次の項は前の項の2分の1である。前の項が奇数の場合、次の項は前の項の3倍＋1である。
// 予想では、nがどのような値であっても、数列は必ず1に達する。
// 注:
// 1. 1. Collatz(1)は[1]である。
// 2. 返されるリストは昇順にソートされている。
// 例えば:
// get_odd_collatz(5) は [1, 5]を返す。つまり、5に対するコラッツ数列 は、[5, 16, 8, 4, 2, 1]であり、 奇数は 1 と 5 である。
// >>> get_odd_collatz(5)
// [1, 5]
function get_odd_collatz(n: number): number[] {
|
reworded
|
transform
|
HumanEval_123_get_odd_collatz
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = get_odd_collatz;
assert.deepEqual(candidate(14),[1, 5, 7, 11, 13, 17]);
assert.deepEqual(candidate(5),[1, 5]);
assert.deepEqual(candidate(12),[1, 3, 5]);
assert.deepEqual(candidate(1),[1]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//与えられた日付文字列を検証し、その日付が有効であればtrueを、そうでなければfalseを返す関数を書く必要がある。
// 日付が有効であるのは、以下のルールがすべて満たされている場合である：
// 1. 日付文字列が空でない。
// 2. 日数が、月1,3,5,7,8,10,12の場合、1日以上31日以下である。また、月4,6,9,11については、日数が1以上30日以下である。また、月2については、日数が1以上29以下であること。
// 3. 月は1未満または12以上であってはならない。
// 4. 日付はmm-dd-yyyyの形式でなければならない。
// >>> valid_date("03-11-2000")
// true
// >>> valid_date("15-01-2012")
// false
// >>> valid_date("04-0-2040")
// false
// >>> valid_date("06-04-2020")
// true
// >>> valid_date("06/04/2020")
// false
function valid_date(date: string): boolean {
|
reworded
|
transform
|
HumanEval_124_valid_date
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = valid_date;
assert.deepEqual(candidate("03-11-2000"),true);
assert.deepEqual(candidate("15-01-2012"),false);
assert.deepEqual(candidate("04-0-2040"),false);
assert.deepEqual(candidate("06-04-2020"),true);
assert.deepEqual(candidate("01-01-2007"),true);
assert.deepEqual(candidate("03-32-2011"),false);
assert.deepEqual(candidate(""),false);
assert.deepEqual(candidate("04-31-3000"),false);
assert.deepEqual(candidate("06-06-2005"),true);
assert.deepEqual(candidate("21-31-2000"),false);
assert.deepEqual(candidate("04-12-2003"),true);
assert.deepEqual(candidate("04122003"),false);
assert.deepEqual(candidate("20030412"),false);
assert.deepEqual(candidate("2003-04"),false);
assert.deepEqual(candidate("2003-04-12"),false);
assert.deepEqual(candidate("04-2003"),false);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//単語の文字列が与えられた場合、空白で分割された単語のリストを返す。
// テキスト中に空白が存在しない場合は、カンマ ',' で分割する必要がある。カンマが存在しない場合は、
// アルファベットの奇数順の小文字の数を返す必要がある。ord('a') = 0, ord('b') = 1, ... ord('z') = 25
// 例
// >>> split_words("Hello world!")
// ["Hello", "world!"]
// >>> split_words("Hello,world!")
// ["Hello", "world!"]
// >>> split_words("abcdef")
// 3
function split_words(txt: string): string[] | number {
|
reworded
|
transform
|
HumanEval_125_split_words
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = split_words;
assert.deepEqual(candidate("Hello world!"),["Hello", "world!"]);
assert.deepEqual(candidate("Hello,world!"),["Hello", "world!"]);
assert.deepEqual(candidate("Hello world,!"),["Hello", "world,!"]);
assert.deepEqual(candidate("Hello,Hello,world !"),["Hello,Hello,world", "!"]);
assert.deepEqual(candidate("abcdef"),3);
assert.deepEqual(candidate("aaabb"),2);
assert.deepEqual(candidate("aaaBb"),1);
assert.deepEqual(candidate(""),0);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_125_split_words.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//数字のリストが与えられたとき、昇順に整列されているかどうかを返す。
// リストに同じ数の重複が1つ以上ある場合は、falseを返す。
// 負の数はなく、整数のみであると仮定する。
// 例
// >>> is_sorted([5])
// true
// >>> is_sorted([1, 2, 3, 4, 5])
// true
// >>> is_sorted([1, 3, 2, 4, 5])
// false
// >>> is_sorted([1, 2, 3, 4, 5, 6])
// true
// >>> is_sorted([1, 2, 3, 4, 5, 6, 7])
// true
// >>> is_sorted([1, 3, 2, 4, 5, 6, 7])
// false
// >>> is_sorted([1, 2, 2, 3, 3, 4])
// true
// >>> is_sorted([1, 2, 2, 2, 3, 4])
// false
function is_sorted(lst: number[]): boolean {
|
reworded
|
transform
|
HumanEval_126_is_sorted
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = is_sorted;
assert.deepEqual(candidate([5]),true);
assert.deepEqual(candidate([1, 2, 3, 4, 5]),true);
assert.deepEqual(candidate([1, 3, 2, 4, 5]),false);
assert.deepEqual(candidate([1, 2, 3, 4, 5, 6]),true);
assert.deepEqual(candidate([1, 2, 3, 4, 5, 6, 7]),true);
assert.deepEqual(candidate([1, 3, 2, 4, 5, 6, 7]),false);
assert.deepEqual(candidate([]),true);
assert.deepEqual(candidate([1]),true);
assert.deepEqual(candidate([3, 2, 1]),false);
assert.deepEqual(candidate([1, 2, 2, 2, 3, 4]),false);
assert.deepEqual(candidate([1, 2, 3, 3, 3, 4]),false);
assert.deepEqual(candidate([1, 2, 2, 3, 3, 4]),true);
assert.deepEqual(candidate([1, 2, 3, 4]),true);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//2つの区間が与えられます。
// それぞれの区間は整数のペアで示されます。例えば、区間 = (start, end ) = (1, 2) です。
// 与えられた区間は閉区間であり、start と end の両端が含まれます。
// 各区間について、start は end 以下であると仮定します。
// あなたの仕事は、これら2つの区間の交差部分の長さが素数であるかどうかを判断することです。
// 例えば、区間 (1, 3) と (2, 4) の交差部分は (2, 3) で、その長さは1ですが、これは素数ではありません。
// 交差部分の長さが素数であれば "YES" を返し、そうでなければ "NO" を返してください。
// もし2つの区間が交差しない場合も "NO" を返してください。
// [input/output] サンプル:
// >>> intersection([1, 2], [2, 3])
// "NO"
// >>> intersection([-1, 1], [0, 4])
// "NO"
// >>> intersection([-3, -1], [-5, 5])
// "YES"
function intersection(interval1: [number, number], interval2: [number, number]): string {
|
reworded
|
transform
|
HumanEval_127_intersection
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = intersection;
assert.deepEqual(candidate([1, 2], [2, 3]),"NO");
assert.deepEqual(candidate([-1, 1], [0, 4]),"NO");
assert.deepEqual(candidate([-3, -1], [-5, 5]),"YES");
assert.deepEqual(candidate([-2, 2], [-4, 0]),"YES");
assert.deepEqual(candidate([-11, 2], [-1, -1]),"NO");
assert.deepEqual(candidate([1, 2], [3, 5]),"NO");
assert.deepEqual(candidate([1, 2], [1, 2]),"NO");
assert.deepEqual(candidate([-2, -2], [-3, -2]),"NO");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//整数の配列 arr が与えられます。この配列に含まれる各数値の絶対値の合計と、
// 各数値の符号（プラスは1、マイナスは-1、ゼロは0）の積を掛け合わせた値を
// 返してください。
// 注意：配列`arr`が空の場合は`undefined`を返してください。
// 例:
// >>> prod_signs([1, 2, 2, -4])
// 9
// >>> prod_signs([0, 1])
// 0
// >>> prod_signs([])
// undefined
function prod_signs(arr: number[]): number | undefined {
|
reworded
|
transform
|
HumanEval_128_prod_signs
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = prod_signs;
assert.deepEqual(candidate([1, 2, 2, -4]),-9);
assert.deepEqual(candidate([0, 1]),0);
assert.deepEqual(candidate([1, 1, 1, 2, 3, -1, 1]),-10);
assert.deepEqual(candidate([]),undefined);
assert.deepEqual(candidate([2, 4, 1, 2, -1, -1, 9]),20);
assert.deepEqual(candidate([-1, 1, -1, 1]),4);
assert.deepEqual(candidate([-1, 1, 1, 1]),-4);
assert.deepEqual(candidate([-1, 1, 1, 0]),0);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//N行とN列 (N >= 2)) のグリッドと正の整数kが与えられた場合、各セルには値が含まれている。
// 囲[1, N * N]（両端を含む）のすべての整数は、グリッドのセルに一度だけ表れる。
// このグリッド内で長さkの最短の経路を見つける必要がある。任意のセルからスタートでき、
// 各ステップで隣接するセルに移動できる。言い換えれば、現在のセルと辺を共有するセルに
// 移動できる。長さkの経路とは、正確にk個のセル（必ずしも異なるとは限らない）を訪れる
// ことを意味する。ただし、グリッドから出ることはない。
// 長さkの2つの経路AとBがある場合、AとBが通るセルの値を順番にリスト化したものを
// それぞれlst_A、lst_Bと呼ぶ。lst_Aがlst_Bより辞書順で小さい場合、経路Aは経路Bよりも
// 小さいとする。つまり、整数インデックスi（ 1 <= i <= k ) が存在して、lst_A[i] < lst_B[i] となり、
// 任意の j（ 1 <= j < i ）に対して lst_A[j] = lst_B[j] が成立する。
// 答えは一意であることが保証されている。
// 最短の経路が通るセルの値の順番に並べたリストを返すようにせよ。
// 例：
// >>> minPath([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3)
// [1, 2, 1]
// >>> minPath([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1)
// [1]
function minPath(grid: number[][], k: number): number[] {
|
reworded
|
transform
|
HumanEval_129_minPath
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = minPath;
assert.deepEqual(candidate([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3),[1, 2, 1]);
assert.deepEqual(candidate([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1),[1]);
assert.deepEqual(candidate([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], 4),[1, 2, 1, 2]);
assert.deepEqual(candidate([[6, 4, 13, 10], [5, 7, 12, 1], [3, 16, 11, 15], [8, 14, 9, 2]], 7),[1, 10, 1, 10, 1, 10, 1]);
assert.deepEqual(candidate([[8, 14, 9, 2], [6, 4, 13, 15], [5, 7, 1, 12], [3, 10, 11, 16]], 5),[1, 7, 1, 7, 1]);
assert.deepEqual(candidate([[11, 8, 7, 2], [5, 16, 14, 4], [9, 3, 15, 6], [12, 13, 10, 1]], 9),[1, 6, 1, 6, 1, 6, 1, 6, 1]);
assert.deepEqual(candidate([[12, 13, 10, 1], [9, 3, 15, 6], [5, 16, 14, 4], [11, 8, 7, 2]], 12),[1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6]);
assert.deepEqual(candidate([[2, 7, 4], [3, 1, 5], [6, 8, 9]], 8),[1, 3, 1, 3, 1, 3, 1, 3]);
assert.deepEqual(candidate([[6, 1, 5], [3, 8, 9], [2, 7, 4]], 8),[1, 5, 1, 5, 1, 5, 1, 5]);
assert.deepEqual(candidate([[1, 2], [3, 4]], 10),[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]);
assert.deepEqual(candidate([[1, 3], [3, 2]], 10),[1, 3, 1, 3, 1, 3, 1, 3, 1, 3]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//フィボナッチ数列は、ここ数世紀の間に数学者によって深く研究され、誰もが知っている。
// しかし、人々が知らないのはトリボナッチ数列である。
// トリボナッチ数列は再帰によって定義される:
// tri(1) = 3
// tri(n) = 1 + n / 2, n が偶数の場合.
// tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), n が奇数の場合d.
// 例えば:
// tri(2) = 1 + (2 / 2) = 2
// tri(4) = 3
// tri(3) = tri(2) + tri(1) + tri(4)
// = 2 + 3 + 3 = 8
// あなたは非負の整数nが与えられるので、トリボナッチ数列の最初のn + 1個の数の
// リストを返さなければならない。
// 例:
// >>> tri(3)
// [1, 3, 2, 8]
function tri(n: number): number[] {
|
reworded
|
transform
|
HumanEval_130_tri
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = tri;
assert.deepEqual(candidate(3),[1, 3, 2, 8]);
assert.deepEqual(candidate(4),[1, 3, 2, 8, 3]);
assert.deepEqual(candidate(5),[1, 3, 2, 8, 3, 15]);
assert.deepEqual(candidate(6),[1, 3, 2, 8, 3, 15, 4]);
assert.deepEqual(candidate(7),[1, 3, 2, 8, 3, 15, 4, 24]);
assert.deepEqual(candidate(8),[1, 3, 2, 8, 3, 15, 4, 24, 5]);
assert.deepEqual(candidate(9),[1, 3, 2, 8, 3, 15, 4, 24, 5, 35]);
assert.deepEqual(candidate(20),[1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11]);
assert.deepEqual(candidate(0),[1]);
assert.deepEqual(candidate(1),[1, 3]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//正の整数 n が与えられた時、奇数桁数の積を返す。
// 全ての桁が偶数の場合は0を返す。
// 例えば:
// >>> digits(1)
// 1
// >>> digits(4)
// 0
// >>> digits(235)
// 15
function digits(n: number): number {
|
reworded
|
transform
|
HumanEval_131_digits
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = digits;
assert.deepEqual(candidate(5),5);
assert.deepEqual(candidate(54),5);
assert.deepEqual(candidate(120),1);
assert.deepEqual(candidate(5014),5);
assert.deepEqual(candidate(98765),315);
assert.deepEqual(candidate(5576543),2625);
assert.deepEqual(candidate(2468),0);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//この関数は、角括弧だけを含む文字列を入力として受け取ります。括弧が有効な順序で
// 並んでいて、その中に少なくとも1つの括弧が入れ子になっている場合、関数はtrueを
// 返すようにしてください。
// >>> is_nested("[[]]")
// true
// >>> is_nested("[]]]]]]][[[[[]")
// false
// >>> is_nested("[][]")
// false
// >>> is_nested("[]")
// false
// >>> is_nested("[[][]]")
// true
// >>> is_nested("[[]][[")
// true
function is_nested(string: string): boolean {
|
reworded
|
transform
|
HumanEval_132_is_nested
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = is_nested;
assert.deepEqual(candidate("[[]]"),true);
assert.deepEqual(candidate("[]]]]]]][[[[[]"),false);
assert.deepEqual(candidate("[][]"),false);
assert.deepEqual(candidate("[]"),false);
assert.deepEqual(candidate("[[[[]]]]"),true);
assert.deepEqual(candidate("[]]]]]]]]]]"),false);
assert.deepEqual(candidate("[][][[]]"),true);
assert.deepEqual(candidate("[[]"),false);
assert.deepEqual(candidate("[]]"),false);
assert.deepEqual(candidate("[[]][["),true);
assert.deepEqual(candidate("[[][]]"),true);
assert.deepEqual(candidate(""),false);
assert.deepEqual(candidate("[[[[[[[["),false);
assert.deepEqual(candidate("]]]]]]]]"),false);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//数字のリストが与えられます。
// 与えられたリスト内の各数値をまず切り上げ（天井関数を使って最も近い整数に丸める）、
// その後それぞれの数値を二乗した値の合計を返してください。
// 例:
// >>> lst([1.0, 2.0, 3.0])
// 14
// >>> lst([1.0, 4.0, 9.0])
// 98
// >>> lst([1.0, 3.0, 5.0, 7.0])
// 84
// >>> lst([1.4, 4.2, 0.0])
// 29
// >>> lst([-2.4, 1.0, 1.0])
// 6
function sum_squares(lst: number[]): number {
|
reworded
|
transform
|
HumanEval_133_sum_squares
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = sum_squares;
assert.deepEqual(candidate([1.0, 2.0, 3.0]),14);
assert.deepEqual(candidate([1.0, 2.0, 3.0]),14);
assert.deepEqual(candidate([1.0, 3.0, 5.0, 7.0]),84);
assert.deepEqual(candidate([1.4, 4.2, 0.0]),29);
assert.deepEqual(candidate([-2.4, 1.0, 1.0]),6);
assert.deepEqual(candidate([100.0, 1.0, 15.0, 2.0]),10230);
assert.deepEqual(candidate([10000.0, 10000.0]),200000000);
assert.deepEqual(candidate([-1.4, 4.6, 6.3]),75);
assert.deepEqual(candidate([-1.4, 17.9, 18.9, 19.9]),1086);
assert.deepEqual(candidate([0.0]),0);
assert.deepEqual(candidate([-1.0]),1);
assert.deepEqual(candidate([-1.0, 1.0, 0.0]),2);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//与えられた文字列の最後の文字がアルファベットであり、かつ単語の一部でなければtrueを、
// そうでなければfalseを返す関数を作成せよ。
// 注意：単語とはスペースで区切られた文字の並びである。
// 例:
// >>> check_if_last_char_is_a_letter("apple pie")
// false
// >>> check_if_last_char_is_a_letter("apple pi e")
// true
// >>> check_if_last_char_is_a_letter("apple pi e ")
// false
// >>> check_if_last_char_is_a_letter("")
// false
function check_if_last_char_is_a_letter(txt: string): boolean {
|
reworded
|
transform
|
HumanEval_134_check_if_last_char_is_a_letter
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = check_if_last_char_is_a_letter;
assert.deepEqual(candidate("apple"),false);
assert.deepEqual(candidate("apple pi e"),true);
assert.deepEqual(candidate("eeeee"),false);
assert.deepEqual(candidate("A"),true);
assert.deepEqual(candidate("Pumpkin pie "),false);
assert.deepEqual(candidate("Pumpkin pie 1"),false);
assert.deepEqual(candidate(""),false);
assert.deepEqual(candidate("eeeee e "),false);
assert.deepEqual(candidate("apple pie"),false);
assert.deepEqual(candidate("apple pi e "),false);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//直前の要素よりも大きくない要素の中で、最も大きなインデックスを持つ要素を探して
// そのインデックスを返す関数を作成してください。そのような要素が存在しない場合は、
// -1を返してください。与えられる配列には重複する値は含まれません。
// 例:
// >>> can_arrange([1, 2, 4, 3, 5])
// 3
// >>> can_arrange([1, 2, 3])
// -1
function can_arrange(arr: number[]): number {
|
reworded
|
transform
|
HumanEval_135_can_arrange
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = can_arrange;
assert.deepEqual(candidate([1, 2, 4, 3, 5]),3);
assert.deepEqual(candidate([1, 2, 4, 5]),-1);
assert.deepEqual(candidate([1, 4, 2, 5, 6, 7, 8, 9, 10]),2);
assert.deepEqual(candidate([4, 8, 5, 7, 3]),4);
assert.deepEqual(candidate([]),-1);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//リストから最も大きな負の整数と最も小さな正の整数を見つけ、それらをタプル（a, b）
// として返す関数を作成してください。リストに負の整数もしくは正の整数がない場合は、
// 代わりにundefinedを返します。
// 例:
// >>> largest_smallest_integers([2, 4, 1, 3, 5, 7])
// [undefined, 1]
// >>> largest_smallest_integers([])
// [undefined, undefined]
// >>> largest_smallest_integers([0])
// [undefined, undefined]
function largest_smallest_integers(lst: number[]): [number | undefined, number | undefined] {
|
reworded
|
transform
|
HumanEval_136_largest_smallest_integers
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = largest_smallest_integers;
assert.deepEqual(candidate([2, 4, 1, 3, 5, 7]),[undefined, 1]);
assert.deepEqual(candidate([2, 4, 1, 3, 5, 7, 0]),[undefined, 1]);
assert.deepEqual(candidate([1, 3, 2, 4, 5, 6, -2]),[-2, 1]);
assert.deepEqual(candidate([4, 5, 3, 6, 2, 7, -7]),[-7, 2]);
assert.deepEqual(candidate([7, 3, 8, 4, 9, 2, 5, -9]),[-9, 2]);
assert.deepEqual(candidate([]),[undefined, undefined]);
assert.deepEqual(candidate([0]),[undefined, undefined]);
assert.deepEqual(candidate([-1, -3, -5, -6]),[-1, undefined]);
assert.deepEqual(candidate([-1, -3, -5, -6, 0]),[-1, undefined]);
assert.deepEqual(candidate([-6, -4, -4, -3, 1]),[-3, 1]);
assert.deepEqual(candidate([-6, -4, -4, -3, -100, 1]),[-3, 1]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//与えられた数値nが、ちょうど4つの正の偶数の合計として表現できるかどうかを評価してください。
// 例
// >>> is_equal_to_sum_even(4)
// false
// >>> is_equal_to_sum_even(6)
// false
// >>> is_equal_to_sum_even(8)
// true
function is_equal_to_sum_even(n: number): boolean {
|
reworded
|
transform
|
HumanEval_138_is_equal_to_sum_even
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = is_equal_to_sum_even;
assert.deepEqual(candidate(4),false);
assert.deepEqual(candidate(6),false);
assert.deepEqual(candidate(8),true);
assert.deepEqual(candidate(10),true);
assert.deepEqual(candidate(11),false);
assert.deepEqual(candidate(12),true);
assert.deepEqual(candidate(13),false);
assert.deepEqual(candidate(16),true);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//ブラジリアン階乗は次のように定義される：
// brazilian_factorial(n) = n！* (n-1)! * (n-2)! * ... * 1!
// ただし n > 0
// 例えば:
// >>> special_factorial(4)
// 288
// The function will receive an integer as input and should return the special
// factorial of this integer.
function special_factorial(n: number): number {
|
reworded
|
transform
|
HumanEval_139_special_factorial
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = special_factorial;
assert.deepEqual(candidate(4),288);
assert.deepEqual(candidate(5),34560);
assert.deepEqual(candidate(7),125411328000);
assert.deepEqual(candidate(1),1);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//文字列テキストが与えられた場合、その中のすべての空白をアンダースコアに置換し、
// 文字列が2つ以上の連続した空白を持つ場合、すべての連続した空白を - に置換する
// >>> fix_spaces(" Example 2") == "_Example_2"
// fix_spaces(" Example 3") == "_Example-3"")
// "Example"
// >>> fix_spaces(" Example 2") == "_Example_2"
// fix_spaces(" Example 3") == "_Example-3" 1")
// "Example_1"
// >>> fix_spaces(" Example 2") == "_Example_2"
// fix_spaces(" Example 3") == "_Example-3" 2")
// "_Example_2"
// >>> fix_spaces(" Example 2") == "_Example_2"
// fix_spaces(" Example 3") == "_Example-3" 3")
// "_Example-3"
function fix_spaces(text: string): string {
|
reworded
|
transform
|
HumanEval_140_fix_spaces
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = fix_spaces;
assert.deepEqual(candidate("Example"),"Example");
assert.deepEqual(candidate("Mudasir Hanif "),"Mudasir_Hanif_");
assert.deepEqual(candidate("Yellow Yellow Dirty Fellow"),"Yellow_Yellow__Dirty__Fellow");
assert.deepEqual(candidate("Exa mple"),"Exa-mple");
assert.deepEqual(candidate(" Exa 1 2 2 mple"),"-Exa_1_2_2_mple");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//ファイル名を表す文字列を受け取り、そのファイル名が有効であれば'Yes'を返し、そうでなければ'No'
// を返す関数を作成する。ファイル名が有効であるとみなされるのは、
// 以下の条件をすべて満たす場合のみである：
// - ファイル名に3桁以上の数字（'0'-'9'）があってはならない。
// - ファイル名に含まれるドット '.' はひとつのみ。
// - ドットの前の部分文字列は空であってはならず、英文字（'a'-'z'および'A'-'Z'）から始まる文字でなければならない。
// - ドットの後の部分文字列は、以下のいずれかでなければならない： ['txt'、'exe'、'dll']。
// 例:
// >>> file_name_check("example.txt")
// "Yes"
// >>> file_name_check("1example.dll")
// "No"(名前は英文字で始まらないといけない）
function file_name_check(file_name: string): string {
|
reworded
|
transform
|
HumanEval_141_file_name_check
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = file_name_check;
assert.deepEqual(candidate("example.txt"),"Yes");
assert.deepEqual(candidate("1example.dll"),"No");
assert.deepEqual(candidate("s1sdf3.asd"),"No");
assert.deepEqual(candidate("K.dll"),"Yes");
assert.deepEqual(candidate("MY16FILE3.exe"),"Yes");
assert.deepEqual(candidate("His12FILE94.exe"),"No");
assert.deepEqual(candidate("_Y.txt"),"No");
assert.deepEqual(candidate("?aREYA.exe"),"No");
assert.deepEqual(candidate("/this_is_valid.dll"),"No");
assert.deepEqual(candidate("this_is_valid.wow"),"No");
assert.deepEqual(candidate("this_is_valid.txt"),"Yes");
assert.deepEqual(candidate("this_is_valid.txtexe"),"No");
assert.deepEqual(candidate("#this2_i4s_5valid.ten"),"No");
assert.deepEqual(candidate("@this1_is6_valid.exe"),"No");
assert.deepEqual(candidate("this_is_12valid.6exe4.txt"),"No");
assert.deepEqual(candidate("all.exe.txt"),"No");
assert.deepEqual(candidate("I563_No.exe"),"Yes");
assert.deepEqual(candidate("Is3youfault.txt"),"Yes");
assert.deepEqual(candidate("no_one#knows.dll"),"Yes");
assert.deepEqual(candidate("1I563_Yes3.exe"),"No");
assert.deepEqual(candidate("I563_Yes3.txtt"),"No");
assert.deepEqual(candidate("final..txt"),"No");
assert.deepEqual(candidate("final132"),"No");
assert.deepEqual(candidate("_f4indsartal132."),"No");
assert.deepEqual(candidate(".txt"),"No");
assert.deepEqual(candidate("s."),"No");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//"
// この関数は整数のリストを受け取ります。リスト内の各要素に対して、そのインデックスが3の倍数で
// あればその整数を二乗し、インデックスが4の倍数でかつ3の倍数でない場合はその整数を三乗します。
// インデックスが3または4の倍数でない要素については、何も変更しません。最後に、すべての要素の
// 合計値を返します。
// 例:
// >>> lst
// [1, 2, 3]
// >>> lst
// []
// >>> lst
// [-1, -5, 2, -1, -5]
function sum_squares(lst: number[]): number {
|
reworded
|
transform
|
HumanEval_142_sum_squares
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = sum_squares;
assert.deepEqual(candidate([1, 2, 3]),6);
assert.deepEqual(candidate([1, 4, 9]),14);
assert.deepEqual(candidate([]),0);
assert.deepEqual(candidate([1, 1, 1, 1, 1, 1, 1, 1, 1]),9);
assert.deepEqual(candidate([-1, -1, -1, -1, -1, -1, -1, -1, -1]),-3);
assert.deepEqual(candidate([0]),0);
assert.deepEqual(candidate([-1, -5, 2, -1, -5]),-126);
assert.deepEqual(candidate([-56, -99, 1, 0, -2]),3030);
assert.deepEqual(candidate([-1, 0, 0, 0, 0, 0, 0, 0, -1]),0);
assert.deepEqual(candidate([-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37]),-14196);
assert.deepEqual(candidate([-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10]),-1448);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//文を表す文字列が与えられ、その文には空白で区切られたいくつかの単語が含まれている。
// 元の文の単語を含みその長さが素数である文字列を返す必要がある。
// 新しい文字列の単語の順序は元の文字列と同じでなければならない。
// 例 1:
// >>> words_in_sentence("This is a test")
// "is"
// 例 2:
// >>> words_in_sentence("lets go for swimming")
// "go for"
// 制約:
// * 1 <= len(sentence) <= 100
// * sentence contains only letters
function words_in_sentence(sentence: string): string {
|
reworded
|
transform
|
HumanEval_143_words_in_sentence
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = words_in_sentence;
assert.deepEqual(candidate("This is a test"),"is");
assert.deepEqual(candidate("lets go for swimming"),"go for");
assert.deepEqual(candidate("there is no place available here"),"there is no place");
assert.deepEqual(candidate("Hi I am Hussein"),"Hi am Hussein");
assert.deepEqual(candidate("go for it"),"go for it");
assert.deepEqual(candidate("here"),"");
assert.deepEqual(candidate("here is"),"is");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//あなたの仕事は、式 x * n を簡単にする関数を実装することです。
// この関数は、x * n が整数になる場合はtrueを、そうでない場合はfalseを
// 返します。xとnはともに分数の文字列表現であり、<分子>/<分母>という形式で、
// 分子と分母はともに正の整数です。
// xとnが有効な分数であり、分母がゼロでないことは仮定してかまいません。
// >>> simplify("1/5", "5/1")
// true
// >>> simplify("1/6", "2/1")
// false
// >>> simplify("7/10", "10/2")
// false
function simplify(x: string, n: string): boolean {
|
reworded
|
transform
|
HumanEval_144_simplify
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = simplify;
assert.deepEqual(candidate("1/5", "5/1"),true);
assert.deepEqual(candidate("1/6", "2/1"),false);
assert.deepEqual(candidate("5/1", "3/1"),true);
assert.deepEqual(candidate("7/10", "10/2"),false);
assert.deepEqual(candidate("2/10", "50/10"),true);
assert.deepEqual(candidate("7/2", "4/2"),true);
assert.deepEqual(candidate("11/6", "6/1"),true);
assert.deepEqual(candidate("2/3", "5/2"),false);
assert.deepEqual(candidate("5/2", "3/5"),false);
assert.deepEqual(candidate("2/4", "8/4"),true);
assert.deepEqual(candidate("2/4", "4/2"),true);
assert.deepEqual(candidate("1/5", "5/1"),true);
assert.deepEqual(candidate("1/5", "1/5"),false);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//各数字の桁の合計に基づいて、与えられた整数のリストを昇順に並べる
// 関数を作成してください。
// 注意：もし桁の合計が同じである複数の項目がある場合は、
// 元のリストでの位置に基づいて並べてください。
// 例えば
// >>> order_by_points([1, 11, -1, -11, -12])
// [-1, -11, 1, -12, 11]
// >>> order_by_points([])
// []
function order_by_points(nums: number[]): number[] {
|
reworded
|
transform
|
HumanEval_145_order_by_points
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = order_by_points;
assert.deepEqual(candidate([1, 11, -1, -11, -12]),[-1, -11, 1, -12, 11]);
assert.deepEqual(candidate([1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46]),[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]);
assert.deepEqual(candidate([]),[]);
assert.deepEqual(candidate([1, -11, -32, 43, 54, -98, 2, -3]),[-3, -32, -98, -11, 1, 2, 43, 54]);
assert.deepEqual(candidate([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]),[1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9]);
assert.deepEqual(candidate([0, 6, 6, -76, -21, 23, 4]),[-76, -21, 0, 4, 23, 6, 6]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//数値の配列を入力とし、配列中の要素のうち、10より大きく、
// かつ数値の最初と最後の桁の両方が奇数（1, 3, 5, 7, 9）である要素の数を返す関数を書く。
// 例えば
// >>> specialFilter([15, -73, 14, -15])
// 1
// >>> specialFilter([33, -2, -3, 45, 21, 109])
// 2
function specialFilter(nums: number[]): number {
|
reworded
|
transform
|
HumanEval_146_specialFilter
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = specialFilter;
assert.deepEqual(candidate([5, -2, 1, -5]),0);
assert.deepEqual(candidate([15, -73, 14, -15]),1);
assert.deepEqual(candidate([33, -2, -3, 45, 21, 109]),2);
assert.deepEqual(candidate([43, -12, 93, 125, 121, 109]),4);
assert.deepEqual(candidate([71, -2, -33, 75, 21, 19]),3);
assert.deepEqual(candidate([1]),0);
assert.deepEqual(candidate([]),0);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//正の整数 n が与えられるので、長さ n の整数配列 a を作成せよ。
// 各 i (1 ≤ i ≤ n) に対して、 a[i] = i * i - i + 1 とする。
// i < j < k において、a[i] + a[j] + a[k] が3の倍数となるような三つ組 (a[i], a[j], a[k]) を返す。
// 例 :
// >>> get_max_triples(5)
// 1
// 解説:
// 唯一の妥当な三つ組は (1, 7, 13)である。
function get_max_triples(n: number): number {
|
reworded
|
transform
|
HumanEval_147_get_max_triples
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = get_max_triples;
assert.deepEqual(candidate(5),1);
assert.deepEqual(candidate(6),4);
assert.deepEqual(candidate(10),36);
assert.deepEqual(candidate(100),53361);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//文字列のリストを引数として受け取る関数を作成してください。
// この関数は、リストから奇数の長さを持つ文字列を削除し、
// 結果として得られるリストを長さで昇順に並べ替えて返します。
// リストは常に文字列のリストであり、数字の配列ではありません。
// また、重複する文字列が含まれる可能性があります。
// リストは各単語の長さで昇順に並べられるべきで、そのルールに従ってソートされたリストを返してください。
// もし二つの単語が同じ長さであれば、リストをアルファベット順に並べ替えてください。
// 関数はソートされた順序で文字列のリストを返すべきです。
// すべての単語が同じ長さを持つと仮定しても構いません。
// 例えば:
// >>> list_sort(["aa", "a", "aaa"])
// ["aa"]
// >>> list_sort(["ab", "a", "aaa", "cd"])
// ["ab", "cd"]
function sorted_list_sum(lst: string[]): string[] {
|
reworded
|
transform
|
HumanEval_149_sorted_list_sum
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = sorted_list_sum;
assert.deepEqual(candidate(["aa", "a", "aaa"]),["aa"]);
assert.deepEqual(candidate(["school", "AI", "asdf", "b"]),["AI", "asdf", "school"]);
assert.deepEqual(candidate(["d", "b", "c", "a"]),[]);
assert.deepEqual(candidate(["d", "dcba", "abcd", "a"]),["abcd", "dcba"]);
assert.deepEqual(candidate(["AI", "ai", "au"]),["AI", "ai", "au"]);
assert.deepEqual(candidate(["a", "b", "b", "c", "c", "a"]),[]);
assert.deepEqual(candidate(["aaaa", "bbbb", "dd", "cc"]),["cc", "dd", "aaaa", "bbbb"]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//素数である場合はxの値を返し、それ以外の場合はyの値を返す簡単なプログラム。
// 例:
// >>> x_or_y(7, 34, 12)
// 34
// >>> x_or_y(15, 8, 5)
// 5
function x_or_y(n: number, x: number, y: number): number {
|
reworded
|
transform
|
HumanEval_150_x_or_y
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = x_or_y;
assert.deepEqual(candidate(7, 34, 12),34);
assert.deepEqual(candidate(15, 8, 5),5);
assert.deepEqual(candidate(3, 33, 5212),33);
assert.deepEqual(candidate(1259, 3, 52),3);
assert.deepEqual(candidate(7919, -1, 12),-1);
assert.deepEqual(candidate(3609, 1245, 583),583);
assert.deepEqual(candidate(91, 56, 129),129);
assert.deepEqual(candidate(6, 34, 1234),1234);
assert.deepEqual(candidate(1, 2, 0),0);
assert.deepEqual(candidate(2, 2, 0),2);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//数字のリストが与えられた場合、そのリスト内の奇数の数値の二乗の合計を返してください。
// 負の数や整数でない数は無視してください。
// >>> double_the_difference([1, 3, 2, 0])
// 10
// >>> double_the_difference([-1, -2, 0])
// 0
// >>> double_the_difference([9, -2])
// 81
// >>> double_the_difference([0])
// 0
// 入力リストが空の場合は0を返すようにしてください。
function double_the_difference(lst: number[]): number {
|
reworded
|
transform
|
HumanEval_151_double_the_difference
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = double_the_difference;
assert.deepEqual(candidate([]),0);
assert.deepEqual(candidate([5.0, 4.0]),25);
assert.deepEqual(candidate([0.1, 0.2, 0.3]),0);
assert.deepEqual(candidate([-10.0, -20.0, -30.0]),0);
assert.deepEqual(candidate([-1.0, -2.0, 8.0]),0);
assert.deepEqual(candidate([0.2, 3.0, 5.0]),34);
assert.deepEqual(candidate([-9.0, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0, 9.0]),165);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//待ち望んでいた出来事の結果がようやく判明したときの感覚は、誰もが覚えていると思う。
// その瞬間に抱いた感情や思考は、間違いなくメモして比較する価値がある。
// あなたの仕事は、人がいくつかの試合の結果を正確に予想したかどうかを判断することです。
// スコアと予想の2つの配列が等しい長さで与えられます。各インデックスは1つの試合を示しています。
// 各予想がどれだけ外れていたかを示す同じ長さの配列を返してください。予想が正確であれば、
// その値は0です。そうでなければ、その値は予想とスコアの絶対的な差です。
// 例:
// >>> compare([1, 2, 3, 4, 5, 1], [1, 2, 3, 4, 2, -2])
// [0, 0, 0, 0, 3, 3]
// >>> compare([0, 5, 0, 0, 0, 4], [4, 1, 1, 0, 0, -2])
// [4, 4, 1, 0, 0, 6]
function compare(game: number[], guess: number[]): number[] {
|
reworded
|
transform
|
HumanEval_152_compare
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = compare;
assert.deepEqual(candidate([1, 2, 3, 4, 5, 1], [1, 2, 3, 4, 2, -2]),[0, 0, 0, 0, 3, 3]);
assert.deepEqual(candidate([0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]),[0, 0, 0, 0, 0, 0]);
assert.deepEqual(candidate([1, 2, 3], [-1, -2, -3]),[2, 4, 6]);
assert.deepEqual(candidate([1, 2, 3, 5], [-1, 2, 3, 4]),[2, 0, 0, 1]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//クラスの名前（文字列）と拡張子のリストが与えられます。
// この拡張子は、指定されたクラスに追加のクラスをロードするために使用されます。
// 拡張子の強度は次のように計算されます：CAPは拡張子の名前に含まれる
// 大文字の数、SMは小文字の数です。強度は、CAP - SM で与えられます。
// 最も強い拡張子を見つけて、この形式の文字列を返してください：ClassName.StrongestExtensionName。
// 同じ強度を持つ2つ以上の拡張子がある場合は、リストで最初に来るものを選びます。
// 例えば、"Slices"というクラスと、拡張子のリスト['SErviNGSliCes', 'Cheese', 'StuFfed'] が与えられた場合、'
// SErviNGSliCes'が最も強い拡張子（強度は-1）となるため、'Slices.SErviNGSliCes'を返すべきです。
// 例：
// >>> Strongest_Extension("my_class", ["AA", "Be", "CC"])
// "my_class.AA"
function Strongest_Extension(class_name: string, extensions: string[]): string {
|
reworded
|
transform
|
HumanEval_153_Strongest_Extension
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = Strongest_Extension;
assert.deepEqual(candidate("Watashi", ["tEN", "niNE", "eIGHt8OKe"]),"Watashi.eIGHt8OKe");
assert.deepEqual(candidate("Boku123", ["nani", "NazeDa", "YEs.WeCaNe", "32145tggg"]),"Boku123.YEs.WeCaNe");
assert.deepEqual(candidate("__YESIMHERE", ["t", "eMptY", "nothing", "zeR00", "NuLl__", "123NoooneB321"]),"__YESIMHERE.NuLl__");
assert.deepEqual(candidate("K", ["Ta", "TAR", "t234An", "cosSo"]),"K.TAR");
assert.deepEqual(candidate("__HAHA", ["Tab", "123", "781345", "-_-"]),"__HAHA.123");
assert.deepEqual(candidate("YameRore", ["HhAas", "okIWILL123", "WorkOut", "Fails", "-_-"]),"YameRore.okIWILL123");
assert.deepEqual(candidate("finNNalLLly", ["Die", "NowW", "Wow", "WoW"]),"finNNalLLly.WoW");
assert.deepEqual(candidate("_", ["Bb", "91245"]),"_.Bb");
assert.deepEqual(candidate("Sp", ["671235", "Bb"]),"Sp.671235");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//2つの単語が与えられる。2番目の単語またはその回転させた文字列が最初の単語の部分文字列である場合、trueを返す必要がある。
// >>> cycpattern_check("abcd", "abd")
// false
// >>> cycpattern_check("hello", "ell")
// true
// >>> cycpattern_check("whassup", "psus")
// false
// >>> cycpattern_check("abab", "baa")
// true
// >>> cycpattern_check("efef", "eeff")
// false
// >>> cycpattern_check("himenss", "simen")
// true
function cycpattern_check(a: string, b: string): boolean {
|
reworded
|
transform
|
HumanEval_154_cycpattern_check
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = cycpattern_check;
assert.deepEqual(candidate("xyzw", "xyw"),false);
assert.deepEqual(candidate("yello", "ell"),true);
assert.deepEqual(candidate("whattup", "ptut"),false);
assert.deepEqual(candidate("efef", "fee"),true);
assert.deepEqual(candidate("abab", "aabb"),false);
assert.deepEqual(candidate("winemtt", "tinem"),true);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//整数が与えられた場合、偶数桁数と奇数桁数をそれぞれ持つタプルを返す。
// 例:
// >>> even_odd_count(-12)
// [1, 1]
// >>> even_odd_count(123)
// [1, 2]
function even_odd_count(num: number): [number, number] {
|
reworded
|
transform
|
HumanEval_155_even_odd_count
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = even_odd_count;
assert.deepEqual(candidate(7),[0, 1]);
assert.deepEqual(candidate(-78),[1, 1]);
assert.deepEqual(candidate(3452),[2, 2]);
assert.deepEqual(candidate(346211),[3, 3]);
assert.deepEqual(candidate(-345821),[3, 3]);
assert.deepEqual(candidate(-2),[1, 0]);
assert.deepEqual(candidate(-45347),[2, 3]);
assert.deepEqual(candidate(0),[1, 0]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//正の整数が与えられたとき、ローマ数字に相当する文字列を小文字で返す。
// 制限事項1 <= num <= 1000
// 例:
// >>> int_to_mini_roman(19)
// "xix"
// >>> int_to_mini_roman(152)
// "clii"
// >>> int_to_mini_roman(426)
// "cdxxvi"
function int_to_mini_roman(number: number): string {
|
reworded
|
transform
|
HumanEval_156_int_to_mini_roman
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = int_to_mini_roman;
assert.deepEqual(candidate(19),"xix");
assert.deepEqual(candidate(152),"clii");
assert.deepEqual(candidate(251),"ccli");
assert.deepEqual(candidate(426),"cdxxvi");
assert.deepEqual(candidate(500),"d");
assert.deepEqual(candidate(1),"i");
assert.deepEqual(candidate(4),"iv");
assert.deepEqual(candidate(43),"xliii");
assert.deepEqual(candidate(90),"xc");
assert.deepEqual(candidate(94),"xciv");
assert.deepEqual(candidate(532),"dxxxii");
assert.deepEqual(candidate(900),"cm");
assert.deepEqual(candidate(994),"cmxciv");
assert.deepEqual(candidate(1000),"m");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//三角形の3辺の長さを与える。三角形が直角三角形ならtrueを、そうでなければfalseを返す。
// 直角三角形とは、1つの角が直角または90度である三角形のことである。
// 例:
// >>> right_angle_triangle(3, 4, 5)
// true
// >>> right_angle_triangle(1, 2, 3)
// false
function right_angle_triangle(a: number, b: number, c: number): boolean {
|
reworded
|
transform
|
HumanEval_157_right_angle_triangle
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = right_angle_triangle;
assert.deepEqual(candidate(3, 4, 5),true);
assert.deepEqual(candidate(1, 2, 3),false);
assert.deepEqual(candidate(10, 6, 8),true);
assert.deepEqual(candidate(2, 2, 2),false);
assert.deepEqual(candidate(7, 24, 25),true);
assert.deepEqual(candidate(10, 5, 7),false);
assert.deepEqual(candidate(5, 12, 13),true);
assert.deepEqual(candidate(15, 8, 17),true);
assert.deepEqual(candidate(48, 55, 73),true);
assert.deepEqual(candidate(1, 1, 1),false);
assert.deepEqual(candidate(2, 2, 10),false);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//文字列のリストを受け取る関数を書きなさい。
// リストは異なる単語を含む。異なる固有の文字数が最も多い単語を返す。
// 複数の文字列が同じ文字数を持つ場合は、辞書順で最初に来るものを返すことにする。
// >>> find_max(["name", "of", "string"])
// "string"
// >>> find_max(["name", "enam", "game"])
// "enam"
// >>> find_max(["aaaaaaa", "bb", "cc"])
// "aaaaaaa"
function find_max(words: string[]): string {
|
reworded
|
transform
|
HumanEval_158_find_max
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = find_max;
assert.deepEqual(candidate(["name", "of", "string"]),"string");
assert.deepEqual(candidate(["name", "enam", "game"]),"enam");
assert.deepEqual(candidate(["aaaaaaa", "bb", "cc"]),"aaaaaaa");
assert.deepEqual(candidate(["abc", "cba"]),"abc");
assert.deepEqual(candidate(["play", "this", "game", "of", "footbott"]),"footbott");
assert.deepEqual(candidate(["we", "are", "gonna", "rock"]),"gonna");
assert.deepEqual(candidate(["we", "are", "a", "mad", "nation"]),"nation");
assert.deepEqual(candidate(["this", "is", "a", "prrk"]),"this");
assert.deepEqual(candidate(["b"]),"b");
assert.deepEqual(candidate(["play", "play", "play"]),"play");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//あなたはお腹を空かせたウサギです。すでに一定数のニンジンを食べました。
// これからさらにニンジンを食べなければその日の食事は完了しません。
// あなたは [ 食事の後に食べたニンジンの総数, 食事の後に残ったニンジンの数 ] の配列を返してください。
// もし残りのニンジンが十分でなければ、あなたは残りのニンジンをすべて食べますが、まだお腹が空いています。
// 例:
// >>> eat(5, 6, 10)
// [11, 4]
// >>> eat(4, 8, 9)
// [12, 1]
// >>> eat(1, 10, 10)
// [11, 0]
// >>> eat(2, 11, 5)
// [7, 0]
// 変数:
// @number : 整数
// 食べたニンジンの数。
// @need : 整数
// にんじんを何本食べるか。
// @remaining : 整数
// 残りのニンジンの在庫数
// 制約:
// * 0 <= number <= 1000
// * 0 <= need <= 1000
// * 0 <= remaining <= 1000
// 楽しんで :)
function eat(number: number, need: number, remaining: number): number[] {
|
reworded
|
transform
|
HumanEval_159_eat
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = eat;
assert.deepEqual(candidate(5, 6, 10),[11, 4]);
assert.deepEqual(candidate(4, 8, 9),[12, 1]);
assert.deepEqual(candidate(1, 10, 10),[11, 0]);
assert.deepEqual(candidate(2, 11, 5),[7, 0]);
assert.deepEqual(candidate(4, 5, 7),[9, 2]);
assert.deepEqual(candidate(4, 5, 1),[5, 0]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//演算子(operator)とオペランド(operand)の2つのリストが与えられる。ひとつ目のリストは
// 基本的な算術演算を持ち、二つ目のリストは整数のリストである。与えられた2つのリストを
// 使って算術式を構築し、その評価結果を返そう。
// 基本的な算術演算:
// 加算 ( + )
// 減算 ( - )
// 乗算 ( * )
// 階除算 ( // )
// 指数化 ( ** )
// 例:
// operator['+', '*', '-']
// array = [2, 3, 4, 5]
// result = 2 + 3 * 4 - 5
// => result = 9
// 注：演算子のリストの長さは、オペランドのリストの長さから1を引いた長さに等しい。
// オペランドは非負整数のリストである。
// operator は少なくとも1つの演算子を持ち、operand は少なくとも2つのオペランドを持つ。
function do_algebra(operator: string[], operand: number[]): number {
|
reworded
|
transform
|
HumanEval_160_do_algebra
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = do_algebra;
assert.deepEqual(candidate(["**", "*", "+"], [2, 3, 4, 5]),37);
assert.deepEqual(candidate(["+", "*", "-"], [2, 3, 4, 5]),9);
assert.deepEqual(candidate(["//", "*"], [7, 3, 4]),8);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//文字列sが与えられます。
// もしs[i]がアルファベットなら、その文字の大文字と小文字を反転させる。そうでない場合は、そのままにしておく。
// もし文字列にアルファベットが一つも含まれていない場合は、文字列全体を逆順にする。
// 関数は結果の文字列を返すようにします。
// 例
// >>> solve("1234")
// "4321"
// >>> solve("ab")
// "AB"
// >>> solve("#a@C")
// "#A@c"
function solve(s: string): string {
|
reworded
|
transform
|
HumanEval_161_solve
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = solve;
assert.deepEqual(candidate("AsDf"),"aSdF");
assert.deepEqual(candidate("1234"),"4321");
assert.deepEqual(candidate("ab"),"AB");
assert.deepEqual(candidate("#a@C"),"#A@c");
assert.deepEqual(candidate("#AsdfW^45"),"#aSDFw^45");
assert.deepEqual(candidate("#6@2"),"2@6#");
assert.deepEqual(candidate("#$a^D"),"#$A^d");
assert.deepEqual(candidate("#ccc"),"#CCC");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//文字列 text が与えられたとき、その md5 ハッシュと等価な文字列を返す。
// text' が空文字列の場合は undefined を返す。
// >>> string_to_md5("Hello world")
// "3e25960a79dbc69b674cd4ec67a72c62"
function string_to_md5(text: string): string | undefined {
|
reworded
|
transform
|
HumanEval_162_string_to_md5
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = string_to_md5;
assert.deepEqual(candidate("Hello world"),"3e25960a79dbc69b674cd4ec67a72c62");
assert.deepEqual(candidate(""),undefined);
assert.deepEqual(candidate("A B C"),"0ef78513b0cb8cef12743f5aeb35f888");
assert.deepEqual(candidate("password"),"5f4dcc3b5aa765d61d8327deb882cf99");
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py
|
ts
|
[
"\nfunction ",
"\n/*",
"\n//",
"\nclass"
] |
//正の整数aとbが与えられたとき、aとbの間にある偶数の数字を昇順で返してください。
// 例えば:
// >>> generate_integers(2, 8)
// [2, 4, 6, 8]
// >>> generate_integers(8, 2)
// [2, 4, 6, 8]
// >>> generate_integers(10, 14)
// []
function generate_integers(a: number, b: number): number[] {
|
reworded
|
transform
|
HumanEval_163_generate_integers
|
declare var require: any;
const assert = require('node:assert');
function test() {
let candidate = generate_integers;
assert.deepEqual(candidate(2, 10),[2, 4, 6, 8]);
assert.deepEqual(candidate(10, 2),[2, 4, 6, 8]);
assert.deepEqual(candidate(132, 2),[2, 4, 6, 8]);
assert.deepEqual(candidate(17, 89),[]);
}
test();
|
/Users/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py
|
ts
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.