Flash Gordon said:
sfuerst said:
Or, even more compressed, and extremely non-readable:
char *squeeze(char *s, char c)
{
char *t=s,*r=s;
while((t+=c!=(*t=*s))&&*s++);
return r;
}
If you want compressed, here is a one liner for you...
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
char *squeeze(char *s,char c)
{
return *s?squeeze(s+1,c):s,*s==c?memmove(s,s+1,strlen(s)),s:s;
}
int main()
{
char s[] = "---The quick brown fox jumped over the lazy dogs!!!~~";
char c;
for (c=CHAR_MIN; c<CHAR_MAX; c++)
printf("%4d (%c): %s\n",c,isprint((unsigned char)c)?c:'
,squeeze(s,c));
printf("%4d (%c): %s\n",c,isprint((unsigned char)c)?c:' ',squeeze(s,c));
return 0;
}
OK, so it might be just a tad less efficient...
Very neat. *applause*
Can be made just a tiny bit shorter, with a somewhat larger tad:
return *s&&squeeze(s+1,c)&&memmove(s,s+(*s==c),strlen(s)),s;
This version has the advantage that the performance is more
predictable.
Of course, the above solutions aren't meant as serious
suggestions, but if we allow ourselves a three-argument
helper function there is a nice compact expression that
also has good run-time performance --
int
squeez3( char *d, const char *s, char c ){
return (*d=*s) && squeez3( d+(*s!=c), s+1, c );
}
char *
squeeze( char *s, char c ){
return squeez3( s, s, c ), s;
}
Unfortunately gcc doesn't (yet?) realize the expression in
squeez3 can be computed using tail recursion. We can do that
using this form instead:
return (*d=*s) ? squeez3( d+(*s!=c), s+1, c ) : 0;
In case there are any gcc developers out there who might be
reading this -- in any integer-type function known to always
return either 0 or 1, an expression such as this one
<condition> && <this-function>( <arguments> )
can be seen as a proper tail call, since it is clearly equivalent
to
<condition> ? <this-function>( <arguments> ) : 0
which gcc already recognizes as tail recursion. (It's
easy to construct sufficient conditions for a function
always returning 0 or 1, looking at all its return
expressions, seeing if the top-most operator is a
comparison or equality operator, &&, ||, ?: with
both branches satisfying the 0/1 property, etc.)
