wegho-agentes 7.0.4 → 7.0.6

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/0.py

@@ -1,21 +0,0 @@
-# HumanEval/0
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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/humaneval-loki-solutions/1.py

@@ -1,36 +0,0 @@
-# HumanEval/1
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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('( ) (( )) (( )( ))')
-    ['()', '(())', '(()())']
-    """
-    result = []
-    current_group = []
-    depth = 0
-    
-    for char in paren_string:
-        if char == ' ':
-            continue
-        
-        if char == '(':
-            depth += 1
-            current_group.append(char)
-        elif char == ')':
-            depth -= 1
-            current_group.append(char)
-            
-            if depth == 0:
-                result.append(''.join(current_group))
-                current_group = []
-    
-    return result

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/10.py

@@ -1,30 +0,0 @@
-# HumanEval/10
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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/humaneval-loki-solutions/100.py

@@ -1,23 +0,0 @@
-# HumanEval/100
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 = [n]
-    for _ in range(n - 1):
-        result.append(result[-1] + 2)
-    return result

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/101.py

@@ -1,17 +0,0 @@
-# HumanEval/101
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 []
-    return s.replace(",", " ").split()

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/102.py

@@ -1,21 +0,0 @@
-# HumanEval/102
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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/humaneval-loki-solutions/103.py

@@ -1,22 +0,0 @@
-# HumanEval/103
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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
-    count = m - n + 1
-    total = count * (n + m) // 2
-    avg = round(total / count)
-    return bin(avg)

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/104.py

@@ -1,23 +0,0 @@
-# HumanEval/104
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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])
-    []
-    """
-    even_digits = set("02468")
-    result = []
-    for num in x:
-        if not any(d in even_digits for d in str(num)):
-            result.append(num)
-    return sorted(result)

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/105.py

@@ -1,34 +0,0 @@
-# HumanEval/105
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 = ["One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"]
-    
-    filtered = [x for x in arr if 1 <= x <= 9]
-    filtered.sort()
-    filtered.reverse()
-    
-    return [names[x - 1] for x in filtered]

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/106.py

@@ -1,26 +0,0 @@
-# HumanEval/106
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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:
-            # Even i: compute factorial
-            factorial = 1
-            for j in range(1, i + 1):
-                factorial *= j
-            result.append(factorial)
-        else:
-            # Odd i: compute sum from 1 to i
-            result.append(i * (i + 1) // 2)
-    return result

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/107.py

@@ -1,40 +0,0 @@
-# HumanEval/107
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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/humaneval-loki-solutions/108.py

@@ -1,27 +0,0 @@
-# HumanEval/108
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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
-        is_negative = num < 0
-        num = abs(num)
-        digits = [int(d) for d in str(num)]
-        if is_negative:
-            digits[0] = -digits[0]
-        if sum(digits) > 0:
-            count += 1
-    return count

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/109.py

@@ -1,53 +0,0 @@
-# HumanEval/109
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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) <= 1:
-        return True
-    
-    # Count the number of break points where arr[i] > arr[i+1]
-    break_count = 0
-    n = len(arr)
-    
-    for i in range(n - 1):
-        if arr[i] > arr[i + 1]:
-            break_count += 1
-    
-    # If already sorted, return True
-    if break_count == 0:
-        return True
-    
-    # If exactly one break point and the wrap-around is valid
-    # (last element <= first element), it can be rotated to sorted order
-    if break_count == 1 and arr[-1] <= arr[0]:
-        return True
-    
-    return False

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/11.py

@@ -1,21 +0,0 @@
-# HumanEval/11
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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/humaneval-loki-solutions/110.py

@@ -1,25 +0,0 @@
-# HumanEval/110
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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.
-    """
-    odds_in_lst1 = sum(1 for x in lst1 if x % 2 != 0)
-    evens_in_lst2 = sum(1 for x in lst2 if x % 2 == 0)
-    
-    if evens_in_lst2 >= odds_in_lst1:
-        return "YES"
-    else:
-        return "NO"

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/111.py

@@ -1,34 +0,0 @@
-# HumanEval/111
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 not test.strip():
-        return {}
-    
-    letters = test.split()
-    counts = {}
-    
-    for letter in letters:
-        if letter:
-            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/humaneval-loki-solutions/112.py

@@ -1,20 +0,0 @@
-# HumanEval/112
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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)
-    """
-    chars_to_delete = set(c)
-    result = ''.join(char for char in s if char not in chars_to_delete)
-    is_palindrome = result == result[::-1]
-    return (result, is_palindrome)

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/113.py

@@ -1,25 +0,0 @@
-# HumanEval/113
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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:
-        odd_digit_count = sum(1 for d in s if int(d) % 2 == 1)
-        count_str = str(odd_digit_count)
-        template = "the number of odd elements in the string i of the input."
-        formatted = template.replace('i', count_str)
-        result.append(formatted)
-    return result

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/114.py

@@ -1,24 +0,0 @@
-# HumanEval/114
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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
-    """
-    if not nums:
-        return 0
-    
-    min_ending_here = nums[0]
-    min_so_far = nums[0]
-    
-    for i in range(1, len(nums)):
-        min_ending_here = min(nums[i], min_ending_here + nums[i])
-        min_so_far = min(min_so_far, min_ending_here)
-    
-    return min_so_far

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/115.py

@@ -1,41 +0,0 @@
-# HumanEval/115
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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
-    """
-    return sum(math.ceil(sum(row) / capacity) for row in grid if sum(row) > 0)

package/skills/loki-mode/benchmarks/results/humaneval-loki-solutions/116.py

@@ -1,17 +0,0 @@
-# HumanEval/116
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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/humaneval-loki-solutions/117.py

@@ -1,30 +0,0 @@
-# HumanEval/117
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 = "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/humaneval-loki-solutions/118.py

@@ -1,31 +0,0 @@
-# HumanEval/118
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 = set("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 ""