strend(s,t) from K&R C

[danthehat]

I've begun to delve the deep wisdom of K&R and resolved to complete each of the exercises presented therein.

Now, I have a working example of exercise 5-4, which asks you to "Write the function strend(s, t), which returns 1 if the string t occurs at the end of the string s, and zero otherwise."

If anyone has any constructive criticism to offer on the composition of my code, it would be much appreciated.

I've included main() for convenience.

#include <stdio.h>

int strend(char *s, char *t);

#define SIZE 16

int main() {
	char helloWorld[SIZE] = "Hello world!";
	char justWorld[SIZE] = "world!";
	
	if (strend(helloWorld, justWorld))
		printf("justWorld occurs at the end of helloWorld\n");
	else
		printf("justWorld DOES NOT occur at the end of helloWorld\n");
	return 0;
}

int strend(char *s, char *t) {
	while (*s++) {	
		if (*t == *s) {
			while ((*s++ == *t++) && (*t != '\0')) ;
			if (*s == '\0' && *t == '\0')
				return 1;
			return 0;
		}
	}
	return 0;
}

Thanks!

[brewbuck]

Hmm. I'd be lazier.

int strend( const char *s, const char *t )
{
    int ns = strlen(s), nt = strlen(t);
    return nt <= ns && strcmp( s + ns - nt, t ) == 0;
}

[dwks]

There's one problem with your code that I can see [edit](by "your" I mean danthehat)[/edit]: consider a string like "endendend", and an ending of "endend". I don't think your code would "spot" the ending, since it would stumble across another substring that starts with the same thing.

Just a thought:

/**
    @return True if @a string ends with @a ending.
*/
int strend(char *string, char *ending) {
    char *ending_end = ending;
    char *string_start = string + strlen(string);
    
    while(string_start != string && *ending_end) {
        string_start --;
        ending_end ++;
    }

    /* The string isn't long enough to contain ending. */
    if(*ending_end) return 0;

    while(*string_start && *string_start == *ending) {
        string_start ++;
        ending ++;
    }

    return *string_start == 0;
}

I haven't tested it, but that code is supposed to step backwards from the end of the string strlen(ending) characters, and if the string isn't long enough return immediately. It then steps forwards in the string, making sure the string matches ending.

There are probably more efficient ways of doing this, but that's what came to mind first. (Actually, there *are* more efficient ways of doing this, I just thought of one. Sigh. See if you can improve on it.)

[itCbitC]

Just my 2c, but IMO it's better to start at the right end of both the arrays instead of their left end (base of the arrays).

[itCbitC]

and here's my version of strend():

int strend(char *s, char *t, int i)
{
        while (i-- >= 0)
            if (*t-- != *s--)
                return 0;
        return 1;
}

but with a minor modification to the way strend() is being called from main(), as in

if (strend(s+strlen(s)-1, t+strlen(t)-1, strlen(t)-1))

[laserlight]

but with a minor modification to the way strend() is being called from main()

That sounds like a major modification to me, and considering that your version of strend() is so different from the requirements, it basically... is not strend.

EDIT:
After some eyeballing of code and consideration of alternatives, I think that brewbuck's solution (and other equivalents) is likely to be the best.

[itCbitC]

That sounds like a major modification to me, and considering that your version of strend() is so different from the requirements, it basically... is not strend.

fail to see where the endianness has been specified.

[laserlight]

fail to see where the endianness

So, you insist that s+strlen(s)-1 is the string s, and t+strlen(t)-1 is the string t, and you can add a parameter at will? That is a fine way to do software development: the requirements are there to be ignored.

Anyway, what you can do is easy: just turn your function into a helper function.

EDIT:
Oh, but then your function has a bug: it assumes that the length of t is never greater than the length of s.

EDIT #2:
Okay, that is not quite true. More accurately, the example of the call of your function has a bug. It should pass the length of the shorter of the two strings as the third argument.

[itCbitC]

So, you insist that s+strlen(s)-1 is the string s, and t+strlen(t)-1 is the string t, and you can add a parameter at will? That is a fine way to do software development: the requirements are there to be ignored.

Anyway, what you can do is easy: just turn your function into a helper function.

Nope, I don't insist on going against requirements but pls point out where have the requirements been explicitly stated.

Edit #1: yes robust error checking has been left out as an exercise for the reader

Edit #2: what is a helper function (??), do you mean as in a library function.

[laserlight]

Nope, I don't insist on going against requirements but pls point out where have the requirements been explicitly stated.

In post #1, and I quote: "Write the function strend(s, t), which returns 1 if the string t occurs at the end of the string s, and zero otherwise."

[itCbitC]

In post #1, and I quote: "Write the function strend(s, t), which returns 1 if the string t occurs at the end of the string s, and zero otherwise."

Yep! I see your point, the title implies that strend() takes two char* parameters.

[laserlight]

what is a helper function (??), do you mean as in a library function.

No, I mean as a function whose primary purpose is to implement strend() (or more generally: a function intended as implementation detail of some set of functions that you are writing).

[itCbitC]

No, I mean as a function whose primary purpose is to implement strend() (or more generally: a function intended as implementation detail of some set of functions that you are writing).

Alright! I see you mean as an intermediate step in the processing.
So here's my attempt at the true-to-requirements function:

int strend(char *s, char *t)
{
        int i = strlen(t)-1;
        int j = strlen(s)-1;
        char *es = s+j;
        char *et = t+i;

        while (i-- >= 0)
            if (*et-- != *es--) return 0;
        return 1;
}

[quzah]

int strend( char *s, char *t )
{
    size_t slen = 0;
    size_t tlen = 0;

    for( slen = 0; s[slen]; slen++ );
    for( tlen = 0; t[tlen]; tlen++ );

    /*
     *  Pick one:
     *
    for( slen -= tlen; tlen && (s + slen)[tlen] == t[tlen]; tlen-- );
     *
    while( tlen && s[slen--] == t[tlen--] );
     */

    return !!tlen;
}

Sans error checking.


Quzah.

[brewbuck]

The reason I like my solution is because A) it's clear what is happening and B) it does no unnecessary work. There is no getting around the fact that you have to find the ends of both strings (two calls to strlen) and there's no getting around the fact that you have to compare the overlap (one call to strcmp).