笔试刷题必备------ 字符串

最新推荐文章于 2022-05-21 17:44:39 发布

Avery123123

最新推荐文章于 2022-05-21 17:44:39 发布

阅读量227

点赞数

分类专栏： Avery的笔试题复习总结

本文链接：https://blog.csdn.net/Avery123123/article/details/106571092

版权

Avery的笔试题复习总结专栏收录该内容

10 篇文章 0 订阅

订阅专栏

笔试刷题必备------ 字符串

笔试刷题必备------ 字符串

笔试刷题必备------ 字符串

反转字符转

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

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

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

示例 1：

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

示例 2：

输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

class Solution(object):
    def reverse_string(self,s):
        for i in range(len(s)//2):
            s[i],s[len(s)-1-i]= s[len(s)-1-i],s[i]
        return s


if __name__ == "__main__":
    solu = Solution()
    print(solu.reverse_string(["h","e","l","l","o"]))

整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

传统的做法：

class Solution(object):
    def reverse(self,x):
        min_value = -2147483648
        max_value = 2147483648



        if x <min_value or x > max_value:
            return 0
        x_str = str(x)
        x_arr = [i for i in x_str]

        for i in range(len(x_arr)//2):
            x_arr[i],x_arr[len(x_str)-1-i] = x_arr[len(x_arr)-1-i],x_arr[i]

        if x >= 0:
            t = 1
            res = 0
            for i in range(len(x_arr)-1,-1,-1):

                res += int(x_arr[i]) * t
                t *= 10
            return res if res > min_value and res < max_value else 0

        else:
            t = 1
            res = 0
            for i in range(len(x_arr)-2,-1,-1):
                res += int(x_arr[i]) * t
                t *= 10
            return -res if -res > min_value and -res < max_value else 0

Python的特性做法

    def reverse2(self,x):
        min_value = -pow(2,31)
        max_value = pow(2,31)-1



        if x < min_value or x > max_value:
            return 0

        if x >= 0:
            res = int(str(x)[::-1])
        else:
            res = -int(str(-x)[::-1])

        return res if res > min_value and res < max_value else 0

if __name__ == "__main__":
    solu = Solution()
    print(solu.reverse2(-5425362))

字符串中的第一个唯一字符

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

案例:

s = "leetcode"

返回 0.

s = "loveleetcode",

返回 2.

class Solution(object):
    def first_uniq_char(self,s):
        my_dict = {}
        for i in s:
            if i not in my_dict.keys():
                my_dict[i] = 1
            else:
                my_dict[i] += 1


        for i in range(0,len(s)):
            if my_dict[s[i]] == 1:
                return i
        return 0


if __name__ == "__main__":
    solu = Solution()
    print(solu.first_uniq_char("loveleetcode"))

有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

说明:
你可以假设字符串只包含小写字母。

class Solution(object):
    def is_anagram(self,s,t):
        s = sorted(s)
        t = sorted(t)

        if len(s) != len(t):
            return False


        for i in range(0,len(s)):
            if s[i] != t[i]:
                return False
        return True

if __name__ == "__main__":
    solu = Solution()
    print(solu.is_anagram(s = "anagram", t = "nagaram"))

验证回文字符串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true

示例 2:

输入: "race a car"
输出: false

class Solution(object):
    def is_palindrome(self,s):
        s = s.lower()
        s_arr = [x for x in s if x.isdigit() or x.isalpha()]
        for i in range(0,len(s_arr)//2):
            if s_arr[i] != s_arr[len(s_arr)-1-i]:
                return False
        return True



if __name__ == "__main__":
    solu = Solution()
    print(solu.is_palindrome("A man, a plan, a canal: Panama"))
    print(solu.is_palindrome("race a car"))

字符串转换整数 (atoi)

请你来实现一个 atoi 函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。

当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0。

说明：

假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

示例 1:

输入: "42"
输出: 42

示例 2:

输入: "   -42"
输出: -42

解释: 第一个非空白字符为 ‘-’, 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
示例 3:

输入: "4193 with words"
输出: 4193

解释: 转换截止于数字 ‘3’ ，因为它的下一个字符不为数字。
示例 4:

输入: "words and 987"
输出: 0

解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。
因此无法执行有效的转换。
示例 5:

输入: "-91283472332"
输出: -2147483648

解释: 数字 “-91283472332” 超过 32 位有符号整数范围。
因此返回 INT_MIN (−231) 。

实现 strStr()

实现 strStr() 函数。

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

示例 1:

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

示例 2:

输入: haystack = "aaaaa", needle = "bba"
输出: -1

说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

class Solution(object):
    def strStr(self,haystack,needle):
        if needle == "":
            return 0
        if needle not in haystack:
            return -1
        i,j = 0,0
        if needle in haystack:
            while i < len(haystack) and j <= len(needle):
                if haystack[i] == needle[j]:
                    i+=1
                    j+=1
                else:
                    i = i-j+1
                    j = 0

                if j == len(needle):
                    return i - len(needle)

if __name__ == "__main__":
    solu  = Solution()
    haystack = "hello"
    needle = "ll"
    print(solu.strStr(haystack,needle))

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

示例 2:

输入: ["dog","racecar","car"]
输出: ""

解释: 输入不存在公共前缀。
说明:

所有输入只包含小写字母 a-z 。

class Solution(object):
    def max_pre(self,strs_arr):
        if strs_arr  is None:
            return None
        s_str = min(strs_arr)
        print(s_str)
        l_str = max(strs_arr)
        print(l_str)
        
        for i in range(len(s_str)):
            if s_str[i] != l_str[i]:
                print(s_str[:i])
                return s_str[:i]

if __name__ == "__main__":
    solu = Solution()
    solu.max_pre(["flower","flow","flight"])

无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是子串的长度，“pwke” 是一个子序列，不是子串。

class Solution(object):
	def length_of_longest_substring(self,s):
		l = 0
		start = 0
		my_dict = {}
		for i in range(len(s)):
			if s[i] not in my_dict.keys():
				my_dict[s[i]] = i
			else:
				if my_dict[s[i]] + 1 > start:
					start = my_dict[s[i]] + 1
				my_dict[s[i]] = i
			if i -start + 1 > l:
				l = i - start + 1
		return l

最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：

输入: “cbbd”
输出: “bb”

class Solution(object):
    def longest_palindrome(self,s):
        start = 0
        max_length = 0

        for i in range(len(s)):
            if i - max_length >= 0 and s[i-max_length:i+1] == s[i-max_length:i+1][::-1]:
                start = i-max_length
                max_length += 1
                continue
            if i - max_length >= 1 and s[i-max_length-1:i+1] ==s[i-max_length-1:i+1][::-1]:
                start =i-max_length-1
                max_length += 2


        return s[start:start+max_length]

Avery123123

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
笔试刷题必备------ 字符串

笔试刷题必备------ 字符串笔试刷题必备------ 字符串反转字符转整数反转字符串中的第一个唯一字符有效的字母异位词验证回文字符串字符串转换整数 (atoi)实现 strStr()最长公共前缀笔试刷题必备------ 字符串反转字符转编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。示例
复制链接

扫一扫