new soln

Author: shreymehul

1002.CommonChars.cs

@@ -0,0 +1,36 @@
+// 1002. Find Common Characters
+// Given a string array words, return an array of all characters that show up in all strings within the words (including duplicates). You may return the answer in any order.
+
+// Example 1:
+// Input: words = ["bella","label","roller"]
+// Output: ["e","l","l"]
+// Example 2:
+// Input: words = ["cool","lock","cook"]
+// Output: ["c","o"]
+
+// Constraints:
+// 1 <= words.length <= 100
+// 1 <= words[i].length <= 100
+// words[i] consists of lowercase English letters.
+
+public class Solution {
+    public IList<string> CommonChars(string[] words) {
+        int[] minFreq = new int[26];
+        Array.Fill(minFreq, Int32.MaxValue);
+        foreach(var word in words){
+            int[] freq = new int[26];
+            foreach(char c in word)
+                freq[c - 'a']++;
+            for(int i = 0; i < 26; i++)
+                minFreq[i] = Math.Min(minFreq[i], freq[i]);
+        }
+        IList<string> result = new List<string>();
+        for(int i = 0; i < 26; i++){
+            if(minFreq[i] < Int32.MaxValue){
+                for(int j = 0; j < minFreq[i]; j++)
+                    result.Add(((char)('a'+i)).ToString());
+            }
+        }
+        return result;
+    }
+}

1296.IsPossibleDivide.cs

@@ -0,0 +1,51 @@
+// 1296. Divide Array in Sets of K Consecutive Numbers
+// Given an array of integers nums and a positive integer k, check whether it is possible to divide this array into sets of k consecutive numbers.
+// Return true if it is possible. Otherwise, return false.
+
+// Example 1:
+// Input: nums = [1,2,3,3,4,4,5,6], k = 4
+// Output: true
+// Explanation: Array can be divided into [1,2,3,4] and [3,4,5,6].
+// Example 2:
+// Input: nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
+// Output: true
+// Explanation: Array can be divided into [1,2,3] , [2,3,4] , [3,4,5] and [9,10,11].
+// Example 3:
+// Input: nums = [1,2,3,4], k = 3
+// Output: false
+// Explanation: Each array should be divided in subarrays of size 3.
+
+// Constraints:
+// 1 <= k <= nums.length <= 105
+// 1 <= nums[i] <= 109
+
+public class Solution {
+    public bool IsPossibleDivide(int[] nums, int k) {
+        if(nums.Length%k != 0)
+            return false;
+        
+        Array.Sort(nums);
+
+        Dictionary<int,int> freq = new();
+        foreach(var num in nums){
+            if(freq.ContainsKey(num))
+                freq[num]++;
+            else
+                freq[num] = 1;
+        }
+        while(freq.Any()){
+            int num = freq.First().Key;
+            for(int i = 0; i < k; i++){
+                int currNum = num  + i;
+                if(freq.ContainsKey(currNum)){
+                    freq[currNum]--;
+                    if(freq[currNum] == 0)
+                        freq.Remove(currNum);
+                }
+                else
+                    return false;
+            }
+        }
+        return true;
+    }
+}

648.ReplaceWords.cs

@@ -0,0 +1,152 @@
+// 648. Replace Words
+// In English, we have a concept called root, which can be followed by some other word to form another longer word - let's call this word derivative. For example, when the root "help" is followed by the word "ful", we can form a derivative "helpful".
+// Given a dictionary consisting of many roots and a sentence consisting of words separated by spaces, replace all the derivatives in the sentence with the root forming it. If a derivative can be replaced by more than one root, replace it with the root that has the shortest length.
+// Return the sentence after the replacement.
+
+// Example 1:
+// Input: dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery"
+// Output: "the cat was rat by the bat"
+// Example 2:
+// Input: dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs"
+// Output: "a a b c"
+
+// Constraints:
+// 1 <= dictionary.length <= 1000
+// 1 <= dictionary[i].length <= 100
+// dictionary[i] consists of only lower-case letters.
+// 1 <= sentence.length <= 106
+// sentence consists of only lower-case letters and spaces.
+// The number of words in sentence is in the range [1, 1000]
+// The length of each word in sentence is in the range [1, 1000]
+// Every two consecutive words in sentence will be separated by exactly one space.
+// sentence does not have leading or trailing spaces.
+
+//Trie
+public class Solution {
+    Trie root = new Trie();
+    
+    public string ReplaceWords(IList<string> dictionary, string sentence) {
+        InsertPrefix(dictionary);
+        return Convert(sentence);
+    }
+
+    public void InsertPrefix(IList<string> dictionary) {
+        foreach (var word in dictionary) {
+            Trie node = root;
+            foreach (var ch in word) {
+                if (!node.Contains(ch))
+                    node.Insert(ch);
+                node = node.child[ch - 'a'];
+            }
+            node.SetEnd();
+        }
+    }
+
+    public string Convert(string sentence) {
+        List<string> words = sentence.Split(" ").ToList();
+        StringBuilder result = new StringBuilder();
+        
+        foreach (var word in words) {
+            StringBuilder prefix = new StringBuilder();
+            Trie node = root;
+            bool found = false;
+            
+            foreach (var ch in word) {
+                if (node.Contains(ch)) {
+                    prefix.Append(ch);
+                    node = node.child[ch - 'a'];
+                    if (node.IsEnd()) {
+                        found = true;
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            
+            if (found) {
+                result.Append(prefix);
+            } else {
+                result.Append(word);
+            }
+            result.Append(" ");
+        }
+        
+        // Remove the extra space at the end
+        if (result.Length > 0) {
+            result.Length--;
+        }
+        
+        return result.ToString();
+    }
+
+    public class Trie {
+        public Trie[] child;
+        bool isEnd;
+        
+        public Trie() {
+            child = new Trie[26];
+            isEnd = false;
+        }
+        
+        public void Insert(char ch) {
+            child[ch - 'a'] = new Trie();
+        }
+        
+        public bool Contains(char ch) {
+            return child[ch - 'a'] != null;
+        }
+        
+        public bool IsEnd() {
+            return isEnd;
+        }
+        
+        public void SetEnd() {
+            isEnd = true;
+        }
+    }
+}
+
+
+//HashSet
+public class Solution {
+    public string ReplaceWords(IList<string> dictionary, string sentence) {
+        StringBuilder word = new StringBuilder("");
+        HashSet<string> wordSet = new HashSet<string>(dictionary);
+        StringBuilder result  = new StringBuilder("");;
+        for(int c = 0; c < sentence.Length; c++){
+            if(sentence[c] != ' '){
+                word.Append(sentence[c]);
+                if(wordSet.Contains(word.ToString())){
+                    while(c+1 < sentence.Length && sentence[c+1] != ' '){
+                        c++;
+                    }
+                }
+            }
+            else{
+                if(word.Length > 0){
+                    result.Append(word);
+                    word = new StringBuilder("");
+                }
+                result.Append(sentence[c]);
+            }
+        }
+        if(word.Length > 0){
+            result.Append(word);
+        }
+        return result.ToString();
+    }
+}
+
+
+//Linq
+public class Solution {
+    public string ReplaceWords(IList<string> dictionary, string sentence) {
+        return string.Join(" ", 
+            sentence.Split()
+                .Select(w => dictionary
+                    .Where(d => d.Length <= w.Length && w[..d.Length].Equals(d))
+                    .MinBy(x => x.Length) ?? w)
+            );
+    }
+}

846.IsNStraightHand.cs

@@ -0,0 +1,49 @@
+// 846. Hand of Straights
+// Alice has some number of cards and she wants to rearrange the cards into groups so that each group is of size groupSize, and consists of groupSize consecutive cards.
+
+// Given an integer array hand where hand[i] is the value written on the ith card and an integer groupSize, return true if she can rearrange the cards, or false otherwise.
+
+// Example 1:
+// Input: hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
+// Output: true
+// Explanation: Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8]
+// Example 2:
+// Input: hand = [1,2,3,4,5], groupSize = 4
+// Output: false
+// Explanation: Alice's hand can not be rearranged into groups of 4.
+
+// Constraints:
+// 1 <= hand.length <= 104
+// 0 <= hand[i] <= 109
+// 1 <= groupSize <= hand.length
+
+public class Solution {
+    public bool IsNStraightHand(int[] hand, int groupSize) {
+        if(hand.Length%groupSize != 0)
+            return false;
+        
+        Array.Sort(hand);
+
+        Dictionary<int,int> cardFreq = new();
+        foreach(var card in hand){
+            if(cardFreq.ContainsKey(card))
+                cardFreq[card]++;
+            else
+                cardFreq[card] = 1;
+        }
+        while(cardFreq.Any()){
+            int card = cardFreq.First().Key;
+            for(int i = 0; i < groupSize; i++){
+                int currCard = card  + i;
+                if(cardFreq.ContainsKey(currCard)){
+                    cardFreq[currCard]--;
+                    if(cardFreq[currCard] == 0)
+                        cardFreq.Remove(currCard);
+                }
+                else
+                        return false;
+            }
+        }
+        return true;
+    }
+}