编程能力提升_14

最新推荐文章于 2023-03-04 21:02:13 发布

manjhOK

最新推荐文章于 2023-03-04 21:02:13 发布

阅读量284

点赞数

分类专栏：算法笔试

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

版权

算法笔试专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1.给定一个字符串和一个整数 k，你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。如果剩余少于 k 个字符，则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符，则反转前 k 个字符，并将剩余的字符保持原样。

2.给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：

3.给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

4.给定长度为 2n 的数组, 你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从1 到 n 的 min(ai, bi) 总和最大。

5.在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。

6.给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。

7.给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

8.和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。

9.你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。如果答案不止一个，则输出所有答案并且不考虑顺序。你可以假设总是存在一个答案。

1.给定一个字符串和一个整数 k，你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。如果剩余少于 k 个字符，则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符，则反转前 k 个字符，并将剩余的字符保持原样。

示例:

输入: s = "abcdefg", k = 2
输出: "bacdfeg"

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        strs=''
        for i in range(0,len(s),2*k):
            if len(s)-i >=k:
                strs = strs + s[i:i+k][::-1] +s[i+k:i+2*k]
            else:
                strs+=s[i:][::-1]
        return strs

等价：

class Solution(object):
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        strs=''
        for i in range(0,len(s),2*k):
            strs = strs + s[i:i+k][::-1] +s[i+k:i+2*k]
        return strs

2.给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：

'A' : Absent，缺勤
'L' : Late，迟到
'P' : Present，到场

如果一个学生的出勤记录中不超过一个'A'(缺勤)并且不超过两个连续的'L'(迟到),即，不能出现LLL，但那可以出现无论多少次LL。那么这个学生会被奖赏。

你需要根据这个学生的出勤记录判断他是否会被奖赏。

示例 1:

输入: "PPALLP"
输出: True

示例 2:

输入: "PPALLL"
输出: False

class Solution:
    def checkRecord(self, s: str) -> bool:
        if s.count('A')<=1 and s.find('LLL')==-1:
            return True
        return False

3.给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:

输入: "Let's take LeetCode contest"
输出: "s'teL ekat edoCteeL tsetnoc"

注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

class Solution:
    def reverseWords(self, s: str) -> str:
        strs=''
        s=s.split()
        for i in s:
            strs+=i[::-1]
            strs+=' '
        return strs[:-1]

4.给定长度为 2n 的数组, 你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从1 到 n 的 min(ai, bi) 总和最大。

示例 1:

输入: [1,4,3,2]

输出: 4
解释: n 等于 2, 最大总和为 4 = min(1, 2) + min(3, 4).

class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        nums.sort()
        retr=0
        for i in range(0,len(nums),2):
            retr+=nums[i]
        return retr

class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        nums.sort()
        return sum(nums[::2])

5.在MATLAB中，有一个非常有用的函数 `reshape`，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。

给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。

重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。

如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

示例 1:

输入: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
输出: 
[[1,2,3,4]]
解释:
行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。

class Solution:
    def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
        if len(nums[0])*len(nums)!=r*c:
            return nums
        retr=[[0]*c for i in range(r)]
        num1=[0]*r*c
        k=0
        for i in nums:
            for j in i:
                num1[k]=j
                k+=1
        k=0
        for i in range(r):
            for j in range(c):
                retr[i][j]=num1[k]
                k+=1
        return retr

6.给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。

示例 1:

输入: candies = [1,1,2,2,3,3]
输出: 3
解析: 一共有三种种类的糖果，每一种都有两个。
     最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。

示例 2 :

输入: candies = [1,1,2,3]
输出: 2
解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1]，妹妹有两种不同的糖果，弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。

class Solution:
    def distributeCandies(self, candies: List[int]) -> int:
        sets=set(candies)
        return min(len(sets),len(candies)//2)

7.给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

你找到的子数组应是最短的，请输出它的长度。

示例 1:

输入: [2, 6, 4, 8, 10, 9, 15]
输出: 5
解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。

方法一：

class Solution(object):
    def findUnsortedSubarray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        min1=0
        max1=0
        a = sorted(nums)
        if a == nums:
            return 0
        for i in range(len(a)):
            if a[i] != nums[i]:
                min1 = i
                break
        for i in range(1,len(a)+1):
            if a[-i] != nums[-i]:
                max1 = -i
                break
        return len(nums)+max1+1-min1

方法二：耗时

class Solution:
    def findUnsortedSubarray(self, nums: List[int]) -> int:
        if nums==sorted(nums):
            return 0        
        be=len(nums)
        end=len(nums)
        for i in range(len(nums)-1):
            if nums[i]>min(nums[i:]) and be==len(nums):
                be=i
            if nums[-i-1]<max(nums[:-i-1]) and end==len(nums):
                end=-i-1
            if be!=len(nums) and end!=len(nums):
                break
        if end==-1:
            return len(nums[be:])
        return len(nums[be:end+1])

8.和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。

现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。

示例 1:

输入: [1,3,2,2,5,2,3,7]
输出: 5
原因: 最长的和谐数组是：[3,2,2,2,3].

class Solution:
    def findLHS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        r = []
        a = {}
        for i in nums:
            a[i] = a.get(i,0) + 1
        for i in a:
            if i+1 in a:
                r.append(a[i] + a[i+1])
        if r == []:
            return 0
        return max(r)

9.你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。如果答案不止一个，则输出所有答案并且不考虑顺序。你可以假设总是存在一个答案。

示例 1:

输入:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"]
输出: ["Shogun"]
解释: 他们唯一共同喜爱的餐厅是“Shogun”。

示例 2:

输入:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["KFC", "Shogun", "Burger King"]
输出: ["Shogun"]
解释: 他们共同喜爱且具有最小索引和的餐厅是“Shogun”，它有最小的索引和1(0+1)。

class Solution:
    def findRestaurant(self, list1, list2):
        """
        :type list1: List[str]
        :type list2: List[str]
        :rtype: List[str]
        """
        a = {}
        b = {}
        for i in range(len(list1)):
            a[list1[i]] = i
        for i in range(len(list2)):
            b[list2[i]] = i
        r = len(list1)+len(list2)
        for i in a:
            if i in b:
                r = min(r, a[i]+b[i])
        re = []
        for i in a:
            if i in b and a[i]+b[i] == r:
                re.append(i)
        return re