namnam-skills 1.0.3 → 1.0.4

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/160.py

@@ -0,0 +1,34 @@
+# HumanEval/160
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def do_algebra(operator, operand):
+    """
+    Given two lists operator, and operand. The first list has basic algebra operations, and 
+    the second list is a list of integers. Use the two given lists to build the algebric 
+    expression and return the evaluation of this expression.
+
+    The basic algebra operations:
+    Addition ( + ) 
+    Subtraction ( - ) 
+    Multiplication ( * ) 
+    Floor division ( // ) 
+    Exponentiation ( ** ) 
+
+    Example:
+    operator['+', '*', '-']
+    array = [2, 3, 4, 5]
+    result = 2 + 3 * 4 - 5
+    => result = 9
+
+    Note:
+        The length of operator list is equal to the length of operand list minus one.
+        Operand is a list of of non-negative integers.
+        Operator list has at least one operator, and operand list has at least two operands.
+
+    """
+    expression = str(operand[0])
+    for i, op in enumerate(operator):
+        expression += op + str(operand[i + 1])
+    return eval(expression)

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/161.py

@@ -0,0 +1,29 @@
+# HumanEval/161
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def solve(s):
+    """You are given a string s.
+    if s[i] is a letter, reverse its case from lower to upper or vise versa, 
+    otherwise keep it as it is.
+    If the string contains no letters, reverse the string.
+    The function should return the resulted string.
+    Examples
+    solve("1234") = "4321"
+    solve("ab") = "AB"
+    solve("#a@C") = "#A@c"
+    """
+    has_letter = any(c.isalpha() for c in s)
+    
+    if not has_letter:
+        return s[::-1]
+    
+    result = []
+    for c in s:
+        if c.isalpha():
+            result.append(c.swapcase())
+        else:
+            result.append(c)
+    
+    return ''.join(result)

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/162.py

@@ -0,0 +1,16 @@
+# HumanEval/162
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def string_to_md5(text):
+    """
+    Given a string 'text', return its md5 hash equivalent string.
+    If 'text' is an empty string, return None.
+
+    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
+    """
+    if text == '':
+        return None
+    import hashlib
+    return hashlib.md5(text.encode()).hexdigest()

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/163.py

@@ -0,0 +1,18 @@
+# HumanEval/163
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def generate_integers(a, b):
+    """
+    Given two positive integers a and b, return the even digits between a
+    and b, in ascending order.
+
+    For example:
+    generate_integers(2, 8) => [2, 4, 6, 8]
+    generate_integers(8, 2) => [2, 4, 6, 8]
+    generate_integers(10, 14) => []
+    """
+    low, high = min(a, b), max(a, b)
+    even_digits = [2, 4, 6, 8]
+    return [d for d in even_digits if low <= d <= high]

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/17.py

@@ -0,0 +1,27 @@
+# HumanEval/17
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+
+
+def parse_music(music_string: str) -> List[int]:
+    """ Input to this function is a string representing musical notes in a special ASCII format.
+    Your task is to parse this string and return list of integers corresponding to how many beats does each
+    not last.
+
+    Here is a legend:
+    'o' - whole note, lasts four beats
+    'o|' - half note, lasts two beats
+    '.|' - quater note, lasts one beat
+
+    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
+    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
+    """
+    if not music_string:
+        return []
+    
+    note_beats = {'o': 4, 'o|': 2, '.|': 1}
+    tokens = music_string.split()
+    return [note_beats[token] for token in tokens if token]

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/18.py

@@ -0,0 +1,23 @@
+# HumanEval/18
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def how_many_times(string: str, substring: str) -> int:
+    """ Find how many times a given substring can be found in the original string. Count overlaping cases.
+    >>> how_many_times('', 'a')
+    0
+    >>> how_many_times('aaa', 'a')
+    3
+    >>> how_many_times('aaaa', 'aa')
+    3
+    """
+    if not string or not substring:
+        return 0
+    
+    count = 0
+    for i in range(len(string) - len(substring) + 1):
+        if string[i:i + len(substring)] == substring:
+            count += 1
+    
+    return count

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/19.py

@@ -0,0 +1,34 @@
+# HumanEval/19
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+
+
+def sort_numbers(numbers: str) -> str:
+    """ Input is a space-delimited string of numberals from 'zero' to 'nine'.
+    Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
+    Return the string with numbers sorted from smallest to largest
+    >>> sort_numbers('three one five')
+    'one three five'
+    """
+    if not numbers or not numbers.strip():
+        return ''
+    
+    word_to_num = {
+        'zero': 0,
+        'one': 1,
+        'two': 2,
+        'three': 3,
+        'four': 4,
+        'five': 5,
+        'six': 6,
+        'seven': 7,
+        'eight': 8,
+        'nine': 9
+    }
+    
+    words = numbers.split()
+    sorted_words = sorted(words, key=lambda w: word_to_num[w])
+    return ' '.join(sorted_words)

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/2.py

@@ -0,0 +1,15 @@
+# HumanEval/2
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def truncate_number(number: float) -> float:
+    """ Given a positive floating point number, it can be decomposed into
+    and integer part (largest integer smaller than given number) and decimals
+    (leftover part always smaller than 1).
+
+    Return the decimal part of the number.
+    >>> truncate_number(3.5)
+    0.5
+    """
+    return number - int(number)

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/20.py

@@ -0,0 +1,27 @@
+# HumanEval/20
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List, Tuple
+
+
+def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
+    """ From a supplied list of numbers (of length at least two) select and return two that are the closest to each
+    other and return them in order (smaller number, larger number).
+    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
+    (2.0, 2.2)
+    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
+    (2.0, 2.0)
+    """
+    sorted_numbers = sorted(numbers)
+    min_diff = float('inf')
+    closest_pair = (sorted_numbers[0], sorted_numbers[1])
+    
+    for i in range(len(sorted_numbers) - 1):
+        diff = sorted_numbers[i + 1] - sorted_numbers[i]
+        if diff < min_diff:
+            min_diff = diff
+            closest_pair = (sorted_numbers[i], sorted_numbers[i + 1])
+    
+    return closest_pair

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/21.py

@@ -0,0 +1,18 @@
+# HumanEval/21
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+
+
+def rescale_to_unit(numbers: List[float]) -> List[float]:
+    """ Given list of numbers (of at least two elements), apply a linear transform to that list,
+    such that the smallest number will become 0 and the largest will become 1
+    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
+    [0.0, 0.25, 0.5, 0.75, 1.0]
+    """
+    min_val = min(numbers)
+    max_val = max(numbers)
+    range_val = max_val - min_val
+    return [(x - min_val) / range_val for x in numbers]

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/22.py

@@ -0,0 +1,16 @@
+# HumanEval/22
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List, Any
+
+
+def filter_integers(values: List[Any]) -> List[int]:
+    """ Filter given list of any python values only for integers
+    >>> filter_integers(['a', 3.14, 5])
+    [5]
+    >>> filter_integers([1, 2, 3, 'abc', {}, []])
+    [1, 2, 3]
+    """
+    return [x for x in values if isinstance(x, int) and not isinstance(x, bool)]

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/23.py

@@ -0,0 +1,13 @@
+# HumanEval/23
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def strlen(string: str) -> int:
+    """ Return length of given string
+    >>> strlen('')
+    0
+    >>> strlen('abc')
+    3
+    """
+    return len(string)

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/24.py

@@ -0,0 +1,14 @@
+# HumanEval/24
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def largest_divisor(n: int) -> int:
+    """ For a given number n, find the largest number that divides n evenly, smaller than n
+    >>> largest_divisor(15)
+    5
+    """
+    for i in range(n // 2, 0, -1):
+        if n % i == 0:
+            return i
+    return 1

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/25.py

@@ -0,0 +1,29 @@
+# HumanEval/25
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+
+
+def factorize(n: int) -> List[int]:
+    """ Return list of prime factors of given integer in the order from smallest to largest.
+    Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
+    Input number should be equal to the product of all factors
+    >>> factorize(8)
+    [2, 2, 2]
+    >>> factorize(25)
+    [5, 5]
+    >>> factorize(70)
+    [2, 5, 7]
+    """
+    factors = []
+    d = 2
+    while d * d <= n:
+        while n % d == 0:
+            factors.append(d)
+            n //= d
+        d += 1
+    if n > 1:
+        factors.append(n)
+    return factors

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/26.py

@@ -0,0 +1,17 @@
+# HumanEval/26
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+from collections import Counter
+
+
+def remove_duplicates(numbers: List[int]) -> List[int]:
+    """ From a list of integers, remove all elements that occur more than once.
+    Keep order of elements left the same as in the input.
+    >>> remove_duplicates([1, 2, 3, 2, 4])
+    [1, 3, 4]
+    """
+    counts = Counter(numbers)
+    return [num for num in numbers if counts[num] == 1]

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/27.py

@@ -0,0 +1,11 @@
+# HumanEval/27
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/28.py

@@ -0,0 +1,16 @@
+# HumanEval/28
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/29.py

@@ -0,0 +1,16 @@
+# HumanEval/29
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/3.py

@@ -0,0 +1,23 @@
+# HumanEval/3
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/30.py

@@ -0,0 +1,13 @@
+# HumanEval/30
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/31.py

@@ -0,0 +1,34 @@
+# HumanEval/31
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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 <= 1:
+        return False
+    if n == 2:
+        return True
+    if n % 2 == 0:
+        return False
+    i = 3
+    while i * i <= n:
+        if n % i == 0:
+            return False
+        i += 2
+    return True

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/32.py

@@ -0,0 +1,37 @@
+# HumanEval/32
+# Loki Mode Multi-Agent Solution
+# Attempts: 3
+# Passed: False
+
+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
+    """
+    # Find initial bounds where polynomial changes sign
+    low, high = -1000.0, 1000.0
+    
+    # Ensure we have opposite signs at bounds
+    while poly(xs, low) * poly(xs, high) > 0:
+        low *= 2
+        high *= 2
+    
+    # Binary search (bisection method)
+    tolerance = 1e-10
+    while high - low > tolerance:
+        mid = (low + high) / 2
+        if poly(xs, mid) == 0:
+            return mid
+        if poly(xs, low) * poly(xs, mid) < 0:
+            high = mid
+        else:
+            low = mid
+    
+    return (low + high) / 2

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/33.py

@@ -0,0 +1,19 @@
+# HumanEval/33
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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]
+    """
+    third_indices_values = sorted([l[i] for i in range(0, len(l), 3)])
+    result = l[:]
+    for idx, val in enumerate(third_indices_values):
+        result[idx * 3] = val
+    return result

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/34.py

@@ -0,0 +1,11 @@
+# HumanEval/34
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/35.py

@@ -0,0 +1,13 @@
+# HumanEval/35
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/36.py

@@ -0,0 +1,19 @@
+# HumanEval/36
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/37.py

@@ -0,0 +1,19 @@
+# HumanEval/37
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+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_elements = sorted(l[::2])
+    result = l[:]
+    for i, val in enumerate(even_elements):
+        result[i * 2] = val
+    return result

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/38.py

@@ -0,0 +1,25 @@
+# HumanEval/38
+# Loki Mode Multi-Agent Solution
+# Attempts: 2
+# Passed: True
+
+def encode_cyclic(s: str):
+    """
+    returns encoded string by cycling groups of three characters.
+    """
+    # 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)]
+    # cycle elements in each group. Unless group has fewer elements than 3.
+    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
+    return "".join(groups)
+
+
+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)]
+    # cycle elements in each group back to original. Unless group has fewer elements than 3.
+    groups = [(group[-1] + group[:-1]) if len(group) == 3 else group for group in groups]
+    return "".join(groups)

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/humaneval-loki-solutions/39.py

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