char *process(char *string) {
    char *newWord = malloc(strlen(string) * sizeof(char) + 1);
    if (newWord == NULL) {
        fprintf(stderr, "Memory error.\n");
        exit(1);
    }

    char *sptr = string;
    char *nptr = newWord;
    char *lastLetter = newWord;

    // Skip leading non-alphabetical characters
    while (!isalpha(*sptr) && *sptr != '\0') {
        sptr++;
    }
    // Deal with empty string
    if (*sptr == '\0') {
        *newWord = '\0';
    }
    else {
        // Process all letters and keep track of last letter to remove trailing special characters
        while (*sptr != '\0') {
            if (isalpha(*sptr)) {
                *nptr = tolower(*sptr);
                lastLetter = nptr;
                nptr++;
            }
            sptr++;
        }
        // Remove trailing special characters by null-terminating after the last letter seen.
        *(lastLetter + 1) = '\0';
    }
    return newWord;
}

मेरे पास यह फ़ंक्शन है जो प्रमुख और अनुगामी गैर वर्णमाला वर्णों को ट्रिम करने के बाद एक शब्द देता है। मेरी समस्या यह है कि मुझे यह पता लगाने में परेशानी हो रही है कि मुझे इसे बदलने के लिए क्या बदलना है ताकि शब्दों के बीच में गैर अल्फा को भी न हटाया जा सके:

word-word should return word-word और '-' को न हटाएं।

एक अन्य उदाहरण didn't and don't जैसे शब्द हैं, यह एपॉस्ट्रॉफी को हटा रहा है। कोई मदद?

c
1
zzca 10 अक्टूबर 2020, 01:38

1 उत्तर

सबसे बढ़िया उत्तर

आप इसका उपयोग करके इसे और अधिक कुशलता से कर सकते हैं:

(ए) strdup() मानक लाइब्रेरी फ़ंक्शन (जो प्रभावी रूप से एक malloc और strcpy एक झटके में गिर जाता है)।

(बी) स्ट्रिंग के 'पिछड़े पुनरावृत्ति', गैर-अल्फा वर्णों को nul वर्ण के साथ तब तक बदलना जब तक अल्फा नहीं मिल जाता (जैसे ही ऐसा होता है)।

char* process(char* string)
{
    // First, we can 'forward iterate' until we find an ALPHA character ...
    char* fp = string;
    while (*fp && !isalpha(*fp)) ++fp;
    // If we have found the NUL terminator, we have an empty string left...
    if (!*fp) return NULL; // Nothing left!

    // We don't need to check again for a valid (alpha) character: there WILL be at least one!
    char* result = strdup(fp); // Allocate memory and copy current string!
    // Now, we can 'backward iterate' until we get to an ALPHA...
    char* bp = result + strlen(result) - 1;
    while (!isalpha(*bp)) *bp-- = '\0'; // Replace with null character and THEN decrement

    // Finally, convert to lowercase:
    for (fp = result; *fp; ++fp) *fp = tolower(*fp);
    return result;
}

अनुगामी गैर-अल्फा वर्णों को nul वर्णों से बदलना संभावित रूप से 'बर्बाद' स्मृति है (लौटा हुआ बफर संभवतः वास्तविक स्ट्रिंग से अधिक लंबा होगा), लेकिन यह आसान है। कोई भी इसे संभालने के लिए 'परिणाम' स्ट्रिंग पर एक और strdup कॉल जोड़ सकता है, अगर यह समस्याग्रस्त है।

यहाँ एक संक्षिप्त main है जिसका उपयोग आप उपरोक्त फ़ंक्शन का परीक्षण करने के लिए कर सकते हैं:

int main()
{
    char test[256];
    printf("Enter a string: ");
    scanf("%s", test);
    char* answer = process(test);
    if (answer) {
        printf("Processed string: %s", answer);
        free(answer);
    }
    else {
        printf("Nothing left after processing!");
    }
    return 0;
}

कृपया किसी और स्पष्टीकरण और/या स्पष्टीकरण के लिए बेझिझक पूछें।

1
Adrian Mole 10 अक्टूबर 2020, 02:19