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)]

 
每当fox出现在Oracle脚本中时，都会要求您为它提供一个值。而使用fox，您只需要在 fox第一次出现时为它提供变量值。如果想将
 
在where子句中，通配符可与like条件一起使用。在Oracle中：
 
%(百分号)： 用来表示任意数量的字符，或者可能根本没有字符。
 
_(下划线)： 表示确切的未知字符。
 
?(问号)： 用来表示确切的未知字符。
 
#(井号)： 用来表示确切的阿拉伯数字，0到9。
 
[a-d](方括号)：用来表示字符范围，在这里是从a到d。
 
单引号(')：在Oracle中，应该只使用单引号将文本和字符和日期括起来，不能使用引号(包括单双引号)将数字括起来。
 
双引号(")：在Oracle中，单双引号含义不同。双引号被用来将包含特定字符或者空格的列别名括起来。双引号还被用来将文本放入日期格式。
 
撇号(')：在Oracle中，撇号也可以写成彼此相邻的两个单引号。为了在供应商名字中间查找所有带撇号的供应商名字，可以这样编写代码
 
&符号：在Oracle中,&符号常用来指出一个变量。
 
例如，&fox是一个变量，稍微有点不同的一种&& fox。每当&fox出现在Oracle脚本中时，都会要求您为它提供一个值。而使用&&fox，您只需要在& &fox第一次出现时为它提供变量值。如果想将&符号作为普通的符号使用，则应该关闭这个特性。要想关闭这个特性，可以运行以下的命令： set define off ，这是一个SQLplus命令，不是一个SQL命令。SQLplus设置了SQL在Oracle中运行的环境。
 
双竖线(||)：Oracle使用双竖线表示字符串连接函数。
 
星号(*)：select *意味着选择所有的列，count(*)意味着计算所有的行，表示通配符时，表示0个或任意多个字符。
 
正斜杠(/)：在Oracle中，用来终止SQL语句。更准确的说，是表示了“运行现在位于缓冲区的SQL代码”。正斜杠也用作分隔项。
 
SQL> select * from test;
 
ID NAME
 
---------- --------------------
 
1 baaab
 
2 ba_ab
 
3 ba%ab
 
SQL> select * from test where name like '%_%';
 
ID NAME
 
---------- --------------------
 
1 baaab
 
2 ba_ab
 
3 ba%ab
 
SQL> select * from test where name like '%\_%' escape '\';
 
ID NAME
 
---------- --------------------
 
2 ba_ab
 
所以我们在将oracle里面一些特定的通配符用作普通字符是，一定别忘了加escape关键字，它的作用如下：
 
1.使用 ESCAPE 关键字定义转义符。在模式中，当转义符置于通配符之前时，该通配符就解释为普通字符。
 
2.ESCAPE 'escape_character'
 
允许在字符串中搜索通配符而不是将其作为通配符使用。escape_character 是放在通配符前表示此特殊用途的字符。
 
select * from a WHERE name LIKE '%/%ab' ESCAPE '/'
 
， 本条技术文章来源于互联网，如果无意侵犯您的权益请点击此处反馈版权投诉 本文系统来源：php中文网

如题：
 
给定一个带通配符问号的数W，问号可以代表任意一个一位数字。
 再给定一个整数X，和W具有同样的长度。

 问有多少个整数符合W的形式并且比X大？

 

 输入格式

 多组数据，每组数据两行，第一行是W，第二行是X，它们长度相同。在[1..10]之间.

 输出格式

 每行一个整数表示结果。

 

 答题说明

 输入样例

 36?1?8

 236428

 8?3

 910

 ?

 5

 输出样例

 100

 0

 4

 

 分析如下：

 先用穷举法来分析几种可能情况

 1.

 36?1?8

 236428

 如果W第一个通配符之前的数字大于X，则通通配符可以是任意数字，因此W比X大的个数就是10的n次方（通配符个数n）

 2.

 8?3

 910

 如果W第一个通配符之前的数字小于x,则W不可能比X大，结果为0

 3.

 2?

 25

 如果W第一个通配符之前的数字等于x，这时，只有W的通配符比X相应位置的数字大的情况，才有可能使w比X大，因此通配符前面的数字不起任何作用，

 我们可以把它简化为

 ？

 5

 此时可以得到结果为4

 

 分析完了第一个通配符我们来分析第二个通配符，这时我们发现，只有第一个通配符前面没有数字或数字和x相等的情况下，我们才需要考虑第二个通配符。

 

 并且情况很相似，只有第一个通配符和x相同位置中的数字相等的情况，我们才需要对第二个通配符进行分析，

 否则，跟上面的情况类似，

 如果第一个通配符大于x中的数字，则W比X大的个数就是10的n-1次方（通配符个数n）

 如果第一个通配符小于x中的数字，则W比X大的个数就是0

 

 
以此类推，就可以得出W比X大总个数
 
c#示例代码如下：
 

 
 

        /// <summary>
        /// 使用算法推算w大于x的个数
        /// </summary>
        /// <param name="string_W"></param>
        /// <param name="string_X"></param>
        /// <returns></returns>
        private int getNum(string string_W, string string_X)
        {
            if (int.Parse(string_W.Replace('?', '9')) <= int.Parse(string_X))
            {
                return 0;
            }

            int firstCharIndex = -1;//第一个通配符的索引
            int secondCharIndex = -1;//第二个通配符的索引
            int value_x = 0;字符串string_X中在第一个通配符相应位置的数字的值
            int charCount = 0;//通配符数量

            //找到第一个通配符的索引和第二个通配符的索引
            for (int i = 0; i < string_W.Length; i++)
            {
                if (string_W[i] == '?')
                {
                    charCount++;

                    if (firstCharIndex == -1)
                    {
                        value_x = int.Parse(string_X[i].ToString());
                        firstCharIndex = i;
                        continue;
                    }
                    if (firstCharIndex != -1 && secondCharIndex == -1)
                    {
                        secondCharIndex = i;
                    }
                }
            }
            //第一个通配符前面有数字,并且与x不相等的情况
            if (firstCharIndex > 0)
            {
                int formerValue_W = int.Parse(string_W.Substring(0, firstCharIndex));
                int formerValue_X = int.Parse(string_X.Substring(0, firstCharIndex));
                if (formerValue_W > formerValue_X)
                {
                    //如果之前的数据W>X,则=通配符的个数n  10的n次方
                    return (int)Math.Pow(10, charCount);
                }
                else if (formerValue_W < formerValue_X)
                {
                    return 0;
                }
            }

            //如果第一个通配符之前的数相等或没有数字,判断通配符和X字符的大小情况
            if (charCount > 1)
            {
                //递归计算出结果  第一个通配符大于x的情况+等于x时进行递归推算
                return (9 - value_x) * (int)Math.Pow(10, charCount - 1) +
                    getNum(string_W.Substring(firstCharIndex + 1), string_X.Substring(firstCharIndex + 1));
            }
            else
            {
                //只有一个通配符，判断当通配符与x相同位置的整数相同时，w和x的大小
                int W = int.Parse(string_W.Replace('?', string_X[firstCharIndex]));
                int X = int.Parse(string_X);
                if (W > X)
                {
                    return (9 - value_x) + 1;
                }
                else
                {
                    return (9 - value_x);
                }
            }
        }
        /// <summary>
        /// 使用常规逻辑遍历计算w大于x的个数
        /// </summary>
        /// <param name="string_W"></param>
        /// <param name="string_X"></param>
        /// <returns></returns>
        private int CalNum(string string_W, string string_X)
        {
            int value_x = int.Parse(string_X);

            string[] parms_w = string_W.Split('?');

            string[] charDic = new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "l", "m" };//最多10个
            //字符字典，用于依次替换string_W中的通配符，以方便递归方法中的遍历
            string_W = "";

            for (int i = 0; i < parms_w.Length; i++)
            {
                string_W += parms_w[i] + charDic[i];
            }
            string_W = string_W.Substring (0,string_W .Length -1);
            int charCount = parms_w.Length - 1;

            return CalNum_sub(string_W, value_x, charDic, charCount); ;
        }
        /// <summary>
        /// CalNum方法中用到的递归计算
        /// </summary>
        /// <param name="string_W"></param>
        /// <param name="value_x"></param>
        /// <param name="charDic"></param>
        /// <param name="charCount"></param>
        /// <returns></returns>
        private int CalNum_sub(string string_W, int value_x, string[] charDic, int charCount)
        {
            int total = 0;

            for (int k = 0; k < 10; k++)
            {
                string temp = string_W.Replace(charDic[charCount - 1], k.ToString());
                if (charCount > 1)
                {
                    total += CalNum_sub(temp, value_x, charDic, charCount - 1);
                }
                else
                {
                    if (int.Parse(temp) > value_x)
                    {
                        total++;
                    }
                }
            }
            return total;
        }

        /// <summary>
        /// 测试方法
        /// </summary>
        /// <param name="string_W"></param>
        /// <param name="string_X"></param>
        /// <returns></returns>
        private string testNum(string string_W, string string_X)
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            int v1 = CalNum(string_W, string_X);
            watch.Stop();
            string t1 = watch.ElapsedTicks.ToString();
            watch.Reset();
            watch.Start();
            int v2 = getNum(string_W, string_X);
            watch.Stop();
            string t2 = watch.ElapsedTicks.ToString();
            return (v1 + "--" + v2 + "\r\n" + t1 + "--" + t2).ToString();
        }


 

 

 给定一个带通配符问号的数W，问号可以代表任意一个一位数字。
 
 再给定一个整数X，和W具有同样的长度。
 
 问有多少个整数符合W的形式并且比X大？
 
 
 
 
 输入格式
 
 多组数据，每组数据两行，第一行是W，第二行是X，它们长度相同。在[1..10]之间.
 
 输出格式
 
 每行一个整数表示结果。
 
 
 
 输入样例
 
 
 36?1?8
 
 
 236428
 
 
 8?3
 
 
 910
 
 
 ?
 
 
 5
 
 
 输出样例
 
 
 100
 
 
 0
 
 
 4
 
 
 
 
 
 
 
 
 #include<stdio.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 char* getInfo(char* str)
 {
     return str;
 }
 int main()
 {    
     int n = 236428;
     char p[10] = "36?1?8";
     printf("%s\n%d\n %d\n", p, n, getNumber(p, n));
     printf(getInfo("Hello World"));
 }
 int getNumber(char * pPatternInt, int nComp)
 {
         int k = 0;
         char nToStr[10];
         sprintf(nToStr, "%d", nComp);
         if(strlen(pPatternInt) != strlen(nToStr)) return k;
 
 
         int nLen = strlen(pPatternInt);
         int i = 0;
         int nQuestionMarkNumber = 0;
         while(i < nLen){
                 if(pPatternInt[i] == '?')       nQuestionMarkNumber++;
                 i++;
         }
         i = 0;
 
 
         while(i < nLen){
                 if(pPatternInt[i] != '?'){
                         if(pPatternInt[i] > nToStr[i]){
                                 k = (nQuestionMarkNumber==0?0:pow(10, nQuestionMarkNumber));
                                 break;
                         }
                         else if(pPatternInt[i] == nToStr[i]){
                                 i++;
                                 continue;
                         }
                         else break;
                 }
                 else{
                         k = 9 - (int)nToStr[i] + 10 * (nQuestionMarkNumber - 1);
                         break;
                 }
         }
 
         return k;
 }