编程能力提升_11

最新推荐文章于 2024-04-17 03:06:18 发布

manjhOK

最新推荐文章于 2024-04-17 03:06:18 发布

阅读量451

点赞数

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

本文链接：https://blog.csdn.net/manjhOK/article/details/88826902

版权

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

24 篇文章 0 订阅

订阅专栏

python 算法每日提升

12 篇文章 1 订阅

订阅专栏

1.给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用补码运算方法。

2.给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。

3.写一个程序，输出从 1 到 n 数字的字符串表示。

4.给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。

5.给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。

6.统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

7.你总共有 n 枚硬币，你需要将它们摆成一个阶梯形状，第 k 行就必须正好有 k 枚硬币给定一个数字 n，找出可形成完整阶梯行的总行数。

8.给定一组字符，使用原地算法将其压缩。压缩后的长度必须始终小于或等于原数组长度。

1.给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用补码运算方法。

注意:

十六进制中所有字母(a-f)都必须是小写。
十六进制字符串中不能包含多余的前导零。如果要转化的数为0，那么以单个字符'0'来表示；对于其他情况，十六进制字符串中的第一个字符将不会是0字符。
给定的数确保在32位有符号整数范围内。
不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。

示例 1：

输入:
26

输出:
"1a"

class Solution(object):
    def toHex(self, num):
        """
        :type num: int
        :rtype: str
        """
        #使用位运算，每4位，对应1位16进制数字
        #使用0xf(00...01111b)获取num的低4位
        #>>算数位移，其中正数右移左边补0，负数右移左边补1。
        result = ''
        alpha = '0123456789abcdef'
        if num == 0:
            return '0'
        #位移运算并不能保证num==0，需要使用32位int保证（对应16进制小于等于8位）。
        while num != 0 and len(result) < 8:
            result += alpha[num & 0xf]
            num = num >> 4
        return result[::-1]

2.给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。

在构造过程中，请注意区分大小写。比如 "Aa" 不能当做一个回文字符串。

注意:
假设字符串的长度不会超过 1010。

示例 1:

输入:
"abccccdd"

输出:
7

解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: int
        """
        #回文字符串的长度= 偶数个字符长度+所有（奇数字符长度-1）+一个长度为一的元素（放在回文字符串的最中间）。
        Flag = False
        res = 0
        dic = {}
        for ss in s:
            dic[ss]=dic.get(ss,0)+1
        for k in dic:
            if dic[k] % 2 == 0:
                res += dic[k]
            else:
                #要么字符有奇数个，要么字符个数为1，只要存在，则丢弃其一个字母来组合，最后再加一个
                res += dic[k] - 1
                Flag = True
        if Flag:
            return res+1
        else:
            return res

3.写一个程序，输出从 1 到 n 数字的字符串表示。

1. 如果 n 是3的倍数，输出“Fizz”；

2. 如果 n 是5的倍数，输出“Buzz”；

3.如果 n 同时是3和5的倍数，输出 “FizzBuzz”。

示例：

n = 15,

返回:
[
    "1",
    "2",
    "Fizz",
    "4",
    "Buzz",
    "Fizz",
    "7",
    "8",
    "Fizz",
    "Buzz",
    "11",
    "Fizz",
    "13",
    "14",
    "FizzBuzz"
]

class Solution(object):
    def fizzBuzz(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        retr=[]
        for i in range(1,n+1):
            if i%3==0 and i%5==0:
                retr.append('FizzBuzz')
            elif i%3==0:
                retr.append('Fizz')
            elif i%5==0:
                retr.append('Buzz')
            else:
                retr.append(str(i))
        return retr

4.给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。

示例 1:

输入: [3, 2, 1]

输出: 1

解释: 第三大的数是 1.

示例 2:

输入: [1, 2]

输出: 2

解释: 第三大的数不存在, 所以返回最大的数 2 .

class Solution:
    def thirdMax(self, nums: List[int]) -> int:
        first,second,third=float('-inf'),float('-inf'),float('-inf')
        for num in nums:
            if num>first:
                first,second,third=num,first,second
            elif second<num<first:
                second,third=num,second
            elif third<num<second:
                third=num
        return third if third!=float('-inf') else first

sort()函数的时间复杂度O（nlogn）

class Solution(object):
    def thirdMax(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums=list(set(nums))
        if len(nums)<=2:
            return max(nums)
        else:
            return sorted(nums,reverse=True)[2]

5.给定两个字符串形式的非负整数 `num1` 和`num2` ，计算它们的和。

注意：

num1 和num2 的长度都小于 5100.
num1 和num2 都只包含数字 0-9.
num1 和num2 都不包含任何前导零。
你不能使用任何內建 BigInteger 库，也不能直接将输入的字符串转换为整数形式。

class Solution(object):
    def addStrings(self, num1, num2):
        """
        :type num1: str
        :type num2: str
        :rtype: str
        """
        i, carry, res = max(len(num1), len(num2)), 0, ""
        #向右靠齐，左侧不够补‘0’
        num1=num1.rjust(i,'0')
        num2=num2.rjust(i,'0')
        while i > 0:
            num = int(num1[i-1]) + int(num2[i-1]) + carry
            res += str(num % 10)
            i= i - 1
            carry = 1 if num >= 10 else 0
        return "1" + res[::-1] if carry else res[::-1]

6.统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。

示例:

输入: "Hello, my name is John"
输出: 5

class Solution:
    def countSegments(self, s: str) -> int:
        return len(s.split())

class Solution(object):
    def countSegments(self, s):
        """
        :type s: str
        :rtype: int
        """
        flag = 0
        count = 0
        s_length = len(s)
        for i in range(0, s_length):
            if s[i] != ' ':
                if not flag:
                    count = count + 1
                flag = 1
            else:
                flag = 0                
        return count

7.你总共有 n 枚硬币，你需要将它们摆成一个阶梯形状，第 k 行就必须正好有 k 枚硬币给定一个数字 n，找出可形成完整阶梯行的总行数。

n 是一个非负整数，并且在32位有符号整型的范围内。

示例 1:

n = 5

硬币可排列成以下几行:
¤
¤ ¤
¤ ¤

因为第三行不完整，所以返回2.

class Solution(object):
    def arrangeCoins(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n==0:
            return 0
        k=int((2*n)**0.5)-1
        while k*(k+1)//2<=n:
            k+=1
        return k-1

方法二比较耗时：

class Solution:
    def arrangeCoins(self, n):
        """
        :type n: int
        :rtype: int
        """        
        i = 1
        while n >= i:
            n -= i
            i += 1
        return i - 1

8.给定一组字符，使用原地算法将其压缩。压缩后的长度必须始终小于或等于原数组长度。

数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。

在完成原地修改输入数组后，返回数组的新长度。

进阶：
你能否仅使用O(1) 空间解决问题？

示例 1：

输入：
["a","a","b","b","c","c","c"]

输出：
返回6，输入数组的前6个字符应该是：["a","2","b","2","c","3"]

说明：
"aa"被"a2"替代。"bb"被"b2"替代。"ccc"被"c3"替代。

示例 2：

输入：
["a"]

输出：
返回1，输入数组的前1个字符应该是：["a"]

说明：
没有任何字符串被替代。

示例 3：

输入：
["a","b","b","b","b","b","b","b","b","b","b","b","b"]

输出：
返回4，输入数组的前4个字符应该是：["a","b","1","2"]。

说明：
由于字符"a"不重复，所以不会被压缩。"bbbbbbbbbbbb"被“b12”替代。
注意每个数字在数组中都有它自己的位置。

双指针法：

class Solution:
    def compress(self, chars: List[str]) -> int:
        i=1
        j=1
        count=1
        temp=chars[0]
        #加长字符串是为了让其可以处理末位字符与其之前字符一致的情况
        chars.append('')
        for i in range(1,len(chars)):
            if chars[i]==temp:
                count+=1
            else:
                temp=chars[i]
                if count>1:
                    for k in range(len(str(count))):
                        chars[j]=str(count)[k]
                        j+=1
                chars[j]=temp
                j+=1
                count=1
        return j-1