Merge pull request ashutosh97#56 from masakotoda/hacktoberfest

Magic Spell (Longest Common Subsequence)

Author: ashutosh97

Magic-Spells-LCS/problem.txt

@@ -0,0 +1,19 @@
+This is from https://www.hackerrank.com/challenges/magic-spells/problem
+
+You are battling a powerful dark wizard. He casts his spells from a distance, giving you only a few seconds to react and conjure
+your counterspells. For a counterspell to be effective, you must first identify what kind of spell you are dealing with.
+
+The wizard uses scrolls to conjure his spells, and sometimes he uses some of his generic spells that restore his stamina. In that
+case, you will be able to extract the name of the scroll from the spell. Then you need to find out how similar this new spell is
+to the spell formulas written in your spell journal.
+
+
+Input Format
+The wizard will read  scrolls, which are hidden from you.
+Every time he casts a spell, it's passed as an argument to your counterspell function.
+
+
+Output Format
+After identifying the given spell, print its name and power.
+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.

Magic-Spells-LCS/solution.cpp

@@ -0,0 +1,142 @@
+#include <iostream>
+#include <vector>
+#include <string>
+using namespace std;
+
+class Spell { 
+    private:
+        string scrollName;
+    public:
+        Spell(): scrollName("") { }
+        Spell(string name): scrollName(name) { }
+        virtual ~Spell() { }
+        string revealScrollName() {
+            return scrollName;
+        }
+};
+
+class Fireball : public Spell { 
+    private: int power;
+    public:
+        Fireball(int power): power(power) { }
+        void revealFirepower(){
+            cout << "Fireball: " << power << endl;
+        }
+};
+
+class Frostbite : public Spell {
+    private: int power;
+    public:
+        Frostbite(int power): power(power) { }
+        void revealFrostpower(){
+            cout << "Frostbite: " << power << endl;
+        }
+};
+
+class Thunderstorm : public Spell { 
+    private: int power;
+    public:
+        Thunderstorm(int power): power(power) { }
+        void revealThunderpower(){
+            cout << "Thunderstorm: " << power << endl;
+        }
+};
+
+class Waterbolt : public Spell { 
+    private: int power;
+    public:
+        Waterbolt(int power): power(power) { }
+        void revealWaterpower(){
+            cout << "Waterbolt: " << power << endl;
+        }
+};
+
+class SpellJournal {
+    public:
+        static string journal;
+        static string read() {
+            return journal;
+        }
+}; 
+string SpellJournal::journal = "";
+
+void counterspell(Spell *spell) {
+
+    /* Enter your code here */
+    if (auto f = dynamic_cast<Fireball*>(spell)) {
+        f->revealFirepower();
+    }
+    else if (auto f = dynamic_cast<Frostbite*>(spell)) {
+        f->revealFrostpower();
+    }
+    else if (auto f = dynamic_cast<Thunderstorm*>(spell)) {
+        f->revealThunderpower();
+    }
+    else if (auto f = dynamic_cast<Waterbolt*>(spell)) {
+        f->revealWaterpower();
+    }
+    else {
+        auto find = [](const string& A, const string& B) -> int
+        {
+            std::vector<std::vector<int>> LCS(A.length() + 1);        
+            for (int i = 0; i < LCS.size(); i++)
+                LCS[i].resize(B.length() + 1);
+            
+            for (int i = 1; i <= A.length(); i++) {
+                for (int j = 1; j <= B.length(); j++) {
+                    if (A[i - 1] == B[j - 1]) {
+                        LCS[i][j] = LCS[i - 1][j - 1] + 1;
+                    }
+                    else {
+                        LCS[i][j] = max(LCS[i - 1][j], LCS[i][j - 1]);
+                    }
+                }
+            }
+            return LCS[A.length()][B.length()];
+        };
+
+        string s1 = spell->revealScrollName();
+        string s2 = SpellJournal::read();
+        int len = 0;
+        if (s1.length() > 0 && s2.length() > 0)
+            len = find(&s1[0], &s2[0]);
+        cout << len << endl;
+    }
+}
+
+class Wizard {
+    public:
+        Spell *cast() {
+            Spell *spell;
+            string s; cin >> s;
+            int power; cin >> power;
+            if(s == "fire") {
+                spell = new Fireball(power);
+            }
+            else if(s == "frost") {
+                spell = new Frostbite(power);
+            }
+            else if(s == "water") {
+                spell = new Waterbolt(power);
+            }
+            else if(s == "thunder") {
+                spell = new Thunderstorm(power);
+            } 
+            else {
+                spell = new Spell(s);
+                cin >> SpellJournal::journal;
+            }
+            return spell;
+        }
+};
+
+int main() {
+    int T;
+    cin >> T;
+    Wizard Arawn;
+    while(T--) {
+        Spell *spell = Arawn.cast();
+        counterspell(spell);
+    }
+    return 0;
+}