wegho-agentes 7.0.3 → 7.0.6

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/0.py

@@ -1,16 +0,0 @@
-from typing import List
-
-
-def has_close_elements(numbers: List[float], threshold: float) -> bool:
-    """ Check if in given list of numbers, are any two numbers closer to each other than
-    given threshold.
-    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
-    False
-    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
-    True
-    """
-    for i in range(len(numbers)):
-        for j in range(i + 1, len(numbers)):
-            if abs(numbers[i] - numbers[j]) < threshold:
-                return True
-    return False

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/1.py

@@ -1,28 +0,0 @@
-from typing import List
-
-
-def separate_paren_groups(paren_string: str) -> List[str]:
-    """ Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
-    separate those group into separate strings and return the list of those.
-    Separate groups are balanced (each open brace is properly closed) and not nested within each other
-    Ignore any spaces in the input string.
-    >>> separate_paren_groups('( ) (( )) (( )( ))')
-    ['()', '(())', '(()())']
-    """
-    paren_string = paren_string.replace(' ', '')
-    result = []
-    current_group = ''
-    depth = 0
-    
-    for char in paren_string:
-        if char == '(':
-            depth += 1
-            current_group += char
-        elif char == ')':
-            depth -= 1
-            current_group += char
-            if depth == 0:
-                result.append(current_group)
-                current_group = ''
-    
-    return result

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/10.py

@@ -1,25 +0,0 @@
-def is_palindrome(string: str) -> bool:
-    """ Test if given string is a palindrome """
-    return string == string[::-1]
-
-
-def make_palindrome(string: str) -> str:
-    """ Find the shortest palindrome that begins with a supplied string.
-    Algorithm idea is simple:
-    - Find the longest postfix of supplied string that is a palindrome.
-    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
-    >>> make_palindrome('')
-    ''
-    >>> make_palindrome('cat')
-    'catac'
-    >>> make_palindrome('cata')
-    'catac'
-    """
-    if not string:
-        return ''
-    
-    for i in range(len(string)):
-        if is_palindrome(string[i:]):
-            return string + string[:i][::-1]
-    
-    return string

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/100.py

@@ -1,20 +0,0 @@
-def make_a_pile(n):
-    """
-    Given a positive integer n, you have to make a pile of n levels of stones.
-    The first level has n stones.
-    The number of stones in the next level is:
-        - the next odd number if n is odd.
-        - the next even number if n is even.
-    Return the number of stones in each level in a list, where element at index
-    i represents the number of stones in the level (i+1).
-
-    Examples:
-    >>> make_a_pile(3)
-    [3, 5, 7]
-    """
-    result = []
-    current = n
-    for _ in range(n):
-        result.append(current)
-        current += 2
-    return result

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/101.py

@@ -1,15 +0,0 @@
-def words_string(s):
-    """
-    You will be given a string of words separated by commas or spaces. Your task is
-    to split the string into words and return an array of the words.
-    
-    For example:
-    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
-    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
-    """
-    if not s:
-        return []
-    
-    # Replace commas with spaces, then split on whitespace
-    s = s.replace(',', ' ')
-    return s.split()

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/102.py

@@ -1,16 +0,0 @@
-def choose_num(x, y):
-    """This function takes two positive numbers x and y and returns the
-    biggest even integer number that is in the range [x, y] inclusive. If 
-    there's no such number, then the function should return -1.
-
-    For example:
-    choose_num(12, 15) = 14
-    choose_num(13, 12) = -1
-    """
-    if x > y:
-        return -1
-    if y % 2 == 0:
-        return y
-    if y - 1 >= x:
-        return y - 1
-    return -1

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/103.py

@@ -1,15 +0,0 @@
-def rounded_avg(n, m):
-    """You are given two positive integers n and m, and your task is to compute the
-    average of the integers from n through m (including n and m). 
-    Round the answer to the nearest integer and convert that to binary.
-    If n is greater than m, return -1.
-    Example:
-    rounded_avg(1, 5) => "0b11"
-    rounded_avg(7, 5) => -1
-    rounded_avg(10, 20) => "0b1111"
-    rounded_avg(20, 33) => "0b11010"
-    """
-    if n > m:
-        return -1
-    avg = round((n + m) / 2)
-    return bin(avg)

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/104.py

@@ -1,22 +0,0 @@
-def unique_digits(x):
-    """Given a list of positive integers x. return a sorted list of all 
-    elements that hasn't any even digit.
-
-    Note: Returned list should be sorted in increasing order.
-    
-    For example:
-    >>> unique_digits([15, 33, 1422, 1])
-    [1, 15, 33]
-    >>> unique_digits([152, 323, 1422, 10])
-    []
-    """
-    def has_even_digit(n):
-        while n > 0:
-            digit = n % 10
-            if digit % 2 == 0:
-                return True
-            n //= 10
-        return False
-    
-    result = [num for num in x if not has_even_digit(num)]
-    return sorted(result)

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/105.py

@@ -1,39 +0,0 @@
-def by_length(arr):
-    """
-    Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-    reverse the resulting array, and then replace each digit by its corresponding name from
-    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
-
-    For example:
-      arr = [2, 1, 1, 4, 5, 8, 2, 3]   
-            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] 
-            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
-      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
-    
-      If the array is empty, return an empty array:
-      arr = []
-      return []
-    
-      If the array has any strange number ignore it:
-      arr = [1, -1 , 55] 
-            -> sort arr -> [-1, 1, 55]
-            -> reverse arr -> [55, 1, -1]
-      return = ['One']
-    """
-    names = {
-        1: "One",
-        2: "Two",
-        3: "Three",
-        4: "Four",
-        5: "Five",
-        6: "Six",
-        7: "Seven",
-        8: "Eight",
-        9: "Nine"
-    }
-    
-    filtered = [x for x in arr if 1 <= x <= 9]
-    filtered.sort()
-    filtered.reverse()
-    
-    return [names[x] for x in filtered]

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/106.py

@@ -1,21 +0,0 @@
-def f(n):
-    """ Implement the function f that takes n as a parameter,
-    and returns a list of size n, such that the value of the element at index i is the factorial of i if i is even
-    or the sum of numbers from 1 to i otherwise.
-    i starts from 1.
-    the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
-    Example:
-    f(5) == [1, 2, 6, 24, 15]
-    """
-    result = []
-    for i in range(1, n + 1):
-        if i % 2 == 0:
-            # factorial of i
-            factorial = 1
-            for j in range(1, i + 1):
-                factorial *= j
-            result.append(factorial)
-        else:
-            # sum of numbers from 1 to i
-            result.append(sum(range(1, i + 1)))
-    return result

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/107.py

@@ -1,35 +0,0 @@
-def even_odd_palindrome(n):
-    """
-    Given a positive integer n, return a tuple that has the number of even and odd
-    integer palindromes that fall within the range(1, n), inclusive.
-
-    Example 1:
-
-        Input: 3
-        Output: (1, 2)
-        Explanation:
-        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-
-    Example 2:
-
-        Input: 12
-        Output: (4, 6)
-        Explanation:
-        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
-
-    Note:
-        1. 1 <= n <= 10^3
-        2. returned tuple has the number of even and odd integer palindromes respectively.
-    """
-    even_count = 0
-    odd_count = 0
-    
-    for i in range(1, n + 1):
-        s = str(i)
-        if s == s[::-1]:
-            if i % 2 == 0:
-                even_count += 1
-            else:
-                odd_count += 1
-    
-    return (even_count, odd_count)

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/108.py

@@ -1,22 +0,0 @@
-def count_nums(arr):
-    """
-    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 number is negative, then its first signed digit will be negative:
-    e.g. -123 has signed digits -1, 2, and 3.
-    >>> count_nums([]) == 0
-    >>> count_nums([-1, 11, -11]) == 1
-    >>> count_nums([1, 1, 2]) == 3
-    """
-    count = 0
-    for num in arr:
-        if num == 0:
-            continue
-        elif num > 0:
-            digit_sum = sum(int(d) for d in str(num))
-        else:
-            s = str(abs(num))
-            digit_sum = -int(s[0]) + sum(int(d) for d in s[1:])
-        if digit_sum > 0:
-            count += 1
-    return count

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/109.py

@@ -1,41 +0,0 @@
-def move_one_ball(arr):
-    """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 determine if
-    it is possible to get an array sorted in non-decreasing order by performing 
-    the following operation on the given array:
-        You are allowed to perform right shift operation any number of times.
-    
-    One right shift operation means shifting all elements of the array by one
-    position in the right direction. The last element of the array will be moved to
-    the starting position in the array i.e. 0th index. 
-
-    If it is possible to obtain the sorted array by performing the above operation
-    then return True else return False.
-    If the given array is empty then return True.
-
-    Note: The given list is guaranteed to have unique elements.
-
-    For Example:
-    
-    move_one_ball([3, 4, 5, 1, 2])==>True
-    Explanation: By performin 2 right shift operations, non-decreasing order can
-                 be achieved for the given array.
-    move_one_ball([3, 5, 4, 1, 2])==>False
-    Explanation:It is not possible to get non-decreasing order for the given
-                array by performing any number of right shift operations.
-                
-    """
-    if len(arr) == 0:
-        return True
-    
-    # Count the number of "breaks" where arr[i] > arr[i+1]
-    # For a rotated sorted array, there should be at most one such break
-    breaks = 0
-    n = len(arr)
-    
-    for i in range(n):
-        if arr[i] > arr[(i + 1) % n]:
-            breaks += 1
-    
-    # If there's at most one break, the array can be sorted by rotation
-    return breaks <= 1

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/11.py

@@ -1,16 +0,0 @@
-from typing import List
-
-
-def string_xor(a: str, b: str) -> str:
-    """ Input are two strings a and b consisting only of 1s and 0s.
-    Perform binary XOR on these inputs and return result also as a string.
-    >>> string_xor('010', '110')
-    '100'
-    """
-    result = []
-    for char_a, char_b in zip(a, b):
-        if char_a == char_b:
-            result.append('0')
-        else:
-            result.append('1')
-    return ''.join(result)

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/110.py

@@ -1,20 +0,0 @@
-def exchange(lst1, lst2):
-    """In this problem, you will implement a function that takes two lists of numbers,
-    and determines whether it is possible to perform an exchange of elements
-    between them to make lst1 a list of only even numbers.
-    There is no limit on the number of exchanged elements between lst1 and lst2.
-    If it is possible to exchange elements between the lst1 and lst2 to make
-    all the elements of lst1 to be even, return "YES".
-    Otherwise, return "NO".
-    For example:
-    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
-    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
-    It is assumed that the input lists will be non-empty.
-    """
-    odd_count_lst1 = sum(1 for x in lst1 if x % 2 != 0)
-    even_count_lst2 = sum(1 for x in lst2 if x % 2 == 0)
-    
-    if even_count_lst2 >= odd_count_lst1:
-        return "YES"
-    else:
-        return "NO"

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/111.py

@@ -1,28 +0,0 @@
-def histogram(test):
-    """Given a string representing a space separated lowercase letters, return a dictionary
-    of the letter with the most repetition and containing the corresponding count.
-    If several letters have the same occurrence, return all of them.
-    
-    Example:
-    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
-    histogram('a b b a') == {'a': 2, 'b': 2}
-    histogram('a b c a b') == {'a': 2, 'b': 2}
-    histogram('b b b b a') == {'b': 4}
-    histogram('') == {}
-
-    """
-    if not test or test.strip() == '':
-        return {}
-    
-    letters = test.split()
-    counts = {}
-    
-    for letter in letters:
-        counts[letter] = counts.get(letter, 0) + 1
-    
-    if not counts:
-        return {}
-    
-    max_count = max(counts.values())
-    
-    return {letter: count for letter, count in counts.items() if count == max_count}

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/112.py

@@ -1,14 +0,0 @@
-def reverse_delete(s,c):
-    """Task
-    We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c
-    then check if the result string is palindrome.
-    A string is called palindrome if it reads the same backward as forward.
-    You should return a tuple containing the result string and True/False for the check.
-    Example
-    For s = "abcde", c = "ae", the result should be ('bcd',False)
-    For s = "abcdef", c = "b"  the result should be ('acdef',False)
-    For s = "abcdedcba", c = "ab", the result should be ('cdedc',True)
-    """
-    result = ''.join(char for char in s if char not in c)
-    is_palindrome = result == result[::-1]
-    return (result, is_palindrome)

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/113.py

@@ -1,19 +0,0 @@
-def odd_count(lst):
-    """Given a list of strings, where each string consists of only digits, return a list.
-    Each element i of the output should be "the number of odd elements in the
-    string i of the input." where all the i's should be replaced by the number
-    of odd digits in the i'th string of the input.
-
-    >>> odd_count(['1234567'])
-    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
-    >>> odd_count(['3',"11111111"])
-    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
-     "the number of odd elements 8n the str8ng 8 of the 8nput."]
-    """
-    result = []
-    for s in lst:
-        count = sum(1 for c in s if c in '13579')
-        template = "the number of odd elements in the string i of the input."
-        replaced = template.replace('i', str(count))
-        result.append(replaced)
-    return result

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/114.py

@@ -1,16 +0,0 @@
-def minSubArraySum(nums):
-    """
-    Given an array of integers nums, find the minimum sum of any non-empty sub-array
-    of nums.
-    Example
-    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
-    minSubArraySum([-1, -2, -3]) == -6
-    """
-    min_sum = nums[0]
-    current_sum = nums[0]
-    
-    for i in range(1, len(nums)):
-        current_sum = min(nums[i], current_sum + nums[i])
-        min_sum = min(min_sum, current_sum)
-    
-    return min_sum

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/115.py

@@ -1,41 +0,0 @@
-def max_fill(grid, capacity):
-    import math
-    """
-    You are given a rectangular grid of wells. Each row represents a single well,
-    and each 1 in a row represents a single unit of water.
-    Each well has a corresponding bucket that can be used to extract water from it, 
-    and all buckets have the same capacity.
-    Your task is to use the buckets to empty the wells.
-    Output the number of times you need to lower the buckets.
-
-    Example 1:
-        Input: 
-            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
-            bucket_capacity : 1
-        Output: 6
-
-    Example 2:
-        Input: 
-            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
-            bucket_capacity : 2
-        Output: 5
-    
-    Example 3:
-        Input: 
-            grid : [[0,0,0], [0,0,0]]
-            bucket_capacity : 5
-        Output: 0
-
-    Constraints:
-        * all wells have the same length
-        * 1 <= grid.length <= 10^2
-        * 1 <= grid[:,1].length <= 10^2
-        * grid[i][j] -> 0 | 1
-        * 1 <= capacity <= 10
-    """
-    total_lowerings = 0
-    for row in grid:
-        water_units = sum(row)
-        if water_units > 0:
-            total_lowerings += math.ceil(water_units / capacity)
-    return total_lowerings

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/116.py

@@ -1,12 +0,0 @@
-def sort_array(arr):
-    """
-    In this Kata, you have to sort an array of non-negative integers according to
-    number of ones in their binary representation in ascending order.
-    For similar number of ones, sort based on decimal value.
-
-    It must be implemented like this:
-    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
-    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
-    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
-    """
-    return sorted(arr, key=lambda x: (bin(x).count('1'), x))

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/117.py

@@ -1,25 +0,0 @@
-def select_words(s, n):
-    """Given a string s and a natural number n, you have been tasked to implement 
-    a function that returns a list of all words from string s that contain exactly 
-    n consonants, in order these words appear in the string s.
-    If the string s is empty then the function should return an empty list.
-    Note: you may assume the input string contains only letters and spaces.
-    Examples:
-    select_words("Mary had a little lamb", 4) ==> ["little"]
-    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
-    select_words("simple white space", 2) ==> []
-    select_words("Hello world", 4) ==> ["world"]
-    select_words("Uncle sam", 3) ==> ["Uncle"]
-    """
-    if not s:
-        return []
-    
-    vowels = set('aeiouAEIOU')
-    result = []
-    
-    for word in s.split():
-        consonant_count = sum(1 for char in word if char.isalpha() and char not in vowels)
-        if consonant_count == n:
-            result.append(word)
-    
-    return result

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/118.py

@@ -1,26 +0,0 @@
-def get_closest_vowel(word):
-    """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. Return empty string if you didn't
-    find any vowel met the above condition. 
-
-    You may assume that the given string contains English letter only.
-
-    Example:
-    get_closest_vowel("yogurt") ==> "u"
-    get_closest_vowel("FULL") ==> "U"
-    get_closest_vowel("quick") ==> ""
-    get_closest_vowel("ab") ==> ""
-    """
-    if len(word) < 3:
-        return ""
-    
-    vowels = "aeiouAEIOU"
-    
-    for i in range(len(word) - 2, 0, -1):
-        if word[i] in vowels:
-            if word[i-1] not in vowels and word[i+1] not in vowels:
-                return word[i]
-    
-    return ""

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/119.py

@@ -1,30 +0,0 @@
-def match_parens(lst):
-    '''
-    You are given a list of two strings, both strings consist of open
-    parentheses '(' or close parentheses ')' only.
-    Your job is to check if it is possible to concatenate the two strings in
-    some order, that the resulting string will be good.
-    A string S is considered to be good if and only if all parentheses in S
-    are balanced. For example: the string '(())()' is good, while the string
-    '())' is not.
-    Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
-
-    Examples:
-    match_parens(['()(', ')']) == 'Yes'
-    match_parens([')', ')']) == 'No'
-    '''
-    def is_balanced(s):
-        count = 0
-        for c in s:
-            if c == '(':
-                count += 1
-            else:
-                count -= 1
-            if count < 0:
-                return False
-        return count == 0
-    
-    s1, s2 = lst[0], lst[1]
-    if is_balanced(s1 + s2) or is_balanced(s2 + s1):
-        return 'Yes'
-    return 'No'

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/12.py

@@ -1,21 +0,0 @@
-from typing import List, Optional
-
-
-def longest(strings: List[str]) -> Optional[str]:
-    """ Out of list of strings, return the longest one. Return the first one in case of multiple
-    strings of the same length. Return None in case the input list is empty.
-    >>> longest([])
-
-    >>> longest(['a', 'b', 'c'])
-    'a'
-    >>> longest(['a', 'bb', 'ccc'])
-    'ccc'
-    """
-    if not strings:
-        return None
-    
-    longest_str = strings[0]
-    for s in strings[1:]:
-        if len(s) > len(longest_str):
-            longest_str = s
-    return longest_str

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/120.py

@@ -1,28 +0,0 @@
-def maximum(arr, k):
-    """
-    Given an array arr of integers and a positive integer k, return a sorted list 
-    of length k with the maximum k numbers in arr.
-
-    Example 1:
-
-        Input: arr = [-3, -4, 5], k = 3
-        Output: [-4, -3, 5]
-
-    Example 2:
-
-        Input: arr = [4, -4, 4], k = 2
-        Output: [4, 4]
-
-    Example 3:
-
-        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
-        Output: [2]
-
-    Note:
-        1. The length of the array will be in the range of [1, 1000].
-        2. The elements in the array will be in the range of [-1000, 1000].
-        3. 0 <= k <= len(arr)
-    """
-    sorted_arr = sorted(arr, reverse=True)
-    top_k = sorted_arr[:k]
-    return sorted(top_k)

package/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/121.py

@@ -1,10 +0,0 @@
-def solution(lst):
-    """Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-    
-
-    Examples
-    solution([5, 8, 7, 1]) ==> 12
-    solution([3, 3, 3, 3, 3]) ==> 9
-    solution([30, 13, 24, 321]) ==>0
-    """
-    return sum(x for i, x in enumerate(lst) if i % 2 == 0 and x % 2 == 1)