leetcode 38 Count and Say

 

38

Count and Say

36.20%

外观序列，后一个数字等于前一个数字的元素重复个数+元素本身

 

正则表达式pattern re模块函数: re.sub()替换,re.match()匹配,re.search()查找,re.group()分组, re.split()切分 lambda(): 创建匿名函数,返回一个lambda对象。lambda 参数:操作(参数)                 eg: m=lambda x,y,z: (x-y)*z,m(2,1,3)=(2-1)*3=3 for _ in range(n - 1): 把_看作一个变量，但不用这个变量。即循环n－1次，和for i in range(n-1)意义一样

 

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jan 23 17:21:03 2018

@author: vicky
"""

class Solution:
    def countAndSay(self, n):
        """
        :type n: int
        :rtype: str
        """
#       x=['1','11','21'] #1211,111221,
        x=['1']
        for i in range(1,n):
#            l=str()
#            k=0
            l,k=str(),0 #一个等式赋多个值
            for j in range(len(x[i-1])-1): 
                if x[i-1][j]!=x[i-1][j+1]:
                    l=l+str(j-k+1)+x[i-1][j]
                    k=j+1 
            l=l+str(len(x[i-1])-k)+x[i-1][len(x[i-1])-1] #j=len(x[i-1])时
            x.append(l)
        return x[n-1]
            
if __name__ == "__main__":
    n=6
    print(Solution().countAndSay(n))

#法1:用正则表达式提取字符
import re
class Solution:
    def countAndSay(self, n):
        s = '1'
        for _ in range(n - 1): 
        #把_看作一个变量，但不用这个变量，即循环n－1次，但不用这个变量_，和for i in range(n-1)没啥区别
            s = re.sub(r'(.)\1*', lambda m: str(len(m.group(0))) + m.group(1), s)
            #print(s)
            #s=1,11,21,1211,111221,312211
        return s

注释：
1.lambde用法：是Python里的匿名函数,返回一个lambde对象。eg: lambda 参数:操作(参数)
      注意事项：lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值，
              但 lambda 函数不能包含命令，包含的表达式不能超过一个。
    与def的区别：lambda会创建一个函数对象，但不会把这个函数对象赋给一个标识符，而def则会把函数对象赋值给一个变量。
               lambda它只是一个表达式，而def则是一个语句。
        eg：m = lambda x,y,z: (x-y)*z
            print m(3,1,2) 
            #结果是4

            与sort结合，列表排序：
            a = [(1, 2), (4, 1), (9, 10), (13, -3)]
            a.sort(key=lambda x: x[1]) #按照第2维度的数字从小到大给a排序
            print(a)
            # Output: [(13, -3), (4, 1), (1, 2), (9, 10)]

            与map结合，将一个 list 里的每个元素都平方：
            m=map( lambda x: x*x, [y for y in range(10)] )
            #map():根据提供的函数对指定序列做映射,map(function, iterable, ...),返回一个map对象
            #[y for y in range(10)]=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
            list(m)
            #输出结果[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
     这里 lambda m: str(len(m.group(0))) + m.group(1)意思是所有字符的个数＋第一组的字符     
            
2.re.sub用法：re.sub(pattern, repl, string, count=0, flags=0)：    
              pattern为正则中的模式字符串；repl表示替换的字符串，也可为一个函数；
              string为被查找替换的原始字符串；count表示模式匹配后替换的最大次数，默认0表示替换所有的匹配。
       这里的pattern为：r'(.)\1*':第一组为一个任意字符，第二组为任意个数字1
       repl函数为：lambda m: str(len(m.group(0))) + m.group(1)，所有字符的个数＋第一组的字符
       被查找的string为：s（即第n行输出值）
       意思是：把s中的每一个字符替换成 1或2的个数（group(0)＋1或2(group(1))
       #s=1,11,21,1211,111221,312211

正则表达式介绍：
http://www.runoob.com/python/python-reg-expressions.html
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143193331387014ccd1040c814dee8b2164bb4f064cff000
正则表达式模式pattern：（记得前面加'r'）
    字符类别：'\d'匹配一个数字，
            '\w'匹配一个字母或数字，
            '.'匹配一个任意字符,
            '\s'匹配一个空格,
            eg: '00\d'可以匹配'007'，但无法匹配'00A'；
    字符个数：'*'表示任意个字符（包括0个)
            '+'表示至少一个字符
            '?'表示0个或1个字符,
            '{n}'表示n个字符,
            '{n,m}'表示n-m个字符,
    字符范围：要做更精确地匹配，用'[]'表示范围
            eg:r'[0-9a-zA-Z\_]+'匹配至少由一个数字、一个字母或者一个下划线组成的字符串，比如'a100'，'0_Z'，'Py3000'等等；
    或：'A|B'匹配A或B
    限定字符的开头和结束：'^'表示行的开头，'^\d'表示必须以数字开头;
                      '$'表示行的结束，'\d$'表示必须以数字结束  
    字符类：  详见http://www.runoob.com/python/python-reg-expressions.html 
    '[Pp]ython'匹配 "Python" 或 "python"
    'rub[ye]'匹配 "ruby" 或 "rube"
    '[aeiou]'匹配中括号内的任意一个字母
    '[0-9]'匹配任何数字。类似于 [0123456789]
    '[a-z]'匹配任何小写字母
    '[A-Z]'匹配任何大写字母
    '[a-zA-Z0-9]'匹配任何字母及数字
    '[^aeiou]'除了aeiou字母以外的所有字符
    '[^0-9]'匹配除了数字外的字符
    特殊字符类: 
    '.'匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
    '\d'	匹配一个数字字符。等价于 [0-9]。
    '\D'匹配一个非数字字符。等价于 [^0-9]。
    '\s'	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
    '\S'匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
    '\w'匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
    '\W'匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
    其他补充：
    '(?imx)'正则表达式包含三种可选标志：i,m,或x。只影响括号中的区域。
    '(?-imx:re)'在括号中不使用i,m,或x可选标志
                      
    eg: 要匹配'010-12345'这样的号码，r'\d{3}\-\d{3,8}',(由于'-'是特殊字符，在正则表达式中，要用'\'转义)
       
re模块的函数：
    正则字符串前要加r: r'string',由于Python的字符串本身也用\转义，所以要使用Python的 r 前缀，就不用考虑转义的问题了:
        'ABC\\-001'对应正则表达式字符串会变成 'ABC\-001'，少了个\
        r'ABC\-001'对应正则表达式字符串不变 'ABC\-001';
    匹配：re.match(pattern, string, flags=0)：
            patten表示正则表达式，string表示字符串，flags用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等，flags可忽略
            从字符串的起始位置匹配一个模式，如果匹配成功，返回一个Match对象，如果不是起始位置匹配成功的话，就返回None
            eg: re.match(r'表达式', '表达')返回None        
                re.match(r'^\d{3}\-\d{3,8}$', '010-12345')返回 <_sre.SRE_Match object; span=(0, 9), match='010-12345'>   
    切分：re.split():用正则表达式切分字符串
              用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：
              eg：>>> 'a b   c'.split(' ')
                      ['a', 'b', '', '', 'c']
                无法识别连续的空格，用正则表达式试试：
                 >>> re.split(r'\s+', 'a b   c')
                     ['a', 'b', 'c']
    分组：用'()'给正则表达式分组
     re.group():可以和match(),search()等结合，输出不同分组的字符结果
        eg: r'^(\d{3})-(\d{3,8})$'分别定义了两个组,限定了以第一个组开头，以最后一个组结束
            第一个组为3个数字，第二个组为3-8个数字，两个组中间用－连接(这里没加'\'-转义？？)
            >>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
            >>> m
                <_sre.SRE_Match object; span=(0, 9), match='010-12345'>
            >>> m.group(0) 或者 m.group()  #group(0)＝m.group()＝原始字符串
                '010-12345'  
            >>> m.group(1) #group(1)=第一组
                '010'
            >>> m.group(2) #group(2)=第二组
                '12345'
        注意：group(0)永远是原始字符串,group(1)、group(2)……表示第1、2、……个子串。
            >>> m.groups() #.groups():输出所有分组
                ('010', '12345')
    查找：re.search(pattern, string, flags=0)：扫描整个字符串，返回一个匹配的对象，否则返回None。
            用span()返回匹配的位置：
            eg：>>>re.search('www', 'www.runoob.com').span()  # 在起始位置匹配
                  (0, 3)
               >>>re.search('com', 'www.runoob.com').span()# 不在起始位置匹配
                  (11, 14)
     re.match与re.search的区别:
        re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
        而re.search匹配整个字符串，直到找到一个匹配。
    替换：re.sub(pattern, repl, string, count=0, flags=0)    
        repl表示替换的字符串，也可为一个函数。count表示模式匹配后替换的最大次数，默认0表示替换所有的匹配。    
        eg：#这里的repl函数double为将匹配的数字乘于 2：
            def double(matched):
                value = int(matched.group('value'))
                return str(value * 2)
            s = 'A23G4HFD567' #string
            print(re.sub('(?P<value>\d+)', double, s)) 
            #pattern为 0或1个数字,或者至少一个数字，（两种可选）
            输出：A46G8HFD1134

#法2：用正则表达式
def countAndSay(self, n):
    s = '1'
    for _ in range(n - 1):
        s = ''.join(str(len(group)) 
            + digit for group, digit in re.findall(r'((.)\2*)', s))
    return s