namnam-skills 1.0.3 → 1.0.4

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

@@ -0,0 +1,21 @@
+# HumanEval/0
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+
+
+def has_close_elements(numbers: List[float], threshold: float) -> bool:
+    """ Check if in given list of numbers, are any two numbers closer to each other than
+    given threshold.
+    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
+    False
+    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
+    True
+    """
+    for i in range(len(numbers)):
+        for j in range(i + 1, len(numbers)):
+            if abs(numbers[i] - numbers[j]) < threshold:
+                return True
+    return False

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

@@ -0,0 +1,36 @@
+# HumanEval/1
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+
+
+def separate_paren_groups(paren_string: str) -> List[str]:
+    """ Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
+    separate those group into separate strings and return the list of those.
+    Separate groups are balanced (each open brace is properly closed) and not nested within each other
+    Ignore any spaces in the input string.
+    >>> separate_paren_groups('( ) (( )) (( )( ))')
+    ['()', '(())', '(()())']
+    """
+    result = []
+    current_group = []
+    depth = 0
+    
+    for char in paren_string:
+        if char == ' ':
+            continue
+        
+        if char == '(':
+            depth += 1
+            current_group.append(char)
+        elif char == ')':
+            depth -= 1
+            current_group.append(char)
+            
+            if depth == 0:
+                result.append(''.join(current_group))
+                current_group = []
+    
+    return result

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

@@ -0,0 +1,30 @@
+# HumanEval/10
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def is_palindrome(string: str) -> bool:
+    """ Test if given string is a palindrome """
+    return string == string[::-1]
+
+
+def make_palindrome(string: str) -> str:
+    """ Find the shortest palindrome that begins with a supplied string.
+    Algorithm idea is simple:
+    - Find the longest postfix of supplied string that is a palindrome.
+    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
+    >>> make_palindrome('')
+    ''
+    >>> make_palindrome('cat')
+    'catac'
+    >>> make_palindrome('cata')
+    'catac'
+    """
+    if not string:
+        return ''
+    
+    for i in range(len(string)):
+        if is_palindrome(string[i:]):
+            return string + string[:i][::-1]
+    
+    return string

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

@@ -0,0 +1,23 @@
+# HumanEval/100
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def make_a_pile(n):
+    """
+    Given a positive integer n, you have to make a pile of n levels of stones.
+    The first level has n stones.
+    The number of stones in the next level is:
+        - the next odd number if n is odd.
+        - the next even number if n is even.
+    Return the number of stones in each level in a list, where element at index
+    i represents the number of stones in the level (i+1).
+
+    Examples:
+    >>> make_a_pile(3)
+    [3, 5, 7]
+    """
+    result = [n]
+    for _ in range(n - 1):
+        result.append(result[-1] + 2)
+    return result

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

@@ -0,0 +1,17 @@
+# HumanEval/101
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def words_string(s):
+    """
+    You will be given a string of words separated by commas or spaces. Your task is
+    to split the string into words and return an array of the words.
+    
+    For example:
+    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
+    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
+    """
+    if not s:
+        return []
+    return s.replace(",", " ").split()

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

@@ -0,0 +1,21 @@
+# HumanEval/102
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def choose_num(x, y):
+    """This function takes two positive numbers x and y and returns the
+    biggest even integer number that is in the range [x, y] inclusive. If 
+    there's no such number, then the function should return -1.
+
+    For example:
+    choose_num(12, 15) = 14
+    choose_num(13, 12) = -1
+    """
+    if x > y:
+        return -1
+    if y % 2 == 0:
+        return y
+    if y - 1 >= x:
+        return y - 1
+    return -1

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

@@ -0,0 +1,22 @@
+# HumanEval/103
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def rounded_avg(n, m):
+    """You are given two positive integers n and m, and your task is to compute the
+    average of the integers from n through m (including n and m). 
+    Round the answer to the nearest integer and convert that to binary.
+    If n is greater than m, return -1.
+    Example:
+    rounded_avg(1, 5) => "0b11"
+    rounded_avg(7, 5) => -1
+    rounded_avg(10, 20) => "0b1111"
+    rounded_avg(20, 33) => "0b11010"
+    """
+    if n > m:
+        return -1
+    count = m - n + 1
+    total = count * (n + m) // 2
+    avg = round(total / count)
+    return bin(avg)

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

@@ -0,0 +1,23 @@
+# HumanEval/104
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def unique_digits(x):
+    """Given a list of positive integers x. return a sorted list of all 
+    elements that hasn't any even digit.
+
+    Note: Returned list should be sorted in increasing order.
+    
+    For example:
+    >>> unique_digits([15, 33, 1422, 1])
+    [1, 15, 33]
+    >>> unique_digits([152, 323, 1422, 10])
+    []
+    """
+    even_digits = set("02468")
+    result = []
+    for num in x:
+        if not any(d in even_digits for d in str(num)):
+            result.append(num)
+    return sorted(result)

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

@@ -0,0 +1,34 @@
+# HumanEval/105
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def by_length(arr):
+    """
+    Given an array of integers, sort the integers that are between 1 and 9 inclusive,
+    reverse the resulting array, and then replace each digit by its corresponding name from
+    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
+
+    For example:
+      arr = [2, 1, 1, 4, 5, 8, 2, 3]   
+            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] 
+            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
+      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
+    
+      If the array is empty, return an empty array:
+      arr = []
+      return []
+    
+      If the array has any strange number ignore it:
+      arr = [1, -1 , 55] 
+            -> sort arr -> [-1, 1, 55]
+            -> reverse arr -> [55, 1, -1]
+      return = ['One']
+    """
+    names = ["One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"]
+    
+    filtered = [x for x in arr if 1 <= x <= 9]
+    filtered.sort()
+    filtered.reverse()
+    
+    return [names[x - 1] for x in filtered]

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

@@ -0,0 +1,26 @@
+# HumanEval/106
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def f(n):
+    """ Implement the function f that takes n as a parameter,
+    and returns a list of size n, such that the value of the element at index i is the factorial of i if i is even
+    or the sum of numbers from 1 to i otherwise.
+    i starts from 1.
+    the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
+    Example:
+    f(5) == [1, 2, 6, 24, 15]
+    """
+    result = []
+    for i in range(1, n + 1):
+        if i % 2 == 0:
+            # Even i: compute factorial
+            factorial = 1
+            for j in range(1, i + 1):
+                factorial *= j
+            result.append(factorial)
+        else:
+            # Odd i: compute sum from 1 to i
+            result.append(i * (i + 1) // 2)
+    return result

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

@@ -0,0 +1,40 @@
+# HumanEval/107
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def even_odd_palindrome(n):
+    """
+    Given a positive integer n, return a tuple that has the number of even and odd
+    integer palindromes that fall within the range(1, n), inclusive.
+
+    Example 1:
+
+        Input: 3
+        Output: (1, 2)
+        Explanation:
+        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
+
+    Example 2:
+
+        Input: 12
+        Output: (4, 6)
+        Explanation:
+        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
+
+    Note:
+        1. 1 <= n <= 10^3
+        2. returned tuple has the number of even and odd integer palindromes respectively.
+    """
+    even_count = 0
+    odd_count = 0
+    
+    for i in range(1, n + 1):
+        s = str(i)
+        if s == s[::-1]:
+            if i % 2 == 0:
+                even_count += 1
+            else:
+                odd_count += 1
+    
+    return (even_count, odd_count)

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

@@ -0,0 +1,27 @@
+# HumanEval/108
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def count_nums(arr):
+    """
+    Write a function count_nums which takes an array of integers and returns
+    the number of elements which has a sum of digits > 0.
+    If a number is negative, then its first signed digit will be negative:
+    e.g. -123 has signed digits -1, 2, and 3.
+    >>> count_nums([]) == 0
+    >>> count_nums([-1, 11, -11]) == 1
+    >>> count_nums([1, 1, 2]) == 3
+    """
+    count = 0
+    for num in arr:
+        if num == 0:
+            continue
+        is_negative = num < 0
+        num = abs(num)
+        digits = [int(d) for d in str(num)]
+        if is_negative:
+            digits[0] = -digits[0]
+        if sum(digits) > 0:
+            count += 1
+    return count

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

@@ -0,0 +1,53 @@
+# HumanEval/109
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def move_one_ball(arr):
+    """We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
+    numbers in the array will be randomly ordered. Your task is to determine if
+    it is possible to get an array sorted in non-decreasing order by performing 
+    the following operation on the given array:
+        You are allowed to perform right shift operation any number of times.
+    
+    One right shift operation means shifting all elements of the array by one
+    position in the right direction. The last element of the array will be moved to
+    the starting position in the array i.e. 0th index. 
+
+    If it is possible to obtain the sorted array by performing the above operation
+    then return True else return False.
+    If the given array is empty then return True.
+
+    Note: The given list is guaranteed to have unique elements.
+
+    For Example:
+    
+    move_one_ball([3, 4, 5, 1, 2])==>True
+    Explanation: By performin 2 right shift operations, non-decreasing order can
+                 be achieved for the given array.
+    move_one_ball([3, 5, 4, 1, 2])==>False
+    Explanation:It is not possible to get non-decreasing order for the given
+                array by performing any number of right shift operations.
+                
+    """
+    if len(arr) <= 1:
+        return True
+    
+    # Count the number of break points where arr[i] > arr[i+1]
+    break_count = 0
+    n = len(arr)
+    
+    for i in range(n - 1):
+        if arr[i] > arr[i + 1]:
+            break_count += 1
+    
+    # If already sorted, return True
+    if break_count == 0:
+        return True
+    
+    # If exactly one break point and the wrap-around is valid
+    # (last element <= first element), it can be rotated to sorted order
+    if break_count == 1 and arr[-1] <= arr[0]:
+        return True
+    
+    return False

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

@@ -0,0 +1,21 @@
+# HumanEval/11
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+from typing import List
+
+
+def string_xor(a: str, b: str) -> str:
+    """ Input are two strings a and b consisting only of 1s and 0s.
+    Perform binary XOR on these inputs and return result also as a string.
+    >>> string_xor('010', '110')
+    '100'
+    """
+    result = []
+    for char_a, char_b in zip(a, b):
+        if char_a == char_b:
+            result.append('0')
+        else:
+            result.append('1')
+    return ''.join(result)

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

@@ -0,0 +1,25 @@
+# HumanEval/110
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def exchange(lst1, lst2):
+    """In this problem, you will implement a function that takes two lists of numbers,
+    and determines whether it is possible to perform an exchange of elements
+    between them to make lst1 a list of only even numbers.
+    There is no limit on the number of exchanged elements between lst1 and lst2.
+    If it is possible to exchange elements between the lst1 and lst2 to make
+    all the elements of lst1 to be even, return "YES".
+    Otherwise, return "NO".
+    For example:
+    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
+    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
+    It is assumed that the input lists will be non-empty.
+    """
+    odds_in_lst1 = sum(1 for x in lst1 if x % 2 != 0)
+    evens_in_lst2 = sum(1 for x in lst2 if x % 2 == 0)
+    
+    if evens_in_lst2 >= odds_in_lst1:
+        return "YES"
+    else:
+        return "NO"

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

@@ -0,0 +1,34 @@
+# HumanEval/111
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def histogram(test):
+    """Given a string representing a space separated lowercase letters, return a dictionary
+    of the letter with the most repetition and containing the corresponding count.
+    If several letters have the same occurrence, return all of them.
+    
+    Example:
+    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
+    histogram('a b b a') == {'a': 2, 'b': 2}
+    histogram('a b c a b') == {'a': 2, 'b': 2}
+    histogram('b b b b a') == {'b': 4}
+    histogram('') == {}
+
+    """
+    if not test or not test.strip():
+        return {}
+    
+    letters = test.split()
+    counts = {}
+    
+    for letter in letters:
+        if letter:
+            counts[letter] = counts.get(letter, 0) + 1
+    
+    if not counts:
+        return {}
+    
+    max_count = max(counts.values())
+    
+    return {letter: count for letter, count in counts.items() if count == max_count}

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

@@ -0,0 +1,20 @@
+# HumanEval/112
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def reverse_delete(s,c):
+    """Task
+    We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c
+    then check if the result string is palindrome.
+    A string is called palindrome if it reads the same backward as forward.
+    You should return a tuple containing the result string and True/False for the check.
+    Example
+    For s = "abcde", c = "ae", the result should be ('bcd',False)
+    For s = "abcdef", c = "b"  the result should be ('acdef',False)
+    For s = "abcdedcba", c = "ab", the result should be ('cdedc',True)
+    """
+    chars_to_delete = set(c)
+    result = ''.join(char for char in s if char not in chars_to_delete)
+    is_palindrome = result == result[::-1]
+    return (result, is_palindrome)

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

@@ -0,0 +1,25 @@
+# HumanEval/113
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def odd_count(lst):
+    """Given a list of strings, where each string consists of only digits, return a list.
+    Each element i of the output should be "the number of odd elements in the
+    string i of the input." where all the i's should be replaced by the number
+    of odd digits in the i'th string of the input.
+
+    >>> odd_count(['1234567'])
+    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
+    >>> odd_count(['3',"11111111"])
+    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
+     "the number of odd elements 8n the str8ng 8 of the 8nput."]
+    """
+    result = []
+    for s in lst:
+        odd_digit_count = sum(1 for d in s if int(d) % 2 == 1)
+        count_str = str(odd_digit_count)
+        template = "the number of odd elements in the string i of the input."
+        formatted = template.replace('i', count_str)
+        result.append(formatted)
+    return result

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

@@ -0,0 +1,24 @@
+# HumanEval/114
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def minSubArraySum(nums):
+    """
+    Given an array of integers nums, find the minimum sum of any non-empty sub-array
+    of nums.
+    Example
+    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
+    minSubArraySum([-1, -2, -3]) == -6
+    """
+    if not nums:
+        return 0
+    
+    min_ending_here = nums[0]
+    min_so_far = nums[0]
+    
+    for i in range(1, len(nums)):
+        min_ending_here = min(nums[i], min_ending_here + nums[i])
+        min_so_far = min(min_so_far, min_ending_here)
+    
+    return min_so_far

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

@@ -0,0 +1,41 @@
+# HumanEval/115
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def max_fill(grid, capacity):
+    import math
+    """
+    You are given a rectangular grid of wells. Each row represents a single well,
+    and each 1 in a row represents a single unit of water.
+    Each well has a corresponding bucket that can be used to extract water from it, 
+    and all buckets have the same capacity.
+    Your task is to use the buckets to empty the wells.
+    Output the number of times you need to lower the buckets.
+
+    Example 1:
+        Input: 
+            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
+            bucket_capacity : 1
+        Output: 6
+
+    Example 2:
+        Input: 
+            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
+            bucket_capacity : 2
+        Output: 5
+    
+    Example 3:
+        Input: 
+            grid : [[0,0,0], [0,0,0]]
+            bucket_capacity : 5
+        Output: 0
+
+    Constraints:
+        * all wells have the same length
+        * 1 <= grid.length <= 10^2
+        * 1 <= grid[:,1].length <= 10^2
+        * grid[i][j] -> 0 | 1
+        * 1 <= capacity <= 10
+    """
+    return sum(math.ceil(sum(row) / capacity) for row in grid if sum(row) > 0)

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

@@ -0,0 +1,17 @@
+# HumanEval/116
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def sort_array(arr):
+    """
+    In this Kata, you have to sort an array of non-negative integers according to
+    number of ones in their binary representation in ascending order.
+    For similar number of ones, sort based on decimal value.
+
+    It must be implemented like this:
+    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
+    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
+    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
+    """
+    return sorted(arr, key=lambda x: (bin(x).count('1'), x))

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

@@ -0,0 +1,30 @@
+# HumanEval/117
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def select_words(s, n):
+    """Given a string s and a natural number n, you have been tasked to implement 
+    a function that returns a list of all words from string s that contain exactly 
+    n consonants, in order these words appear in the string s.
+    If the string s is empty then the function should return an empty list.
+    Note: you may assume the input string contains only letters and spaces.
+    Examples:
+    select_words("Mary had a little lamb", 4) ==> ["little"]
+    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
+    select_words("simple white space", 2) ==> []
+    select_words("Hello world", 4) ==> ["world"]
+    select_words("Uncle sam", 3) ==> ["Uncle"]
+    """
+    if not s:
+        return []
+    
+    vowels = "aeiouAEIOU"
+    result = []
+    
+    for word in s.split():
+        consonant_count = sum(1 for char in word if char.isalpha() and char not in vowels)
+        if consonant_count == n:
+            result.append(word)
+    
+    return result

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

@@ -0,0 +1,31 @@
+# HumanEval/118
+# Loki Mode Multi-Agent Solution
+# Attempts: 1
+# Passed: True
+
+def get_closest_vowel(word):
+    """You are given a word. Your task is to find the closest vowel that stands between 
+    two consonants from the right side of the word (case sensitive).
+    
+    Vowels in the beginning and ending doesn't count. Return empty string if you didn't
+    find any vowel met the above condition. 
+
+    You may assume that the given string contains English letter only.
+
+    Example:
+    get_closest_vowel("yogurt") ==> "u"
+    get_closest_vowel("FULL") ==> "U"
+    get_closest_vowel("quick") ==> ""
+    get_closest_vowel("ab") ==> ""
+    """
+    if len(word) < 3:
+        return ""
+    
+    vowels = set("aeiouAEIOU")
+    
+    for i in range(len(word) - 2, 0, -1):
+        if word[i] in vowels:
+            if word[i - 1] not in vowels and word[i + 1] not in vowels:
+                return word[i]
+    
+    return ""