Add files via upload

basigu · web-flow · commit 87ae406fd79d · 2022-05-07T20:52:24.000-07:00
Added c# solutions for 1,49,70,217,238,242,347 and 746
diff --git a/csharp/1-Two-Sum.cs b/csharp/1-Two-Sum.cs
@@ -0,0 +1,22 @@
+﻿public class Solution
+{
+    public int[] TwoSum(int[] nums, int target)
+    {
+        var numToIndex = new Dictionary<int, int>();
+        for (var i = 0; i < nums.Length; i++)
+        {
+            var diff = target - nums[i];
+            if (numToIndex.ContainsKey(diff))
+            {
+                return new int[] { i, numToIndex[diff] };
+            }
+            else
+            {
+                numToIndex[nums[i]] = i;
+            }
+        }
+
+        return new int[0];
+    }
+}
+
diff --git a/csharp/217-Contains-Duplicate.cs b/csharp/217-Contains-Duplicate.cs
@@ -0,0 +1,19 @@
+﻿public class Solution
+{
+    public bool ContainsDuplicate(int[] nums)
+    {
+        var hashSet = new HashSet<int>();
+        foreach (var num in nums)
+        {
+            if (hashSet.Contains(num))
+            {
+                return true;
+            }
+            else
+            {
+                hashSet.Add(num);
+            }
+        }
+        return false;
+    }
+}
diff --git a/csharp/238-Product-Except-Self.cs b/csharp/238-Product-Except-Self.cs
@@ -0,0 +1,43 @@
+﻿public class Solution5
+{
+    public int[] TopKFrequent(int[] nums, int k)
+    {
+        var topK = new int[k];
+
+        var numToCount = new Dictionary<int, int>();
+
+        foreach (var num in nums)
+        {
+            if (numToCount.ContainsKey(num))
+            {
+                numToCount[num]++;
+            }
+            else
+            {
+                numToCount[num] = 1;
+            }
+        }
+
+        PriorityQueue<int, int> priorityQueue = new(new ElementComparer());
+
+        foreach (var kv in numToCount)
+        {
+            priorityQueue.Enqueue(kv.Key, kv.Value);
+        }
+
+        for (var i = 0; i < k; i++)
+        {
+            topK[i] = priorityQueue.Dequeue();
+        }
+
+        return topK;
+    }
+}
+
+public class ElementComparer : IComparer<int>
+{
+    public int Compare(int x, int y)
+    {
+        return y - x;
+    }
+}
diff --git a/csharp/242-Valid-Anagram.cs b/csharp/242-Valid-Anagram.cs
@@ -0,0 +1,43 @@
+﻿public class Solution
+{
+    public bool IsAnagram(string s, string t)
+    {
+        var sStrToCount = CreateMap(s);
+        var tStrToCount = CreateMap(t);
+
+        if (sStrToCount.Keys.Count != tStrToCount.Keys.Count)
+        {
+            return false;
+        }
+
+        foreach (var key in sStrToCount.Keys)
+        {
+            if (!tStrToCount.ContainsKey(key))
+            {
+                return false;
+            }
+            if (sStrToCount[key] != tStrToCount[key])
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    Dictionary<char, int> CreateMap(string str)
+    {
+        var dict = new Dictionary<char, int>();
+        foreach (var ch in str)
+        {
+            if (dict.ContainsKey(ch))
+            {
+                dict[ch]++;
+            }
+            else
+            {
+                dict[ch] = 1;
+            }
+        }
+        return dict;
+    }
+}
diff --git a/csharp/347-Top-K-Frequent-Elements.cs b/csharp/347-Top-K-Frequent-Elements.cs
@@ -0,0 +1,43 @@
+﻿public class Solution
+{
+    public int[] TopKFrequent(int[] nums, int k)
+    {
+        var topK = new int[k];
+
+        var numToCount = new Dictionary<int, int>();
+
+        foreach (var num in nums)
+        {
+            if (numToCount.ContainsKey(num))
+            {
+                numToCount[num]++;
+            }
+            else
+            {
+                numToCount[num] = 1;
+            }
+        }
+
+        PriorityQueue<int, int> priorityQueue = new(new ElementComparer());
+
+        foreach (var kv in numToCount)
+        {
+            priorityQueue.Enqueue(kv.Key, kv.Value);
+        }
+
+        for (var i = 0; i < k; i++)
+        {
+            topK[i] = priorityQueue.Dequeue();
+        }
+
+        return topK;
+    }
+}
+
+public class ElementComparer : IComparer<int>
+{
+    public int Compare(int x, int y)
+    {
+        return y - x;
+    }
+}
diff --git a/csharp/49-Group-Anagrams.cs b/csharp/49-Group-Anagrams.cs
@@ -0,0 +1,36 @@
+﻿public class Solution
+{
+    public IList<IList<string>> GroupAnagrams(string[] strs)
+    {
+        IList<IList<string>> result = new List<IList<string>>();
+        if (strs == null || strs.Length == 0)
+        {
+            return result;
+        }
+
+        var encodedStrToValueList = new Dictionary<string, List<string>>();
+        foreach (var str in strs)
+        {
+            var arr = new int[26];
+            foreach (var c in str)
+            {
+                arr[c - 'a']++;
+            }
+            var encodedStr = string.Join('#', arr);
+            if (encodedStrToValueList.ContainsKey(encodedStr))
+            {
+                encodedStrToValueList[encodedStr].Add(str);
+            }
+            else
+            {
+                encodedStrToValueList[encodedStr] = new List<string>() { str };
+            }
+        }
+
+        foreach (var kv in encodedStrToValueList)
+        {
+            result.Add(kv.Value);
+        }
+        return result;
+    }
+}
diff --git a/csharp/70-Climbing-Stairs.cs b/csharp/70-Climbing-Stairs.cs
@@ -0,0 +1,16 @@
+﻿public class Solution
+{
+    public int ClimbStairs(int n)
+    {
+        var oneStep = 1;
+        var twoStep = 1;
+
+        for (var i = 0; i < n - 1; i++)
+        {
+            var temp = oneStep;
+            oneStep = oneStep + twoStep;
+            twoStep = temp;
+        }
+        return oneStep;
+    }
+}
diff --git a/csharp/746-Min-Cost-Climbing-Stairs.cs b/csharp/746-Min-Cost-Climbing-Stairs.cs
@@ -0,0 +1,17 @@
+﻿public class Solution
+{
+    public int MinCostClimbingStairs(int[] cost)
+    {
+        int[] minCost = new int[cost.Length + 1];
+        minCost[minCost.Length - 1] = 0;
+        minCost[minCost.Length - 2] = cost[cost.Length - 1];
+
+        for (var i = minCost.Length - 3; i >= 0; i--)
+        {
+            var oneStep = cost[i] + minCost[i + 1];
+            var twoStep = cost[i] + minCost[i + 2];
+            minCost[i] = Math.Min(oneStep, twoStep);
+        }
+        return Math.Min(minCost[0], minCost[1]);
+    }
+}
