What's the point of embedding the LCS problem in this dynamic-cast mystery problem?

All most all code examples in hackerrank C++ are

1. Lacking proper variable naming conventions.
2. Lacking proper const conrrectness and use of const refereces where ever possible.
3. careless use of copy and having too many memory leaks. 4.Lot of redundancy in problem information ex:- some problems give you length of string as input and then the string. why ? you can find the length directly from the string alone.

These do become important when you do real world programming for production quality code.

just FYI:-

Note: This is a very bad code example!

The code is producing memory leaks!!! none of the cast spells is ever deallocated in main. Do not do that! if you need a polymorphic return use std::shared_ptr and make_shared or unique_ptr and make_unique.

The great problem with this test is that the english words used are trick and cause difficults to non-english native speakers to understand.

Pretty annoyed at this problem! Not for the first time a challenge on here has assumed other knowledge but barely hinted at what it required. It signposts the obvious (almost to the point of being patronising) that casting is required, but fails to mention LCS (which I'd never heard of prior to coming on this page). To rub it in, I later find out it is one of the algorithm challenges.

WHERE WAS THE LINK?!

I think I'd still be trying to solve this problem this time next year if I hadn't been for the hints on this page.

I tried this out yesterday and can't seem to grok the criteria for:

"If it is a generic spell, find a subsequence of letters that are contained in both the spell name and your spell journal. Among all such subsequences, find and print the length of the longest one on a new line."

They're definitely not continued subsequences, and I thought it would be shared letters in order but that's not right, either.

Can anyone specify the constraint in a clear manner?

This challenge is very misleading. The most difficult portion is not the part about inheritance; that's an afterthought. Instead, the most difficult portion is about subsequences (not even contiguous subsequences), making it way more of an algorithms problem. It took me a long time to think of a solution.

Hint for those other readers: The best you can do it O(n*m). Consider "the longest subsequence you could find" for a given (contiguous) substring of the scrollname and a given (contiguous) substring of the journal.

I decided to read the discussion page before solving the actual problem since I can't believe what I see.

The most interesting part is not that you have to solve the LCS problem which is, by the way, much more complicated than dynamic casts in C++. The real fun begins when you realize that the only thing that you can edit is the body of a single function!

This means that you can't use recursion solving the LCS! You must unroll the structure of the problem "by hand" using some array, as it was shown below. I tried some tricks with local lambdas or std::function which didn't work, especially that I cannot include the header "functional". But maybe I didn't try hard enough :)

This is just crazy...

It is a simple problem just made hard to understand. Fantasy fiction writers are making programming challenges on harckerrank.

Although the memory's not deallocated in the main function, it's not a big issue in this test problem.

void counterspell(Spell *spell) {    
    Fireball *foo1 = dynamic_cast<Fireball*>(spell);
    Frostbite *foo2 = dynamic_cast<Frostbite*>(spell);
    Waterbolt *foo3 = dynamic_cast<Waterbolt*>(spell);
    Thunderstorm *foo4 = dynamic_cast<Thunderstorm*>(spell);
    if(foo1 != NULL) {
        foo1->revealFirepower();
    }
    else if(foo2 != NULL) {
        foo2->revealFrostpower();
    }
    else if(foo3 != NULL) {
        foo3->revealWaterpower();
    }
    else if(foo4 != NULL) {
        foo4->revealThunderpower();
    }
    else {
        string X = spell->revealScrollName();
        string Y = SpellJournal::read();
        int m = X.size();
        int n = Y.size();
        int L[m+1][n+1];
        int i, j;
        for (i = 0; i <= m; i++) {
            for (j = 0; j <= n; j++) {
                if (i == 0 || j == 0)
                    L[i][j] = 0; 
                else if (X[i-1] == Y[j-1])
                    L[i][j] = L[i-1][j-1] + 1;
                else
                    L[i][j] = max(L[i-1][j], L[i][j-1]);
            }
        }
        cout << L[m][n] << endl;            
    }
}