剑指Offer（四）——字符串

柚芷

于 2021-03-04 22:59:27 发布

阅读量218

点赞数

分类专栏：算法文章标签：剑指Offer 字符串 python 算法

本文链接：https://blog.csdn.net/caicai0001000/article/details/114339664

版权

算法专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1、（JZ34）第一个只出现一次的字符位置

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

dict无序，所以使用dict在检索时需要指定顺序

# -*- coding:utf-8 -*-
from collections import defaultdict
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        return [i for i in range(len(s)) if s.count(s[i])==1][0] if s else -1

s.count用于统计字符串中指定字符数目

# -*- coding:utf-8 -*-
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        #判断输入条件
        if len(s)<=0 or len(s)>10000:
            return -1
        #count用于统计字符串中某个字符的出现个数
        #index为计算字符串中某个字符的位置
        for i in s:
            if s.count(i)==1:
                return s.index(i)

第三种方法：哈希

# -*- coding:utf-8 -*-
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        if s=='':
            return -1
        hashtable = [0]*256
        for i in s:
            hashtable[ord(i)] += 1
        for i in s:
            if hashtable[ord(i)] == 1:
                return s.index(i)
'''
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，
返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
'''

2、（JZ43）左旋字符串

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s:
            return ''
        s_len = len(s)
        n = n%s_len
        s = s[n:] + s[:n]
        return s

double做法

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if len(s) == 0:
            return s
        doubles = s + s
        s_len = len(s)
        return doubles[n:n+s_len]

3、（JZ45）扑克牌顺子

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何，如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers:
            return False
        if len(numbers)!= 5:
            return False
        max_num = max(numbers)
        min_num = min([13 if x == 0 else x for x in numbers])
        zero_count = len([x for x in numbers if x == 0])
        if len(list(set([x for x in numbers if x != 0])))!= len([x for x in numbers if x != 0]):
            return False
        if max_num - min_num <= 4:
            tmp = min_num
            while tmp != max_num:
                tmp += 1
                if tmp not in numbers:
                    if zero_count>0:
                        zero_count -= 1
                    else:
                        return False
            return True
        else:
            return False

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        length = len(numbers)
        if numbers == None or length == 0:
            return False
        
        zeroCount = 0
        numbers.sort()
        
        startIndex = 0
        while numbers[startIndex] ==0 :
            startIndex += 1
            zeroCount += 1
        for i in range(startIndex + 1, len(numbers)):
            tmp = numbers[i] - numbers[i-1]
            if tmp == 1:
                continue
            elif tmp > 1 and zeroCount >= tmp - 1:
                zeroCount -= tmp - 1
            else:
                return False
        return True

4、（JZ53）表示数指的字符串

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

这个答案很秀。

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param str string字符串 
# @return bool布尔型
#
class Solution:
    def isNumeric(self , s ):
        # write code here
        state = [
            {' ': 0, 's': 1, 'd': 2, '.':4},
            {'d': 2, '.': 4},
            {'d': 2, ' ': 8, 'e':5, '.':3},
            {'d':3, 'e':5, ' ': 8},
            {'d': 3},
            {'s':6, 'd':7},
            {'d':7},
            {' ': 8, 'd':7},
            {' ': 8}
        ]
        p = 0
        for item in s:
            if '0' <= item <= '9':
                t = 'd'
            elif item in "eE":
                t = 'e'
            elif item in '+-':
                t = 's'
            elif item in '. ':
                t = item
            else:
                t = '?'
            if t not in state[p]:
                return False
            p = state[p][t]
        return p in [2,3,7,8]

5、（JZ54）字符流中第一个不重复的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

# -*- coding:utf-8 -*-
class Solution:
    # 返回对应char
    s = ''
    def FirstAppearingOnce(self):
        # write code here
        for i in self.s:
            if self.s.count(i)==1:
                return i 
        return '#'
    
    def Insert(self, char):
        # write code here
        self.s += char

6、（JZ2）替换空格

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param s string字符串 
# @return string字符串
#
class Solution:
    def replaceSpace(self , s ):
        # write code here
        return s.replace(' ','%20')

7、（JZ27）字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

# -*- coding:utf-8 -*-
from itertools import permutations
class Solution:
    def Permutation(self, ss):
        # write code here
        ans = []
        if not ss:
            return []
        return sorted(list(set(map(''.join, permutations(ss)))))

8、（JZ44）翻转单词顺序列

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

# -*- coding:utf-8 -*-
class Solution:
    def ReverseSentence(self, s):
        # write code here
        if not s:
            return ''
        if ' ' not in s:
            return s
        if s.count(' ') == len(s):
            return s
        s = s.split(' ')[::-1]
        ans = ''
        for i in s:
            ans += i + ' '
        return ans.strip(' ')

' '.join(xxx)

# -*- coding:utf-8 -*-
class Solution:
    def ReverseSentence(self, s):
        # write code here
        if not s:
            return ''
        if ' ' not in s:
            return s
        if s.count(' ') == len(s):
            return s
        s = s.split(' ')[::-1]
        ans = ' '.join(s)
        return ans

9、（JZ49）把字符串转换成整数

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0。

10、（JZ52）正则表达式匹配

请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配。

柚芷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
剑指Offer（四）——字符串

1、（JZ34）第一个只出现一次的字符位置在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）dict无序，所以使用dict在检索时需要指定顺序# -*- coding:utf-8 -*-from collections import defaultdictclass Solution: def FirstNotRepeatingChar(self, s):
复制链接

扫一扫