wegho-agentes 7.0.4 → 7.0.6

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

@@ -1,35 +0,0 @@
-# HumanEval/119
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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):
-        balance = 0
-        for char in s:
-            if char == '(':
-                balance += 1
-            else:
-                balance -= 1
-            if balance < 0:
-                return False
-        return balance == 0
-    
-    # Try both concatenation orders
-    if is_balanced(lst[0] + lst[1]) or is_balanced(lst[1] + lst[0]):
-        return 'Yes'
-    return 'No'

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

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

@@ -1,33 +0,0 @@
-# HumanEval/120
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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)
-    """
-    if k == 0:
-        return []
-    return sorted(arr)[-k:]

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

@@ -1,15 +0,0 @@
-# HumanEval/121
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 x in lst[::2] if x % 2 == 1)

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

@@ -1,24 +0,0 @@
-# HumanEval/122
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def add_elements(arr, k):
-    """
-    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 k elements of arr.
-
-    Example:
-
-        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
-        Output: 24 # sum of 21 + 3
-
-    Constraints:
-        1. 1 <= len(arr) <= 100
-        2. 1 <= k <= len(arr)
-    """
-    total = 0
-    for element in arr[:k]:
-        if -99 <= element <= 99:
-            total += element
-    return total

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

@@ -1,35 +0,0 @@
-# HumanEval/123
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def get_odd_collatz(n):
-    """
-    Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
-
-    The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
-    as follows: start with any positive integer n. Then each term is obtained from the 
-    previous term as follows: if the previous term is even, the next term is one half of 
-    the previous term. If the previous term is odd, the next term is 3 times the previous
-    term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
-
-    Note: 
-        1. Collatz(1) is [1].
-        2. returned list sorted in increasing order.
-
-    For example:
-    get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.
-    """
-    odd_numbers = set()
-    
-    while n >= 1:
-        if n % 2 == 1:
-            odd_numbers.add(n)
-        if n == 1:
-            break
-        if n % 2 == 0:
-            n = n // 2
-        else:
-            n = 3 * n + 1
-    
-    return sorted(odd_numbers)

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

@@ -1,58 +0,0 @@
-# HumanEval/124
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def valid_date(date):
-    """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 string is not empty.
-    2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.
-    3. The months should not be less than 1 or higher than 12.
-    4. The date should be in the format: mm-dd-yyyy
-
-    for example: 
-    valid_date('03-11-2000') => True
-
-    valid_date('15-01-2012') => False
-
-    valid_date('04-0-2040') => False
-
-    valid_date('06-04-2020') => True
-
-    valid_date('06/04/2020') => False
-    """
-    if not date or not isinstance(date, str):
-        return False
-    
-    parts = date.split('-')
-    if len(parts) != 3:
-        return False
-    
-    mm, dd, yyyy = parts
-    
-    if len(mm) != 2 or len(dd) != 2 or len(yyyy) != 4:
-        return False
-    
-    try:
-        month = int(mm)
-        day = int(dd)
-        year = int(yyyy)
-    except ValueError:
-        return False
-    
-    if month < 1 or month > 12:
-        return False
-    
-    if month in [1, 3, 5, 7, 8, 10, 12]:
-        max_days = 31
-    elif month in [4, 6, 9, 11]:
-        max_days = 30
-    else:
-        max_days = 29
-    
-    if day < 1 or day > max_days:
-        return False
-    
-    return True

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

@@ -1,25 +0,0 @@
-# HumanEval/125
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def split_words(txt):
-    '''
-    Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-    should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-    Examples
-    split_words("Hello world!") ➞ ["Hello", "world!"]
-    split_words("Hello,world!") ➞ ["Hello", "world!"]
-    split_words("abcdef") == 3 
-    '''
-    if ' ' in txt:
-        return txt.split()
-    elif ',' in txt:
-        return txt.split(',')
-    else:
-        count = 0
-        for char in txt:
-            if char.islower() and (ord(char) - ord('a')) % 2 == 1:
-                count += 1
-        return count

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

@@ -1,34 +0,0 @@
-# HumanEval/126
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def is_sorted(lst):
-    '''
-    Given a list of numbers, return whether or not they are sorted
-    in ascending order. If list has more than 1 duplicate of the same
-    number, return False. Assume no negative numbers and only integers.
-
-    Examples
-    is_sorted([5]) ➞ True
-    is_sorted([1, 2, 3, 4, 5]) ➞ True
-    is_sorted([1, 3, 2, 4, 5]) ➞ False
-    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
-    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
-    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
-    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
-    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
-    '''
-    # Check if sorted in ascending order
-    for i in range(len(lst) - 1):
-        if lst[i] > lst[i + 1]:
-            return False
-    
-    # Check that no number appears more than twice
-    count = {}
-    for num in lst:
-        count[num] = count.get(num, 0) + 1
-        if count[num] > 2:
-            return False
-    
-    return True

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

@@ -1,41 +0,0 @@
-# HumanEval/127
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def intersection(interval1, interval2):
-    """You are given two intervals,
-    where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
-    The given intervals are closed which means that the interval (start, end)
-    includes both start and end.
-    For each given interval, it is assumed that its start is less or equal its end.
-    Your task is to determine whether the length of intersection of these two 
-    intervals is a prime number.
-    Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
-    which its length is 1, which not a prime number.
-    If the length of the intersection is a prime number, return "YES",
-    otherwise, return "NO".
-    If the two intervals don't intersect, return "NO".
-
-
-    [input/output] samples:
-    intersection((1, 2), (2, 3)) ==> "NO"
-    intersection((-1, 1), (0, 4)) ==> "NO"
-    intersection((-3, -1), (-5, 5)) ==> "YES"
-    """
-    start = max(interval1[0], interval2[0])
-    end = min(interval1[1], interval2[1])
-    
-    if start > end:
-        return "NO"
-    
-    length = end - start
-    
-    if length < 2:
-        return "NO"
-    
-    for i in range(2, int(length ** 0.5) + 1):
-        if length % i == 0:
-            return "NO"
-    
-    return "YES"

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

@@ -1,31 +0,0 @@
-# HumanEval/128
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def prod_signs(arr):
-    """
-    You are given an array arr of integers and you need to return
-    sum of magnitudes of integers multiplied by product of all signs
-    of each number in the array, represented by 1, -1 or 0.
-    Note: return None for empty arr.
-
-    Example:
-    >>> prod_signs([1, 2, 2, -4]) == -9
-    >>> prod_signs([0, 1]) == 0
-    >>> prod_signs([]) == None
-    """
-    if not arr:
-        return None
-    
-    sign_product = 1
-    magnitude_sum = 0
-    
-    for num in arr:
-        if num == 0:
-            sign_product = 0
-        elif num < 0:
-            sign_product *= -1
-        magnitude_sum += abs(num)
-    
-    return sign_product * magnitude_sum

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

@@ -1,62 +0,0 @@
-# HumanEval/129
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def minPath(grid, k):
-    """
-    Given a grid with N rows and N columns (N >= 2) and a positive integer k, 
-    each cell of the grid contains a value. Every integer in the range [1, N * N]
-    inclusive appears exactly once on the cells of the grid.
-
-    You have to find the minimum path of length k in the grid. You can start
-    from any cell, and in each step you can move to any of the neighbor cells,
-    in other words, you can go to cells which share an edge with you current
-    cell.
-    Please note that a path of length k means visiting exactly k cells (not
-    necessarily distinct).
-    You CANNOT go off the grid.
-    A path A (of length k) is considered less than a path B (of length k) if
-    after making the ordered lists of the values on the cells that A and B go
-    through (let's call them lst_A and lst_B), lst_A is lexicographically less
-    than lst_B, in other words, there exist an integer index i (1 <= i <= k)
-    such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
-    lst_A[j] = lst_B[j].
-    It is guaranteed that the answer is unique.
-    Return an ordered list of the values on the cells that the minimum path go through.
-
-    Examples:
-
-        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
-        Output: [1, 2, 1]
-
-        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
-        Output: [1]
-    """
-    n = len(grid)
-    
-    # Find the position of cell with value 1
-    row_1, col_1 = 0, 0
-    for i in range(n):
-        for j in range(n):
-            if grid[i][j] == 1:
-                row_1, col_1 = i, j
-                break
-    
-    # Find the smallest neighbor of cell with value 1
-    min_neighbor = n * n + 1
-    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
-    for dr, dc in directions:
-        nr, nc = row_1 + dr, col_1 + dc
-        if 0 <= nr < n and 0 <= nc < n:
-            min_neighbor = min(min_neighbor, grid[nr][nc])
-    
-    # Build the result: alternating pattern of 1 and min_neighbor
-    result = []
-    for i in range(k):
-        if i % 2 == 0:
-            result.append(1)
-        else:
-            result.append(min_neighbor)
-    
-    return result

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

@@ -1,17 +0,0 @@
-# HumanEval/13
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """ Return a greatest common divisor of two integers a and b
-    >>> greatest_common_divisor(3, 5)
-    1
-    >>> greatest_common_divisor(25, 15)
-    5
-    """
-    a = abs(a)
-    b = abs(b)
-    while b:
-        a, b = b, a % b
-    return a

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

@@ -1,35 +0,0 @@
-# HumanEval/130
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def tri(n):
-    """Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in 
-    the last couple centuries. However, what people don't know is Tribonacci sequence.
-    Tribonacci sequence is defined by the recurrence:
-    tri(1) = 3
-    tri(n) = 1 + n / 2, if n is even.
-    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
-    For example:
-    tri(2) = 1 + (2 / 2) = 2
-    tri(4) = 3
-    tri(3) = tri(2) + tri(1) + tri(4)
-           = 2 + 3 + 3 = 8 
-    You are given a non-negative integer number n, you have to a return a list of the 
-    first n + 1 numbers of the Tribonacci sequence.
-    Examples:
-    tri(3) = [1, 3, 2, 8]
-    """
-    if n == 0:
-        return [1]
-    
-    result = [1, 3]
-    
-    for i in range(2, n + 1):
-        if i % 2 == 0:
-            result.append(1 + i // 2)
-        else:
-            next_even = 1 + (i + 1) // 2
-            result.append(result[i - 1] + result[i - 2] + next_even)
-    
-    return result

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

@@ -1,24 +0,0 @@
-# HumanEval/131
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def digits(n):
-    """Given a positive integer n, return the product of the odd digits.
-    Return 0 if all digits are even.
-    For example:
-    digits(1)  == 1
-    digits(4)  == 0
-    digits(235) == 15
-    """
-    product = 1
-    has_odd = False
-    
-    while n > 0:
-        digit = n % 10
-        if digit % 2 == 1:
-            product *= digit
-            has_odd = True
-        n //= 10
-    
-    return product if has_odd else 0

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

@@ -1,32 +0,0 @@
-# HumanEval/132
-# Loki Mode Multi-Agent Solution
-# Attempts: 2
-# Passed: True
-
-def is_nested(string):
-    '''
-    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 the subsequence is nested.
-
-    is_nested('[[]]') ➞ True
-    is_nested('[]]]]]]][[[[[]') ➞ False
-    is_nested('[][]') ➞ False
-    is_nested('[]') ➞ False
-    is_nested('[[][]]') ➞ True
-    is_nested('[[]][[') ➞ True
-    '''
-    depth = 0
-    max_depth = 0
-    for char in string:
-        if char == '[':
-            depth += 1
-            max_depth = max(max_depth, depth)
-        elif char == ']':
-            if depth > 0:
-                depth -= 1
-                if depth == 0 and max_depth >= 2:
-                    return True
-                if depth == 0:
-                    max_depth = 0
-    return False

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

@@ -1,21 +0,0 @@
-# HumanEval/133
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-import math
-
-def sum_squares(lst):
-    """You are given a list of numbers.
-    You need to return the sum of squared numbers in the given list,
-    round each element in the list to the upper int(Ceiling) first.
-    Examples:
-    For lst = [1,2,3] the output should be 14
-    For lst = [1,4,9] the output should be 98
-    For lst = [1,3,5,7] the output should be 84
-    For lst = [1.4,4.2,0] the output should be 29
-    For lst = [-2.4,1,1] the output should be 6
-    
-
-    """
-    return sum(math.ceil(x)**2 for x in lst)

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

@@ -1,23 +0,0 @@
-# HumanEval/134
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def check_if_last_char_is_a_letter(txt):
-    '''
-    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 characters separated by space.
-
-    Examples:
-    check_if_last_char_is_a_letter("apple pie") ➞ False
-    check_if_last_char_is_a_letter("apple pi e") ➞ True
-    check_if_last_char_is_a_letter("apple pi e ") ➞ False
-    check_if_last_char_is_a_letter("") ➞ False 
-    '''
-    if not txt or not txt[-1].isalpha():
-        return False
-    if len(txt) == 1:
-        return True
-    return txt[-2] == ' '

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

@@ -1,20 +0,0 @@
-# HumanEval/135
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def can_arrange(arr):
-    """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
-    no such element exists then return -1. The given array will not contain
-    duplicate values.
-
-    Examples:
-    can_arrange([1,2,4,3,5]) = 3
-    can_arrange([1,2,3]) = -1
-    """
-    result = -1
-    for i in range(1, len(arr)):
-        if arr[i] < arr[i - 1]:
-            result = i
-    return result

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

@@ -1,24 +0,0 @@
-# HumanEval/136
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def largest_smallest_integers(lst):
-    '''
-    Create a function that returns a tuple (a, b), where 'a' is
-    the largest of negative integers, and 'b' is the smallest
-    of positive integers in a list.
-    If there is no negative or positive integers, return them as None.
-
-    Examples:
-    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-    largest_smallest_integers([]) == (None, None)
-    largest_smallest_integers([0]) == (None, None)
-    '''
-    negatives = [x for x in lst if x < 0]
-    positives = [x for x in lst if x > 0]
-    
-    largest_negative = max(negatives) if negatives else None
-    smallest_positive = min(positives) if positives else None
-    
-    return (largest_negative, smallest_positive)

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

@@ -1,31 +0,0 @@
-# HumanEval/137
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def compare_one(a, b):
-    """
-    Create a function that takes integers, floats, or strings representing
-    real numbers, and returns the larger variable in its given variable type.
-    Return None if the values are equal.
-    Note: If a real number is represented as a string, the floating point might be . or ,
-
-    compare_one(1, 2.5) ➞ 2.5
-    compare_one(1, "2,3") ➞ "2,3"
-    compare_one("5,1", "6") ➞ "6"
-    compare_one("1", 1) ➞ None
-    """
-    def to_float(x):
-        if isinstance(x, str):
-            return float(x.replace(",", "."))
-        return float(x)
-    
-    val_a = to_float(a)
-    val_b = to_float(b)
-    
-    if val_a == val_b:
-        return None
-    elif val_a > val_b:
-        return a
-    else:
-        return b