Concatenation of first halves of two separate strings - c

Question

How can I write C-program which accepts two strings from the user and prints a string which is the result of the concatenation of the first half of the two strings. For odd length strings, extra character goes in the first half of the string.
I have this so far but am confused on the splitting in half part...
printf("Please enter your first word.\n"); //Asks for first string
scanf("%s",&c); //Takes first string
printf("Please enter your second word.\n"); //Asks for second string
scanf("%s",&d); //Takes second string
strcat(c,d); //Combines both strings

Answer 1

If you just want to print out the result not caring about the content of the strings c and d any more you could do something like
#include <stdio.h>
#include <string.h>
int main(void) {
char c[1024]; // c string buffer
char d[1024]; // d string buffer
// initialize to empty strings
c[0] = '\0';
d[0] = '\0';
// read strings c and d
scanf("%s", c);
scanf("%s", d);
// just to make sure there is no overflow
c[1023] = '\0';
d[1023] = '\0';
// cut strings in middle
c[(strlen(c) + 1)/2] = '\0';
d[(strlen(d) + 1)/2] = '\0';
// print final string
printf("%s", c);
printf("%s\n", d);
return 0;
}
The result of (strlen(c) + 1)/2 does what you want because it performs an integer division. If strlen(c) gives an even size then adding 1 would make it the next odd with no effect on the integer division. If on the other hand the number is odd adding one will make it the next even achieving the rounding up you need. The '\0' will make sure that the string is terminated at that point.
If you don't want to loose the information of the two strings or need the resulting string stored then you could do something like
#include <stdio.h>
#include <string.h>
int main(void) {
char c[1024]; // c string buffer
char d[1024]; // d string buffer
char r[1024]; // resulting string buffer
int i; // general counter
int c_half_len; // c half length
int d_half_len; // d half length
// initialize to empty strings
c[0] = '\0';
d[0] = '\0';
r[0] = '\0';
// read strings c and d
scanf("%s", c);
scanf("%s", d);
// just to make sure there is no overflow
c[1023] = '\0';
d[1023] = '\0';
// get c and d half lengths rounding up
c_half_len = (strlen(c) + 1)/2;
d_half_len = (strlen(d) + 1)/2;
// copy first half c string to begining of result
for (i = 0; i < c_half_len; ++i) {
r[i] = c[i];
}
// copy first half d string after the end of the first half string
for (i = 0; i < d_half_len; ++i) {
r[c_half_len + i] = d[i];
}
// add an end of string character
r[c_half_len + d_half_len] = '\0';
// print final string
printf("%s\n", r);
return 0;
}
In both cases I assume that the two strings have a maximum length, in this case 1024 (including the end of string character). If that is not the case then you will need to handle things using dynamic memory.

Answer 2

void concathalf(const char *a, const char *b, char *out)
{
char *abuf, *bbuf;
if ((abuf = malloc(strlen(a) / 2)) && (bbuf = malloc(strlen(b) / 2))) {
memcpy(abuf, a, strlen(a) / 2);
memcpy(bbuf, b, strlen(b) / 2);
abuf[strlen(a) / 2] = bbuf[strlen(b) / 2] = 0;
}
sprintf(out, "%s%s", abuf, bbuf);
free(abuf);
free(bbuf);
}
Now, handling odd length inputs will be left as an exercise.