Take a list of strings; sort alphabetically.


Take a list of strings; arrange alphabetically.


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


Take a list of integers; drop the zeros.


Take a list of integers; keep only nonzero elements.


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


Take a list of integers; keep the negative numbers.


Take a list of integers; extract negatives.


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


Take a list of integers; return whether the list is sorted ascending.


Take a list of integers; verify the list is sorted ascending.


Take a list of integers; true if already sorted smallest to largest.


Take a list of integers; does this list go in ascending order.


Take a list of integers; check if the list is in ascending order.


Take a list of integers; is the list sorted.


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


Take a list of integers; sort by absolute value.


Take a list of integers; rearrange by distance from zero.


Take a list of integers; arrange by magnitude ignoring sign.


Take a list of integers; put them in order by magnitude.


Take a list of integers; arrange in order of absolute value.


Take a list of integers; sort by distance from zero.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=abs)
    return r


Take a list of people records (name, age); extract the ages.


Take a list of people records (name, age); show me all ages.


Take a list of people records (name, age); pluck the age field from each record.


Take a list of people records (name, age); get the age field.


Take a list of people records (name, age); keep just each person's age.


Take a list of people records (name, age); extract age values.


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


Take a list of strings; keep the first character of each (dropping empties).


Take a list of strings; extract initial letters.


Take a list of strings; take each string's first letter.


Take a list of strings; give me the first letter of everything.


Take a list of strings; reduce each string to its first character.


Take a list of strings; take first char drop blanks.


def solve(xs):
    r = list(xs)
    r = [s[0] for s in r if s]
    return r


Take a list of integers; each value squared.


Take a list of integers; multiply each value by itself.


Take a list of integers; square them all.


Take a list of integers; raise each to the power of two.


Take a list of integers; I need each number multiplied by itself.


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


Take a list of integers; subtract one from each.


Take a list of integers; Decrement all items.


Take a list of integers; decrement each value.


Take a list of integers; Lower each number by one.


Take a list of integers; reduce each by one.


Take a list of integers; Subtract 1 from all.


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


Take a list of integers; pad with zeros to at least three elements.


Take a list of integers; add zeros until the list has at least three values.


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


Take a list of people records (name, age); sort records by age, youngest first.


Take a list of people records (name, age); put the youngest at the top.


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


Take a list of strings; return the total number of characters.


Take a list of strings; sum the lengths of all strings.


Take a list of strings; sum up all the characters across everything and tell me what you get.


Take a list of strings; count characters across all strings.


Take a list of strings; character count.


def solve(xs):
    r = list(xs)
    return sum(len(s) for s in r)


Take a list of strings; trim whitespace from each.


Take a list of strings; strip whitespace from every element.


Take a list of strings; remove surrounding whitespace.


Take a list of strings; trim the whitespace off everything.


Take a list of strings; strip spaces from all strings.


Take a list of strings; strip all the strings.


def solve(xs):
    r = list(xs)
    r = [s.strip() for s in r]
    return r


Take a list of strings; return how many strings remain.


Take a list of strings; give me the total number of strings.


Take a list of strings; tell me how many strings we have.


Take a list of strings; what's the string count.


Take a list of strings; count the remaining strings.


Take a list of strings; how many strings are left.


def solve(xs):
    r = list(xs)
    return len(r)


Take a list of integers; return whether all values are positive.


Take a list of integers; is everything positive.


Take a list of integers; true only if all are positive.


Take a list of integers; do all of these have positive values.


Take a list of integers; check if every value is positive.


Take a list of integers; confirm all values are positive.


def solve(xs):
    r = list(xs)
    return all(x > 0 for x in r)


Take a list of integers; sort descending.


Take a list of integers; sort largest first.


Take a list of integers; sort in descending order.


Take a list of integers; sort from greatest to least.


Take a list of integers; arrange in decreasing order.


def solve(xs):
    r = list(xs)
    r = sorted(r, reverse=True)
    return r


Take a list of people records (name, age); extract the names.


Take a list of people records (name, age); Give me the names.


Take a list of people records (name, age); pluck the name field from each record.


Take a list of people records (name, age); Grab the names.


Take a list of people records (name, age); keep just each person's name.


Take a list of people records (name, age); List the names.


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


Take a list of integers; keep the even numbers.


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


Take a list of people records (name, age); return how many records remain.


Take a list of people records (name, age); Tell me how many records we have.


Take a list of people records (name, age); give the number of people.


Take a list of people records (name, age); How many records still exist.


Take a list of people records (name, age); Count the remaining records.


Take a list of people records (name, age); Total records.


Take a list of integers; keep the odd numbers.


Take a list of integers; odd numbers only.


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


Take a list of integers; if empty, use a single zero.


Take a list of integers; if blank use 0.


Take a list of integers; default to [0] when there is nothing.


Take a list of integers; when the list is empty, substitute a zero value.


Take a list of integers; replace an empty list with one zero.


Take a list of integers; zero it out if it's empty.


def solve(xs):
    r = list(xs)
    r = r if r else [0]
    return r


Take a list of integers; drop the leading negative values.


Take a list of integers; cut the leading negatives.


Take a list of integers; skip negatives at the start.


Take a list of integers; remove all negatives at the front.


Take a list of integers; remove the initial run of negative numbers.


Take a list of integers; strip the front negatives.


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


Take a list of integers; keep only the first three.


Take a list of integers; keep the first 3 items.


Take a list of integers; take the first 3 elements.


Take a list of integers; remove everything after the third.


Take a list of integers; truncate to three items.


Take a list of integers; show the first three.


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


Take a list of integers; drop the first element.


Take a list of integers; Take everything except the first.


def solve(xs):
    r = list(xs)
    r = r[1:]
    return r


Take a list of integers; return their sum.


Take a list of integers; add them all up.


Take a list of integers; add all those together.


Take a list of integers; give back the total.


def solve(xs):
    r = list(xs)
    return sum(r)


Take a list of strings; drop strings shorter than three characters.


Take a list of strings; eliminate strings below length three.


Take a list of strings; remove short strings (under 3 chars).


Take a list of strings; only keep strings with three or more characters.


Take a list of strings; keep only strings that are at least three characters long.


Take a list of strings; filter strings shorter than 3 chars.


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


Take a list of integers; return how many remain.


Take a list of integers; how many are left.


Take a list of integers; just the length please.


Take a list of integers; how much is still there.


Take a list of integers; count the elements.


def solve(xs):
    r = list(xs)
    return len(r)


Take a list of integers; keep values greater than five.


Take a list of integers; filter out values less than or equal to 5.


Take a list of integers; keep only numbers above 5.


Take a list of integers; exclude values of 5 and below.


Take a list of integers; remove anything 5 or less.


Take a list of integers; filter to keep only values above 5.


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


Take a list of integers; reverse the order.


Take a list of integers; flip the list around.


Take a list of integers; flip the order around.


Take a list of integers; put the elements backwards.


Take a list of integers; reverse that for me.


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


Take a list of integers; return whether the list contains a zero.


Take a list of integers; does it contain zero.


def solve(xs):
    r = list(xs)
    return 0 in r


Take a list of integers; sort ascending.


Take a list of integers; Sort it from low to high.


Take a list of integers; arrange in increasing order.


Take a list of integers; Organize these ascending.


Take a list of integers; Sort in ascending order.


Take a list of integers; I need this sorted ascending.


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


Take a list of integers; drop the first and last elements.


Take a list of integers; take out the first and last items.


Take a list of integers; remove both ends.


Take a list of integers; trim the edges.


Take a list of integers; trim one element off each end.


Take a list of integers; cut off the first and last.


def solve(xs):
    r = list(xs)
    r = r[1:-1]
    return r


Take a list of integers; return their product.


Take a list of integers; calculate the product.


Take a list of integers; give back the product of all values.


Take a list of integers; product of the list.


Take a list of integers; what's the product.


Take a list of integers; what do they multiply to.


def solve(xs):
    r = list(xs)
    return __import__('math').prod(r)


Take a list of strings; lowercase each string.


Take a list of strings; change to lowercase.


def solve(xs):
    r = list(xs)
    r = [s.lower() for s in r]
    return r


Take a list of integers; times two for each item.


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


Take a list of integers; keep everything before the first zero.


Take a list of integers; take only what comes before the initial zero.


Take a list of integers; cut the list at the first zero.


Take a list of integers; cut off after the first zero appears.


Take a list of integers; take values up to (excluding) the first zero.


Take a list of integers; keep the part before the first 0.


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


Take a list of integers; return how many values are even.


Take a list of integers; return the number of even items.


Take a list of integers; count the even numbers.


Take a list of integers; what's the even count.


Take a list of integers; give the number of evens.


Take a list of integers; find how many values are divisible by two.


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


Take a list of integers; take the absolute value of each.


Take a list of integers; convert to absolute value.


Take a list of integers; strip the signs.


Take a list of integers; take abs of each.


Take a list of integers; get the absolute value of everything.


Take a list of integers; apply absolute value to the whole list.


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


Take a list of integers; keep only the last three.


Take a list of integers; keep the final three items.


Take a list of integers; take the last three.


Take a list of integers; trim to the last three.


Take a list of integers; last three only.


Take a list of integers; truncate to the last three items.


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


Take a list of strings; return whether any string is empty.


Take a list of strings; find if any string is empty.


Take a list of strings; true if a blank string is present.


Take a list of strings; check for empty strings in the list.


Take a list of strings; check if there's an empty string.


Take a list of strings; does the collection contain an empty string value somewhere.


def solve(xs):
    r = list(xs)
    return any(s == '' for s in r)


Take a list of integers; take values while they are positive.


Take a list of integers; take positive values then stop.


Take a list of integers; keep going while positive.


Take a list of integers; stop at first non positive.


Take a list of integers; take while greater than zero.


Take a list of integers; take values while positive.


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


Take a list of integers; add one to each.


Take a list of integers; make each one bigger.


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


Take a list of integers; return whether any value is even.


Take a list of integers; tell me if any element is even.


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


Take a list of integers; return the maximum (0 if empty).


Take a list of integers; Max value please, zero if none exist.


Take a list of integers; find the max, defaulting to 0.


Take a list of integers; Give me the maximum, but 0 if there are no items.


Take a list of integers; What's the highest number in the list.


Take a list of integers; Return the greatest value or default to 0.


def solve(xs):
    r = list(xs)
    return max(r) if r else 0


Take a list of integers; reverse the signs of everything.


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


Take a list of people records (name, age); return the name of the oldest person (empty if none).


Take a list of people records (name, age); what's the oldest person's name.


def solve(xs):
    r = list(xs)
    return max(r, key=lambda d: d['age'])['name'] if r else ''


Take a list of integers; drop duplicates keeping first occurrence.


Take a list of integers; drop duplicates but keep the first one.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    return r


Take a list of integers; add ten to each.


Take a list of integers; bump everything up by 10.


Take a list of integers; increase every value by 10.


Take a list of integers; add 10 to each item.


Take a list of integers; shift each up by ten.


Take a list of integers; increase all numbers by 10.


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


Take a list of strings; uppercase each string.


Take a list of strings; make it all caps.


Take a list of strings; convert each to upper case.


Take a list of strings; change all strings to uppercase.


Take a list of strings; make every string uppercase.


Take a list of strings; uppercase each one.


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


Take a list of strings; join them with commas.


Take a list of strings; make it comma delimited.


Take a list of strings; concatenate with commas between.


Take a list of strings; add commas between items.


Take a list of strings; return them as one comma-separated string.


Take a list of strings; separate by comma.


def solve(xs):
    r = list(xs)
    return ','.join(r)


Take a list of integers; return the minimum (0 if empty).


Take a list of integers; the minimum value with a default of zero.


Take a list of integers; give the smallest value (0 if none).


Take a list of integers; what's the smallest element, or 0 if there's nothing.


Take a list of integers; find the min, defaulting to 0.


Take a list of integers; minimum value, zero otherwise.


def solve(xs):
    r = list(xs)
    return min(r) if r else 0


Take a list of integers; return the first even value (0 if none).


Take a list of integers; what's the first even number.


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


Take a list of strings; sort by length, shortest first.


Take a list of strings; sort ascending by length.


Take a list of strings; order strings from shortest to longest.


Take a list of strings; shortest to longest.


Take a list of strings; arrange by string length ascending.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=len)
    return r


Take a list of strings; return the longest string (empty if none).


Take a list of strings; Give the longest string if any exist.


def solve(xs):
    r = list(xs)
    return max(r, key=len) if r else ''


Take a list of integers; keep multiples of three.


Take a list of integers; get rid of non-multiples of three.


Take a list of integers; keep values divisible by 3.


Take a list of integers; keep items where x mod 3 equals zero.


Take a list of integers; drop anything not divisible by three.


Take a list of integers; filter out everything except multiples of three.


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


Take a list of integers; cap each value at 10.


Take a list of integers; clip values at 10.


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


Take a list of integers; keep the positive numbers.


Take a list of integers; get rid of anything that's not positive.


Take a list of integers; drop non-positive values.


Take a list of integers; drop the negative numbers.


Take a list of integers; filter out the negative ones.


Take a list of integers; remove all negative values.


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


Take a list of strings; drop duplicate strings keeping the first.


Take a list of strings; remove duplicate strings keep first.


Take a list of strings; remove repeating strings first one stays.


Take a list of strings; delete duplicate strings keep the first one.


Take a list of strings; deduplicate the strings.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    return r


Take a list of strings; return the length of the longest string (0 if none).


Take a list of strings; how long is the longest string.


Take a list of strings; find the longest string length.


Take a list of strings; longest string length please.


Take a list of strings; return longest string length.


Take a list of strings; find how long the longest string is.


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


Take a list of integers; return whether all values are distinct.


Take a list of integers; tell me if values are distinct.


Take a list of integers; are all values distinct.


Take a list of integers; do any values repeat.


Take a list of integers; verify all values are different.


Take a list of integers; true if every value is unique.


def solve(xs):
    r = list(xs)
    return len(r) == len(set(r))


Take a list of strings; drop empty strings.


Take a list of strings; get rid of blanks.


Take a list of strings; eliminate empty string values.


Take a list of strings; filter out blank strings.


Take a list of strings; remove strings that are empty.


def solve(xs):
    r = list(xs)
    r = [s for s in r if s]
    return r


Take a list of strings; prefix each with a hash.


Take a list of strings; add # to the start of each string.


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


Take a list of integers; drop duplicates keeping first occurrence, then default to [0] when there is nothing.


Take a list of integers; drop duplicates but keep the first one, then when the list is empty, substitute a zero value.


Take a list of integers; drop duplicates keeping first occurrence, then replace an empty list with one zero.


Take a list of integers; drop duplicates but keep the first one, then zero it out if it's empty.


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


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


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = r if r else [0]
    return r


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


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


Take a list of integers; if blank use 0, then pad to 3.


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


Take a list of integers; when the list is empty, substitute a zero value, then pad to 3.


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


Take a list of integers; zero it out if it's empty, then pad to 3.


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


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


Take a list of people records (name, age); extract the ages, then multiply each value by itself.


Take a list of people records (name, age); show me all ages, then square them all.


Take a list of people records (name, age); pluck the age field from each record, then raise each to the power of two.


Take a list of people records (name, age); get the age field, then I need each number multiplied by itself.


Take a list of people records (name, age); keep just each person's age, then square all of them.


Take a list of people records (name, age); extract age values, then multiply each element by itself.


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


Take a list of people records (name, age); extract the ages, then square each.


Take a list of strings; trim whitespace from each, then order strings from shortest to longest.


Take a list of strings; strip whitespace from every element, then shortest to longest.


Take a list of strings; remove surrounding whitespace, then arrange by string length ascending.


Take a list of strings; trim the whitespace off everything, then length sort.


Take a list of strings; strip spaces from all strings, then sort by length shortest first.


Take a list of strings; strip all the strings, then organize by string length least to greatest.


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


Take a list of strings; trim whitespace from each, then sort by length, shortest first.


Take a list of integers; keep only the last three, then remove both ends.


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


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


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


Take a list of integers; last three only, then remove the first and last elements.


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


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


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


Take a list of integers; keep only the first three, then add them all up.


Take a list of integers; keep the first 3 items, then add all those together.


Take a list of integers; take the first 3 elements, then give back the total.


Take a list of integers; remove everything after the third, then sum r.


Take a list of integers; truncate to three items, then add them up.


Take a list of integers; show the first three, then calculate the sum of all elements.


def solve(xs):
    r = list(xs)
    r = r[:3]
    return sum(r)


Take a list of integers; keep only the first three, then return their sum.


Take a list of integers; keep the negative numbers, then keep values divisible by 3.


Take a list of integers; extract negatives, then keep items where x mod 3 equals zero.


Take a list of integers; keep the negative numbers, then drop anything not divisible by three.


Take a list of integers; extract negatives, then filter out everything except multiples of three.


Take a list of integers; keep the negative numbers, then keep only multiples of three.


Take a list of integers; extract negatives, then multiples of three only.


def solve(xs):
    r = list(xs)
    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; keep the negative numbers, then keep multiples of three.


Take a list of integers; negate each, then keep the leading run of positive numbers.


Take a list of integers; reverse the signs of everything, then take values while they are positive.


Take a list of integers; negate each, then take positive values then stop.


Take a list of integers; reverse the signs of everything, then keep going while positive.


Take a list of integers; negate each, then stop at first non positive.


Take a list of integers; reverse the signs of everything, then take while greater than zero.


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 r


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


Take a list of integers; keep the positive numbers, then remove all zero values.


Take a list of integers; get rid of anything that's not positive, then exclude zeros.


Take a list of integers; drop non-positive values, then remove all zero values.


Take a list of integers; drop the negative numbers, then exclude zeros.


Take a list of integers; filter out the negative ones, then remove all zero values.


Take a list of integers; remove all negative values, then exclude zeros.


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


Take a list of integers; keep the positive numbers, then drop the zeros.


Take a list of integers; keep only the last three, then keep values divisible by 3.


Take a list of integers; keep the final three items, then keep items where x mod 3 equals zero.


Take a list of integers; take the last three, then drop anything not divisible by three.


Take a list of integers; trim to the last three, then filter out everything except multiples of three.


Take a list of integers; last three only, then keep only multiples of three.


Take a list of integers; truncate to the last three items, then multiples of three only.


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


Take a list of integers; keep only the last three, then keep multiples of three.


Take a list of integers; reverse the order, then check if values are in increasing order.


Take a list of integers; reverse, then give me a yes or no if the list is sorted.


Take a list of integers; flip the list around, then is this list sorted.


Take a list of integers; flip the order around, then determine whether the list is sorted in ascending order from smallest to largest value.


Take a list of integers; put the elements backwards, then tell me if it's sorted ascending.


Take a list of integers; reverse that for me, then return whether the list is sorted ascending.


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


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


Take a list of strings; lowercase each string, then convert each to upper case.


Take a list of strings; change to lowercase, then change all strings to uppercase.


Take a list of strings; lowercase each string, then make every string uppercase.


Take a list of strings; change to lowercase, then uppercase each one.


Take a list of strings; lowercase each string, then make all the strings uppercase.


Take a list of strings; change to lowercase, then convert all strings to uppercase letters.


def solve(xs):
    r = list(xs)
    r = [s.lower() for s in r]
    r = [s.upper() for s in r]
    return r


Take a list of strings; lowercase each string, then uppercase each string.


Take a list of integers; if empty, use a single zero, then count the even numbers.


Take a list of integers; if blank use 0, then what's the even count.


Take a list of integers; default to [0] when there is nothing, then give the number of evens.


Take a list of integers; when the list is empty, substitute a zero value, then find how many values are divisible by two.


Take a list of integers; replace an empty list with one zero, then how many are even.


Take a list of integers; zero it out if it's empty, then get the total number of even values in the list.


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


Take a list of integers; if empty, use a single zero, then return how many values are even.


Take a list of strings; drop empty strings, then convert each to lower case.


Take a list of strings; get rid of blanks, then lowercase each one.


Take a list of strings; remove blanks, then convert each to lower case.


Take a list of strings; eliminate empty string values, then lowercase each one.


Take a list of strings; filter out blank strings, then convert each to lower case.


Take a list of strings; remove strings that are empty, then lowercase each one.


def solve(xs):
    r = list(xs)
    r = [s for s in r if s]
    r = [s.lower() for s in r]
    return r


Take a list of strings; drop empty strings, then lowercase each string.


Take a list of integers; keep everything before the first zero, then drop anything 5 or below.


Take a list of integers; take only what comes before the initial zero, then keep only numbers greater than 5.


Take a list of integers; cut the list at the first zero, then filter for numbers above 5.


Take a list of integers; cut off after the first zero appears, then give me values where x is greater than 5.


Take a list of integers; take values up to (excluding) the first zero, then show me only the values that are bigger than five.


Take a list of integers; keep the part before the first 0, then keep values greater than five.


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


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


Take a list of strings; drop duplicate strings keeping the first, then order strings from shortest to longest.


Take a list of strings; dedupe, then shortest to longest.


Take a list of strings; remove duplicate strings keep first, then arrange by string length ascending.


Take a list of strings; remove repeating strings first one stays, then length sort.


Take a list of strings; delete duplicate strings keep the first one, then sort by length shortest first.


Take a list of strings; deduplicate the strings, then organize by string length least to greatest.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = sorted(r, key=len)
    return r


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


Take a list of integers; add one to each, then give the largest value (0 if none).


Take a list of integers; make each one bigger, then The biggest one, or 0 if it's empty.


Take a list of integers; add one to each, then Get the maximum value, or zero if there's nothing.


Take a list of integers; make each one bigger, then What's the max here.


Take a list of integers; add one to each, then Return the max or 0 if empty.


Take a list of integers; make each one bigger, then return the maximum (0 if empty).


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


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


Take a list of integers; sort descending, then keep only even values.


Take a list of integers; sort largest first, then extract all even numbers.


Take a list of integers; sort in descending order, then keep only even values.


Take a list of integers; sort from greatest to least, then extract all even numbers.


Take a list of integers; sort z to a, then keep only even values.


Take a list of integers; arrange in decreasing order, then extract all even numbers.


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


Take a list of integers; sort descending, then keep the even numbers.


Take a list of integers; drop the first and last elements, then check if values are in increasing order.


Take a list of integers; take out the first and last items, then give me a yes or no if the list is sorted.


Take a list of integers; remove both ends, then is this list sorted.


Take a list of integers; trim the edges, then determine whether the list is sorted in ascending order from smallest to largest value.


Take a list of integers; trim one element off each end, then tell me if it's sorted ascending.


Take a list of integers; cut off the first and last, then return whether the list is sorted ascending.


def solve(xs):
    r = list(xs)
    r = r[1:-1]
    return r == sorted(r)


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


Take a list of integers; keep the positive numbers, then increment each value.


Take a list of integers; get rid of anything that's not positive, then plus one for all.


Take a list of integers; drop non-positive values, then increment each value.


Take a list of integers; drop the negative numbers, then plus one for all.


Take a list of integers; filter out the negative ones, then increment each value.


Take a list of integers; remove all negative values, then plus one for all.


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


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


Take a list of strings; prefix each with a hash, then concatenate with commas between.


Take a list of strings; add # to the start of each string, then add commas between items.


Take a list of strings; prefix each with a hash, then return them as one comma-separated string.


Take a list of strings; add # to the start of each string, then separate by comma.


Take a list of strings; prefix each with a hash, then join with commas.


Take a list of strings; add # to the start of each string, then comma join.


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


Take a list of strings; prefix each with a hash, then join them with commas.


Take a list of integers; keep the even numbers, then remove both ends.


Take a list of integers; keep evens, then trim the edges.


Take a list of integers; keep the even numbers, then trim one element off each end.


Take a list of integers; keep evens, then cut off the first and last.


Take a list of integers; keep the even numbers, then remove the first and last elements.


Take a list of integers; keep evens, then keep only the middle part.


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


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


Take a list of integers; add one to each, then flip the sign of each.


Take a list of integers; make each one bigger, then turn positives to negatives and vice versa.


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


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


Take a list of integers; drop the zeros, then check if zero appears.


Take a list of integers; keep only nonzero elements, then find out whether there's a zero in here.


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


Take a list of integers; drop the zeros, then return whether the list contains a zero.


Take a list of integers; subtract one from each, then multiply them all together.


Take a list of integers; Decrement all items, then multiply them all.


Take a list of integers; decrement each value, then multiply all the numbers together.


Take a list of integers; Lower each number by one, then get the product.


Take a list of integers; reduce each by one, then find the product of these.


Take a list of integers; Subtract 1 from all, then return their product.


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


Take a list of integers; subtract one from each, then return their product.


Take a list of integers; double each, then remove the first item.


Take a list of integers; times two for each item, then Remove head.


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


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


Take a list of integers; if empty, use a single zero, then keep only odd values.


Take a list of integers; if blank use 0, then eliminate the even numbers.


Take a list of integers; default to [0] when there is nothing, then keep only odd values.


Take a list of integers; when the list is empty, substitute a zero value, then eliminate the even numbers.


Take a list of integers; replace an empty list with one zero, then keep only odd values.


Take a list of integers; zero it out if it's empty, then eliminate the even numbers.


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


Take a list of integers; if empty, use a single zero, then keep the odd numbers.


Take a list of integers; drop duplicates keeping first occurrence, then remove both ends.


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


Take a list of integers; drop duplicates keeping first occurrence, then trim one element off each end.


Take a list of integers; drop duplicates but keep the first one, then cut off the first and last.


Take a list of integers; drop duplicates keeping first occurrence, then remove the first and last elements.


Take a list of integers; drop duplicates but keep the first one, then keep only the middle part.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = r[1:-1]
    return r


Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements.


Take a list of integers; keep values greater than five, then add them all up.


Take a list of integers; filter out values less than or equal to 5, then add all those together.


Take a list of integers; keep only numbers above 5, then give back the total.


Take a list of integers; exclude values of 5 and below, then sum r.


Take a list of integers; remove anything 5 or less, then add them up.


Take a list of integers; filter to keep only values above 5, then calculate the sum of all elements.


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


Take a list of integers; keep values greater than five, then return their sum.


Take a list of integers; if empty, use a single zero, then keep values divisible by 3.


Take a list of integers; if blank use 0, then keep items where x mod 3 equals zero.


Take a list of integers; default to [0] when there is nothing, then drop anything not divisible by three.


Take a list of integers; when the list is empty, substitute a zero value, then filter out everything except multiples of three.


Take a list of integers; replace an empty list with one zero, then keep only multiples of three.


Take a list of integers; zero it out if it's empty, then multiples of three only.


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


Take a list of integers; if empty, use a single zero, then keep multiples of three.


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


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


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]
    return r


Take a list of integers; drop the zeros, then keep the odd numbers.


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


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


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


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


Take a list of integers; negate each, then take the first three.


Take a list of integers; reverse the signs of everything, then keep first 3.


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


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


Take a list of integers; square each, then cut the list at the first zero.


Take a list of integers; each value squared, then cut off after the first zero appears.


Take a list of integers; multiply each value by itself, then take values up to (excluding) the first zero.


Take a list of integers; square them all, then keep the part before the first 0.


Take a list of integers; raise each to the power of two, then truncate at the first zero.


Take a list of integers; I need each number multiplied by itself, then delete everything starting with the first zero.


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


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


Take a list of integers; drop the leading negative values, then extend to length 3 using zeros.


Take a list of integers; cut the leading negatives, then pad to 3.


Take a list of integers; skip negatives at the start, then extend to length 3 using zeros.


Take a list of integers; remove all negatives at the front, then pad to 3.


Take a list of integers; remove the initial run of negative numbers, then extend to length 3 using zeros.


Take a list of integers; strip the front negatives, then pad to 3.


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 r


Take a list of integers; drop the leading negative values, then pad with zeros to at least three elements.


Take a list of integers; negate each, then extend to length 3 using zeros.


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


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


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


Take a list of integers; take the absolute value of each, then clamp each to at most ten.


Take a list of integers; convert to absolute value, then don't let anything exceed 10.


Take a list of integers; strip the signs, then clamp each to at most ten.


Take a list of integers; take abs of each, then don't let anything exceed 10.


Take a list of integers; get the absolute value of everything, then clamp each to at most ten.


Take a list of integers; apply absolute value to the whole list, then don't let anything exceed 10.


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


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


Take a list of integers; drop the zeros, then cut the list at the first zero.


Take a list of integers; keep only nonzero elements, then cut off after the first zero appears.


Take a list of integers; drop the zeros, then take values up to (excluding) the first zero.


Take a list of integers; keep only nonzero elements, then keep the part before the first 0.


Take a list of integers; drop the zeros, then truncate at the first zero.


Take a list of integers; keep only nonzero elements, then delete everything starting with the first zero.


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


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


Take a list of strings; drop empty strings, then check for an empty string.


Take a list of strings; get rid of blanks, then are there empty strings.


Take a list of strings; remove blanks, then is any string empty.


Take a list of strings; eliminate empty string values, then any blanks.


Take a list of strings; filter out blank strings, then do any of the strings have no characters.


Take a list of strings; remove strings that are empty, then return whether any string is empty.


def solve(xs):
    r = list(xs)
    r = [s for s in r if s]
    return any(s == '' for s in r)


Take a list of strings; drop empty strings, then return whether any string is empty.


Take a list of integers; subtract one from each, then clamp each to at most ten.


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


Take a list of integers; decrement each value, then clamp each to at most ten.


Take a list of integers; Lower each number by one, then don't let anything exceed 10.


Take a list of integers; reduce each by one, then clamp each to at most ten.


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


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


Take a list of integers; subtract one from each, then cap each value at 10.


Take a list of integers; sort ascending, then skip negatives at the start.


Take a list of integers; Sort it from low to high, then remove all negatives at the front.


Take a list of integers; arrange in increasing order, then remove the initial run of negative numbers.


Take a list of integers; Organize these ascending, then strip the front negatives.


Take a list of integers; Sort in ascending order, then remove leading negative numbers.


Take a list of integers; I need this sorted ascending, then drop negatives from start.


def solve(xs):
    r = list(xs)
    r = sorted(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 drop the leading negative values.


Take a list of integers; keep everything before the first zero, then order by distance from zero.


Take a list of integers; take only what comes before the initial zero, then sort based on absolute value.


Take a list of integers; cut the list at the first zero, then organize by magnitude.


Take a list of integers; cut off after the first zero appears, then arrange by absolute value ascending.


Take a list of integers; take values up to (excluding) the first zero, then sort from smallest to largest absolute value.


Take a list of integers; keep the part before the first 0, then sort by absolute value.


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


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


Take a list of integers; add one to each, then return the length.


Take a list of integers; make each one bigger, then count them.


Take a list of integers; add one to each, then what's the count.


Take a list of integers; make each one bigger, then return how many remain.


Take a list of integers; add one to each, then what's left.


Take a list of integers; make each one bigger, then how many are left.


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


Take a list of integers; add one to each, then return how many remain.


Take a list of integers; keep only the last three, then keep values above zero.


Take a list of integers; keep the final three items, then filter for positive numbers.


Take a list of integers; take the last three, then keep only positive numbers.


Take a list of integers; trim to the last three, then keep the positives.


Take a list of integers; last three only, then remove negatives.


Take a list of integers; truncate to the last three items, then keep the positive numbers.


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


Take a list of integers; keep only the last three, then keep the positive numbers.


Take a list of strings; trim whitespace from each, then give back the lengthiest string.


Take a list of strings; strip whitespace from every element, then Longest string please.


Take a list of strings; remove surrounding whitespace, then give back the lengthiest string.


Take a list of strings; trim the whitespace off everything, then Longest string please.


Take a list of strings; strip spaces from all strings, then give back the lengthiest string.


Take a list of strings; strip all the strings, then Longest string please.


def solve(xs):
    r = list(xs)
    r = [s.strip() for s in r]
    return max(r, key=len) if r else ''


Take a list of strings; trim whitespace from each, then return the longest string (empty if none).


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


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


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


Take a list of integers; Take everything except the first, then strip the front negatives.


Take a list of integers; drop the first element, then remove leading negative numbers.


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


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


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


Take a list of integers; sort descending, then extend to length 3 using zeros.


Take a list of integers; sort largest first, then pad to 3.


Take a list of integers; sort in descending order, then extend to length 3 using zeros.


Take a list of integers; sort from greatest to least, then pad to 3.


Take a list of integers; sort z to a, then extend to length 3 using zeros.


Take a list of integers; arrange in decreasing order, then pad to 3.


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


Take a list of integers; sort descending, then pad with zeros to at least three elements.


Take a list of integers; if empty, use a single zero, then return the length.


Take a list of integers; if blank use 0, then count them.


Take a list of integers; default to [0] when there is nothing, then what's the count.


Take a list of integers; when the list is empty, substitute a zero value, then return how many remain.


Take a list of integers; replace an empty list with one zero, then what's left.


Take a list of integers; zero it out if it's empty, then how many are left.


def solve(xs):
    r = list(xs)
    r = r if r else [0]
    return len(r)


Take a list of integers; if empty, use a single zero, then return how many remain.


Take a list of integers; if empty, use a single zero, then keep values below zero.


Take a list of integers; if blank use 0, then get the negative numbers.


Take a list of integers; default to [0] when there is nothing, then keep values below zero.


Take a list of integers; when the list is empty, substitute a zero value, then get the negative numbers.


Take a list of integers; replace an empty list with one zero, then keep values below zero.


Take a list of integers; zero it out if it's empty, then get the negative numbers.


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


Take a list of integers; if empty, use a single zero, then keep the negative numbers.


Take a list of integers; keep only the first three, then give the largest value (0 if none).


Take a list of integers; keep the first 3 items, then The biggest one, or 0 if it's empty.


Take a list of integers; take the first 3 elements, then Get the maximum value, or zero if there's nothing.


Take a list of integers; remove everything after the third, then What's the max here.


Take a list of integers; truncate to three items, then Return the max or 0 if empty.


Take a list of integers; show the first three, then return the maximum (0 if empty).


def solve(xs):
    r = list(xs)
    r = r[:3]
    return max(r) if r else 0


Take a list of integers; keep only the first three, then return the maximum (0 if empty).


Take a list of integers; drop the first and last elements, then take the first 3 elements.


Take a list of integers; take out the first and last items, then remove everything after the third.


Take a list of integers; remove both ends, then truncate to three items.


Take a list of integers; trim the edges, then show the first three.


Take a list of integers; trim one element off each end, then take the first three.


Take a list of integers; cut off the first and last, then keep first 3.


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


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


Take a list of strings; prefix each with a hash, then check for an empty string.


Take a list of strings; add # to the start of each string, then are there empty strings.


Take a list of strings; prefix each with a hash, then is any string empty.


Take a list of strings; add # to the start of each string, then any blanks.


Take a list of strings; prefix each with a hash, then do any of the strings have no characters.


Take a list of strings; add # to the start of each string, then return whether any string is empty.


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


Take a list of strings; prefix each with a hash, then return whether any string is empty.


Take a list of integers; subtract one from each, then multiply each by two.


Take a list of integers; Decrement all items, then double each item in the list.


Take a list of integers; decrement each value, then multiply each by two.


Take a list of integers; Lower each number by one, then double each item in the list.


Take a list of integers; reduce each by one, then multiply each by two.


Take a list of integers; Subtract 1 from all, then double each item in the list.


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


Take a list of integers; subtract one from each, then double each.


Take a list of integers; drop the first and last elements, then find the first even number, defaulting to 0.


Take a list of integers; take out the first and last items, then first even value zero if not found.


Take a list of integers; remove both ends, then find the first even number, defaulting to 0.


Take a list of integers; trim the edges, then first even value zero if not found.


Take a list of integers; trim one element off each end, then find the first even number, defaulting to 0.


Take a list of integers; cut off the first and last, then first even value zero if not found.


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


Take a list of integers; drop the first and last elements, then return the first even value (0 if none).


Take a list of integers; drop the first element, then extend to length 3 using zeros.


Take a list of integers; Take everything except the first, then pad to 3.


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


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


Take a list of integers; pad with zeros to at least three elements, then give the smallest value (0 if none).


Take a list of integers; add zeros until the list has at least three values, then what's the smallest element, or 0 if there's nothing.


Take a list of integers; pad with zeros to at least three elements, then find the min, defaulting to 0.


Take a list of integers; add zeros until the list has at least three values, then minimum value, zero otherwise.


Take a list of integers; pad with zeros to at least three elements, then get the minimum value or zero if empty.


Take a list of integers; add zeros until the list has at least three values, then give me the min or 0.


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


Take a list of integers; pad with zeros to at least three elements, then return the minimum (0 if empty).


Take a list of strings; drop strings shorter than three characters, then keep only non-empty strings.


Take a list of strings; eliminate strings below length three, then filter empty strings.


Take a list of strings; remove short strings (under 3 chars), then remove empty strings from the list.


Take a list of strings; only keep strings with three or more characters, then clean up empty strings.


Take a list of strings; keep only strings that are at least three characters long, then delete empty entries.


Take a list of strings; filter strings shorter than 3 chars, then drop empty strings.


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


Take a list of strings; drop strings shorter than three characters, then drop empty strings.


Take a list of integers; keep everything before the first zero, then skip negatives at the start.


Take a list of integers; take only what comes before the initial zero, then remove all negatives at the front.


Take a list of integers; cut the list at the first zero, then remove the initial run of negative numbers.


Take a list of integers; cut off after the first zero appears, then strip the front negatives.


Take a list of integers; take values up to (excluding) the first zero, then remove leading negative numbers.


Take a list of integers; keep the part before the first 0, then drop negatives from start.


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


Take a list of integers; keep everything before the first zero, then drop the leading negative values.


Take a list of strings; sort by length, shortest first, then take each string's first letter.


Take a list of strings; sort ascending by length, then give me the first letter of everything.


Take a list of strings; order strings from shortest to longest, then reduce each string to its first character.


Take a list of strings; shortest to longest, then take first char drop blanks.


Take a list of strings; arrange by string length ascending, then keep first letters only.


Take a list of strings; length sort, then first letter from each item that isn't empty.


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


Take a list of strings; sort by length, shortest first, then keep the first character of each (dropping empties).


Take a list of strings; drop duplicate strings keeping the first, then strip spaces around each string.


Take a list of strings; dedupe, then remove leading and trailing spaces.


Take a list of strings; remove duplicate strings keep first, then remove whitespace from each item.


Take a list of strings; remove repeating strings first one stays, then clean whitespace from each entry.


Take a list of strings; delete duplicate strings keep the first one, then trim each string.


Take a list of strings; deduplicate the strings, then trim whitespace from each.


def solve(xs):
    r = list(xs)
    r = list(dict.fromkeys(r))
    r = [s.strip() for s in r]
    return r


Take a list of strings; drop duplicate strings keeping the first, then trim whitespace from each.


Take a list of integers; keep the odd numbers, then check that there are no duplicates.


Take a list of integers; odd numbers only, then are the values all unique.


Take a list of integers; keep the odd numbers, then check if all values are unique.


Take a list of integers; odd numbers only, then return whether all values are distinct.


Take a list of integers; keep the odd numbers, then tell me if values are distinct.


Take a list of integers; odd numbers only, then are all values distinct.


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


Take a list of integers; keep the odd numbers, then return whether all values are distinct.


Take a list of integers; drop the leading negative values, then default to [0] when there is nothing.


Take a list of integers; cut the leading negatives, then when the list is empty, substitute a zero value.


Take a list of integers; skip negatives at the start, then replace an empty list with one zero.


Take a list of integers; remove all negatives at the front, then zero it out if it's empty.


Take a list of integers; remove the initial run of negative numbers, then use zero if the list is empty.


Take a list of integers; strip the front negatives, then default to zero when empty.


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


Take a list of integers; drop the leading negative values, then if empty, use a single zero.


Take a list of integers; add ten to each, then keep values divisible by 3.


Take a list of integers; bump everything up by 10, then keep items where x mod 3 equals zero.


Take a list of integers; increase every value by 10, then drop anything not divisible by three.


Take a list of integers; add 10 to each item, then filter out everything except multiples of three.


Take a list of integers; shift each up by ten, then keep only multiples of three.


Take a list of integers; increase all numbers by 10, then multiples of three only.


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


Take a list of integers; add ten to each, then keep multiples of three.


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


Take a list of integers; clip values at 10, then cut off after the first zero appears.


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


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


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


Take a list of integers; clip values at 10, then delete everything starting with the first 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
    return r


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


Take a list of integers; keep multiples of three, then cut the list at the first zero.


Take a list of integers; get rid of non-multiples of three, then cut off after the first zero appears.


Take a list of integers; keep values divisible by 3, then take values up to (excluding) the first zero.


Take a list of integers; keep items where x mod 3 equals zero, then keep the part before the first 0.


Take a list of integers; drop anything not divisible by three, then truncate at the first zero.


Take a list of integers; filter out everything except multiples of three, then delete everything starting with the first zero.


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


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


Take a list of integers; drop the zeros, then check that there are no duplicates.


Take a list of integers; keep only nonzero elements, then are the values all unique.


Take a list of integers; drop the zeros, then check if all values are unique.


Take a list of integers; keep only nonzero elements, then return whether all values are distinct.


Take a list of integers; drop the zeros, then tell me if values are distinct.


Take a list of integers; keep only nonzero elements, then are all values distinct.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x != 0]
    return len(r) == len(set(r))


Take a list of integers; drop the zeros, then return whether all values are distinct.


Take a list of integers; keep only the last three, then give the smallest value (0 if none).


Take a list of integers; keep the final three items, then what's the smallest element, or 0 if there's nothing.


Take a list of integers; take the last three, then find the min, defaulting to 0.


Take a list of integers; trim to the last three, then minimum value, zero otherwise.


Take a list of integers; last three only, then get the minimum value or zero if empty.


Take a list of integers; truncate to the last three items, then give me the min or 0.


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


Take a list of integers; keep only the last three, then return the minimum (0 if empty).


Take a list of integers; reverse the order, then skip negatives at the start.


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


Take a list of integers; flip the list around, then remove the initial run of negative numbers.


Take a list of integers; flip the order around, then strip the front negatives.


Take a list of integers; put the elements backwards, then remove leading negative numbers.


Take a list of integers; reverse that for me, then drop negatives from start.


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


Take a list of integers; reverse the order, then drop the leading negative values.


Take a list of integers; drop the leading negative values, then sort largest to smallest.


Take a list of integers; cut the leading negatives, then sort by descending values.


Take a list of integers; skip negatives at the start, then sort from highest to lowest.


Take a list of integers; remove all negatives at the front, then sort descending.


Take a list of integers; remove the initial run of negative numbers, then sort largest first.


Take a list of integers; strip the front negatives, then sort in descending order.


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


Take a list of integers; drop the leading negative values, then sort descending.


Take a list of integers; double each, then drop anything 5 or below.


Take a list of integers; times two for each item, then keep only numbers greater than 5.


Take a list of integers; double each, then filter for numbers above 5.


Take a list of integers; times two for each item, then give me values where x is greater than 5.


Take a list of integers; double each, then show me only the values that are bigger than five.


Take a list of integers; times two for each item, then keep values greater than five.


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


Take a list of integers; double each, then keep values greater than five.


Take a list of strings; keep the first character of each (dropping empties), then convert each to upper case.


Take a list of strings; extract initial letters, then change all strings to uppercase.


Take a list of strings; take each string's first letter, then make every string uppercase.


Take a list of strings; give me the first letter of everything, then uppercase each one.


Take a list of strings; reduce each string to its first character, then make all the strings uppercase.


Take a list of strings; take first char drop blanks, then convert all strings to uppercase letters.


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


Take a list of strings; keep the first character of each (dropping empties), then uppercase each string.


Take a list of integers; subtract one from each, then make every value non-negative.


Take a list of integers; Decrement all items, then absolute value for all items.


Take a list of integers; decrement each value, then take absolute values.


Take a list of integers; Lower each number by one, then turn negatives into positives.


Take a list of integers; reduce each by one, then abs each element.


Take a list of integers; Subtract 1 from all, then take the absolute value of each.


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


Take a list of integers; subtract one from each, then take the absolute value of each.


Take a list of integers; take values while they are positive, then keep values above zero.


Take a list of integers; take positive values then stop, then filter for positive numbers.


Take a list of integers; keep going while positive, then keep only positive numbers.


Take a list of integers; stop at first non positive, then keep the positives.


Take a list of integers; take while greater than zero, then remove negatives.


Take a list of integers; take values while positive, then keep the positive numbers.


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 r


Take a list of integers; take values while they are positive, then keep the positive numbers.


Take a list of integers; negate each, then default to [0] when there is nothing.


Take a list of integers; reverse the signs of everything, then when the list is empty, substitute a zero value.


Take a list of integers; negate each, then replace an empty list with one zero.


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


Take a list of integers; negate each, then use zero if the list is empty.


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


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


Take a list of integers; negate each, then if empty, use a single zero.


Take a list of integers; keep only the first three, then keep only odd values.


Take a list of integers; keep the first 3 items, then eliminate the even numbers.


Take a list of integers; take the first 3 elements, then keep only odd values.


Take a list of integers; remove everything after the third, then eliminate the even numbers.


Take a list of integers; truncate to three items, then keep only odd values.


Take a list of integers; show the first three, then eliminate the even numbers.


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


Take a list of integers; keep only the first three, then keep the odd numbers.


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


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


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


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


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


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


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]
    return r


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


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


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


Take a list of people records (name, age); pluck the age field from each record, then take positive values then stop.


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


Take a list of people records (name, age); keep just each person's age, then stop at first non positive.


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


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 r


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


Take a list of strings; sort alphabetically, then convert each to upper case.


Take a list of strings; arrange alphabetically, then change all strings to uppercase.


Take a list of strings; sort alphabetically, then make every string uppercase.


Take a list of strings; arrange alphabetically, then uppercase each one.


Take a list of strings; sort alphabetically, then make all the strings uppercase.


Take a list of strings; arrange alphabetically, then convert all strings to uppercase letters.


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


Take a list of strings; sort alphabetically, then uppercase each string.


Take a list of integers; drop the zeros, then keep the leading run of positive numbers.


Take a list of integers; keep only nonzero elements, then take values while they are positive.


Take a list of integers; drop the zeros, then take positive values then stop.


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


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


Take a list of integers; keep only nonzero elements, then take while greater than zero.


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


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


Take a list of integers; subtract one from each, then keep only odd values.


Take a list of integers; Decrement all items, then eliminate the even numbers.


Take a list of integers; decrement each value, then keep only odd values.


Take a list of integers; Lower each number by one, then eliminate the even numbers.


Take a list of integers; reduce each by one, then keep only odd values.


Take a list of integers; Subtract 1 from all, then eliminate the even numbers.


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


Take a list of integers; subtract one from each, then keep the odd numbers.


Take a list of integers; cap each value at 10, then give the smallest value (0 if none).


Take a list of integers; clip values at 10, then what's the smallest element, or 0 if there's nothing.


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


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


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


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


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


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


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


Take a list of integers; get rid of non-multiples of three, then eliminate the even numbers.


Take a list of integers; keep values divisible by 3, then keep only odd values.


Take a list of integers; keep items where x mod 3 equals zero, then eliminate the even numbers.


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


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


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


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


Take a list of integers; square each, then multiply each by two.


Take a list of integers; each value squared, then double each item in the list.


Take a list of integers; multiply each value by itself, then multiply each by two.


Take a list of integers; square them all, then double each item in the list.


Take a list of integers; raise each to the power of two, then multiply each by two.


Take a list of integers; I need each number multiplied by itself, then double each item in the list.


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


Take a list of integers; square each, then double each.


Take a list of strings; keep the first character of each (dropping empties), then give the maximum string length.


Take a list of strings; extract initial letters, then max length of all strings.


Take a list of strings; take each string's first letter, then what's the max string length.


Take a list of strings; give me the first letter of everything, then return the length of the longest string (0 if none).


Take a list of strings; reduce each string to its first character, then how long is the longest string.


Take a list of strings; take first char drop blanks, then find the longest string length.


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


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


Take a list of integers; keep only the first three, then extend to length 3 using zeros.


Take a list of integers; keep the first 3 items, then pad to 3.


Take a list of integers; take the first 3 elements, then extend to length 3 using zeros.


Take a list of integers; remove everything after the third, then pad to 3.


Take a list of integers; truncate to three items, then extend to length 3 using zeros.


Take a list of integers; show the first three, then pad to 3.


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


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


Take a list of integers; keep the even numbers, then return the length.


Take a list of integers; keep evens, then count them.


Take a list of integers; keep the even numbers, then what's the count.


Take a list of integers; keep evens, then return how many remain.


Take a list of integers; keep the even numbers, then what's left.


Take a list of integers; keep evens, then how many are left.


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


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


Take a list of integers; sort ascending, then keep values below zero.


Take a list of integers; Sort it from low to high, then get the negative numbers.


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


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


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


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


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


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


Take a list of integers; sort by absolute value, then add them all up.


Take a list of integers; rearrange by distance from zero, then add all those together.


Take a list of integers; arrange by magnitude ignoring sign, then give back the total.


Take a list of integers; put them in order by magnitude, then sum r.


Take a list of integers; arrange in order of absolute value, then add them up.


Take a list of integers; sort by distance from zero, then calculate the sum of all elements.


def solve(xs):
    r = list(xs)
    r = sorted(r, key=abs)
    return sum(r)


Take a list of integers; sort by absolute value, then return their sum.


Take a list of integers; drop the first and last elements, then increase every value by 10.


Take a list of integers; take out the first and last items, then add 10 to each item.


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


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


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


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


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


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


Take a list of integers; drop duplicates keeping first occurrence, then keep values divisible by 3.


Take a list of integers; drop duplicates but keep the first one, then keep items where x mod 3 equals zero.


Take a list of integers; drop duplicates keeping first occurrence, then drop anything not divisible by three.


Take a list of integers; drop duplicates but keep the first one, then filter out everything except multiples of three.


Take a list of integers; drop duplicates keeping first occurrence, then keep only multiples of three.


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


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


Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three.


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


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


Take a list of integers; keep going while positive, then flip the sign of each.


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


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


Take a list of integers; take values while positive, then turn positives to negatives and vice versa.


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 r


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


Take a list of integers; keep the odd numbers, then check if values are in increasing order.


Take a list of integers; odd numbers only, then give me a yes or no if the list is sorted.


Take a list of integers; keep the odd numbers, then is this list sorted.


Take a list of integers; odd numbers only, then determine whether the list is sorted in ascending order from smallest to largest value.


Take a list of integers; keep the odd numbers, then tell me if it's sorted ascending.


Take a list of integers; odd numbers only, then return whether the list is sorted ascending.


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


Take a list of integers; keep the odd numbers, then return whether the list is sorted ascending.


Take a list of integers; keep everything before the first zero, then remove the first item.


Take a list of integers; take only what comes before the initial zero, then Remove head.


Take a list of integers; cut the list at the first zero, then remove the first item.


Take a list of integers; cut off after the first zero appears, then Remove head.


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


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


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


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


Take a list of integers; drop the zeros, then drop anything 5 or below.


Take a list of integers; keep only nonzero elements, then keep only numbers greater than 5.


Take a list of integers; drop the zeros, then filter for numbers above 5.


Take a list of integers; keep only nonzero elements, then give me values where x is greater than 5.


Take a list of integers; drop the zeros, then show me only the values that are bigger than five.


Take a list of integers; keep only nonzero elements, then keep values greater than five.


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


Take a list of integers; drop the zeros, then keep values greater than five.


Take a list of integers; keep values greater than five, then multiply them all together.


Take a list of integers; filter out values less than or equal to 5, then multiply them all.


Take a list of integers; keep only numbers above 5, then multiply all the numbers together.


Take a list of integers; exclude values of 5 and below, then get the product.


Take a list of integers; remove anything 5 or less, then find the product of these.


Take a list of integers; filter to keep only values above 5, then return their product.


def solve(xs):
    r = list(xs)
    r = [x for x in r if x > 5]
    return __import__('math').prod(r)


Take a list of integers; keep values greater than five, then return their product.


Take a list of integers; sort ascending, then increase every value by 10.


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


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


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


Take a list of integers; Sort in ascending order, then add 10 to everything.


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


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


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


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


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


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


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


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


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


def solve(xs):
    r = list(xs)
    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; keep everything before the first zero, then add ten to each.


Take a list of integers; keep only the first three, then count the even numbers.


Take a list of integers; keep the first 3 items, then what's the even count.


Take a list of integers; take the first 3 elements, then give the number of evens.


Take a list of integers; remove everything after the third, then find how many values are divisible by two.


Take a list of integers; truncate to three items, then how many are even.


Take a list of integers; show the first three, then get the total number of even values in the list.


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


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


Take a list of integers; keep the odd numbers, then flip the list around.


Take a list of integers; odd numbers only, then flip the order around.


Take a list of integers; keep the odd numbers, then put the elements backwards.


Take a list of integers; odd numbers only, then reverse that for me.


Take a list of integers; keep the odd numbers, then flip it backwards.


Take a list of integers; odd numbers only, then make it backwards.


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


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


Take a list of integers; square each, then give the largest value (0 if none).


Take a list of integers; each value squared, then The biggest one, or 0 if it's empty.


Take a list of integers; multiply each value by itself, then Get the maximum value, or zero if there's nothing.


Take a list of integers; square them all, then What's the max here.


Take a list of integers; raise each to the power of two, then Return the max or 0 if empty.


Take a list of integers; I need each number multiplied by itself, then return the maximum (0 if empty).


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


Take a list of integers; square each, then return the maximum (0 if empty).


Take a list of integers; keep multiples of three, then give the largest value (0 if none).


Take a list of integers; get rid of non-multiples of three, then The biggest one, or 0 if it's empty.


Take a list of integers; keep values divisible by 3, then Get the maximum value, or zero if there's nothing.


Take a list of integers; keep items where x mod 3 equals zero, then What's the max here.


Take a list of integers; drop anything not divisible by three, then Return the max or 0 if empty.


Take a list of integers; filter out everything except multiples of three, then return the maximum (0 if empty).


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


Take a list of integers; keep multiples of three, then return the maximum (0 if empty).


Take a list of integers; pad with zeros to at least three elements, then check if zero appears.


Take a list of integers; add zeros until the list has at least three values, then find out whether there's a zero in here.


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


Take a list of integers; pad with zeros to at least three elements, then return whether the list contains a zero.


Take a list of integers; keep multiples of three, then remove repeated values.


Take a list of integers; get rid of non-multiples of three, then unique values preserving order.


Take a list of integers; keep values divisible by 3, then remove repeated values.


Take a list of integers; keep items where x mod 3 equals zero, then unique values preserving order.


Take a list of integers; drop anything not divisible by three, then remove repeated values.


Take a list of integers; filter out everything except multiples of three, then unique values preserving order.


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


Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence.


Take a list of integers; take the absolute value of each, then remove both ends.


Take a list of integers; convert to absolute value, then trim the edges.


Take a list of integers; strip the signs, then trim one element off each end.


Take a list of integers; take abs of each, then cut off the first and last.


Take a list of integers; get the absolute value of everything, then remove the first and last elements.


Take a list of integers; apply absolute value to the whole list, then keep only the middle part.


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


Take a list of integers; take the absolute value of each, then drop the first and last elements.


Take a list of integers; double each, then default to [0] when there is nothing.


Take a list of integers; times two for each item, then when the list is empty, substitute a zero value.


Take a list of integers; double each, then replace an empty list with one zero.


Take a list of integers; times two for each item, then zero it out if it's empty.


Take a list of integers; double each, then use zero if the list is empty.


Take a list of integers; times two for each item, then default to zero when empty.


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


Take a list of integers; double each, then if empty, use a single zero.


Take a list of people records (name, age); extract the ages, then keep values divisible by 3.


Take a list of people records (name, age); show me all ages, then keep items where x mod 3 equals zero.


Take a list of people records (name, age); pluck the age field from each record, then drop anything not divisible by three.


Take a list of people records (name, age); get the age field, then filter out everything except multiples of three.


Take a list of people records (name, age); keep just each person's age, then keep only multiples of three.


Take a list of people records (name, age); extract age values, then multiples of three only.


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


Take a list of people records (name, age); extract the ages, then keep multiples of three.


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


Take a list of integers; each value squared, then pad to 3.


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


Take a list of integers; square them all, then pad to 3.


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


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


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
    return r


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


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


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


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


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


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


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


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


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


Take a list of integers; keep the positive numbers, then flip the list around.


Take a list of integers; get rid of anything that's not positive, then flip the order around.


Take a list of integers; drop non-positive values, then put the elements backwards.


Take a list of integers; drop the negative numbers, then reverse that for me.


Take a list of integers; filter out the negative ones, then flip it backwards.


Take a list of integers; remove all negative values, then make it backwards.


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


Take a list of integers; keep the positive numbers, then reverse the order.


Take a list of integers; add one to each, then default to [0] when there is nothing.


Take a list of integers; make each one bigger, then when the list is empty, substitute a zero value.


Take a list of integers; add one to each, then replace an empty list with one zero.


Take a list of integers; make each one bigger, then zero it out if it's empty.


Take a list of integers; add one to each, then use zero if the list is empty.


Take a list of integers; make each one bigger, then default to zero when empty.


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


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


Take a list of integers; drop the zeros, then add them all up.


Take a list of integers; keep only nonzero elements, then add all those together.


Take a list of integers; drop the zeros, then give back the total.


Take a list of integers; keep only nonzero elements, then sum r.


Take a list of integers; drop the zeros, then add them up.


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


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


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


Take a list of integers; negate each, then count the even numbers.


Take a list of integers; reverse the signs of everything, then what's the even count.


Take a list of integers; negate each, then give the number of evens.


Take a list of integers; reverse the signs of everything, then find how many values are divisible by two.


Take a list of integers; negate each, then how many are even.


Take a list of integers; reverse the signs of everything, then get the total number of even values in the list.


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


Take a list of integers; negate each, then return how many values are even.


Take a list of integers; sort descending, then find the first even number, defaulting to 0.


Take a list of integers; sort largest first, then first even value zero if not found.


Take a list of integers; sort in descending order, then find the first even number, defaulting to 0.


Take a list of integers; sort from greatest to least, then first even value zero if not found.


Take a list of integers; sort z to a, then find the first even number, defaulting to 0.