C solution to "99 bottles" kata
Logic

I find it counterintuitive that your main loop doesn't look like this:

for (int bottles = limit; bottles &gt;= 0; bottles--) {
    …
}


The way you build the song backwards (with some index arithmetic), followed by two special cases, makes the code hard to follow.

You have a pluralization bug:




2 bottles of beer on the wall, 2 bottles of beer
Take one down, pass it around, 1 bottles of beer on the wall...

  
  


You used a special case for SENTENCE_FORMAT_1. Because the text happens to be constant, you call malloc() and strcpy() instead of createCouplet().  I don't recommend doing anything so drastically different. In fact, createCouplet() should be made responsible for choosing the right template to use based on the bottle count, such that the function "just works" for any i.

Memory management

I don't understand the appeal of storing all of the verses in a variable-length array. If you want to have the entire song at once, it would be better to build one huge contiguous string. Alternatively, if you are willing to write a loop that prints each verse (like my countdown loop above), then you don't even need to have the entire song in memory at any given time; you can just work one verse at a time.

In particular, the one-verse-at-a-time approach gives you the option to use one buffer, whose contents are overwritten repeatedly. I would just use a static buffer. In general any design in C that avoids malloc() altogether is highly appealing.

I'm not a fan of the technique you used to calculate the length of the output. It's a very manual process, requiring you to tell it how many numbers appear in the template, and calculating how many digits should be rendered. Rather, what you could do is take advantage of the return value of snprintf(), which tells you how long the output should be — and that technique works in general. (The whole issue would be a moot point with a static buffer: you just generously estimate the required space for any verse.)

Suggested design


  int bottleVerse(int bottles, int init_bottles, char *buf, size_t bufsize)
  
  This function generates one verse from the song 99 Bottles of Beer on the Wall, writing it to the given buffer.  The output ends with a newline and a NUL terminator.
  
  Parameters
  
  
  bottles: The number of bottles of beer at the start of the verse
  init_bottles: The initial number of bottles (traditionally 99)
  buf: Pointer to a buffer to which the output should be written (possibly NULL, to obtain the output length without writing the output anywhere).
  bufsize: The size of the buffer
  
  
  Return value
  
  On success, a positive value is returned, indicating the length of the string that was written to the buffer.  A negative value indicates the number of bytes by which the buffer is undersized.


This design mimics the pattern followed by many functions in the C library.  The caller is responsible for providing the buffer and its size; the function merely fills it in.  The return value acts as a status indicator.

The memory management is very in-your-face.  It seems more inconvenient to use than your createCouplet().  However, it has many advantages:


This function obviously allocates no memory.  It's very clear what the memory ownership policy is: the caller provides and "owns" the memory.
The caller has the flexibility to provide several kinds of memory:


It could be a static buffer, reused between verses.
The caller could malloc() a buffer.
The caller could append this verse to the previous verse in one huge buffer for the song.

It can avoid some drawbacks of malloc() and free():


malloc() is a mildly expensive operation.
malloc() might allocate memory in non-consecutive chunks, reducing the efficiency of the memory cache.
Allocating many small chunks of memory with malloc() can lead to memory fragmentation, wasting memory.
Forgetting to free() a newly allocated string would cause a memory leak.
Accidentally using memory that has already been free()d could cause a security vulnerability.



Many of these issues are negligible concerns for a tiny program like this.  However, if many functions in a large program were designed to use malloc(), then you would have a chaotic mess.  For these reasons, idiomatic C functions generally have this kind of design where the caller provides the memory.

Here is an example of what the code might look like if you wanted to compose the entire song as one long string.  Using a static buffer to print one verse at a time would result in a slightly simpler program.

#include &lt;assert.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

// Left as an implementation exercise for you, using snprintf()
int bottleVerse(int bottles, int init_bottles, char *buf, size_t bufsize);

int main() {
    const int initBottles = 99;
    char *song, *verse;

    // Overestimate the length by one verse
    // (better than underestimating by one byte!)
    int estimatedVerseLen = -bottleVerse(initBottles, initBottles, NULL, 0);
    int bufsize = estimatedVerseLen * (initBottles + 2) + 1;

    if (NULL == (verse = song = malloc(bufsize))) {
        return 1;
    }
    for (int bottles = initBottles; bottles &gt;= 0; bottles--) {
        int len = bottleVerse(bottles, initBottles, verse, bufsize);
        assert(len &gt;= 0);
        verse += len;
        bufsize -= len;
    }
    fputs(song, stdout);
    free(song);
}