name stringlengths 15 44 | language stringclasses 1
value | prompt stringlengths 311 1.97k | doctests stringclasses 1
value | original stringlengths 108 137 | prompt_terminology stringclasses 1
value | tests stringlengths 300 2.15k | stop_tokens listlengths 1 1 |
|---|---|---|---|---|---|---|---|
HumanEval_105_by_length | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function By_Length (Arr : Integer_Array) return Unbounded_String_Array;
--... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py | reworded |
end By_Length;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array) return Unbounded_String_Array renames Placeholder.By_Length;
begin
pragma Assert (Candidate ([2, 1, 1, 4, ... | [
"\n end "
] |
HumanEval_106_f | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function F (N : Integer) return Integer_Array;
-- Implement the function f that takes n as a parameter,
-- and returns a Vector of size n, such that the value of the element at index i is the factorial of i ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py | reworded |
end F;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Integer_Array renames Placeholder.F;
begin
pragma Assert (Candidate (5) = [1, 2, 6, 24, 15]);
pragma Assert (Candidate (7) = [1, 2, 6, 24, 15, 720, 28]);
pragma Ass... | [
"\n end "
] |
HumanEval_107_even_odd_palindrome | adb | pragma Ada_2022;
package Placeholder is
type Integer_Integer_Tuple is record
Integer_1 : Integer;
Integer_2 : Integer;
end record;
function Even_Odd_Palindrome (N : Integer) return Integer_Integer_Tuple;
-- Given a positive integer n, return a record that has the number of even and odd
-- i... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py | reworded |
end Even_Odd_Palindrome;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Integer_Integer_Tuple renames Placeholder.Even_Odd_Palindrome;
begin
pragma Assert (Candidate (123) = (8, 13));
pragma Assert (Candidate (12) = (4, 6... | [
"\n end "
] |
HumanEval_108_count_nums | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Count_Nums (Arr : Integer_Array) return Integer;
-- Write a function count_nums which takes an array of integers and returns
-- the number of elements which has a sum of digits > 0.
-- If a numbe... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py | reworded |
end Count_Nums;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array) return Integer renames Placeholder.Count_Nums;
begin
pragma Assert (Candidate ([]) = 0);
pragma Assert (Candidate ([-1, -2, 0]) = 0);
pragma Assert (Candi... | [
"\n end "
] |
HumanEval_109_move_one_ball | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Move_One_Ball (Arr : Integer_Array) return Boolean;
-- We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
-- numbers in the array will be randomly ordered. Your task is to determin... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py | reworded |
end Move_One_Ball;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array) return Boolean renames Placeholder.Move_One_Ball;
begin
pragma Assert (Candidate ([3, 4, 5, 1, 2]) = True);
pragma Assert (Candidate ([3, 5, 10, 1, 2]) = ... | [
"\n end "
] |
HumanEval_110_exchange | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Exchange (Lst1 : Integer_Array; Lst2 : Integer_Array) return String;
-- In this problem, you will implement a function that takes two Vectors of numbers,
-- and determines whether it is possible to ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | reworded |
end Exchange;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst1 : Integer_Array; Lst2 : Integer_Array) return String renames Placeholder.Exchange;
begin
pragma Assert (Candidate ([1, 2, 3, 4], [1, 2, 3, 4]) = "YES");
pragma Assert (Candida... | [
"\n end "
] |
HumanEval_111_histogram | adb | pragma Ada_2022;
with Ada.Containers.Indefinite_Ordered_Maps;
package Placeholder is
package String_Integer_Dict is new Ada.Containers.Indefinite_Ordered_Maps (Key_Type => String, Element_Type => Integer);
use String_Integer_Dict;
function Histogram (Test : String) return String_Integer_Dict.Map;
-- Given ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | reworded |
end Histogram;
end Placeholder;
pragma Ada_2022;
with Ada.Containers.Indefinite_Ordered_Maps;
with Placeholder; use Placeholder;
procedure Main is
use String_Integer_Dict;
function Candidate (Test : String) return String_Integer_Dict.Map renames Placeholder.Histogram;
begin
pragma Assert (Candidate (... | [
"\n end "
] |
HumanEval_112_reverse_delete | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Boolean_Tuple is record
Unbounded_String_1 : Unbounded_String;
Boolean_2 : Boolean;
end record;
function Reverse_Delete (S : String; C : String) return Unbounded_String_Boolean_Tup... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | reworded |
end Reverse_Delete;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (S : String; C : String) return Unbounded_String_Boolean_Tuple renames Placeholder.Reverse_Delete;
begin
pragma Assert (Can... | [
"\n end "
] |
HumanEval_113_odd_count | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function Odd_Count (Lst : Unbounded_String_Array) return Unbounded_String_Array;
-- Given a Vector of strings, where each string consists... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | reworded |
end Odd_Count;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Unbounded_String_Array) return Unbounded_String_Array renames Placeholder.Odd_Count;
begin
pragma Assert (Candidate ([To_... | [
"\n end "
] |
HumanEval_114_minSubArraySum | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Min_Sub_Array_Sum (Nums : Integer_Array) return Integer;
-- Given an array of integers nums, find the minimum sum of any non-empty sub-array
-- of nums.
-- Example
-- >>> Minsubarraysum ([2, 3... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | reworded |
end Min_Sub_Array_Sum;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Nums : Integer_Array) return Integer renames Placeholder.Min_Sub_Array_Sum;
begin
pragma Assert (Candidate ([2, 3, 4, 1, 2, 4]) = 1);
pragma Assert (Candidate ([-1, -2, -3... | [
"\n end "
] |
HumanEval_115_max_fill | adb | pragma Ada_2022;
with Ada.Containers.Vectors;
package Placeholder is
package Integer_Vector is new Ada.Containers.Vectors (Index_Type => Positive, Element_Type => Integer);
use Integer_Vector;
type Integer_Vector_Vector_Array is array (Positive range <>) of Integer_Vector.Vector;
function Max_Fill (Grid : ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | reworded |
end Max_Fill;
end Placeholder;
pragma Ada_2022;
with Ada.Containers.Vectors;
with Placeholder; use Placeholder;
procedure Main is
use Integer_Vector;
function Candidate (Grid : Integer_Vector_Vector_Array; Capacity : Integer) return Integer renames Placeholder.Max_Fill;
begin
pragma Assert (Candidate... | [
"\n end "
] |
HumanEval_116_sort_array | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Sort_Array (Arr : Integer_Array) return Integer_Array;
-- In this Kata, you have to sort an array of non-negative integers according to
-- number of ones in their binary representation in ascending ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py | reworded |
end Sort_Array;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array) return Integer_Array renames Placeholder.Sort_Array;
begin
pragma Assert (Candidate ([1, 5, 2, 3, 4]) = [1, 2, 4, 3, 5]);
pragma Assert (Candidate ([-2, -3, ... | [
"\n end "
] |
HumanEval_117_select_words | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function Select_Words (S : String; N : Integer) return Unbounded_String_Array;
-- Given a string s and a natural number n, you have been ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | reworded |
end Select_Words;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (S : String; N : Integer) return Unbounded_String_Array renames Placeholder.Select_Words;
begin
pragma Assert (Candidate ("Ma... | [
"\n end "
] |
HumanEval_118_get_closest_vowel | adb | pragma Ada_2022;
package Placeholder is
function Get_Closest_Vowel (Word : String) return String;
-- You are given a word. Your task is to find the closest vowel that stands between
-- two consonants from the right side of the word (case sensitive).
-- Vowels in the beginning and ending doesn't count. Ret... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | reworded |
end Get_Closest_Vowel;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Word : String) return String renames Placeholder.Get_Closest_Vowel;
begin
pragma Assert (Candidate ("yogurt") = "u");
pragma Assert (Candidate ("full") = "u");
pragma A... | [
"\n end "
] |
HumanEval_119_match_parens | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function Match_Parens (Lst : Unbounded_String_Array) return String;
-- You are given a Vector of two strings, both strings consist of ope... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | reworded |
end Match_Parens;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Unbounded_String_Array) return String renames Placeholder.Match_Parens;
begin
pragma Assert (Candidate ([To_Unbounded_... | [
"\n end "
] |
HumanEval_120_maximum | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Maximum (Arr : Integer_Array; K : Integer) return Integer_Array;
-- Given an array arr of integers and a positive integer k, return a sorted Vector
-- of length k with the maximum k numbers in arr.... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | reworded |
end Maximum;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array; K : Integer) return Integer_Array renames Placeholder.Maximum;
begin
pragma Assert (Candidate ([-3, -4, 5], 3) = [-4, -3, 5]);
pragma Assert (Candidate ([4, -4,... | [
"\n end "
] |
HumanEval_121_solution | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Solution (Lst : Integer_Array) return Integer;
-- Given a non-empty Vector of integers, return the sum of all of the odd elements that are in even positions.
-- Examples
-- >>> Solution ([5, 8, 7... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | reworded |
end Solution;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Integer_Array) return Integer renames Placeholder.Solution;
begin
pragma Assert (Candidate ([5, 8, 7, 1]) = 12);
pragma Assert (Candidate ([3, 3, 3, 3, 3]) = 9);
pragma As... | [
"\n end "
] |
HumanEval_122_add_elements | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Add_Elements (Arr : Integer_Array; K : Integer) return Integer;
-- Given a non-empty array of integers arr and an integer k, return
-- the sum of the elements with at most two digits from the first ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | reworded |
end Add_Elements;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array; K : Integer) return Integer renames Placeholder.Add_Elements;
begin
pragma Assert (Candidate ([1, -2, -3, 41, 57, 76, 87, 88, 99], 3) = -4);
pragma Assert ... | [
"\n end "
] |
HumanEval_123_get_odd_collatz | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Get_Odd_Collatz (N : Integer) return Integer_Array;
-- Given a positive integer n, return a sorted Vector that has the odd numbers in collatz sequence.
-- The Collatz conjecture is a conjecture in m... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | reworded |
end Get_Odd_Collatz;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Integer_Array renames Placeholder.Get_Odd_Collatz;
begin
pragma Assert (Candidate (14) = [1, 5, 7, 11, 13, 17]);
pragma Assert (Candidate (5) = [1, 5]);
... | [
"\n end "
] |
HumanEval_124_valid_date | adb | pragma Ada_2022;
package Placeholder is
function Valid_Date (Date : String) return Boolean;
-- You have to write a function which validates a given date string and
-- returns True if the date is valid otherwise False.
-- The date is valid if all of the following rules are satisfied:
-- 1. The date strin... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | reworded |
end Valid_Date;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Date : String) return Boolean renames Placeholder.Valid_Date;
begin
pragma Assert (Candidate ("03-11-2000") = True);
pragma Assert (Candidate ("15-01-2012") = False);
pragma A... | [
"\n end "
] |
HumanEval_126_is_sorted | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Is_Sorted (Lst : Integer_Array) return Boolean;
-- Given a Vector of numbers, return whether or not they are sorted
-- in ascending order. If Vector has more than 1 duplicate of the same
-- numbe... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | reworded |
end Is_Sorted;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Integer_Array) return Boolean renames Placeholder.Is_Sorted;
begin
pragma Assert (Candidate ([5]) = True);
pragma Assert (Candidate ([1, 2, 3, 4, 5]) = True);
pragma Asse... | [
"\n end "
] |
HumanEval_127_intersection | adb | pragma Ada_2022;
package Placeholder is
type Integer_Integer_Tuple is record
Integer_1 : Integer;
Integer_2 : Integer;
end record;
function Intersection (Interval1 : Integer_Integer_Tuple; Interval2 : Integer_Integer_Tuple) return String;
-- You are given two intervals,
-- where each interv... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | reworded |
end Intersection;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Interval1 : Integer_Integer_Tuple; Interval2 : Integer_Integer_Tuple) return String renames Placeholder.Intersection;
begin
pragma Assert (Candidate ((1, 2), (2, 3)) = "NO");
p... | [
"\n end "
] |
HumanEval_128_prod_signs | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
type Integer_Option (Valid : Boolean := False) is record
case Valid is
when True =>
Value : Integer;
when False =>
null;
end case;
end record;
function Prod_Signs (Arr : Inte... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py | reworded |
end Prod_Signs;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array) return Integer_Option renames Placeholder.Prod_Signs;
begin
pragma Assert (Candidate ([1, 2, 2, -4]) = (Valid => True, Value => -9));
pragma Assert (Candidat... | [
"\n end "
] |
HumanEval_129_minPath | adb | pragma Ada_2022;
with Ada.Containers.Vectors;
package Placeholder is
package Integer_Vector is new Ada.Containers.Vectors (Index_Type => Positive, Element_Type => Integer);
use Integer_Vector;
type Integer_Vector_Vector_Array is array (Positive range <>) of Integer_Vector.Vector;
type Integer_Array is arra... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | reworded |
end Min_Path;
end Placeholder;
pragma Ada_2022;
with Ada.Containers.Vectors;
with Placeholder; use Placeholder;
procedure Main is
use Integer_Vector;
function Candidate (Grid : Integer_Vector_Vector_Array; K : Integer) return Integer_Array renames Placeholder.Min_Path;
begin
pragma Assert (Candidate ... | [
"\n end "
] |
HumanEval_130_tri | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Tri (N : Integer) return Integer_Array;
-- Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
-- the last couple centuries. However, what people don't know is Tribonacci ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | reworded |
end Tri;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Integer_Array renames Placeholder.Tri;
begin
pragma Assert (Candidate (3) = [1, 3, 2, 8]);
pragma Assert (Candidate (4) = [1, 3, 2, 8, 3]);
pragma Assert (Candida... | [
"\n end "
] |
HumanEval_131_digits | adb | pragma Ada_2022;
package Placeholder is
function Digits (N : Integer) return Integer;
-- Given a positive integer n, return the product of the odd digits.
-- Return 0 if all digits are even.
-- For example:
-- >>> My_Digits (1)
-- 1
-- >>> My_Digits (4)
-- 0
-- >>> My_Digits (235)
-- 15
... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | reworded |
end Digits;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Integer renames Placeholder.Digits;
begin
pragma Assert (Candidate (5) = 5);
pragma Assert (Candidate (54) = 5);
pragma Assert (Candidate (120) = 1);
pragma... | [
"\n end "
] |
HumanEval_132_is_nested | adb | pragma Ada_2022;
package Placeholder is
function Is_Nested (My_String : String) return Boolean;
-- Create a function that takes a string as input which contains only square brackets.
-- The function should return True if and only if there is a valid subsequence of brackets
-- where at least one bracket in... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | reworded |
end Is_Nested;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (My_String : String) return Boolean renames Placeholder.Is_Nested;
begin
pragma Assert (Candidate ("[[]]") = True);
pragma Assert (Candidate ("[]]]]]]][[[[[]") = False);
pragma ... | [
"\n end "
] |
HumanEval_133_sum_squares | adb | pragma Ada_2022;
package Placeholder is
type Float_Array is array (Positive range <>) of Float;
function Sum_Squares (Lst : Float_Array) return Integer;
-- You are given a Vector of numbers.
-- You need to return the sum of squared numbers in the given Vector,
-- round each element in the Vector to the ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | reworded |
end Sum_Squares;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Float_Array) return Integer renames Placeholder.Sum_Squares;
begin
pragma Assert (Candidate ([1.0, 2.0, 3.0]) = 14);
pragma Assert (Candidate ([1.0, 2.0, 3.0]) = 14);
p... | [
"\n end "
] |
HumanEval_134_check_if_last_char_is_a_letter | adb | pragma Ada_2022;
package Placeholder is
function Check_If_Last_Char_Is_A_Letter (Txt : String) return Boolean;
-- Create a function that returns True if the last character
-- of a given string is an alphabetical character and is not
-- a part of a word, and False otherwise.
-- Note: "word" is a group of... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | reworded |
end Check_If_Last_Char_Is_A_Letter;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Txt : String) return Boolean renames Placeholder.Check_If_Last_Char_Is_A_Letter;
begin
pragma Assert (Candidate ("apple") = False);
pragma Assert (Candidate (... | [
"\n end "
] |
HumanEval_135_can_arrange | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Can_Arrange (Arr : Integer_Array) return Integer;
-- Create a function which returns the largest index of an element which
-- is not greater than or equal to the element immediately preceding it. If... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | reworded |
end Can_Arrange;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Arr : Integer_Array) return Integer renames Placeholder.Can_Arrange;
begin
pragma Assert (Candidate ([1, 2, 4, 3, 5]) = 3);
pragma Assert (Candidate ([1, 2, 4, 5]) = -1);
pra... | [
"\n end "
] |
HumanEval_136_largest_smallest_integers | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
type Integer_Option (Valid : Boolean := False) is record
case Valid is
when True =>
Value : Integer;
when False =>
null;
end case;
end record;
type Integer_Option_Integer_Opt... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | reworded |
end Largest_Smallest_Integers;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Integer_Array) return Integer_Option_Integer_Option_Tuple renames Placeholder.Largest_Smallest_Integers;
begin
pragma Assert (Candidate ([2, 4, 1, 3, 5, 7]) = (... | [
"\n end "
] |
HumanEval_138_is_equal_to_sum_even | adb | pragma Ada_2022;
package Placeholder is
function Is_Equal_To_Sum_Even (N : Integer) return Boolean;
-- Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
-- Example
-- >>> Is_Equal_To_Sum_Even (4)
-- False
-- >>> Is_Equal_To_Sum_Even (6)
-- False
--... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | reworded |
end Is_Equal_To_Sum_Even;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Boolean renames Placeholder.Is_Equal_To_Sum_Even;
begin
pragma Assert (Candidate (4) = False);
pragma Assert (Candidate (6) = False);
pragma Asse... | [
"\n end "
] |
HumanEval_139_special_factorial | adb | pragma Ada_2022;
package Placeholder is
function Special_Factorial (N : Integer) return Integer;
-- The Brazilian factorial is defined as:
-- brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
-- where n > 0
-- For example:
-- >>> Special_Factorial (4)
-- 288
-- The function will receive ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | reworded |
end Special_Factorial;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Integer renames Placeholder.Special_Factorial;
begin
pragma Assert (Candidate (4) = 288);
pragma Assert (Candidate (5) = 34560);
pragma Assert (Cand... | [
"\n end "
] |
HumanEval_140_fix_spaces | adb | pragma Ada_2022;
package Placeholder is
function Fix_Spaces (Text : String) return String;
-- Given a string text, replace all spaces in it with underscores,
-- and if a string has more than 2 consecutive spaces,
-- then replace all consecutive spaces with -
-- >>> Fix_Spaces (" Example")
-- "Exam... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | reworded |
end Fix_Spaces;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Text : String) return String renames Placeholder.Fix_Spaces;
begin
pragma Assert (Candidate ("Example") = "Example");
pragma Assert (Candidate ("Mudasir Hanif ") = "Mudasir_Hanif... | [
"\n end "
] |
HumanEval_141_file_name_check | adb | pragma Ada_2022;
package Placeholder is
function File_Name_Check (File_Name : String) return String;
-- Create a function which takes a string representing a file's name, and returns
-- 'Yes' if the the file's name is valid, and returns 'No' otherwise.
-- A file's name is considered to be valid if and only... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | reworded |
end File_Name_Check;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (File_Name : String) return String renames Placeholder.File_Name_Check;
begin
pragma Assert (Candidate ("example.txt") = "Yes");
pragma Assert (Candidate ("1example.dll") = "... | [
"\n end "
] |
HumanEval_142_sum_squares | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Sum_Squares (Lst : Integer_Array) return Integer;
-- "
-- This function will take a Vector of integers. For all entries in the Vector, the function shall square the integer entry if its index is a
... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | reworded |
end Sum_Squares;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Integer_Array) return Integer renames Placeholder.Sum_Squares;
begin
pragma Assert (Candidate ([1, 2, 3]) = 6);
pragma Assert (Candidate ([1, 4, 9]) = 14);
pragma Asser... | [
"\n end "
] |
HumanEval_143_words_in_sentence | adb | pragma Ada_2022;
package Placeholder is
function Words_In_Sentence (Sentence : String) return String;
-- You are given a string representing a sentence,
-- the sentence contains some words separated by a space,
-- and you have to return a string that contains the words from the original sentence,
-- who... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | reworded |
end Words_In_Sentence;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Sentence : String) return String renames Placeholder.Words_In_Sentence;
begin
pragma Assert (Candidate ("This is a test") = "is");
pragma Assert (Candidate ("lets go for s... | [
"\n end "
] |
HumanEval_144_simplify | adb | pragma Ada_2022;
package Placeholder is
function Simplify (X : String; N : String) return Boolean;
-- Your task is to implement a function that will simplify the expression
-- x * n. The function returns True if x * n evaluates to a whole number and False
-- otherwise. Both x and n, are string representati... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | reworded |
end Simplify;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (X : String; N : String) return Boolean renames Placeholder.Simplify;
begin
pragma Assert (Candidate ("1/5", "5/1") = True);
pragma Assert (Candidate ("1/6", "2/1") = False);
pra... | [
"\n end "
] |
HumanEval_145_order_by_points | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Order_By_Points (Nums : Integer_Array) return Integer_Array;
-- Write a function which sorts the given Vector of integers
-- in ascending order according to the sum of their digits.
-- Note: if t... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | reworded |
end Order_By_Points;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Nums : Integer_Array) return Integer_Array renames Placeholder.Order_By_Points;
begin
pragma Assert (Candidate ([1, 11, -1, -11, -12]) = [-1, -11, 1, -12, 11]);
pragma Asser... | [
"\n end "
] |
HumanEval_146_specialFilter | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Special_Filter (Nums : Integer_Array) return Integer;
-- Write a function that takes an array of numbers as input and returns
-- the number of elements in the array that are greater than 10 and bot... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | reworded |
end Special_Filter;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Nums : Integer_Array) return Integer renames Placeholder.Special_Filter;
begin
pragma Assert (Candidate ([5, -2, 1, -5]) = 0);
pragma Assert (Candidate ([15, -73, 14, -15]) =... | [
"\n end "
] |
HumanEval_147_get_max_triples | adb | pragma Ada_2022;
package Placeholder is
function Get_Max_Triples (N : Integer) return Integer;
-- You are given a positive integer n. You have to create an integer array a of length n.
-- For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-- Return the number of triples (a[i], a[j], a[k]) of a wher... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | reworded |
end Get_Max_Triples;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer) return Integer renames Placeholder.Get_Max_Triples;
begin
pragma Assert (Candidate (5) = 1);
pragma Assert (Candidate (6) = 4);
pragma Assert (Candidate (10)... | [
"\n end "
] |
HumanEval_148_bf | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function Bf (Planet1 : String; Planet2 : String) return Unbounded_String_Array;
-- There are eight planets in our solar system: the close... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py | reworded |
end Bf;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Planet1 : String; Planet2 : String) return Unbounded_String_Array renames Placeholder.Bf;
begin
pragma Assert (Candidate ("Jupiter", "... | [
"\n end "
] |
HumanEval_149_sorted_list_sum | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function Sorted_List_Sum (Lst : Unbounded_String_Array) return Unbounded_String_Array;
-- Write a function that accepts a Vector of strin... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | reworded |
end Sorted_List_Sum;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Unbounded_String_Array) return Unbounded_String_Array renames Placeholder.Sorted_List_Sum;
begin
pragma Assert (Can... | [
"\n end "
] |
HumanEval_150_x_or_y | adb | pragma Ada_2022;
package Placeholder is
function X_Or_Y (N : Integer; X : Integer; Y : Integer) return Integer;
-- A simple program which should return the value of x if n is
-- a prime number and should return the value of y otherwise.
-- Examples:
-- >>> X_Or_Y (7, 34, 12)
-- 34
-- >>> X_Or_Y (... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | reworded |
end X_Or_Y;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (N : Integer; X : Integer; Y : Integer) return Integer renames Placeholder.X_Or_Y;
begin
pragma Assert (Candidate (7, 34, 12) = 34);
pragma Assert (Candidate (15, 8, 5) = 5);
pragm... | [
"\n end "
] |
HumanEval_151_double_the_difference | adb | pragma Ada_2022;
package Placeholder is
type Float_Array is array (Positive range <>) of Float;
function Double_The_Difference (Lst : Float_Array) return Integer;
-- Given a Vector of numbers, return the sum of squares of the numbers
-- in the Vector that are odd. Ignore numbers that are negative or not in... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | reworded |
end Double_The_Difference;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Lst : Float_Array) return Integer renames Placeholder.Double_The_Difference;
begin
pragma Assert (Candidate ([]) = 0);
pragma Assert (Candidate ([5.0, 4.0]) = 25);
... | [
"\n end "
] |
HumanEval_152_compare | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Compare (Game : Integer_Array; Guess : Integer_Array) return Integer_Array;
-- I think we all remember that feeling when the result of some long-awaited
-- event is finally known. The feelings and t... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | reworded |
end Compare;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Game : Integer_Array; Guess : Integer_Array) return Integer_Array renames Placeholder.Compare;
begin
pragma Assert (Candidate ([1, 2, 3, 4, 5, 1], [1, 2, 3, 4, 2, -2]) = [0, 0, 0, 0, 3... | [
"\n end "
] |
HumanEval_153_Strongest_Extension | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function Strongest_Extension (Class_Name : String; Extensions : Unbounded_String_Array) return String;
-- You will be given the name of a... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | reworded |
end Strongest_Extension;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Class_Name : String; Extensions : Unbounded_String_Array) return String renames Placeholder.Strongest_Extension;
begin
... | [
"\n end "
] |
HumanEval_154_cycpattern_check | adb | pragma Ada_2022;
package Placeholder is
function Cycpattern_Check (A : String; B : String) return Boolean;
-- You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
-- >>> Cycpattern_Check ("abcd", "abd")
-- False
-- >>> Cycpattern_Chec... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | reworded |
end Cycpattern_Check;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (A : String; B : String) return Boolean renames Placeholder.Cycpattern_Check;
begin
pragma Assert (Candidate ("xyzw", "xyw") = False);
pragma Assert (Candidate ("yello", "el... | [
"\n end "
] |
HumanEval_155_even_odd_count | adb | pragma Ada_2022;
package Placeholder is
type Integer_Integer_Tuple is record
Integer_1 : Integer;
Integer_2 : Integer;
end record;
function Even_Odd_Count (Num : Integer) return Integer_Integer_Tuple;
-- Given an integer. return a record that has the number of even and odd digits respectively.... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | reworded |
end Even_Odd_Count;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Num : Integer) return Integer_Integer_Tuple renames Placeholder.Even_Odd_Count;
begin
pragma Assert (Candidate (7) = (0, 1));
pragma Assert (Candidate (-78) = (1, 1));
pra... | [
"\n end "
] |
HumanEval_156_int_to_mini_roman | adb | pragma Ada_2022;
package Placeholder is
function Int_To_Mini_Roman (Number : Integer) return String;
-- Given a positive integer, obtain its roman numeral equivalent as a string,
-- and return it in lowercase.
-- Restrictions: 1 <= num <= 1000
-- Examples:
-- >>> Int_To_Mini_Roman (19)
-- "xix"
... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | reworded |
end Int_To_Mini_Roman;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Number : Integer) return String renames Placeholder.Int_To_Mini_Roman;
begin
pragma Assert (Candidate (19) = "xix");
pragma Assert (Candidate (152) = "clii");
pragma As... | [
"\n end "
] |
HumanEval_157_right_angle_triangle | adb | pragma Ada_2022;
package Placeholder is
function Right_Angle_Triangle (A : Integer; B : Integer; C : Integer) return Boolean;
-- Given the lengths of the three sides of a triangle. Return True if the three
-- sides form a right-angled triangle, False otherwise.
-- A right-angled triangle is a triangle in w... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | reworded |
end Right_Angle_Triangle;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (A : Integer; B : Integer; C : Integer) return Boolean renames Placeholder.Right_Angle_Triangle;
begin
pragma Assert (Candidate (3, 4, 5) = True);
pragma Assert (Candida... | [
"\n end "
] |
HumanEval_158_find_max | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
function Find_Max (Words : Unbounded_String_Array) return String;
-- Write a function that accepts a Vector of strings.
-- The Vector ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | reworded |
end Find_Max;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Words : Unbounded_String_Array) return String renames Placeholder.Find_Max;
begin
pragma Assert (Candidate ([To_Unbounded_String... | [
"\n end "
] |
HumanEval_159_eat | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Eat (Number : Integer; Need : Integer; Remaining : Integer) return Integer_Array;
-- You're a hungry rabbit, and you already have eaten a certain number of carrots,
-- but now you need to eat more c... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | reworded |
end Eat;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Number : Integer; Need : Integer; Remaining : Integer) return Integer_Array renames Placeholder.Eat;
begin
pragma Assert (Candidate (5, 6, 10) = [11, 4]);
pragma Assert (Candidate (4, 8... | [
"\n end "
] |
HumanEval_160_do_algebra | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Array is array (Positive range <>) of Unbounded_String;
type Integer_Array is array (Positive range <>) of Integer;
function Do_Algebra (Operator : Unbounded_String_Array; Operand : Integer_Arr... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | reworded |
end Do_Algebra;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Operator : Unbounded_String_Array; Operand : Integer_Array) return Integer renames Placeholder.Do_Algebra;
begin
pragma Assert... | [
"\n end "
] |
HumanEval_161_solve | adb | pragma Ada_2022;
package Placeholder is
function Solve (S : String) return String;
-- You are given a string s.
-- if s[i] is a letter, reverse its case from lower to upper or vise versa,
-- otherwise keep it as it is.
-- If the string contains no letters, reverse the string.
-- The function should ... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | reworded |
end Solve;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (S : String) return String renames Placeholder.Solve;
begin
pragma Assert (Candidate ("AsDf") = "aSdF");
pragma Assert (Candidate ("1234") = "4321");
pragma Assert (Candidate ("ab")... | [
"\n end "
] |
HumanEval_162_string_to_md5 | adb | pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Placeholder is
type Unbounded_String_Option (Valid : Boolean := False) is record
case Valid is
when True =>
Value : Unbounded_String;
when False =>
null;
end case;
end record;
function String_To_Md... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py | reworded |
end String_To_Md5;
end Placeholder;
pragma Ada_2022;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (Text : String) return Unbounded_String_Option renames Placeholder.String_To_Md5;
begin
pragma Assert (Candidate ("Hello wor... | [
"\n end "
] |
HumanEval_163_generate_integers | adb | pragma Ada_2022;
package Placeholder is
type Integer_Array is array (Positive range <>) of Integer;
function Generate_Integers (A : Integer; B : Integer) return Integer_Array;
-- Given two positive integers a and b, return the even digits between a
-- and b, in ascending order.
-- For example:
-- >>>... | transform | /mnt/ssd/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | reworded |
end Generate_Integers;
end Placeholder;
pragma Ada_2022;
with Placeholder; use Placeholder;
procedure Main is
function Candidate (A : Integer; B : Integer) return Integer_Array renames Placeholder.Generate_Integers;
begin
pragma Assert (Candidate (2, 10) = [2, 4, 6, 8]);
pragma Assert (Candidate (10,... | [
"\n end "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.