port-nuker 1.0.1 → 1.0.3

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

@@ -1,19 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/145.py

@@ -1,22 +0,0 @@
-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(abs(n))
-        total = 0
-        for i, digit in enumerate(s):
-            if i == 0 and n < 0:
-                total -= int(digit)
-            else:
-                total += int(digit)
-        return total
-    
-    return sorted(nums, key=digit_sum)

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

@@ -1,21 +0,0 @@
-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
-    """
-    count = 0
-    odd_digits = {'1', '3', '5', '7', '9'}
-    
-    for num in nums:
-        if num > 10:
-            num_str = str(num)
-            first_digit = num_str[0]
-            last_digit = num_str[-1]
-            
-            if first_digit in odd_digits and last_digit in odd_digits:
-                count += 1
-    
-    return count

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

@@ -1,22 +0,0 @@
-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).
-    """
-    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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/148.py

@@ -1,28 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/149.py

@@ -1,17 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/15.py

@@ -1,8 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/150.py

@@ -1,15 +0,0 @@
-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 < 2:
-        return y
-    for i in range(2, int(n ** 0.5) + 1):
-        if n % i == 0:
-            return y
-    return x

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

@@ -1,20 +0,0 @@
-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.
-    '''
-    if not lst:
-        return 0
-    
-    result = 0
-    for num in lst:
-        if isinstance(num, int) and not isinstance(num, bool) and num > 0 and num % 2 == 1:
-            result += num ** 2
-    return result

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

@@ -1,16 +0,0 @@
-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(guess, game)]

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

@@ -1,30 +0,0 @@
-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 = None
-    max_strength = None
-    
-    for ext in extensions:
-        cap = sum(1 for c in ext if c.isupper())
-        sm = sum(1 for c in ext if c.islower())
-        strength = cap - sm
-        
-        if max_strength is None or strength > max_strength:
-            max_strength = strength
-            strongest_ext = ext
-    
-    return f"{class_name}.{strongest_ext}"

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

@@ -1,15 +0,0 @@
-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
-
-    """
-    for i in range(len(b)):
-        rotation = b[i:] + b[:i]
-        if rotation in a:
-            return True
-    return False

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

@@ -1,15 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/156.py

@@ -1,32 +0,0 @@
-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'
-    """
-    val = [
-        1000, 900, 500, 400,
-        100, 90, 50, 40,
-        10, 9, 5, 4,
-        1
-    ]
-    syms = [
-        'm', 'cm', 'd', 'cd',
-        'c', 'xc', 'l', 'xl',
-        'x', 'ix', 'v', 'iv',
-        'i'
-    ]
-    
-    roman_num = ''
-    i = 0
-    while number > 0:
-        for _ in range(number // val[i]):
-            roman_num += syms[i]
-            number -= val[i]
-        i += 1
-    return roman_num

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

@@ -1,12 +0,0 @@
-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
-    '''
-    sides = sorted([a, b, c])
-    return sides[0]**2 + sides[1]**2 == sides[2]**2

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

@@ -1,11 +0,0 @@
-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 x: (-len(set(x)), x))[0]

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

@@ -1,33 +0,0 @@
-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 :)
-    """
-    if need <= remaining:
-        return [number + need, remaining - need]
-    else:
-        return [number + remaining, 0]

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

@@ -1,8 +0,0 @@
-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()))

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

@@ -1,29 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/161.py

@@ -1,24 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/162.py

@@ -1,11 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/163.py

@@ -1,14 +0,0 @@
-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) => []
-    """
-    lower = min(a, b)
-    upper = max(a, b)
-    even_digits = [2, 4, 6, 8]
-    return [d for d in even_digits if lower <= d <= upper]

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

@@ -1,27 +0,0 @@
-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_map = {
-        'o': 4,
-        'o|': 2,
-        '.|': 1
-    }
-    
-    notes = music_string.split()
-    return [note_map[note] for note in notes]

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

@@ -1,23 +0,0 @@
-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 substring or not string:
-        return 0
-    
-    count = 0
-    start = 0
-    
-    while True:
-        pos = string.find(substring, start)
-        if pos == -1:
-            break
-        count += 1
-        start = pos + 1
-    
-    return count

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

@@ -1,21 +0,0 @@
-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'
-    """
-    word_to_num = {
-        'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'four': 4,
-        'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9
-    }
-    
-    if not numbers.strip():
-        return ''
-    
-    words = numbers.split()
-    sorted_words = sorted(words, key=lambda x: word_to_num[x])
-    return ' '.join(sorted_words)

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

@@ -1,10 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/20.py

@@ -1,22 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/21.py

@@ -1,13 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/22.py

@@ -1,11 +0,0 @@
-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/.agent/skills/skills/loki-mode/benchmarks/results/2026-01-05-00-49-17/humaneval-solutions/23.py

@@ -1,8 +0,0 @@
-def strlen(string: str) -> int:
-    """ Return length of given string
-    >>> strlen('')
-    0
-    >>> strlen('abc')
-    3
-    """
-    return len(string)

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

@@ -1,9 +0,0 @@
-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 - 1, 0, -1):
-        if n % i == 0:
-            return i
-    return 1

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

@@ -1,24 +0,0 @@
-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 = []
-    divisor = 2
-    while divisor * divisor <= n:
-        while n % divisor == 0:
-            factors.append(divisor)
-            n //= divisor
-        divisor += 1
-    if n > 1:
-        factors.append(n)
-    return factors

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

@@ -1,12 +0,0 @@
-from typing import List
-
-
-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]
-    """
-    from collections import Counter
-    counts = Counter(numbers)
-    return [num for num in numbers if counts[num] == 1]