剑指offer-字符串&数字规律

1. 表示数值的字符串

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

解：

思考方向应该是把非法的情况列举出来，合法的情况太多了。这题比较繁琐。

class Solution:
    # s字符串
    def isNumeric(self, s):
        # write code here
        if not s:
            return False
        n = len(s)
        sign, decimal, hasE = False, False, False
        for i in range(n):
            if s[i] in {'e', 'E'}:
                if i == n-1:
                    return False  # e后面要接数字
                if hasE:
                    return False  # 不能有两个e
                hasE = True
            elif s[i] in {'+', '-'}:
                if sign and s[i-1] not in {'e', 'E'}:  # 第二次出现+-，必须在e后面
                    return False
                if not sign and i > 0 and s[i-1] not in {'e', 'E'}:  # 第一次出现+-，且不是开头，也必须在e后面
                    return False
                sign = True
            elif s[i] == '.':
                if hasE or decimal:  # e后面不能有小数点，小数点不能出现两次
                    return False
                decimal = True
            elif s[i] < '0' or s[i] > '9':  # 非法字符
                return False
        return True

　　

 

2. 字符流中第一个不重复的字符

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

输出描述:

如果当前字符流没有存在出现一次的字符，返回#字符。

解：

用哈希表

class Solution:
    # 返回对应char
    def __init__(self):
        self.strs = ''
        self.hashmap = dict()

    def FirstAppearingOnce(self):
        # write code here
        if not self.strs:
            return '#'
        n = len(self.strs)

        first_index = n
        for key, value in self.hashmap.items():
            if value[0] == 1:
                first_index = min(first_index, value[1])
        return '#' if first_index == n else self.strs[first_index]
    
    def Insert(self, char):
        # write code here
        self.strs += char
        count, index = self.hashmap.get(self.strs[-1], (0, -1))
        self.hashmap[self.strs[-1]] = (count+1, len(self.strs)-1)

 

 

3.替换空格

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

解：

递归实现

class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        if not s:
            return s
        if s[0] == ' ':
            return '%20' + self.replaceSpace(s[1:])
        return s[0] + self.replaceSpace(s[1:])

　　

扫一遍记录位置，然后挨个替换，注意替换过程中原先记录的索引会改变，要对应好。

class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        if not s:
            return s
        tobeReplace = []
        n = len(s)
        for i in range(n):
            if s[i] == ' ':
                tobeReplace.append(i)
        m = len(tobeReplace)
        for j in range(m):
            s = s[:tobeReplace[j]+2*j] + '%20' + s[tobeReplace[j]+2*j+1:]
        return s

　　

 

4. 扑克牌顺子

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。

解：

这题表述有点蛋疼。。。其实就是给定一串字符，判断是不是顺子，其中大小王都是0可以当作赖子牌用。这题可以先sort一下然后统计有多少赖子牌，然后从第一张不是赖子的牌开始，如果后一张不是连续的，就可以拿赖子牌补。如果有两张同样的牌还不是赖子，那肯定不是顺子；如果赖子被补位完了还不够，也不是顺子。

class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers:
            return False
        n = len(numbers)
        numbers.sort()
        laizi = 0
        for i in range(n):
            if numbers[i] == 0:
                laizi += 1
            else:
                break

        for j in range(i, n-1):
            if numbers[j+1] == numbers[j]:
                return False
            laizi -= numbers[j+1] - numbers[j] - 1
            if laizi < 0:
                return False
        return True

 

 

5. 字符串转化为整数

将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。

解：

判断字符串能否转换为整数，加减号只能出现在开头，其他位置只能是数字字符。用栈来存

class Solution:
    def StrToInt(self, s):
        # write code here 
        if not s:
            return 0
        d = {'0','1','2','3','4','5','6','7','8','9'}
        stack = []
        for i, char in enumerate(s):
            if char in d:
                stack.append(int(char))
            elif i == 0 and char in {'+', '-'}:
                continue
            else:
                return 0
        ans = 0
        if not stack:
            return 0
        for num in stack:
            ans = 10*ans + num
        return -ans if s[0] == '-' else ans

 

 

6. 左旋转字符串

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

解：

一个思路两种写法。一次左移一位，移n次；

class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s or not n:
            return s
        for i in range(n):
            s = self.ROL(s)
        return s
    
    def ROL(self, s):
        return s[1:]+s[0]

 

循环实现；一次截好所有要左移的部分，需要取 mod

class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s or not n:
            return s
        n %= len(s)
        return s[n:]+s[:n]

　　

　

7. 翻转单词顺序列

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

解：

先全部翻转，再按空格切分后每个单词单独翻转，再用空格 join 起来

class Solution:
    def ReverseSentence(self, s):
        # write code here
        s = self.Reverse(s)
        words = s.split(' ')
        n = len(words)
        for i in range(n):
            words[i] = self.Reverse(words[i])
        return ' '.join(words)
        
    def Reverse(self, s):
        return s[::-1]

 

　　

8. 第一个只出现一次的字符

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

解：

用哈希表统计次数。然后从头遍历判断即可。

from collections import Counter
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        if not s:
            return -1
        count = dict(Counter(s))
        
        for i in range(len(s)):
            if count[s[i]] == 1:
                return i
        return -1

 

 

9. 整数中1出现的次数

求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

解：

通过使用一个 位置乘子m 遍历数字的位置, m 分别为1,10,100,1000…etc.（m<=n）

 

对于每个位置来说，把10进制数分成两个部分，比如说 当m=100的时候， 把十进制数 n=3141592 分成 a=31415 和 b=92 ，以此来分析百位数为1时所有数的个数和。

m=100时，百位数的前缀为3141，当百位数大于1时，为3142*100，因为当百位数大于1时，前缀可以为0，即百位数可以从100到199，共100个数；当百位数不大于1时，为3141*100

如何判断百位数是否大于1？假设百位数为x，若 (x+8)//10 等于1，则大于1，若 (x+8)//10 等于0，则小于1。因此前缀可用 (n//m + 8)//10 *m来计算(若计算2的个数，可以改为（n//m + 7）//10*m,若计算3的个数，改为（n//m + 6）//10*m，…以此类推)。

 

再例如m=1000时，n分为a=3141和 b=592；千位数的前缀为314，千位数不大于1，故前缀计算为314*1000；因为千位数为1，再加b+1(0到592)。即千位数为1的所有数的个数和为314*1000+592+1；公式（n//m + 8）//10*m + b +1。

 

注意：只有n的第m位为1时需要计算后缀，后缀计算为 （n//m%10==1）*(b+1)，

 

即（n//m%10==1）判断第m位是否为1，若为1，则加上（b+1），若不为1，则只计算前缀。（若计算2的个数，可以改为（n//m%10==2）*(b+1)，若计算3的个数，可以改为（n//m%10==3）*(b+1)…以此类推）

class Solution:
    def NumberOf1Between1AndN_Solution(self, n):
        # write code here
        cnt = 0
        a, b = 0, 0
        m = 1
        while m <= n:
            a = n//m
            b = n%m
            cnt += (a+8)//10*m + (a%10 == 1)*(b+1)
            m *= 10
        return cnt 

 

 

10. 把数组排成最小的数

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

解：

先把数字转成字符。自定义一个比较大小的函数，比较两个字符串s1, s2大小的时候，先将它们拼接起来，比较 s1+s2 和 s2+s1 那个大按字符比较，如果 s1+s2 大，那说明 s2 应该放前面

class Solution:
    def PrintMinNumber(self, numbers):
        # write code here
        if not numbers:
            return ''
        def cmp(a, b):
            if a < b:
                return -1
            elif a > b:
                return 1
            return 0
        numbers = list(map(lambda x: str(x), numbers))
        numbers = sorted(numbers, cmp=lambda x, y: cmp(x+y, y+x))  # py3: key=functools.cmp_to_key(cmp)
        return ''.join(numbers).lstrip('0') or '0'  # 去掉所有左边的0，以及避免全为0的测试用例