精华内容
下载资源
问答
  • :代表一个字符;;:连续不同命令之间的分隔符;#:配置文件注释;|:管道;~:当前用户的家目录;-:上一次所在的路径;$:变量前面需要加的符号;/:路径分隔符;>或1>:重定向,会覆盖原有数据;>>:追加重定向;...

    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中:%(百分号): 用来表示任意数量...

    每当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 '/'

    logo.gif, 本条技术文章来源于互联网,如果无意侵犯您的权益请点击此处反馈版权投诉 本文系统来源:php中文网

    展开全文
  • 算法实战: 给定一个通配符问号的数W,问号可以代表任意一个一位数字。 再给定一个整数X,和W具有同样的长度。 问有多少个整数符合W的形式并且比X大?

    如题:

    给定一个带通配符问号的数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,第二行...

    给定一个带通配符问号的数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;
    }

    展开全文
  • 通配符

    2016-08-03 09:35:16
    1、通配符通配符作用?...[-]匹配中括号中任意一个字符,-代表一个范围。例如:[a-z]代表匹配一个小写字母。[^]逻辑非,表示匹配不是中括号内的一个字符。例如:[^0-9]代表匹配一个不是数字的字符。...
  • 什么是通配符(glob)?通配符是Linuxshell中...]代表非括号中存在的任意单个字符[^]代表指定范围外的任意单个字符[a-z]代表所有单个小写字母[A-Z]代表所有单个大写字母[:digit:]代表所有单个数字[:upper:]代表所有单...
  • 在ultraedit中进行搜索替换ÿ...想要把每一个搜索到的内容最后的B替换为9。*所代表字符保持不变。 例子可能不太准确,但就是这么个意思,替换后让*所代表字符保持不变 如何才能实现呢?</p>
  • 在搜索数据库中的数据时,SQL 通配符可以替代一个或多个字符。 SQL 通配符必须与 LIKE 运算符一起使用。 在 SQL 中,可使用以下通配符通配符 描述 % 替代一个或多个字符 _ ...
  • Shell 通配符 特殊字符

    2020-02-28 10:25:16
    通配符 作 用 ? 匹配一个任意字符 * 匹配 0 个或任意多个任意字符,也就是可以... 匹配中括号中任意一个字符,- 代表一个范围。例如,[a-z] 代表匹配一个小写字母 {} 匹配集合,例如ls /etc/{yu...
  • 给定一个通配符问号的数W,问号可以代表任意数字。 再给定一个整数X,和W具有同样的长度。 问有多少个整数符合W的形式并且比X大? 输入格式 多组数据,每组数据两行,第一行是W,第二行是X,它们长度相同。在[1.....
  • 实现字通配符*

    2019-09-20 18:32:07
    当不知道真正字符或者懒得输入完整名字时,常常使用通配符代替一个或多个真正的字符。 实际上用"*Not?pad"可以对应Notepad\MyNotepad【*可以代表任何字符串;?仅代表单个字符串,但此单字必须存在】;Notep[ao]d可以...
  • 代表一个任意字符。。但是在使用中却有时会经常出错。。特别是在命令行上运行时 我们知道shell 的参数解析是“-”,也就是说把“-”开头或“--”当作是参数。。这可和Win的“/”个不同。。 也就是这个问题
  • 字符通配符匹配

    千次阅读 2019-02-27 15:52:27
    通配符 * 表示可以替换一个 长度任意的字符串 或者替换空 a*b? 可以匹配: acdbfdbf abc 现给定通配字符串s1 判断s2 是否满足匹配 思路:采用动态规划 dp[i][j]表示S1前i长度部分与S2前j部分是否匹配 对于dp[i...
  • C一个简单的通配符匹配实例

    千次阅读 2012-08-18 16:29:23
    例如:SQL中有“_”通配符(仅替代一个字符) 与“%”通配符(替代一个或多个字符),须与LINK运算符一起使用。 此处仅考虑通配符*和?,*表示0或任意多个字符,?表示单个字符。 int match(char *pat,char *str...
  • 可以匹配一个字符 这个算法应用的是递归的算法,开始担心如果字符串过长的话,会因递归引起栈的溢出,还好在网上查了一下,win32默认的递归栈大小是2M,这足以进行很长字符串的匹配。 下面是核心的代码,思路...
  • 字符串2中能够存在'*'符号,且该符号能够代表随意字符,即字符串2中存在通配符。e.g. 输入:abcdefghabef, a*f 输出:abcdef#include #include using namespace std;bool Match(const string &s1,const string &s2,...
  •  问题描述:在计算机中,通配符一种特殊语法,广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。 要求: 实现如下2通配符: *:匹配0或以上的字符字符由英文字母和数字0-...
  • 给定一个号码与通配符问号W,问号代表一个随机数字。 给定的整数,得到X,和W它具有相同的长度。 问:多少整数协议W的形式和的比率X大? 进格公式 数据的多组,两排各数据的,W,第二行是X。它们长度同样。在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,898
精华内容 34,359
关键字:

代表一个字符的通配符