查找字符串中最小和最长的单词

Question

I used:

keep for recording where is the begin of the word.

position_max and position_min for recording position of final char's word.

max and min for compare every word and find the length of longest and the smallest.

lenght is the length of entire string.

#include<limits.h>
#include<stdio.h>
#include<time.h>
#include<math.h>
#include<string.h>
#include<conio.h>
#include<ctype.h>
#include<stdlib.h>
#include<malloc.h>


int main(void)
{
char *stringa = "alex keep all money";
size_t x;
int keep;       
int min;            
int max;        
int position_max;   
int position_min;   
int lenght;     
keep = 1;
max = 0;
min = INT_MAX;
position_max = 0;
lenght = strlen(stringa);
while(x != lenght + 1)
{
    if(isalnum(stringa[x]) != 0)
    {
        keep += 1;
    }
    
    if(isspace(stringa[x]) != 0 || stringa[x] == '\0')
    {
        if(keep > max)
        {
            position_max = x;
            max = keep;
        }
        if(keep < min)
        {
            position_min = x;
            min = keep;
        }
        keep = 0;
    }
    x++;
}
puts("the longest word:");
for(x = position_max - max; x != position_max; x++)
{
    printf("%c",stringa[x]);
}
puts("\n\nthe smallest word:");
for(x = position_min - min; x != position_min; x++)
{
    printf("%c", stringa[x]);
}
return 0;
}

Answer 1

The program has undefined behavior at least because the variable x used in this while loop

while(x != lenght + 1)

was not initialized

size_t x;

Another problem is the initial initializing of the variable keep by 1

keep = 1;

This can results for example that for the string like "A BB" the substring with the maximum length will be "A" instead of "BB" provided that initially the variable x was initialized by 0 Or if the string starts from space character ' ' like " A" then the maximum substring will be " " and using the expression x = position_max - max in this for loop

for(x = position_max - max; x != position_max; x++)

again results in undefined behavior.

Also you have to take into account situations when a string contains adjacent white spaces.

I would write a separate function for example as shown in the demonstration program below.

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

struct SubString
{
    char *position;
    size_t length;
};

struct MinMax
{
    struct SubString min;
    struct SubString max;
};

struct MinMax minmax_string( const char *s, const char *delim )
{
    struct MinMax minmax = 
    { 
        .min = { .position = NULL, .length = 00 }, 
        .max = { .position = NULL, .length = 0 } 
    };

    for ( s += strspn( s, delim ); *s; s += strspn( s, delim )  )
    {
        const char *position = s;
        s += strcspn( s, delim );

        size_t length = s - position;

        if ( minmax.min.position == NULL )
        {
            minmax.min.position = ( char * )position;
            minmax.min.length = length;
            minmax.max.position = ( char * )position;
            minmax.max.length = length;
        }
        else if ( minmax.max.length < length )
        {
            minmax.max.position = ( char * )position;
            minmax.max.length = length;
        }
        else if ( length < minmax.min.length )
        {
            minmax.min.position = ( char * )position;
            minmax.min.length = length;
        }
    }

    return minmax;
}

int main(void) 
{
    const char *s = "alex keep all money";

    struct MinMax minmax = minmax_string( s, " \t" );

    printf( "The minimal string is \"%.*s\" at position %zu\n", 
        ( int )minmax.min.length, minmax.min.position, ( size_t )( minmax.min.position - s ) );
    printf( "The maximum string is \"%.*s\" at position %zu\n", 
        ( int )minmax.max.length, minmax.max.position, ( size_t )( minmax.max.position - s ) );
}

The program output is

The minimal string is "all" at position 10
The maximum string is "money" at position 14

If you want to use the standard C function isspace then the function minmax_string can look the following way

#include <stdio.h>
#include <ctype.h>

struct SubString
{
    char *position;
    size_t length;
};

struct MinMax
{
    struct SubString min;
    struct SubString max;
};

struct MinMax minmax_string( const char *s )
{
    struct MinMax minmax = 
    { 
        .min = { .position = NULL, .length = 00 }, 
        .max = { .position = NULL, .length = 0 } 
    };

    do
    {
        while ( isspace( ( unsigned char )*s )) ++s;

        if ( *s )
        {
            const char *position = s;

            while ( *s && !isspace( ( unsigned char )*s ) ) ++s;

            size_t length = s - position;

            if ( minmax.min.position == NULL )
            {
                minmax.min.position = ( char * )position;
                minmax.min.length = length;
                minmax.max.position = ( char * )position;
                minmax.max.length = length;
            }
            else if ( minmax.max.length < length )
            {
                minmax.max.position = ( char * )position;
                minmax.max.length = length;
            }
            else if ( length < minmax.min.length )
            {
                minmax.min.position = ( char * )position;
                minmax.min.length = length;
            }
        }
    } while ( *s );
    

    return minmax;
}

int main(void) 
{
    const char *s = "alex keep all money";

    struct MinMax minmax = minmax_string( s );

    printf( "The minimal string is \"%.*s\" at position %zu\n", 
        ( int )minmax.min.length, minmax.min.position, ( size_t )( minmax.min.position - s ) );
    printf( "The maximum string is \"%.*s\" at position %zu\n", 
        ( int )minmax.max.length, minmax.max.position, ( size_t )( minmax.max.position - s ) );
}

The program output is the same as shown above that is

The minimal string is "all" at position 10
The maximum string is "money" at position 14

Answer 2

as others already mentioned - you have problems with uninitialized variables ( x , position_min ), also there are couple edge cases missed: when you have spaces at the start/end or multiple consecutive ones, here is fixed version:

int main(void) {
    const char * const stringa = " alex keep   all money ";
    size_t x = 0; // keep declaration and definition in one place, so it is easy to spot mistakes
    unsigned int keep = 0;
    unsigned int min = 0; // initial min/max should be zero to work properly later during printing
    unsigned int max = 0;
    size_t position_max = 0;
    size_t position_min = 0;
    const size_t length = strlen(stringa);
    
    while (x <= length) {
        if (x == length || isspace(stringa[x])) { // first cover end of string case
            if (keep > 0) { // multiple spaces
                if (max == 0 || keep > max) {
                    position_max = x;
                    max = keep;
                }
                if (min == 0 || keep < min) {
                    position_min = x;
                    min = keep;
                }
                keep = 0;
            }
        } else if (isalnum(stringa[x]))
            keep++;
        x++;
    }

    puts("the longest word:");
    for(x = position_max - max; x < position_max; x++) printf("%c", stringa[x]);
    puts("\n\nthe smallest word:");
    for(x = position_min - min; x < position_min; x++) printf("%c", stringa[x]);
    return 0;
}

Answer 3

Iterate through the string using a pair of pointers.
Use pointers to store the beginning of the longest and shortest words.
Use counters to store the lengths of the words. Updating longest and shortest as needed.
In case of duplicate lengths, this will use the first word found.

#include <stdio.h>
#include <ctype.h>
#include <limits.h>

int main ( void) {
    char *str = "compare every word, find the length of longest and the smallest";
    char *begin = str;
    char *end = str;
    char *longest = str;
    char *shortest = str;
    int len = 0;
    int longlen = 0;
    int shortlen = INT_MAX;

    printf ( "%s\n", str);
    while ( *begin) {
        while ( ! isalnum ( (unsigned char)*begin)) {
            ++begin; //advance past non-alphanumeric
        }
        end = begin; //assign pointer to section to evaluate
        len = 0;
        while ( isalnum ( (unsigned char)*end)) {
            ++end; //advance past alphanumeric
            ++len; //count characters
        }
        printf ( "\tword '%.*s' length %d\n", len, begin, len);
        if ( len > longlen) { //found longer word
            longlen = len; //store length
            longest = begin; //store pointer
        }
        if ( len && len < shortlen) { //found shorter word
            shortlen = len; //store length
            shortest = begin; //store pointer
        }
        begin = end; //assign pointer to iterate next section
    }

    printf ( "\nlength of longest word '%.*s' is %d\n", longlen, longest, longlen);
    printf ( "length of shortest word '%.*s' is %d\n", shortlen, shortest, shortlen);

    return 1;
}