how can I reduce the memory usage of a python script?

I am trying to solve a Python problem and while my code works it exceeds the memory usage limit.
I tried to reduce the number of variables but It wasn't enough.

I would like to know how to approach a problem of this kind

here's my code

class Solution(object):
    def threeSum(self, nums):
        
        duos = {}
        triple = {}
        for num1 in nums:
            del nums[nums.index(num1)]
            for num2 in nums :
                duos[tuple([num1,num2])] = num1 + num2
            nums.insert(0, num1)
       
        for duo in duos:
            del nums [nums.index(duo[0])]
            del nums [nums.index(duo[-1])]
            for num in nums:
                if duo[0] + duo[-1] + num == 0:
                    x = [duo[0],duo[-1],num]
                    x.sort()
                    triple[tuple(x)] = 1

            nums.insert(0,duo[0])
            nums.insert(0,duo[-1])
        return triple    

and here is a link to the problem I tried solving:
https://leetcode.com/problems/3sum/

One simple (naive) way would be to go through every distinct pair of items and check if the inverse of their sum is in the rest of the list.

You don't need to make any change to the input list and you can use a set to ensure that you only keep unique triplets (which you can store as sorted tuples to ensure that order of values isn't treated as different triplets):

def zeroSumTriplets(nums):
    result = set()
    for i,a in enumerate(nums[:-2],1):
        for j,b in enumerate(nums[i:-1],i+1):
            if -a-b not in nums[j:]: continue
            triplet = tuple(sorted([a,b,-a-b]))
            result.add(triplet)
    return list(result)

nums = [-1,0,1,2,-1,-4]
print(zeroSumTriplets(nums)) # [(-1, -1, 2), (-1, 0, 1)]

How it works:

for i,a in enumerate(nums[:-2],1) goes through the numbers collecting an index (i) and a number (a) for the first part of the triplet. It leaves out the last two items of the list (nums[:-2]) because there needs to be room for two more numbers to form a triplet. The index (i) starts at 1 and represents the starting point for the second numbers. So, as we move the first item forward, the subsequent items will always start at the next available position (never backwards).

for j,b in enumerate(nums[i:-1],i+1) goes through the numbers starting immediately after the current first item and runs down the list again to form the second part of the triplet. It leave out the last item (nums[i:-1]) because we need room for one more to form a triplet.

For each of the (a,b) pairs, we want to find a third item in the rest of the list (starting from j) that will make the sum equal to zero. At this point we know exactly what value this item should have. It must be 0 - a - b because sum(a, b, 0-a-b) will be zero if we can complete the triplet (a,b,...) with that exact third number. So we dont actually need to make any more addition, just checking if -a-b is present in the list will tell us if the a,b pair can be used in a triplet that sums up to zero. This is why checking if -a-b not in nums[j:] is enough to decide if the triplet (a, b, -a-b) exists.

Since the problem only wants distinct triplets, wee need to make sure that similar triplets (e.g. [2,-1,-1] and [-1,2,-1]) which are actually the same 3 numbers are only output once. By sorting the values, both [2,-1,-1] and [-1,2,-1] will become [-1,-1,2]. We can then store this sorted triplet in a set (which only keeps one of each distinct values). The only issue with this is that a set cannot store lists. It can however store tuples so we convert the sorted values to a tuple before adding it to the set.

In the end the result is the content of the set, which is output as a list.

Note that there are ways to make this more efficient, using a set to check the presence of the inverse and binary search to skip over partial sums but this should give you a reasonable starting point

replace return with yield and see if the memory doesn't overflow, it will probably work.