Leetcode #77 Combinations - Not sure what is wrong with this syntax

It should be self.dfs(result, temp, 0, n, k). So change to self.dfs wherever you are using dfs

In this example, dfs is a method on Solution, so when using it from other methods on Solution you want to call self.dfs instead of dfs. Alternatively, you could move the definition of dfs outside of the class, like so:

def dfs(...):
   ...

class Solution:
   ...

I assume that the reason these are methods on a class is something about the format of leetcode's interface that requires the use of classes rather than free-standing functions, but probably it would be more idiomatic in Python for dfs to be a free-standing function rather than a method in most cases. Generally if something doesn't need to use the self argument and doesn't need to be called by something that only has a reference to a specific object, there's no need to make it a method.

It's not the best idea to use itertools.combinations for solving these algorithm problems, but just in case you didn't know, here we can solve the problem with that.

This'll pass:

class Solution:
    def combine(self, n, k):
        return tuple(itertools.combinations(range(1, n + 1), k))

Here are some of LeetCode's solutions with comments, implementing the same idea:

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        # init first combination
        nums = list(range(1, k + 1)) + [n + 1]
        
        output, j = [], 0
        while j < k:
            # add current combination
            output.append(nums[:k])
            # increase first nums[j] by one
            # if nums[j] + 1 != nums[j + 1]
            j = 0
            while j < k and nums[j + 1] == nums[j] + 1:
                nums[j] = j + 1
                j += 1
            nums[j] += 1
            
        return output

With backtracking:

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        def backtrack(first = 1, curr = []):
            # if the combination is done
            if len(curr) == k:  
                output.append(curr[:])
            for i in range(first, n + 1):
                # add i into the current combination
                curr.append(i)
                # use next integers to complete the combination
                backtrack(i + 1, curr)
                # backtrack
                curr.pop()
        
        output = []
        backtrack()
        return output

References

• For additional details, please see the Discussion Board which you can find plenty of well-explained accepted solutions in there, with a variety of languages including efficient algorithms and asymptotic time/space complexity analysis^{1, 2}.

If you declare the functions inside the Solution class, then you have to refer to them as self.dfs(...) only if you don't want to do that, then write your function outside the Solution class. Something like this:

def dfs(...):
    # your body

class Solution(..):
    def combine(...):

And also, in Python, it is not 'push' for lists it is 'append' so please replace temp.push to temp.append