add LeetCodeInputTemplate

Author: mkmark

leetcode/.template/main.cpp

@@ -3,22 +3,22 @@ author: [email protected]
 */
 
 #include <bits/stdc++.h>
-#include "../../lib/LeetCodeInput.hpp"
+#include "../../lib/LeetCodeInputTemplate.hpp"
 #include "solution.cpp"
 using namespace std;
 
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
 int main()
 {
     LeetCodeInput li("0.in");
 
-    // vector<vector<int>> mat_1 = li.get_vvi(0);
-    // vector<int> arr_1 = li.get_vi(0);
-    // int num_1 = li.get_i(0);
-    // string s_1 = li.get_s(0);
+    auto l0 = li.get<vvi>(0);
 
     chrono::steady_clock::time_point begin = chrono::steady_clock::now();
     Solution solution;
-    auto output = solution.solution();
+    auto output = solution.solution(l0);
     chrono::steady_clock::time_point end = chrono::steady_clock::now();
     cout << "Time difference = " << chrono::duration_cast<chrono::microseconds> (end - begin).count() << "µs" << endl;
 

leetcode/.template/solution.cpp

@@ -17,7 +17,7 @@ typedef vector<vector<int>> vvi;
 
 class Solution {
 public:
-    int solution() {
+    int solution(vvi l0) {
 
     }
 };

lib/LeetCodeInput.hpp

@@ -1,5 +1,6 @@
 /*
 author: [email protected]
+depreciated, use LeetCodeInputTemplate
 */
 
 #include <bits/stdc++.h>
@@ -14,14 +15,19 @@ class LeetCodeInput{
     vector<string>          r2vr(string& r);
     vector<vector<string>>  r2vvr(string& r);
     vector<int>             vr2vi(vector<string>& vr);
+    vector<char>            vr2vc(vector<string>& vr);
     vector<string>          vr2vs(vector<string>& vr);
     vector<vector<int>>     vvr2vvi(vector<vector<string>>& vvr);
+    vector<vector<char>>    vvr2vvc(vector<vector<string>>& vvr);
     vector<vector<string>>  vvr2vvs(vector<vector<string>>& vvr);
 
     int                     r2i(string& r);
+    char                    r2c(string& r);
     string                  r2s(string& r);
     vector<int>             r2vi(string& r);
+    vector<char>            r2vc(string& r);
     vector<vector<int>>     r2vvi(string& r);
+    vector<vector<char>>    r2vvc(string& r);
     vector<string>          r2vs(string& r);
     vector<vector<string>>  r2vvs(string& r);
 public: 
@@ -35,6 +41,7 @@ class LeetCodeInput{
     string                  get_s(int line)     {return r2s(lines[line]);};
     vector<int>             get_vi(int line)    {return r2vi(lines[line]);};
     vector<vector<int>>     get_vvi(int line)   {return r2vvi(lines[line]);};
+    vector<vector<char>>    get_vvc(int line)   {return r2vvc(lines[line]);};
     vector<string>          get_vs(int line)    {return r2vs(lines[line]);};
     vector<vector<string>>  get_vvs(int line)   {return r2vvs(lines[line]);};
 };
@@ -85,6 +92,10 @@ int LeetCodeInput::r2i(string& r){
     return stoi(r);
 }
 
+char LeetCodeInput::r2c(string& r){
+    return r[1];
+}
+
 string LeetCodeInput::r2s(string& r){
     return r.substr(1, r.size() - 2);;
 }
@@ -103,6 +114,15 @@ vector<int> LeetCodeInput::vr2vi(vector<string>& vr){
     return vi;
 }
 
+vector<char> LeetCodeInput::vr2vc(vector<string>& vr){
+    int n = vr.size();
+    vector<char> vc(n);
+    for (int i=0; i<n; ++i){
+        vc[i] = r2c(vr[i]);
+    }
+    return vc;
+}
+
 vector<string> LeetCodeInput::vr2vs(vector<string>& vr){
     int n = vr.size();
     vector<string> vs(n);
@@ -132,6 +152,15 @@ vector<vector<int>> LeetCodeInput::vvr2vvi(vector<vector<string>>& vvr){
     return vvi;
 }
 
+vector<vector<char>> LeetCodeInput::vvr2vvc(vector<vector<string>>& vvr){
+    int n = vvr.size();
+    vector<vector<char>> vvc(n);
+    for (int i=0; i<n; ++i){
+        vvc[i] = vr2vc(vvr[i]);
+    }
+    return vvc;
+}
+
 vector<vector<string>> LeetCodeInput::vvr2vvs(vector<vector<string>>& vvr){
     int n = vvr.size();
     vector<vector<string>> vvs(n);
@@ -151,6 +180,11 @@ vector<vector<int>> LeetCodeInput::r2vvi(string& r){
     return vvr2vvi(vvr);
 }
 
+vector<vector<char>> LeetCodeInput::r2vvc(string& r){
+    auto vvr = r2vvr(r);
+    return vvr2vvc(vvr);
+}
+
 vector<string> LeetCodeInput::r2vs(string& r){
     auto vr = r2vr(r);
     return vr2vs(vr);

lib/LeetCodeInputTemplate.hpp

@@ -0,0 +1,109 @@
+/*
+author: [email protected]
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+template <class T>
+struct is_std_vector { static const bool value=false; };
+
+template <class T>
+struct is_std_vector<std::vector<T>> { static const bool value=true; };
+
+class LeetCodeInput{
+private:
+    vector<string> get_lines(string &path);
+    vector<string> split(const string &s);
+
+    template <class T>
+    T r2t(string& r);
+
+public: 
+    vector<string> lines;
+
+    LeetCodeInput(string path){
+        lines = get_lines(path);
+    }
+
+    template <class T>
+    T get(int line) {return r2t<T>(lines[line]);};
+
+};
+
+vector<string> LeetCodeInput::get_lines(string &path){
+    string line;
+    vector<string> lines;
+    ifstream input(path);
+    if (input.is_open())
+    {
+        while (getline(input, line))
+        {
+            lines.push_back(line);
+        }
+        input.close();
+    }
+    return lines;
+}
+
+vector<string> LeetCodeInput::split (const string &s) {
+    vector<string> result;
+    int level=0;
+    if (s == "[]"){
+        return result;
+    } else {
+        result.push_back("");
+    }
+    for (auto c : s){
+        switch(c){
+            case '[': 
+                if (level != 0) {
+                    result.back().push_back(c);
+                } 
+                ++level;
+                break;
+            case ']': 
+                if (level != 0) {
+                    result.back().push_back(c);
+                } 
+                --level;
+                break;
+            case ',':
+                if (level == 1) {
+                    result.push_back("");
+                } else {
+                    result.back().push_back(c);
+                }
+                break;
+            default: 
+                result.back().push_back(c);
+                break;
+        }
+    }
+    return result;
+}
+
+template <>
+int LeetCodeInput::r2t(string& r){
+    return stoi(r);
+}
+
+template <>
+char LeetCodeInput::r2t(string& r){
+    return r[1];
+}
+
+template <>
+string LeetCodeInput::r2t(string& r){
+    return r.substr(1, r.size() - 2);
+}
+
+template <class T>
+T LeetCodeInput::r2t(string& r){
+    T res;
+    for (auto e : split(r)){
+        res.push_back(r2t<typename T::value_type>(e));
+    }
+    return res;
+}