如何在c中检查字符串中的重复字符

Question

我正在尝试创建一个程序来检查命令行参数字符串中的重复字符。假设该字符串仅包含 26 个字符，并且所有字符都必须是字母顺序。但是，字符串中不能有任何重复的字符，每个字母字符只能出现一次。我想出了程序的前两个部分，但我不知道如何检查重复的字符。我真的可以使用一些帮助和解释。

#include <stdio.h>
#include <cs50.h>
#include <string.h>
#include <ctype.h>

int main (int argc, string argv[])
{
    if (argc != 2)
    {
        printf("Usage: ./substitution key\n");
        return 1;
    }
    else
    {
        int len = strlen(argv[1]);
        if (len != 26)
        {
            printf("Key must contain 26 characters.\n");
            return 1;
        }
        else
        {
            for (int i = 0; i < len; i++)
            {
                if (!isalpha(argv[1][i]))
                {
                    printf("Usage: ./substitution key\n");
                    return 1;
                }
            }
        }
    }
}

Answer 1

以下是解决方案的基础知识：

开始时，初始化一个标志表：char Seen[UCHAR_MAX+1] = {0};。在此数组中，当且仅当字符 c 已经出现时，Seen[c] 才会为真（非零）。 （获取UCHAR_MAX，#include <limits.h>。）

处理每个字符时，将其复制到unsigned char：unsigned char c = argv[1][i];。然后将其转换为大写：c = toupper(c);。 然后测试是否已经看过：

if (Seen[c])
    Report error...

如果是新的，请记住它已被看到：Seen[c] = 1;。

这就是所有必要的。

注意事项：

• 如果已知 A 到 Z 在字符集中是连续的，就像它们在 ASCII 中一样，则可以将 char Seen[UCHAR_MAX+1] 简化为 char Seen['Z'-'A'+1] 并使用 Seen[c-'A'] 进行索引。 （实际上，一个较弱的条件就足够了：A 是 value 中最小的大写字符，Z 是最大的。）
• 不要试图使用unsigned char c = toupper(argv[1][i])，因为toupper 是为unsigned char 值定义的，char 值可能超出范围（负）。
• 在一个深奥的 C 实现中，char 与 int 一样宽，但它们都不存在，UCHAR_MAX+1 的计算结果为零。但是，如果发生这种情况，编译器应该发出警告。

Answer 2

根据问题，预期输入是 26 个字符，每个字符只出现 1 次。

根据Andreas Wenzel 的想法，我为每个角色添加了计数器。以防发现任何字符丢失或重复。这是我的解决方案：

int main(int argc, char *argv[])
{
    const int OFFSET = 'A';

    if (argc != 2)
    {
        return 1;
    }
    if (strlen(argv[1]) != 26)
    {
        printf("Key must contain 26 characters.\n");
        return 1;
    }

    unsigned char *key = argv[1];
    int count[26] = {0}; // array of all zero

    // Check for any invalid character 
    for (int i = 0, n = strlen(key); i < n; i++)
    {
        if (!isalpha(key[i]))
        {
            printf("Key contains invalid characters.\n");
            return 1;
        }
        count[toupper(key[i]) - OFFSET]++;
    }
    // check for duplicate character of 
    for (int i = 0; i < 26; i++)
    {
        if (count[i] != 1) 
        {
            printf("Key shouldn't contain duplicate characters\n");
            return 1;
        }
    }
)

Answer 3

我假设这是来自 cs50，我现在正在处理这个问题......我所做的是我使用了一个简单的布尔函数。我使用了两个循环，第一个循环代表引用的第一个字符，在嵌套循环中，我遍历所有其他字符，如果 i == k 则返回 false。

bool no_repeat(string arg_letters)
{
   for (int i = 0, j = strlen(arg_letters); i < j; i++)
   {
      for (int k = i+1; k < j; k++)
      {
         if (arg_letters[i] == arg_letters[k])
         {
            return false;
         }

      }
   }
   return true;
}

Answer 4

您可以使用strchr() 来检测给定字符是否在字符串的其余部分中重复：

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: ./substitution key\n");
        return 1;
    } else {
        char *key = argv[1];
        int len = strlen(key]);
        if (len != 26) {
            printf("Key must contain 26 characters.\n");
            return 1;
        } else {
            for (int i = 0; i < len; i++) {
                unsigned char c = key[i];
                if (!isalpha(c)) {
                    printf("The key must contain only letters.\n");
                    return 1;
                }
                if (strchr(key + i + 1, c) {
                    printf("The key must not contain duplicate letters.\n");
                    return 1;
                }
            }
        }
    }
    return 0;
}

或者，您可以使用一组指标来一次性执行检查。如果您想忽略字符大小写，则首选此方法。

#include <ctype.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: ./substitution key\n");
        return 1;
    } else {
        char *key = argv[1];
        unsigned char seen['Z' + 1 - 'A'] = { 0 };
        int i;
        for (i = 0; key[i] != '\0'; i++) {
            unsigned char c = key[i];
            if (!isalpha(c)) {
                printf("The key must contain only letters.\n");
                return 1;
            }
            if (seen[toupper(c) - 'A']++ != 0) {
                printf("The key must not contain duplicate letters.\n");
                return 1;
            }
        }
        if (i != 26) {
            printf("Key must contain all 26 letters.\n");
            return 1;
        }
    }
    return 0;
}

Answer 5

您可以考虑使用strchr()。我从https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_72/rtref/strchr.htm得到一个例子

#include <stdio.h>
#include <string.h>

#define SIZE 40

int main(void) {
  char buffer1[SIZE] = "computer program";
  char * ptr;
  int    ch = 'p';

  ptr = strchr(buffer1, ch);
  printf("The first occurrence of %c in '%s' is '%s'\n",
          ch, buffer1, ptr );

}

/*****************  Output should be similar to:  *****************
The first occurrence of p in 'computer program' is 'puter program'
*/

Answer 6

有很多方法可以做到这一点，但我喜欢的方法是先对字符串进行排序，然后遍历它并将字符串删除或复制到另一个字符串/数组，你可以这样做

s = "bedezdbe"

排序后

s = "bbddeeez"

检查一下

if(s[i-1]!=s[i])

Answer 7

我假设您还没有学习数据结构和算法。如果是这样，我会进行二进制插入排序，当您发现重复时，您只需打印错误消息并返回 1，就像您对其余错误所做的那样。

也就是说，现在你可能已经想不通了。所以在这种情况下，只需使用蛮力方法而不考虑优化。

1. 从第一个字符开始，遍历字符串的其余部分以查看是否匹配。

2. 如果匹配，错误信息

3. 如果没有匹配，则重复下一个字符。

下面的代码通过提到的这种蛮力方法检查是否有任何重复字符。当然，您需要根据您的代码对其进行调整。

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool itrepeats(char c, char *restofstring, int sublen){
    for(int j=0; j<sublen; j++){
        if(c==*restofstring) return true;
        restofstring++;
    }
    return false;
}

int main (int argc, char *argv[])
{
    int len = strlen(argv[1]);
    char *substr = argv[1];
    
    //loop through all characters
    for(int i=0;i<len;i++){
        //get a character
        char c = argv[1][i];
        //start of substring after c
        substr++;
        //length of that substring
        int substrlen = len-(i+1);
        //check for c in rest of string
        if(itrepeats(c, substr, substrlen)){
            printf("%c repeats, not allowed!\n",c);
            return 1;
        }
        else printf("all good!\n");
    }
}

Answer 8

您可以首先对字符串中的字符进行排序，以便任何重复的字母彼此相邻。因此，在排序后，使用包含当前扫描字符的变量扫描已排序的字符串。如果您扫描的下一个字符与您扫描的最后一个字符相同，则您有一个重复字符

Answer 9

我以前做过，所以这是我对这个问题的解决方案： 每次我们在字符串中找到当前 argv[1] 的字符时，我们都会给计数器加 1

在argv[1]正常的正常情况下，计数器最后应该是26。

但是如果有重复的字符，counter最后应该大于26。

int counter = 0;
for (int i = 0; i < len; i++)
        {
            char argu = argv[1][i];
            // make sure that the key doesnt accept duplicated characters in key.
            for (int k = 0; k < len; k++)
            {
                if (argu == argv[1][k])
                {
                    counter++;
                }
                if (counter > 26)
                {
                    printf("Opps! no duplicated characters!\n");
                    return 1;
                }
            }
        }