Optimize inversing word while capitalize word after space function - c++

Question

void inverse(char *string)
{
int i = 0;
int j = strlen(string) - 1;
char temp;
//Inverse the order
while ( i < j )
{
temp = *( string + i );
*( string + i ) = *( string + j );
*( string + j ) = temp;
i++;
j--;
}
//Capitalize letter after space
while( *string != '\0')
{
if ( *( string ) == ' ' && *( string + 1 ) != ' ')
{
*( ++string ) = toupper( *( string ) );
}
string++;
}
}
I just want to know if there is a better way to make this output, especially produce same output with less lines of code

Answer 1

Some general tips to cleanup and reduce the number of lines of code:
1. Use for loops instead of while loops. This
int i = 0;
while ( i < 10 )
{
// loop body
i++;
}
is better written as
for ( int i = 0; i < 10; i++ )
{
// loop body
}
2. Declare variables when you first use them. For example, the declaration of temp can be done inside the loop.
3. Use array syntax instead of pointer arithmetic. For example, this
*( string + i ) = *( string + j );
is better written as
string[i] = string[j];
With that in mind the code to reverse the string could be written as
for ( int i = 0, j = strlen(string)-1; i < j; i++, j-- )
{
char temp = string[i];
string[i] = string[j];
string[j] = temp;
}
As mentioned in the comments, the code to capitalize the first letter of words has some issues. The algorithm in the question advances the string pointer until it points to a space character, and then capitalizes the character at address string+1.
An alternative algorithm keeps a copy of the previous character. If the previous character was a space, then the current character is capitalized. Here's an implementation of that algorithm:
for ( char oldc = ' '; *string != '\0'; string++ )
{
if ( oldc == ' ' )
*string = toupper(*string);
oldc = *string;
}
Note that this will capitalize the first character in the string, and any character that follows a space. If you specifically only want to capitalize characters that follow a space, and not the first character, then change the initialization of oldc so that is doesn't start as a space, e.g.
for ( char oldc = 'a'; *string != '\0'; string++ )

Answer 2

Oh, you can optimize it greatly. Let's review the logic first.
We need to have each character that follows the space be uppercased in the result string. What does that mean? That means that in the original string such characters are located before the space. Thus, we have the criteria to find those in the original string and actually make them uppercase even before swapping. This renders second loop unnessessary -- we can do all in one.
Here's the example how it can be implemented:
#include <stdio.h>
#include <string.h>
#include <ctype.h>
void transform(char* s)
{
char temp;
char* endPtr = s + strlen(s) - 1;
while (s < endPtr)
{
/*
converting left hand part like 'c ' to 'C '
so that after swap it turns to ' C'
*/
if (!isspace(*s) && isspace(*(s + 1)))
*s = toupper(*s);
/* same to the right side */
if (isspace(*endPtr) && !isspace(*(endPtr - 1)))
*(endPtr - 1) = toupper(*(endPtr - 1));
/* swap */
temp = *s;
*s = *endPtr;
*endPtr = temp;
s++;
endPtr--;
}
}
int main(void)
{
char str[] = "this is a demo string! the one and only real demo string. crazy example ";
transform(str);
printf("'%s'\n", str);
return 0;
}

Answer 3

You can remove the temp variable while reversing using xor operation
int end= strlen(string)-1;
int start = 0;
while( start<end )
{
string[start] ^= string[end];
string[end] ^= string[start];
string[start]^= string[end];
++start;
--end;
}
To capitalized each letter, try with code below:
char* reversestr = *string;
while( *reversestr != '\0')
{
if (i==0 || *(reversestr - 1) ==' ' && *reversestr >= 'a' && *reversestr <= 'z')
*reversestr = toupper(*reversestr);
reversestr++;
}
I am not tested the code yet, but I think it should work.