1.linux通配符

*:代表所有字符(0到多个);

?:代表一个字符;

;:连续不同命令之间的分隔符;

#:配置文件注释;

|:管道;

~:当前用户的家目录;

-:上一次所在的路径;

$:变量前面需要加的符号;

/:路径分隔符;

>或1>:重定向,会覆盖原有数据;

>>:追加重定向;

<:输入重定向(xargs、tr);

<<:追加输入重定向(cat);

':单引号,不具有命令置换功能,输出时所见即所得;

":双引号,具有变量置换功能,解析变量后才输出.不加引号相当于双引号;

`:反引号,两个``中间为命令,会先执行,等价于$();

{}:命令区块组合或内容序列,echo stu{1..5};cp a.txt {,.bak};

!:逻辑运算中的非(not);

&&:and并且,前一个命令执行成功时,才执行后一个命令;

||:or或,前一个命令执行失败时,执行后一个命令;

.:当前目录;

..:上一级目录;

2.正则表达式:为处理大量字符串而定义的一套规则和方法

a.基础正则第一波:

# 匹配以m开头的字符,因为是贪婪模式,所以匹配到整行

grep "^m" oldboy.txt

# 匹配以m结尾的字符

grep "m$" oldboy.txt

# 匹配空行并显示行号

grep -n "^$" oldboy.txt

# 排除空行

grep -vn "^$" oldboy.txt

# 只输出匹配到的m字符

grep -no "m" oldboy.txt

.:代表且只能代表任意一个字符;

*:重复0个或多个前面的一个字符,例如:my*,0个y,会匹配有m字符的字符串;1个y,my;多个y,myyy;

\:转义,让有特殊意义的字符,只代表字符本身;

.*:匹配任意长度的任意字符.

b.基础正则第二波:

grep -no [abc] oldboy.txt 匹配集合内的任意一个字符

grep -no [^abc] oldboy.txt 不匹配集合内的字符

a\{n,m\} 前一个字符,重复n到m次

a\{n,\} 重复至少n次

a\{n\} 重复n次

a\{,m\} 最多重复m次

# -w参数是按单词搜索,只匹配有这个单词的行

grep -w "oldboy" oldboy.txt

# grep -E 不用再加转义符\,egrep、sed -r是同样的道理--支持扩展正则

# -i、-v为常用参数、-o(用于统计出现在文中的次数)

c.通配符和正则表达式比较:

通配符多用在文件上,比如find、ls、cp等;正则表达式多用于文本过滤,比如grep、awk、sed等;

*在通配符中表示匹配任意的0个或多个字符;在正则表达式中是重复之前的一个或者多个字符,不能独立使用.

3.python去重的几种方法:

>>> lst1 = [2, 1, 3, 4, 1]

>>> lst2 = list(set(lst1))

>>> print(lst2)

[1, 2, 3, 4]

二、常规方法

>>> lst1 = [2, 1, 3, 4, 1]

>>> temp = []

>>> for item in lst1:

if not item in temp:

temp.append(item)

>>> print(temp)

[2, 1, 3, 4]

三、列表推导

>>> lst1 = [2, 1, 3, 4, 1]

>>> temp = []

>>> [temp.append(i) for i in lst1 if not i in temp]

[None, None, None, None]

>>> print(temp)

[2, 1, 3, 4]

>>> data = [2, 1, 3, 4, 1]

>>> [item for item in data if data.count(item) == 1]

[2, 3, 4]

四、sort、sorted

>>> lst1 = [2, 1, 3, 4, 1]

>>> lst2.sort(key=lst1.index)

>>> lst2 = sorted(set(lst1), key=lst1.index)

个人觉得第一种和第三种方法比较好理解

sort与sorted区别:

sort 是应用在list上的方法,sorted 可以对所有可迭代的对象进行排序操作.list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作.

通过指定列表中的元素进行排序:

>>> random = [(2, 2), (3, 4), (4, 1), (1, 3)]

>>> random.sort(key=lambda s:s[1])

>>> print(random)

[(4, 1), (2, 2), (1, 3), (3, 4)]

sorted的使用方法:

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

# 按年龄降序排序

>>> sorted(students, key=lambda s: s[2], reverse=True)

[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

字符串通配符

描述
问题描述：在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。

要求：
实现如下2个通配符：
* ：匹配0个或以上的字符（注：能被*和?匹配的字符仅由英文字母和数字0到9组成，下同）
？：匹配1个字符

注意：匹配时不区分大小写。

输入：
通配符表达式；
一组字符串。
输出：

返回不区分大小写的匹配结果，匹配成功输出true，匹配失败输出false
注意：本题含有多组样例输入！
数据范围：数据组数：1<=t<=10，字符串长度：1<=s<=100
进阶：时间复杂度：O(n^2)，空间复杂度：O(n)
输入描述：
先输入一个带有通配符的字符串，再输入一个需要匹配的字符串

输出描述：
返回不区分大小写的匹配结果，匹配成功输出true，匹配失败输出false

示例1
输入：

te?t*.*
txt12.xls

输出：
false

示例2
输入：

z
zz

输出：
false

示例3
输入：

pq
pppq

输出：
false

示例4
输入：

**Z
0QZz

输出：
true

示例5
输入：

?*Bc*?
abcd

输出：
true

示例6
输入：

h*?*a
h#a

输出：
false

说明：
根据题目描述可知能被*和?匹配的字符仅由英文字母和数字0到9组成，所以?不能匹配#，故输出false
示例7
输入：

p*p*qp**pq*p**p***ppq
pppppppqppqqppqppppqqqppqppqpqqqppqpqpppqpppqpqqqpqqp

输出：
false

动态规划

dp[i][j]表示pattern前i个字符和字符串str前j个字符的的匹配情况，如果匹配，dp[i][j]=1；如果不匹配，dp[i][j]=0。初始化动态数组dp[0][0]=1，遍历一遍动态数组，假设pattern第i个字符为ch1，str数组第j个字符为ch2，：

如果ch1为∗，可以匹配或者不匹配。如果用*去匹配字符的话，dp[i][j]=dp[i][j-1]；如果忽略 ∗ ，则dp[i][j]=dp[i-1][j]。
如果ch1不为∗，考虑ch2的情况，如果ch2为数字，那么ch1必须为?或者和ch2相同的数字才能匹配成功；如果ch2为字母，那么ch1必须为?或者和ch2的大小写字母才能匹配成功；如果ch2既不为数字也不为字母，那么ch1必须和ch2相同才能匹配成功。
用以上方法更新dp数组，最后dp[pattern.size()][str.size()]表示两个字符串的匹配结果。

#include<iostream>
#include<string>
#include<vector>
using namespace std;

int match(string patten,string str){
	int n=patten.size(); int m=str.size();
	vector<vector<int>> dp(n+1,vector<int>(m+1,0));
	dp[0][0]=1;
	for(int i=1;i<=n;++i){
		char ch1=patten[i-1];
		dp[i][0]=dp[i-1][0]&&(ch1=='*');
		for(int j=1;j<=m;++j){
			char ch2=str[j-1];
			if(ch1=='*'){
				dp[i][j]=dp[i-1][j] || dp[i][j-1];
			}
			else {
				if(isalpha(ch2)){
					dp[i][j]=dp[i-1][j-1] &&(ch1==ch2 || ch1=='?' 
					|| (ch1==ch2-('a'-'A')) || ch1==ch2+('a'-'A'));
				}
				else if(isdigit(ch2)){
					dp[i][j]=dp[i-1][j-1]&&(ch1=='?'|| ch1==ch2);
				}
				else {
					dp[i][j]=dp[i-1][j-1]&&(ch1==ch2);
				}
			}
		}
	}
	return dp[n][m];
}

int main(){
	string patten,str;
	while(cin>>patten>>str){
		int flag=match(patten,str);
		if(flag) cout<<"true"<<endl;
		else cout<<"false"<<endl;
	}
	return 0;
}

复杂度分析：

时间复杂度：
O(mn)，需要遍历一遍dp数组。
空间复杂度：
O(mn)，dp数组大小为mn。