Question

I have almost completed the code for this problem, which I shall state as under:

Given:

Array of length ‘n’ (say n = 10000) declared as below,

     char **records = malloc(10000*sizeof(*records));

Each record[i] is a char pointer and points to a non-empty string.

     records[i] = malloc(11);

The strings are of fixed length (10 chars + ‘\0’).

Requirement:

Return the most frequently occurring string in the above array.

But now, I am interested in obtaining a slightly less brutal algorithm than the primitive one which I have currently, which is to sift through the entire array in two for loops :(, storing strings encountered by the two loops in a temporary array of similar size (‘n’ – in case all are unique strings) for comparison with the next strings. The inner loop iterates from ‘outer loop position + 1‘ to ‘n‘. At the same time, I have an integer array, of similar size – ‘n’, for counting repeat occurrences, with each i th element corresponding to the i th (unique) string in the comparison array. Then find the largest integer and use its index in the comparison array to return the most frequently occurring string.

I hope I am clear enough. I am quite ashamed of the algo myself, but it had to be done. I am sure there is a much smarter way to do this in C.

Have a great Sunday,

Cheers!

Answer 1

In most languages, the usual approach would be to construct a hashtable, mapping strings to counts. This has O(N) complexity.

For example, in Python (although usually you would use collections.Counter for this, and even this code can be made more concise using more specialised Python knowledge, but I’ve made it explicit for demonstration).

def most_common(strings):
    counts = {}
    for s in strings:
        if s not in counts:
            counts[s] = 0
        counts[s] += 1
    return max(counts, key=counts.get)

But in C, you don’t have a hashtable in the standard library (although in C++ you can use hash_map from the STL), so a sort and scan can be done instead. It’s O(N.log(N)) complexity, which is worse than optimal, but quite practical.

Here’s some C (actually C99) code that implements this.

int compare_strings(const void*s0, const void*s1) {
    return strcmp((const char*)s0, (const char*)s1);
}

const char *most_common(const char **records, size_t n) {
    qsort(records, n, sizeof(records[0]), compare_strings);
    const char *best = 0;  // The most common string found so far.
    size_t max = 0;  // The longest run found.
    size_t run = 0;  // The length of the current run.
    for (size_t i = 0; i < n; i++) {
        if (!compare_strings(records[i], records[i - run])) {
            run += 1;
        } else {
            run = 1;
        }
        if (run > max) {
            best = records[i];
            max = run;
        }
     }
     return best;
}