new soln

Author: shreymehul

148.SortList.cs

@@ -0,0 +1,40 @@
+// 148. Sort List
+// Given the head of a linked list, return the list after sorting it in ascending order.
+// Example 1:
+// Input: head = [4,2,1,3]
+// Output: [1,2,3,4]
+// Example 2:
+// Input: head = [-1,5,3,4,0]
+// Output: [-1,0,3,4,5]
+// Example 3:
+// Input: head = []
+// Output: []
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode SortList(ListNode head) {
+        List<int> list = new List<int>();
+        ListNode temp = head;
+        while(temp!=null){
+            list.Add(temp.val);
+            temp = temp.next;
+        }
+        list.Sort();
+        temp = head;
+        foreach(var item in list){
+            temp.val = item;
+            temp = temp.next;
+        }
+        return head;
+    }
+}

2225.FindWinners.cs

@@ -0,0 +1,55 @@
+// 2225. Find Players With Zero or One Losses
+// You are given an integer array matches where matches[i] = [winneri, loseri] indicates that the player winneri defeated player loseri in a match.
+// Return a list answer of size 2 where:
+// answer[0] is a list of all players that have not lost any matches.
+// answer[1] is a list of all players that have lost exactly one match.
+// The values in the two lists should be returned in increasing order.
+// Note:
+// You should only consider the players that have played at least one match.
+// The testcases will be generated such that no two matches will have the same outcome.
+// Example 1:
+// Input: matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]]
+// Output: [[1,2,10],[4,5,7,8]]
+// Explanation:
+// Players 1, 2, and 10 have not lost any matches.
+// Players 4, 5, 7, and 8 each have lost one match.
+// Players 3, 6, and 9 each have lost two matches.
+// Thus, answer[0] = [1,2,10] and answer[1] = [4,5,7,8].
+// Example 2:
+// Input: matches = [[2,3],[1,3],[5,4],[6,4]]
+// Output: [[1,2,5,6],[]]
+// Explanation:
+// Players 1, 2, 5, and 6 have not lost any matches.
+// Players 3 and 4 each have lost two matches.
+// Thus, answer[0] = [1,2,5,6] and answer[1] = [].
+
+public class Solution {
+    public IList<IList<int>> FindWinners(int[][] matches) {
+        Dictionary<int,int> stats = new Dictionary<int,int>();
+        foreach(var item in matches){
+            if(!stats.ContainsKey(item[0])){
+                stats[item[0]] = 0;
+            }
+            if(stats.ContainsKey(item[1])){
+                stats[item[1]]++;
+            }
+            else{
+                stats[item[1]] = 1;
+            }
+        }
+        IList<IList<int>> result = new List<IList<int>>();
+        List<int> l1 = new List<int>();
+        List<int> l2 = new List<int>();
+        foreach(var item in stats){
+            if(item.Value == 0)
+                l1.Add(item.Key);
+            if(item.Value == 1)
+                l2.Add(item.Key);
+        }
+        l1.Sort();
+        l2.Sort();
+        result.Add(l1);
+        result.Add(l2);
+        return result;
+    }
+}

692.TopKFrequent.cs

@@ -0,0 +1,28 @@
+// 692. Top K Frequent Words
+// Given an array of strings words and an integer k, return the k most frequent strings.
+// Return the answer sorted by the frequency from highest to lowest. Sort the words with the same frequency by their lexicographical order.
+// Example 1:
+// Input: words = ["i","love","leetcode","i","love","coding"], k = 2
+// Output: ["i","love"]
+// Explanation: "i" and "love" are the two most frequent words.
+// Note that "i" comes before "love" due to a lower alphabetical order.
+// Example 2:
+// Input: words = ["the","day","is","sunny","the","the","the","sunny","is","is"], k = 4
+// Output: ["the","is","sunny","day"]
+// Explanation: "the", "is", "sunny" and "day" are the four most frequent words, with the number of occurrence being 4, 3, 2 and 1 respectively.
+
+public class Solution {
+    public IList<string> TopKFrequent(string[] words, int k) {
+        Dictionary<string,int> freq = new Dictionary<string,int>();
+        foreach(var item in words){
+            if(freq.ContainsKey(item))
+                freq[item]++;
+            else
+                freq[item] = 1;
+        }
+        List<string> res = freq.OrderByDescending(x => x.Value)
+                                .ThenBy(x => x.Key)
+                                .Select(x => x.Key).Take(k).ToList();
+        return res;
+    }
+}

994.OrangesRotting.cs

@@ -0,0 +1,60 @@
+// 994. Rotting Oranges
+// You are given an m x n grid where each cell can have one of three values:
+// 0 representing an empty cell,
+// 1 representing a fresh orange, or
+// 2 representing a rotten orange.
+// Every minute, any fresh orange that is 4-directionally adjacent to a rotten orange becomes rotten.
+// Return the minimum number of minutes that must elapse until no cell has a fresh orange. If this is impossible, return -1.
+// Example 1:
+// Input: grid = [[2,1,1],[1,1,0],[0,1,1]]
+// Output: 4
+// Example 2:
+// Input: grid = [[2,1,1],[0,1,1],[1,0,1]]
+// Output: -1
+// Explanation: The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.
+// Example 3:
+// Input: grid = [[0,2]]
+// Output: 0
+// Explanation: Since there are already no fresh oranges at minute 0, the answer is just 0.
+
+public class Solution {
+    public int OrangesRotting(int[][] grid) {
+        int time = 0;
+        int countFresh = 0;
+        int[] X = new int[]{1,-1,0,0};
+        int[] Y = new int[]{0,0,1,-1};
+        Queue<(int,int)> queue = new Queue<(int,int)>();
+        for(int i = 0; i < grid.Length; i++){
+            for(int j = 0; j < grid[0].Length; j++){
+                if(grid[i][j] == 2)
+                    queue.Enqueue((i,j));
+                else if(grid[i][j] == 1)
+                    countFresh++;
+            }
+        }
+        if(countFresh == 0) return 0;
+        while(queue.Count > 0){
+            ++time;
+            int size = queue.Count();
+            while(size > 0){
+                (int x, int y) = queue.Dequeue();
+                for(int i = 0; i < 4; i++){
+                    if(!IsValid(grid,X[i]+x,Y[i]+y))
+                        continue;
+                    grid[X[i]+x][Y[i]+y] = 2;
+                    queue.Enqueue((X[i]+x,Y[i]+y));
+                    countFresh--;
+                }
+                size--;
+            }
+        }
+        
+        return countFresh == 0 ? time-1 : -1;
+    }
+    public bool IsValid(int[][]grid, int row, int col){
+        if(row < 0 || col < 0 || row >= grid.Length || col >= grid[0].Length
+          || grid[row][col] == 0 || grid[row][col] == 2)
+            return false;
+        return true;
+    }
+}