added few leetcode solutions

Author: sishashank1094

Leetcode/Jul2021/2049-count-nodes-with-highest-score.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    def countHighestScoreNodes(self, parents: List[int]) -> int:
+        from collections import defaultdict, Counter
+        graph = defaultdict(list)
+        for _node, parent in enumerate(parents):
+            graph[parent].append(_node)
+        # print(graph)
+        counter = Counter()
+        n = len(parents)
+
+        def count_nodes(node):
+            score = 1
+            children = 0
+            for child in graph[node]:
+                t = count_nodes(child)
+                t += 1
+                children += t
+                score = score * t
+            upward_nodes = n - 1 - children
+            # print(locals())
+            if upward_nodes:
+                score = score * upward_nodes
+            counter[score] += 1
+            return children
+
+        count_nodes(0)
+        return counter[max(counter.keys())]
+
+
+if __name__ == '__main__':
+    print(Solution().countHighestScoreNodes([-1, 2, 0, 2, 0]))

Leetcode/Jul2021/dequesTut.py

@@ -0,0 +1,31 @@
+# time_append.py
+
+from collections import deque
+from time import perf_counter
+
+TIMES = 10_000
+a_list = []
+a_deque = deque()
+
+
+def average_time(func, times):
+    total = 0.0
+    for i in range(times):
+        start = perf_counter()
+        func(i)
+        total += (perf_counter() - start) * 1e9
+    return total / times
+
+
+a_list = [TIMES] * TIMES
+for _ in range(TIMES):
+    a_deque.append(TIMES)
+
+print(f'len() : {len(a_list)}')
+list_time = average_time(lambda i: a_list.pop(0), TIMES)
+deque_time = average_time(lambda i: a_deque.popleft(), TIMES)
+print(f'len() : {len(a_list)}')
+gain = list_time / deque_time
+
+print(f"list.insert()      {list_time:.6} ns")
+print(f"deque.appendleft() {deque_time:.6} ns  ({gain:.6}x faster)")

Leetcode/Jul2021/parallel-course-III.py

@@ -0,0 +1,43 @@
+# https://leetcode.com/problems/parallel-courses-iii/
+
+from collections import deque
+from collections import defaultdict
+from typing import List
+
+
+class Solution:
+    def minimumTime(self, n: int, relations: List[List[int]], time: List[int]) -> int:
+
+        edges = defaultdict(list)
+        indegrees = [0] * n
+        for relation in relations:
+            edges[relation[0] - 1].append(relation[1] - 1)
+            indegrees[relation[1] - 1] += 1
+
+        # Initializing a queue
+        q = deque()
+        for indx, indegree in enumerate(indegrees):
+            if indegree == 0:
+                q.append(indx)
+            else:
+                pass
+
+        distance = [0] * n
+        # print(q, time, edges, indegrees)
+        while q:
+            # print(q, time, edges, indegrees, distance)
+            node = q.popleft()
+            node_dist = max(distance[node], time[node])
+            distance[node] = node_dist
+            if node in edges:
+                for neigbour in edges[node]:
+                    indegrees[neigbour] -= 1
+                    distance[neigbour] = max(distance[node] + time[neigbour], distance[neigbour])
+                    if indegrees[neigbour] == 0:
+                        q.append(neigbour)
+
+        return max(distance)
+
+
+print(Solution().minimumTime(n=5, relations=[[1, 5], [2, 5], [3, 5], [3, 4], [4, 5]], time=[1, 2, 3, 4, 5]))
+# print(Solution().minimumTime(n=3, relations=[[1, 3], [2, 3]], time=[3, 2, 5]))

Leetcode/Jul2021/zigzag-conversion.py

@@ -0,0 +1,67 @@
+# https://leetcode.com/problems/zigzag-conversion/
+# The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this:
+# (you may want to display this pattern in a fixed font for better legibility)
+#
+# P   A   H   N
+# A P L S I I G
+# Y   I   R
+# And then read line by line: "PAHNAPLSIIGYIR"
+#
+# Write the code that will take a string and make this conversion given a number of rows:
+#
+# string convert(string s, int numRows);
+#
+#
+# Example 1:
+#
+# Input: s = "PAYPALISHIRING", numRows = 3
+# Output: "PAHNAPLSIIGYIR"
+# Example 2:
+#
+# Input: s = "PAYPALISHIRING", numRows = 4
+# Output: "PINALSIGYAHRPI"
+# Explanation:
+# P     I    N
+# A   L S  I G
+# Y A   H R
+# P     I
+# Example 3:
+#
+# Input: s = "A", numRows = 1
+# Output: "A"
+#
+#
+# Constraints:
+#
+# 1 <= s.length <= 1000
+# s consists of English letters (lower-case and upper-case), ',' and '.'.
+# 1 <= numRows <= 1000
+
+class Solution(object):
+    def convert(self, s, numRows):
+        """
+        :type s: str
+        :type numRows: int
+        :rtype: str
+        """
+        if numRows == 1 or numRows >= len(s):
+            return s
+
+        L = [''] * numRows
+        index, step = 0, 1
+
+        for x in s:
+            print(L, index, step, x)
+            L[index] += x
+            if index == 0:
+                step = 1
+            elif index == numRows - 1:
+                step = -1
+            index += step
+
+        return ''.join(L)
+
+
+if __name__ == '__main__':
+    result = Solution().convert('PAYPALISHIRING', 4)
+    print(result)

difference-between-2-timestamps.py

@@ -0,0 +1,22 @@
+from datetime import datetime
+# Import the library
+import argparse
+# Create the parser
+import pytz
+
+parser = argparse.ArgumentParser()
+# Add an argument
+parser.add_argument('--earlier', type=str, required=True)
+# Add another argument
+parser.add_argument('--later', type=str, required=False, default=None)
+# Parse the argument
+args = parser.parse_args()
+# # Print "Hello" + the user input argument
+# print('Hello,', args.name)
+datetime_earlier = datetime.strptime(args.earlier, '%Y-%m-%dT%H:%M:%S.%f%z')
+if args.later:
+    datetime_later = datetime.strptime(args.later, '%Y-%m-%dT%H:%M:%S.%f%z')
+else:
+    datetime_later = datetime.utcnow().replace(tzinfo=pytz.utc)
+diff = (datetime_later - datetime_earlier)
+print(str(diff))

requirements.txt

@@ -1 +1,10 @@
-django
+boto3==1.18.34
+botocore==1.21.34
+grpcio==1.38.0
+grpcio-tools==1.38.0
+jmespath==0.10.0
+protobuf==3.17.1
+python-dateutil==2.8.2
+s3transfer==0.5.0
+six==1.16.0
+urllib3==1.26.6