Exactly my thought, it's two problems in one. I came for inheritance but I found the most complex part was the LCS.

Exactly. LCS is the only algorithm to implement here, it has nothing to do with C++ language knowledge. This exercise should be broken into 2 parts.

Exactly. LCS is the only algorithm to implement here, it has nothing to do with C++ language knowledge. This exercise should be broken into 2 parts.

Very true. Also didn't think I'd see Peter Sommerlad here!

I feel like I've been seeing a lot of red flags like this in the discussion for almost every question. It does make me pretty concerned since I'm using this site to practice for interviews. Does anyone have other suggestions for websites or books to practice C++?

Hi Alexhans,
check the wikipedia page for the Longest Common Subsequent problem: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
You have to find the length of the longest subsequence common to the both of the strings, and it's different from the problem of finding common substrings: unlike substrings, subsequences are not required to occupy consecutive positions.

Subsequence definition: "In mathematics, a subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements".

Consider X = XMJYAUZ and Y = MZJAWXU
The longest common subsequence between X and Y is MJAU

As you can see, in the subsequences there can be missing chars (compared to the original strings), but the important thing is that any char in the common subsequence is present in both the input strings (in the same order).

counterspell:

if (Fireball *fb=dynamic_cast<Fireball*>(spell)) {
    fb->revealFirepower();
} 
else if (Frostbite *fz=dynamic_cast<Frostbite*>(spell)) {
    fz->revealFrostpower();
} 
else if (Thunderstorm *ts=dynamic_cast<Thunderstorm*>(spell)) {
    ts->revealThunderpower();
} 
else if (Waterbolt *wb=dynamic_cast<Waterbolt*>(spell)) {
    wb->revealWaterpower();
}
else { // generic spell
    string spellN = spell->revealScrollName();
    string spellJ = SpellJournal::read();
    int m=spellN.length();
    int n=spellJ.length();
    int array[m+1][n+1]; 

    // solve for LCS
    for (int i=0;i<=m;i++) array[i][0]=0;
    for (int j=0;j<=n;j++) array[0][j]=0;
    for (int i=1;i<=m;i++) {
        for (int j=1;j<=n;j++) {
            if (spellN[i-1] == spellJ[j-1])
                array[i][j]=array[i-1][j-1]+1;
            else
                array[i][j]=max(array[i][j-1],array[i-1][j]);
        }
    }  
    cout << array[m][n] << endl; 
}

Exactly! i had never solved LCS non recursively. Quite interesting.

the recursive relation for LCS can naturally be translated to an iterative non-recursive algorithm for successively filling up the memo table of subproblem answers. That can be done with a simple C-style double nested for loop, and doesn't require defining external functions or fancy lambdas / functors.

You can use a local struct type to define a local function within a function:

void counterspell(Spell *spell) {
    ...
    struct A {
        static size_t f(...) { ... }
    };
    size_t lcs = A::f(...);
    cout << lcs << endl;
}

You're supposed to call the non-generic spell's reveal function. eg. revealFrostpower()

Notice that

Spell* spell;

When the new spell is not generic, spell is a pointer to the base class "Spell",but it is pointing to the derived classes (fire,frost,etc...) In order to use the reveal functions, you have to downcast the pointer. You can use dynamic_cast for this.

In the case of generic spells, the pointer is actually pointing to the base class Spell. If you attempt to dynamic_cast this, it will fail and return a null ptr. If you then try to call the reveal functions from the null ptr, you'll get undefined behavior. So you have to write a check for if dynamic cast failed.