C什么是""首先[a [c] - 'a'] ++;"

我在学校开始使用C语(因为我正在慢慢结束),我遇到了一个关于编程anagram检查器的问题.经过一番思考后我仍然无法找出除了每个特定字母的单独计数器,如果计数器匹配,那将是一个字谜.但这写起来似乎非常漫长(特别是在纸面上).所以我通过谷歌搜索了一些类型的答案,寻找一个anagram解算器并设法遇到一些代码,但有一件事我不明白:

#include 

int check_anagram(char [], char []);

int main() {
   char a[100], b[100];
   int flag;

   printf("Enter first string\n");
   gets(a);

   printf("Enter second string\n");
   gets(b);

   flag = check_anagram(a, b);

   if (flag == 1)
      printf("\"%s\" and \"%s\" are anagrams.\n", a, b);
   else
      printf("\"%s\" and \"%s\" are not anagrams.\n", a, b);

   return 0;
}

int check_anagram(char a[], char b[]) {
    int first[26] = {0}, second[26] = {0}, c = 0;

    while (a[c] != '\0') {
        first[a[c] - 'a']++;
        c++;
    }

    c = 0;

    while (b[c] != '\0') {
        second[b[c] - 'a']++;
        c++;
    }

    for (c = 0; c < 26; c++) {
        if (first[c] != second[c])
            return 0;
    }

    return 1;
}

起初我认为这不适用于超过26个字母的字谜,所以我尝试了一些长于26的随机字符串,它确实有效.然而,当我查看代码时,我看到我无法理解: first[a[c]-'a']++;和second[b[c]-'a']++; 意思.有人可以澄清这是什么,它做了什么,或者至少我应该寻找什么来实现这些东西,因为它并没有很好地融入我的脑海.

编辑1 - 首先,你们人很快...... - 其次,如果我理解正确,这个程序不应该很好地处理大写字母或不同的上限(例如:HELLO和你好)？

这是一个常见的技巧,实际上:a是一个字符数组,每个字符都是ASCII值(即数字,int兼容),因此您可以在数学表达式中使用它.c是一个int,用于遍历字符数组a.假设所有字符a都是小写字母,那么表达式

a[c] - 'a'

将评估为0for a,1for b等.因为first是一个int数组,26 long(int first[26]),每个小写字母都有一个有效的,对应的索引('a' - 'a'= 0,'z' - 'a'= 25),所以你是基本上计算每个角色的出现次数.second[b[c] - 'a']++对第二个字符串执行完全相同的操作:计算字符串中每个字母的出现次数.
最后,您将迭代这些字母计数数组,比较每个字母的值(occ.count).如果所有字母在两个字符串中出现的次数相同,则表示您正在处理字谜.如果没有,你就回来了0.

这个技巧更常用于将数字转换为整数:

char foo[] = "123";
int result = 0;
for (int i=0;foo[i] != 0;++i)
    result = result * 10 + (foo[i] - '0');
printf("String: %s vs int: %d\n", foo, result);

为了完整性,所有ASCII字符及其对应的十进制(即int)值:

Char  Dec  Oct  Hex | Char  Dec  Oct  Hex | Char  Dec  Oct  Hex | Char Dec  Oct   Hex
-------------------------------------------------------------------------------------
(nul)   0 0000 0x00 | (sp)   32 0040 0x20 | @      64 0100 0x40 | `      96 0140 0x60
(soh)   1 0001 0x01 | !      33 0041 0x21 | A      65 0101 0x41 | a      97 0141 0x61
(stx)   2 0002 0x02 | "      34 0042 0x22 | B      66 0102 0x42 | b      98 0142 0x62
(etx)   3 0003 0x03 | #      35 0043 0x23 | C      67 0103 0x43 | c      99 0143 0x63
(eot)   4 0004 0x04 | $      36 0044 0x24 | D      68 0104 0x44 | d     100 0144 0x64
(enq)   5 0005 0x05 | %      37 0045 0x25 | E      69 0105 0x45 | e     101 0145 0x65
(ack)   6 0006 0x06 | &      38 0046 0x26 | F      70 0106 0x46 | f     102 0146 0x66
(bel)   7 0007 0x07 | '      39 0047 0x27 | G      71 0107 0x47 | g     103 0147 0x67
(bs)    8 0010 0x08 | (      40 0050 0x28 | H      72 0110 0x48 | h     104 0150 0x68
(ht)    9 0011 0x09 | )      41 0051 0x29 | I      73 0111 0x49 | i     105 0151 0x69
(nl)   10 0012 0x0a | *      42 0052 0x2a | J      74 0112 0x4a | j     106 0152 0x6a
(vt)   11 0013 0x0b | +      43 0053 0x2b | K      75 0113 0x4b | k     107 0153 0x6b
(np)   12 0014 0x0c | ,      44 0054 0x2c | L      76 0114 0x4c | l     108 0154 0x6c
(cr)   13 0015 0x0d | -      45 0055 0x2d | M      77 0115 0x4d | m     109 0155 0x6d
(so)   14 0016 0x0e | .      46 0056 0x2e | N      78 0116 0x4e | n     110 0156 0x6e
(si)   15 0017 0x0f | /      47 0057 0x2f | O      79 0117 0x4f | o     111 0157 0x6f
(dle)  16 0020 0x10 | 0      48 0060 0x30 | P      80 0120 0x50 | p     112 0160 0x70
(dc1)  17 0021 0x11 | 1      49 0061 0x31 | Q      81 0121 0x51 | q     113 0161 0x71
(dc2)  18 0022 0x12 | 2      50 0062 0x32 | R      82 0122 0x52 | r     114 0162 0x72
(dc3)  19 0023 0x13 | 3      51 0063 0x33 | S      83 0123 0x53 | s     115 0163 0x73
(dc4)  20 0024 0x14 | 4      52 0064 0x34 | T      84 0124 0x54 | t     116 0164 0x74
(nak)  21 0025 0x15 | 5      53 0065 0x35 | U      85 0125 0x55 | u     117 0165 0x75
(syn)  22 0026 0x16 | 6      54 0066 0x36 | V      86 0126 0x56 | v     118 0166 0x76
(etb)  23 0027 0x17 | 7      55 0067 0x37 | W      87 0127 0x57 | w     119 0167 0x77
(can)  24 0030 0x18 | 8      56 0070 0x38 | X      88 0130 0x58 | x     120 0170 0x78
(em)   25 0031 0x19 | 9      57 0071 0x39 | Y      89 0131 0x59 | y     121 0171 0x79
(sub)  26 0032 0x1a | :      58 0072 0x3a | Z      90 0132 0x5a | z     122 0172 0x7a
(esc)  27 0033 0x1b | ;      59 0073 0x3b | [      91 0133 0x5b | {     123 0173 0x7b
(fs)   28 0034 0x1c |       62 0076 0x3e | ^      94 0136 0x5e | ~     126 0176 0x7e
(us)   31 0037 0x1f | ?      63 0077 0x3f | _      95 0137 0x5f | (del) 127 0177 0x7f

简而言之:first[a[c] -'a']++;就像它说:

first[a[c] - 97]++;//a[c] will be value between 97 and 122 so first[0..25]++

看到你在处理大写字符串时可能遇到的问题不是100%,这里是如果你将一个字符串如"FOO"和"OOF"传递给你的函数会发生什么的细分:

int first[26] = {0};// valid indexes are 0 to 25
//if a[c] == 'F', this evaluates to first[65-97] or first[-32]
first[a[c] - 'a']++;//DANGER: Out of bounds!

您可能不会立即注意到问题的原因仅仅是因为您将一个字符数组(一个字符串)传递给您的函数.一旦传递给函数,数组就会衰减成指针.可以说,数组几乎总是衰减成指针:

下标运算符[]的定义是E1 [E2]与(*((E1)+(E2)))相同.

这意味着写作与写作a[c]相同,写作等同于:,在这种情况下可以评估,当然*(a+c)与写作相同. 那就是要求你的机器获取地址,并向后移动32步(每一步都是).你无法知道你正在访问的内存中有什么:陷阱值,其他变量......任何事情都可能发生.这些表达式的行为是未定义的.first[a[c] - 'a']*(first + (a[c] - 'a'));first[-32]*(first - 32);
first[0]sizeof(int)

要解决此问题,您可以检查以确保字符在这样的a-z范围内:

if (a[c] > 96 && a[c] <= 'z')//96 == 'a' -1
   first[a[c] -'a']++;
else
    return -1;//indicate error

或者简单地转换为小写:

首先[tolower(a [c]) - 'a'] ++;

tolower天真地调用假设字符a将是大写或小写字母.这不一定是这样,所以如果我是你,我会做两个:转换为低,然后检查结果char是否确实是一个字母(理论上,你的函数可以接收像"foo:123"这样的字符串!",包含空格,数字和其他字符).

总而言之,你可以简单地增加的大小first和second对256,只是这样写:

first[a[c]]++;
//and
second[b[c]]++;

这解决了大小写问题,并解决了EBCDIC与ASCII的问题.检查字谜时,您可以安全地跳过第一个元素(first[0]现在只计算终止的空字符,无论如何都没用).