Find two distinct subsets of a list that add up to the same value
Some "more pythonic" suggestions which also improve performance:


use Counter.elements()


in partition_into_equal_parts this code:

second = []
# Fill second with items from counter
second_counter = Counter(l) - Counter(first)
for number, amount in second_counter.items():
    second.extend([number] * amount)


can be merely replaced by

second = list((Counter(l) - Counter(first)).elements()


As Counter.elements returns a chained iterable of the expanded elements according to their count. So no need to do that with a loop and an extra list.


Cache the indexed element


In recursive_calculate, you have to use the index in

for idx in range(start, len(lst)):


but why not storing lst[idx] in a local variable? It's repeated a lot of times, and accessing a list element is costly. Just cache this access since you're not writing in lst (well you're writing to the end of it, recursively, but lst[idx] isn't udpated because the index is low enough).

def recursive_calculate(k, lst, start):
    for idx in range(start, len(lst)):
        element = lst[idx]
        if element == k:
            return [element]
        elif element &lt; k:
            rest = recursive_calculate(k - element, lst, idx + 1)
            if rest is not None:
                rest.append(element)
                return rest
    return None


Small note: python functions implicitly return None, but "Explicit is better than implicit" (The Zen Of Python) so it's better to actually return it.