计算 C 中一致字符串的数量

Question

所以这是 leetcode 的一个问题，我遇到了一些问题。我已经看到解决这个问题的代码发布到 leetcode 的讨论部分，但我想知道是否有人可以帮助我解决它我已经写了一些代码..这是问题所在：

给你一个字符串allowed，由不同的字符和 字符串数组words。如果字符串中的所有字符都是一致的 该字符串出现在字符串allowed 中。返回数量 数组单词中的一致字符串。

示例：
输入：allowed = "ab"，words => ["ad","bd","aaab","baa","badab"]

输出：2

解释：字符串“aaab”和“baa”是一致的，因为它们只 包含字符“a”和“b”。

到目前为止，这是我的代码：

注意：允许包含单个字符串

#include <string.h>

int countConsistentStrings(char * allowed, char ** words, int wordsSize){
    
    int real_count = 0;
    for(int i = 0; i < wordsSize; i++)
    {
        for(int j = 0; j < strlen(allowed); j++)
        {
            for(int k = 0; k < strlen(words[i]); k++)
            {
                if(words[i][k] != allowed[j])
                {
                    // stuff goes here?
                }
            }

        }
    }


    return real_count;
}

我能够逐个字符地遍历数组中的字符串，并将它们与允许的字符进行比较......但我真的不知道从那里去哪里。我尝试过记录东西并使用比较，但后来我遇到了 words[i] 是否小于 strlen(allowed) 或反之亦然的问题..

我知道可能有更简单的方法来解决这个问题（正如我在 leetcode 的讨论部分中看到的那样），但我想知道是否有任何方法可以使用我已经完成的方法来解决它？

感谢任何可以帮助我解决这个问题的人......我觉得我“几乎”解决了这个问题，但我也被困了很长一段时间，所以我准备好接受任何解释我可以得到。

Answer 1

这是一个 O(N) 的解决方案。因此，您不必为每个字符重新扫描allowed，只需使用查找表即可。很容易，因为字符通常是 8 位的，并且包含 256 个真值/值的数组很容易。

int countConsistentStrings(char * allowed, char ** words, int wordsSize) {

    // put all the allowed chars into a table of booleans

    unsigned int table[256] = {0}; // 256 assumes 8-bit char
    int real_count = 0;
    const char* ptr = allowed;

    while (*ptr)
    {
        char c = *ptr;
        table[(unsigned char)c)] = 1;   // table[c] = 1 to indicate "is allowed"
        ptr++;
    }

    // evaluate each word and see if each char in word
    // is in the allowed list of chars
    
    for(int i = 0; i < wordsSize; i++)
    {
        char* word = words[i];
        int consistent = 1;
        while (*word && consistent)
        {
            char c = *word;
            consistent = table[(unsigned char)c]; // lookup to see if this char is allowed
            word++;
        }
        real_count += consistent;
    }

    return real_count;
}

Answer 2

您可以使用strchr 函数来帮助检测allowed 中是否存在字符。该函数的工作原理如下：

   char *strchr(const char *s, int c);
   The strchr() function returns a pointer to the first occurrence
   of the character c in the string s.
   The strchr() and strrchr() functions return a pointer to the
   matched character or NULL if the character is not found.

因此，对 NULL 的测试可以让您检查是否在 allowed 中找到了相关字符。使用此功能，您可以删除其中一个循环，只需遍历给定单词中的每个字符以查找匹配项。考虑到这一点，我认为假设所有单词 do 匹配然后减去不匹配的单词会更容易。

这里有一些代码说明了我的意思。我创建了一个调用 countConsistentStrings 的主函数，其中包含一些我用来验证行为的测试数据。

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

int countConsistentStrings(char *allowed, char **words, int wordsSize)
{
    int real_count = wordsSize;
    for(int i = 0; i < wordsSize; i++)
    {
        for(int k = 0; k < strlen(words[i]); k++)
        {
            // if character is not found, then it's not a consistent string
            // so we can just lower the count and exit the loop right now
            if(strchr(allowed, words[i][k]) == NULL)
            {
                real_count--;
                break;
            }
        }
    }

    return real_count;
}

int main()
{
    char *allowed = "abcde";
    char *words[] =
    {
       "abcde",
       "fghji",
       "d",
       "l",
       "abcdef"
    };
    int wordcount = sizeof(words)/sizeof(words[0]);
    int count;

    printf("Finding consistent strings among %d words\n", wordcount);
    
    count = countConsistentStrings(allowed, words, wordcount);
    
    printf("Consistent string count: %d\n", count);

    return 0;
}

Answer 3

假设标准 C 库函数是允许的，下面使用 size_t strspn(const char *dest, const char *src)，它“返回由 dest 指向的空终止字节字符串的最大初始段（跨度）的长度，包括仅在 src 指向的以空字符结尾的字节字符串中找到的字符。"。

#include <string.h>

int countConsistentStrings(char *allowed, char **words, int wordsSize)
{
    int count = 0;
    for(int i = 0; i < wordsSize; i++)
    {
        char *word = words[i];
        if(word[strspn(word, allowed)] == '\0')
            count++;
    }
    return count;
}