精华内容
下载资源
问答
  • 它也处理此类向量的串联,并且实际上对于任何实际数组(受数值精度的考虑)都会生成该数组的有效字符串表示,作为重新整形的行向量。 我写这个是因为我发现自己 GUI 中使用输入对话框,其中输入一个数字向量作为...
  • 使用 MATLAB 冒号表示法(单一分辨率)将向量转换为字符串。 选项是: 'Delimiter' - 'on','yes','off','no' {default on} :包括方括号 [] (或大括号 {} 当输出的尺寸不一致时) 默认为“自动”。 'Sort' - 'on...
  • 将日期时间或日期向量或序列日期号轻松转换为日期字符串。 日期字符串可以是ISO 8601时间戳,也可以是单个日期/时间值,由(可选)输入令牌选择。 多个令牌可用于输出多个字符串。 此函数支持的 ISO 8601 时间戳...
  • 字符串的特征向量与KMP算法

    千次阅读 2015-03-30 16:33:16
    字符串的特征向量就是由字符串各位置上的特征数构成的一个向量。设字符串为P,令Pi为从字符串首字母到第i个位置的前缀,则字符串P的i位置上的特征数就是Pi的首尾非空真子串匹配的最大长度。例如:字符串abcdaabcab的...

    字符串的特征向量就是由字符串各位置上的特征数构成的一个向量。设字符串为P,令Pi为从字符串首字母到第i个位置的前缀,则字符串P的i位置上的特征数就是Pi的首尾非空真子串匹配的最大长度。例如:字符串abcdaabcab的特征向量是(0,0,0,0,1,1,2,3,1,2)。其中第5个位置的特征数是1,因为P5是abcdaa,首尾非空真子串能够匹配的就是a;而第7个位置的特征数是3,因为P7是abcdaabc,首尾非空真子串能够匹配的是abc。0位置上的特征数显然为0。暴力法求特征向量显然是非常耗时的,实际上可以基于这样一个思路求特征向量:从0位置开始求特征数,i位置上的特征数是由之前位置的特征数决定的。

    用Next数组表示字符串的特征向量。如上所示,假设Next[i-1]==x1,也就是说i-1位置上首尾x1个元素是匹配的。很显然,当P[i]==P[x1]时,i位置上首尾至少有x1+1个元素匹配,实际上就是x1+1个。

    当P[i]!=P[x1]时,考查Next[x1-1],假设其值为x2,这说明在x1-1位置上首尾x2个元素相等,此时,如果P[i]==P[x2],则说明i位置首尾至少有x2+1个元素是匹配的,实际上就是x2+1个。如果P[i]!=P[x2],则可以考查Next[x2-1],依次类推。直到x的值为0,此时如果P[i]==P[x],则特征数为x+1也就是1,否则就是0。 上述过程并不是算法的充分条件,只是由特征向量推出的性质;当然理论上也早有证明,这个性质是可以用来求出特征向量的。
    POJ2406是一道利用特征向量的简单题目。假设字符串s是另外一个字符串的t的n次方,即s是由t重复n次得到的,那么最后一个位置上的首尾匹配的真子串一定是s-t,而t的长度一定是s的长度减去s最后一个位置上的特征数,且s的长度一定是t长度的整数倍。这也是由n次方得到的性质,但是利用这个性质一样可以证明s一定是t的n次方。

    //令字符串S=s^n,求最大的n
    //例如aaaa = a^4 = (aa)^2,则答案是4
    //如果S长度为L,s的长度为l,则S最后一个特征数一定是L-l
    //而且L是l的n倍
    #include <cstdio>
    #include <cstring>
    using namespace std;
    #define SIZE 1000005
    
    void getNext(char const P[],int n,int next[]){
        next[0] = 0;
        for(int i=1;i<n;++i){
            int k = next[i-1];
            while( k > 0 && P[k] != P[i] ) k = next[k-1];
            next[i] = ( P[i] == P[k] ) ? k + 1 : 0;
        }
        return;
    }
    
    char P[SIZE];
    int Next[SIZE];
    int main() {
        while( scanf("%s",P) ){
            if ( '.' == *P && '\0' == P[1] ) return 0;
            int len = strlen(P);
            getNext(P,len,Next);
            if ( len % ( len - Next[len-1] ) ) printf("1\n");
            else printf("%d\n",len/(len-Next[len-1]));
        }
        return 0;
    }
    

    令目标为T,模式为P,问P是否为T的子串,这就是字符串匹配问题。暴力法很容易想到,每当不匹配的时候,将P后移一个位置,再次尝试匹配。KMP算法的关键就在于当不匹配时,P是否只能往后移动一位?

    上图很明显显示了:当Pi与对应的Ti字母不相等时,P可以往后移多位。假设next[i-1]==2,则P应该往后移动i-2位再进行匹配。一般的,应该往后移动i-next[i-1]位。例如:abcdaabcab的特征向量是(0000112312),假设T1是abcz….,则当比较到第3位的时候字母不匹配,此时应该把P后移3-next[2]也就是3位,再进行比较;假设T2是abcdaabcz…,则当比较到第8位的时候不匹配,此时应该将P后移到8-next[7]也就是5位,再开始比较。
    不过,特别要注意的是:在上图中,P后移了i-next[i-1]位以后(假设next[i-1]是2),P0还需要与T[i-2]进行比较吗?P1还需要与T[i-1]进行比较吗?不需要,因为可以确定是相等的,只需从Ti和P2开始往下比较。所以很重要的一点:KMP算法中,T的字母只访问一次,T中已经比较过的字母不需要再次与P去比较,T的下标不存在回溯。所以KMP算法是线性时间的。对P而言,当Pi字母与T对应字母不匹配时,需要从P的第next[i-1]个字母重新开始比较。在上图中,就是要从第2个字母开始比较。在T2的例子中,T2是abcdaabcz…,P是abcdaabcad,当第8个字母a与T的字母z不匹配的时候,我们只需从P中的第3个字母d开始再跟T比较。
    所以,我们可以重新定义特征数和特征向量,i位置的特征数就是当i位置的字母不匹配的时候,P的下标需要重新定位的位置。特别的当第0个位置不匹配时,令next[0]==-1,表示P的下标仍然维持在0,但T的下标要往后移一位。于是P: abcdaabcad的KMP匹配算法的特征向量是(-1,0,0,0,0,1,1,2,3,1)。
    KMP算法仍然有优化的可能,当T3是abcdaaz…时,比较到第6个字母,P的下标应该回溯到几?按上述值应该是1,但其实可以回到0。假设T4是abcdz…,当比较到第4个字母不匹配时,P的下标应该回到几?可以回到0,但实际上T的这个字母不用再比较了,所以在P的下标回到0的同时,T的下标应该加1。这种操作恰好是特征向量为-1时应该进行的操作。

    如上,令i的特征数是x1,即当Pi不匹配时,P下标应该回到x1。但是当P[i]==P[x1]时,下标还可以再往前。令x1位置的特征数是x2,则显然下标可以回到x2,当P[i]!=P[x2]时。否则,下标还可以往前,如此反复直到0位置。如果P[i]==P[0],则i位置的特征数应该是-1,表示此位置不匹配时,P的下标维持在0,而T的下标加1。字符串abcdaabcab优化过后的特征向量应该是(-1,0,0,0,-1,1,0,0,3,0)。
    hdu1711是标准的KMP问题,只不过匹配的不是字符串,而是整数序列。

    //KMP算法,匹配的不是字符序列,而是整数
    #include <cstdio>
    using namespace std;
    int T[1000005];
    int P[10005];
    int Next[10005];
    void getKMPNext(int const P[],int n,int next[]){
        next[0] = -1;
        int i = 0, k = -1;
        while( i < n ){
            while( k >= 0 && P[i] != P[k] )
                k = next[k];
            ++i,++k;
            if ( i == n ) return;
            next[i] = ( P[i] == P[k] ) ? next[k] : k;
        }
    }
    //在T中搜索P,输出第一个找到的位置,否则输出-1
    int KMP(int const T[],int tn,int const P[],int pn,int const next[]){
        if ( pn > tn ) return -1;
        int tp = 0, pp = 0;
        while( tp < tn ){
            if ( -1 == pp || T[tp] == P[pp] ) ++tp,++pp;
            else pp = next[pp];
            if ( pn == pp ) return tp - pp;
        }
        return -1;
    }
    int main() {
        int nofkase;
        scanf("%d",&nofkase);
        while(nofkase--){
            int tn,pn;
            scanf("%d%d",&tn,&pn);
            for(int i=0;i<tn;++i)scanf("%d",T+i);
            for(int i=0;i<pn;++i)scanf("%d",P+i);
            getKMPNext(P,pn,Next);
            //从1开始索引
            int t = KMP(T,tn,P,pn,Next);
            printf("%d\n",(-1==t)?-1:t+1);
        }
        return 0;
    }
    
    展开全文
  • 字符串 ... 创建字符向量 通过将字符序列括单引号中来创建一个字符向量。 chr = 'Hello, world' ...字符向量为 char 类型的 1×n 数组。计算机编程中,字符串表示 1×n 字符数组的常用术 语。但...

    字符串

    https://ww2.mathworks.cn/help/matlab/characters-and-strings.html

     

    创建字符向量
    通过将字符序列括在单引号中来创建一个字符向量。
    chr = 'Hello, world'
    chr =
    'Hello, world'
    字符向量为 char 类型的 1×n 数组。在计算机编程中,字符串是表示 1×n 字符数组的常用术
    语。但是,从 R2016b 开始,MATLAB 同时提供 string 数据类型,因此 1×n 字符数组在
    MATLAB 文档中称为字符向量。
    whos chr
    Name Size Bytes Class Attributes
    chr 1x12 24 char
    如果文本包含单个引号,请在分配字符向量时放入两个引号。
    newChr = 'You''re right'
    newChr =
    'You're right'
    uint16 等函数将字符转换为其数值代码。
    chrNumeric = uint16(chr)
    chrNumeric =
    1×12 uint16 row vector
    72 101 108 108 111 44 32 119 111 114 108 100
    char 函数将整数向量重新转换为字符。
    chrAlpha = char([72 101 108 108 111 44 32 119 111 114 108 100])

     

    要将字符向量合并到二维字符数组中,请使用方括号或 char 函数。
    • 应用 MATLAB 串联运算符 []。使用分号 (;) 分隔每一行。每一行都必须包含相同数量的字
    符。例如,合并长度相同的三个字符向量:
    devTitle = ['Thomas R. Lee'; ...
    'Sr. Developer'; ...
    'SFTware Corp.']
    devTitle =
    3×13 char array
    'Thomas R. Lee'
    'Sr. Developer'
    'SFTware Corp.'
    如果字符向量的长度不同,请根据需要用空格字符填充。例如:
    mgrTitle = ['Harold A. Jorgensen '; ...
    'Assistant Project Manager'; ...
    'SFTware Corp. ']

     

     

    调用 char 函数。如果字符向量的长度不同,char 将用尾随空格填充较短的向量,以使每
    一行具有相同数量的字符。
    mgrTitle = char('Harold A. Jorgensen', ...
    'Assistant Project Manager', 'SFTware Corp.')
    mgrTitle =
    3×25 char array
    'Harold A. Jorgensen '
    'Assistant Project Manager'
    'SFTware Corp. '

    水平合并字符向量
    要将字符向量合并到一个行向量中,请使用方括号或 strcat 函数。
    • 应用 MATLAB 串联运算符 []。用逗号或空格分隔输入字符向量。此方法可保留输入数组中
    的任何尾随空格。
    name = 'Thomas R. Lee';
    title = 'Sr. Developer';
    company = 'SFTware Corp.';
    fullName = [name ', ' title ', ' company]
    MATLAB 返回
    fullName =
    'Thomas R. Lee, Sr. Developer, SFTware Corp.'


    调用串联函数 strcat。此方法可删除输入中的尾随空格。例如,组合字符向量以创建一个
    假设的电子邮件地址。
    name = 'myname ';
    domain = 'mydomain ';
    ext = 'com ';
    address = strcat(name, '@', domain, '.', ext)
    address =
    'myname@mydomain.com'

    使用以下任何函数标识字符数组,或者标识字符数组中的某些字符。
    函数 说明
    ischar 确定输入是否为字符数组
    isletter 查找输入字符数组中的所有英文字母
    isspace 查找输入字符数组中的所有空格字符
    isstrprop 查找特定类别的所有字符
    查找字符向量中的空格。
    chr = 'Find the space characters in this character vector';
    % | | | | | | |
    % 5 9 15 26 29 34 44
    find(isspace(chr))
    ans =
    5 9 15 26 29 34 44


    使用空格字符
    blanks 函数会创建一个包含空字符的字符向量。创建一个包含 15 个空格字符的向量。字符
    向量始终会显示在单引号之间。
    chr = blanks(15)
    chr =
    ' '
    在空白字符向量的中间插入一些非空格字符。
    chr(6:10) = 'AAAAA'
    chr =
    ' AAAAA '
    您可以使用 strjust 函数将这些字符的位置向左或向右对齐:
    chrLeft = strjust(chr,'left')
    chrLeft =
    'AAAAA '
    chrRight = strjust(chr,'right')
    chrRight =
    ' AAAAA'
    使用 deblank 删除所有尾随空格字符:
    chrDeblank = deblank(chr)
    chrDeblank =
    ' AAAAA'
    使用 strtrim 删除所有前导和尾随空格:
    chrTrim = strtrim(chr)
    chrTrim =
    'AAAAA'
     

    字符数组中的数据
    有时,字符表示的数据并不对应到文本,例如 DNA 序列。您可以将此类数据存储在数据类型
    为 char 的字符数组中。字符数组使用单引号。
    seq = 'GCTAGAATCC';
    whos seq
    Name Size Bytes Class Attributes
    seq 1x10 20 char
    数组的每个元素都包含单个字符。
    seq(4)
    ans =
    'A'
    使用方括号串联字符数组,就像串联数值数组一样。
    seq2 = [seq 'ATTAGAAACC']
    seq2 =
    'GCTAGAATCCATTAGAAACC'
    在字符串数组引入之前编写的程序中,字符数组很常见。接受 string 数据的所有 MATLAB 函
    数都能接受 char 数据,反之亦然

     

    创建字符串数组
    R2016b 中引入了字符串数组。字符串数组可存储文本片段,并提供一组用于将文本按数据进
    行处理的函数。您可以对字符串数组进行索引、重构和进行串联,就像处理任何其他类型的数
    组一样。此外,还可以访问字符串中的字符,并使用 plus 运算符向字符串追加文本。要重新
    排列字符串数组中的字符串,请使用 split、 join 和 sort 等函数。
    根据变量创建字符串数组
    MATLAB® 提供字符串数组来存储文本片段。字符串数组的每个元素都包含一个 1×n 字符序
    列。
    从 R2017a 开始,您可以使用双引号创建字符串。

    当您处理文本时,将字符序列括在双引号中。可以将文本赋给变量。
    t = "Hello, world";
    如果文本包含双引号,请在定义中使用两个双引号。
    q = "Something ""quoted"" and something else."
    q =
    "Something "quoted" and something else."

     

    作为备选方法,您可以使用 string 函数将字符向量转换为字符串。 chr 为一个 1×17 字符向
    量。 str 为一个与该字符向量具有相同文本的 1×1 字符串。
    chr = 'Greetings, friend'
    chr =
    'Greetings, friend'
    str = string(chr)
    str =
    "Greetings, friend"
    使用 [] 运算符创建一个包含多个字符串的字符串数组。 str 是一个 2×3 字符串数组,其中包
    含六个字符串。
    str = ["Mercury","Gemini","Apollo";
    "Skylab","Skylab B","ISS"]
    str = 2x3 string array
    "Mercury" "Gemini" "Apollo"
    "Skylab" "Skylab B" "ISS"

     

    作为备选方法,您可以使用 string 函数将字符向量元胞数组转换为字符串数组。MATLAB 使
    用双引号显示字符串数组中的字符串,使用单引号显示元胞数组中的字符向量。
    C = {'Mercury','Venus','Earth'}
    C = 1x3 cell array
    {'Mercury'} {'Venus'} {'Earth'}
    str = string(C)
    str = 1x3 string array
    "Mercury" "Venus" "Earth"

     

    要将文本添加到字符串的末尾,请使用加号运算符 +。
    f = 71;
    c = (f-32)/1.8;
    tempText = "Temperature is " + c + "C"
    tempText =
    "Temperature is 21.6667C"


    与数值数组类似,字符串数组可以有多个元素。使用 strlength 函数求数组中每个字符串的长
    度。
    A = ["a","bb","ccc"; "dddd","eeeeee","fffffff"]
    A =
    2×3 string array


    strlength(A)

     

    除了字符向量,您还可以使用 string 函数将数值、日期时间、持续时间和分类值转换为字符
    串。
    将数值数组转换为字符串数组。
    X = [5 10 20 3.1416];
    string(X)
    ans = 1x4 string array
    "5" "10" "20" "3.1416"


    将日期时间值转换为字符串。
    d = datetime('now');
    string(d)
    ans =
    "03-Feb-2019 10:12:54"

     

     

    将字符串串联到字符串数组中
    将字符串串联到字符串数组中,就像您串联任何其他类型的数组一样。
    使用方括号 [] 串联两个字符串数组。
    str1 = ["Mercury","Gemini","Apollo"];
    str2 = ["Skylab","Skylab B","ISS"];
    str = [str1 str2]
    str = 1x6 string array
    "Mercury" "Gemini" "Apollo" "Skylab" "Skylab B" "ISS"
    转置 str1 和 str2。将它们进行串联,然后将列标题垂直串联到字符串数组上。当您将字符向
    量串联到字符串数组中时,字符向量会自动转换为字符串。
    str1 = str1';
    str2 = str2';
    str = [str1 str2];
    str = [["Mission:","Station:"] ; str]
    str = 4x2 string array
    "Mission:" "Station:"
    "Mercury" "Skylab"
    "Gemini" "Skylab B"
    "Apollo" "ISS"

     

     

    字符串相关函数

    字符串数组

    string字符串数组
    strings创建不包含字符的字符串数组
    join合并字符串

    字符数组

    char字符数组
    cellstr转换为字符向量元胞数组
    blanks创建空白字符数组
    newline创建换行符

    字符或字符串数组

    compose将数据格式化为多个字符串
    sprintf将数据格式化为字符串或字符向量
    strcat水平串联字符串
    append合并字符串

    转换输入参数

    convertCharsToStrings将字符数组转换为字符串数组,其他数组不变
    convertStringsToChars将字符串数组转换为字符数组,其他数组不变
    convertContainedStringsToChars在元胞数组或结构体的任何级别转换字符串数组

    在数值和字符串之间转换

    double双精度数组
    string字符串数组
    str2double将字符串转换为双精度值
    num2str

    将数字转换为字符数组

     

    ischar确定输入是否为字符数组
    iscellstr确定输入是否为字符向量元胞数组
    isstring确定输入是否为字符串数组
    isStringScalar确定输入是否为包含一个元素的字符串数组

    文本属性

    strlength字符串长度
    isstrprop确定输入字符串中的哪些字符属于指定类别
    isletter确定哪些字符为字母
    isspace确定哪些字符是空白字符

    查找

    contains确定字符串中是否有模式
    count计算字符串中模式的出现次数
    endsWith确定字符串是否以模式结尾
    startsWith确定字符串是否以模式开头
    strfind在其他字符串中查找字符串
    sscanf从字符串读取格式化数据

    替换

    replace查找并替换一个或多个子字符串
    replaceBetween替换起点和终点之间的子字符串
    strrep

    查找并替换子字符串

     

    join合并字符串
    split在分隔符处拆分字符串
    splitlines在换行符处拆分字符串
    strjoin联接数组中的字符串
    strsplit在指定分隔符处拆分字符串或字符向量
    strtok所选的字符串部分
    erase删除字符串内的子字符串
    eraseBetween删除起点和终点之间的子字符串
    extractAfter提取指定位置后的子字符串
    extractBefore提取指定位置前的子字符串
    extractBetween提取起点和终点之间的子字符串
    insertAfter在指定的子字符串后插入字符串
    insertBefore在指定的子字符串前插入字符串
    pad为字符串添加前导或尾随字符
    strip删除字符串中的前导和尾随字符
    lower将字符串转换为小写
    upper将字符串转换为大写
    reverse反转字符串中的字符顺序
    deblank删除字符串末尾的尾随空白
    strtrim从字符串中删除前导和尾随空白
    strjust

    对齐字符串

     

    strcmp比较字符串
    strcmpi比较字符串(不区分大小写)
    strncmp比较字符串的前 n 个字符(区分大小写)
    strncmpi比较字符串的前 n 个字符(不区分大小写)
    regexp匹配正则表达式(区分大小写)
    regexpi匹配正则表达式(不区分大小写)
    regexprep使用正则表达式替换文本
    regexptranslate将文本转换为正则表达式

     

    数值类型

    整数和浮点数据

    MATLAB® 中的数值类包括有符号和无符号整数、单精度和双精度浮点数。

    默认情况下,MATLAB 以双精度浮点形式存储所有数值。(您不能更改默认类型和精度。)您可以选择以整数或单精度形式存储任何数值或数值数组。

    与双精度数组相比,以整数和单精度数组形式存储数据更节省内存。

    所有数值类型都支持基本的数组运算,例如添加下标、重构和数学运算。

    函数

    double双精度数组
    single单精度数组
    int88 位有符号整数数组
    int1616 位有符号整数数组
    int3232 位有符号整数数组
    int6464 位有符号整数数组
    uint88 位无符号整数数组
    uint1616 位无符号整数数组
    uint3232 位无符号整数数组
    uint6464 位无符号整数数组
    cast将变量转换为不同的数据类型
    typecast在不更改基础数据的情况下转换数据类型
    isinteger确定输入是否为整数数组
    isfloat确定输入是否为浮点数组
    isnumeric确定输入是否为数值数组
    isreal确定数组是否为实数数组
    isfinite确定数组元素是否为有限值
    isinf确定数组元素是否为无限值
    isnan判断查询数组元素是否包含 NaN 值
    eps浮点相对精度
    flintmax浮点格式的最大连续整数
    Inf创建所有值均为 Inf 的数组
    intmax指定整数类型的最大值
    intmin指定整数类型的最小值
    NaN创建所有值均为 NaN 的数组
    realmax最大的正浮点数
    realmin

    最小的标准正浮点数

     

     

     

    MATLAB 默认情况下以双精度浮点形式 (double) 存储数值数据。要以整数形式存储数据,您需要从 double 转换为所需的整数类型。使用上表中所示的转换函数之一。

    例如,如果要以 16 位有符号整数形式存储赋给变量 x 的值 325,请键入

    x = int16(325);
    

    如果要转换为整数的数值带有小数部分,MATLAB 将舍入到最接近的整数。如果小数部分正好是 0.5,则 MATLAB 会从两个同样临近的整数中选择绝对值大小更大的整数:

    x = 325.499;
    int16(x)
    ans =
    	
      int16
    
       325         
    
    x = x + .001;
    int16(x)
    ans =
    
      int16
    
       326  

    在将其他类(例如字符串)转换为整数时,这些整数转换函数也很有用:

    str = 'Hello World';
    
    int8(str)
    ans =
    
      1×11 int8 row vector
    
        72   101   108   108   111    32    87   111   114   108   100

    如果您将 NaN 值转换为整数类,则结果为该整数类中的 0 值。例如,

    int32(NaN)
    ans =
    
      int32
    
       0

     

    数值的显示格式
    默认显示
    默认情况下,MATLAB® 将数值输出显示为 5 位数的定标定点值。您可以将数值的显示方式更改为以下任意方式:

    5 位数的定标定点、浮点或这两种方式中的最佳方式

    15 位数的定标定点、浮点或这两种方式中的最佳方式

    小整数的比率

    十六进制(以 16 为基数)

    Bank 表示法

    format 参考页中列出了所有可用格式。

    要更改数值显示设置,请使用 format 函数或预设对话框(可通过 MATLAB 文件菜单访问)。format 函数只在单个 MATLAB 会话期间更改数值的显示方式,
    而您的“预设”设置则会从一个会话到下一个会话都保持活动状态。这些设置仅影响数值的显示方式,而不影响 MATLAB 计算或保存数值的方式。
    为 x 设置一个整数值并以十六进制(以 16 为基数)格式显示:

    format hex
    x = uint32(876543210)
    x =
       343efcea


    将格式设置为 5 位数的浮点格式:

    format short e
    x
    x =
       1.3333e+00   1.2345e-06


    设置 x 的值并以 5 位数的定标定点格式显示:

    x = [4/3 1.2345e-6]
    x =
        1.3333    0.0000
     

     

     

    确定数值类
    您可以使用以下任意命令检查变量 x 的数据类型。

    whos x

    显示 x 的数据类型。

    xType = class(x);

    将 x 的数据类型赋予变量。

    isnumeric(x)

    确定 x 是否为数值类型。

    isa(x, 'integer')
    isa(x, 'uint64') 
    isa(x, 'float') 
    isa(x, 'double') 
    isa(x, 'single')

    确定 x 是否为指定的数值类型。(此处显示了任意整数、无符号的 64 位整数、任意浮点数、双精度数和单精度数的示例)。

    isreal(x)

    确定 x 是实数还是复数。

    isnan(x)

    确定 x 是否不是数值 (NaN)。

    isinf(x)

    确定 x 是否为无限值。

    isfinite(x)

    确定 x 是否为有限值。

     

    合并不同的整数类型
    概述
    如果您在矩阵中合并不同的整数类型(例如有符号与无符号,或 8 位整数与 16 位整数),MATLAB® 将返回所有元素都属于一个公共类型的矩阵。MATLAB 将生成矩阵的所有元素设置为输入矩阵中的最左侧元素的数据类型。例如,以下串联生成由 3 个 16 位有符号整数组成的向量:

    A = [int16(450) uint8(250) int32(1000000)]
    合并不同大小的整数的示例
    禁用如上所示的整数串联警告后,一次串联下面的两个数字,然后转换它们的顺序。返回值取决于整数的串联顺序。最左侧的类型决定着向量中的所有元素的数据类型:

    A = [int16(5000) int8(50)]
    A =
       5000   50

    B = [int8(50) int16(5000)]
    B =
       50   127
    第一个操作返回由 16 位整数组成的向量。第二个操作返回由 8 位整数组成的向量。元素 int16(5000) 设置为 127,即 8 位有符号整数的最大值。

    相同规则也适用于垂直串联:

    C = [int8(50); int16(5000)]
    C =
        50
       127
    合并有符号与无符号整数的示例
    现在使用有符号与无符号整数做相同的练习。同样,最左侧的元素决定着生成矩阵中的所有元素的数据类型:

    A = [int8(-100) uint8(100)]
    A =
       -100   100

    B = [uint8(100) int8(-100)]
    B =
       100   0
    元素 int8(-100) 设为零,因为它不再有符号。

    MATLAB 在将每个元素串联为一个合并数组之前计算每个元素。换句话说,在合并两个元素前,以下语句的计算结果为一个 8 位有符号整数(等于 50)和一个 8 位无符号整数(无符号的 -50 设为零)。按照该串联,第二个元素保留其零值,但采用无符号 int8 类型:

    A = [int8(50), uint8(-50)]
    A =
      50    0

     

    数据类型检测函数

    函数

    iscalendarduration确定输入是否为日历持续时间数组
    iscategorical确定输入是否为分类数组
    iscell确定输入是否为元胞数组
    iscellstr确定输入是否为字符向量元胞数组
    ischar确定输入是否为字符数组
    isdatetime确定输入是否为日期时间数组
    isduration确定输入是否为持续时间数组
    isenum确定变量是否为枚举
    isfloat确定输入是否为浮点数组
    isgraphics对有效的图形对象句柄为 True
    isinteger确定输入是否为整数数组
    isjava确定输入是否为 Java 对象
    islogical确定输入是否为逻辑数组
    isnumeric确定输入是否为数值数组
    isobject确定输入是否为 MATLAB 对象
    isreal确定数组是否为实数数组
    isstring确定输入是否为字符串数组
    isstruct确定输入是否为结构体数组
    istable确定输入是否为表
    istimetable确定输入是否为时间表
    is*检测状态
    isa确定输入是否具有指定数据类型
    class对象的类
    validateattributes检查数组的有效性
    whos列出工作区中的变量及大小和类型

     

     

     

    数据类型转换

    数值数组、字符数组、元胞数组、结构体或表格之间的转换

    函数

    char字符数组
    cellstr转换为字符向量元胞数组
    int2str将整数转换为字符
    mat2str将矩阵转换为字符
    num2str将数字转换为字符数组
    str2double将字符串转换为双精度值
    str2num将字符数组或字符串转换为数值数组
    native2unicode将数值字节转换为 Unicode 字符表示形式
    unicode2native将 Unicode 字符表示形式转换为数值字节
    base2dec将以 N 为基数表示数字的文本转换为十进制数字
    bin2dec将用文本表示的二进制数字转换为十进制数字
    dec2base将十进制数字转换为以 N 为基数的数字的字符向量
    dec2bin将十进制数字转换为表示二进制数字的字符向量
    dec2hex将十进制数字转换为表示十六进制数字的字符向量
    hex2dec将十六进制数字的文本表示形式转换为十进制数字
    hex2num将 IEEE 十六进制字符串转换为双精度数字
    num2hex将单精度和双精度值转换成 IEEE 十六进制字符串
    table2array将表转换为同构数组
    table2cell将表转换为元胞数组
    table2struct将表转换为结构体数组
    array2table将同构数组转换为表
    cell2table将元胞数组转换为表
    struct2table将结构体数组转换为表
    cell2mat将元胞数组转换为基础数据类型的普通数组
    cell2struct将元胞数组转换为结构体数组
    mat2cell将数组转换为在元胞中包含子数组的元胞数组
    num2cell将数组转换为相同大小的元胞数组
    struct2cell将结构体转换为元胞数组

     

    函数摘要
    此表中列出的函数提供了多种将数值数据转换为字符数组的方法。

    函数说明示例
    char将正整数转换为等效的字符。(截断任何小数部分。)[72 105] → 'Hi'
    string将包含双精度值的数组转换为字符串数组。[72 105] → "72" "105"
    [3.1416 2.178] →
    "3.1416" "2.178"
    int2str将正整数或负整数转换为字符类型。(对任何小数部分
    四舍五入。)
    [72 105] → '72 105'
    num2str将数值类型转换为指定精度和格式的字符类型。[72 105] → '72/105/'
    (格式设置为 %1d/)
    mat2str将数值类型转换为指定精度的字符类型,并返回
    MATLAB 可以计算的字符向量。
    [72 105] → '[72 105]'
    dec2hex将正整数转换为字符类型的十六进制基数。[72 105] → '48 69'
    dec2bin将正整数转换为字符类型的二进制基数。[72 105] → '1001000
    1101001'
    dec2base将正整数转换为字符类型的数字,基数可从 2 到 36。[72 105] → '110 151'

     

    将数字转换为字符代码
    char 函数将整数转换为 Unicode 字符代码,并返回由对等字符构成的字符数组:
    6 字符和字符串
    6-56x = [77 65 84 76 65 66];
    char(x)
    ans =
    'MATLAB'

    将数字表示为文本
    int2str、 num2str 和 mat2str 函数将数值表示为文本,其中每个字符表示输入值中一位单
    独的数字。 int2str 和 num2str 函数常被用来为绘图添加标签。例如,下列线条使用
    num2str 为绘图的 x 轴准备自动化标签:
    function plotlabel(x, y)
    plot(x, y)
    chr1 = num2str(min(x));
    chr2 = num2str(max(x));
    out = ['Value of f from ' chr1 ' to ' chr2];


    转换为特定基数
    另一类转换函数将数值更改为字符数组,将十进制值用另一种基数形式表示,例如二进制或十
    六进制表示形式。这些函数包括 dec2hex、 dec2bin 和 dec2base。

     

    函数摘要
    此表中列出的函数提供了多种将字符数组转换为数值数据的方法。

    函数说明示例
    uintN(例如 uint8)将字符转换为表示该字符的整数代码。'Hi' → 72 105
    str2num将字符类型转换为数值类型。'72 105' → [72 105]
    str2double与 str2num 类似,但提供更佳的性能,用于处理
    字符串数组和字符向量元胞数组。
    "72" "105" → [72 105]
    {'72' '105'} → [72 105]
    hex2num将数值类型转换为指定精度的字符类型,并返回
    MATLAB 可以计算的字符数组。
    'A' → '-1.4917e-154'
    hex2dec将数值类型的十六进制基数转换为正整数。'A' → 10
    bin2dec将字符类型的二进制数字转换为十进制数字。'1010' → 10
    base2dec将字符类型的 2 到 36 内任何进制的数字转换为十
    进制数字。
    '12' → 10 (如果 base
    == 8)


    从特定基数转换
    要将非十进制数字的字符表示转换为该数字的值,请使用以下函数之一:hex2num、
    hex2dec、 bin2dec 或 base2dec。
    hex2num 和 hex2dec 函数都接受十六进制(以 16 为基数)输入,但 hex2num 返回它表
    示的 IEEE 双精度浮点数,而 hex2dec 则将输入转换为十进制整数

    展开全文
  • 将符号变量转换为 Matlab 方程字符串,确保只使用数组 opps。 符号数组转换为字符串的线性元胞数组。 此函数最常用于准备与“eval()”命令一起使用的符号答案。 此外,将 Maple "atan" 函数转换为 Matlab ...
  • 如果strcmp(s1,s2)返回的结果为0,表示字符串s1和s2不相同。 F 当s1<s2时,返回值<0; 当s1=s2时,返回值=0; 当s1>s2时,返回值>0; 1-4 假设模式串是abababaab,则KMP模式匹配算法中的next[j] = 0 1 ...


    第一章——褚论

    第二章——线性表

    第三章——栈与队列

    第四章——字符串

    第五章——树与二叉树

    第六章——图

    第七章——排序

    第八章——检索


    判断题

    1-10
    如果strcmp(s1,s2)返回的结果为0,表示字符串s1和s2不相同。
    F

    当s1<s2时,返回值<0;
    当s1=s2时,返回值=0;
    当s1>s2时,返回值>0;


    1-4
    假设模式串是abababaab,则KMP模式匹配算法中的next[j] = 0 1 1 2 3 4 5 6 2。
    next[j]就是第j个元素前j-1个元素首尾重合部分个数加一
    KMP算法详解

    根据上面文章的内容可得到:
    j的下标从1开始
    j=1时,规定next[1]=0;
    j=2时,s[2]前(下标从1开始)有"a",首尾重合个数为0,故next[2]=0+1=1
    j=3时,s[3]前有"ab",首尾重合个数为0,故next[3]=0+1=1;
    j=4时,s[4]前有"aba",首尾重合个数为1,故next[4]=1+1=2;
    同理,
    j=5时,“abab”…2…next[5]=2+1=3;
    j=6时,“ababa”…3…next[6]=3+1=4
    j=7时,“ababab”…4…next[7]=4+1=5;
    j=8时,“abababa”…首尾重合有"ababa",个数为5,
    故next[8]=5+1=6;
    j=9时,“abababaa”…首尾重合有"a",个数为1,
    故next[9]=1+1=2;


    1-3
    (nueDS_C++)如果一个串中的所有字符均在另一串中出现,则说前者是后者的子串。

    F 还和顺序对应有关


    1-1
    char * s=“C Language”;表示s是一个指向字符串的指针变量,把字符串的首地址赋予s。
    T


    1-2
    字符串在内存中的起始地址称为字符串的指针,可以定义一个字符指针变量指向一个字符串。
    T


    1-4
    (neuDS_C++)空串与空格串是相同的。
    F


    1-5
    指针变量可以存放指针(地址)、数值和字符。
    F


    1-8
    重载运算符可以保持原运算符的优先级和结合性不变。
    T


    1-12
    字符串常量在内存中的存放位置由系统自动安排。
    T


    1-13
    调用strcmp函数比较字符串大小时,通常较长的字符串会较大。
    F strcmp函数的比较是一位一位的比较ascii码值,只要对应有一位的ascii码值不相同,即得出大小结果,与后面剩下的字符都无关。


    1-14
    字符串常量就是用一对双引号括起来的字符序列,它有一个结束标志’\0’。
    T


    1-15
    对于两个字符串变量s1和s2,使用if(s1>s2)来比较大小是可以的。
    F 不可以,只可以用函数strcmp()


    1-16
    判断字符串a和b是否相等的表达式为if (a==b)。
    F 同样需要用strcmp()函数来比较


    单选题

    2-14
    令s=“abcabaa”,则它的特征向量next函数值和优化特征向量nextval函数值为(下标从0开始):
    next={0,1,1,1,2,3,2},nextval={0,1,1,0,1,2,1}
    next={-1,0,0,-1,0,2,1},nextval={-1,0,0,0,1,2,1}
    next={-1,0,0,0,1,2,1},nextval={-1,0,0,-1,0,2,1}
    next={-1,0,0,0,1,2,1},nextval={-1,0,0,0,1,2,1}

    参考1-4的做法可以得到next数组
    规定next[1]=0
    s[2]前,“a”,next[2]=重合个数0+1=1
    s[3]前,“ab”,next[3]=重合个数0+1=1
    s[4]前,“abc”,next[4]=重合个数0+1=1
    s[5]前,“abca”,next[5]=重合个数1+1=2
    s[6]前,“abcab”,next[6]=重合个数2+1=3
    s[7]前,“abcaba”,next[7]=重合个数1+1=2
    next[j]函数值为{0,1,1,1,2,3,2}(这里下标是从1开始)
    题目中下标从0开始,故函数值都减1,得到
    next={-1,0,0,0,1,2,1}.

    求解优化特征向量nextval详解

    从文章内容分析本题
    上面已经求得next={0,1,1,1,2,3,2}
    规定nextval[1]=0(下标从1开始)
    观察s[1]和s[2],(下标从1开始),a和b不相同,故
    nextval[2]=1
    求nextval[3]时,看next[3],next[3]=1,观察s[1]和s[3],a和c不相等,故nextval[3]=next[3]=1.
    求nextval[4]时,next[4]=1,s[1]和s[4]为a和a,相等,nextval[4]=0;
    求nextval[5]时,next[5]=2,s[2]和s[5]为b和b,相同,看next[2]=1,比较s[1]和s[2]为a和b,不相同,则nextval[5]=next[2]=1;
    next[6]=3,s[3]和s[6]为c和a,不相同,nextval[6]=next[6]=3;
    next[7]=2,s[2]和s[7]为b和a,不相同,nextval[7]=2
    综上可以得到nextval={0,1,1,0,1,3,2}
    而题目中要求从下标0开始,则将其减1得到
    {-1,0,0,-1,0,2,1}


    2-21
    设主串 T = abaabaabcabaabc,模式串 S = abaabc,采用 KMP 算法进行模式匹配,到匹配成功时为止,在匹配过程中进行的单个字符间的比较次数是:
    9
    10
    12
    15

    解析:
    1.求S的next数组,(下标从0开始)next={-1,0,0,1,1,2}
    2.开始匹配

    • abaabaabcabaaba
      abaabc
      当比较到s[5]和T[5]时,不成功,比较了6次
    • 根据next[5]=2,将s移动到s[2]处和T[5]开始重新匹配比较:
      abaabaabcabaaba
      -----abaabc
      比较4次,成功,结束匹配。
    • 一共比较了6+4=10次;

    2-6
    串“ababaabab”的nextval为( )。
    010104101
    010102101
    010100011
    010101011

    解析:
    用第一位默认-1的求法求next

    • 默认next[0]=-1;
    • next[1]是看s[1]之前的字符串“a”中前后重复的子串长度为0,(本身不算),故next[1]=0;
    • next[2]是看s[2]之前字符串"ab"中前后重复的子串长度为0,故next[2]=0;
    • next[3]是看s[3]之前字符串"aba"中前后重复子串长度为1,故next[3]=1;
    • next[4]是看s[4]之前字符串"abab"中前后重复子串长度为2,故next[4]=2;
    • next[5]……“ababa” ……重复子串长度为3,故next[5]=3;
    • next[6]……“ababaa”……1……next[6]=1;
    • next[7]……“ababaab”……2……next[7]=2;
    • next[8]……“ababaaba”……3……next[8]=3;
    • 综上:next={-1,0,0,1,2,3,1,2,3}

    求nextval:(下标从0开始的方法)
    规定nextval[0]=-1
    比较s[ next[i] ]和s[ i ]

    • 若不相等,则nextval [ i ] =next [ i ];
    • 若相等,则nextval [ i ] = nextval [ next [ i ] ];

    本题解析:

    • nextval[0]=-1,和next[0]的值一样;
    • nextval[1],next[1]=0,比较s[1]和s[0],为a和b,
      不相等,则nextval[1]=next[1]=0;
    • nextval[2],next[2]=0,比较s[2]和s[0],为a和a,
      相同,nextval[2]=nextval[ next[2] ]=nextval[0]=-1;
    • nextval[3],next[3]=1,比较s[3]和s[1],为b和b,
      相同,nextval[3]=nextval[next[3]]=nextval[1]=0;
    • nextval[4],next[4]=2,比较s[4]和s[2],为a和a,
      相同,nextval[4]=nextval[ next[4] ]=nextval[2]=-1;
    • nextval[5],next[5]=3,比较s[5]和s[3],为b和a,不相同,nextval[5]=next[5]=3;
    • nextval[6],next[6]=1,比较s[6]和s[1],为b和b,
      相同,nextval[6]=nextval[1]=0;
    • nextval[7],next[7]=2,比较s[7]和s[2],为a和a,
      相同,nextval[7]=nextval[2]=-1;
    • nextval[8],next[8]=3,比较s[8]和s[3],为b和b
      相同,nextval[8]=nextval[3]=0;
      综上所述
      nextval={-1,0,-1,0,-1,3,0,-1,0}
      根据题目选项可得题目应该是下标从1开始的做法,故将函数值依次加1即可:
      nextval={0,1,0,1,0,4,1,0,1}

    2-15
    (neuDS)设有两个串p和q,其中q是p的子串,求q在p中首次出现的位置的算法称为( )。
    求子串
    联接
    模式匹配
    求串长


    2-16
    (neuDS)串也是一种线性表,只不过( )。
    数据元素均为字符
    数据元素是子串
    数据元素数据类型不受限制
    表长受到限制


    2-17
    KMP算法下,长为n的字符串匹配长度为m的字串的时间复杂度为
    O(N)
    O(M+N)
    O(M+LOGN)
    O(N+LOGM)


    2-18
    下面关于串的叙述中,哪一个是不正确的
    串是字符的有限序列
    空串是由空格构成的串
    模式匹配是串的一种重要运算
    串既可以采用顺序存储,也可以采用链式存储

    空串是不含字符的串,空格也算字符。


    2-19
    若串S=“software”,其子串的数目是
    8
    37
    36
    9
    解析
    插板法:用两个隔板夹取某些字符,长度不限,取尽所有长度
    software有8个字符,则有9个空,用组合排序即:
    C(2 9)=9*8/2=36,再加上空串,也就是37种。


    2-20
    串的长度是指

    串中所含不同字母的个数
    串中所含字符的个数
    串中所含不同字符的个数
    串中所含非空格字符的个数


    2-7
    下述对C语言字符数组的描述中错误的是()。

    字符数组可以存放字符串
    字符数组中的字符串可以整体输入、输出
    可以在赋值语句中通过赋值运算符"="对字符数组整体赋值
    不可以用关系运算符对字符数组中的字符串进行比较


    2-8
    (neuDS)设主串的长度为n,模式串的长度为m,则串匹配的KMP算法时间复杂度是( )。

    O(m)
    O(n)
    O(n + m)
    O(n×m)


    2-10
    下面关于字符串的程序,其输出结果是

    #include <stdio.h>
    
    void fun(char s[], char t) {
    	int i = 0;
    	while (s[i]) {
    		if (s[i] == t)
    			s[i] = t - 'a' + 'A';
    		i++;
    	}
    }
    int main() {
    	char str[100] = "abcdefg", c = 'd';
    	fun(str, c);
    	printf("%s\n", str);
    	return 0;
    }
    

    abcdefg
    abcDefg
    ABCdEFG
    ABCDEFG


    2-12
    (neuDS_C++)串是一种特殊的线性表,其特殊性体现在( )。

    可以顺序存储
    数据元素是一个字符
    可以链接存储
    数据元素可以是多个字符


    2-13
    (neuDS_C++)设串s1=’ABCDEFG’,s2=’PQRST’,函数con (x,y)返回x和y串的连接串,subs(s,i,j)返回串s的从序号i的字符开始的j个字符组成的子串,len(s)返回串s的长度,则con (subs (s1,2,len (s2)), subs (s1,len (s2),2))的结果串是( )。

    BCDEF
    BCDEFG
    BCPQRST
    BCDEFEF


    展开全文
  • R语言4——字符串&列表&矩阵&数组

    千次阅读 2020-11-01 10:43:39
    1.1 在字符串的语法中,单引号和双引号不能混用 1.2 字符串连接函数——paste()函数 1.3 字符串格式化函数——format()函数 1.4字符串计算长度函数——nchar()函数 1.5大小写转换函数——toupper()&...

    R语言4——R的数据类型2

    目录

    R语言4——R的数据类型2

    1、字符串

    1.1 在字符串的语法中,单引号和双引号不能混用

    1.2  字符串连接函数——paste()函数

    1.3  字符串格式化函数——format()函数

    1.4字符串计算长度函数——nchar()函数

    1.5大小写转换函数——toupper()& tolower()函数

    1.6截取字符串函数——substring()函数

    2、列表

    3.矩阵

    1、创建矩阵函数——matrix()函数

    2、转置矩阵函数——t()函数

    3、访问矩阵元素

    4、矩阵计算

    4.数组

    1、数组的创建——array()函数

    2、访问数组元素

    3、数组跨纬度的元素计算


    1、字符串

    1.1 在字符串的语法中,单引号和双引号不能混用

    在字符串构造中应用的规则

    1. 在字符串的开头和结尾的引号应该是两个双引号或两个单引号。它们不能被混合。

    2. 双引号可以插入到以单引号开头和结尾的字符串中。

    3. 单引号可以插入以双引号开头和结尾的字符串。

    4. 双引号不能插入以双引号开头和结尾的字符串。

    5. 单引号不能插入以单引号开头和结尾的字符串。

    1.2  字符串连接函数——paste()函数

    函数的实例如下代码,paste()函数语法规则如下:

    paste(..., sep = " ", collapse = NULL)

    其中...,表示需要进行连接的字符串;

    sep表示前面...的参数之间进行连接的连接符,默认是空格,可以自行设置。

    collapse是在字符串之间进行操作,当前面传入的字符串参数a,b,c...字符串为单个字符串时,collapse参数的意义在于消除a,b,c...字符串之间的空格,但不包括字符串内部的空格。当前面传入的字符串参数是一个列表时,collapse可以使用我们设置的连接符(collapse的参数)为字符串进行连接并消除字符串之间的空格,不包括字符串内的空格。

    > a <- "apple"
    > b <- 'orange'
    > c <- "water"
    > paste(a,b,c)
    [1] "apple orange water"
    > paste(a,b,c, sep = "&")
    [1] "apple&orange&water"
    > paste(c(a,b,c), 1:3, ".pdf", sep = "")
    [1] "apple1.pdf"  "orange2.pdf" "water3.pdf" 
    > paste(c(a,b,c), sep = "",collapse = "&")
    [1] "apple&orange&water"
    > paste(c(a,b,c), 1:3, ".pdf", sep = "", collapse = "&")
    [1] "apple1.pdf&orange2.pdf&water3.pdf"
    
    #关于collapse与sep的区别
    > paste(a,b,c, sep = "", collapse = "+")
    [1] "appleorangewater"
    > paste(c(a,b,c), sep = "", collapse = "+")
    [1] "apple+orange+water"
    

    如上所示,paste(a,b,c) 表示将a,b,c三个字符串连接成一个字符串,默认分隔符为空格。

    paste(a,b,c, sep = "&") 表示使用"&"连接符连接三个字符串。

    paste(c(a,b,c), 1:3, ".pdf", sep = "") 表示连接多个参数,可以批量输出文本/文件名

    paste(a,b,c, sep = "", collapse = "+") 表示消除a,b,c三个字符串之间的空格连接成一个字符串

    paste(c(a,b,c), sep = "", collapse = "+") 表示将元素进行折叠,并使用参数连接符进行连接。

    1.3  字符串格式化函数——format()函数

    format() 函数用于格式化字符串,format() 可作用于字符串或数字。

    语法格式:format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))

    其中,x表示输入的向量;

    digits表示需要显示的小数点位数;

    nsmall表示小数点右边显示的最小位数;

    science表示是否设置为科学计数法,参数为true/false

    width表示通过在开头填充空白来显示最小宽度;

    justify表示设置显示的位置,左边,右边,中间,其他。此时X参数的参数需要为字符串

    > r <- format(12.345322223, digits = 5)
    > r
    [1] "12.345"
    #digits=5表示可以保留五位数字,不包括小数点
    
    > r <- format(12.345322223, nsmall = 5)
    > r
    [1] "12.34532"
    > r <- format(12.345322223, nsmall = 2)
    > r
    [1] "12.34532"
    #nsmall函数表示小数点右边最少的位数
    
    
    > r <- format(1122.345322223, scientific = TRUE)
    > r
    [1] "1.122345e+03"
    #scientific参数不需要带引号,true需要大写
    
    > r <- format(11.23, width = 10)
    > r
    [1] "     11.23"
    >
    
    
    > r <- format("12.12", width = 10, justify = "c")
    > r 
    [1] "  12.12   "
    > 

    1.4字符串计算长度函数——nchar()函数

    nchar() 函数用于计数字符串或数字列表的长度。   语法格式:nchar(x)  ,  其中,x 为向量或字符串

    > r <- nchar("hello world!")
    > r
    [1] 12
    > 

    1.5大小写转换函数——toupper()& tolower()函数

    toupper() & tolower() 函数用于将字符串的字母转化为大写或者小写。

    语法格式:toupper(x)    tolower(x)     其中,x 为向量或字符串。

    > r <- nchar("hello world!")
    > r
    [1] 12
    > a <- toupper("hello world!")
    > a
    [1] "HELLO WORLD!"
    > b <- tolower(a)
    > b
    [1] "hello world!"
    > 

    1.6截取字符串函数——substring()函数

    substring() 函数用于截取字符串。 语法格式:substring(x,first,last)

    x : 向量或字符串

    first : 开始截取的位置

    last: 结束截取的位置,截取结果不包含

    > str1 <- "hello world!hello world!"
    > str <- substring(str1, 2 ,6)
    > str
    [1] "ello "
    
    #注意在R中字符串的计数是从1开始计算的,所以2表示的是字母e

    2、列表

    创建列表使用 list() 函数。列表中的元素可以是数字、向量、字符串、列表本身、矩阵、函数。

    > list_data <- list("white", "gogo", c(11,22,33), 123, 12.12, 119.1)
    > list_data
    [[1]]
    [1] "white"
    
    [[2]]
    [1] "gogo"
    
    [[3]]
    [1] 11 22 33
    
    [[4]]
    [1] 123
    
    [[5]]
    [1] 12.12
    
    [[6]]
    [1] 119.1

    使用names()函数给列表的元素命名:

    # 列表包含向量、矩阵、列表
    list_data <- list(c("Google","Runoob","Taobao"), matrix(c(1,2,3,4,5,6), nrow = 2),
       list("runoob",12.3))
    
    # 给列表元素设置名字
    names(list_data) <- c("Sites", "Numbers", "Lists")
    
    # 显示列表
    print(list_data)
    
    
    #输出结果如下:
    $Sites
    [1] "Google" "Runoob" "Taobao"
    
    $Numbers
         [,1] [,2] [,3]
    [1,]    1    3    5
    [2,]    2    4    6
    
    $Lists
    $Lists[[1]]
    [1] "runoob"
    
    $Lists[[2]]
    [1] 12.3

    访问列表:

    列表中的元素可以使用索引来访问,如果使用来 names() 函数命名后,我们还可以使用对应名字来访问:

    # 列表包含向量、矩阵、列表
    list_data <- list(c("Google","Runoob","Taobao"), matrix(c(1,2,3,4,5,6), nrow = 2),
       list("runoob",12.3))
    
    # 给列表元素设置名字
    names(list_data) <- c("Sites", "Numbers", "Lists")
    
    # 显示列表
    print(list_data[1])
    
    # 访问列表的第三个元素
    print(list_data[3])
    
    # 访问第一个向量元素
    print(list_data$Numbers)
    
    
    

    输出结果如下:

    $Sites
    [1] "Google" "Runoob" "Taobao"
    
    $Lists
    $Lists[[1]]
    [1] "runoob"
    
    $Lists[[2]]
    [1] 12.3
    
    
         [,1] [,2] [,3]
    [1,]    1    3    5

    合并列表:

    # 创建两个列表
    list1 <- list(1,2,3)
    list2 <- list("Google","Runoob","Taobao")
    
    # 合并列表
    merged.list <- c(list1,list2)
    
    # 显示合并后的列表
    print(merged.list)

    将列表转换为向量

    > list1 <- list(1:5)
    > print(list1)
    [[1]]
    [1] 1 2 3 4 5
    
    > list1 <- list(1:5)
    > print(list1)
    [[1]]
    [1] 1 2 3 4 5
    
    > 
    > list2 <-list(10:14)
    > print(list2)
    [[1]]
    [1] 10 11 12 13 14
    
    > # 转换为向量
    > v1 <- unlist(list1)
    > v2 <- unlist(list2)
    > v1
    [1] 1 2 3 4 5
    > v2
    [1] 10 11 12 13 14
    > result <- v1+v2
    > print(result)
    [1] 11 13 15 17 19
    

    3.矩阵

    1、创建矩阵函数——matrix()函数

    我们看过的这部经典电影黑客帝国的英文名称就是matrix,电影里世界就是由矩阵组成的。

    在R中使用 matrix() 函数来创建矩阵 matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,dimnames = NULL)

    其中data表示矩阵中的数字;

    nrow表示行数;ncol表示列数;

    byrow表示逻辑值,byrow值为 FALSE 按列排列,为 TRUE 按行排列;

    dimname 设置行和列的名称

    > m <- matrix(c(1:10), nrow = 2, byrow = TRUE)
    > m
         [,1] [,2] [,3] [,4] [,5]
    [1,]    1    2    3    4    5
    [2,]    6    7    8    9   10
    > 
    
    #为矩阵设置行列名称
    > rownames = c("r1", "r2", "r3", "r4")
    > colnames = c("c1", "c2", "c3", "c4", "c5", "c6", "c7")
    > 
    > m2 <- matrix(c(10:37), nrow =4 ,byrow = TRUE, dimnames = list(rownames, colnames))
    > m2
       c1 c2 c3 c4 c5 c6 c7
    r1 10 11 12 13 14 15 16
    r2 17 18 19 20 21 22 23
    r3 24 25 26 27 28 29 30
    r4 31 32 33 34 35 36 37
    > 

    2、转置矩阵函数——t()函数

    > M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
    > print(M)
         [,1] [,2] [,3]
    [1,]    2    6    5
    [2,]    1   10    4
    > print(t(M))
         [,1] [,2]
    [1,]    2    1
    [2,]    6   10
    [3,]    5    4
    

    3、访问矩阵元素

    如果想获取矩阵元素,可以通过使用元素的列索引和行索引,类似坐标形式。

    > M[1,2]
    [1] 6
    > M[,2]  #访问第二列
    [1]  6 10
    > M[1,]   #访问第一行
    [1] 2 6 5
    > 

    4、矩阵计算

    大小相同(行数列数都相同)的矩阵之间可以相互加减,具体是对每个位置上的元素做加减法。矩阵的乘法则较为复杂。两个矩阵可以相乘,当且仅当第一个矩阵的列数等于第二个矩阵的行数

    > # 创建 2 行 3 列的矩阵
    > matrix1 <- matrix(c(7, 9, -1, 4, 2, 3), nrow = 2)
    > print(matrix1)
         [,1] [,2] [,3]
    [1,]    7   -1    2
    [2,]    9    4    3
    > 
    > matrix2 <- matrix(c(6, 1, 0, 9, 3, 2), nrow = 2)
    > print(matrix2)
         [,1] [,2] [,3]
    [1,]    6    0    3
    [2,]    1    9    2
    > 
    > # 两个矩阵相加
    > result <- matrix1 + matrix2
    > cat("相加结果:","\n")
    相加结果: 
    > print(result)
         [,1] [,2] [,3]
    [1,]   13   -1    5
    [2,]   10   13    5
    > 
    > # 两个矩阵相减
    > result <- matrix1 - matrix2
    > cat("相减结果:","\n")
    相减结果: 
    > print(result)
         [,1] [,2] [,3]
    [1,]    1   -1   -1
    [2,]    8   -5    1
    > 
    > # 创建 2 行 3 列的矩阵
    > matrix1 <- matrix(c(7, 9, -1, 4, 2, 3), nrow = 2)
    > print(matrix1)
         [,1] [,2] [,3]
    [1,]    7   -1    2
    [2,]    9    4    3
    > 
    > matrix2 <- matrix(c(6, 1, 0, 9, 3, 2), nrow = 2)
    > print(matrix2)
         [,1] [,2] [,3]
    [1,]    6    0    3
    [2,]    1    9    2
    > 
    > # 两个矩阵相乘
    > result <- matrix1 * matrix2
    > cat("相加结果:","\n")
    相加结果: 
    > print(result)
         [,1] [,2] [,3]
    [1,]   42    0    6
    [2,]    9   36    6
    > 
    > # 两个矩阵相除
    > result <- matrix1 / matrix2
    > cat("相减结果:","\n")
    相减结果: 
    > print(result)
             [,1]      [,2]      [,3]
    [1,] 1.166667      -Inf      0.6666667
    [2,] 9.000000   0.4444444    1.5000000

    4.数组

    数组也是 R 语言的对象,R 语言可以创建一维或多维数组。R 语言数组是一个同一类型的集合,前面的矩阵 matrix 其实就是一个二维数组。向量、矩阵、数组关系可以看下图:

    1、数组的创建——array()函数

    R 语言数组创建使用 array() 函数,该函数使用向量作为输入参数,可以使用 dim 设置数组维度。array() 函数语法格式如下:array(data = NA, dim = length(data), dimnames = NULL)

    其中:data 向量,数组元素。

    dim 数组的维度,默认是一维数组。

    dimnames 维度的名称,必须是个列表,默认情况下是不设置名称的。

    > v1 <- c(1,2,3)
    > v2 <- c(2,3,4,5,6,7)
    > v1
    [1] 1 2 3
    > v2
    [1] 2 3 4 5 6 7
    > 
    > v3 <- array(c(v1,v2), dim = c(3,3,2))
    > v3
    , , 1
    
         [,1] [,2] [,3]
    [1,]    1    2    5
    [2,]    2    3    6
    [3,]    3    4    7
    
    , , 2
    
         [,1] [,2] [,3]
    [1,]    1    2    5
    [2,]    2    3    6
    [3,]    3    4    7
    
    > 

    dimnames参数为数组命名:

    > column.names <- c("COL1","COL2","COL3")
    > row.names <- c("ROW1","ROW2","ROW3")
    > matrix.names <- c("Matrix1","Matrix2")
    > v4 <- array(c(v1,v2), dim = c(3,3,2), dimnames = list(row.names,column.names,matrix.names) )
    > v4
    , , Matrix1
    
         COL1 COL2 COL3
    ROW1    1    2    5
    ROW2    2    3    6
    ROW3    3    4    7
    
    , , Matrix2
    
         COL1 COL2 COL3
    ROW1    1    2    5
    ROW2    2    3    6
    ROW3    3    4    7
    

    2、访问数组元素

    > v3
    , , 1
    
         [,1] [,2] [,3]
    [1,]    1    2    5
    [2,]    2    3    6
    [3,]    3    4    7
    
    > #显示第一个矩阵第一行
    > print(v3[1,,1])
    [1] 1 2 5
    > #显示第一个矩阵第一行第三列的数字
    > print(v3[1,3,1])
    [1] 5
    > #输出第二个矩阵
    > print(v3[,,1])
         [,1] [,2] [,3]
    [1,]    1    2    5
    [2,]    2    3    6
    [3,]    3    4    7
    

    3、数组跨纬度的元素计算

    使用 apply() 元素对数组元素进行跨维度计算,语法格式如下:apply(x, margin, fun)

    x 数组

    margin 数据名称

    fun 计算函数

    以下我们使用 apply() 函数来计算数组两个矩阵中每一行对数字之和。

    > # 创建两个不同长度的向量
    > vector1 <- c(5,9,3)
    > vector2 <- c(10,11,12,13,14,15)
    > 
    > # 创建数组
    > new.array <- array(c(vector1,vector2),dim = c(3,3,2))
    > print(new.array)
    , , 1
    
         [,1] [,2] [,3]
    [1,]    5   10   13
    [2,]    9   11   14
    [3,]    3   12   15
    
    , , 2
    
         [,1] [,2] [,3]
    [1,]    5   10   13
    [2,]    9   11   14
    [3,]    3   12   15
    
    > 
    > # 计算数组中所有矩阵第一的数字之和
    > result <- apply(new.array, c(1), sum)
    > print(result)
    [1] 56 68 60

     

    展开全文
  • 但是,直接在字符串数组中的index characters,必须使用大括号表示法: str{3}(2) % == 'b' >内存使用.字符使用与字符一样多的字节.字符串有开销: a = 'abc' b = string('abc') whos a b 回报 06002
  • 第四章 字符串、数组和特殊矩阵 4.1字符串 字符串是由0个或多个字符构成的有限序列。 串中所含字符串的个数n称为字符串的长度;当n=0时。字符串为一空串 两个字符串相等,当且仅...寻找字符串p在字符串t中首次出现的位
  • R语言 字符串

    2021-05-20 17:20:15
    R语言中的单引号或双引号对中写入的任何值都被视为字符串。 R语言存储的每个字符串双引号内,即使是使用单引号创建的依旧如此。在字符串构造中应用的规则在字符串的开头和结尾的引号应该是两个双引号或两个单...
  • 文本数据存储字符向量中,字符向量的每个元素都是字符串,而非单独的字符。R中,可以使用双引号,或单引号表示字符。 一,字符串中的字符数量 函数nchar()用于获得字符串中的字符数量: > s <- 'read' &...
  • 2.具有四种进制表示形式: 十六进制:以0x或者0X开头,例如:0x5a,-0X6a; 十进制:例如:21,37,199; 八进制:以0o或者0O开头,例如:0o235,0O453; 二进制:以0b或者0B开头,例如:0b011,-0B001; 二、浮点数类型 1...
  • Qt字符串转换

    千次阅读 2018-12-08 20:23:17
    另外,与C风格的字符串不同,QString中间是可以包含'\0'符号的,而length()函数则会返回整个字符串的长度,而不仅仅是从开始到'\0'的长度。C++语言提供了两种字符串的实现:C风格的字符串,以'\0‘结尾;std::string...
  • 经常有题目或者题目的一个部分涉及到两字符串S和T之间的关系判断操作。 常见的有三种: ①求S是否包含T 例如S=“ababcd”,T=“abc”,很明显包含。 ②求T是否是S的子序列 例如S=“ababcd”,T=“acd”,很明显...
  • Java语言中是没有指针概念的,但如果能正确灵活地使用指针又确实可以大大提高程序的质量,比如C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷,Java提供了丰富的类库来方便编程者使用,Vector类...
  • 1. 字符串字面量 1.1 定义 1.2 字符串字面量包含转义序列 1.3 延续字符串字面量 1.3.1 使用续行符 1.3.2 仅用空白字符分割字符串字面量 1.4 存储字符串字面量 1.5 字符串字面量与字符常量的区别 2. 字符串...
  • 其中,string和 vector是两种最重耍的标准库类型,前者支持可变长字符串,后者则 表示可变长的集合。还有…种标准库类型是迭代器,它是string和vector的配套类型,常被用于访问string中的字符或vector中的元素。 ...
  • R字符串 R语言字符串可以使用一对单引号' '或者一对双引号” “来表示。 单引号字符串中可以包含双引号; 双引号字符串中可以包含单引号; 双引号字符串中不可以包含双引号; 单引号字符串中不可以包含单引号。 ...
  • MATLAB 字符串与矩阵的学习

    千次阅读 2020-04-14 17:50:54
    相等返回1,否则返回0 Strncmpi(s1,s2,n)在忽略字母大小写的前提下,用来比较两个字符串前n个字符是否相等,相等返回1,否则返回0 字符串的查找与替换 Findstr(s1,s2):返回短字符串在长字符串中的开始位置 Strrep(s1,...
  • R学习笔记(字符串和因子)

    千次阅读 2019-05-25 00:03:32
    文章目录笔记内容基于《学习R》一书字符串创建和打印字符串格式化数字特殊字符大小写截取字符串分割字符串因子创建更改因子水平去掉因子值有序因子将连续变量转化为类别将类别转化为连续变量生成因子水平合并因子 ...
  • MATLAB基本运算 MATLAB面向矩阵! MATLAB面向矩阵!...短字符串在长字符串中的开始位置 , 与参数位置无关 strrep(s1, s2, s3):等价于Java中String.replaceAll 还要拾起线代qnq 2019/4/17
  • 合法字符串——庞果网

    千次阅读 2013-09-15 19:25:03
    这个题目应该是庞果网上目前为止最难的一道题目了,今天群中大神FancyMouse的提点下,找到一篇名为“Recursive Sequence”的文章,完成了m项递推式的O(m^2logn)时间复杂度的优化,这是这道题目的
  • 近日面试美团的时候手撕一道回溯的算法题,题意如下: 给定一个数字字符串,要求将这个数字字符串进行分割,使得分割的结果为有效的IP地址。 样例输入: 25525511135 样例输出: 255.255.11.135, 255...
  • 2、如果strcmp(s1,s2)返回的结果为0,表示字符串s1和s2不相同。 (F) 解析: C 库函数 int strcmp(const char *str1, const char *str2) 把 str1 所指向的字符串和 str2 所指向的字符串进行比较; 如果返回值 &...
  • 案例要求对“c lanuage”,“hello world”,“itcast”,“strcmp”,"just do it"这五个字符串按照字母大小的排序,并将结果输出到屏幕上。 案例分析 此案例用到三个知识点: 用指针数组构造字符串数组,使用指针数组...
  • 功能需求:最近做通过爬虫技术去爬取各大相关网站的新闻,储存到公司数据中。这里面就有一个技术点,就是如何保证你已爬取的新闻,再有相似的新闻 或者一样的新闻,那就不存储到数据库中。(因为有网站会去引用...
  • 字符串链表题

    千次阅读 2014-07-20 08:59:21
    字符串的题目有: 001字符串旋转 002字符串包含
  • 词的向量表示

    万次阅读 2014-04-30 12:59:13
     这篇博客是我看了半年的论文后,自己对 Deep Learning NLP 领域中应用的理解和总结,此分享。其中必然有局限性,欢迎各种交流,随便拍。  Deep Learning 算法已经图像和音频领域取得了惊人的成果,但是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,967
精华内容 8,786
关键字:

向量法表示字符串是在