wegho-agentes 7.0.3 → 7.0.6

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

@@ -1,19 +0,0 @@
-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 i in range(k):
-        if -99 <= arr[i] <= 99:
-            total += arr[i]
-    return total

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

@@ -1,31 +0,0 @@
-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 = []
-    current = n
-    
-    while current != 1:
-        if current % 2 == 1:
-            odd_numbers.append(current)
-        if current % 2 == 0:
-            current = current // 2
-        else:
-            current = 3 * current + 1
-    
-    odd_numbers.append(1)
-    
-    return sorted(odd_numbers)

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

@@ -1,56 +0,0 @@
-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:
-        return False
-    
-    try:
-        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
-        
-        month = int(mm)
-        day = int(dd)
-        year = int(yyyy)
-        
-        if month < 1 or month > 12:
-            return False
-        
-        if day < 1:
-            return False
-        
-        if month in [1, 3, 5, 7, 8, 10, 12]:
-            if day > 31:
-                return False
-        elif month in [4, 6, 9, 11]:
-            if day > 30:
-                return False
-        elif month == 2:
-            if day > 29:
-                return False
-        
-        return True
-    except:
-        return False

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

@@ -1,20 +0,0 @@
-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/2026-01-05-00-49-17/humaneval-solutions/126.py

@@ -1,29 +0,0 @@
-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 for more than 1 duplicate of any number
-    from collections import Counter
-    counts = Counter(lst)
-    for count in counts.values():
-        if count > 2:
-            return False
-    
-    return True

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

@@ -1,47 +0,0 @@
-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"
-    """
-    def is_prime(n):
-        if n < 2:
-            return False
-        if n == 2:
-            return True
-        if n % 2 == 0:
-            return False
-        for i in range(3, int(n**0.5) + 1, 2):
-            if n % i == 0:
-                return False
-        return True
-    
-    start1, end1 = interval1
-    start2, end2 = interval2
-    
-    intersection_start = max(start1, start2)
-    intersection_end = min(end1, end2)
-    
-    if intersection_start > intersection_end:
-        return "NO"
-    
-    length = intersection_end - intersection_start
-    
-    if is_prime(length):
-        return "YES"
-    else:
-        return "NO"

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

@@ -1,25 +0,0 @@
-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
-    
-    sum_magnitudes = sum(abs(x) for x in arr)
-    
-    sign_product = 1
-    for x in arr:
-        if x == 0:
-            return 0
-        elif x < 0:
-            sign_product *= -1
-    
-    return sum_magnitudes * sign_product

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

@@ -1,61 +0,0 @@
-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 position of value 1 (the minimum value)
-    pos_1 = None
-    for i in range(n):
-        for j in range(n):
-            if grid[i][j] == 1:
-                pos_1 = (i, j)
-                break
-        if pos_1:
-            break
-    
-    # Find the minimum neighbor of cell containing 1
-    i, j = pos_1
-    min_neighbor = float('inf')
-    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
-    for di, dj in directions:
-        ni, nj = i + di, j + dj
-        if 0 <= ni < n and 0 <= nj < n:
-            min_neighbor = min(min_neighbor, grid[ni][nj])
-    
-    # The minimum path starting from 1 will alternate between 1 and its minimum neighbor
-    # This is because we can always go back to 1 from any neighbor
-    result = []
-    for step in range(k):
-        if step % 2 == 0:
-            result.append(1)
-        else:
-            result.append(min_neighbor)
-    
-    return result

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

@@ -1,10 +0,0 @@
-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
-    """
-    while b:
-        a, b = b, a % b
-    return a

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

@@ -1,29 +0,0 @@
-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:
-            result.append(result[i - 1] + result[i - 2] + (1 + (i + 1) // 2))
-    
-    return result

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

@@ -1,18 +0,0 @@
-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
-    
-    for digit in str(n):
-        d = int(digit)
-        if d % 2 == 1:
-            product *= d
-            has_odd = True
-    
-    return product if has_odd else 0

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

@@ -1,36 +0,0 @@
-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
-    '''
-    opening_bracket_index = []
-    closing_bracket_index = []
-    
-    for i, c in enumerate(string):
-        if c == '[':
-            opening_bracket_index.append(i)
-        else:
-            closing_bracket_index.append(i)
-    
-    closing_bracket_index.reverse()
-    
-    cnt = 0
-    i = 0
-    j = 0
-    
-    while i < len(opening_bracket_index) and j < len(closing_bracket_index):
-        if opening_bracket_index[i] < closing_bracket_index[j]:
-            cnt += 1
-            i += 1
-        else:
-            j += 1
-    
-    return cnt >= 2

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

@@ -1,16 +0,0 @@
-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/2026-01-05-00-49-17/humaneval-solutions/134.py

@@ -1,27 +0,0 @@
-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 len(txt) == 0:
-        return False
-    
-    last_char = txt[-1]
-    
-    if not last_char.isalpha():
-        return False
-    
-    if len(txt) == 1:
-        return True
-    
-    second_last_char = txt[-2]
-    
-    return second_last_char == ' '

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

@@ -1,15 +0,0 @@
-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/2026-01-05-00-49-17/humaneval-solutions/136.py

@@ -1,19 +0,0 @@
-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]
-    
-    a = max(negatives) if negatives else None
-    b = min(positives) if positives else None
-    
-    return (a, b)

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

@@ -1,26 +0,0 @@
-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

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

@@ -1,8 +0,0 @@
-def is_equal_to_sum_even(n):
-    """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
-    is_equal_to_sum_even(8) == True
-    """
-    return n >= 8 and n % 2 == 0

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

@@ -1,18 +0,0 @@
-def special_factorial(n):
-    """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 an integer as input and should return the special
-    factorial of this integer.
-    """
-    result = 1
-    factorial = 1
-    for i in range(1, n + 1):
-        factorial *= i
-        result *= factorial
-    return result

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

@@ -1,9 +0,0 @@
-from typing import List
-
-
-def all_prefixes(string: str) -> List[str]:
-    """ Return list of all prefixes from shortest to longest of the input string
-    >>> all_prefixes('abc')
-    ['a', 'ab', 'abc']
-    """
-    return [string[:i+1] for i in range(len(string))]

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

@@ -1,30 +0,0 @@
-def fix_spaces(text):
-    """
-    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") == "Example"
-    fix_spaces("Example 1") == "Example_1"
-    fix_spaces(" Example 2") == "_Example_2"
-    fix_spaces(" Example   3") == "_Example-3"
-    """
-    result = []
-    i = 0
-    while i < len(text):
-        if text[i] == ' ':
-            # Count consecutive spaces
-            space_count = 0
-            while i < len(text) and text[i] == ' ':
-                space_count += 1
-                i += 1
-            # If more than 2 consecutive spaces, replace with -
-            if space_count > 2:
-                result.append('-')
-            else:
-                # Replace each space with underscore
-                result.append('_' * space_count)
-        else:
-            result.append(text[i])
-            i += 1
-    return ''.join(result)

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

@@ -1,35 +0,0 @@
-def file_name_check(file_name):
-    """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 if all the following conditions 
-    are met:
-    - There should not be more than three digits ('0'-'9') in the file's name.
-    - The file's name contains exactly one dot '.'
-    - The substring before the dot should not be empty, and it starts with a letter from 
-    the latin alphapet ('a'-'z' and 'A'-'Z').
-    - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
-    Examples:
-    file_name_check("example.txt") # => 'Yes'
-    file_name_check("1example.dll") # => 'No' (the name should start with a latin alphapet letter)
-    """
-    # Check for exactly one dot
-    if file_name.count('.') != 1:
-        return 'No'
-    
-    # Split the file name into name and extension
-    name, extension = file_name.split('.')
-    
-    # Check if the name is not empty and starts with a letter
-    if len(name) == 0 or not name[0].isalpha():
-        return 'No'
-    
-    # Check if extension is valid
-    if extension not in ['txt', 'exe', 'dll']:
-        return 'No'
-    
-    # Count digits in the entire file name
-    digit_count = sum(1 for char in file_name if char.isdigit())
-    if digit_count > 3:
-        return 'No'
-    
-    return 'Yes'

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

@@ -1,20 +0,0 @@
-def sum_squares(lst):
-    """"
-    This function will take a list of integers. For all entries in the list, the function shall square the integer entry if its index is a 
-    multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not 
-    change the entries in the list whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries. 
-    
-    Examples:
-    For lst = [1,2,3] the output should be 6
-    For lst = []  the output should be 0
-    For lst = [-1,-5,2,-1,-5]  the output should be -126
-    """
-    result = 0
-    for i, val in enumerate(lst):
-        if i % 3 == 0:
-            result += val ** 2
-        elif i % 4 == 0:
-            result += val ** 3
-        else:
-            result += val
-    return result

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

@@ -1,35 +0,0 @@
-def words_in_sentence(sentence):
-    """
-    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,
-    whose lengths are prime numbers,
-    the order of the words in the new string should be the same as the original one.
-
-    Example 1:
-        Input: sentence = "This is a test"
-        Output: "is"
-
-    Example 2:
-        Input: sentence = "lets go for swimming"
-        Output: "go for"
-
-    Constraints:
-        * 1 <= len(sentence) <= 100
-        * sentence contains only letters
-    """
-    def is_prime(n):
-        if n < 2:
-            return False
-        if n == 2:
-            return True
-        if n % 2 == 0:
-            return False
-        for i in range(3, int(n ** 0.5) + 1, 2):
-            if n % i == 0:
-                return False
-        return True
-    
-    words = sentence.split()
-    prime_words = [word for word in words if is_prime(len(word))]
-    return " ".join(prime_words)