MILESTONE 300 questions on day 31!

Author: Zanger67

README.md

@@ -0,0 +1,41 @@
+class FileSystem:
+
+    def __init__(self):
+        self.trie = {}
+
+    def createPath(self, path: str, value: int) -> bool:
+        pathChunks = path.split('/')[1:]
+
+        curr = self.trie
+        for i in range(len(pathChunks) - 1) :
+            if pathChunks[i] not in curr :
+                return False
+            curr = curr[pathChunks[i]]
+
+        if pathChunks[-1] in curr and 'value' in curr[pathChunks[-1]] :
+            return False
+
+        curr[pathChunks[-1]] = {}
+        curr[pathChunks[-1]]['value'] = value
+        return True
+
+    def get(self, path: str) -> int:
+        pathChunks = path.split('/')[1:]
+
+        curr = self.trie
+        for chunk in pathChunks :
+            if chunk not in curr :
+                return -1
+            curr = curr[chunk]
+        
+        if 'value' in curr :
+            return curr['value']
+        return -1
+        
+
+
+
+# Your FileSystem object will be instantiated and called as such:
+# obj = FileSystem()
+# param_1 = obj.createPath(path,value)
+# param_2 = obj.get(path)

my-submissions/m1166.py

@@ -0,0 +1,25 @@
+class Solution:
+    def removeSubfolders(self, folder: List[str]) -> List[str]:
+        trie = {}
+        folder.sort()
+        output = []
+
+
+        for f in folder :
+            path = f.split('/')[1:]
+            curr = trie
+            add = False
+            for c in path :
+                if c not in curr :
+                    curr[c] = {}
+                    add = True
+                if False in curr :
+                    break
+
+                curr = curr[c]
+
+            if add and False not in curr:
+                output.append(f)
+                curr[False] = True
+
+        return output

my-submissions/m1233.py

@@ -0,0 +1,10 @@
+class Solution:
+    def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]:
+        people = sorted([(groupSizes[i], i) for i in range(len(groupSizes))], reverse=True)
+        outputs = []
+
+        while people :
+            currSize = people[-1][0]
+            outputs.append([people.pop()[1] for _ in range(currSize)])
+
+        return outputs

my-submissions/m1282.py

@@ -0,0 +1,13 @@
+class Solution:
+    def maximumImportance(self, n: int, roads: List[List[int]]) -> int:
+        cnt = Counter([roads[x // 2][x % 2] for x in range(len(roads) * 2)])
+        validVals = sorted(list(cnt.values()))
+
+        i = n
+        output = 0
+
+        while validVals :
+            output += i * validVals.pop()
+            i -= 1
+
+        return output

my-submissions/m2285 Daily.py

@@ -0,0 +1,21 @@
+int compare(const void* a, const void* b) {
+    return *((int*) a) - *((int*) b);
+}
+
+long long maximumImportance(int n, int** roads, int roadsSize, int* roadsColSize) {
+    int cnt[n];
+        memset(&cnt, 0, n * sizeof(int));
+
+        for (int i = 0; i < roadsSize; i++) {
+            cnt[roads[i][0]]++;
+            cnt[roads[i][1]]++;
+        }
+
+        qsort(cnt, n, sizeof(int), compare);
+
+        long long output = 0;
+        for (int i = n; i > 0 && cnt[i - 1] > 0; i--) {
+            output += (long long) i * (long long) cnt[i - 1];
+        }
+        return output;
+}

my-submissions/m2285 v2.c

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    long long maximumImportance(int n, vector<vector<int>>& roads) {
+        int cnt[n];
+        memset(&cnt, 0, n * sizeof(int));
+
+        for (int i = 0; i < roads.size(); i++) {
+            cnt[roads[i][0]]++;
+            cnt[roads[i][1]]++;
+        }
+        sort(cnt, cnt + n);
+
+        long long output = 0;
+        for (int i = n; i > 0 && cnt[i - 1] > 0; i--) {
+            output += (long long) i * (long long) cnt[i - 1];
+        }
+        return output;
+    }
+};

my-submissions/m2285 v2.cpp

@@ -0,0 +1,17 @@
+class Solution {
+    public long maximumImportance(int n, int[][] roads) {
+        int[] cnt = new int[n];
+
+        for (int[] road : roads) {
+            cnt[road[0]]++;
+            cnt[road[1]]++;
+        }
+        Arrays.sort(cnt);
+
+        long output = 0;
+        for (int i = n; i > 0 && cnt[i - 1] > 0; i--) {
+            output += ((long) i * (long) cnt[i - 1]);
+        }
+        return output;
+    }
+}

my-submissions/m2285 v2.java

@@ -0,0 +1,16 @@
+class Solution:
+    def maximumImportance(self, n: int, roads: List[List[int]]) -> int:
+        cnt = [0] * n
+        for road in roads :
+            cnt[road[0]] += 1
+            cnt[road[1]] += 1
+        cnt.sort()
+
+        i = n
+        output = 0
+
+        while cnt and cnt[-1] > 0 :
+            output += i * cnt.pop()
+            i -= 1
+
+        return output

my-submissions/m2285 v2.py

@@ -0,0 +1,24 @@
+class Solution:
+    def longestCommonPrefix(self, arr1: List[int], arr2: List[int]) -> int:
+        trie = {}
+
+        for s in arr1 :
+            curr = trie
+            for c in str(s) :
+                if c not in curr :
+                    curr[c] = {}
+                curr = curr[c]
+            curr[False] = True
+        
+        maxx = 0
+        for s in arr2 :
+            curr = trie
+            counter = 0
+            for c in str(s) :
+                if c not in curr :
+                    break
+                counter += 1
+                curr = curr[c]
+            maxx = max(maxx, counter)
+
+        return maxx

my-submissions/m3043.py

@@ -0,0 +1,64 @@
+# Identical to 758
+
+class Solution:
+    def addBoldTag(self, s: str, words: List[str]) -> str:
+        trie = {}
+
+        for word in words :
+            curr = trie
+            for c in word :
+                if c not in curr :
+                    curr[c] = {}
+                curr = curr[c]
+
+            curr[False] = True
+        
+        # Find intervals that need to be bolded
+        intervals = []
+        curr = {}
+        for i, c in enumerate(s) :
+            curr[i] = trie
+            keys = list(curr.keys())
+            for key in keys :
+                if False in curr[key] :
+                    intervals.append((key, i))
+                
+                if c not in curr[key] :
+                    curr.pop(key)
+                    continue
+                
+                curr[key] = curr[key][c]
+
+        for i, branch in curr.items() :
+            if False in branch :
+                intervals.append((i, len(s)))
+
+        intervals.sort(key=lambda x: x[0])
+
+        # merging intervals
+        output = []
+        if intervals :
+            output.append(s[:intervals[0][0]])
+        
+        indx = 0
+        while indx < len(intervals) :
+            left, right = intervals[indx]
+            indx += 1
+
+            while indx < len(intervals) and intervals[indx][0] <= right :
+                if intervals[indx][1] > right :
+                    right = intervals[indx][1]
+                indx += 1
+
+            output.append('<b>')
+            output.append(s[left:right])
+            output.append('</b>')
+            
+            if indx < len(intervals) :
+                output.append(s[right:intervals[indx][0]])
+        if intervals :
+            output.append(s[right:])
+        else :
+            output.append(s)
+
+        return ''.join(output)

my-submissions/m616.py

@@ -0,0 +1,64 @@
+# Identical to 758
+
+class Solution:
+    def boldWords(self, words: List[str], s: str) -> str:
+        trie = {}
+
+        for word in words :
+            curr = trie
+            for c in word :
+                if c not in curr :
+                    curr[c] = {}
+                curr = curr[c]
+
+            curr[False] = True
+        
+        # Find intervals that need to be bolded
+        intervals = []
+        curr = {}
+        for i, c in enumerate(s) :
+            curr[i] = trie
+            keys = list(curr.keys())
+            for key in keys :
+                if False in curr[key] :
+                    intervals.append((key, i))
+                
+                if c not in curr[key] :
+                    curr.pop(key)
+                    continue
+                
+                curr[key] = curr[key][c]
+
+        for i, branch in curr.items() :
+            if False in branch :
+                intervals.append((i, len(s)))
+
+        intervals.sort(key=lambda x: x[0])
+
+        # merging intervals
+        output = []
+        if intervals :
+            output.append(s[:intervals[0][0]])
+        
+        indx = 0
+        while indx < len(intervals) :
+            left, right = intervals[indx]
+            indx += 1
+
+            while indx < len(intervals) and intervals[indx][0] <= right :
+                if intervals[indx][1] > right :
+                    right = intervals[indx][1]
+                indx += 1
+
+            output.append('<b>')
+            output.append(s[left:right])
+            output.append('</b>')
+            
+            if indx < len(intervals) :
+                output.append(s[right:intervals[indx][0]])
+        if intervals :
+            output.append(s[right:])
+        else :
+            output.append(s)
+
+        return ''.join(output)