Take a list of integers; drop the zeros, then keep only even values, then remove from the first zero onwards.


Take a list of integers; keep only nonzero elements, then extract all even numbers, then up to but not including the first zero.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x != 0]
    r = [x for x in r if x % 2 == 0]
    r = r[:r.index(0)] if 0 in r else r
    return r


Take a list of integers; drop the zeros, then keep the even numbers, then keep everything before the first zero.


Take a list of integers; square each, then extend to length 3 using zeros, then skip the first one.


Take a list of integers; each value squared, then pad to 3, then Discard the first element.


Take a list of integers; multiply each value by itself, then extend to length 3 using zeros, then skip the first one.


Take a list of integers; square them all, then pad to 3, then Discard the first element.


Take a list of integers; raise each to the power of two, then extend to length 3 using zeros, then skip the first one.


Take a list of integers; I need each number multiplied by itself, then pad to 3, then Discard the first element.


def solve(xs):
    r = list(xs)
    r = [x * x for x in r]
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = r[1:]
    return r


Take a list of integers; square each, then pad with zeros to at least three elements, then drop the first element.


Take a list of integers; keep only the first three, then default to [0] when there is nothing, then arrange in decreasing order.


Take a list of integers; keep the first 3 items, then when the list is empty, substitute a zero value, then arrange in descending order.


Take a list of integers; take the first 3 elements, then replace an empty list with one zero, then reverse sort.


Take a list of integers; remove everything after the third, then zero it out if it's empty, then sort largest to smallest.


Take a list of integers; truncate to three items, then use zero if the list is empty, then sort by descending values.


Take a list of integers; show the first three, then default to zero when empty, then sort from highest to lowest.


def solve(xs):
    r = list(xs)
    r = r[:3]
    r = r if r else [0]
    r = sorted(r, reverse=True)
    return r


Take a list of integers; keep only the first three, then if empty, use a single zero, then sort descending.


Take a list of integers; add one to each, then remove all zero values, then true only if all are positive.


Take a list of integers; make each one bigger, then exclude zeros, then do all of these have positive values.


Take a list of integers; add one to each, then remove all zero values, then check if every value is positive.


Take a list of integers; make each one bigger, then exclude zeros, then confirm all values are positive.


Take a list of integers; add one to each, then remove all zero values, then all positive.


Take a list of integers; make each one bigger, then exclude zeros, then check if every number is above zero.


def solve(xs):
    r = list(xs)
    r = [x + 1 for x in r]
    r = [x for x in r if x != 0]
    return all(x > 0 for x in r)


Take a list of integers; add one to each, then drop the zeros, then return whether all values are positive.


Take a list of integers; keep multiples of three, then flip the list around, then true if at least one even value.


Take a list of integers; get rid of non-multiples of three, then flip the order around, then any even.


Take a list of integers; keep values divisible by 3, then put the elements backwards, then true if at least one even value.


Take a list of integers; keep items where x mod 3 equals zero, then reverse that for me, then any even.


Take a list of integers; drop anything not divisible by three, then flip it backwards, then true if at least one even value.


Take a list of integers; filter out everything except multiples of three, then make it backwards, then any even.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x % 3 == 0]
    r = list(reversed(r))
    return any(x % 2 == 0 for x in r)


Take a list of integers; keep multiples of three, then reverse the order, then return whether any value is even.


Take a list of integers; drop the first and last elements, then order by distance from zero, then true if every value is unique.


Take a list of integers; take out the first and last items, then sort based on absolute value, then check for duplicates in the values.


Take a list of integers; remove both ends, then organize by magnitude, then do all values appear only once.


Take a list of integers; trim the edges, then arrange by absolute value ascending, then check that there are no duplicates.


Take a list of integers; trim one element off each end, then sort from smallest to largest absolute value, then are the values all unique.


Take a list of integers; cut off the first and last, then sort by absolute value, then check if all values are unique.


def solve(xs):
    r = list(xs)
    r = r[1:-1]
    r = sorted(r, key=abs)
    return len(r) == len(set(r))


Take a list of integers; drop the first and last elements, then sort by absolute value, then return whether all values are distinct.


Take a list of integers; add one to each, then extend to length 3 using zeros, then drop anything not divisible by three.


Take a list of integers; make each one bigger, then pad to 3, then filter out everything except multiples of three.


Take a list of integers; add one to each, then extend to length 3 using zeros, then keep only multiples of three.


Take a list of integers; make each one bigger, then pad to 3, then multiples of three only.


Take a list of integers; add one to each, then extend to length 3 using zeros, then filter for numbers divisible by three.


Take a list of integers; make each one bigger, then pad to 3, then give me only the values divisible by three.


def solve(xs):
    r = list(xs)
    r = [x + 1 for x in r]
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [x for x in r if x % 3 == 0]
    return r


Take a list of integers; add one to each, then pad with zeros to at least three elements, then keep multiples of three.


Take a list of integers; drop the first element, then skip negatives at the start, then arrange in increasing order.


Take a list of integers; Take everything except the first, then remove all negatives at the front, then Organize these ascending.


Take a list of integers; drop the first element, then remove the initial run of negative numbers, then Sort in ascending order.


Take a list of integers; Take everything except the first, then strip the front negatives, then I need this sorted ascending.


Take a list of integers; drop the first element, then remove leading negative numbers, then Put these in ascending order.


Take a list of integers; Take everything except the first, then drop negatives from start, then sort smallest to largest.


def solve(xs):
    r = list(xs)
    r = r[1:]
    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]
    r = sorted(r)
    return r


Take a list of integers; drop the first element, then drop the leading negative values, then sort ascending.


Take a list of integers; add ten to each, then drop anything 5 or below, then strip the signs.


Take a list of integers; bump everything up by 10, then keep only numbers greater than 5, then take abs of each.


Take a list of integers; increase every value by 10, then filter for numbers above 5, then get the absolute value of everything.


Take a list of integers; add 10 to each item, then give me values where x is greater than 5, then apply absolute value to the whole list.


Take a list of integers; shift each up by ten, then show me only the values that are bigger than five, then make them all positive.


Take a list of integers; increase all numbers by 10, then keep values greater than five, then make every value non-negative.


def solve(xs):
    r = list(xs)
    r = [x + 10 for x in r]
    r = [x for x in r if x > 5]
    r = [abs(x) for x in r]
    return r


Take a list of integers; add ten to each, then keep values greater than five, then take the absolute value of each.


Take a list of integers; negate each, then increase every value by 10, then bump each up by one.


Take a list of integers; reverse the signs of everything, then add 10 to each item, then increment each item.


Take a list of integers; negate each, then shift each up by ten, then bump each up by one.


Take a list of integers; reverse the signs of everything, then increase all numbers by 10, then increment each item.


Take a list of integers; negate each, then add 10 to everything, then bump each up by one.


Take a list of integers; reverse the signs of everything, then give everything a boost of 10, then increment each item.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = [x + 10 for x in r]
    r = [x + 1 for x in r]
    return r


Take a list of integers; negate each, then add ten to each, then add one to each.


Take a list of integers; drop the first and last elements, then sort largest to smallest, then find the min, defaulting to 0.


Take a list of integers; take out the first and last items, then sort by descending values, then minimum value, zero otherwise.


Take a list of integers; remove both ends, then sort from highest to lowest, then get the minimum value or zero if empty.


Take a list of integers; trim the edges, then sort descending, then give me the min or 0.


Take a list of integers; trim one element off each end, then sort largest first, then return the smallest number, defaulting to 0.


Take a list of integers; cut off the first and last, then sort in descending order, then return smallest or zero if empty.


def solve(xs):
    r = list(xs)
    r = r[1:-1]
    r = sorted(r, reverse=True)
    return min(r) if r else 0


Take a list of integers; drop the first and last elements, then sort descending, then return the minimum (0 if empty).


Take a list of integers; take the absolute value of each, then extend to length 3 using zeros, then drop non-negative values.


Take a list of integers; convert to absolute value, then pad to 3, then drop all positive numbers.


Take a list of integers; strip the signs, then extend to length 3 using zeros, then drop non-negative values.


Take a list of integers; take abs of each, then pad to 3, then drop all positive numbers.


Take a list of integers; get the absolute value of everything, then extend to length 3 using zeros, then drop non-negative values.


Take a list of integers; apply absolute value to the whole list, then pad to 3, then drop all positive numbers.


def solve(xs):
    r = list(xs)
    r = [abs(x) for x in r]
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [x for x in r if x < 0]
    return r


Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then keep the negative numbers.


Take a list of integers; keep values greater than five, then order by distance from zero, then remove the initial run of negative numbers.


Take a list of integers; filter out values less than or equal to 5, then sort based on absolute value, then strip the front negatives.


Take a list of integers; keep only numbers above 5, then organize by magnitude, then remove leading negative numbers.


Take a list of integers; exclude values of 5 and below, then arrange by absolute value ascending, then drop negatives from start.


Take a list of integers; remove anything 5 or less, then sort from smallest to largest absolute value, then strip negative values from the start.


Take a list of integers; filter to keep only values above 5, then sort by absolute value, then remove negatives before the first non-negative.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x > 5]
    r = sorted(r, key=abs)
    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]
    return r


Take a list of integers; keep values greater than five, then sort by absolute value, then drop the leading negative values.


Take a list of people records (name, age); extract the ages, then default to [0] when there is nothing, then truncate to three items.


Take a list of people records (name, age); show me all ages, then when the list is empty, substitute a zero value, then show the first three.


Take a list of people records (name, age); pluck the age field from each record, then replace an empty list with one zero, then take the first three.


Take a list of people records (name, age); get the age field, then zero it out if it's empty, then keep first 3.


Take a list of people records (name, age); keep just each person's age, then use zero if the list is empty, then truncate to first three.


Take a list of people records (name, age); extract age values, then default to zero when empty, then first three.


def solve(xs):
    r = list(xs)
    r = [d['age'] for d in r]
    r = r if r else [0]
    r = r[:3]
    return r


Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then keep only the first three.


Take a list of integers; negate each, then extend to length 3 using zeros, then drop non-negative values.


Take a list of integers; reverse the signs of everything, then pad to 3, then drop all positive numbers.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [x for x in r if x < 0]
    return r


Take a list of integers; negate each, then pad with zeros to at least three elements, then keep the negative numbers.


Take a list of integers; keep values greater than five, then increase every value by 10, then truncate to the last three items.


Take a list of integers; filter out values less than or equal to 5, then add 10 to each item, then show only the last three.


Take a list of integers; keep only numbers above 5, then shift each up by ten, then remove all but the last three.


Take a list of integers; exclude values of 5 and below, then increase all numbers by 10, then take the final 3 elements.


Take a list of integers; remove anything 5 or less, then add 10 to everything, then drop everything except the final three.


Take a list of integers; filter to keep only values above 5, then give everything a boost of 10, then give me the last three elements.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x > 5]
    r = [x + 10 for x in r]
    r = r[-3:]
    return r


Take a list of integers; keep values greater than five, then add ten to each, then keep only the last three.


Take a list of integers; pad with zeros to at least three elements, then flip the sign of each, then truncate to three items.


Take a list of integers; add zeros until the list has at least three values, then turn positives to negatives and vice versa, then show the first three.


Take a list of integers; pad with zeros to at least three elements, then flip the sign of each, then take the first three.


Take a list of integers; add zeros until the list has at least three values, then turn positives to negatives and vice versa, then keep first 3.


Take a list of integers; pad with zeros to at least three elements, then flip the sign of each, then truncate to first three.


Take a list of integers; add zeros until the list has at least three values, then turn positives to negatives and vice versa, then first three.


def solve(xs):
    r = list(xs)
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [-x for x in r]
    r = r[:3]
    return r


Take a list of integers; pad with zeros to at least three elements, then negate each, then keep only the first three.


Take a list of integers; sort ascending, then clamp each to at most ten, then stop at the first non-positive value.


Take a list of integers; Sort it from low to high, then don't let anything exceed 10, then keep the leading run of positive numbers.


Take a list of integers; arrange in increasing order, then clamp each to at most ten, then take values while they are positive.


Take a list of integers; Organize these ascending, then don't let anything exceed 10, then take positive values then stop.


Take a list of integers; Sort in ascending order, then clamp each to at most ten, then keep going while positive.


Take a list of integers; I need this sorted ascending, then don't let anything exceed 10, then stop at first non positive.


def solve(xs):
    r = list(xs)
    r = sorted(r)
    r = [min(x, 10) for x in r]
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    return r


Take a list of integers; sort ascending, then cap each value at 10, then take values while they are positive.


Take a list of integers; negate each, then keep only odd values, then drop anything not divisible by three.


Take a list of integers; reverse the signs of everything, then eliminate the even numbers, then filter out everything except multiples of three.


Take a list of integers; negate each, then keep only odd values, then keep only multiples of three.


Take a list of integers; reverse the signs of everything, then eliminate the even numbers, then multiples of three only.


Take a list of integers; negate each, then keep only odd values, then filter for numbers divisible by three.


Take a list of integers; reverse the signs of everything, then eliminate the even numbers, then give me only the values divisible by three.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = [x for x in r if x % 2 != 0]
    r = [x for x in r if x % 3 == 0]
    return r


Take a list of integers; negate each, then keep the odd numbers, then keep multiples of three.


Take a list of integers; subtract one from each, then clamp each to at most ten, then find the min, defaulting to 0.


Take a list of integers; Decrement all items, then don't let anything exceed 10, then minimum value, zero otherwise.


Take a list of integers; decrement each value, then clamp each to at most ten, then get the minimum value or zero if empty.


Take a list of integers; Lower each number by one, then don't let anything exceed 10, then give me the min or 0.


Take a list of integers; reduce each by one, then clamp each to at most ten, then return the smallest number, defaulting to 0.


Take a list of integers; Subtract 1 from all, then don't let anything exceed 10, then return smallest or zero if empty.


def solve(xs):
    r = list(xs)
    r = [x - 1 for x in r]
    r = [min(x, 10) for x in r]
    return min(r) if r else 0


Take a list of integers; subtract one from each, then cap each value at 10, then return the minimum (0 if empty).


Take a list of integers; sort ascending, then increment each value, then true if every value is unique.


Take a list of integers; Sort it from low to high, then plus one for all, then check for duplicates in the values.


Take a list of integers; arrange in increasing order, then increment each value, then do all values appear only once.


Take a list of integers; Organize these ascending, then plus one for all, then check that there are no duplicates.


Take a list of integers; Sort in ascending order, then increment each value, then are the values all unique.


Take a list of integers; I need this sorted ascending, then plus one for all, then check if all values are unique.


def solve(xs):
    r = list(xs)
    r = sorted(r)
    r = [x + 1 for x in r]
    return len(r) == len(set(r))


Take a list of integers; sort ascending, then add one to each, then return whether all values are distinct.


Take a list of integers; keep the even numbers, then keep values below zero, then skip the first one.


Take a list of integers; keep evens, then get the negative numbers, then Discard the first element.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x % 2 == 0]
    r = [x for x in r if x < 0]
    r = r[1:]
    return r


Take a list of integers; keep the even numbers, then keep the negative numbers, then drop the first element.


Take a list of integers; take values while they are positive, then sort smallest to largest, then arrange in decreasing order.


Take a list of integers; take positive values then stop, then Ascending sort, then arrange in descending order.


Take a list of integers; keep going while positive, then Sort this ascending, then reverse sort.


Take a list of integers; stop at first non positive, then Sort lowest to highest, then sort largest to smallest.


Take a list of integers; take while greater than zero, then Arrange from smallest to largest, then sort by descending values.


Take a list of integers; take values while positive, then sort ascending, then sort from highest to lowest.


def solve(xs):
    r = list(xs)
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    r = sorted(r)
    r = sorted(r, reverse=True)
    return r


Take a list of integers; take values while they are positive, then sort ascending, then sort descending.


Take a list of integers; sort ascending, then increase every value by 10, then make each twice as big.


Take a list of integers; Sort it from low to high, then add 10 to each item, then multiply each by 2.


Take a list of integers; arrange in increasing order, then shift each up by ten, then make each twice as big.


Take a list of integers; Organize these ascending, then increase all numbers by 10, then multiply each by 2.


Take a list of integers; Sort in ascending order, then add 10 to everything, then make each twice as big.


Take a list of integers; I need this sorted ascending, then give everything a boost of 10, then multiply each by 2.


def solve(xs):
    r = list(xs)
    r = sorted(r)
    r = [x + 10 for x in r]
    r = [x * 2 for x in r]
    return r


Take a list of integers; sort ascending, then add ten to each, then double each.


Take a list of people records (name, age); extract the ages, then keep the leading run of positive numbers, then find the min, defaulting to 0.


Take a list of people records (name, age); show me all ages, then take values while they are positive, then minimum value, zero otherwise.


Take a list of people records (name, age); pluck the age field from each record, then take positive values then stop, then get the minimum value or zero if empty.


Take a list of people records (name, age); get the age field, then keep going while positive, then give me the min or 0.


Take a list of people records (name, age); keep just each person's age, then stop at first non positive, then return the smallest number, defaulting to 0.


Take a list of people records (name, age); extract age values, then take while greater than zero, then return smallest or zero if empty.


def solve(xs):
    r = list(xs)
    r = [d['age'] for d in r]
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    return min(r) if r else 0


Take a list of people records (name, age); extract the ages, then take values while they are positive, then return the minimum (0 if empty).


Take a list of integers; take values while they are positive, then extend to length 3 using zeros, then true if every value is unique.


Take a list of integers; take positive values then stop, then pad to 3, then check for duplicates in the values.


Take a list of integers; keep going while positive, then extend to length 3 using zeros, then do all values appear only once.


Take a list of integers; stop at first non positive, then pad to 3, then check that there are no duplicates.


Take a list of integers; take while greater than zero, then extend to length 3 using zeros, then are the values all unique.


Take a list of integers; take values while positive, then pad to 3, then check if all values are unique.


def solve(xs):
    r = list(xs)
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    return len(r) == len(set(r))


Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then return whether all values are distinct.


Take a list of integers; add one to each, then keep only odd values, then drop non-negative values.


Take a list of integers; make each one bigger, then eliminate the even numbers, then drop all positive numbers.


def solve(xs):
    r = list(xs)
    r = [x + 1 for x in r]
    r = [x for x in r if x % 2 != 0]
    r = [x for x in r if x < 0]
    return r


Take a list of integers; add one to each, then keep the odd numbers, then keep the negative numbers.


Take a list of integers; square each, then decrement each value, then truncate to the last three items.


Take a list of integers; each value squared, then Lower each number by one, then show only the last three.


Take a list of integers; multiply each value by itself, then reduce each by one, then remove all but the last three.


Take a list of integers; square them all, then Subtract 1 from all, then take the final 3 elements.


Take a list of integers; raise each to the power of two, then Subtract one from each, then drop everything except the final three.


Take a list of integers; I need each number multiplied by itself, then Drop each by one, then give me the last three elements.


def solve(xs):
    r = list(xs)
    r = [x * x for x in r]
    r = [x - 1 for x in r]
    r = r[-3:]
    return r


Take a list of integers; square each, then subtract one from each, then keep only the last three.


Take a list of integers; cap each value at 10, then keep values divisible by 3, then give the number of evens.


Take a list of integers; clip values at 10, then keep items where x mod 3 equals zero, then find how many values are divisible by two.


Take a list of integers; cap each value at 10, then drop anything not divisible by three, then how many are even.


Take a list of integers; clip values at 10, then filter out everything except multiples of three, then get the total number of even values in the list.


Take a list of integers; cap each value at 10, then keep only multiples of three, then give me the count of even values.


Take a list of integers; clip values at 10, then multiples of three only, then I need to know how many of these are even.


def solve(xs):
    r = list(xs)
    r = [min(x, 10) for x in r]
    r = [x for x in r if x % 3 == 0]
    return sum(1 for x in r if x % 2 == 0)


Take a list of integers; cap each value at 10, then keep multiples of three, then return how many values are even.


Take a list of integers; negate each, then take the final 3 elements, then replace an empty list with one zero.


Take a list of integers; reverse the signs of everything, then drop everything except the final three, then zero it out if it's empty.


Take a list of integers; negate each, then give me the last three elements, then use zero if the list is empty.


Take a list of integers; reverse the signs of everything, then keep only the last three, then default to zero when empty.


Take a list of integers; negate each, then keep the final three items, then if there's nothing, put in a zero.


Take a list of integers; reverse the signs of everything, then take the last three, then if no items, add a zero.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = r[-3:]
    r = r if r else [0]
    return r


Take a list of integers; negate each, then keep only the last three, then if empty, use a single zero.


Take a list of integers; add ten to each, then flip the list around, then arrange in increasing order.


Take a list of integers; bump everything up by 10, then flip the order around, then Organize these ascending.


Take a list of integers; increase every value by 10, then put the elements backwards, then Sort in ascending order.


Take a list of integers; add 10 to each item, then reverse that for me, then I need this sorted ascending.


Take a list of integers; shift each up by ten, then flip it backwards, then Put these in ascending order.


Take a list of integers; increase all numbers by 10, then make it backwards, then sort smallest to largest.


def solve(xs):
    r = list(xs)
    r = [x + 10 for x in r]
    r = list(reversed(r))
    r = sorted(r)
    return r


Take a list of integers; add ten to each, then reverse the order, then sort ascending.


Take a list of integers; cap each value at 10, then sort largest to smallest, then deduplicate the list.


Take a list of integers; clip values at 10, then sort by descending values, then remove repeats.


Take a list of integers; cap each value at 10, then sort from highest to lowest, then deduplicate the list.


Take a list of integers; clip values at 10, then sort descending, then remove repeats.


Take a list of integers; cap each value at 10, then sort largest first, then deduplicate the list.


Take a list of integers; clip values at 10, then sort in descending order, then remove repeats.


def solve(xs):
    r = list(xs)
    r = [min(x, 10) for x in r]
    r = sorted(r, reverse=True)
    r = list(dict.fromkeys(r))
    return r


Take a list of integers; cap each value at 10, then sort descending, then drop duplicates keeping first occurrence.


Take a list of integers; take the absolute value of each, then keep only even values, then count the elements.


Take a list of integers; convert to absolute value, then extract all even numbers, then how many items remain.


Take a list of integers; strip the signs, then keep only even values, then tell me the length.


Take a list of integers; take abs of each, then extract all even numbers, then return the length.


Take a list of integers; get the absolute value of everything, then keep only even values, then count them.


Take a list of integers; apply absolute value to the whole list, then extract all even numbers, then what's the count.


def solve(xs):
    r = list(xs)
    r = [abs(x) for x in r]
    r = [x for x in r if x % 2 == 0]
    return len(r)


Take a list of integers; take the absolute value of each, then keep the even numbers, then return how many remain.


Take a list of integers; keep the negative numbers, then remove both ends, then keep only non-zero numbers.


Take a list of integers; extract negatives, then trim the edges, then strip the zeros.


Take a list of integers; keep the negative numbers, then trim one element off each end, then keep only non-zero numbers.


Take a list of integers; extract negatives, then cut off the first and last, then strip the zeros.


Take a list of integers; keep the negative numbers, then remove the first and last elements, then keep only non-zero numbers.


Take a list of integers; extract negatives, then keep only the middle part, then strip the zeros.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x < 0]
    r = r[1:-1]
    r = [x for x in r if x != 0]
    return r


Take a list of integers; keep the negative numbers, then drop the first and last elements, then drop the zeros.


Take a list of integers; take values while they are positive, then flip the sign of each, then true only if all are positive.


Take a list of integers; take positive values then stop, then turn positives to negatives and vice versa, then do all of these have positive values.


Take a list of integers; keep going while positive, then flip the sign of each, then check if every value is positive.


Take a list of integers; stop at first non positive, then turn positives to negatives and vice versa, then confirm all values are positive.


Take a list of integers; take while greater than zero, then flip the sign of each, then all positive.


Take a list of integers; take values while positive, then turn positives to negatives and vice versa, then check if every number is above zero.


def solve(xs):
    r = list(xs)
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    r = [-x for x in r]
    return all(x > 0 for x in r)


Take a list of integers; take values while they are positive, then negate each, then return whether all values are positive.


Take a list of integers; drop the first element, then remove repeated values, then keep only non-zero numbers.


Take a list of integers; Take everything except the first, then unique values preserving order, then strip the zeros.


def solve(xs):
    r = list(xs)
    r = r[1:]
    r = list(dict.fromkeys(r))
    r = [x for x in r if x != 0]
    return r


Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then drop the zeros.


Take a list of integers; drop the zeros, then multiply each by two, then give back the total.


Take a list of integers; keep only nonzero elements, then double each item in the list, then sum r.


Take a list of integers; drop the zeros, then multiply each by two, then add them up.


Take a list of integers; keep only nonzero elements, then double each item in the list, then calculate the sum of all elements.


Take a list of integers; drop the zeros, then multiply each by two, then what's the total.


Take a list of integers; keep only nonzero elements, then double each item in the list, then what do they add up to.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x != 0]
    r = [x * 2 for x in r]
    return sum(r)


Take a list of integers; drop the zeros, then double each, then return their sum.


Take a list of integers; pad with zeros to at least three elements, then drop anything 5 or below, then drop anything not divisible by three.


Take a list of integers; add zeros until the list has at least three values, then keep only numbers greater than 5, then filter out everything except multiples of three.


Take a list of integers; pad with zeros to at least three elements, then filter for numbers above 5, then keep only multiples of three.


Take a list of integers; add zeros until the list has at least three values, then give me values where x is greater than 5, then multiples of three only.


Take a list of integers; pad with zeros to at least three elements, then show me only the values that are bigger than five, then filter for numbers divisible by three.


Take a list of integers; add zeros until the list has at least three values, then keep values greater than five, then give me only the values divisible by three.


def solve(xs):
    r = list(xs)
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [x for x in r if x > 5]
    r = [x for x in r if x % 3 == 0]
    return r


Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then keep multiples of three.


Take a list of people records (name, age); extract the ages, then flip the list around, then true if already sorted smallest to largest.


Take a list of people records (name, age); show me all ages, then flip the order around, then does this list go in ascending order.


Take a list of people records (name, age); pluck the age field from each record, then put the elements backwards, then check if the list is in ascending order.


Take a list of people records (name, age); get the age field, then reverse that for me, then is the list sorted.


Take a list of people records (name, age); keep just each person's age, then flip it backwards, then is it sorted.


Take a list of people records (name, age); extract age values, then make it backwards, then check if values are in increasing order.


def solve(xs):
    r = list(xs)
    r = [d['age'] for d in r]
    r = list(reversed(r))
    return r == sorted(r)


Take a list of people records (name, age); extract the ages, then reverse the order, then return whether the list is sorted ascending.


Take a list of integers; negate each, then remove all zero values, then drop anything not divisible by three.


Take a list of integers; reverse the signs of everything, then exclude zeros, then filter out everything except multiples of three.


Take a list of integers; negate each, then remove all zero values, then keep only multiples of three.


Take a list of integers; reverse the signs of everything, then exclude zeros, then multiples of three only.


Take a list of integers; negate each, then remove all zero values, then filter for numbers divisible by three.


Take a list of integers; reverse the signs of everything, then exclude zeros, then give me only the values divisible by three.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = [x for x in r if x != 0]
    r = [x for x in r if x % 3 == 0]
    return r


Take a list of integers; negate each, then drop the zeros, then keep multiples of three.


Take a list of integers; sort descending, then increase every value by 10, then replace an empty list with one zero.


Take a list of integers; sort largest first, then add 10 to each item, then zero it out if it's empty.


Take a list of integers; sort in descending order, then shift each up by ten, then use zero if the list is empty.


Take a list of integers; sort from greatest to least, then increase all numbers by 10, then default to zero when empty.


Take a list of integers; sort z to a, then add 10 to everything, then if there's nothing, put in a zero.


Take a list of integers; arrange in decreasing order, then give everything a boost of 10, then if no items, add a zero.


def solve(xs):
    r = list(xs)
    r = sorted(r, reverse=True)
    r = [x + 10 for x in r]
    r = r if r else [0]
    return r


Take a list of integers; sort descending, then add ten to each, then if empty, use a single zero.


Take a list of integers; sort ascending, then cut the list at the first zero, then drop non-negative values.


Take a list of integers; Sort it from low to high, then cut off after the first zero appears, then drop all positive numbers.


Take a list of integers; arrange in increasing order, then take values up to (excluding) the first zero, then drop non-negative values.


Take a list of integers; Organize these ascending, then keep the part before the first 0, then drop all positive numbers.


Take a list of integers; Sort in ascending order, then truncate at the first zero, then drop non-negative values.


Take a list of integers; I need this sorted ascending, then delete everything starting with the first zero, then drop all positive numbers.


def solve(xs):
    r = list(xs)
    r = sorted(r)
    r = r[:r.index(0)] if 0 in r else r
    r = [x for x in r if x < 0]
    return r


Take a list of integers; sort ascending, then keep everything before the first zero, then keep the negative numbers.


Take a list of integers; keep the negative numbers, then take the final 3 elements, then give back the product of all values.


Take a list of integers; extract negatives, then drop everything except the final three, then product of the list.


Take a list of integers; keep the negative numbers, then give me the last three elements, then what's the product.


Take a list of integers; extract negatives, then keep only the last three, then what do they multiply to.


Take a list of integers; keep the negative numbers, then keep the final three items, then give me their product.


Take a list of integers; extract negatives, then take the last three, then multiply them all together.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x < 0]
    r = r[-3:]
    return __import__('math').prod(r)


Take a list of integers; keep the negative numbers, then keep only the last three, then return their product.


Take a list of integers; keep values greater than five, then keep only even values, then strip the signs.


Take a list of integers; filter out values less than or equal to 5, then extract all even numbers, then take abs of each.


Take a list of integers; keep only numbers above 5, then keep only even values, then get the absolute value of everything.


Take a list of integers; exclude values of 5 and below, then extract all even numbers, then apply absolute value to the whole list.


Take a list of integers; remove anything 5 or less, then keep only even values, then make them all positive.


Take a list of integers; filter to keep only values above 5, then extract all even numbers, then make every value non-negative.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x > 5]
    r = [x for x in r if x % 2 == 0]
    r = [abs(x) for x in r]
    return r


Take a list of integers; keep values greater than five, then keep the even numbers, then take the absolute value of each.


Take a list of integers; double each, then increase every value by 10, then limit every value to 10.


Take a list of integers; times two for each item, then add 10 to each item, then maximum of 10 for all.


Take a list of integers; double each, then shift each up by ten, then limit every value to 10.


Take a list of integers; times two for each item, then increase all numbers by 10, then maximum of 10 for all.


Take a list of integers; double each, then add 10 to everything, then limit every value to 10.


Take a list of integers; times two for each item, then give everything a boost of 10, then maximum of 10 for all.


def solve(xs):
    r = list(xs)
    r = [x * 2 for x in r]
    r = [x + 10 for x in r]
    r = [min(x, 10) for x in r]
    return r


Take a list of integers; double each, then add ten to each, then cap each value at 10.


Take a list of integers; drop duplicates keeping first occurrence, then make every value non-negative, then skip the first one.


Take a list of integers; drop duplicates but keep the first one, then absolute value for all items, then Discard the first element.


Take a list of integers; drop duplicates keeping first occurrence, then take absolute values, then skip the first one.


Take a list of integers; drop duplicates but keep the first one, then turn negatives into positives, then Discard the first element.


Take a list of integers; drop duplicates keeping first occurrence, then abs each element, then skip the first one.


Take a list of integers; drop duplicates but keep the first one, then take the absolute value of each, then Discard the first element.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = [abs(x) for x in r]
    r = r[1:]
    return r


Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then drop the first element.


Take a list of integers; take the absolute value of each, then increment each value, then find the max, defaulting to 0.


Take a list of integers; convert to absolute value, then plus one for all, then Give me the maximum, but 0 if there are no items.


Take a list of integers; strip the signs, then increment each value, then What's the highest number in the list.


Take a list of integers; take abs of each, then plus one for all, then Return the greatest value or default to 0.


Take a list of integers; get the absolute value of everything, then increment each value, then Find the largest element, defaulting to zero.


Take a list of integers; apply absolute value to the whole list, then plus one for all, then give the largest value (0 if none).


def solve(xs):
    r = list(xs)
    r = [abs(x) for x in r]
    r = [x + 1 for x in r]
    return max(r) if r else 0


Take a list of integers; take the absolute value of each, then add one to each, then return the maximum (0 if empty).


Take a list of integers; square each, then keep the leading run of positive numbers, then multiply each by -1.


Take a list of integers; each value squared, then take values while they are positive, then negate.


Take a list of integers; multiply each value by itself, then take positive values then stop, then multiply each by -1.


Take a list of integers; square them all, then keep going while positive, then negate.


Take a list of integers; raise each to the power of two, then stop at first non positive, then multiply each by -1.


Take a list of integers; I need each number multiplied by itself, then take while greater than zero, then negate.


def solve(xs):
    r = list(xs)
    r = [x * x for x in r]
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    r = [-x for x in r]
    return r


Take a list of integers; square each, then take values while they are positive, then negate each.


Take a list of integers; sort by absolute value, then clamp each to at most ten, then skip the first one.


Take a list of integers; rearrange by distance from zero, then don't let anything exceed 10, then Discard the first element.


Take a list of integers; arrange by magnitude ignoring sign, then clamp each to at most ten, then skip the first one.


Take a list of integers; put them in order by magnitude, then don't let anything exceed 10, then Discard the first element.


Take a list of integers; arrange in order of absolute value, then clamp each to at most ten, then skip the first one.


Take a list of integers; sort by distance from zero, then don't let anything exceed 10, then Discard the first element.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=abs)
    r = [min(x, 10) for x in r]
    r = r[1:]
    return r


Take a list of integers; sort by absolute value, then cap each value at 10, then drop the first element.


Take a list of integers; drop duplicates keeping first occurrence, then keep only even values, then find the min, defaulting to 0.


Take a list of integers; drop duplicates but keep the first one, then extract all even numbers, then minimum value, zero otherwise.


Take a list of integers; drop duplicates keeping first occurrence, then keep only even values, then get the minimum value or zero if empty.


Take a list of integers; drop duplicates but keep the first one, then extract all even numbers, then give me the min or 0.


Take a list of integers; drop duplicates keeping first occurrence, then keep only even values, then return the smallest number, defaulting to 0.


Take a list of integers; drop duplicates but keep the first one, then extract all even numbers, then return smallest or zero if empty.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = [x for x in r if x % 2 == 0]
    return min(r) if r else 0


Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then return the minimum (0 if empty).


Take a list of integers; keep only the first three, then multiply each by two, then give the number of evens.


Take a list of integers; keep the first 3 items, then double each item in the list, then find how many values are divisible by two.


Take a list of integers; take the first 3 elements, then multiply each by two, then how many are even.


Take a list of integers; remove everything after the third, then double each item in the list, then get the total number of even values in the list.


Take a list of integers; truncate to three items, then multiply each by two, then give me the count of even values.


Take a list of integers; show the first three, then double each item in the list, then I need to know how many of these are even.


def solve(xs):
    r = list(xs)
    r = r[:3]
    r = [x * 2 for x in r]
    return sum(1 for x in r if x % 2 == 0)


Take a list of integers; keep only the first three, then double each, then return how many values are even.


Take a list of integers; sort descending, then multiply each value by itself, then drop non-positive values.


Take a list of integers; sort largest first, then square them all, then drop the negative numbers.


Take a list of integers; sort in descending order, then raise each to the power of two, then filter out the negative ones.


Take a list of integers; sort from greatest to least, then I need each number multiplied by itself, then remove all negative values.


Take a list of integers; sort z to a, then square all of them, then keep positive values only.


Take a list of integers; arrange in decreasing order, then multiply each element by itself, then keep values above zero.


def solve(xs):
    r = list(xs)
    r = sorted(r, reverse=True)
    r = [x * x for x in r]
    r = [x for x in r if x > 0]
    return r


Take a list of integers; sort descending, then square each, then keep the positive numbers.


Take a list of integers; square each, then take the final 3 elements, then reduce each by one.


Take a list of integers; each value squared, then drop everything except the final three, then Subtract 1 from all.


Take a list of integers; multiply each value by itself, then give me the last three elements, then Subtract one from each.


Take a list of integers; square them all, then keep only the last three, then Drop each by one.


Take a list of integers; raise each to the power of two, then keep the final three items, then Decrease all values by one.


Take a list of integers; I need each number multiplied by itself, then take the last three, then Remove one from each value.


def solve(xs):
    r = list(xs)
    r = [x * x for x in r]
    r = r[-3:]
    r = [x - 1 for x in r]
    return r


Take a list of integers; square each, then keep only the last three, then subtract one from each.


Take a list of integers; keep only the last three, then take the first 3 elements, then true if every value is unique.


Take a list of integers; keep the final three items, then remove everything after the third, then check for duplicates in the values.


Take a list of integers; take the last three, then truncate to three items, then do all values appear only once.


Take a list of integers; trim to the last three, then show the first three, then check that there are no duplicates.


Take a list of integers; last three only, then take the first three, then are the values all unique.


Take a list of integers; truncate to the last three items, then keep first 3, then check if all values are unique.


def solve(xs):
    r = list(xs)
    r = r[-3:]
    r = r[:3]
    return len(r) == len(set(r))


Take a list of integers; keep only the last three, then keep only the first three, then return whether all values are distinct.


Take a list of integers; keep only the first three, then cut the list at the first zero, then drop non-negative values.


Take a list of integers; keep the first 3 items, then cut off after the first zero appears, then drop all positive numbers.


Take a list of integers; take the first 3 elements, then take values up to (excluding) the first zero, then drop non-negative values.


Take a list of integers; remove everything after the third, then keep the part before the first 0, then drop all positive numbers.


Take a list of integers; truncate to three items, then truncate at the first zero, then drop non-negative values.


Take a list of integers; show the first three, then delete everything starting with the first zero, then drop all positive numbers.


def solve(xs):
    r = list(xs)
    r = r[:3]
    r = r[:r.index(0)] if 0 in r else r
    r = [x for x in r if x < 0]
    return r


Take a list of integers; keep only the first three, then keep everything before the first zero, then keep the negative numbers.


Take a list of integers; drop the zeros, then keep the leading run of positive numbers, then true if already sorted smallest to largest.


Take a list of integers; keep only nonzero elements, then take values while they are positive, then does this list go in ascending order.


Take a list of integers; drop the zeros, then take positive values then stop, then check if the list is in ascending order.


Take a list of integers; keep only nonzero elements, then keep going while positive, then is the list sorted.


Take a list of integers; drop the zeros, then stop at first non positive, then is it sorted.


Take a list of integers; keep only nonzero elements, then take while greater than zero, then check if values are in increasing order.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x != 0]
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    return r == sorted(r)


Take a list of integers; drop the zeros, then take values while they are positive, then return whether the list is sorted ascending.


Take a list of people records (name, age); extract the ages, then remove repeated values, then drop the even numbers.


Take a list of people records (name, age); show me all ages, then unique values preserving order, then strip out the evens.


Take a list of people records (name, age); pluck the age field from each record, then remove repeated values, then drop the even numbers.


Take a list of people records (name, age); get the age field, then unique values preserving order, then strip out the evens.


Take a list of people records (name, age); keep just each person's age, then remove repeated values, then drop the even numbers.


Take a list of people records (name, age); extract age values, then unique values preserving order, then strip out the evens.


def solve(xs):
    r = list(xs)
    r = [d['age'] for d in r]
    r = list(dict.fromkeys(r))
    r = [x for x in r if x % 2 != 0]
    return r


Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then keep the odd numbers.


Take a list of integers; keep the odd numbers, then increment each value, then make each twice as big.


Take a list of integers; odd numbers only, then plus one for all, then multiply each by 2.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x % 2 != 0]
    r = [x + 1 for x in r]
    r = [x * 2 for x in r]
    return r


Take a list of integers; keep the odd numbers, then add one to each, then double each.


Take a list of integers; cap each value at 10, then keep only odd values, then deduplicate the list.


Take a list of integers; clip values at 10, then eliminate the even numbers, then remove repeats.


def solve(xs):
    r = list(xs)
    r = [min(x, 10) for x in r]
    r = [x for x in r if x % 2 != 0]
    r = list(dict.fromkeys(r))
    return r


Take a list of integers; cap each value at 10, then keep the odd numbers, then drop duplicates keeping first occurrence.


Take a list of integers; keep the negative numbers, then sort smallest to largest, then shift each up by ten.


Take a list of integers; extract negatives, then Ascending sort, then increase all numbers by 10.


Take a list of integers; keep the negative numbers, then Sort this ascending, then add 10 to everything.


Take a list of integers; extract negatives, then Sort lowest to highest, then give everything a boost of 10.


Take a list of integers; keep the negative numbers, then Arrange from smallest to largest, then increment each by ten.


Take a list of integers; extract negatives, then sort ascending, then add a constant 10 to each.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x < 0]
    r = sorted(r)
    r = [x + 10 for x in r]
    return r


Take a list of integers; keep the negative numbers, then sort ascending, then add ten to each.


Take a list of people records (name, age); extract the names, then add '#' to the start of each string, then make every string lowercase.


Take a list of people records (name, age); Give me the names, then make each one start with a hash, then make it all lowercase.


Take a list of people records (name, age); pluck the name field from each record, then add '#' to the start of each string, then make every string lowercase.


Take a list of people records (name, age); Grab the names, then make each one start with a hash, then make it all lowercase.


Take a list of people records (name, age); keep just each person's name, then add '#' to the start of each string, then make every string lowercase.


Take a list of people records (name, age); List the names, then make each one start with a hash, then make it all lowercase.


def solve(xs):
    r = list(xs)
    r = [d['name'] for d in r]
    r = ['#' + s for s in r]
    r = [s.lower() for s in r]
    return r


Take a list of people records (name, age); extract the names, then prefix each with a hash, then lowercase each string.


Take a list of people records (name, age); sort records by age, youngest first, then pluck the name field from each record, then arrange in lexicographic order.


Take a list of people records (name, age); put the youngest at the top, then Grab the names, then sort by letter.


Take a list of people records (name, age); sort records by age, youngest first, then keep just each person's name, then arrange in lexicographic order.


Take a list of people records (name, age); put the youngest at the top, then List the names, then sort by letter.


Take a list of people records (name, age); sort records by age, youngest first, then Extract the names, then arrange in lexicographic order.


Take a list of people records (name, age); put the youngest at the top, then Get the name field, then sort by letter.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=lambda d: d['age'])
    r = [d['name'] for d in r]
    r = sorted(r)
    return r


Take a list of people records (name, age); sort records by age, youngest first, then extract the names, then sort alphabetically.


Take a list of integers; reverse the order, then sort smallest to largest, then true if already sorted smallest to largest.


Take a list of integers; reverse, then Ascending sort, then does this list go in ascending order.


Take a list of integers; flip the list around, then Sort this ascending, then check if the list is in ascending order.


Take a list of integers; flip the order around, then Sort lowest to highest, then is the list sorted.


Take a list of integers; put the elements backwards, then Arrange from smallest to largest, then is it sorted.


Take a list of integers; reverse that for me, then sort ascending, then check if values are in increasing order.


def solve(xs):
    r = list(xs)
    r = list(reversed(r))
    r = sorted(r)
    return r == sorted(r)


Take a list of integers; reverse the order, then sort ascending, then return whether the list is sorted ascending.


Take a list of integers; keep only the last three, then keep values below zero, then arrange in increasing order.


Take a list of integers; keep the final three items, then get the negative numbers, then Organize these ascending.


Take a list of integers; take the last three, then keep values below zero, then Sort in ascending order.


Take a list of integers; trim to the last three, then get the negative numbers, then I need this sorted ascending.


Take a list of integers; last three only, then keep values below zero, then Put these in ascending order.


Take a list of integers; truncate to the last three items, then get the negative numbers, then sort smallest to largest.


def solve(xs):
    r = list(xs)
    r = r[-3:]
    r = [x for x in r if x < 0]
    r = sorted(r)
    return r


Take a list of integers; keep only the last three, then keep the negative numbers, then sort ascending.


Take a list of integers; reverse the order, then increment each value, then strip the signs.


Take a list of integers; reverse, then plus one for all, then take abs of each.


Take a list of integers; flip the list around, then increment each value, then get the absolute value of everything.


Take a list of integers; flip the order around, then plus one for all, then apply absolute value to the whole list.


Take a list of integers; put the elements backwards, then increment each value, then make them all positive.


Take a list of integers; reverse that for me, then plus one for all, then make every value non-negative.


def solve(xs):
    r = list(xs)
    r = list(reversed(r))
    r = [x + 1 for x in r]
    r = [abs(x) for x in r]
    return r


Take a list of integers; reverse the order, then add one to each, then take the absolute value of each.


Take a list of integers; drop duplicates keeping first occurrence, then keep values above zero, then reduce each by one.


Take a list of integers; drop duplicates but keep the first one, then filter for positive numbers, then Subtract 1 from all.


Take a list of integers; drop duplicates keeping first occurrence, then keep only positive numbers, then Subtract one from each.


Take a list of integers; drop duplicates but keep the first one, then keep the positives, then Drop each by one.


Take a list of integers; drop duplicates keeping first occurrence, then remove negatives, then Decrease all values by one.


Take a list of integers; drop duplicates but keep the first one, then keep the positive numbers, then Remove one from each value.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = [x for x in r if x > 0]
    r = [x - 1 for x in r]
    return r


Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then subtract one from each.


Take a list of integers; keep only the last three, then sort smallest to largest, then drop the odd numbers.


Take a list of integers; keep the final three items, then Ascending sort, then filter out the odd numbers.


Take a list of integers; take the last three, then Sort this ascending, then drop the odd numbers.


Take a list of integers; trim to the last three, then Sort lowest to highest, then filter out the odd numbers.


Take a list of integers; last three only, then Arrange from smallest to largest, then drop the odd numbers.


Take a list of integers; truncate to the last three items, then sort ascending, then filter out the odd numbers.


def solve(xs):
    r = list(xs)
    r = r[-3:]
    r = sorted(r)
    r = [x for x in r if x % 2 == 0]
    return r


Take a list of integers; keep only the last three, then sort ascending, then keep the even numbers.


Take a list of integers; sort descending, then keep values above zero, then raise each to the power of two.


Take a list of integers; sort largest first, then filter for positive numbers, then I need each number multiplied by itself.


Take a list of integers; sort in descending order, then keep only positive numbers, then square all of them.


Take a list of integers; sort from greatest to least, then keep the positives, then multiply each element by itself.


Take a list of integers; sort z to a, then remove negatives, then make each one squared.


Take a list of integers; arrange in decreasing order, then keep the positive numbers, then square each value in the list.


def solve(xs):
    r = list(xs)
    r = sorted(r, reverse=True)
    r = [x for x in r if x > 0]
    r = [x * x for x in r]
    return r


Take a list of integers; sort descending, then keep the positive numbers, then square each.


Take a list of integers; reverse the order, then increment each value, then trim one element off each end.


Take a list of integers; reverse, then plus one for all, then cut off the first and last.


Take a list of integers; flip the list around, then increment each value, then remove the first and last elements.


Take a list of integers; flip the order around, then plus one for all, then keep only the middle part.


Take a list of integers; put the elements backwards, then increment each value, then drop first and last.


Take a list of integers; reverse that for me, then plus one for all, then eliminate the outermost elements.


def solve(xs):
    r = list(xs)
    r = list(reversed(r))
    r = [x + 1 for x in r]
    r = r[1:-1]
    return r


Take a list of integers; reverse the order, then add one to each, then drop the first and last elements.


Take a list of integers; subtract one from each, then keep the leading run of positive numbers, then give the number of evens.


Take a list of integers; Decrement all items, then take values while they are positive, then find how many values are divisible by two.


Take a list of integers; decrement each value, then take positive values then stop, then how many are even.


Take a list of integers; Lower each number by one, then keep going while positive, then get the total number of even values in the list.


Take a list of integers; reduce each by one, then stop at first non positive, then give me the count of even values.


Take a list of integers; Subtract 1 from all, then take while greater than zero, then I need to know how many of these are even.


def solve(xs):
    r = list(xs)
    r = [x - 1 for x in r]
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    return sum(1 for x in r if x % 2 == 0)


Take a list of integers; subtract one from each, then take values while they are positive, then return how many values are even.


Take a list of integers; pad with zeros to at least three elements, then keep only even values, then bump each up by one.


Take a list of integers; add zeros until the list has at least three values, then extract all even numbers, then increment each item.


def solve(xs):
    r = list(xs)
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [x for x in r if x % 2 == 0]
    r = [x + 1 for x in r]
    return r


Take a list of integers; pad with zeros to at least three elements, then keep the even numbers, then add one to each.


Take a list of strings; keep the first character of each (dropping empties), then order the strings A to Z, then find how long the longest string is.


Take a list of strings; extract initial letters, then make it alphabetical, then give the length of the longest string in the list.


Take a list of strings; take each string's first letter, then order the strings A to Z, then get me the longest string's length.


Take a list of strings; give me the first letter of everything, then make it alphabetical, then give the maximum string length.


Take a list of strings; reduce each string to its first character, then order the strings A to Z, then max length of all strings.


Take a list of strings; take first char drop blanks, then make it alphabetical, then what's the max string length.


def solve(xs):
    r = list(xs)
    r = [s[0] for s in r if s]
    r = sorted(r)
    return max((len(s) for s in r), default=0)


Take a list of strings; keep the first character of each (dropping empties), then sort alphabetically, then return the length of the longest string (0 if none).


Take a list of integers; pad with zeros to at least three elements, then flip the sign of each, then skip the first one.


Take a list of integers; add zeros until the list has at least three values, then turn positives to negatives and vice versa, then Discard the first element.


def solve(xs):
    r = list(xs)
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [-x for x in r]
    r = r[1:]
    return r


Take a list of integers; pad with zeros to at least three elements, then negate each, then drop the first element.


Take a list of integers; cap each value at 10, then increment each value, then find the min, defaulting to 0.


Take a list of integers; clip values at 10, then plus one for all, then minimum value, zero otherwise.


Take a list of integers; cap each value at 10, then increment each value, then get the minimum value or zero if empty.


Take a list of integers; clip values at 10, then plus one for all, then give me the min or 0.


Take a list of integers; cap each value at 10, then increment each value, then return the smallest number, defaulting to 0.


Take a list of integers; clip values at 10, then plus one for all, then return smallest or zero if empty.


def solve(xs):
    r = list(xs)
    r = [min(x, 10) for x in r]
    r = [x + 1 for x in r]
    return min(r) if r else 0


Take a list of integers; cap each value at 10, then add one to each, then return the minimum (0 if empty).


Take a list of integers; reverse the order, then increment each value, then truncate to the last three items.


Take a list of integers; reverse, then plus one for all, then show only the last three.


Take a list of integers; flip the list around, then increment each value, then remove all but the last three.


Take a list of integers; flip the order around, then plus one for all, then take the final 3 elements.


Take a list of integers; put the elements backwards, then increment each value, then drop everything except the final three.


Take a list of integers; reverse that for me, then plus one for all, then give me the last three elements.


def solve(xs):
    r = list(xs)
    r = list(reversed(r))
    r = [x + 1 for x in r]
    r = r[-3:]
    return r


Take a list of integers; reverse the order, then add one to each, then keep only the last three.


Take a list of integers; cap each value at 10, then cut the list at the first zero, then arrange by magnitude ignoring sign.


Take a list of integers; clip values at 10, then cut off after the first zero appears, then put them in order by magnitude.


Take a list of integers; cap each value at 10, then take values up to (excluding) the first zero, then arrange in order of absolute value.


Take a list of integers; clip values at 10, then keep the part before the first 0, then sort by distance from zero.


Take a list of integers; cap each value at 10, then truncate at the first zero, then order by how far from zero.


Take a list of integers; clip values at 10, then delete everything starting with the first zero, then order by distance from zero.


def solve(xs):
    r = list(xs)
    r = [min(x, 10) for x in r]
    r = r[:r.index(0)] if 0 in r else r
    r = sorted(r, key=abs)
    return r


Take a list of integers; cap each value at 10, then keep everything before the first zero, then sort by absolute value.


Take a list of integers; keep everything before the first zero, then increase every value by 10, then keep only numbers above 5.


Take a list of integers; take only what comes before the initial zero, then add 10 to each item, then exclude values of 5 and below.


Take a list of integers; cut the list at the first zero, then shift each up by ten, then remove anything 5 or less.


Take a list of integers; cut off after the first zero appears, then increase all numbers by 10, then filter to keep only values above 5.


Take a list of integers; take values up to (excluding) the first zero, then add 10 to everything, then get rid of values that aren't greater than five.


Take a list of integers; keep the part before the first 0, then give everything a boost of 10, then drop anything 5 or below.


def solve(xs):
    r = list(xs)
    r = r[:r.index(0)] if 0 in r else r
    r = [x + 10 for x in r]
    r = [x for x in r if x > 5]
    return r


Take a list of integers; keep everything before the first zero, then add ten to each, then keep values greater than five.


Take a list of integers; drop the first element, then make every value non-negative, then give the number of evens.


Take a list of integers; Take everything except the first, then absolute value for all items, then find how many values are divisible by two.


Take a list of integers; drop the first element, then take absolute values, then how many are even.


Take a list of integers; Take everything except the first, then turn negatives into positives, then get the total number of even values in the list.


Take a list of integers; drop the first element, then abs each element, then give me the count of even values.


Take a list of integers; Take everything except the first, then take the absolute value of each, then I need to know how many of these are even.


def solve(xs):
    r = list(xs)
    r = r[1:]
    r = [abs(x) for x in r]
    return sum(1 for x in r if x % 2 == 0)


Take a list of integers; drop the first element, then take the absolute value of each, then return how many values are even.


Take a list of integers; reverse the order, then increase every value by 10, then limit every value to 10.


Take a list of integers; reverse, then add 10 to each item, then maximum of 10 for all.


Take a list of integers; flip the list around, then shift each up by ten, then limit every value to 10.


Take a list of integers; flip the order around, then increase all numbers by 10, then maximum of 10 for all.


Take a list of integers; put the elements backwards, then add 10 to everything, then limit every value to 10.


Take a list of integers; reverse that for me, then give everything a boost of 10, then maximum of 10 for all.


def solve(xs):
    r = list(xs)
    r = list(reversed(r))
    r = [x + 10 for x in r]
    r = [min(x, 10) for x in r]
    return r


Take a list of integers; reverse the order, then add ten to each, then cap each value at 10.


Take a list of integers; reverse the order, then keep only odd values, then skip the first one.


Take a list of integers; reverse, then eliminate the even numbers, then Discard the first element.


Take a list of integers; flip the list around, then keep only odd values, then skip the first one.


Take a list of integers; flip the order around, then eliminate the even numbers, then Discard the first element.


Take a list of integers; put the elements backwards, then keep only odd values, then skip the first one.


Take a list of integers; reverse that for me, then eliminate the even numbers, then Discard the first element.


def solve(xs):
    r = list(xs)
    r = list(reversed(r))
    r = [x for x in r if x % 2 != 0]
    r = r[1:]
    return r


Take a list of integers; reverse the order, then keep the odd numbers, then drop the first element.


Take a list of integers; keep only the last three, then remove both ends, then bump each up by one.


Take a list of integers; keep the final three items, then trim the edges, then increment each item.


Take a list of integers; take the last three, then trim one element off each end, then bump each up by one.


Take a list of integers; trim to the last three, then cut off the first and last, then increment each item.


Take a list of integers; last three only, then remove the first and last elements, then bump each up by one.


Take a list of integers; truncate to the last three items, then keep only the middle part, then increment each item.


def solve(xs):
    r = list(xs)
    r = r[-3:]
    r = r[1:-1]
    r = [x + 1 for x in r]
    return r


Take a list of integers; keep only the last three, then drop the first and last elements, then add one to each.


Take a list of integers; if empty, use a single zero, then extend to length 3 using zeros, then raise each to the power of two.


Take a list of integers; if blank use 0, then pad to 3, then I need each number multiplied by itself.


Take a list of integers; default to [0] when there is nothing, then extend to length 3 using zeros, then square all of them.


Take a list of integers; when the list is empty, substitute a zero value, then pad to 3, then multiply each element by itself.


Take a list of integers; replace an empty list with one zero, then extend to length 3 using zeros, then make each one squared.


Take a list of integers; zero it out if it's empty, then pad to 3, then square each value in the list.


def solve(xs):
    r = list(xs)
    r = r if r else [0]
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [x * x for x in r]
    return r


Take a list of integers; if empty, use a single zero, then pad with zeros to at least three elements, then square each.


Take a list of integers; take values while they are positive, then remove all zero values, then give back the total.


Take a list of integers; take positive values then stop, then exclude zeros, then sum r.


Take a list of integers; keep going while positive, then remove all zero values, then add them up.


Take a list of integers; stop at first non positive, then exclude zeros, then calculate the sum of all elements.


Take a list of integers; take while greater than zero, then remove all zero values, then what's the total.


Take a list of integers; take values while positive, then exclude zeros, then what do they add up to.


def solve(xs):
    r = list(xs)
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    r = [x for x in r if x != 0]
    return sum(r)


Take a list of integers; take values while they are positive, then drop the zeros, then return their sum.


Take a list of integers; take values while they are positive, then remove all zero values, then make each twice as big.


Take a list of integers; take positive values then stop, then exclude zeros, then multiply each by 2.


Take a list of integers; keep going while positive, then remove all zero values, then make each twice as big.


Take a list of integers; stop at first non positive, then exclude zeros, then multiply each by 2.


Take a list of integers; take while greater than zero, then remove all zero values, then make each twice as big.


Take a list of integers; take values while positive, then exclude zeros, then multiply each by 2.


def solve(xs):
    r = list(xs)
    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]
    r = [x for x in r if x != 0]
    r = [x * 2 for x in r]
    return r


Take a list of integers; take values while they are positive, then drop the zeros, then double each.


Take a list of integers; add ten to each, then cut the list at the first zero, then truncate to the last three items.


Take a list of integers; bump everything up by 10, then cut off after the first zero appears, then show only the last three.


Take a list of integers; increase every value by 10, then take values up to (excluding) the first zero, then remove all but the last three.


Take a list of integers; add 10 to each item, then keep the part before the first 0, then take the final 3 elements.


Take a list of integers; shift each up by ten, then truncate at the first zero, then drop everything except the final three.


Take a list of integers; increase all numbers by 10, then delete everything starting with the first zero, then give me the last three elements.


def solve(xs):
    r = list(xs)
    r = [x + 10 for x in r]
    r = r[:r.index(0)] if 0 in r else r
    r = r[-3:]
    return r


Take a list of integers; add ten to each, then keep everything before the first zero, then keep only the last three.


Take a list of integers; keep everything before the first zero, then take the first 3 elements, then drop non-positive values.


Take a list of integers; take only what comes before the initial zero, then remove everything after the third, then drop the negative numbers.


Take a list of integers; cut the list at the first zero, then truncate to three items, then filter out the negative ones.


Take a list of integers; cut off after the first zero appears, then show the first three, then remove all negative values.


Take a list of integers; take values up to (excluding) the first zero, then take the first three, then keep positive values only.


Take a list of integers; keep the part before the first 0, then keep first 3, then keep values above zero.


def solve(xs):
    r = list(xs)
    r = r[:r.index(0)] if 0 in r else r
    r = r[:3]
    r = [x for x in r if x > 0]
    return r


Take a list of integers; keep everything before the first zero, then keep only the first three, then keep the positive numbers.


Take a list of integers; drop duplicates keeping first occurrence, then keep only even values, then drop the even numbers.


Take a list of integers; drop duplicates but keep the first one, then extract all even numbers, then strip out the evens.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = [x for x in r if x % 2 == 0]
    r = [x for x in r if x % 2 != 0]
    return r


Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then keep the odd numbers.


Take a list of integers; keep only the first three, then remove the first item, then drop anything not divisible by three.


Take a list of integers; keep the first 3 items, then Remove head, then filter out everything except multiples of three.


Take a list of integers; take the first 3 elements, then remove the first item, then keep only multiples of three.


Take a list of integers; remove everything after the third, then Remove head, then multiples of three only.


Take a list of integers; truncate to three items, then remove the first item, then filter for numbers divisible by three.


Take a list of integers; show the first three, then Remove head, then give me only the values divisible by three.


def solve(xs):
    r = list(xs)
    r = r[:3]
    r = r[1:]
    r = [x for x in r if x % 3 == 0]
    return r


Take a list of integers; keep only the first three, then drop the first element, then keep multiples of three.


Take a list of integers; keep only the first three, then increase every value by 10, then give the earliest even value or zero.


Take a list of integers; keep the first 3 items, then add 10 to each item, then fetch the first even element, default to 0.


Take a list of integers; take the first 3 elements, then shift each up by ten, then give the earliest even value or zero.


Take a list of integers; remove everything after the third, then increase all numbers by 10, then fetch the first even element, default to 0.


Take a list of integers; truncate to three items, then add 10 to everything, then give the earliest even value or zero.


Take a list of integers; show the first three, then give everything a boost of 10, then fetch the first even element, default to 0.


def solve(xs):
    r = list(xs)
    r = r[:3]
    r = [x + 10 for x in r]
    return next((x for x in r if x % 2 == 0), 0)


Take a list of integers; keep only the first three, then add ten to each, then return the first even value (0 if none).


Take a list of integers; sort by absolute value, then make every value non-negative, then limit every value to 10.


Take a list of integers; rearrange by distance from zero, then absolute value for all items, then maximum of 10 for all.


Take a list of integers; arrange by magnitude ignoring sign, then take absolute values, then limit every value to 10.


Take a list of integers; put them in order by magnitude, then turn negatives into positives, then maximum of 10 for all.


Take a list of integers; arrange in order of absolute value, then abs each element, then limit every value to 10.


Take a list of integers; sort by distance from zero, then take the absolute value of each, then maximum of 10 for all.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=abs)
    r = [abs(x) for x in r]
    r = [min(x, 10) for x in r]
    return r


Take a list of integers; sort by absolute value, then take the absolute value of each, then cap each value at 10.


Take a list of integers; keep the odd numbers, then increment each value, then drop anything not divisible by three.


Take a list of integers; odd numbers only, then plus one for all, then filter out everything except multiples of three.


Take a list of integers; keep the odd numbers, then increment each value, then keep only multiples of three.


Take a list of integers; odd numbers only, then plus one for all, then multiples of three only.


Take a list of integers; keep the odd numbers, then increment each value, then filter for numbers divisible by three.


Take a list of integers; odd numbers only, then plus one for all, then give me only the values divisible by three.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x % 2 != 0]
    r = [x + 1 for x in r]
    r = [x for x in r if x % 3 == 0]
    return r


Take a list of integers; keep the odd numbers, then add one to each, then keep multiples of three.


Take a list of integers; keep only the first three, then drop anything 5 or below, then count the elements.


Take a list of integers; keep the first 3 items, then keep only numbers greater than 5, then how many items remain.


Take a list of integers; take the first 3 elements, then filter for numbers above 5, then tell me the length.


Take a list of integers; remove everything after the third, then give me values where x is greater than 5, then return the length.


Take a list of integers; truncate to three items, then show me only the values that are bigger than five, then count them.


Take a list of integers; show the first three, then keep values greater than five, then what's the count.


def solve(xs):
    r = list(xs)
    r = r[:3]
    r = [x for x in r if x > 5]
    return len(r)


Take a list of integers; keep only the first three, then keep values greater than five, then return how many remain.


Take a list of integers; keep everything before the first zero, then sort smallest to largest, then shift each up by ten.


Take a list of integers; take only what comes before the initial zero, then Ascending sort, then increase all numbers by 10.


Take a list of integers; cut the list at the first zero, then Sort this ascending, then add 10 to everything.


Take a list of integers; cut off after the first zero appears, then Sort lowest to highest, then give everything a boost of 10.


Take a list of integers; take values up to (excluding) the first zero, then Arrange from smallest to largest, then increment each by ten.


Take a list of integers; keep the part before the first 0, then sort ascending, then add a constant 10 to each.


def solve(xs):
    r = list(xs)
    r = r[:r.index(0)] if 0 in r else r
    r = sorted(r)
    r = [x + 10 for x in r]
    return r


Take a list of integers; keep everything before the first zero, then sort ascending, then add ten to each.


Take a list of integers; double each, then extend to length 3 using zeros, then keep only non-zero numbers.


Take a list of integers; times two for each item, then pad to 3, then strip the zeros.


def solve(xs):
    r = list(xs)
    r = [x * 2 for x in r]
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [x for x in r if x != 0]
    return r


Take a list of integers; double each, then pad with zeros to at least three elements, then drop the zeros.


Take a list of integers; drop the first element, then sort largest to smallest, then make each twice as big.


Take a list of integers; Take everything except the first, then sort by descending values, then multiply each by 2.


Take a list of integers; drop the first element, then sort from highest to lowest, then make each twice as big.


Take a list of integers; Take everything except the first, then sort descending, then multiply each by 2.


Take a list of integers; drop the first element, then sort largest first, then make each twice as big.


Take a list of integers; Take everything except the first, then sort in descending order, then multiply each by 2.


def solve(xs):
    r = list(xs)
    r = r[1:]
    r = sorted(r, reverse=True)
    r = [x * 2 for x in r]
    return r


Take a list of integers; drop the first element, then sort descending, then double each.


Take a list of integers; reverse the order, then cut the list at the first zero, then shift each up by ten.


Take a list of integers; reverse, then cut off after the first zero appears, then increase all numbers by 10.


Take a list of integers; flip the list around, then take values up to (excluding) the first zero, then add 10 to everything.


Take a list of integers; flip the order around, then keep the part before the first 0, then give everything a boost of 10.


Take a list of integers; put the elements backwards, then truncate at the first zero, then increment each by ten.


Take a list of integers; reverse that for me, then delete everything starting with the first zero, then add a constant 10 to each.


def solve(xs):
    r = list(xs)
    r = list(reversed(r))
    r = r[:r.index(0)] if 0 in r else r
    r = [x + 10 for x in r]
    return r


Take a list of integers; reverse the order, then keep everything before the first zero, then add ten to each.


Take a list of integers; drop duplicates keeping first occurrence, then clamp each to at most ten, then reduce each by one.


Take a list of integers; drop duplicates but keep the first one, then don't let anything exceed 10, then Subtract 1 from all.


Take a list of integers; drop duplicates keeping first occurrence, then clamp each to at most ten, then Subtract one from each.


Take a list of integers; drop duplicates but keep the first one, then don't let anything exceed 10, then Drop each by one.


Take a list of integers; drop duplicates keeping first occurrence, then clamp each to at most ten, then Decrease all values by one.


Take a list of integers; drop duplicates but keep the first one, then don't let anything exceed 10, then Remove one from each value.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = [min(x, 10) for x in r]
    r = [x - 1 for x in r]
    return r


Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then subtract one from each.


Take a list of integers; keep only the last three, then increase every value by 10, then truncate to three items.


Take a list of integers; keep the final three items, then add 10 to each item, then show the first three.


Take a list of integers; take the last three, then shift each up by ten, then take the first three.


Take a list of integers; trim to the last three, then increase all numbers by 10, then keep first 3.


Take a list of integers; last three only, then add 10 to everything, then truncate to first three.


Take a list of integers; truncate to the last three items, then give everything a boost of 10, then first three.


def solve(xs):
    r = list(xs)
    r = r[-3:]
    r = [x + 10 for x in r]
    r = r[:3]
    return r


Take a list of integers; keep only the last three, then add ten to each, then keep only the first three.


Take a list of integers; drop duplicates keeping first occurrence, then keep values above zero, then multiply each by -1.


Take a list of integers; drop duplicates but keep the first one, then filter for positive numbers, then negate.


Take a list of integers; drop duplicates keeping first occurrence, then keep only positive numbers, then multiply each by -1.


Take a list of integers; drop duplicates but keep the first one, then keep the positives, then negate.


Take a list of integers; drop duplicates keeping first occurrence, then remove negatives, then multiply each by -1.


Take a list of integers; drop duplicates but keep the first one, then keep the positive numbers, then negate.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = [x for x in r if x > 0]
    r = [-x for x in r]
    return r


Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then negate each.


Take a list of integers; keep only the last three, then make every value non-negative, then true if any value equals zero.


Take a list of integers; keep the final three items, then absolute value for all items, then check for zero.


Take a list of integers; take the last three, then take absolute values, then true if any value equals zero.


Take a list of integers; trim to the last three, then turn negatives into positives, then check for zero.


Take a list of integers; last three only, then abs each element, then true if any value equals zero.


Take a list of integers; truncate to the last three items, then take the absolute value of each, then check for zero.


def solve(xs):
    r = list(xs)
    r = r[-3:]
    r = [abs(x) for x in r]
    return 0 in r


Take a list of integers; keep only the last three, then take the absolute value of each, then return whether the list contains a zero.


Take a list of integers; drop the first element, then remove both ends, then shift each up by ten.


Take a list of integers; Take everything except the first, then trim the edges, then increase all numbers by 10.


Take a list of integers; drop the first element, then trim one element off each end, then add 10 to everything.


Take a list of integers; Take everything except the first, then cut off the first and last, then give everything a boost of 10.


Take a list of integers; drop the first element, then remove the first and last elements, then increment each by ten.


Take a list of integers; Take everything except the first, then keep only the middle part, then add a constant 10 to each.


def solve(xs):
    r = list(xs)
    r = r[1:]
    r = r[1:-1]
    r = [x + 10 for x in r]
    return r


Take a list of integers; drop the first element, then drop the first and last elements, then add ten to each.


Take a list of integers; negate each, then make every value non-negative, then find the min, defaulting to 0.


Take a list of integers; reverse the signs of everything, then absolute value for all items, then minimum value, zero otherwise.


Take a list of integers; negate each, then take absolute values, then get the minimum value or zero if empty.


Take a list of integers; reverse the signs of everything, then turn negatives into positives, then give me the min or 0.


Take a list of integers; negate each, then abs each element, then return the smallest number, defaulting to 0.


Take a list of integers; reverse the signs of everything, then take the absolute value of each, then return smallest or zero if empty.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = [abs(x) for x in r]
    return min(r) if r else 0


Take a list of integers; negate each, then take the absolute value of each, then return the minimum (0 if empty).


Take a list of integers; drop the zeros, then keep only odd values, then strip the signs.


Take a list of integers; keep only nonzero elements, then eliminate the even numbers, then take abs of each.


Take a list of integers; drop the zeros, then keep only odd values, then get the absolute value of everything.


Take a list of integers; keep only nonzero elements, then eliminate the even numbers, then apply absolute value to the whole list.


Take a list of integers; drop the zeros, then keep only odd values, then make them all positive.


Take a list of integers; keep only nonzero elements, then eliminate the even numbers, then make every value non-negative.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x != 0]
    r = [x for x in r if x % 2 != 0]
    r = [abs(x) for x in r]
    return r


Take a list of integers; drop the zeros, then keep the odd numbers, then take the absolute value of each.


Take a list of integers; keep the negative numbers, then sort smallest to largest, then deduplicate the list.


Take a list of integers; extract negatives, then Ascending sort, then remove repeats.


Take a list of integers; keep the negative numbers, then Sort this ascending, then deduplicate the list.


Take a list of integers; extract negatives, then Sort lowest to highest, then remove repeats.


Take a list of integers; keep the negative numbers, then Arrange from smallest to largest, then deduplicate the list.


Take a list of integers; extract negatives, then sort ascending, then remove repeats.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x < 0]
    r = sorted(r)
    r = list(dict.fromkeys(r))
    return r


Take a list of integers; keep the negative numbers, then sort ascending, then drop duplicates keeping first occurrence.


Take a list of integers; pad with zeros to at least three elements, then make every value non-negative, then multiply each by -1.


Take a list of integers; add zeros until the list has at least three values, then absolute value for all items, then negate.


Take a list of integers; pad with zeros to at least three elements, then take absolute values, then multiply each by -1.


Take a list of integers; add zeros until the list has at least three values, then turn negatives into positives, then negate.


Take a list of integers; pad with zeros to at least three elements, then abs each element, then multiply each by -1.


Take a list of integers; add zeros until the list has at least three values, then take the absolute value of each, then negate.


def solve(xs):
    r = list(xs)
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    r = [abs(x) for x in r]
    r = [-x for x in r]
    return r


Take a list of integers; pad with zeros to at least three elements, then take the absolute value of each, then negate each.


Take a list of integers; sort descending, then extend to length 3 using zeros, then true if every value is unique.


Take a list of integers; sort largest first, then pad to 3, then check for duplicates in the values.


Take a list of integers; sort in descending order, then extend to length 3 using zeros, then do all values appear only once.


Take a list of integers; sort from greatest to least, then pad to 3, then check that there are no duplicates.


Take a list of integers; sort z to a, then extend to length 3 using zeros, then are the values all unique.


Take a list of integers; arrange in decreasing order, then pad to 3, then check if all values are unique.


def solve(xs):
    r = list(xs)
    r = sorted(r, reverse=True)
    r = r + [0] * (3 - len(r)) if len(r) < 3 else r
    return len(r) == len(set(r))


Take a list of integers; sort descending, then pad with zeros to at least three elements, then return whether all values are distinct.


Take a list of integers; subtract one from each, then keep values above zero, then drop the even numbers.


Take a list of integers; Decrement all items, then filter for positive numbers, then strip out the evens.


Take a list of integers; decrement each value, then keep only positive numbers, then drop the even numbers.


Take a list of integers; Lower each number by one, then keep the positives, then strip out the evens.


Take a list of integers; reduce each by one, then remove negatives, then drop the even numbers.


Take a list of integers; Subtract 1 from all, then keep the positive numbers, then strip out the evens.


def solve(xs):
    r = list(xs)
    r = [x - 1 for x in r]
    r = [x for x in r if x > 0]
    r = [x for x in r if x % 2 != 0]
    return r


Take a list of integers; subtract one from each, then keep the positive numbers, then keep the odd numbers.


Take a list of integers; drop the zeros, then keep values below zero, then reduce each by one.


Take a list of integers; keep only nonzero elements, then get the negative numbers, then Subtract 1 from all.


Take a list of integers; drop the zeros, then keep values below zero, then Subtract one from each.


Take a list of integers; keep only nonzero elements, then get the negative numbers, then Drop each by one.


Take a list of integers; drop the zeros, then keep values below zero, then Decrease all values by one.


Take a list of integers; keep only nonzero elements, then get the negative numbers, then Remove one from each value.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x != 0]
    r = [x for x in r if x < 0]
    r = [x - 1 for x in r]
    return r


Take a list of integers; drop the zeros, then keep the negative numbers, then subtract one from each.


Take a list of integers; sort ascending, then multiply each value by itself, then shift each up by ten.


Take a list of integers; Sort it from low to high, then square them all, then increase all numbers by 10.


Take a list of integers; arrange in increasing order, then raise each to the power of two, then add 10 to everything.


Take a list of integers; Organize these ascending, then I need each number multiplied by itself, then give everything a boost of 10.


Take a list of integers; Sort in ascending order, then square all of them, then increment each by ten.


Take a list of integers; I need this sorted ascending, then multiply each element by itself, then add a constant 10 to each.


def solve(xs):
    r = list(xs)
    r = sorted(r)
    r = [x * x for x in r]
    r = [x + 10 for x in r]
    return r


Take a list of integers; sort ascending, then square each, then add ten to each.


Take a list of integers; drop the first and last elements, then remove the first item, then drop the even numbers.