Why does my C function return string variable as a pointer instead of a value?

In C, I have the following function:

//Get Readability: Coleman-Liau Index Formula: ((0.0588 * Average # of letters per 100 words) - (0.296 * Average # of sentences per 100 words) - 15.8)
string get_readability(float avg_letters, float avg_sentences)
{
    //Store as int so that it rounds the resulting index number
    int index = (0.0588 * avg_letters) - (0.296 * avg_sentences) - 15.8;

    //printf("Index: %i\n", index);//debug

    //Return the grade level
    if (index < 1)
    {
        return "Before Grade 1";
    }
    else if (index > 16)
    {
        return "Grade 16+";
    }
    else
    {
        //Create char array for result in order to concat the index number
        char result[8] = "Grade ";
        char grade[2];
        sprintf(grade, "%i", index);//Convert int to string
        strcat(result, grade);
        //Convert char array to string in order to return results
        string result_str = result;

        return result_str;
    }
}

When I call it and store it in a variable it's correct and I can print it right away with no issues:

//Get reading level
//string reading_level = get_readability(letter_avg, sentence_avg);
string reading_level = get_readability(464.29f, 28.57f);

//printf("%i letters\n%i words\n%i sentences\n%f letter avg\n%f sentence avg\n", letter_count, word_count, sentence_count, letter_avg, sentence_avg);//debug
    
printf("%s\n", reading_level);

But if I do multiple printf statements between setting the variable and printing it, then the variable changes to "" and just prints a blank line.

//Get reading level
//string reading_level = get_readability(letter_avg, sentence_avg);
string reading_level = get_readability(464.29f, 28.57f);

//printf("%i letters\n%i words\n%i sentences\n%f letter avg\n%f sentence avg\n", letter_count, word_count, sentence_count, letter_avg, sentence_avg);//debug
printf("\n");
printf("\n");
printf("\n");

printf("%s\n", reading_level);

Looking this up it seems like the issue might be that when the function is returning result_str it's returning the pointer to that variable and after calling printf a couple times, it's getting written over. But I don't really understand how that would happen as I'm not passing anything with *.

Here's your problem:

char result[8] = "Grade ";
...
string result_str = result;
return result_str;

First, the string type is unique to CS50; it's not part of standard C. C does not have an actual string data type.

Second, the CS50 string type is not an actual string data type, either - it's a typedef name (alias) for a pointer type:

typedef char *string;

A string in C is simply a sequence of character values including a zero-valued terminator - the string "hello" is represented as the sequence {'h', 'e', 'l', 'l', 'o', 0}. Strings are stored in arrays of character type, but character arrays can also store sequences that are not strings (either don't have a 0-valued terminator, or have multiple 0-valued bytes).

Unless it is the operand of the sizeof, _Alignof, or unary & operators, or is a string literal used to initialize a character array in a declaration, an expression of type "N-element array of T" will be converted, or "decay", to an expression of type "pointer to T" and the value of the expression will be the address of the first element of the array. When you pass an array expression as an argument to a function, like

char arr[N];
foo( arr );

the conversion rule above replaces arr with a pointer expression, such that the function call looks more like

foo( &arr[0] );

and what the function receives is a pointer, not an array. This is true for all array types, not just character arrays.

So when you write

string result_str = result;

you're storing a pointer to the first element of the result array to result_str, not its contents, and by extension returning that address to the caller.

Third, the result array is local to get_readability and ceases to exist once the function exits. The memory that the array occupied is still there, but now it's available for other functions to use. As long as you didn't call any other functions after get_readability that memory remained unmodified and your code appeared to work as expected, but as soon as you called printf( "\n" ); that memory was overwritten.

There are two ways to go here.

The first (and IMO preferred) method is to pass the target buffer as a parameter to get_readability (replacing any instance of string with char * since string won't work outside of the CS50 environment):

/**
* We're returning a pointer to the target buffer just
* for convenience's sake.
*/
char *get_readability( float avg_letters, float avg_sentences, char *result, size_t result_size )
{
...
/**
* Using snprintf to make sure we don't write past the
* end of the result array.
*/
snprintf( result, result_size, "Grade %d", index );
return result;
}

And you'd call it as

char result[8];
...
printf( "reading level: %s\n", get_readability( 464.29f, 28.57f, result, sizeof result ) );

Again, we're returning the result pointer just for convenience; you could also do:

char result[8];
get_readability( 464.29f, 28.57f, result, sizeof result );
printf( "Reading level: %s\n", result );

The second (less-preferred) option is to dynamically allocate memory within get_readability and return a pointer to that:

char *get_readability( float avg_letters, float avg_sentences )
{
...
char *result = calloc( 8, sizeof *result );
if ( result )
snprintf( result, 8, "Grade %d", index );
else
// memory allocation failure, handle as appropriate
return result;
}

and call it as

char *result = get_readablity( 464.29f, 28.57f );
printf( "Reading level: %s\n", result );
...
free( result );

Drawbacks to this method:

<ul>
<li>When you're done with it, you must explicitly free the allocated memory using the <code>free</code> library function;
<li>To be able to do that, you must save the returned pointer value to a variable somewhere - if you write something like <pre><code>printf( "Reading level: %s\n", get_readability( 464.29f, 28.57f ) );</code></pre> then you've lost any reference to that dynamically-allocated buffer and it hangs around until the program exits.
<br><br>
You <em>could</em> do something like <pre><code>char *result;
printf( "Reading level: %s\n", (result = get_readability( 464.29f, 28.57f ) );
...
free( result );
</code></pre> but it doesn't buy you that much and you'd likely get murdered by anyone maintaining your code.
</ul>