【LeetCode刷题】136 只出现一次的数字 || 125 验证回文字符串

136、只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:
输入: [2,2,1]
输出: 1

示例 2:
输入: [4,1,2,1,2]
输出: 4

class Solution(object):
    def singleNumber(self, nums):
        for num in nums:
            if nums.count(num) != 2:
                return num

class Solution1:
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        s = []
        for i in nums:
            if i not in s:
                s.append(i)
            elif i in s:
                s.remove(i)
        return s[0]

class Solution2:
    def singleNumber(self, nums):

        s = {}
        for i in nums:
            if i in s.keys():
                s.pop(i)
            else:
                s[i]=1
        return list(s.keys())[0]

nums = [1,2,3,4,1,2,3]
solution = Solution()
print(solution.singleNumber(nums))

0异或任何数不变，任何数与自己异或为0。a⊕b⊕a=b

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        result = 0

        for num in nums:
            result ^= num
            print("result:",result)
        return result
nums = [1,2,3,4,1,2,3]
solution = Solution()
print(solution.singleNumber(nums))

用两倍的set内元素的和，减掉nums和就行了

class Solution4(object):
    def singleNumber(self,nums):
        a = 2*sum(list(set(nums)))
        b = sum(nums)
        return a-b

---

125、验证回文字符串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:
输入: “A man, a plan, a canal: Panama”
输出: true

示例 2:
输入: “race a car”
输出: false

设置一个双向指针，一前一后判断，如果不是字母与数字，则跳过，指向下一个，否则计算当前两个是否相等

class Solution(object):
    def isPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        i, j = 0, len(s) - 1

        while i < j:
            while i < j and not s[i].isalnum():#isalnum 是否为数字或者字母组成
                i += 1
            while i < j and not s[j].isalnum():
                j -= 1
            if s[i].lower() != s[j].lower():
                return False
            i += 1
            j -= 1
        return True

class Solution1(object):
    def isPalindrome(self, s):
        #list(filter(lambda x:x.isalnum,s))
        s = list(filter(str.isalnum, s.lower())) #filter(函数，序列)

        return True if s == s[::-1] else False