Codility Test - Better Answer? - c

Question

Had a Codility test yeterday and did not do great. The first question was pretty easy, but I ran out of time on the second question. Was curious if I was at least headed down the right path toward an efficient solution.
The task says you're given a char array A of up to N elements. ALL of the elements are upper case letters. The task is to figure out how many times a particular word can be spelled from the letters in the array, keeping in mind a set of the letters in this word get "consumed" each time you find an instance of the word. The letters DON'T have to appear in order. Lets say the word is "MOON". So if you have an array filled with {F, N, D, M, O, R, O}, you can spell "MOON" once. In an array like {R, N, O, T ,O, M, O, D, W, N, O, M} you can spell "MOON" twice.
I wrote in C, and my strategy was pretty simple: figure out which letter in "MOON" appeared the least, as that would be limiting factor. I used a for loop to scan the array for M, O and N. Used a switch inside the for loop with a counter for each of these three letters. When complete, first realize that "MOON" requires TWO "Os", so divide the total number of "Os" found by 2. Then, compare the totals for each of the three letters, seeing which one was the smallest. That should be the "limiting factor" in how many times I can spell the word.
So roughly:
int solution(int *A)
{
int Mcnt = 0, Ocnt = 0, Ncnt = 0;
int N = sizeof(A)/sizeof(char);
int lowestIter = N;
int cntArr[];
for(int x = 0; int < N; x++0)
{
switch A[x]
{
case 'M':
Mcnt++;
break;
//Etc. for O and N
default:
break;
}
}
Ocnt = Ocnt / 2; //Divide by 2 since O gets used twice in "MOON"
//Stick the count values in another array to check for smallest
CntArr[0] = Mcnt;
CntArr[1] = Ocnt;
CntArr[2] = Ncnt;
for (y = 0; y < 3; y++)
{
if (CntArr[y] < lowestIter)
{
lowestIter = CntArr[y];
}
}
return lowestIter;
}
I think this results in O(n), but not positive. Am I way off?

Answer 1

I found almost the same question on LeetCode (the word was "balloon", all in lowercase). Cleaned up a couple of syntax errors, and submitted it: 0mS execution time, faster than 100% of C submissions. A bit annoyed that it seems the company that was interviewing me only looked at my score and didn't notice I was a few typos away from a working, efficient solution...
Anyway, here it is:
int maxNumberOfBalloons(char * text){
int Bcnt = 0, Ocnt = 0, Ncnt = 0, Acnt = 0, Lcnt = 0;
int len = strlen(text);
int lowestIter = len;
int CntArr[5];
for(int x = 0; x < len; x++)
{
switch(text[x])
{
case 'b':
Bcnt++;
break;
case 'a':
Acnt++;
break;
case 'l':
Lcnt++;
break;
case 'o':
Ocnt++;
break;
case 'n':
Ncnt++;
break;
default:
break;
}
}
Ocnt = Ocnt / 2; //Divide by 2 since O gets used twice
Lcnt = Lcnt / 2;
//Stick the count values in another array to check for smallest
CntArr[0] = Bcnt;
CntArr[1] = Acnt;
CntArr[2] = Lcnt;
CntArr[3] = Ocnt;
CntArr[4] = Ncnt;
for (int y = 0; y < 5; y++)
{
if (CntArr[y] < lowestIter)
{
lowestIter = CntArr[y];
}
}
return lowestIter;
}

Answer 2

The following proposed code:
cleanly compiles (but due to no main() function, does not link)
performs the desired functionality for any length of input values
lets the caller determine the two arrays rather than being limited just moon
regarding: for( size_t x = 0; availableChars[x]; x++ ) the availableChars[x] will cause the loop to exit when the NUL termination char is encountered.
and now, the proposed code:
#include <string.h>
#include <ctype.h>
#define A_Z_LEN 26
int solution( size_t availableLen, char availableChars[ availableLen ], size_t targetLen, char target[ targetLen ] )
{
char localTarget[ targetLen ];
int retValue = 0;
char alphabetCounts[ A_Z_LEN ] = {'\0'};
// init counts
for( size_t x = 0; availableChars[x]; x++ )
{
alphabetCounts[ tolower( availableChars[x]) ]++;
}
while( 1 )
{
for ( size_t y = 0; y < targetLen; y++)
{
localTarget[y] = (char)tolower( target[y] );
if ( alphabetCounts[ localTarget[y] - 'a' ] > 0 )
{
alphabetCounts[ tolower( target[ y ] ) - 'a' ]--;
}
else
{
return retValue;
}
}
retValue++;
}
return retValue;
}