Question

我遇到问题，如果y_lim由与secret相同的字母组成，则此函数应返回1。

只要letters_guessed至少有letters_guessed中的1个相同字母，它就可以正常工作。如果有相同的字母2次或更多，它不起作用。我知道为什么，但我无法解决它，因为我不能删除相同的字母。我无法从letters_guessed数组中删除相同的字母，因为它是常量，我无法将其更改为非常数。

再次......

如果：

secret

抱歉我的英文不好和长篇解释。这是我的计划：

secret = "cat"

letters_guessed = "txaoc"

return 1

**Right**

If:

secret = "dog"

letters_guessed = "gefxd"

return 0 

**Right**

If:

secret = "car"

letters_guessed = "ccr"

return 1

**Wrong, How can I solve this?**

Answer 1

你可以：

复制你的字符串，以便标记已经计算过的字母（因为你告诉你不要修改字符串，我建议先复制一份，以便已经丢弃计数字母）;
获取字符串的排序版本，然后将它们与单个循环进行比较;此解决方案还可以提供更好的复杂性（您可以获得 O（n log n）而不是当前的 O（n ^ 2）。

Answer 2

您可以通过维护所有26个字母的数组来保持内存中的迭代。

假设： - 所有字母都应为小写字母。秘密不应该重复写信。

逻辑： - 如果我们考虑过这封信，请将数组输入设为1。 97是＆＃39; a＆＃39;

的ascii值

//声明头文件

#include "string.h"


int is_word_guessed(const char secret[], const char letters_guessed[])
{
    int same = 0;

    int alphabets[26];
    // make all enteries 0
    for (int k = 0; k <= 25; k++)
    {
        alphabets[k] = 0;
    }

    for (int i = 0; i < strlen(letters_guessed); i++)
    {
        for (int j = 0; j < strlen(secret); j++)
        {
            if (letters_guessed[i] == secret[j] && (alphabets[(char)letters_guessed[i] - 97] == 0))
            {
                same++;
                alphabets[(char)letters_guessed[i] - 97] = 1;
            }
        }
    }
    if (same == strlen(secret))
        return 1;
    else
        return 0;
}

Answer 3

在不修改字符串的情况下执行此操作的一种方法是计算字符串中字母的出现次数。当猜测出现的字母多于秘密时，它就是未命中的。在秘密的猜测中出现字母的情况只是一种特殊情况，因为那时秘密中出现的次数为零。

在实践中，您不要保留两个单独的计数：首先将猜测字母添加到计数中，然后删除秘密的字母。一旦一个计数降到零以下，那就错过了。

您可以利用只有256个不同的字符并将数字保存在数组中的事实。数组的索引是字母的ASCII码。注意不要在负索引处访问数组。 C＆＃39; char不保证是无符号的，因此您可以使用无符号临时变量或选择不考虑负值。

这是一个实现：

int contains(const char *guess, const char *secret)
{
    int count[256] = {0};               // start with all-zero array

    while (*guess) {
        unsigned char c = *guess++;

        count[c]++;
    }

    while (*secret) {
        unsigned char c = *secret++;

        if (count[c] == 0) return 0;
        count[c]--;
    }

    return 1;
}

Answer 4

这很容易。
在Haskell中它将是：

all (`elem` letters_guessed) secret

换言之：秘密中的所有字符必须是letters_guessed。

在C中（未经测试）：

// Iterate though string 'secret' until there is a char not
// part of 'letters_guessed'. If there is none, return 1
unsigned check(char *secret, char *letters_guessed) {
  unsigned length_secret = length(secret);
  unsigned length_guessed = length(letters_guessed);

  for (int i = 0; i < length_secret; i++) {
    if (!elem(secret[i], letters_guessed) {
      return 0;
    }
  }

  return 1;
}

// Check if char 'current' is part of 'string'
unsigned elem(char current, char *string) {
  unsigned length = length(string);
  unsigned found = 0;

  for (int i = 0; i < length; i++) {
    if (current == string[i]) {
      return 1;
    }
  }

  return 0;
}

查找2个字符串是否由相同的字母组成

4 个答案: