wegho-agentes 7.0.4 → 7.0.6

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

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

@@ -1,23 +0,0 @@
-# HumanEval/139
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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
-    current_factorial = 1
-    for k in range(1, n + 1):
-        current_factorial *= k
-        result *= current_factorial
-    return result

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

@@ -1,14 +0,0 @@
-# HumanEval/14
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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] for i in range(1, len(string) + 1)]

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

@@ -1,26 +0,0 @@
-# HumanEval/140
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-import re
-
-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"
-    """
-    def replace_spaces(match):
-        spaces = match.group(0)
-        if len(spaces) > 2:
-            return '-'
-        else:
-            return '_' * len(spaces)
-    
-    return re.sub(r' +', replace_spaces, text)

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

@@ -1,42 +0,0 @@
-# HumanEval/141
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 by dot
-    parts = file_name.split('.')
-    prefix = parts[0]
-    suffix = parts[1]
-    
-    # Check prefix is non-empty and starts with a letter
-    if len(prefix) == 0 or not prefix[0].isalpha():
-        return 'No'
-    
-    # Check suffix is valid
-    if suffix not in ['txt', 'exe', 'dll']:
-        return 'No'
-    
-    # Count digits in entire filename
-    digit_count = sum(1 for c in file_name if c.isdigit())
-    if digit_count > 3:
-        return 'No'
-    
-    return 'Yes'

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

@@ -1,25 +0,0 @@
-# HumanEval/142
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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 in range(len(lst)):
-        if i % 3 == 0:
-            result += lst[i] ** 2
-        elif i % 4 == 0:
-            result += lst[i] ** 3
-        else:
-            result += lst[i]
-    return result

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

@@ -1,40 +0,0 @@
-# HumanEval/143
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-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)

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

@@ -1,24 +0,0 @@
-# HumanEval/144
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def simplify(x, n):
-    """Your task is to implement a function that will simplify the expression
-    x * n. The function returns True if x * n evaluates to a whole number and False
-    otherwise. Both x and n, are string representation of a fraction, and have the following format,
-    <numerator>/<denominator> where both numerator and denominator are positive whole numbers.
-
-    You can assume that x, and n are valid fractions, and do not have zero as denominator.
-
-    simplify("1/5", "5/1") = True
-    simplify("1/6", "2/1") = False
-    simplify("7/10", "10/2") = False
-    """
-    x_num, x_den = map(int, x.split('/'))
-    n_num, n_den = map(int, n.split('/'))
-    
-    numerator = x_num * n_num
-    denominator = x_den * n_den
-    
-    return numerator % denominator == 0

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

@@ -1,24 +0,0 @@
-# HumanEval/145
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def order_by_points(nums):
-    """
-    Write a function which sorts the given list of integers
-    in ascending order according to the sum of their digits.
-    Note: if there are several items with similar sum of their digits,
-    order them based on their index in original list.
-
-    For example:
-    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
-    >>> order_by_points([]) == []
-    """
-    def digit_sum(n):
-        s = str(n)
-        if s[0] == '-':
-            return -int(s[1]) + sum(int(d) for d in s[2:])
-        else:
-            return sum(int(d) for d in s)
-    
-    return sorted(nums, key=digit_sum)

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

@@ -1,21 +0,0 @@
-# HumanEval/146
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def specialFilter(nums):
-    """Write a function that takes an array of numbers as input and returns 
-    the number of elements in the array that are greater than 10 and both 
-    first and last digits of a number are odd (1, 3, 5, 7, 9).
-    For example:
-    specialFilter([15, -73, 14, -15]) => 1 
-    specialFilter([33, -2, -3, 45, 21, 109]) => 2
-    """
-    odd_digits = {'1', '3', '5', '7', '9'}
-    count = 0
-    for num in nums:
-        if num > 10:
-            s = str(num)
-            if s[0] in odd_digits and s[-1] in odd_digits:
-                count += 1
-    return count

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

@@ -1,32 +0,0 @@
-# HumanEval/147
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def get_max_triples(n):
-    """
-    You are given a positive integer n. You have to create an integer array a of length n.
-        For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-        Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, 
-    and a[i] + a[j] + a[k] is a multiple of 3.
-
-    Example :
-        Input: n = 5
-        Output: 1
-        Explanation: 
-        a = [1, 3, 7, 13, 21]
-        The only valid triple is (1, 7, 13).
-    """
-    if n < 3:
-        return 0
-    
-    a = [i * i - i + 1 for i in range(1, n + 1)]
-    
-    count = 0
-    for i in range(n):
-        for j in range(i + 1, n):
-            for k in range(j + 1, n):
-                if (a[i] + a[j] + a[k]) % 3 == 0:
-                    count += 1
-    
-    return count

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

@@ -1,33 +0,0 @@
-# HumanEval/148
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def bf(planet1, planet2):
-    '''
-    There are eight planets in our solar system: the closerst to the Sun 
-    is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, 
-    Uranus, Neptune.
-    Write a function that takes two planet names as strings planet1 and planet2. 
-    The function should return a tuple containing all planets whose orbits are 
-    located between the orbit of planet1 and the orbit of planet2, sorted by 
-    the proximity to the sun. 
-    The function should return an empty tuple if planet1 or planet2
-    are not correct planet names. 
-    Examples
-    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
-    bf("Earth", "Mercury") ==> ("Venus")
-    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
-    '''
-    planets = ("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
-    
-    if planet1 not in planets or planet2 not in planets:
-        return ()
-    
-    idx1 = planets.index(planet1)
-    idx2 = planets.index(planet2)
-    
-    if idx1 > idx2:
-        idx1, idx2 = idx2, idx1
-    
-    return planets[idx1 + 1:idx2]

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

@@ -1,22 +0,0 @@
-# HumanEval/149
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def sorted_list_sum(lst):
-    """Write a function that accepts a list of strings as a parameter,
-    deletes the strings that have odd lengths from it,
-    and returns the resulted list with a sorted order,
-    The list is always a list of strings and never an array of numbers,
-    and it may contain duplicates.
-    The order of the list should be ascending by length of each word, and you
-    should return the list sorted by that rule.
-    If two words have the same length, sort the list alphabetically.
-    The function should return a list of strings in sorted order.
-    You may assume that all words will have the same length.
-    For example:
-    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
-    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
-    """
-    filtered = [s for s in lst if len(s) % 2 == 0]
-    return sorted(filtered, key=lambda x: (len(x), x))

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

@@ -1,13 +0,0 @@
-# HumanEval/15
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def string_sequence(n: int) -> str:
-    """ Return a string containing space-delimited numbers starting from 0 upto n inclusive.
-    >>> string_sequence(0)
-    '0'
-    >>> string_sequence(5)
-    '0 1 2 3 4 5'
-    """
-    return ' '.join(str(i) for i in range(n + 1))

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

@@ -1,26 +0,0 @@
-# HumanEval/150
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def x_or_y(n, x, y):
-    """A simple program which should return the value of x if n is 
-    a prime number and should return the value of y otherwise.
-
-    Examples:
-    for x_or_y(7, 34, 12) == 34
-    for x_or_y(15, 8, 5) == 5
-    
-    """
-    if n <= 1:
-        return y
-    if n == 2:
-        return x
-    if n % 2 == 0:
-        return y
-    i = 3
-    while i * i <= n:
-        if n % i == 0:
-            return y
-        i += 2
-    return x

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

@@ -1,22 +0,0 @@
-# HumanEval/151
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def double_the_difference(lst):
-    '''
-    Given a list of numbers, return the sum of squares of the numbers
-    in the list that are odd. Ignore numbers that are negative or not integers.
-    
-    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-    double_the_difference([-1, -2, 0]) == 0
-    double_the_difference([9, -2]) == 81
-    double_the_difference([0]) == 0  
-   
-    If the input list is empty, return 0.
-    '''
-    total = 0
-    for n in lst:
-        if isinstance(n, int) and not isinstance(n, bool) and n > 0 and n % 2 != 0:
-            total += n * n
-    return total

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

@@ -1,21 +0,0 @@
-# HumanEval/152
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def compare(game,guess):
-    """I think we all remember that feeling when the result of some long-awaited
-    event is finally known. The feelings and thoughts you have at that moment are
-    definitely worth noting down and comparing.
-    Your task is to determine if a person correctly guessed the results of a number of matches.
-    You are given two arrays of scores and guesses of equal length, where each index shows a match. 
-    Return an array of the same length denoting how far off each guess was. If they have guessed correctly,
-    the value is 0, and if not, the value is the absolute difference between the guess and the score.
-    
-    
-    example:
-
-    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
-    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
-    """
-    return [abs(g - s) for g, s in zip(game, guess)]

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

@@ -1,32 +0,0 @@
-# HumanEval/153
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def Strongest_Extension(class_name, extensions):
-    """You will be given the name of a class (a string) and a list of extensions.
-    The extensions are to be used to load additional classes to the class. The
-    strength of the extension is as follows: Let CAP be the number of the uppercase
-    letters in the extension's name, and let SM be the number of lowercase letters 
-    in the extension's name, the strength is given by the fraction CAP - SM. 
-    You should find the strongest extension and return a string in this 
-    format: ClassName.StrongestExtensionName.
-    If there are two or more extensions with the same strength, you should
-    choose the one that comes first in the list.
-    For example, if you are given "Slices" as the class and a list of the
-    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
-    return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension 
-    (its strength is -1).
-    Example:
-    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
-    """
-    strongest_ext = extensions[0]
-    max_strength = sum(1 for c in strongest_ext if c.isupper()) - sum(1 for c in strongest_ext if c.islower())
-    
-    for ext in extensions[1:]:
-        strength = sum(1 for c in ext if c.isupper()) - sum(1 for c in ext if c.islower())
-        if strength > max_strength:
-            max_strength = strength
-            strongest_ext = ext
-    
-    return f"{class_name}.{strongest_ext}"

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

@@ -1,25 +0,0 @@
-# HumanEval/154
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def cycpattern_check(a , b):
-    """You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
-    cycpattern_check("abcd","abd") => False
-    cycpattern_check("hello","ell") => True
-    cycpattern_check("whassup","psus") => False
-    cycpattern_check("abab","baa") => True
-    cycpattern_check("efef","eeff") => False
-    cycpattern_check("himenss","simen") => True
-
-    """
-    if len(b) == 0:
-        return True
-    if len(b) > len(a):
-        return False
-    
-    for i in range(len(b)):
-        rotation = b[i:] + b[:i]
-        if rotation in a:
-            return True
-    return False

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

@@ -1,20 +0,0 @@
-# HumanEval/155
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def even_odd_count(num):
-    """Given an integer. return a tuple that has the number of even and odd digits respectively.
-
-     Example:
-        even_odd_count(-12) ==> (1, 1)
-        even_odd_count(123) ==> (1, 2)
-    """
-    even_count = 0
-    odd_count = 0
-    for digit in str(abs(num)):
-        if int(digit) % 2 == 0:
-            even_count += 1
-        else:
-            odd_count += 1
-    return (even_count, odd_count)

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

@@ -1,39 +0,0 @@
-# HumanEval/156
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def int_to_mini_roman(number):
-    """
-    Given a positive integer, obtain its roman numeral equivalent as a string,
-    and return it in lowercase.
-    Restrictions: 1 <= num <= 1000
-
-    Examples:
-    >>> int_to_mini_roman(19) == 'xix'
-    >>> int_to_mini_roman(152) == 'clii'
-    >>> int_to_mini_roman(426) == 'cdxxvi'
-    """
-    value_symbol_pairs = [
-        (1000, 'm'),
-        (900, 'cm'),
-        (500, 'd'),
-        (400, 'cd'),
-        (100, 'c'),
-        (90, 'xc'),
-        (50, 'l'),
-        (40, 'xl'),
-        (10, 'x'),
-        (9, 'ix'),
-        (5, 'v'),
-        (4, 'iv'),
-        (1, 'i')
-    ]
-    
-    result = ''
-    for value, symbol in value_symbol_pairs:
-        while number >= value:
-            result += symbol
-            number -= value
-    
-    return result

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

@@ -1,28 +0,0 @@
-# HumanEval/157
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def right_angle_triangle(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return True if the three
-    sides form a right-angled triangle, False otherwise.
-    A right-angled triangle is a triangle in which one angle is right angle or 
-    90 degree.
-    Example:
-    right_angle_triangle(3, 4, 5) == True
-    right_angle_triangle(1, 2, 3) == False
-    '''
-    epsilon = 1e-9
-    a_sq = a * a
-    b_sq = b * b
-    c_sq = c * c
-    
-    if abs(a_sq + b_sq - c_sq) < epsilon:
-        return True
-    if abs(a_sq + c_sq - b_sq) < epsilon:
-        return True
-    if abs(b_sq + c_sq - a_sq) < epsilon:
-        return True
-    
-    return False

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

@@ -1,16 +0,0 @@
-# HumanEval/158
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def find_max(words):
-    """Write a function that accepts a list of strings.
-    The list contains different words. Return the word with maximum number
-    of unique characters. If multiple strings have maximum number of unique
-    characters, return the one which comes first in lexicographical order.
-
-    find_max(["name", "of", "string"]) == "string"
-    find_max(["name", "enam", "game"]) == "enam"
-    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
-    """
-    return sorted(words, key=lambda w: (-len(set(w)), w))[0]

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

@@ -1,36 +0,0 @@
-# HumanEval/159
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def eat(number, need, remaining):
-    """
-    You're a hungry rabbit, and you already have eaten a certain number of carrots,
-    but now you need to eat more carrots to complete the day's meals.
-    you should return an array of [ total number of eaten carrots after your meals,
-                                    the number of carrots left after your meals ]
-    if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
-    
-    Example:
-    * eat(5, 6, 10) -> [11, 4]
-    * eat(4, 8, 9) -> [12, 1]
-    * eat(1, 10, 10) -> [11, 0]
-    * eat(2, 11, 5) -> [7, 0]
-    
-    Variables:
-    @number : integer
-        the number of carrots that you have eaten.
-    @need : integer
-        the number of carrots that you need to eat.
-    @remaining : integer
-        the number of remaining carrots thet exist in stock
-    
-    Constrain:
-    * 0 <= number <= 1000
-    * 0 <= need <= 1000
-    * 0 <= remaining <= 1000
-
-    Have fun :)
-    """
-    actual_eaten = min(need, remaining)
-    return [number + actual_eaten, remaining - actual_eaten]

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

@@ -1,13 +0,0 @@
-# HumanEval/16
-# Loki Mode Multi-Agent Solution
-# Attempts: 1
-# Passed: True
-
-def count_distinct_characters(string: str) -> int:
-    """ Given a string, find out how many distinct characters (regardless of case) does it consist of
-    >>> count_distinct_characters('xyzXYZ')
-    3
-    >>> count_distinct_characters('Jerry')
-    4
-    """
-    return len(set(string.lower()))