Я ничего не получаю \ пустым при попытке вывести эту функцию

Question

update "он спрашивает меня, чтобы я пробежал через str только один раз, и они уже дали мне, что функция должна быть только с одним аргументом)" Я пытаюсь вернуть первый символ, который не повторяется, например: "blazqnqbla" -> первый символ, который не повторяется, это "z", поэтому функция должна вернуть z.теперь функция принимает строку (str), которая построена из символа, значения ASCII символа которого находятся в диапазоне 1-127 (включая 1 и 127).Проблема в том, что я получаю пустой вывод.Я ничего не получаю при попытке вывести код

#include <stdio.h>
char first(char *str);
char first(char *str){
    int L = 0;
    int a[127] = {0};
    for (int i=0; i<127; i++){
        a[i] = i+1;
    }
    while (str[L] != '\0'){
        for(int d=1; d<127; d++){
            if (str[L]==(char)d){
                if (a[L]>0){
                    a[L] = 0;
                    L++;
                    break;
                }
                else if (a[L]==0){
                    a[L] =- 1;
                    L++;
                    break;
                }
                else{
                    L++;
                    break;
                }
            }
        }
    }
    for (int i=0; i<127; i++){
        if(a[i]==0)
            return (char)(i+1);
    }
    return '\0';
}

int main()
{
    char s[] = "blazqnqbla";
    char m   = first(s);
    printf("%c", m);
    return 0;
}

Answer 1

Извините, но ваша функция слишком сложна.В тот момент, когда вы даже не можете понять это и использовать a[L], когда это должно быть a[d].Это вернет что-то, но только первую букву в алфавитном порядке.Таким образом, в вашем примере это будет n.

. Чтобы заставить его работать, вам нужно:

• массив всех возможных символов, которые нужно отметить, если они были замечены никогда (скажем, 0), один раз (скажем,> 0) или более одного раза (скажем, -1).
• массив, отмечающий порядок, в котором встречаются уникальные символы
• при первом обнаружении символа,добавьте его в следующую позицию в массиве для заказа и сохраните этот ранг в первом массиве.

Код функции может стать следующим:

char first(char *str){
    int a[127] = {0};              // rank+1 of the character in resul array
    char resul[127] = {0};         // array of candidates for unique characters
    int rank = 0;                  // current position in array of unique candidates
    char c;
    while((c = *str++) != '\0') {  // scan the input string one char at a time
        int i = (unsigned char) c; // convert to int to avoid warnings when
                                   //  using the char value as an index
        if (c > 127) {             // control char validity
            fprintf(stderr, "Forbidden character %d\n", i);
            return 1;
        }
        if (a[i] == 0) {        // first time seen, store the character
            resul[rank] = c;
            a[i] = rank + 1;    // and its rank
            rank += 1;
        }
        else if (a[i] > 0) {    // already seen, remove it
            resul[a[i] -1] = 0;
            a[i] = -1;          // and never use it any longer
        }
    }
    for(int i=0; i<127; i++){   // return first unique character
        if(resul[i]!=0)
            return resul[i];
    }
    return '\0';
}

В этом кодевходная строка сканируется только один раз, как и массив результатов.Весь другой доступ осуществляется напрямую через индекс.

Answer 2

@ Реализация Бромана хороша и рекурсивна.Я включаю нерекурсивную реализацию.Алгоритм: сканирование строки от начала до конца: если индекс текущего символа совпадает с поиском в начале (strchr), а также в конце (strrchr), то этот символ уникален.иначе я возвращаю '-', если нет ничего уникального.(Это может быть изменено в зависимости от вашего приложения)

---

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

char first_unique_char(const char* s);

int main()
{
    char s[] = "abcdefghijtkqyabcdefghijkqx";
    char unique = first_unique_char(s);
    printf("The first unique char is %c\n",
                unique);
    return EXIT_SUCCESS;
}
// -----------------------------
char first_unique_char(const char* s)
{
    int i = 0;
    char* loc_forward = NULL;
    char* loc_backward = NULL;
    int len = strlen(s);
    bool found = false;

    printf("Len = %d\n", len);
    for(; i < len; i++)
    {
        loc_backward = strrchr(s, s[i]);
        loc_forward = strchr(s, s[i]);

        printf("i = %d, Char = %c, Loc_rev: %d, Loc_forward %d\n",
                        i, s[i], (int)(loc_backward - s), (int)(loc_forward - s));
        if ((loc_backward - s == i) && (loc_forward - s == i))//unique
        {
            found = true;
            break;
        }
    }
    printf("Returning at %d, s[i] = %c\n", i, s[i]);
    if (!found)
        return '-';
    else
        return s[i];
}

---

Вывод:

Len = 27
i = 0, Char = a, Loc_rev: 14, Loc_forward 0
i = 1, Char = b, Loc_rev: 15, Loc_forward 1
i = 2, Char = c, Loc_rev: 16, Loc_forward 2
i = 3, Char = d, Loc_rev: 17, Loc_forward 3
i = 4, Char = e, Loc_rev: 18, Loc_forward 4
i = 5, Char = f, Loc_rev: 19, Loc_forward 5
i = 6, Char = g, Loc_rev: 20, Loc_forward 6
i = 7, Char = h, Loc_rev: 21, Loc_forward 7
i = 8, Char = i, Loc_rev: 22, Loc_forward 8
i = 9, Char = j, Loc_rev: 23, Loc_forward 9
i = 10, Char = t, Loc_rev: 10, Loc_forward 10
Returning at 10, s[i] = t
The first unique char is t

Process returned 0 (0x0)   execution time : 0.016 s
Press any key to continue.

Answer 3

Ты делаешь это слишком сложным.Это будет делать:

int in(char c, char *str) 
{
    while(*str != '\0') {
        if(*str == c)
            return 1;
        str++;
    }
    return 0;
}

char first(char *str)
{
    if(*str == '\0')
        return 0;
    else if(!in(*str, str+1))
        return *str;
    else return first(str+1);
}

in - вспомогательная функция, которая возвращает 1, если строка str содержит символ c.

first проверит, присутствует ли первый символ в строке.Если это не так, то мы нашли первый неповторяющийся символ.Если нет, мы делаем ту же процедуру, но начинаем со следующего символа в строке.