Take a list of integers; drop duplicates keeping first occurrence, then increment each value, then use zero if the list is empty.


Take a list of integers; drop duplicates but keep the first one, then plus one for all, then default to zero when empty.


Take a list of integers; drop duplicates keeping first occurrence, then increment each value, then if there's nothing, put in a zero.


Take a list of integers; drop duplicates but keep the first one, then plus one for all, then if no items, add a zero.


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


Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then if empty, use a single zero.


Take a list of integers; take the absolute value of each, then keep only even values, then true if at least one even value.


Take a list of integers; convert to absolute value, then extract all even numbers, then any even.


Take a list of integers; strip the signs, then keep only even values, then true if at least one even value.


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


Take a list of integers; get the absolute value of everything, then keep only even values, then true if at least one even value.


Take a list of integers; apply absolute value to the whole list, then extract all even numbers, then any even.


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


Take a list of integers; take the absolute value of each, then keep the even numbers, then return whether any value is even.


Take a list of integers; cap each value at 10, then flip the list around, then ensure at least three items by appending zeros.


Take a list of integers; clip values at 10, then flip the order around, then ensure minimum length of three by adding zeros to the end.


Take a list of integers; cap each value at 10, then put the elements backwards, then ensure at least three items by appending zeros.


Take a list of integers; clip values at 10, then reverse that for me, then ensure minimum length of three by adding zeros to the end.


Take a list of integers; cap each value at 10, then flip it backwards, then ensure at least three items by appending zeros.


Take a list of integers; clip values at 10, then make it backwards, then ensure minimum length of three by adding zeros to the end.


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


Take a list of integers; cap each value at 10, then reverse the order, then pad with zeros to at least three elements.


Take a list of integers; cap each value at 10, then decrement each value, then true if at least one even value.


Take a list of integers; clip values at 10, then Lower each number by one, then any even.


Take a list of integers; cap each value at 10, then reduce each by one, then true if at least one even value.


Take a list of integers; clip values at 10, then Subtract 1 from all, then any even.


Take a list of integers; cap each value at 10, then Subtract one from each, then true if at least one even value.


Take a list of integers; clip values at 10, then Drop each by one, then any even.


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


Take a list of integers; cap each value at 10, then subtract one from each, then return whether any value is even.


Take a list of integers; negate each, then keep values divisible by 3, then give the earliest even value or zero.


Take a list of integers; reverse the signs of everything, then keep items where x mod 3 equals zero, then fetch the first even element, default to 0.


Take a list of integers; negate each, then drop anything not divisible by three, then give the earliest even value or zero.


Take a list of integers; reverse the signs of everything, then filter out everything except multiples of three, then fetch the first even element, default to 0.


Take a list of integers; negate each, then keep only multiples of three, then give the earliest even value or zero.


Take a list of integers; reverse the signs of everything, then multiples of three only, then fetch the first even element, default to 0.


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


Take a list of integers; negate each, then keep multiples of three, then return the first even value (0 if none).


Take a list of integers; keep everything before the first zero, then multiply each value by itself, then give back the total.


Take a list of integers; take only what comes before the initial zero, then square them all, then sum r.


Take a list of integers; cut the list at the first zero, then raise each to the power of two, then add them up.


Take a list of integers; cut off after the first zero appears, then I need each number multiplied by itself, then calculate the sum of all elements.


Take a list of integers; take values up to (excluding) the first zero, then square all of them, then what's the total.


Take a list of integers; keep the part before the first 0, then multiply each element by itself, then what do they add up to.


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


Take a list of integers; keep everything before the first zero, then square each, then return their sum.


Take a list of integers; take values while they are positive, then multiply each by two, then find the min, defaulting to 0.


Take a list of integers; take positive values then stop, then double each item in the list, then minimum value, zero otherwise.


Take a list of integers; keep going while positive, then multiply each by two, then get the minimum value or zero if empty.


Take a list of integers; stop at first non positive, then double each item in the list, then give me the min or 0.


Take a list of integers; take while greater than zero, then multiply each by two, then return the smallest number, defaulting to 0.


Take a list of integers; take values while positive, then double each item in the list, then return smallest or zero if empty.


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


Take a list of integers; take values while they are positive, then double each, then return the minimum (0 if empty).


Take a list of integers; keep values greater than five, then sort smallest to largest, then arrange in decreasing order.


Take a list of integers; filter out values less than or equal to 5, then Ascending sort, then arrange in descending order.


Take a list of integers; keep only numbers above 5, then Sort this ascending, then reverse sort.


Take a list of integers; exclude values of 5 and below, then Sort lowest to highest, then sort largest to smallest.


Take a list of integers; remove anything 5 or less, then Arrange from smallest to largest, then sort by descending values.


Take a list of integers; filter to keep only values above 5, then sort ascending, then sort from highest to lowest.


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


Take a list of integers; keep values greater than five, then sort ascending, then sort descending.


Take a list of integers; add one to each, then increase every value by 10, then take values up to (excluding) the first zero.


Take a list of integers; make each one bigger, then add 10 to each item, then keep the part before the first 0.


Take a list of integers; add one to each, then shift each up by ten, then truncate at the first zero.


Take a list of integers; make each one bigger, then increase all numbers by 10, then delete everything starting with the first zero.


Take a list of integers; add one to each, then add 10 to everything, then remove from the first zero onwards.


Take a list of integers; make each one bigger, then give everything a boost of 10, then up to but not including the first zero.


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


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


Take a list of integers; drop duplicates keeping first occurrence, then drop anything 5 or below, then bump each up by one.


Take a list of integers; drop duplicates but keep the first one, then keep only numbers greater than 5, then increment each item.


Take a list of integers; drop duplicates keeping first occurrence, then filter for numbers above 5, then bump each up by one.


Take a list of integers; drop duplicates but keep the first one, then give me values where x is greater than 5, then increment each item.


Take a list of integers; drop duplicates keeping first occurrence, then show me only the values that are bigger than five, then bump each up by one.


Take a list of integers; drop duplicates but keep the first one, then keep values greater than five, then increment each item.


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


Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five, then add one to each.


Take a list of integers; negate each, then skip negatives at the start, then give back the product of all values.


Take a list of integers; reverse the signs of everything, then remove all negatives at the front, then product of the list.


Take a list of integers; negate each, then remove the initial run of negative numbers, then what's the product.


Take a list of integers; reverse the signs of everything, then strip the front negatives, then what do they multiply to.


Take a list of integers; negate each, then remove leading negative numbers, then give me their product.


Take a list of integers; reverse the signs of everything, then drop negatives from start, then multiply them all together.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]
    return __import__('math').prod(r)


Take a list of integers; negate each, then drop the leading negative values, then return their product.


Take a list of integers; sort by absolute value, then sort smallest to largest, then replace an empty list with one zero.


Take a list of integers; rearrange by distance from zero, then Ascending sort, then zero it out if it's empty.


Take a list of integers; arrange by magnitude ignoring sign, then Sort this ascending, then use zero if the list is empty.


Take a list of integers; put them in order by magnitude, then Sort lowest to highest, then default to zero when empty.


Take a list of integers; arrange in order of absolute value, then Arrange from smallest to largest, then if there's nothing, put in a zero.


Take a list of integers; sort by distance from zero, then sort ascending, then if no items, add a zero.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=abs)
    r = sorted(r)
    r = r if r else [0]
    return r


Take a list of integers; sort by absolute value, then sort ascending, then if empty, use a single zero.


Take a list of integers; sort by absolute value, then increment each value, then ensure at least three items by appending zeros.


Take a list of integers; rearrange by distance from zero, then plus one for all, then ensure minimum length of three by adding zeros to the end.


Take a list of integers; arrange by magnitude ignoring sign, then increment each value, then ensure at least three items by appending zeros.


Take a list of integers; put them in order by magnitude, then plus one for all, then ensure minimum length of three by adding zeros to the end.


Take a list of integers; arrange in order of absolute value, then increment each value, then ensure at least three items by appending zeros.


Take a list of integers; sort by distance from zero, then plus one for all, then ensure minimum length of three by adding zeros to the end.


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


Take a list of integers; sort by absolute value, then add one to each, then pad with zeros to at least three elements.


Take a list of integers; drop the first and last elements, then keep values above zero, then true if already sorted smallest to largest.


Take a list of integers; take out the first and last items, then filter for positive numbers, then does this list go in ascending order.


Take a list of integers; remove both ends, then keep only positive numbers, then check if the list is in ascending order.


Take a list of integers; trim the edges, then keep the positives, then is the list sorted.


Take a list of integers; trim one element off each end, then remove negatives, then is it sorted.


Take a list of integers; cut off the first and last, then keep the positive numbers, then check if values are in increasing order.


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


Take a list of integers; drop the first and last elements, then keep the positive numbers, then return whether the list is sorted ascending.


Take a list of strings; drop empty strings, then add '#' to the start of each string, then remove short strings (under 3 chars).


Take a list of strings; get rid of blanks, then make each one start with a hash, then only keep strings with three or more characters.


Take a list of strings; remove blanks, then add '#' to the start of each string, then keep only strings that are at least three characters long.


Take a list of strings; eliminate empty string values, then make each one start with a hash, then filter strings shorter than 3 chars.


Take a list of strings; filter out blank strings, then add '#' to the start of each string, then drop anything shorter than three characters.


Take a list of strings; remove strings that are empty, then make each one start with a hash, then keep only strings of length 3 or more.


def solve(xs):
    r = list(xs)
    r = [s for s in r if s]
    r = ['#' + s for s in r]
    r = [s for s in r if len(s) >= 3]
    return r


Take a list of strings; drop empty strings, then prefix each with a hash, then drop strings shorter than three characters.


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


Take a list of integers; clip values at 10, then Remove head, then keep the part before the first 0.


Take a list of integers; cap each value at 10, then remove the first item, then truncate at the first zero.


Take a list of integers; clip values at 10, then Remove head, then delete everything starting with the first zero.


Take a list of integers; cap each value at 10, then remove the first item, then remove from the first zero onwards.


Take a list of integers; clip values at 10, then Remove head, then up to but not including the first zero.


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


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


Take a list of integers; negate each, then take the first 3 elements, then arrange in decreasing order.


Take a list of integers; reverse the signs of everything, then remove everything after the third, then arrange in descending order.


Take a list of integers; negate each, then truncate to three items, then reverse sort.


Take a list of integers; reverse the signs of everything, then show the first three, then sort largest to smallest.


Take a list of integers; negate each, then take the first three, then sort by descending values.


Take a list of integers; reverse the signs of everything, then keep first 3, then sort from highest to lowest.


def solve(xs):
    r = list(xs)
    r = [-x for x in r]
    r = r[:3]
    r = sorted(r, reverse=True)
    return r


Take a list of integers; negate each, then keep only the first three, then sort descending.


Take a list of integers; keep values greater than five, then keep values below zero, then give the number of evens.


Take a list of integers; filter out values less than or equal to 5, then get the negative numbers, then find how many values are divisible by two.


Take a list of integers; keep only numbers above 5, then keep values below zero, then how many are even.


Take a list of integers; exclude values of 5 and below, then get the negative numbers, then get the total number of even values in the list.


Take a list of integers; remove anything 5 or less, then keep values below zero, then give me the count of even values.


Take a list of integers; filter to keep only values above 5, then get the negative numbers, then I need to know how many of these are even.


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


Take a list of integers; keep values greater than five, then keep the negative numbers, then return how many values are even.


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


Take a list of integers; get rid of non-multiples of three, then plus one for all, then strip out the evens.


Take a list of integers; keep values divisible by 3, then increment each value, then drop the even numbers.


Take a list of integers; keep items where x mod 3 equals zero, then plus one for all, then strip out the evens.


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


Take a list of integers; filter out everything except multiples of three, then plus one for all, then strip out the evens.


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


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


Take a list of strings; prefix each with a hash, then convert each to upper case, then remove blanks.


Take a list of strings; add # to the start of each string, then change all strings to uppercase, then eliminate empty string values.


Take a list of strings; prefix each with a hash, then make every string uppercase, then filter out blank strings.


Take a list of strings; add # to the start of each string, then uppercase each one, then remove strings that are empty.


Take a list of strings; prefix each with a hash, then make all the strings uppercase, then strip out empty strings.


Take a list of strings; add # to the start of each string, then convert all strings to uppercase letters, then keep only non-empty strings.


def solve(xs):
    r = list(xs)
    r = ['#' + s for s in r]
    r = [s.upper() for s in r]
    r = [s for s in r if s]
    return r


Take a list of strings; prefix each with a hash, then uppercase each string, then drop empty strings.


Take a list of strings; sort by length, shortest first, then convert each to upper case, then remove blanks.


Take a list of strings; sort ascending by length, then change all strings to uppercase, then eliminate empty string values.


Take a list of strings; order strings from shortest to longest, then make every string uppercase, then filter out blank strings.


Take a list of strings; shortest to longest, then uppercase each one, then remove strings that are empty.


Take a list of strings; arrange by string length ascending, then make all the strings uppercase, then strip out empty strings.


Take a list of strings; length sort, then convert all strings to uppercase letters, then keep only non-empty strings.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=len)
    r = [s.upper() for s in r]
    r = [s for s in r if s]
    return r


Take a list of strings; sort by length, shortest first, then uppercase each string, then drop empty strings.


Take a list of integers; keep only the last three, then clamp each to at most ten, then reduce each by one.


Take a list of integers; keep the final three items, then don't let anything exceed 10, then Subtract 1 from all.


Take a list of integers; take the last three, then clamp each to at most ten, then Subtract one from each.


Take a list of integers; trim to the last three, then don't let anything exceed 10, then Drop each by one.


Take a list of integers; last three only, then clamp each to at most ten, then Decrease all values by one.


Take a list of integers; truncate to the last three items, then don't let anything exceed 10, then Remove one from each value.


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


Take a list of integers; keep only the last three, then cap each value at 10, then subtract one from each.


Take a list of strings; sort by length, shortest first, then add '#' to the start of each string, then deduplicate the strings.


Take a list of strings; sort ascending by length, then make each one start with a hash, then filter out duplicate strings retain first.


Take a list of strings; order strings from shortest to longest, then add '#' to the start of each string, then strip duplicates preserve order.


Take a list of strings; shortest to longest, then make each one start with a hash, then remove repeated strings.


Take a list of strings; arrange by string length ascending, then add '#' to the start of each string, then keep unique strings first appearance.


Take a list of strings; length sort, then make each one start with a hash, then eliminate repeated strings preserve first occurrence.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=len)
    r = ['#' + s for s in r]
    r = list(dict.fromkeys(r))
    return r


Take a list of strings; sort by length, shortest first, then prefix each with a hash, then drop duplicate strings keeping the first.