Merge pull request #281 from hellomrsun/master

Add C# solutions

Author: hellomrsun

README.md

@@ -13,6 +13,9 @@ Solutions in various programming languages are provided. Enjoy it.
 4. [Partition Labels](https://github.com/AlgoStudyGroup/Leetcode/tree/master/September-LeetCoding-Challenge/04-Partition-Labels)
 5. [All Elements in Two Binary Search Trees](https://github.com/AlgoStudyGroup/Leetcode/tree/master/September-LeetCoding-Challenge/05-All-Elements-in-Two-Binary-Search-Trees)
 6. [Image Overlap](https://github.com/AlgoStudyGroup/Leetcode/tree/master/September-LeetCoding-Challenge/06-Image-Overlap)
+7. [Word Pattern](https://github.com/AlgoStudyGroup/Leetcode/tree/master/September-LeetCoding-Challenge/07-Word-Pattern)
+8. [Sum of Root To Leaf Binary Numbers](https://github.com/AlgoStudyGroup/Leetcode/tree/master/September-LeetCoding-Challenge/08-Sum-of-Root-To-Leaf-Binary-Numbers)
+9. [Compare Version Numbers](https://github.com/AlgoStudyGroup/Leetcode/tree/master/September-LeetCoding-Challenge/09-Compare-Version-Numbers)
 
 ## August LeetCoding Challenge
 Click [here](https://leetcode.com/explore/challenge/card/august-leetcoding-challenge/) for problem descriptions.

September-LeetCoding-Challenge/07-Word-Pattern/Word-Pattern.cs

@@ -0,0 +1,29 @@
+public class Solution {
+    public bool WordPattern(string pattern, string str) {
+            var words = str.Split(" ");
+
+            if (pattern.Length != words.Length) return false;
+
+            var dict = new Dictionary<char, string>();
+
+            for (int i = 0; i < words.Length; i++)
+            {
+                char c = pattern[i]; //Positionning char
+
+                if (dict.ContainsKey(c))
+                {
+                    if (dict[c] != words[i])
+                        return false;
+                }
+                else
+                {
+                    if (dict.ContainsValue(words[i]))
+                        return false;
+
+                    dict.Add(c, words[i]);
+                }
+            }
+
+            return true;
+    }
+}

September-LeetCoding-Challenge/08-Sum-of-Root-To-Leaf-Binary-Numbers/Sum-of-Root-To-Leaf-Binary-Numbers.cs

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public int SumRootToLeaf(TreeNode root) {
+        if(root == null) return 0;
+        
+        return Traverse(root, 0);
+    }
+    
+    private int Traverse(TreeNode node, int v){
+        if(node == null) {
+            return 0;
+        }
+        
+        v = v * 2 + node.val;
+        
+        return node.left == node.right ? v : Traverse(node.left, v) + Traverse(node.right, v);
+    }
+}

September-LeetCoding-Challenge/09-Compare-Version-Numbers/Compare-Version-Numbers.cs

@@ -0,0 +1,31 @@
+public class Solution {
+    public int CompareVersion(string version1, string version2) {       
+        var v1parts = version1.Split(".").ToList();
+        var v2parts = version2.Split(".").ToList();
+        
+        if(v1parts.Count != v2parts.Count){
+            while(v1parts.Count < v2parts.Count)
+            {
+                v1parts.Add("0");
+            }
+            while(v1parts.Count > v2parts.Count)
+            {
+                v2parts.Add("0");
+            }
+        }
+        
+        for(int i=0; i<v1parts.Count; i++){
+            var v1 = int.Parse(v1parts[i]);
+            var v2 = int.Parse(v2parts[i]);
+            if(v1 > v2){
+                return 1;
+            }else if(v1 == v2){
+                continue;
+            }else if(v1 < v2){
+                return -1;
+            }
+        }
+        
+        return 0;
+    }
+}