How do I fix the problem with this condition?

Basically, learning through the K&R book I got into an entab exercice, and its objective is to change blanks by \t correctly when they can be replaced to minimize the use of characters. For example: "hello " can be written as "hello\t" considering a 8 blanks equivalent tab stop. My program is changing 8 blanks sequentially by a \t, and can also leave normal blanks on their places, however, when I have a situation like this: "hihi hihihi " that could be written as "hihi\thihihi\t", the final tab don't gets added. That's my code:

#include <stdio.h>
#define MAXLINE 1000
#define STDTAB  8
#define STDVAL  0
// Functions prototypes
void removechar(char array[], int character, int number);
int my_getline(char array[MAXLINE]);
void entab(char array[]);
int main() {
char array[MAXLINE];
int len = STDVAL;
while ((len = my_getline(array)) != 0) {
entab(array);
printf("%s", array);
}
}
void removechar(char array[], int character, int number) {
int length;
int out_idx, in_idx;
// Determining array length
for (length = STDVAL; array[length] != '\0'; ++length) {
;
}
// Length is increased by one to include the null character
++length;
// Iterate over all array elements
for (out_idx = STDVAL; out_idx <= length; ++out_idx) {
if (array[out_idx] == character && number > 0) {
for (in_idx = out_idx; in_idx <= length; ++in_idx) {
array[in_idx] = array[in_idx+1];
}
// Resize length after removing one character
--length;
// Return one index on outer loop to check the previous character before proceeding
--out_idx;
--number;
}
}
}
int my_getline(char array[MAXLINE]) {
int input, i;
for (i = STDVAL; (input = getchar()) != EOF && input != '\n' && i < MAXLINE-2; ++i) {
array[i] = input;
}
if (input == '\n') {
array[i] = '\n';
++i;
}
array[i] = '\0';
return i;
}
void entab(char array[]) {
int i;
int length = STDVAL;
int blankcounter = STDVAL;
int normalchar = STDVAL;
char copy[MAXLINE];
for (i = STDVAL; array[i] != '\0'; ++i) {
++length;
if (length > 8) {
blankcounter = normalchar = STDVAL;
}
if (array[i] == ' ') {
++blankcounter;
}
if (array[i] != ' ') {
++normalchar;
}
// 8 Blanks sequentially, gets replaced by one \t
if (blankcounter == STDTAB && normalchar == STDVAL) {
array[i-7] = '\t';
removechar(array, ' ', blankcounter-1);
blankcounter = STDVAL;
normalchar = STDVAL;
} 
if (normalchar <= 7 && normalchar >= 1 && blankcounter >= 2) {
array[(i+1)-blankcounter] = '\t';
removechar(array, ' ', blankcounter+1);
blankcounter = normalchar = STDVAL;
}
}
}

I already tried changing the conditions multiple times, changing the removechar() function, and a lot of other things, however, or it causes more problems, or just don't solve it. The idea here to change blanks for tabs in 2 situations:

1. " " (8 sequential blanks)
2. "dawd " (Characters and sequential blanks without exceeding the tab stop limit)

And leave the blanks as they were in another situations.

The concept of a "tabstop" is to think of a string in terms of "fragments" of a certain length. The key to replacing trailing spaces in each fragment with a single TAB character comes from measuring out each fragment as one scans across the original string.

It's common for beginner's to write too much code employing too many variables as they struggle to solve a problem. There's no need for multiple functions or an overabundance of variables that increase and decrease in value. All too much to keep track of!

Try this:

#include <stdio.h>
#define MAXLINE 1000
#define STDTAB  8
void toTab( char *str ) { // mutable buffer may be "condensed".
size_t s = 0, d = 0, i; // 's'ource and 'd'estination
while( str
展开收缩
 ) { // to the end of the string...
for( i = 0; i < STDTAB && (str[d++] = str
展开收缩
) != '\0'; s++, i++ )
; // copy up to 'tablength' chars.
if( i < STDTAB ) // leave partial trailing fragment alone.
break;
// scan backwards and replace trailing copied SP's in this fragment with TAB
if( str[ d - 1 ] == ' ' ) {
while( str[ d - 1 ] == ' ' ) d--;
str[ d++ ] = '\t';
}
}
str[ d ] = '\0'; // terminate the string (condensed or not).
}
int main( void ) {
char test[][MAXLINE] = {
"ABCD        EFGH",
"  ABCD        EFGH",
};
for( int i = 0; i < sizeof test/sizeof test[0]; i++ ) {
puts( test[i] );
toTab( test[i] );
puts( test[i] );
}
return 0;
}

This does not address a trailing newline. My view is that any/all trailing whitespace should be removed (reducing the volume of the text).

The next challenge is to take a string with embedded tabs, and "expand" it out to a string with SP's...

EDIT<br>
Admitting my mistake...<br>
The above will stray beyond the beginning of the string if the string begins with enough SP's. Below corrects the "reverse scan". The lesson is, always test edge cases.

void toTab( char *str ) {
size_t i = 0, s = 0, d = 0;
while( str
展开收缩
 ) {
i = 0;
while( i < STDTAB && (str[d] = str
展开收缩
) != '\0' )
s++, i++, d++; // copy up to '8' chars.
if( i < STDTAB )
break;
if( str[ d - 1] == ' ' ) {
while( i-- && str[ d - 1] == ' ' )
d--;
str[d++] = '@';
}
}
str[ d ] = '\0';
}

Your test cases you mention is inconsistent with the requirement:

"hihi hihihi " that could be written as "hihi\thihihi\t"

but the input has 4 and 2 spaces not 8.

#include <stdio.h>
#include <string.h>
#define STDTAB  8
// write to array[i] and read from array[j]
void entab(char array[]) {
size_t i = 0;
for(size_t j = 0; array[j];) {
if(array[j] == ' ') {
// read look-ahead array[j+l]
size_t l = 1;
for(; array[j+l] && array[j+l] == ' ' && l < STDTAB; l++);
if(l == STDTAB) {
array[i++] = '\t';
j += l;
continue;
}
strncpy(&array[i], &array[j], l);
i += l;
j += l;
continue;
}
array[i++] = array[j++];
}
array[i] = '\0';
}
int main() {
struct {
char *input;
const char *expected;
} tests[] = {
{(char []) {"        "}, "\t"},
{(char []) {"dawd    "}, "dawd    "},
{(char []) {"hihi    hihihi  "}, "hihi    hihihi  "}
};
for(size_t i = 0; i < sizeof tests / sizeof *tests; i++) {
entab(tests[i].input);
if(strcmp(tests[i].input, tests[i].expected))
printf("tests: %zu\n"
"\tgot: \"%s\"\n"
"\texpected: \"%s\"\n",
i, tests[i].input, tests[i].expected);
}
}

Consider reworking the interface to return a new string instead of modifying the input in place.