编程能力提升_10

 

 

1.编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

方法一：

class Solution(object):
    def reverseString(self, s):
        """
        :type s: List[str]
        :rtype: None Do not return anything, modify s in-place instead.
        """
        for i in range(len(s)//2):
            tmp = s[i]
            s[i] = s[len(s)-1-i]
            s[len(s)-1-i] = tmp

方法二：

class Solution(object):
    def reverseString(self, s):
        for i in range(2,len(s)+1):
            temp=s.pop(-i)
            s.append(temp)

2.编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

示例 1:

输入: "hello"
输出: "holle"

示例 2:

输入: "leetcode"
输出: "leotcede"

只反转字符串中的元音字母，双指针法

class Solution:
    def reverseVowels(self, s: str) -> str:
        left,right=0,len(s)-1
        s=list(s)
        while left<right:
            if s[left] in 'aeiouAEIOU' and s[right] in 'aeiouAEIOU':
                s[left],s[right]=s[right],s[left]
                left+=1
                right-=1
            elif s[left] not in 'aeiouAEIOU':
                left+=1
            elif s[right] not in 'aeiouAEIOU':
                right-=1
        return ''.join(s)

3.给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]

说明:

• 输出结果中的每个元素一定是唯一的。
• 我们可以不考虑输出结果的顺序。

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        retr=[]
        for i in nums1:
            if i in nums2 and i not in retr:
                retr.append(i)
        return retr

4.给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

说明：

• 输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
• 我们可以不考虑输出结果的顺序。

方法一：

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        retr=[]
        for i in nums1:
            if i in nums2:
                nums2.remove(i)
                retr.append(i)
        return retr

方法二：

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        inter = set(nums1) & set(nums2)
        l = []
        for i in inter:
            l += [i] * min(nums1.count(i), nums2.count(i))  
        return l

5.给定一个正整数 num，编写一个函数，如果 num 是一个完全平方数，则返回 True，否则返回 False。

说明：不要使用任何内置的库函数，如  sqrt。

示例 1：

输入：16
输出：True

示例 2：

输入：14
输出：False

class Solution:
    def isPerfectSquare(self, num):
        """
        :type num: int
        :rtype: bool
        """
        if num == 1:
            return True
        lo = 0
        hi = num
        while lo <= hi:
            mid = (lo + hi) // 2
            if mid ** 2 > num:
                hi = mid - 1
            elif mid ** 2 < num:
                lo = mid + 1
            elif mid**2==num:
                return True
        return False

方法二：牛顿法

class Solution(object):
    def isPerfectSquare(self, num):
        """
        :type num: int
        :rtype: bool
        """
        r = num
        while r*r > num:
            r = (r+num//r)//2
        if r*r == num:
            return True
        return False

6.我们正在玩一个猜数字游戏。 游戏规则如下：我从 1 到 n 选择一个数字。 你需要猜我选择了哪个数字。

每次你猜错了，我会告诉你这个数字是大了还是小了。你调用一个预先定义好的接口 guess(int num)，它会返回 3 个可能的结果（-1，1 或 0）：

-1 : 我的数字比较小
 1 : 我的数字比较大
 0 : 恭喜！你猜对了！

示例 :

输入: n = 10, pick = 6
输出: 6

class Solution(object):
    def guessNumber(self, n):
        """
        :type n: int
        :rtype: int
        """
        low=1
        high=n        
        while low<=high:
            mid=low+(high-low)/2
            if guess(mid)==0:
                return mid
            elif guess(mid)==-1:
                high=mid-1
            else:
                low=mid+1

7.给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

方法一：

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        ransom=list(ransomNote)
        magazine=list(magazine)
        while ransom != []:
            temp=ransom.pop()
            if temp not in magazine:
                return False
            else:
                magazine.remove(temp)
        return True

方法二：

class Solution:
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        r = {}
        for i in magazine:
            if i in r:
                r[i] += 1
            else:
                r[i] = 1
        for i in ransomNote:
            if i in r:
                if r[i] == 0:
                    return False
                else:
                    r[i] -= 1
            else:
                return False
        return True

8.给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

案例:

s = "leetcode"
返回 0.

s = "loveleetcode",
返回 2.

class Solution:
    def firstUniqChar(self, s: str) -> int:
        dic1={}
        for i in range(len(s)):
            dic1[s[i]]=dic1.get(s[i],0)+1
        for i in s:
            if dic1[i]==1:
                return s.index(i)
        return -1
        

class Solution(object):
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        from collections import Counter
        cnt1 = Counter(s)
        for i in s:
            if cnt1[i] == 1:
                return s.index(i)
        return -1

9.给定两个字符串 s 和 t，它们只包含小写字母。字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。请找出在 t 中被添加的字母。

示例:

输入：
s = "abcd"
t = "abcde"

输出：
e

解释：
'e' 是那个被添加的字母。

方法一：

class Solution(object):
    def findTheDifference(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: str
        """
        ls=list(s)
        for i in t:
            if i in ls:
                ls.remove(i)
            else:
                return i

方法二：

class Solution:
    def findTheDifference(self, s: str, t: str) -> str:
        retr = 0
        for i in s+t:
            retr=retr^ord(i)
        return chr(retr)