leet code

Author: chao.yang

.idea/.gitignore

@@ -0,0 +1,70 @@
+#include <memory>
+#include <vector>
+using namespace std;
+class Solution {
+public:
+    vector<string> printVertically(string s) {
+        int totalNum = 0;
+        int indexs[202];
+        indexs[0] = 0;
+        int lengths[202];
+        int length = s.size();
+        bool startCheck = true;
+        int maxSubLen = 0;
+        for(size_t i = 0; i < length; i++)
+        {
+            if(s[i] != ' ' && startCheck)
+            {
+                indexs[++totalNum] = i;
+                lengths[totalNum - 1] = indexs[totalNum]  - 1;
+                maxSubLen = max(maxSubLen, indexs[totalNum] - indexs[totalNum - 1] - 1);
+                startCheck = false;
+            }
+            else if(s[i] == ' ')
+            {
+                startCheck = true;
+            }
+        }
+
+
+        indexs[++totalNum] = s.size() + 1;
+        lengths[totalNum - 1] = indexs[totalNum]  - 1;
+        maxSubLen = max(maxSubLen, indexs[totalNum] - indexs[totalNum - 1] - 1);
+
+        std::vector<std::string> res;
+        for(size_t j = 0; j < maxSubLen; j++)
+        {
+            std::string tmp(totalNum - 1, ' ');
+            int lastEmpty = -1;
+            for(size_t k = 1; k < totalNum; k++)
+            {
+                if(indexs[k] < lengths[k])
+                {
+                    auto c = s[indexs[k]];
+                    tmp[k - 1] = c;
+                    if(c != ' ')
+                    {
+                        lastEmpty = k - 1;
+                    }
+                    indexs[k] += 1;
+
+                }
+            }
+            tmp.resize(lastEmpty + 1);
+            res.emplace_back(tmp);
+        }
+
+        return  res;
+
+    }
+};
+
+#include <iostream>
+int main()
+{
+    auto result = Solution().printVertically("HOW U AK");
+    for(auto& s: result)
+    {
+        std::cout << s << std::endl;
+    }
+}

.idea/.name

@@ -0,0 +1,76 @@
+//
+// Created by Administrator on 07/05/2020.
+//
+#include <vector>
+#include <unordered_map>
+using namespace std;
+
+class Node {
+public:
+    int val;
+    vector<Node*> neighbors;
+
+    Node() {
+        val = 0;
+        neighbors = vector<Node*>();
+    }
+
+    Node(int _val) {
+        val = _val;
+        neighbors = vector<Node*>();
+    }
+
+    Node(int _val, vector<Node*> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+};
+
+class Solution {
+public:
+    Node* cloneGraph(Node* node) {
+        if (node == nullptr)
+        {
+            return nullptr;
+        }
+        Node* newNode = new Node(node->val, node->neighbors);
+        map_[newNode->val] = newNode;
+        cloneNeighbors(newNode);
+        map_.clear();
+        return newNode;
+    }
+
+
+    void cloneNeighbors(Node* newNode)
+    {
+        auto& neighbors = newNode->neighbors;
+        for(size_t i = 0; i < neighbors.size(); i++)
+        {
+            auto neighbor = neighbors.at(i);
+            if(map_.find(neighbor->val) != map_.end())
+            {
+                neighbors[i] = map_[neighbor->val];
+            }
+            else
+            {
+                Node* n = new Node(neighbor->val, neighbor->neighbors);
+                map_[neighbor->val] = n;
+                neighbors[i] = n;
+                cloneNeighbors(n);
+            }
+        }
+    }
+private:
+    unordered_map<int, Node*> map_;
+};
+
+int main()
+{
+    Node* one = new Node(1);
+    Node* two = new Node(2);
+
+    one->neighbors = vector<Node*>{two};
+    two->neighbors = vector<Node*>{one};
+
+    Solution().cloneGraph(one);
+}

.idea/leetcode.iml

@@ -0,0 +1,96 @@
+//
+// Created by Administrator on 06/05/2020.
+//
+
+#include <unordered_map>
+#include <list>
+using namespace std;
+class LRUCache {
+public:
+    LRUCache(int capacity):
+        capacity_(capacity)
+    {
+
+    }
+
+    int get(int key) {
+        if(map_.find(key) == map_.end())
+        {
+            return -1;
+        }
+
+        auto it = map_[key];
+
+        auto nodePointer = *it;
+        list_.erase(it);
+        list_.push_front(nodePointer);
+        map_[key] = list_.begin();
+        return nodePointer->value;
+    }
+
+    void put(int key, int value) {
+        if(capacity_ <= 0)
+        {
+            return;
+        }
+
+        if(map_.find(key) == map_.end())
+        {
+            if(list_.size() >= capacity_)
+            {
+                auto it = --list_.end();
+                auto nodePointer = *it;
+                map_.erase(map_.find(nodePointer->key));
+                list_.pop_back();
+
+                delete nodePointer;
+            }
+            list_.push_front(new ListNode(key, value));
+            map_[key] = list_.begin();
+        }
+        else{
+            auto it = map_[key];
+            auto nodePointer = *it;
+            nodePointer->value = value;
+            list_.erase(it);
+            list_.push_front(nodePointer);
+            map_[key] = list_.begin();
+        }
+    }
+
+private:
+    struct ListNode{
+        int key;
+        int value;
+        ListNode(int k, int v):
+                key(k),
+                value(v)
+        {
+
+        }
+    };
+    list<ListNode*> list_;
+    using MyIterator = list<ListNode*>::iterator;
+    unordered_map<int, MyIterator> map_;
+    int capacity_;
+};
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache* obj = new LRUCache(capacity);
+ * int param_1 = obj->get(key);
+ * obj->put(key,value);
+ */
+
+#include <iostream>
+int main()
+{
+    LRUCache cache(2);
+
+    cache.put(2, 1);
+    cache.put(2, 2);
+    std::cout << cache.get(2) << std::endl;
+    cache.put(1, 1);
+    cache.put(4, 1);
+    std::cout << cache.get(2) << std::endl;
+}

.idea/misc.xml

@@ -0,0 +1,27 @@
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(nullptr) {}
+};
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* sortList(ListNode* head) {
+        // last pivot current
+        ListNode* middle = findMiddle(head, nullptr, head->val);
+        return nullptr;
+    }
+
+    ListNode* findMiddle(ListNode* start, ListNode* end, int pivot)
+    {
+       return nullptr;
+    }
+
+};

.idea/modules.xml

@@ -0,0 +1,69 @@
+#include <iostream>
+#include <memory>
+using namespace std;
+class Solution {
+public:
+    string reverseWords(string s) {
+        
+        std::string output;
+        output.reserve(s.size());
+
+        int outputIndex = 0;
+        int inputIndex = s.size() - 1;
+        int endIndex = 0;
+        int startIndex = 0;
+        bool hasLast = false;
+        while(true)
+        {
+            endIndex = findNextNoneSpacePos(s, inputIndex);
+            if(endIndex >= 0)
+            {
+                if(hasLast)
+                {
+                    output[outputIndex++] = ' ';
+                }
+                startIndex = findNextSpacePos(s, endIndex - 1);
+                memcpy((void *) (output.data() + outputIndex), s.data() + startIndex + 1, endIndex - startIndex);
+                outputIndex += (endIndex - startIndex);
+                inputIndex = startIndex - 1;
+                hasLast = true;
+            }
+            else
+            {
+                break;
+            }
+        }
+        output[outputIndex] = '\0';
+        return output;
+    }
+
+    int findNextSpacePos(string const& s, int index)
+    {
+
+        for(int i = index; i >= 0; i--)
+        {
+            if(s[i] == ' ')
+            {
+                return i;
+            }
+        }
+        return -1;
+    }
+    int findNextNoneSpacePos(string const& s, int index)
+    {
+        for(int i = index; i >= 0; i--)
+        {
+            if(s[i] != ' ')
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+};
+int main()
+{
+    std::cout << Solution().reverseWords("a good   example").c_str() << std::endl;
+}