Given a non -empty array. Except for only one element, each element appears twice. Find the element that only appears once.

Instructions:

Your algorithm should have a linear time complexity. Can you achieve it without extra space?

link:https://leetcode-cn.com/problems/single-number

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        a=0
        for i in nums:
            a=a^i
        return a

Given an array of n, and find most of them. Most elements refer to elements that appear in the array greater than ⌊ n/2 ⌋.

You can assume that the array is non -empty, and the given array always has a majority element.

link:https://leetcode-cn.com/problems/majority-element

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        count=1
        maj=nums[0]
        for i in range(1,len(nums)):
            if maj==nums[i]:
                count+=1
            else:
                count-=1
                if count==0:
                    maj=nums[i+1]
        return maj

merge the two linked linked lists into a new linked list and return. The new linked list is composed of all nodes of the two linked list given by stitching.
link:https://leetcode-cn.com/problems/merge-two-sorted-lists/

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if l1==None:
            return l2
        if l2==None:
            return l1
        res=l1 if l1.val<l2.val else l2
        res.next=self.mergeTwoLists(res.next,l2 if l1.val<l2.val else l1)
        return res

Given a array Nums, write a function to move all 0 to the end of the array, while maintaining the relative order of non -zero elements.
link:https://leetcode-cn.com/problems/move-zeroes/

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        nums.sort(key=bool,reverse=True)

Given a integer array with a range of 1 ≤ a [i] ≤ n (n = array size). Some of the elements in the array appear twice, and others only appear once.

Find the number that does not appear in the array between the [1, n] range.

Can you complete this task without using extra space and time complexity of time O (n)? You can assume that the returned array is not counted in additional space.

link:https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        a=set([i for i in range(1,len(nums)+1)])
        nums=set(nums)
        return a-nums