我正在尝试编写一个布尔函数，该功能检查字符串输入是否具有任何重复字符

Question

我在main下编写了此功能，我想检查字符串输入是否具有任何重复的字符，但是当我使用调试功能时，事实证明，当内部循环循环正确循环时，外循环仅循环一次。我不知道为什么外循环不应该像字符串的长度那样多次吗？由于某种原因不起作用，是的，它是CS50任务

#include <cs50.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
bool only_letters(string s);
bool duplicts(string b);
int main(int argc, string argv[])
{
    if(argc!=2){
        printf("wrong input\n");
        return 1;
    }
    int length=strlen(argv[1]);
    if(length!=26){
        printf("Key must contain 26 characters.\n");
        return 1;
    }
    if(!only_letters(argv[1])){
        printf("key must contain only alphapetic letters.\n");
        return 1;
    }
    if(!duplicts(argv[1])){
        printf("key must not contain same characters\n");
        return 1;
    }
}
// need a check input function if letters or not
bool only_letters(string s){
    int length=strlen(s);
    for(int i =0;i<length;i++){
if(!isalpha(s[i]))
     return false;
    }return true;
}
bool duplicts(string b) {
    int length = strlen(b);
    for (int i = 0; i < length; i++) {
        for (int k = i + 1; k < length; k++) {
            tolower(b[i]);
            tolower(b[k]);
            if (b[i] == b[k])
                return false;
        }
    }
    return true;
}

Answer 1

通过明智的凹痕约定将代码重新格式化使错误显而易见：

bool duplicts(string b) {
    int length = strlen(b);
    int count = 0;
    for (int i = 0; i < length; i++) {
        for (int k = 1; k < length; k++) {
            if ((b[i]) == b[k])
                count++;
        }
        return count;
    }
    if (count > 0) {
        return false;
    }
    return true;
}

返回计数;在外循环内，因此仅迭代一次。

还有另一个问题：内部循环应以k = i + 1开始，否则您将始终在超过1个字节的字符串中找到重复项。

一旦找到重复的字符，您的代码就可以轻松修改以返回false：

bool duplicts(string b) {
    int length = strlen(b);
    for (int i = 0; i < length; i++) {
        for (int k = i + 1; k < length; k++) {
            if (b[i] == b[k])
                return false;
        }
    }
    return true;
}

您可以进一步简化以避免调用strlen并处理任意的大字符串（尽管非常效率低下）：

bool duplicts(const char *s) {
    for (; *s != '\0'; s++) {
        for (size_t k = 1; s[k] != '\0'; k++) {
            if (s[k] == *s)
                return false;
        }
    }
    return true;
}

要修复对大字符串效率低下的二次复杂性，您可以使用一个数组：

bool duplicts(const char *s) {
    unsigned char seen[256] = { 0 };
    unsigned char c;
    while ((c = *s++) != '\0') {
        if (seen[c] != 0)
            return false;
        seen[c] = 1;
    }
    return true;
}