wegho-agentes 7.0.4 → 7.0.6

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

@@ -1,6 +0,0 @@
-def flip_case(string: str) -> str:
-    """ For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-    >>> flip_case('Hello')
-    'hELLO'
-    """
-    return string.swapcase()

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

@@ -1,11 +0,0 @@
-from typing import List
-
-
-def concatenate(strings: List[str]) -> str:
-    """ Concatenate list of strings into a single string
-    >>> concatenate([])
-    ''
-    >>> concatenate(['a', 'b', 'c'])
-    'abc'
-    """
-    return ''.join(strings)

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

@@ -1,11 +0,0 @@
-from typing import List
-
-
-def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
-    """ Filter an input list of strings only for ones that start with a given prefix.
-    >>> filter_by_prefix([], 'a')
-    []
-    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
-    ['abc', 'array']
-    """
-    return [s for s in strings if s.startswith(prefix)]

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

@@ -1,18 +0,0 @@
-from typing import List
-
-
-def below_zero(operations: List[int]) -> bool:
-    """ You're given a list of deposit and withdrawal operations on a bank account that starts with
-    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
-    at that point function should return True. Otherwise it should return False.
-    >>> below_zero([1, 2, 3])
-    False
-    >>> below_zero([1, 2, -4, 5])
-    True
-    """
-    balance = 0
-    for operation in operations:
-        balance += operation
-        if balance < 0:
-            return True
-    return False

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

@@ -1,8 +0,0 @@
-def get_positive(l: list):
-    """Return only positive numbers in the list.
-    >>> get_positive([-1, 2, -4, 5, 6])
-    [2, 5, 6]
-    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    [5, 3, 2, 3, 9, 123, 1]
-    """
-    return [x for x in l if x > 0]

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

@@ -1,27 +0,0 @@
-def is_prime(n):
-    """Return true if a given number is prime, and false otherwise.
-    >>> is_prime(6)
-    False
-    >>> is_prime(101)
-    True
-    >>> is_prime(11)
-    True
-    >>> is_prime(13441)
-    True
-    >>> is_prime(61)
-    True
-    >>> is_prime(4)
-    False
-    >>> is_prime(1)
-    False
-    """
-    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

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

@@ -1,50 +0,0 @@
-import math
-
-
-def poly(xs: list, x: float):
-    """
-    Evaluates polynomial with coefficients xs at point x.
-    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
-    """
-    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
-
-
-def find_zero(xs: list):
-    """ xs are coefficients of a polynomial.
-    find_zero find x such that poly(x) = 0.
-    find_zero returns only only zero point, even if there are many.
-    Moreover, find_zero only takes list xs having even number of coefficients
-    and largest non zero coefficient as it guarantees
-    a solution.
-    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-    -0.5
-    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
-    1.0
-    """
-    # Use Newton-Raphson method to find a zero
-    # First, find a suitable starting point and bounds
-    
-    # For a polynomial with odd degree (even number of coefficients),
-    # there's guaranteed to be at least one real root
-    
-    # Use bisection method to find bounds, then Newton-Raphson
-    
-    # Find bounds where the polynomial changes sign
-    lo, hi = -1.0, 1.0
-    
-    # Expand bounds until we find a sign change
-    while poly(xs, lo) * poly(xs, hi) > 0:
-        lo *= 2
-        hi *= 2
-    
-    # Bisection method for reliability
-    while hi - lo > 1e-10:
-        mid = (lo + hi) / 2.0
-        if poly(xs, mid) == 0:
-            return mid
-        if poly(xs, lo) * poly(xs, mid) < 0:
-            hi = mid
-        else:
-            lo = mid
-    
-    return (lo + hi) / 2.0

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

@@ -1,20 +0,0 @@
-def sort_third(l: list):
-    """This function takes a list l and returns a list l' such that
-    l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
-    to the values of the corresponding indicies of l, but sorted.
-    >>> sort_third([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
-    [2, 6, 3, 4, 8, 9, 5]
-    """
-    # Extract values at indices divisible by 3
-    third_values = [l[i] for i in range(0, len(l), 3)]
-    # Sort them
-    third_values.sort()
-    
-    # Build result list
-    result = l.copy()
-    for i, val in enumerate(third_values):
-        result[i * 3] = val
-    
-    return result

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

@@ -1,6 +0,0 @@
-def unique(l: list):
-    """Return sorted unique elements in a list
-    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [0, 2, 3, 5, 9, 123]
-    """
-    return sorted(set(l))

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

@@ -1,8 +0,0 @@
-def max_element(l: list):
-    """Return maximum element in the list.
-    >>> max_element([1, 2, 3])
-    3
-    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    123
-    """
-    return max(l)

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

@@ -1,14 +0,0 @@
-def fizz_buzz(n: int):
-    """Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-    >>> fizz_buzz(50)
-    0
-    >>> fizz_buzz(78)
-    2
-    >>> fizz_buzz(79)
-    3
-    """
-    count = 0
-    for i in range(n):
-        if i % 11 == 0 or i % 13 == 0:
-            count += str(i).count('7')
-    return count

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

@@ -1,14 +0,0 @@
-def sort_even(l: list):
-    """This function takes a list l and returns a list l' such that
-    l' is identical to l in the odd indicies, while its values at the even indicies are equal
-    to the values of the even indicies of l, but sorted.
-    >>> sort_even([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_even([5, 6, 3, 4])
-    [3, 6, 5, 4]
-    """
-    even_values = sorted(l[::2])
-    result = l[:]
-    for i, val in enumerate(even_values):
-        result[i * 2] = val
-    return result

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

@@ -1,11 +0,0 @@
-def decode_cyclic(s: str):
-    """
-    takes as input string encoded with encode_cyclic function. Returns decoded string.
-    """
-    # split string to groups. Each of length 3.
-    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
-    # reverse the cycle operation: shift the last character to the front
-    # encode does: abc -> bca (shift left)
-    # decode should: bca -> abc (shift right, i.e., last char to front)
-    groups = [(group[-1] + group[:-1]) if len(group) == 3 else group for group in groups]
-    return "".join(groups)

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

@@ -1,35 +0,0 @@
-def prime_fib(n: int):
-    """
-    prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-    >>> prime_fib(1)
-    2
-    >>> prime_fib(2)
-    3
-    >>> prime_fib(3)
-    5
-    >>> prime_fib(4)
-    13
-    >>> prime_fib(5)
-    89
-    """
-    def is_prime(num):
-        if num < 2:
-            return False
-        if num == 2:
-            return True
-        if num % 2 == 0:
-            return False
-        for i in range(3, int(num ** 0.5) + 1, 2):
-            if num % i == 0:
-                return False
-        return True
-    
-    count = 0
-    fib_prev, fib_curr = 0, 1
-    
-    while count < n:
-        fib_prev, fib_curr = fib_curr, fib_prev + fib_curr
-        if is_prime(fib_curr):
-            count += 1
-    
-    return fib_curr

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

@@ -1,14 +0,0 @@
-from typing import List
-
-
-def mean_absolute_deviation(numbers: List[float]) -> float:
-    """ For a given list of input numbers, calculate Mean Absolute Deviation
-    around the mean of this dataset.
-    Mean Absolute Deviation is the average absolute difference between each
-    element and a centerpoint (mean in this case):
-    MAD = average | x - x_mean |
-    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
-    1.0
-    """
-    mean = sum(numbers) / len(numbers)
-    return sum(abs(x - mean) for x in numbers) / len(numbers)

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

@@ -1,24 +0,0 @@
-def triples_sum_to_zero(l: list):
-    """
-    triples_sum_to_zero takes a list of integers as an input.
-    it returns True if there are three distinct elements in the list that
-    sum to zero, and False otherwise.
-
-    >>> triples_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> triples_sum_to_zero([1, 3, -2, 1])
-    True
-    >>> triples_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
-    True
-    >>> triples_sum_to_zero([1])
-    False
-    """
-    n = len(l)
-    for i in range(n):
-        for j in range(i + 1, n):
-            for k in range(j + 1, n):
-                if l[i] + l[j] + l[k] == 0:
-                    return True
-    return False

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

@@ -1,13 +0,0 @@
-def car_race_collision(n: int):
-    """
-    Imagine a road that's a perfectly straight infinitely long line.
-    n cars are driving left to right;  simultaneously, a different set of n cars
-    are driving right to left.   The two sets of cars start out being very far from
-    each other.  All cars move in the same speed.  Two cars are said to collide
-    when a car that's moving left to right hits a car that's moving right to left.
-    However, the cars are infinitely sturdy and strong; as a result, they continue moving
-    in their trajectory as if they did not collide.
-
-    This function outputs the number of such collisions.
-    """
-    return n * n

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

@@ -1,8 +0,0 @@
-def incr_list(l: list):
-    """Return list with elements incremented by 1.
-    >>> incr_list([1, 2, 3])
-    [2, 3, 4]
-    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [6, 4, 6, 3, 4, 4, 10, 1, 124]
-    """
-    return [x + 1 for x in l]

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

@@ -1,22 +0,0 @@
-def pairs_sum_to_zero(l):
-    """
-    pairs_sum_to_zero takes a list of integers as an input.
-    it returns True if there are two distinct elements in the list that
-    sum to zero, and False otherwise.
-    >>> pairs_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> pairs_sum_to_zero([1, 3, -2, 1])
-    False
-    >>> pairs_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
-    True
-    >>> pairs_sum_to_zero([1])
-    False
-    """
-    seen = set()
-    for num in l:
-        if -num in seen:
-            return True
-        seen.add(num)
-    return False

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

@@ -1,18 +0,0 @@
-def change_base(x: int, base: int):
-    """Change numerical base of input number x to base.
-    return string representation after the conversion.
-    base numbers are less than 10.
-    >>> change_base(8, 3)
-    '22'
-    >>> change_base(8, 2)
-    '1000'
-    >>> change_base(7, 2)
-    '111'
-    """
-    if x == 0:
-        return '0'
-    result = ''
-    while x > 0:
-        result = str(x % base) + result
-        x //= base
-    return result

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

@@ -1,6 +0,0 @@
-def triangle_area(a, h):
-    """Given length of a side and high return area for a triangle.
-    >>> triangle_area(5, 3)
-    7.5
-    """
-    return (a * h) / 2

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

@@ -1,23 +0,0 @@
-def fib4(n: int):
-    """The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fib4(0) -> 0
-    fib4(1) -> 0
-    fib4(2) -> 2
-    fib4(3) -> 0
-    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
-    Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
-    >>> fib4(5)
-    4
-    >>> fib4(6)
-    8
-    >>> fib4(7)
-    14
-    """
-    if n < 4:
-        return [0, 0, 2, 0][n]
-    
-    a, b, c, d = 0, 0, 2, 0
-    for _ in range(4, n + 1):
-        a, b, c, d = b, c, d, a + b + c + d
-    
-    return d

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

@@ -1,14 +0,0 @@
-def median(l: list):
-    """Return median of elements in the list l.
-    >>> median([3, 1, 2, 4, 5])
-    3
-    >>> median([-10, 4, 6, 1000, 10, 20])
-    15.0
-    """
-    sorted_l = sorted(l)
-    n = len(sorted_l)
-    mid = n // 2
-    if n % 2 == 1:
-        return sorted_l[mid]
-    else:
-        return (sorted_l[mid - 1] + sorted_l[mid]) / 2

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

@@ -1,13 +0,0 @@
-def is_palindrome(text: str):
-    """
-    Checks if given string is a palindrome
-    >>> is_palindrome('')
-    True
-    >>> is_palindrome('aba')
-    True
-    >>> is_palindrome('aaaaa')
-    True
-    >>> is_palindrome('zbcd')
-    False
-    """
-    return text == text[::-1]

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

@@ -1,14 +0,0 @@
-def modp(n: int, p: int):
-    """Return 2^n modulo p (be aware of numerics).
-    >>> modp(3, 5)
-    3
-    >>> modp(1101, 101)
-    2
-    >>> modp(0, 101)
-    1
-    >>> modp(3, 11)
-    8
-    >>> modp(100, 101)
-    1
-    """
-    return pow(2, n, p)

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

@@ -1,19 +0,0 @@
-from typing import List
-
-
-def intersperse(numbers: List[int], delimeter: int) -> List[int]:
-    """ Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
-    >>> intersperse([], 4)
-    []
-    >>> intersperse([1, 2, 3], 4)
-    [1, 4, 2, 4, 3]
-    """
-    if not numbers:
-        return []
-    
-    result = [numbers[0]]
-    for num in numbers[1:]:
-        result.append(delimeter)
-        result.append(num)
-    
-    return result

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

@@ -1,12 +0,0 @@
-def encode_shift(s: str):
-    """
-    returns encoded string by shifting every character by 5 in the alphabet.
-    """
-    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
-
-
-def decode_shift(s: str):
-    """
-    takes as input string encoded with encode_shift function. Returns decoded string.
-    """
-    return "".join([chr(((ord(ch) - 5 - ord("a")) % 26) + ord("a")) for ch in s])

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

@@ -1,18 +0,0 @@
-def remove_vowels(text):
-    """
-    remove_vowels is a function that takes string and returns string without vowels.
-    >>> remove_vowels('')
-    ''
-    >>> remove_vowels("abcdef\nghijklm")
-    'bcdf\nghjklm'
-    >>> remove_vowels('abcdef')
-    'bcdf'
-    >>> remove_vowels('aaaaa')
-    ''
-    >>> remove_vowels('aaBAA')
-    'B'
-    >>> remove_vowels('zbcd')
-    'zbcd'
-    """
-    vowels = 'aeiouAEIOU'
-    return ''.join(char for char in text if char not in vowels)

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

@@ -1,8 +0,0 @@
-def below_threshold(l: list, t: int):
-    """Return True if all numbers in the list l are below threshold t.
-    >>> below_threshold([1, 2, 4, 10], 100)
-    True
-    >>> below_threshold([1, 20, 4, 10], 5)
-    False
-    """
-    return all(x < t for x in l)

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

@@ -1,8 +0,0 @@
-def add(x: int, y: int):
-    """Add two numbers x and y
-    >>> add(2, 3)
-    5
-    >>> add(5, 7)
-    12
-    """
-    return x + y

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

@@ -1,17 +0,0 @@
-def same_chars(s0: str, s1: str):
-    """
-    Check if two words have the same characters.
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
-    True
-    >>> same_chars('abcd', 'dddddddabc')
-    True
-    >>> same_chars('dddddddabc', 'abcd')
-    True
-    >>> same_chars('eabcd', 'dddddddabc')
-    False
-    >>> same_chars('abcd', 'dddddddabce')
-    False
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
-    False
-    """
-    return set(s0) == set(s1)

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

@@ -1,18 +0,0 @@
-def fib(n: int):
-    """Return n-th Fibonacci number.
-    >>> fib(10)
-    55
-    >>> fib(1)
-    1
-    >>> fib(8)
-    21
-    """
-    if n <= 0:
-        return 0
-    elif n == 1:
-        return 1
-    else:
-        a, b = 0, 1
-        for _ in range(2, n + 1):
-            a, b = b, a + b
-        return b

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

@@ -1,22 +0,0 @@
-def correct_bracketing(brackets: str):
-    """ brackets is a string of "<" and ">".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing("<")
-    False
-    >>> correct_bracketing("<>")
-    True
-    >>> correct_bracketing("<<><>>")
-    True
-    >>> correct_bracketing("><<>")
-    False
-    """
-    depth = 0
-    for bracket in brackets:
-        if bracket == "<":
-            depth += 1
-        elif bracket == ">":
-            depth -= 1
-        if depth < 0:
-            return False
-    return depth == 0

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

@@ -1,16 +0,0 @@
-def monotonic(l: list):
-    """Return True is list elements are monotonically increasing or decreasing.
-    >>> monotonic([1, 2, 4, 20])
-    True
-    >>> monotonic([1, 20, 4, 10])
-    False
-    >>> monotonic([4, 1, 0, -10])
-    True
-    """
-    if len(l) <= 2:
-        return True
-    
-    increasing = all(l[i] <= l[i + 1] for i in range(len(l) - 1))
-    decreasing = all(l[i] >= l[i + 1] for i in range(len(l) - 1))
-    
-    return increasing or decreasing

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

@@ -1,9 +0,0 @@
-def common(l1: list, l2: list):
-    """Return sorted unique common elements for two lists.
-    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
-    [1, 5, 653]
-    >>> common([5, 3, 2, 8], [3, 2])
-    [2, 3]
-
-    """
-    return sorted(set(l1) & set(l2))

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

@@ -1,22 +0,0 @@
-def largest_prime_factor(n: int):
-    """Return the largest prime factor of n. Assume n > 1 and is not a prime.
-    >>> largest_prime_factor(13195)
-    29
-    >>> largest_prime_factor(2048)
-    2
-    """
-    largest = 2
-    while n % 2 == 0:
-        n //= 2
-    
-    factor = 3
-    while factor * factor <= n:
-        while n % factor == 0:
-            largest = factor
-            n //= factor
-        factor += 2
-    
-    if n > 1:
-        largest = n
-    
-    return largest

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

@@ -1,26 +0,0 @@
-from typing import List
-
-
-def parse_nested_parens(paren_string: str) -> List[int]:
-    """ Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
-    For each of the group, output the deepest level of nesting of parentheses.
-    E.g. (()()) has maximum two levels of nesting while ((())) has three.
-
-    >>> parse_nested_parens('(()()) ((())) () ((())()())')
-    [2, 3, 1, 3]
-    """
-    result = []
-    groups = paren_string.split()
-    
-    for group in groups:
-        max_depth = 0
-        current_depth = 0
-        for char in group:
-            if char == '(':
-                current_depth += 1
-                max_depth = max(max_depth, current_depth)
-            elif char == ')':
-                current_depth -= 1
-        result.append(max_depth)
-    
-    return result