demo unittest

Author: greyshell

core_concepts/demo_unittest/blance_bracket.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# author: greyshell
+
+
+def solution(arr):
+    # create a stack
+    s = list()
+
+    for i in range(0, len(arr)):
+        if arr[i] == '(':
+            s.append(')')
+
+        elif arr[i] == ')':
+            if len(s) != 0:
+                out = s[-1]
+                if out == ')':
+                    s.pop()
+            else:
+                s.append('(')
+
+    if len(s) == 0:
+        return True
+
+    return False
+
+
+def main():
+    # sample test case
+    arr = ['(', ')']
+    result = solution(arr)
+    print(f"{result}")
+
+
+if __name__ == '__main__':
+    main()

core_concepts/demo_unittest/test_blance_bracket.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# author: greyshell
+# how to run: python -m unittest test_blance_bracket.TestSolution
+
+import unittest
+from blance_bracket import solution
+
+
+class TestSolution(unittest.TestCase):
+
+    def test_solution_case_1(self):
+        self.assertEqual(solution(['(', '(']), False)
+
+    def test_solution_case_2(self):
+        self.assertEqual(solution(['(', ')']), True)
+
+    def test_solution_case_3(self):
+        self.assertEqual(solution([')', '(']), False)
+
+    def test_solution_case_4(self):
+        self.assertEqual(solution(['(', '(', ')', ')']), True)
+
+    def test_solution_case_5(self):
+        self.assertEqual(solution([')', ')']), False)
+
+    def test_solution_case_6(self):
+        self.assertEqual(solution(['(', '(', ')', '(', ')']), False)
+
+    def test_solution_case_7(self):
+        self.assertEqual(solution(['(', ')', '(']), False)
+
+    def test_solution_case_8(self):
+        self.assertEqual(solution(['(', ')', ')']), False)
+
+    def test_solution_case_9(self):
+        self.assertEqual(solution(['(', '(', ')', '(', ')', ')']), True)
+
+
+if __name__ == '__main__':
+    unittest.main()

core_concepts/demo_unittest/test_two_sum.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# author: greyshell
+# command: python -m unittest test_two_sum.TestSolution
+
+import unittest
+from two_sum import LeetCode
+
+
+class TestSolution(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        optional ->
+        run one time before staring the test
+        can be used to populate a database to set up testing
+        :return:
+        """
+        print("running setUpClass method")
+
+    def setUp(self):
+        """
+        optional ->
+        run this before every single test function
+        can be used to add files to a directory / set variables
+        :return:
+        """
+        print("running setUp method method")
+
+    def test_case_1(self):
+        """
+        verify the correctness of the solution
+        - actual -> means what we are providing into the assert statement
+        - expected -> means what we are getting from the program
+        :return:
+        """
+        self.assertEqual(LeetCode.solution([12, 7, 11, 15, 35], 50), [3, 4])
+
+    def test_case_2(self):
+        self.assertEqual(LeetCode.solution([12, 7, 11, 15, 35], 19), [0, 1])
+
+    def tearDown(self):
+        """
+        optional ->
+        run this after every single test
+        can be used to delete files from directory those created during testing / unset variables
+        :return:
+        """
+        print("running tearDown method")
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        optional ->
+        can be used to clean up the database to start other testing from clean state
+        :return:
+        """
+        print("running tearDownClass method")
+
+
+if __name__ == '__main__':
+    unittest.main()

core_concepts/demo_unittest/two_sum.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+# author: greyshell
+
+"""
+reference: https://leetcode.com/problems/two-sum/
+
+description:
+Given an array of integers, return indices of the two numbers such that
+they add up to a specific target.
+
+You may assume that each input would have exactly one two_sum, and you may not
+use the same element twice.
+
+Example:
+
+Given nums = [2, 7, 11, 15], target = 9,
+
+Because nums[0] + nums[1] = 2 + 7 = 9,
+return [0, 1].
+"""
+
+
+class LeetCode:
+    @staticmethod
+    def solution(nums: list, target: int) -> list:
+        """
+        time complexity: O(n)
+        space complexity: O(n) -> size of the hash table
+        """
+        lookup = {}
+
+        for index in range(0, len(nums)):
+            complement = target - nums[index]
+            # if the complement is not present in hash_map then
+            # insert the number as key, index as value
+            found_value = lookup.get(complement)  # O(1), not found return None
+            if found_value is None:
+                key = nums[index]
+                lookup[key] = index
+
+            else:  # found the complement in the hash_map
+                index_of_prev_number = lookup[complement]
+                return [index_of_prev_number, index]
+
+        # scenario where target is not found
+        return [None, None]  # returns a list
+
+
+def main():
+    # sample test case
+    nums = [12, 7, 11, 15, 35, 17, 2]
+    target = 26
+
+    result = LeetCode.solution(nums, target)
+
+    print(f"{result}")  # expected result: [1, 2]
+
+
+if __name__ == '__main__':
+    main()

core_concepts/play.py renamed to core_concepts/helper_create_hashtable.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+
+# author: greyshell
+
+
+def add(x, y):
+    return x + y
+
+
+def double(x):
+    return x + x

core_concepts/modules_packages/adder.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# author: greyshell
+
+"""
+note:
+
+module - a file containing python code that can be reused in other python code files.
+
+advantage of module:
+1. simplicity
+2. maintainability
+3. reuability
+4. scoping - module has its own namespace
+
+advantage of namesapce:
+- group the names into logical containers
+- prevent the clashes between the duplicate namespace
+- provide context to names
+
+- during function name clash, local / current function only gets executed.
+
+- when the module has only one class then import that directly, for example
+from datetime import datetime
+
+best practice is the import module to keep the imported
+module separated from the callings modules namespace
+"""
+
+from adder import add as myadd
+
+
+def add(x, y):
+    return x - y
+
+
+def main():
+    value = add(7, 3)
+    print(value)
+
+    value = myadd(7, 3)
+    print(value)
+
+
+if __name__ == '__main__':
+    main()

core_concepts/modules_packages/main.py

@@ -1,4 +1,4 @@
-# !/usr/bin/env python3
+#!/usr/bin/env python3
 
 # author: greyshell
 

core_concepts/quxes_fb.py

@@ -1,4 +1,4 @@
-# !/usr/bin/env python3
+#!/usr/bin/env python3
 
 # author: greyshell
 # description: play with dict