Additional work + daily

Author: Zanger67

Diff for: README.md

@@ -0,0 +1,10 @@
+class Solution:
+    def findCenter(self, edges: List[List[int]]) -> int:
+        edgeCounter = defaultdict(int)
+
+        for edge in edges :
+            edgeCounter[edge[0]] += 1
+            edgeCounter[edge[1]] += 1
+            
+        return max([x for x in edgeCounter], key=lambda x:edgeCounter.get(x))
+        

Diff for: my-submissions/e1791 v1 Inefficient Counter.py

@@ -0,0 +1,3 @@
+class Solution:
+    def findCenter(self, edges: List[List[int]]) -> int:
+        return edges[0][0] if edges[0][0] in edges[1] else edges[0][1]

Diff for: my-submissions/e1791 v2 oneliner single if.py

@@ -0,0 +1 @@
+#define findCenter(edges, edgeSize, edgesColSize) ((edges[0][0] == edges[1][0] || edges[0][0] == edges[1][1]) ? edges[0][0] : edges[0][1])

Diff for: my-submissions/e1791 v2.c

@@ -0,0 +1,9 @@
+class Solution {
+public:
+    int findCenter(vector<vector<int>>& edges) {
+        if (edges[0][0] == edges[1][0] || edges[0][0] == edges[1][1])
+            return edges[0][0];
+        else
+            return edges[0][1];
+    }
+};

Diff for: my-submissions/e1791 v2.cpp

@@ -0,0 +1,5 @@
+class Solution {
+    public int findCenter(int[][] edges) {
+        return (edges[0][0] == edges[1][0] || edges[0][0] == edges[1][1]) ? edges[0][0] : edges[0][1];
+    }
+}

Diff for: my-submissions/e1791 v2.java

@@ -0,0 +1,49 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def correctBinaryTree(self, root: TreeNode) -> TreeNode:
+        toVisit = [(root, 0)]       # (curr, depth)
+        depths = {}
+
+        while toVisit :
+            curr, depth = toVisit.pop()
+            if not curr :
+                continue
+            if curr in depths and depths[curr] < depth :
+                continue
+
+            depths[curr] = depth
+            depth += 1
+
+            toVisit.append((curr.left, depth))
+            toVisit.append((curr.right, depth))
+
+        toVisit.append((root))
+
+        while toVisit :
+            parent = toVisit.pop()
+
+            if parent.left and \
+                    ((parent.left.left and depths[parent.left] == depths[parent.left.left]) or \
+                    (parent.left.right and depths[parent.left] == depths[parent.left.right])) :
+                parent.left = None
+                break
+
+            if parent.right and \
+                    ((parent.right.right and depths[parent.right] == depths[parent.right.right]) or \
+                    (parent.right.left and depths[parent.right] == depths[parent.right.left])) :
+                parent.right = None
+                break
+            
+            if parent.right :
+                toVisit.append(parent.right)
+            if parent.left :
+                toVisit.append(parent.left)
+
+
+        return root
+

Diff for: my-submissions/m1660 v1.py

@@ -0,0 +1,31 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def correctBinaryTree(self, root: TreeNode) -> TreeNode:
+        toVisit = [(root, None, 0)]       # (curr, depth)
+        depths = {}
+
+        while toVisit :
+            curr, parent, depth = toVisit.pop()
+            if not curr :
+                continue
+
+            if curr.left in depths or curr.right in depths :
+                if parent.left == curr :
+                    parent.left = None
+                else :
+                    parent.right = None
+                break
+            
+            depths[curr] = depth
+            depth += 1
+
+            toVisit.append((curr.left, curr, depth))
+            toVisit.append((curr.right, curr, depth))
+            
+        return root
+

Diff for: my-submissions/m1660 v2 One Pass.py

@@ -0,0 +1,31 @@
+class Solution:
+    def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:
+        mappings = defaultdict(list)
+        starters = set()
+
+        # Mapping
+        for pair in adjacentPairs :
+            mappings[pair[0]].append(pair[1])
+            mappings[pair[1]].append(pair[0])
+            
+        # Find starter
+        starter = -1
+        for k, v in mappings.items() :
+            if len(v) == 1 :
+                starter = k
+                break
+        
+
+            
+        output = [starter]
+        while len(output) <= len(adjacentPairs) :
+            options = mappings[output[-1]]
+
+            if len(options) <= 1 :
+                output.append(options[0])
+            elif output[-2] != options[0] :
+                output.append(options[0])
+            else :
+                output.append(options[1])
+
+        return output

Diff for: my-submissions/m1743 v2.py

@@ -0,0 +1,38 @@
+class Solution:
+    def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:
+        mappings = defaultdict(List[int])
+        starters = set()
+
+        for pair in adjacentPairs :
+            if pair[0] in mappings : 
+                mappings[pair[0]].append(pair[1])
+            else :
+                mappings[pair[0]] = [pair[1]]
+            
+            if pair[1] in mappings :
+                mappings[pair[1]].append(pair[0])
+            else :
+                mappings[pair[1]] = [pair[0]]
+
+            if pair[0] in starters :
+                starters.remove(pair[0])
+            else :
+                starters.add(pair[0])
+                
+            if pair[1] in starters :
+                starters.remove(pair[1])
+            else :
+                starters.add(pair[1])
+
+        output = [list(starters)[0]]
+        while len(output) <= len(adjacentPairs) :
+            options = mappings[output[-1]]
+
+            if len(options) <= 1 :
+                output.append(options[0])
+            elif output[-2] != options[0] :
+                output.append(options[0])
+            else :
+                output.append(options[1])
+
+        return output

Diff for: my-submissions/m1743.py

@@ -0,0 +1,36 @@
+class Solution:
+    def findDifferentBinaryString(self, nums: List[str]) -> str:
+        trie = {}
+
+        for num in nums :
+            curr = trie
+            for c in num :
+                curr[-1] = curr.get(-1, 0) + 1      # Count cases
+                if c not in curr :
+                    curr[c] = {}
+                curr = curr[c]
+        
+        output = []
+
+        while len(output) < len(nums[0]) :
+            if not trie :
+                output.append('0')
+            elif len(trie) == 3 :
+                zero = trie['0'].get(-1, 0)
+                one = trie['1'].get(-1, 0)
+
+                if zero > one :
+                    output.append('0')
+                    trie = trie.get('0')
+                else :
+                    output.append('1')
+                    trie = trie.get('1')
+            elif '0' in trie :
+                output.append('1')
+                trie = None
+            else :
+                output.append('0')
+                trie = None
+                
+
+        return ''.join(output)

Diff for: my-submissions/m1980 v1 trie.py

@@ -0,0 +1,9 @@
+class Solution:
+    def findDifferentBinaryString(self, nums: List[str]) -> str:
+        output = []
+
+        for i in range(len(nums[0])) :
+            output.append('0' if nums[i][i] == '1' else '1')
+                
+
+        return ''.join(output)

Diff for: my-submissions/m1980 v2 Cantours Diagonal Argument.py

@@ -0,0 +1,10 @@
+char* findDifferentBinaryString(char** nums, int numsSize) {
+    char* output = (char*) malloc(sizeof(char) * (numsSize + 1));
+
+    for (int i = 0; i < numsSize; i++) {
+        output[i] = (nums[i][i] == '1') ? '0' : '1';
+    }
+    output[numsSize] = 0;
+
+    return output;
+}

Diff for: my-submissions/m1980 v2.c

@@ -0,0 +1,18 @@
+class Solution:
+    def equalPairs(self, grid: List[List[int]]) -> int:
+        horizontal = {}
+        vertical = {}
+
+        for i, row in enumerate(grid) :
+            horizontal[i] = tuple(row)
+        
+        for j in range(len(grid[0])) :
+            vertical[j] = tuple([grid[i][j] for i in range(len(grid))])
+        
+        output = 0
+        for i in range(len(grid)) :
+            for j in range(len(grid[0])) :
+                if horizontal[i] == vertical[j] :
+                    output += 1
+
+        return output

Diff for: my-submissions/m2352 brute force.py

@@ -0,0 +1,47 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* prev;
+    Node* next;
+    Node* child;
+};
+*/
+
+class Solution {
+public:
+    Node* flatten(Node* head) {
+        if (!head) {
+            return NULL;
+        }
+
+        if (!head->child) {
+            head->next = flatten(head->next);
+            return head;
+        }
+
+        if (!head->next) {
+            head->next = flatten(head->child);
+            head->child = NULL;
+            head->next->prev = head;
+            return head;
+        }
+
+        Node* holder = head->next;
+        head->next = flatten(head->child);
+        head->next->prev = head;
+        head->child = NULL;
+
+        Node* output = head;
+
+        while (head->next) {
+            head = head->next;
+        }
+
+        head->next = flatten(holder);
+        head->next->prev = head;
+
+        return output;
+    }
+};

Diff for: my-submissions/m430.cpp

@@ -0,0 +1,44 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node prev;
+    public Node next;
+    public Node child;
+};
+*/
+
+class Solution {
+    public Node flatten(Node head) {
+        if (head == null) {
+            return null;
+        }
+
+        if (head.child == null) {
+            head.next = flatten(head.next);
+            return head;
+        }
+
+        if (head.next == null) {
+            head.next = flatten(head.child);
+            head.child = null;
+            head.next.prev = head;
+            
+            return head;
+        }
+
+        Node holder = head.next;
+        head.next = flatten(head.child);
+        head.next.prev = head;
+        head.child = null;
+
+        Node output = head;
+        while (head.next != null) {
+            head = head.next;
+        } 
+        head.next = flatten(holder);
+        head.next.prev = head;
+
+        return output;
+    }
+}