力扣第39题dfsdfs(respathtarget-candidates[1]i)#调用递归，组成目标的 i 可以重复用，不用i+1,def dfsdfs(resres,pathtarget,ind

#class Solution:
#    def combinationSum(self,candidates:List[int],target:int)->List[List[int]]:
#        if not candidates:#干掉捣乱的
#            return []
#        def dfsdfs(resres,pathtarget,index):#index 下标，告诉递归，带着小标搞，
#            if target==0:#递归终止的条件
#                resres.append(path[:])
#        for i in range(indexlen(candidates)):
#            if target>=candidates[i]:#该元素可以组成目标，因为值比目标小
#                path.append(candidates[i])
#                dfsdfs(respathtarget-candidates[1]i)#调用递归，组成目标的 i 可以重复用，不用i+1,
#                path.pop()
#        
#        resres = []
#        dfsdfs(resres,[ltarget,0) 
#        return resres

class Solution:
    def combinationSum(self, can: List[int], tar: int) -> List[List[int]]:
        if not can:
            return []

        def dfs(res, path, tar, index):
            if tar == 0:
                res.append(path[:])
            for i in range(index, len(can)):
                if tar >= can[i]:
                    path.append(can[i])
                    dfs(res, path, tar - can[i], i)
                    path.pop()

        res = []
        dfs(res, [], tar, 0)
        return res
 

n:

import json

class ListNode:

    def __init__(self, val=0, next=None):

        self.val = val

        self.next = next

 

class Solution:

    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:

        dummy = ListNode(0, head)

        #dummy = head

        first = head

        second = dummy

        for i in range(n):

            first = first.next

        while first:

            first = first.next

            second = second.next

        

        second.next = second.next.next

        return dummy.next

 

def stringToListNode(input):

    print(input)

    #numbers = json.loads(input)

    numbers = [bb for bb in input.split()]

    #print(numbers,"*1")

    #numbers = input

    dummyRoot = ListNode(0)

    ptr = dummyRoot

    for number in numbers:

        ptr.next = ListNode(number)

        ptr = ptr.next

    ptra = ptr

    #print()

    print(listNodeToString(ptra),"*3")

    #print(listNodeToString(ptra),"*3")

    ptr = dummyRoot.next

    #print()

    #print(listNodeToString(ptr),"*4")

    return ptr

 

 

 

def listNodeToString(node):

    if not node:

        return "[]"

    result = ""

    while node:

        result += str(node.val) + ", "

        node = node.next

    #return result[:-2]

    return result

 

 

 

def main():

    while True:

        try:

            head = stringToListNode(str([1,2,3,4]))

            n = 2

            ret = Solution().removeNthFromEnd(head, n)

            out = listNodeToString(ret)

            print(out)

        except StopIteration:

            break

 

#if __name__ == '__main__':

# main()

main()