MCS Feb25 Results & Solutions

Tech Geeks Club proudly launched the Monthly Coding Series 2025, a competitive coding event designed to challenge and enhance students’ problem-solving skills. The first edition, held on 24th and 25th February 2025, witnessed enthusiastic participation from B.Tech (CSE), BCA, and MCA students across various academic years.

Winners#

🎉 Congratulations to our coding champions! 🎉

Day 1 Winners#

🥇 Pankaj Sharma (BTech CSE, 6th Sem)
🥈 Nitin Sharma (BTech CSE, 6th Sem)
🥉 Mayank Joshi (BTech CSE, 6th Sem)

Day 2 Winners#

🥇 Abhishek Mehra (BTech, 2nd sem)
🥈 Pankaj Pandey (BCA, 2nd sem B sec)
🥉 Priyanshu Bisht (BCA AI & DS, 2nd Sem)

Questions & Solutions#

Group 1#

Questions: https://www.hackerrank.com/mcs-feb25-g1

1. Longest Word Length (MCS)#

This question was about finding the length of the longest word in a given string.

1
int longest(char* sentence) {
2
    // maximum length of a word
3
    int max = 0;
4

5
    // current length of a word
6
    int length = 0;
7

8
    // iterate over the sentence
9
    for(int i = 0; sentence[i] != '\0'; i++){
10
        // if a space is found word end
11
        if(sentence[i] == ' '){
12
            // check if the current word length is greater than max
13
            max = length > max ? length : max;
14
            // reset the length
15
            length = 0;
16
        } else {
17
            // increment the length
18
            length ++;
19
        }
20
    }
21

22
    // check for the last word (since there is no space at the end)
23
    max = length > max ? length : max;
24

25
    // return the maximum length
26
    return max;
27
}

2. Grains (MCS)#

This question was about finding the sum of grains on the chessboard.

The first box had 1 grain. The second box had 2 grains. The third box had 4 grains. The fourth box had 8 grains. And so on.

Your task was to find the sum of grains up to the box number n.

Naive Solution

1
long grains(long square) {
2
    long sum = 0;
3

4
    for (int i = 1; i < square; i++) {
5
        // since pow returns a double
6
        // typecast it to long
7
        sum += (long) pow(2, i);
8
    }
9

10
    return sum;
11
}

A more optimized solution would be to use the formula 2^n - 1. (Why?)

1
long grains(long square) {
2
    return (long) pow(2, square) - 1;
3
}

An even more optimized solution would be to use bitwise operators.

1
long grains(long square) {
2
    return (1 << square) - 1;
3
}

3. Hamming (MCS)#

This was a fairly easy question. You were given two strings of equal length. And you had to find the number of places where the characters were different.

1
int hamming(char* dna1, char* dna2) {
2
    int diff = 0;
3

4
    // iterate over the strings
5
    // (you can also use strlen)
6
    for(int i = 0; dna1[i] != '\0'; i++) {
7
        // if characters are different
8
        // increment the difference count
9
        if (dna1[i] != dna2[i])
10
            diff++;
11
    }
12

13
    return diff;
14
}

4. RNA Transcription#

This was another “easier” question. Your task was to replace the DNA sequence with its corresponding RNA sequence.

In other words you just had to replace

“G” with “C”
“C” with “G”
“T” with “A”
and “A” with “U”

1
char* complement(char* dna) {
2
    // iterate over the string "dna"
3
    for(int i = 0; dna[i] != '\0'; i++){
4
        // you can use regular if-else
5
        // but switch is more readable
6
        switch(dna[i]){
7
            case 'G':
8
                dna[i] = 'C';
9
                break;
10
            case 'C':
11
                dna[i] = 'G';
12
                break;
13
            case 'T':
14
                dna[i] = 'A';
15
                break;
16
            case 'A':
17
                dna[i] = 'U';
18
                break;
19
        }
20
    }
21

22
    // return the modified dna string
23
    return dna;
24
}

5. Population Growth (MCS)#

This question is my personal favorite. Taken from the Harvard CS50 course.

You were given the initial population, the growth rate, and the target population. Your task was to find the number of years it would take for the population to reach the target population.

Every year

the population grows by 1/3 of last year’s population
and 1/4 of the (last year’s) population dies

That is

Growth = Last Year Population / 3

Deaths = Last Year Population / 4

Current Year Population = Last Year Population + Growth - Deaths

1
int growth(int start, int end) {
2
    int years = 0;
3

4
    while(start < end) {
5
        start += (start / 3) - (start / 4);
6
        years++;
7
    }
8

9
    return years;
10
}

Note to Python folks
The division is truncated. So in python 5/3 would give 1.6666666666666667 but in C it would give 1.
So in python you would have to use // for integer division.

Group 2#

Questions: https://www.hackerrank.com/mcs-feb25-g1

1. Eliud’s Eggs#

This question was fairly simple (if you could understand what it wants).

TLDR it was about how many 1 bits are there in the binary representation of the number.

One way to solve it is to convert the number to binary and count the number of 1s. But that’s not efficient.

A more efficient way is to use bitwise operators.

In the below snippet we are using the bitwise AND operator & to check if the last bit is 1. If it is we increment the eggs count.

Then we discard the last bit by shifting the number to the right by 1. (This is equivalent to dividing the number by 2).

1
// eliud's eggs
2
int count(int display)
3
{
4
    int eggs = 0;
5

6
    // repeat till display != zero
7
    while (display)
8
    {
9
        // if last bit of display is 1
10
        if (display & 1)
11
            eggs++; // increment eggs
12

13
        // discard the last bit
14
        display >>= 1;
15
    }
16

17
    return eggs;
18
}

2. Luhn#

This was also a fairly easy question 😁. The twist was the input was not clean.

If you’ve read the problem statement, it said ignore the spaces, but reject any non digits.

Rest the algorithm was easy, just iterate the string backward, and keep a flag to check if the current digit is the second digit from the right.

1
bool valid(char *number)
2
{
3
    bool flag = false; // for checking every 2nd number
4
    int sum = 0;
5
    // reverse traverse string;
6
    for (int i = strlen(number) - 1; i >= 0; i--)
7
    {
8
        if ('0' <= number[i] && number[i] <= '9')
9
        {
10
            int digit = number[i] - '0';
11
            if (flag)
12
            {
13
                digit *= 2;
14
                sum += digit > 9 ? digit - 9 : digit;
15
            }
16
            else
17
            {
18
                sum += digit;
19
            }
20
            // reverse flag
21
            flag = !flag;
22
        }
23
        else if (number[i] == ' ')
24
        {
25
            // ignore spaces
26
            continue;
27
        }
28
        else
29
        {
30
            // no non digit character allowed
31
            return false;
32
        }
33
    }
34

35
    return sum % 10 == 0;
36
}

3. Matching Brackets (MCS)#

This was a classic Stack problem. Let the solution speak for itself.

1
bool valid(char *sequence)
2
{
3
    char stack[100] = {0}; // initialized a stack
4
    int top = -1;
5

6
    // iterate over string
7
    for (; *sequence != '\0'; sequence++)
8
    {
9
        switch (*sequence)
10
        {
11
        case '(':
12
        case '{':
13
        case '[':
14
            stack[++top] = *sequence;
15
            break;
16
        case ')':
17
            if (stack[top] == '(')
18
                top--;
19
            else
20
                return false;
21
            break;
22
        case '}':
23
            if (stack[top] == '{')
24
                top--;
25
            else
26
                return false;
27
            break;
28
        case ']':
29
            if (stack[top] == '[')
30
                top--;
31
            else
32
                return false;
33
            break;
34
        }
35
    }
36

37
    return top < 0; // is stack empty?
38
}

4. Sublist (MCS)#

This was another simp… okay, this was fairly hard TBH. If you’ve read the problem carefully, you would’ve recognized its the classic Substring problem (taught is Algorithms classes).

There are various optimal solution for this (KMP, Rabin Karp etc, you can look them up), but here I’ll be showing the bruteforce approach.

1
// hackerrank did a horrendous job naming the "size" variable of the lists in C
2
bool sublist(int a_count, int *a, int b_count, int *b)
3
{
4
    // if size of a is greater than b
5
    // then a can't be a sublist of b
6
    if (b_count < a_count)
7
        return false;
8

9
    // flag to check if a is sublist of b
10
    bool is_sublist = true;
11

12
    for (int i = 0; i <= b_count - a_count; i++)
13
    {
14
        // reset the flag for every iteration
15
        is_sublist = true;
16

17
        // check if a is equal to b[ i : i+ size of a]
18
        for (int j = 0; j < a_count; j++)
19
        {
20
            if (a[j] != b[i + j])
21
            {
22
                is_sublist = false;
23
                break;
24
            }
25
        }
26
        // if a is sublist of b
27
        // no need to check further
28
        if (is_sublist)
29
            return true;
30
    }
31

32
    return is_sublist;
33
}

5. Queen Attack (MCS)#

Back to geometry class.

Queen can attack if the lie in the same line vertically or horizontally. Or when they lie in the same diagonal.

Horizontal or vertical check is simple, just check if the x or y coordinates are same.

For diagonal check, the difference between the x and y coordinates should be same. (Why?.. Trigonometry 😁)

But!!! There’s a catch, the coordinates can only lie between 0 and 8. (Bet you didn’t see that coming).

1
bool can_attack(int q1_x, int q1_y, int q2_x, int q2_y)
2
{
3
    // coordinates can only lie between 0 and 8
4
    if (!(0 < q1_x && q1_x < 8) ||
5
        !(0 <= q1_y && q1_y <= 8) ||
6
        !(0 <= q2_x && q2_x <= 8) ||
7
        !(0 <= q2_y && q2_y <= 8))
8
        return false;
9

10
    // vertical and horizontal attack
11
    if ((q1_x == q2_x) || (q1_y == q2_y))
12
        return true;
13

14
    // lateral attack
15
    return abs(q1_x - q2_x) == abs(q1_y - q2_y);
16
}

6. Largest Series Product#

To the Sliding Window.

We start with a “window” containing 0 elements. We keep adding elements to the window until the window size is equal to the given span.

Next we calculate the product of the elements in the window and compare it with the maximum product found so far.

Then we remove the first element from the window and repeat the process.

(Might need a youtube video to explain this 😅, look it up)

1
int largest_product(char *digits, int span)
2
{
3
    // If span is 0 just return 1
4
    // Why (The same why 0! = 1)
5
    if (span == 0)
6
        return 1;
7

8
    // maximum product found
9
    int max_product = 0;
10

11
    // first and last index of window
12
    int first = 0, last = 0;
13
    // current window product
14
    int current = 1;
15

16
    while (last < strlen(digits))
17
    {
18
        int digit = digits[last] - '0';
19
        last++;
20

21
        if (digit == 0)
22
        {
23
            first = last;
24
            current = 1;
25
        }
26
        else
27
        {
28
            current *= digit;
29
            // if current window size == span
30
            if (last - first == span)
31
            {
32
                max_product = max_product > current ? max_product : current;
33
                // remove the first element from the product
34
                current /= digits[first] - '0';
35
                first++;
36
            }
37
        }
38
    }
39

40
    return max_product;
41
}

This was the first edition of the Monthly Coding Series 2025. We hope you had a great time participating in the event. Stay tuned for the next edition.