编程能力提升_2

最新推荐文章于 2023-04-25 09:31:46 发布

manjhOK

最新推荐文章于 2023-04-25 09:31:46 发布

阅读量279

点赞数

分类专栏：算法笔试 python 算法每日提升

本文链接：https://blog.csdn.net/manjhok/article/details/88632776

版权

算法笔试同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

python 算法每日提升

12 篇文章 1 订阅

订阅专栏

1.给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

2.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

3.给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

4.给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。

5.实现 strStr() 函数。给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

6.给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

7.报数序列是一个整数序列，按照其中的整数的顺序进行报数，21-->1211

1.给定一个只包括 `'('`，`')'`，`'{'`，`'}'`，`'['`，`']'` 的字符串，判断字符串是否有效。

注意空字符串可被认为是有效字符串。

示例 1:

输入: "()[]{}"
输出: true

示例 2:

输入: "([)]"
输出: false

方法一：

class Solution:
    def isValid(self, s: str) -> bool:
        sls=list(s)
        lf='([{'
        rt=')]}'
        retr=[]
        #遍历每一个元素
        for i in range(len(sls)):
            #如果当前元素为左括号，直接添加到retr列表中
            if sls[i] in lf:
                retr.append(sls[i])
            #如果当前元素为右括号，分三种情况
            elif sls[i] in rt:
                #如果retr列表为空，则直接返回false
                if retr==[]:
                    return False
                #如果当前元素和retr列表中的元素不匹配则返回false
                elif lf.index(retr[-1])!=rt.index(sls[i]):
                    return False
                #其它情况即为合理情况，删除retr最末尾匹配的元素
                else:
                    retr.pop()
        return retr==[]

方法二：

class Solution:
    def isValid(self, s):
        while '{}' in s or '()' in s or '[]' in s:
            s = s.replace('{}', '')
            s = s.replace('[]', '')
            s = s.replace('()', '')
        return s == ''

2.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        head=ListNode(0)
        cur = head
        while l1 and l2 :            
            if l1.val<l2.val:
                cur.next=l1
                l1=l1.next
                cur=cur.next
            else:
                cur.next=l2
                l2=l2.next
                cur=cur.next
        if l1==None:
                cur.next=l2
        elif l2==None:
                cur.next=l1
            
        return head.next

3.给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2], 
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 你不需要考虑数组中超出新长度后面的元素。

方法一，但使用了额外的空间

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        ls=[]
        ls.append(nums[0])
        for i in range(1,len(nums)):
            if nums[i]!=nums[i-1]:
                ls.append(nums[i])
        return ls

方法二：标准解法

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if nums==[] or len(nums)==1:
            return len(nums)
        i=1
        #因为要动态的修改nums列表，所以使用while循环
        while i<=len(nums)-1:
            if nums[i]==nums[i-1]:
                nums.pop(i)
            else:
                i+=1
        return len(nums)

方法三：双指针的思想，但是其nums[i+1:]之后的元素并未被删除

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if nums==[] or len(nums)==1:
            return len(nums)
        i=0
        for j in range(1,len(nums)):
            #采用双指针的方式，i,j代表其索引，其中nums[:i+1]为处理好的列表，其之后为残余未处理
            if nums[i]!=nums[j]:
                i+=1
                nums[i]=nums[j]
        return i+1

4.给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

方法一：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        while val in nums:
            nums.remove(val)
        return len(nums)

方法二：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        for i in range(len(nums)-1,-1,-1):
            if nums[i]==val:
                nums.pop(i)    
        return len(nums)

5.实现 strStr() 函数。给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = "hello", needle = "ll"
输出: 2

方法一：

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        if needle =='':
            return 0
        if len(needle)>len(haystack):
            return -1
        #处理两个字符串长度一致问题
        if needle==haystack:
            return 0
        #下面的for循环无法处理两个字符串长度相等的情形，因此上语句单独处理        
        for i in range(0,len(haystack)-len(needle)+1):
            #len(haystack)-len(needle)加一之后才是与needle等长的字符串
            if haystack[i:i+len(needle)]==needle:
                return i
        return -1

方法二：

class Solution(object):
    def strStr(self, haystack, needle):
        if needle == '':
            return 0
        #无法使用haystack.index(needle)
        #因为str.index()函数找不到needle时会报错，find()不会报错，会返回-1
        return haystack.find(needle)

str.find(str, beg=0, end=len(string))

参数

str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则返回-1。

index()方法语法：

str.index(str, beg=0, end=len(string))

参数

str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则抛出异常。

6.给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1:

输入: [1,3,5,6], 5
输出: 2

示例 2:

输入: [1,3,5,6], 2
输出: 1

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if target in nums:
            return nums.index(target)
        if target > nums[-1]:
            nums.append(target)
            return len(nums)-1
        if target < nums[0]:
            nums.insert(0,target)
            return 0        
        
        for i in range(1,len(nums)):
            if nums[i-1]<target and nums[i]>target:
                nums.insert(i,target)
                return i

        i = 0
        while i<len(nums) and nums[i]<target:
            i = i + 1
        return i

二分法查找：贴代码：

        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        low = 0
        high = len(nums)
        while low < high:
            mid = low + (high - low)/2
            if nums[mid] > target:
                high = mid
            elif nums[mid] < target:
                low = mid +1
            else:
                return mid
        return low

7.报数序列是一个整数序列，按照其中的整数的顺序进行报数，`21-->1211`

1.     1
2.     11
3.     21
4.     1211
5.     111221

1 被读作 "one 1" ("一个一") , 即 11。
11 被读作 "two 1s" ("两个一"）, 即 21。
21 被读作 "one 2", "one 1" （"一个二" , "一个一") , 即 1211。

给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。

class Solution(object):
    def countAndSay(self, n):
        """
        :type n: int
        :rtype: str
        """
        rstr='1'
        for i in range(1,n):
            #x,y用来盛放个数和它的字母
            x=[]
            y=[]
            #统计x,y的值
            for j in range(len(rstr)):
                if j==0:
                    x.append(rstr[0])
                    y.append(1)
                elif rstr[j-1]==rstr[j]:
                    y[-1]+=1
                else:
                    x.append(rstr[j])
                    y.append(1)
            #更新得到新的rstr
            rstr=''
            for i in range(len(x)):
                rstr=rstr+str(y[i])+x[i]
        return rstr