stop_tokens listlengths 1 1 | prompt stringlengths 99 1.02k | prompt_terminology stringclasses 1
value | doctests stringclasses 1
value | name stringlengths 15 44 | tests stringlengths 133 2.09k | original stringlengths 130 159 | language stringclasses 1
value |
|---|---|---|---|---|---|---|---|
[
"\n}"
] | /// 整数の配列が与えられたとき、1から9までの整数をソートし、
/// 得られた配列を逆順にし、各桁を以下の数字に相当する名前に置き換える。
/// "One"、"Two"、"Three"、"Four"、"Five"、"Six"、"Seven"、"Eight"、"Nine "
/// 例えば:
/// >>> by_length(vec![2, 1, 1, 4, 5, 8, 2, 3])
/// vec![String::from("Eight"), String::from("Five"), String::from("Four"), String::from("Three"), String::from("Two"), St... | reworded | transform | HumanEval_105_by_length | }
fn main() {
let candidate = by_length;
assert_eq!(candidate(vec![2, 1, 1, 4, 5, 8, 2, 3]), vec![String::from("Eight"), String::from("Five"), String::from("Four"), String::from("Three"), String::from("Two"), String::from("Two"), String::from("One"), String::from("One")]);
assert_eq!(candidate(Vec::<isize>... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py | rs |
[
"\n}"
] | /// iは1から始まる。iの階乗は1からiまでの数の掛け算（1 * 2 * ... * i）である。
/// 例:
/// >>> f(5)
/// vec![1, 2, 6, 24, 15]
fn f(n: isize) -> Vec<isize> {
| reworded | transform | HumanEval_106_f | }
fn main() {
let candidate = f;
assert_eq!(candidate(5), vec![1, 2, 6, 24, 15]);
assert_eq!(candidate(7), vec![1, 2, 6, 24, 15, 720, 28]);
assert_eq!(candidate(1), vec![1]);
assert_eq!(candidate(3), vec![1, 2, 6]);
}
| /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py | rs |
[
"\n}"
] | /// 与えられた正の整数 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.... | reworded | transform | HumanEval_107_even_odd_palindrome | }
fn main() {
let candidate = even_odd_palindrome;
assert_eq!(candidate(123), (8, 13));
assert_eq!(candidate(12), (4, 6));
assert_eq!(candidate(3), (1, 2));
assert_eq!(candidate(63), (6, 8));
assert_eq!(candidate(25), (5, 6));
assert_eq!(candidate(19), (4, 6));
assert_eq!(candidate(9), ... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py | rs |
[
"\n}"
] | /// count_nums 関数は、整数の配列を引数として受け取り、その配列内の各整数の各桁の合計が
/// >0 となるような整数の個数を返す。負の数に関しては、最初の桁（符号付き桁）は負となる。
/// たとえば、−123 の符号付き桁は −1, 2, 3 である。
/// >>> count_nums(vec![])
/// 0
/// >>> count_nums(vec![-1, 11, -11])
/// 1
/// >>> count_nums(vec![1, 1, 2])
/// 3
fn count_nums(arr: Vec<isize>) -> isize {
| reworded | transform | HumanEval_108_count_nums | }
fn main() {
let candidate = count_nums;
assert_eq!(candidate(Vec::<isize>::new()), 0);
assert_eq!(candidate(vec![-1, -2, 0]), 0);
assert_eq!(candidate(vec![1, 1, 2, -2, 3, 4, 5]), 6);
assert_eq!(candidate(vec![1, 6, 9, -6, 0, 1, 5]), 5);
assert_eq!(candidate(vec![1, 100, 98, -7, 1, -1]), 4);
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py | rs |
[
"\n}"
] | /// N個の整数arr[1], arr[2], ..., arr[N]なる配列 'arr' があります。
/// この配列の数字はランダムな順番に並んでいます。あなたの課題は、以下の操作を何度でも行うことで、
/// 配列を非減少の順番にソートできるかどうかを判断することです。
/// 操作として許されているのは「右シフト」です。
/// 一回の「右シフト」操作とは、配列のすべての要素を右方向に一つずつずらすことを意味します。
/// 配列の最後の要素は配列の先頭、すなわち0番目のインデックスに移動します。
/// 上記の操作を行ってソートされた配列を得られる場合は true を、そうでない場合は false を返してください。... | reworded | transform | HumanEval_109_move_one_ball | }
fn main() {
let candidate = move_one_ball;
assert_eq!(candidate(vec![3, 4, 5, 1, 2]), true);
assert_eq!(candidate(vec![3, 5, 10, 1, 2]), true);
assert_eq!(candidate(vec![4, 3, 1, 2]), false);
assert_eq!(candidate(vec![3, 5, 4, 1, 2]), false);
assert_eq!(candidate(Vec::<isize>::new()), true);
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py | rs |
[
"\n}"
] | /// この問題では、2つの数のリストを受け取り、lst1を偶数のみのリストに
/// するために、それらの間で要素の交換を行うことが可能かどうかを判断す
/// る関数を実装する。
/// lst1とlst2の間で交換される要素の数に制限はない。
/// lst1とlst2の間で要素の交換を行い、lst1の要素をすべて偶数にすることが
/// 可能であれば、"YES "を返す。
/// そうでなければ "NO "を返す。
/// 例えば:
/// >>> exchange(vec![1, 2, 3, 4], vec![1, 2, 3, 4])
/// String::from("YES")
/// >>> exchange(vec... | reworded | transform | HumanEval_110_exchange | }
fn main() {
let candidate = exchange;
assert_eq!(candidate(vec![1, 2, 3, 4], vec![1, 2, 3, 4]), String::from("YES"));
assert_eq!(candidate(vec![1, 2, 3, 4], vec![1, 5, 3, 4]), String::from("NO"));
assert_eq!(candidate(vec![1, 2, 3, 4], vec![2, 1, 4, 3]), String::from("YES"));
assert_eq!(candidate... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | rs |
[
"\n}"
] | use std::collections::HashMap;
/// 空白で区切られた小文字を表す文字列が与えられる。最も出現回数が多い文字と
/// 対応するカウントの辞書を返す。
/// 複数の文字が同じ出現回数を持つ場合、それらすべてを返す。
/// 例:
/// >>> histogram(String::from("a b c"))
/// HashMap::from([(String::from("a"), 1), (String::from("b"), 1), (String::from("c"), 1)])
/// >>> histogram(String::from("a b b a"))
/// HashMap... | reworded | transform | HumanEval_111_histogram | }
fn main() {
let candidate = histogram;
assert_eq!(candidate(String::from("a b b a")), HashMap::from([(String::from("a"), 2), (String::from("b"), 2)]));
assert_eq!(candidate(String::from("a b c a b")), HashMap::from([(String::from("a"), 2), (String::from("b"), 2)]));
assert_eq!(candidate(String::from(... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | rs |
[
"\n}"
] | /// 課題
/// sとcの2つの文字列が与えられる。sに含まれる文字のうち、cに含まれる文字と
/// 等しいものをすべて削除し、その結果の文字列が回文かどうかをチェックする。
/// 文字列は、後ろから読んでも前から読んでも同じであれば回文と呼ばれる。
/// 結果文字列とチェックのためのtrue/falseを含むタプルを返す必要がある。
/// 例
/// >>> reverse_delete(String::from("abcde"), String::from("ae"))
/// (String::from("bcd"), false)
/// >>> reverse_delete(String::from("abcd... | reworded | transform | HumanEval_112_reverse_delete | }
fn main() {
let candidate = reverse_delete;
assert_eq!(candidate(String::from("abcde"), String::from("ae")), (String::from("bcd"), false));
assert_eq!(candidate(String::from("abcdef"), String::from("b")), (String::from("acdef"), false));
assert_eq!(candidate(String::from("abcdedcba"), String::from("a... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | rs |
[
"\n}"
] | /// 数字のみで構成された文字列のリストを引数として受け取り、新しいリストを返します。
/// 出力される新しいリストの各要素は、"the number of odd elements in the string i of the
/// input."となりますが、この文字列内のすべての 'i' は、入力リストのi番目の文字列に含ま
/// る奇数の数に置き換えられます。
/// >>> odd_count(vec![String::from("1234567")])
/// vec![String::from("the number of odd elements 4n the str4ng 4 of the 4nput."... | reworded | transform | HumanEval_113_odd_count | }
fn main() {
let candidate = odd_count;
assert_eq!(candidate(vec![String::from("1234567")]), vec![String::from("the number of odd elements 4n the str4ng 4 of the 4nput.")]);
assert_eq!(candidate(vec![String::from("3"), String::from("11111111")]), vec![String::from("the number of odd elements 1n the str1ng... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | rs |
[
"\n}"
] | /// 整数の配列 nums が与えられたとき、nums の空でない部分配列の最小和を求めよ。
/// 例:
/// >>> minSubArraySum(vec![2, 3, 4, 1, 2, 4])
/// 1
/// >>> minSubArraySum(vec![-1, -2, -3])
/// -6
fn minSubArraySum(nums: Vec<isize>) -> isize {
| reworded | transform | HumanEval_114_minSubArraySum | }
fn main() {
let candidate = minSubArraySum;
assert_eq!(candidate(vec![2, 3, 4, 1, 2, 4]), 1);
assert_eq!(candidate(vec![-1, -2, -3]), -6);
assert_eq!(candidate(vec![-1, -2, -3, 2, -10]), -14);
assert_eq!(candidate(vec![-9999999999999999]), -9999999999999999);
assert_eq!(candidate(vec![0, 10, ... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | rs |
[
"\n}"
] | /// 長方形のグリッド状(grid)の井戸が与えられる。各行が1つの井戸を表し、
/// 行の1が1単位の水を表す。
/// 各井戸には，そこから水を汲み上げるのに使える対応するバケツがあり，
/// すべてのバケツ容量(capacity)は同じである．
/// あなたの仕事は，バケツを使って井戸を空にすることである．
/// バケツを降ろす回数を出力せよ．
/// 例 1:
/// >>> max_fill(vec![vec![0, 0, 1, 0], vec![0, 1, 0, 0], vec![1, 1, 1, 1]], 1)
/// 6
/// 例 2:
/// >>> max_fill(vec![vec![0, 0, 1... | reworded | transform | HumanEval_115_max_fill | }
fn main() {
let candidate = max_fill;
assert_eq!(candidate(vec![vec![0, 0, 1, 0], vec![0, 1, 0, 0], vec![1, 1, 1, 1]], 1), 6);
assert_eq!(candidate(vec![vec![0, 0, 1, 1], vec![0, 0, 0, 0], vec![1, 1, 1, 1], vec![0, 1, 1, 1]], 2), 5);
assert_eq!(candidate(vec![vec![0, 0, 0], vec![0, 0, 0]], 5), 0);
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | rs |
[
"\n}"
] | /// この問題では、非負整数の配列を2進数表現における"1"の個数を昇順でソートする。
/// "1"の個数が同じ場合は，10進数に基づいてソートする。
/// 次のように実装する：
/// >>> sort_array(vec![1, 5, 2, 3, 4])
/// vec![1, 2, 3, 4, 5]
/// >>> sort_array(vec![-2, -3, -4, -5, -6])
/// vec![-6, -5, -4, -3, -2]
/// >>> sort_array(vec![1, 0, 2, 3, 4])
/// vec![0, 1, 2, 3, 4]
fn sort_array(arr: Vec<is... | reworded | transform | HumanEval_116_sort_array | }
fn main() {
let candidate = sort_array;
assert_eq!(candidate(vec![1, 5, 2, 3, 4]), vec![1, 2, 4, 3, 5]);
assert_eq!(candidate(vec![-2, -3, -4, -5, -6]), vec![-4, -2, -6, -5, -3]);
assert_eq!(candidate(vec![1, 0, 2, 3, 4]), vec![0, 1, 2, 4, 3]);
assert_eq!(candidate(Vec::<isize>::new()), Vec::<isi... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py | rs |
[
"\n}"
] | /// ある文字列sと自然数nが与えらる。あなたに課せられたタスクは、文字列s
/// の中から、ちょうどn個の子音を含むすべての単語のリストを現れる順に返す
/// 関数を実装することである。
/// 注意：入力文字列には英文字と空白しか含まれないと仮定してもよい。
/// 例:
/// >>> select_words(String::from("Mary had a little lamb"), 4)
/// vec![String::from("little")]
/// >>> select_words(String::from("Mary had a little lamb"), 3)
/// vec![String::... | reworded | transform | HumanEval_117_select_words | }
fn main() {
let candidate = select_words;
assert_eq!(candidate(String::from("Mary had a little lamb"), 4), vec![String::from("little")]);
assert_eq!(candidate(String::from("Mary had a little lamb"), 3), vec![String::from("Mary"), String::from("lamb")]);
assert_eq!(candidate(String::from("simple white... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | rs |
[
"\n}"
] | /// 単語が与えられる。あなたの仕事は、単語の右側から2つの子音（大文字と
/// 小文字を区別）の間に立っている最も近い母音を見つけることである。
/// 最初と最後の母音はカウントされない。上記の条件を満たす母音が見つから
/// なかった場合は、空の文字列を返せ。
/// 指定された文字列は英字のみを含むとみなしてよい。
/// 例:
/// >>> get_closest_vowel(String::from("yogurt"))
/// String::from("u")
/// >>> get_closest_vowel(String::from("FULL"))
/// String::from("U")
/// >... | reworded | transform | HumanEval_118_get_closest_vowel | }
fn main() {
let candidate = get_closest_vowel;
assert_eq!(candidate(String::from("yogurt")), String::from("u"));
assert_eq!(candidate(String::from("full")), String::from("u"));
assert_eq!(candidate(String::from("easy")), String::from(""));
assert_eq!(candidate(String::from("eAsy")), String::from(... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | rs |
[
"\n}"
] | /// 2つの文字列からなるリストが与えられます。両方の文字列は開き括弧 '(' または
/// 閉じ括弧 ')' のみで構成されています。
/// あなたの仕事は、2つの文字列を何らかの順序で結合して、「良い」文字列にすることが
/// 可能かどうかを確認することです。
/// 文字列Sが「良い」とは、文字列内のすべての括弧がバランスしている場合に限ります。
/// 例えば、文字列 '(())()' は良いですが、文字列 '())' は良くありません。
/// 良い文字列を作る方法がある場合は 'Yes' を返し、そうでない場合は 'No' を返してください。
/// 例
/// >>> match_parens(vec![Str... | reworded | transform | HumanEval_119_match_parens | }
fn main() {
let candidate = match_parens;
assert_eq!(candidate(vec![String::from("()("), String::from(")")]), String::from("Yes"));
assert_eq!(candidate(vec![String::from(")"), String::from(")")]), String::from("No"));
assert_eq!(candidate(vec![String::from("(()(())"), String::from("())())")]), Strin... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | rs |
[
"\n}"
] | /// 整数の配列 arr と正の整数 k が与えられる。arr に含まれる大きい方から k 個の数を含む
/// 長さ k のソート済みリストを返す。
/// 例 1:
/// >>> maximum(vec![-3, -4, 5], 3)
/// vec![-4, -3, 5]
/// 例 2:
/// >>> maximum(vec![4, -4, 4], 2)
/// vec![4, 4]
/// 例 3:
/// >>> maximum(vec![-3, 2, 1, 2, -1, -2, 1], 1)
/// vec![2]
/// ノート:
/// 1. 配列の長さは[1, 1000]の範囲とする。
/// 2. 配列の... | reworded | transform | HumanEval_120_maximum | }
fn main() {
let candidate = maximum;
assert_eq!(candidate(vec![-3, -4, 5], 3), vec![-4, -3, 5]);
assert_eq!(candidate(vec![4, -4, 4], 2), vec![4, 4]);
assert_eq!(candidate(vec![-3, 2, 1, 2, -1, -2, 1], 1), vec![2]);
assert_eq!(candidate(vec![123, -123, 20, 0, 1, 2, -3], 3), vec![2, 20, 123]);
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | rs |
[
"\n}"
] | /// 整数の空でないリストが与えられた時、偶数の位置にある奇数の要素の合計を返す。
/// 例
/// >>> solution(vec![5, 8, 7, 1])
/// 12
/// >>> solution(vec![3, 3, 3, 3, 3])
/// 9
/// >>> solution(vec![30, 13, 24, 321])
/// 0
fn solution(lst: Vec<isize>) -> isize {
| reworded | transform | HumanEval_121_solution | }
fn main() {
let candidate = solution;
assert_eq!(candidate(vec![5, 8, 7, 1]), 12);
assert_eq!(candidate(vec![3, 3, 3, 3, 3]), 9);
assert_eq!(candidate(vec![30, 13, 24, 321]), 0);
assert_eq!(candidate(vec![5, 9]), 5);
assert_eq!(candidate(vec![2, 4, 8]), 0);
assert_eq!(candidate(vec![30, 1... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | rs |
[
"\n}"
] | /// 整数の空でない配列 arr と整数 k が与えられたとき、
/// arr の最初の k 個の要素から高々 2 桁までの要素の和を返す。
/// 例:
/// >>> add_elements(vec![111, 21, 3, 4000, 5, 6, 7, 8, 9], 4)
/// 24
/// # 21 + 3 の話
/// 制約:
/// 1. 1 <= len(arr) <= 100
/// 2. 1 <= k <= len(arr)
fn add_elements(arr: Vec<isize>, k: isize) -> isize {
| reworded | transform | HumanEval_122_add_elements | }
fn main() {
let candidate = add_elements;
assert_eq!(candidate(vec![1, -2, -3, 41, 57, 76, 87, 88, 99], 3), -4);
assert_eq!(candidate(vec![111, 121, 3, 4000, 5, 6], 2), 0);
assert_eq!(candidate(vec![11, 21, 3, 90, 5, 6, 7, 8, 9], 4), 125);
assert_eq!(candidate(vec![111, 21, 3, 4000, 5, 6, 7, 8, 9... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | rs |
[
"\n}"
] | /// 正の整数nが与えられたとき、コラッツ数列の奇数を持つソートされたリストを返す。
/// コラッツ予想とは数学の予想で、次のように定義される数列に関するものである：
/// 任意の正の整数nから始め、各項は前の項から次のように求められる。
/// 前の項が偶数なら、次の項は前の項の2分の1である。前の項が奇数の場合、次の項は前の項の3倍＋1である。
/// 予想では、nがどのような値であっても、数列は必ず1に達する。
/// 注:
/// 1. Collatz(1)は[1]である。
/// 2. 返されるリストは昇順にソートされている。
/// 例えば:
/// get_odd_collatz(5) は [1, 5]を返す... | reworded | transform | HumanEval_123_get_odd_collatz | }
fn main() {
let candidate = get_odd_collatz;
assert_eq!(candidate(14), vec![1, 5, 7, 11, 13, 17]);
assert_eq!(candidate(5), vec![1, 5]);
assert_eq!(candidate(12), vec![1, 3, 5]);
assert_eq!(candidate(1), vec![1]);
}
| /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | rs |
[
"\n}"
] | /// 与えられた日付文字列を検証し、その日付が有効であれば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(String::fro... | reworded | transform | HumanEval_124_valid_date | }
fn main() {
let candidate = valid_date;
assert_eq!(candidate(String::from("03-11-2000")), true);
assert_eq!(candidate(String::from("15-01-2012")), false);
assert_eq!(candidate(String::from("04-0-2040")), false);
assert_eq!(candidate(String::from("06-04-2020")), true);
assert_eq!(candidate(Str... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | rs |
[
"\n}"
] | /// 数字のリストが与えられたとき、昇順に整列されているかどうかを返す。
/// リストに同じ数の重複が1つ以上ある場合は、falseを返す。
/// 負の数はなく、整数のみであると仮定する。
/// 例
/// >>> is_sorted(vec![5])
/// true
/// >>> is_sorted(vec![1, 2, 3, 4, 5])
/// true
/// >>> is_sorted(vec![1, 3, 2, 4, 5])
/// false
/// >>> is_sorted(vec![1, 2, 3, 4, 5, 6])
/// true
/// >>> is_sorted(vec![1, 2, 3, ... | reworded | transform | HumanEval_126_is_sorted | }
fn main() {
let candidate = is_sorted;
assert_eq!(candidate(vec![5]), true);
assert_eq!(candidate(vec![1, 2, 3, 4, 5]), true);
assert_eq!(candidate(vec![1, 3, 2, 4, 5]), false);
assert_eq!(candidate(vec![1, 2, 3, 4, 5, 6]), true);
assert_eq!(candidate(vec![1, 2, 3, 4, 5, 6, 7]), true);
as... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | rs |
[
"\n}"
] | /// 2つの区間が与えられます。
/// それぞれの区間は整数のペアで示されます。例えば、区間 = (start, end ) = (1, 2) です。
/// 与えられた区間は閉区間であり、start と end の両端が含まれます。
/// 各区間について、start は end 以下であると仮定します。
/// あなたの仕事は、これら2つの区間の交差部分の長さが素数であるかどうかを判断することです。
/// 例えば、区間 (1, 3) と (2, 4) の交差部分は (2, 3) で、その長さは1ですが、これは素数ではありません。
/// 交差部分の長さが素数であれば "YES" を返し、そうでなければ "NO"... | reworded | transform | HumanEval_127_intersection | }
fn main() {
let candidate = intersection;
assert_eq!(candidate((1, 2), (2, 3)), String::from("NO"));
assert_eq!(candidate((-1, 1), (0, 4)), String::from("NO"));
assert_eq!(candidate((-3, -1), (-5, 5)), String::from("YES"));
assert_eq!(candidate((-2, 2), (-4, 0)), String::from("YES"));
assert_... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | rs |
[
"\n}"
] | /// 整数の配列 arr が与えられます。この配列に含まれる各数値の絶対値の合計と、
/// 各数値の符号（プラスは1、マイナスは-1、ゼロは0）の積を掛け合わせた値を
/// 返してください。
/// 注意：配列`arr`が空の場合は`None`を返してください。
/// 例:
/// >>> prod_signs(vec![1, 2, 2, -4])
/// Some(9)
/// >>> prod_signs(vec![0, 1])
/// Some(0)
/// >>> prod_signs(vec![])
/// None
fn prod_signs(arr: Vec<isize>) -> Option<isize> {... | reworded | transform | HumanEval_128_prod_signs | }
fn main() {
let candidate = prod_signs;
assert_eq!(candidate(vec![1, 2, 2, -4]), Some(-9));
assert_eq!(candidate(vec![0, 1]), Some(0));
assert_eq!(candidate(vec![1, 1, 1, 2, 3, -1, 1]), Some(-10));
assert_eq!(candidate(Vec::<isize>::new()), None);
assert_eq!(candidate(vec![2, 4, 1, 2, -1, -1,... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py | rs |
[
"\n}"
] | /// N行とN列 (N >= 2)) のグリッドと正の整数kが与えられた場合、各セルには値が含まれている。
/// 囲[1, N * N]（両端を含む）のすべての整数は、グリッドのセルに一度だけ表れる。
/// このグリッド内で長さkの最短の経路を見つける必要がある。任意のセルからスタートでき、
/// 各ステップで隣接するセルに移動できる。言い換えれば、現在のセルと辺を共有するセルに
/// 移動できる。長さkの経路とは、正確にk個のセル（必ずしも異なるとは限らない）を訪れる
/// ことを意味する。ただし、グリッドから出ることはない。
/// 長さkの2つの経路AとBがある場合、AとBが通るセルの値を順番にリスト化したものを
... | reworded | transform | HumanEval_129_minPath | }
fn main() {
let candidate = minPath;
assert_eq!(candidate(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]], 3), vec![1, 2, 1]);
assert_eq!(candidate(vec![vec![5, 9, 3], vec![4, 1, 6], vec![7, 8, 2]], 1), vec![1]);
assert_eq!(candidate(vec![vec![1, 2, 3, 4], vec![5, 6, 7, 8], vec![9, 10, 11, 12], vec... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | rs |
[
"\n}"
] | /// フィボナッチ数列は、ここ数世紀の間に数学者によって深く研究され、誰もが知っている。
/// しかし、人々が知らないのはトリボナッチ数列である。
/// トリボナッチ数列は再帰によって定義される:
/// 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)
/// ... | reworded | transform | HumanEval_130_tri | }
fn main() {
let candidate = tri;
assert_eq!(candidate(3), vec![1, 3, 2, 8]);
assert_eq!(candidate(4), vec![1, 3, 2, 8, 3]);
assert_eq!(candidate(5), vec![1, 3, 2, 8, 3, 15]);
assert_eq!(candidate(6), vec![1, 3, 2, 8, 3, 15, 4]);
assert_eq!(candidate(7), vec![1, 3, 2, 8, 3, 15, 4, 24]);
as... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | rs |
[
"\n}"
] | /// 正の整数 n が与えられた時、奇数桁数の積を返す。
/// 全ての桁が偶数の場合は0を返す。
/// 例えば:
/// >>> digits(1)
/// 1
/// >>> digits(4)
/// 0
/// >>> digits(235)
/// 15
fn digits(n: isize) -> isize {
| reworded | transform | HumanEval_131_digits | }
fn main() {
let candidate = digits;
assert_eq!(candidate(5), 5);
assert_eq!(candidate(54), 5);
assert_eq!(candidate(120), 1);
assert_eq!(candidate(5014), 5);
assert_eq!(candidate(98765), 315);
assert_eq!(candidate(5576543), 2625);
assert_eq!(candidate(2468), 0);
}
| /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | rs |
[
"\n}"
] | /// この関数は、角括弧だけを含む文字列を入力として受け取ります。括弧が有効な順序で
/// 並んでいて、その中に少なくとも1つの括弧が入れ子になっている場合、関数はtrueを
/// 返すようにしてください。
/// >>> is_nested(String::from("[[]]"))
/// true
/// >>> is_nested(String::from("[]]]]]]][[[[[]"))
/// false
/// >>> is_nested(String::from("[][]"))
/// false
/// >>> is_nested(String::from("[]"))
/// false
/// >>... | reworded | transform | HumanEval_132_is_nested | }
fn main() {
let candidate = is_nested;
assert_eq!(candidate(String::from("[[]]")), true);
assert_eq!(candidate(String::from("[]]]]]]][[[[[]")), false);
assert_eq!(candidate(String::from("[][]")), false);
assert_eq!(candidate(String::from("[]")), false);
assert_eq!(candidate(String::from("[[[[... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | rs |
[
"\n}"
] | /// 数字のリストが与えられます。
/// 与えられたリスト内の各数値をまず切り上げ（天井関数を使って最も近い整数に丸める）、
/// その後それぞれの数値を二乗した値の合計を返してください。
/// 例:
/// >>> lst(vec![1.0, 2.0, 3.0])
/// 14
/// >>> lst(vec![1.0, 4.0, 9.0])
/// 98
/// >>> lst(vec![1.0, 3.0, 5.0, 7.0])
/// 84
/// >>> lst(vec![1.4, 4.2, 0.0])
/// 29
/// >>> lst(vec![-2.4, 1.0, 1.0])
/// 6
fn sum_squ... | reworded | transform | HumanEval_133_sum_squares | }
fn main() {
let candidate = sum_squares;
assert_eq!(candidate(vec![1.0, 2.0, 3.0]), 14);
assert_eq!(candidate(vec![1.0, 2.0, 3.0]), 14);
assert_eq!(candidate(vec![1.0, 3.0, 5.0, 7.0]), 84);
assert_eq!(candidate(vec![1.4, 4.2, 0.0]), 29);
assert_eq!(candidate(vec![-2.4, 1.0, 1.0]), 6);
ass... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | rs |
[
"\n}"
] | /// 与えられた文字列の最後の文字がアルファベットであり、かつ単語の一部でなければtrueを、
/// そうでなければfalseを返す関数を作成せよ。
/// 注意：単語とはスペースで区切られた文字の並びである。
/// 例:
/// >>> check_if_last_char_is_a_letter(String::from("apple pie"))
/// false
/// >>> check_if_last_char_is_a_letter(String::from("apple pi e"))
/// true
/// >>> check_if_last_char_is_a_letter(String::from("... | reworded | transform | HumanEval_134_check_if_last_char_is_a_letter | }
fn main() {
let candidate = check_if_last_char_is_a_letter;
assert_eq!(candidate(String::from("apple")), false);
assert_eq!(candidate(String::from("apple pi e")), true);
assert_eq!(candidate(String::from("eeeee")), false);
assert_eq!(candidate(String::from("A")), true);
assert_eq!(candidate(S... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | rs |
[
"\n}"
] | /// 直前の要素よりも大きくない要素の中で、最も大きなインデックスを持つ要素を探して
/// そのインデックスを返す関数を作成してください。そのような要素が存在しない場合は、
/// -1を返してください。与えられる配列には重複する値は含まれません。
/// 例:
/// >>> can_arrange(vec![1, 2, 4, 3, 5])
/// 3
/// >>> can_arrange(vec![1, 2, 3])
/// -1
fn can_arrange(arr: Vec<isize>) -> isize {
| reworded | transform | HumanEval_135_can_arrange | }
fn main() {
let candidate = can_arrange;
assert_eq!(candidate(vec![1, 2, 4, 3, 5]), 3);
assert_eq!(candidate(vec![1, 2, 4, 5]), -1);
assert_eq!(candidate(vec![1, 4, 2, 5, 6, 7, 8, 9, 10]), 2);
assert_eq!(candidate(vec![4, 8, 5, 7, 3]), 4);
assert_eq!(candidate(Vec::<isize>::new()), -1);
}
| /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | rs |
[
"\n}"
] | /// リストから最も大きな負の整数と最も小さな正の整数を見つけ、それらをタプル（a, b）
/// として返す関数を作成してください。リストに負の整数もしくは正の整数がない場合は、
/// 代わりにNoneを返します。
/// 例:
/// >>> largest_smallest_integers(vec![2, 4, 1, 3, 5, 7])
/// (None, Some(1))
/// >>> largest_smallest_integers(vec![])
/// (None, None)
/// >>> largest_smallest_integers(vec![0])
/// (None, None)
fn la... | reworded | transform | HumanEval_136_largest_smallest_integers | }
fn main() {
let candidate = largest_smallest_integers;
assert_eq!(candidate(vec![2, 4, 1, 3, 5, 7]), (None, Some(1)));
assert_eq!(candidate(vec![2, 4, 1, 3, 5, 7, 0]), (None, Some(1)));
assert_eq!(candidate(vec![1, 3, 2, 4, 5, 6, -2]), (Some(-2), Some(1)));
assert_eq!(candidate(vec![4, 5, 3, 6, 2... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | rs |
[
"\n}"
] | /// 与えられた数値nが、ちょうど4つの正の偶数の合計として表現できるかどうかを評価してください。
/// 例
/// >>> is_equal_to_sum_even(4)
/// false
/// >>> is_equal_to_sum_even(6)
/// false
/// >>> is_equal_to_sum_even(8)
/// true
fn is_equal_to_sum_even(n: isize) -> bool {
| reworded | transform | HumanEval_138_is_equal_to_sum_even | }
fn main() {
let candidate = is_equal_to_sum_even;
assert_eq!(candidate(4), false);
assert_eq!(candidate(6), false);
assert_eq!(candidate(8), true);
assert_eq!(candidate(10), true);
assert_eq!(candidate(11), false);
assert_eq!(candidate(12), true);
assert_eq!(candidate(13), false);
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | rs |
[
"\n}"
] | /// ブラジリアン階乗は次のように定義される：
/// brazilian_factorial(n) = n！* (n-1)! * (n-2)! * ... * 1!
/// ただし n > 0
/// 例えば:
/// >>> special_factorial(4)
/// 288
/// この関数は入力として整数を受け取り、整数の特殊な階乗を返す。
fn special_factorial(n: isize) -> isize {
| reworded | transform | HumanEval_139_special_factorial | }
fn main() {
let candidate = special_factorial;
assert_eq!(candidate(4), 288);
assert_eq!(candidate(5), 34560);
assert_eq!(candidate(7), 125411328000);
assert_eq!(candidate(1), 1);
}
| /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | rs |
[
"\n}"
] | /// 文字列テキストが与えられた場合、その中のすべての空白をアンダースコアに置換し、
/// 文字列が2つ以上の連続した空白を持つ場合、すべての連続した空白を - に置換する
/// >>> fix_spaces(String::from(" Example"))
/// String::from("Example")
/// >>> fix_spaces(String::from(" Example 1"))
/// String::from("Example_1")
/// >>> fix_spaces(String::from(" Example 2"))
/// String::from("_Example_2")
//... | reworded | transform | HumanEval_140_fix_spaces | }
fn main() {
let candidate = fix_spaces;
assert_eq!(candidate(String::from("Example")), String::from("Example"));
assert_eq!(candidate(String::from("Mudasir Hanif ")), String::from("Mudasir_Hanif_"));
assert_eq!(candidate(String::from("Yellow Yellow Dirty Fellow")), String::from("Yellow_Yellow__Dirt... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | rs |
[
"\n}"
] | /// ファイル名を表す文字列を受け取り、そのファイル名が有効であれば'Yes'を返し、そうでなければ'No'
/// を返す関数を作成する。ファイル名が有効であるとみなされるのは、
/// 以下の条件をすべて満たす場合のみである：
/// - ファイル名に3桁以上の数字（'0'-'9'）があってはならない。
/// - ファイル名に含まれるドット '.' はひとつのみ。
/// - ドットの前の部分文字列は空であってはならず、英文字（'a'-'z'および'A'-'Z'）から始まる文字でなければならない。
/// - ドットの後の部分文字列は、以下のいずれかでなければならない： ['txt'、'exe'、'dll']。
/// 例:... | reworded | transform | HumanEval_141_file_name_check | }
fn main() {
let candidate = file_name_check;
assert_eq!(candidate(String::from("example.txt")), String::from("Yes"));
assert_eq!(candidate(String::from("1example.dll")), String::from("No"));
assert_eq!(candidate(String::from("s1sdf3.asd")), String::from("No"));
assert_eq!(candidate(String::from("... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | rs |
[
"\n}"
] | /// "
/// この関数は整数のリストを受け取ります。リスト内の各要素に対して、そのインデックスが3の倍数で
/// あればその整数を二乗し、インデックスが4の倍数でかつ3の倍数でない場合はその整数を三乗します。
/// インデックスが3または4の倍数でない要素については、何も変更しません。最後に、すべての要素の
/// 合計値を返します。
/// 例:
/// >>> lst
/// vec![1, 2, 3]
/// >>> lst
/// vec![]
/// >>> lst
/// vec![-1, -5, 2, -1, -5]
fn sum_squares(lst: Vec<isize>) -> isize {
| reworded | transform | HumanEval_142_sum_squares | }
fn main() {
let candidate = sum_squares;
assert_eq!(candidate(vec![1, 2, 3]), 6);
assert_eq!(candidate(vec![1, 4, 9]), 14);
assert_eq!(candidate(Vec::<isize>::new()), 0);
assert_eq!(candidate(vec![1, 1, 1, 1, 1, 1, 1, 1, 1]), 9);
assert_eq!(candidate(vec![-1, -1, -1, -1, -1, -1, -1, -1, -1]),... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | rs |
[
"\n}"
] | /// 文を表す文字列が与えられ、その文には空白で区切られたいくつかの単語が含まれている。
/// 元の文の単語を含みその長さが素数である文字列を返す必要がある。
/// 新しい文字列の単語の順序は元の文字列と同じでなければならない。
/// 例 1:
/// >>> words_in_sentence(String::from("This is a test"))
/// String::from("is")
/// 例 2:
/// >>> words_in_sentence(String::from("lets go for swimming"))
/// String::from("go for")
/// 制約:
/// ... | reworded | transform | HumanEval_143_words_in_sentence | }
fn main() {
let candidate = words_in_sentence;
assert_eq!(candidate(String::from("This is a test")), String::from("is"));
assert_eq!(candidate(String::from("lets go for swimming")), String::from("go for"));
assert_eq!(candidate(String::from("there is no place available here")), String::from("there is... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | rs |
[
"\n}"
] | /// あなたの仕事は、式 x * n を簡単にする関数を実装することです。
/// この関数は、x * n が整数になる場合はtrueを、そうでない場合はfalseを
/// 返します。xとnはともに分数の文字列表現であり、<分子>/<分母>という形式で、
/// 分子と分母はともに正の整数です。
/// xとnが有効な分数であり、分母がゼロでないことは仮定してかまいません。
/// >>> simplify(String::from("1/5"), String::from("5/1"))
/// true
/// >>> simplify(String::from("1/6"), String::from("2/1"))
//... | reworded | transform | HumanEval_144_simplify | }
fn main() {
let candidate = simplify;
assert_eq!(candidate(String::from("1/5"), String::from("5/1")), true);
assert_eq!(candidate(String::from("1/6"), String::from("2/1")), false);
assert_eq!(candidate(String::from("5/1"), String::from("3/1")), true);
assert_eq!(candidate(String::from("7/10"), St... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | rs |
[
"\n}"
] | /// 各数字の桁の合計に基づいて、与えられた整数のリストを昇順に並べる
/// 関数を作成してください。
/// 注意：もし桁の合計が同じである複数の項目がある場合は、
/// 元のリストでの位置に基づいて並べてください。
/// 例えば
/// >>> order_by_points(vec![1, 11, -1, -11, -12])
/// vec![-1, -11, 1, -12, 11]
/// >>> order_by_points(vec![])
/// Vec::<isize>::new()
fn order_by_points(nums: Vec<isize>) -> Vec<isize> {
| reworded | transform | HumanEval_145_order_by_points | }
fn main() {
let candidate = order_by_points;
assert_eq!(candidate(vec![1, 11, -1, -11, -12]), vec![-1, -11, 1, -12, 11]);
assert_eq!(candidate(vec![1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46]), vec![0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]);
assert_eq!(can... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | rs |
[
"\n}"
] | /// 数値の配列を入力とし、配列中の要素のうち、10より大きく、
/// かつ数値の最初と最後の桁の両方が奇数（1, 3, 5, 7, 9）である要素の数を返す関数を書く。
/// 例えば
/// >>> specialFilter(vec![15, -73, 14, -15])
/// 1
/// >>> specialFilter(vec![33, -2, -3, 45, 21, 109])
/// 2
fn specialFilter(nums: Vec<isize>) -> isize {
| reworded | transform | HumanEval_146_specialFilter | }
fn main() {
let candidate = specialFilter;
assert_eq!(candidate(vec![5, -2, 1, -5]), 0);
assert_eq!(candidate(vec![15, -73, 14, -15]), 1);
assert_eq!(candidate(vec![33, -2, -3, 45, 21, 109]), 2);
assert_eq!(candidate(vec![43, -12, 93, 125, 121, 109]), 4);
assert_eq!(candidate(vec![71, -2, -33... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | rs |
[
"\n}"
] | /// 正の整数 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
/// 解説:
/// a = [1, 3, 7, 13, 21]
/// 唯一の妥当な三つ組は (1, 7, 13)である。
fn get_max_triples(n: isize) -> isize {
| reworded | transform | HumanEval_147_get_max_triples | }
fn main() {
let candidate = get_max_triples;
assert_eq!(candidate(5), 1);
assert_eq!(candidate(6), 4);
assert_eq!(candidate(10), 36);
assert_eq!(candidate(100), 53361);
}
| /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | rs |
[
"\n}"
] | /// 文字列のリストを引数として受け取る関数を作成してください。
/// この関数は、リストから奇数の長さを持つ文字列を削除し、
/// 結果として得られるリストを長さで昇順に並べ替えて返します。
/// リストは常に文字列のリストであり、数字の配列ではありません。
/// また、重複する文字列が含まれる可能性があります。
/// リストは各単語の長さで昇順に並べられるべきで、そのルールに従ってソートされたリストを返してください。
/// もし二つの単語が同じ長さであれば、リストをアルファベット順に並べ替えてください。
/// 関数はソートされた順序で文字列のリストを返すべきです。
/// すべての単語が同じ長さを持つと仮定しても... | reworded | transform | HumanEval_149_sorted_list_sum | }
fn main() {
let candidate = sorted_list_sum;
assert_eq!(candidate(vec![String::from("aa"), String::from("a"), String::from("aaa")]), vec![String::from("aa")]);
assert_eq!(candidate(vec![String::from("school"), String::from("AI"), String::from("asdf"), String::from("b")]), vec![String::from("AI"), String:... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | rs |
[
"\n}"
] | /// 素数である場合はxの値を返し、それ以外の場合はyの値を返す簡単なプログラム。
/// 例:
/// >>> x_or_y(7, 34, 12)
/// 34
/// >>> x_or_y(15, 8, 5)
/// 5
fn x_or_y(n: isize, x: isize, y: isize) -> isize {
| reworded | transform | HumanEval_150_x_or_y | }
fn main() {
let candidate = x_or_y;
assert_eq!(candidate(7, 34, 12), 34);
assert_eq!(candidate(15, 8, 5), 5);
assert_eq!(candidate(3, 33, 5212), 33);
assert_eq!(candidate(1259, 3, 52), 3);
assert_eq!(candidate(7919, -1, 12), -1);
assert_eq!(candidate(3609, 1245, 583), 583);
assert_eq!... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | rs |
[
"\n}"
] | /// 数字のリストが与えられた場合、そのリスト内の奇数の数値の二乗の合計を返してください。
/// 負の数や整数でない数は無視してください。
/// >>> double_the_difference(vec![1, 3, 2, 0])
/// 10
/// >>> double_the_difference(vec![-1, -2, 0])
/// 0
/// >>> double_the_difference(vec![9, -2])
/// 81
/// >>> double_the_difference(vec![0])
/// 0
/// 入力リストが空の場合は0を返すようにしてください。
fn double_the_d... | reworded | transform | HumanEval_151_double_the_difference | }
fn main() {
let candidate = double_the_difference;
assert_eq!(candidate(Vec::<f64>::new()), 0);
assert_eq!(candidate(vec![5.0, 4.0]), 25);
assert_eq!(candidate(vec![0.1, 0.2, 0.3]), 0);
assert_eq!(candidate(vec![-10.0, -20.0, -30.0]), 0);
assert_eq!(candidate(vec![-1.0, -2.0, 8.0]), 0);
a... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | rs |
[
"\n}"
] | /// 待ち望んでいた出来事の結果がようやく判明したときの感覚は、誰もが覚えていると思う。
/// その瞬間に抱いた感情や思考は、間違いなくメモして比較する価値がある。
/// あなたの仕事は、人がいくつかの試合の結果を正確に予想したかどうかを判断することです。
/// スコアと予想の2つの配列が等しい長さで与えられます。各インデックスは1つの試合を示しています。
/// 各予想がどれだけ外れていたかを示す同じ長さの配列を返してください。予想が正確であれば、
/// その値は0です。そうでなければ、その値は予想とスコアの絶対的な差です。
/// 例:
/// >>> compare(vec![1, 2, 3, 4, 5, 1], v... | reworded | transform | HumanEval_152_compare | }
fn main() {
let candidate = compare;
assert_eq!(candidate(vec![1, 2, 3, 4, 5, 1], vec![1, 2, 3, 4, 2, -2]), vec![0, 0, 0, 0, 3, 3]);
assert_eq!(candidate(vec![0, 0, 0, 0, 0, 0], vec![0, 0, 0, 0, 0, 0]), vec![0, 0, 0, 0, 0, 0]);
assert_eq!(candidate(vec![1, 2, 3], vec![-1, -2, -3]), vec![2, 4, 6]);
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | rs |
[
"\n}"
] | /// クラスの名前（文字列）と拡張子のリストが与えられます。
/// この拡張子は、指定されたクラスに追加のクラスをロードするために使用されます。
/// 拡張子の強度は次のように計算されます：CAPは拡張子の名前に含まれる
/// 大文字の数、SMは小文字の数です。強度は、CAP - SM で与えられます。
/// 最も強い拡張子を見つけて、この形式の文字列を返してください：ClassName.StrongestExtensionName。
/// 同じ強度を持つ2つ以上の拡張子がある場合は、リストで最初に来るものを選びます。
/// 例えば、"Slices"というクラスと、拡張子のリスト['SErviNGSliCes', 'C... | reworded | transform | HumanEval_153_Strongest_Extension | }
fn main() {
let candidate = Strongest_Extension;
assert_eq!(candidate(String::from("Watashi"), vec![String::from("tEN"), String::from("niNE"), String::from("eIGHt8OKe")]), String::from("Watashi.eIGHt8OKe"));
assert_eq!(candidate(String::from("Boku123"), vec![String::from("nani"), String::from("NazeDa"), ... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | rs |
[
"\n}"
] | /// 2つの単語が与えられる。2番目の単語またはその回転させた文字列が最初の単語の部分文字列である場合、trueを返す必要がある。
/// >>> cycpattern_check(String::from("abcd"), String::from("abd"))
/// false
/// >>> cycpattern_check(String::from("hello"), String::from("ell"))
/// true
/// >>> cycpattern_check(String::from("whassup"), String::from("psus"))
/// false
/// >>> cycpatt... | reworded | transform | HumanEval_154_cycpattern_check | }
fn main() {
let candidate = cycpattern_check;
assert_eq!(candidate(String::from("xyzw"), String::from("xyw")), false);
assert_eq!(candidate(String::from("yello"), String::from("ell")), true);
assert_eq!(candidate(String::from("whattup"), String::from("ptut")), false);
assert_eq!(candidate(String:... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | rs |
[
"\n}"
] | /// 整数が与えられた場合、偶数桁数と奇数桁数をそれぞれ持つタプルを返す。
/// 例:
/// >>> even_odd_count(-12)
/// (1, 1)
/// >>> even_odd_count(123)
/// (1, 2)
fn even_odd_count(num: isize) -> (isize, isize) {
| reworded | transform | HumanEval_155_even_odd_count | }
fn main() {
let candidate = even_odd_count;
assert_eq!(candidate(7), (0, 1));
assert_eq!(candidate(-78), (1, 1));
assert_eq!(candidate(3452), (2, 2));
assert_eq!(candidate(346211), (3, 3));
assert_eq!(candidate(-345821), (3, 3));
assert_eq!(candidate(-2), (1, 0));
assert_eq!(candidate... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | rs |
[
"\n}"
] | /// 正の整数が与えられたとき、ローマ数字に相当する文字列を小文字で返す。
/// 制限事項1 <= num <= 1000
/// 例:
/// >>> int_to_mini_roman(19)
/// String::from("xix")
/// >>> int_to_mini_roman(152)
/// String::from("clii")
/// >>> int_to_mini_roman(426)
/// String::from("cdxxvi")
fn int_to_mini_roman(number: isize) -> String {
| reworded | transform | HumanEval_156_int_to_mini_roman | }
fn main() {
let candidate = int_to_mini_roman;
assert_eq!(candidate(19), String::from("xix"));
assert_eq!(candidate(152), String::from("clii"));
assert_eq!(candidate(251), String::from("ccli"));
assert_eq!(candidate(426), String::from("cdxxvi"));
assert_eq!(candidate(500), String::from("d"));... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | rs |
[
"\n}"
] | /// 三角形の3辺の長さを与える。三角形が直角三角形ならtrueを、そうでなければfalseを返す。
/// 直角三角形とは、1つの角が直角または90度である三角形のことである。
/// 例:
/// >>> right_angle_triangle(3, 4, 5)
/// true
/// >>> right_angle_triangle(1, 2, 3)
/// false
fn right_angle_triangle(a: isize, b: isize, c: isize) -> bool {
| reworded | transform | HumanEval_157_right_angle_triangle | }
fn main() {
let candidate = right_angle_triangle;
assert_eq!(candidate(3, 4, 5), true);
assert_eq!(candidate(1, 2, 3), false);
assert_eq!(candidate(10, 6, 8), true);
assert_eq!(candidate(2, 2, 2), false);
assert_eq!(candidate(7, 24, 25), true);
assert_eq!(candidate(10, 5, 7), false);
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | rs |
[
"\n}"
] | /// 文字列のリストを受け取る関数を書きなさい。
/// リストは異なる単語を含む。異なる固有の文字数が最も多い単語を返す。
/// 複数の文字列が同じ文字数を持つ場合は、辞書順で最初に来るものを返すことにする。
/// >>> find_max(vec![String::from("name"), String::from("of"), String::from("string")])
/// String::from("string")
/// >>> find_max(vec![String::from("name"), String::from("enam"), String::from("game")])
/// Str... | reworded | transform | HumanEval_158_find_max | }
fn main() {
let candidate = find_max;
assert_eq!(candidate(vec![String::from("name"), String::from("of"), String::from("string")]), String::from("string"));
assert_eq!(candidate(vec![String::from("name"), String::from("enam"), String::from("game")]), String::from("enam"));
assert_eq!(candidate(vec![S... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | rs |
[
"\n}"
] | /// あなたはお腹を空かせたウサギです。すでに一定数のニンジンを食べました。
/// bこれからさらにニンジンを食べなければその日の食事は完了しません。
/// あなたは [ 食事の後に食べたニンジンの総数, 食事の後に残ったニンジンの数 ] の配列を返してください。
/// もし残りのニンジンが十分でなければ、あなたは残りのニンジンをすべて食べますが、まだお腹が空いています。
/// 例:
/// >>> eat(5, 6, 10)
/// vec![11, 4]
/// >>> eat(4, 8, 9)
/// vec![12, 1]
/// >>> eat(1, 10, 10)
/// vec![11, 0]
/// >>... | reworded | transform | HumanEval_159_eat | }
fn main() {
let candidate = eat;
assert_eq!(candidate(5, 6, 10), vec![11, 4]);
assert_eq!(candidate(4, 8, 9), vec![12, 1]);
assert_eq!(candidate(1, 10, 10), vec![11, 0]);
assert_eq!(candidate(2, 11, 5), vec![7, 0]);
assert_eq!(candidate(4, 5, 7), vec![9, 2]);
assert_eq!(candidate(4, 5, 1)... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | rs |
[
"\n}"
] | /// 演算子(operator)とオペランド(operand)の2つのリストが与えられる。ひとつ目のリストは
/// 基本的な算術演算を持ち、二つ目のリストは整数のリストである。与えられた2つのリストを
/// 使って算術式を構築し、その評価結果を返そう。
/// 基本的な算術演算:
/// 加算 ( + )
/// 減算 ( - )
/// 乗算 ( * )
/// 階除算 ( // )
/// 指数化 ( ** )
/// 例:
/// operator['+', '*', '-']
/// vector = [2, 3, 4, 5]
/// result = 2 + 3 * 4 - 5
/// => result = ... | reworded | transform | HumanEval_160_do_algebra | }
fn main() {
let candidate = do_algebra;
assert_eq!(candidate(vec![String::from("**"), String::from("*"), String::from("+")], vec![2, 3, 4, 5]), 37);
assert_eq!(candidate(vec![String::from("+"), String::from("*"), String::from("-")], vec![2, 3, 4, 5]), 9);
assert_eq!(candidate(vec![String::from("//"),... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | rs |
[
"\n}"
] | /// 文字列sが与えられます。
/// もしs[i]がアルファベットなら、その文字の大文字と小文字を反転させる。そうでない場合は、そのままにしておく。
/// もし文字列にアルファベットが一つも含まれていない場合は、文字列全体を逆順にする。
/// 関数は結果の文字列を返すようにします。
/// 例
/// >>> solve(String::from("1234"))
/// String::from("4321")
/// >>> solve(String::from("ab"))
/// String::from("AB")
/// >>> solve(String::from("#a@C"))
/// String::fr... | reworded | transform | HumanEval_161_solve | }
fn main() {
let candidate = solve;
assert_eq!(candidate(String::from("AsDf")), String::from("aSdF"));
assert_eq!(candidate(String::from("1234")), String::from("4321"));
assert_eq!(candidate(String::from("ab")), String::from("AB"));
assert_eq!(candidate(String::from("#a@C")), String::from("#A@c"))... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | rs |
[
"\n}"
] | /// 文字列 text が与えられたとき、その md5 ハッシュと等価な文字列を返す。
/// text' が空文字列の場合は None を返す。
/// >>> string_to_md5(String::from("Hello world"))
/// Some(String::from("3e25960a79dbc69b674cd4ec67a72c62"))
fn string_to_md5(text: String) -> Option<String> {
| reworded | transform | HumanEval_162_string_to_md5 | }
fn main() {
let candidate = string_to_md5;
assert_eq!(candidate(String::from("Hello world")), Some(String::from("3e25960a79dbc69b674cd4ec67a72c62")));
assert_eq!(candidate(String::from("")), None);
assert_eq!(candidate(String::from("A B C")), Some(String::from("0ef78513b0cb8cef12743f5aeb35f888")));
... | /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py | rs |
[
"\n}"
] | /// 正の整数aとbが与えられたとき、aとbの間にある偶数の数字を昇順で返してください。
/// 例えば:
/// >>> generate_integers(2, 8)
/// vec![2, 4, 6, 8]
/// >>> generate_integers(8, 2)
/// vec![2, 4, 6, 8]
/// >>> generate_integers(10, 14)
/// Vec::<isize>::new()
fn generate_integers(a: isize, b: isize) -> Vec<isize> {
| reworded | transform | HumanEval_163_generate_integers | }
fn main() {
let candidate = generate_integers;
assert_eq!(candidate(2, 10), vec![2, 4, 6, 8]);
assert_eq!(candidate(10, 2), vec![2, 4, 6, 8]);
assert_eq!(candidate(132, 2), vec![2, 4, 6, 8]);
assert_eq!(candidate(17, 89), Vec::<isize>::new());
}
| /work/arjunguha-research-group/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | rs |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.