Encode a null terminated string using Run-length encoding More...

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

Include dependency graph for run_length_encoding.c:

Functions
char *	run_length_encode (char *str)
	for IO operations More...

static void	test ()
	Self-test implementations. More...

int	main ()
	Main function. More...

Detailed Description

Encode a null terminated string using Run-length encoding

Author: serturx

Run-length encoding is a lossless compression algorithm. It works by counting the consecutive occurences symbols and encodes that series of consecutive symbols into the counted symbol and a number denoting the number of consecutive occorences.

For example the string "AAAABBCCD" gets encoded into "4A2B2C1D"

Function Documentation

◆ main()

int main ( void )

Main function.

Returns: 0 on exit

           {
    test();  // run self-test implementations
    printf("All tests have passed!\n");
    return 0;
}

Here is the call graph for this function:

◆ run_length_encode()

char * run_length_encode ( char * str )

for IO operations

for string functions for malloc/free for assert

Encodes a null-terminated string using run-length encoding

Parameters

str	String to encode

Returns: char* Encoded string

                                   {
    int str_length = strlen(str);
    int encoded_index = 0;
 
    //allocate space for worst-case scenario
    char* encoded = malloc(2 * strlen(str));
    
    //temp space for int to str conversion
    char int_str[20];
 
    for(int i = 0; i < str_length; ++i) {
        int count = 0;
        char current = str[i];
 
        //count occurences
        while(current == str[i + count]) count++;
 
        i += count - 1;
 
        //convert occurrence amount to string and write to encoded string
        sprintf(int_str, "%d", count);
        int int_str_length = strlen(int_str);
        strncpy(&encoded[encoded_index], int_str, strlen(int_str));
 
        //write current char to encoded string
        encoded_index += strlen(int_str);
        encoded[encoded_index] = current;
        ++encoded_index;
    }
 
    //null terminate string and move encoded string to compacted memory space 
    encoded[encoded_index] = '\0';
    char* compacted_string = malloc(strlen(encoded) + 1);
    strcpy(compacted_string, encoded);
    
    free(encoded);
 
    return compacted_string;
}

◆ test()

static void test ( void )

static

Self-test implementations.

Returns: void