Added new problem.

Author: manastalukdar

.vscode/launch.json

@@ -4,6 +4,13 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "name": "Python: Current File",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        },
         {
             "type": "java",
             "name": "Debug (Launch) - Current File",
@@ -29,7 +36,7 @@
             "type": "python",
             "request": "launch",
             "stopOnEntry": true,
-            "pythonPath": "${command:python.interpreterPath}",
+            "python": "${command:python.interpreterPath}",
             "program": "${file}",
             "cwd": "${workspaceRoot}",
             "env": {},

.vscode/python.code-snippets

@@ -15,15 +15,14 @@
 	// 	],
 	// 	"description": "Log output to console"
 	// }
-
 	"Solution": {
 		"scope": "python",
 		"prefix": "solution",
 		"body": [
 			"class Solution:",
 			"\tdef method(self):",
 			"\t\t",
-			"def main():",			
+			"def main():",
 			"\tsolution = Solution()",
 			"",
 			"if __name__ == '__main__':",
@@ -38,12 +37,12 @@
 			"import unittest",
 			"",
 			"class TrivialCase(unittest.TestCase):",
-    		"\tdef testTrivialCase1(self):",
-        	"\t\t\"\"\"\"trivial case 1\"\"\"",
+			"\tdef test_trivial_case_1(self):",
+			"\t\t\"\"\"\"trivial case 1\"\"\"",
 			"\t\texpected = ",
 			"\t\tsol = solution.Solution()",
-        	"\t\tactual = sol.",
-        	"\t\tself.assertEqual(expected, actual)",
+			"\t\tactual = sol.",
+			"\t\tself.assertEqual(expected, actual)",
 			"",
 			"if __name__ == \"__main__\":",
 			"\tunittest.main()"

scripts/run_unit_tests.py

@@ -1,27 +1,26 @@
 import os
 import unittest
-import traceback
 import sys
 import re
 
-def runTests():
+
+def run_tests():
     lsPaths = []
-    cwd = os.getcwd()        
+    cwd = os.getcwd()
 
     #Find all relevant subdirectories that contain unit tests
     root_dir = "src"
     for root, dirs, files in os.walk(root_dir):
         dirs.sort()
         for file in files:
-            if "pycache" not in root and file.startswith("test_"):
+            if "pycache" not in root and 'test_' in file:
                 test_folder = os.path.join(cwd, root)
-                lsPaths.append(test_folder)    
+                lsPaths.append(test_folder)
 
     #loop through subdirectories and run individually
     for path in lsPaths:
         sys.path.append(path)
         loader = unittest.TestLoader()
-        suite = unittest.TestSuite()
         suite = loader.discover(path)
         testresult = unittest.TextTestRunner().run(suite)
         sys.path.remove(path)
@@ -39,14 +38,16 @@ def runTests():
         if len(testresult.failures) > 0 or len(testresult.errors) > 0:
             raise Exception()
 
+
 def main():
     """main method."""
-    try:              
+    try:
         print("Running unit tests...")
-        runTests()
+        run_tests()
         print("Finished running unit tests.")
     except Exception as e:
         sys.exit(f"Failure in unit test run. Exception: {e}.")
 
+
 if __name__ == '__main__':
     main()

src/Glassdoor/src/Facebook/NumberOfStringsFromEncodedAlphabet/Python/solution.py

@@ -7,16 +7,17 @@ def find_strings(self, x):
             if int(i) != 0:
                 total += 1
                 nums.append(int(i))
-            if prev:
-                if int(prev + i) != int(i) and int(prev+i) < 27:
-                    total += 1
-                    nums.append(int(prev+i))
+            if prev and int(prev + i) != int(i) and int(prev + i) < 27:
+                total += 1
+                nums.append(int(prev + i))
             prev = i
         return total, nums
 
+
 def main():
     solution = Solution()
     print(solution.find_strings(23413259802))
 
+
 if __name__ == '__main__':
     main()

src/Glassdoor/src/Facebook/NumberOfStringsFromEncodedAlphabet/Python/test_solution.py

@@ -1,13 +1,15 @@
 import solution
 import unittest
 
+
 class TrivialCase(unittest.TestCase):
-    def testTrivialCase1(self):
+    def test_trivial_case_1(self):
         """trivial case 1"""
         expected = (13, [2, 3, 23, 4, 1, 3, 13, 2, 5, 25, 9, 8, 2])
         sol = solution.Solution()
         actual = sol.find_strings(23413259802)
         self.assertEqual(expected, actual)
 
+
 if __name__ == "__main__":
     unittest.main()

src/HackerRank/src/Miscellaneous/DamDesign/Python/solution.py

@@ -0,0 +1,8 @@
+class Solution:
+  def method(self):
+    
+def main():
+  solution = Solution()
+
+if __name__ == '__main__':
+  main()

src/HackerRank/src/Miscellaneous/DamDesign/Python/test_solution.py

@@ -0,0 +1,31 @@
+{
+  "type": "Coding",
+  "name": "Dam Design",
+  "origin": {
+    "name": "HackerRank",
+    "link": ""
+  },
+  "companies": ["", ""],
+  "categories": [
+    {
+      "name": "",
+      "children": [
+        {
+          "name": "",
+          "children": []
+        }
+      ]
+    },
+    {
+      "name": "Difficulty",
+      "children": [
+        {
+          "name": "Easy",
+          "children": []
+        }
+      ]
+    }
+  ],
+  "tags": ["Arrays", ""],
+  "buckets": ["", ""]
+}

src/HackerRank/src/Miscellaneous/DamDesign/metadata.json

@@ -0,0 +1,139 @@
+# Problem Definition
+
+## Description
+
+Your company is designing a dam to be built across a stream to create a small lake. To reduce materials cost, it will be made of one or more concrete walls with mud packed in between them. Determine the maximum height of the mud segments in the dam with the following restrictions:
+
+- One unit width of the gap between walls will contain one segment of packed mud
+- The height of mud in a segment cannot exceed 1 unit more than an adjacent wall or mud segment.
+
+Given the placement of a number of walls and their heights, determine the maximum height of a mud segment that can be built. If no mud segment can be built, return 0.
+
+Example
+
+```plaintext
+wallPositions = [1, 2, 4, 7]
+wallHeights = [4, 6, 8, 11]
+```
+
+- There is no space between the first two walls.
+- Between positions 2 and 4, there is one unit open for mud. Heights of the surrounding walls are 6 and 8, so the maximum height of mud is 6 + 1 = 7.
+- Between positions 4 and 7 there are two units. The heights of surrounding walls are 8 and 11.
+  - The maximum height mud segment next to the wall of height 8 is 9.
+  - The maximum height mud next to a mud segment of height 9 is 10.
+- Overall, mud segment heights are 7, 9 and 10, and the maximum height is 10.
+
+Function Description
+
+Complete the function maxHeight in the editor below.
+maxHeight has the following parameter(s):
+    int wallPositions[n]:  an array of integers
+    int wallHeights[n]:  an array of integers
+Returns:
+    int: the maximum height mud segment that can be build
+
+Constraints
+
+- 1 < n ≤ 10^5
+- 1 ≤ wallPositions[i], wallHeights[i] ≤ 109 (where 0 ≤ i < n)
+
+### Input Format For Custom Testing
+
+The first line contains an integer, n, the number of elements in wallPositions.
+
+Each line i of the n subsequent lines (where 0 ≤ i < n) contains an integer, wallPositions[i].
+
+The next line contains the integer, n, the number of elements in wallHeights.
+
+Each line i of the n subsequent lines (where 0 ≤ i < n) contains an integer, wallHeights[i].
+
+### Sample Case 0
+
+Sample Input For Custom Testing
+
+```plaintext
+STDIN    Function
+-----    --------
+3    →   wallPositions[] size n = 3
+1    →   wallPositions = [1, 3, 7]
+3
+7
+3    →   wallHeights[] size n = 3
+4    →   wallHeights = [4, 3, 3]
+3
+3
+```
+
+Sample Output
+
+5
+
+Explanation
+
+The wallPositions = [1, 3, 7] and wallHeights = [4, 3, 3].  There can be a segment of height 4 at position 2 supported by walls of heights 4 and 3.  Between positions 3 and 7, there can be a segment of height 4 at positions 4 and 6.  Between them, a segment can be built of height 5 at position 5.
+
+### Sample Case 1
+
+Sample Input For Custom Testing
+
+```plaintext
+STDIN    Function
+-----    --------
+2    →   wallPositions[] size n = 2
+1    →   wallPositions = [1, 10]
+10
+2    →   wallHeights[] size n = 2
+1    →   wallHeights = [1, 5]
+5
+```
+
+Sample Output
+
+7
+
+Explanation
+
+The wallPositions = [1, 10] and wallHeights = [1, 5]. The heights of the mud segments from positions 2 through 9 are [2, 3, 4, 5, 6, 7, 7, 6].
+
+## Discussion
+
+### Approach
+
+#### Time Complexity
+
+#### Space Complexity
+
+### Alternate Approach 1
+
+#### Time Complexity - Alternate Approach 1
+
+#### Space Complexity - Alternate Approach 1
+
+## Notes
+
+```java
+public static int maxHeight(List<Integer> wallPositions, List<Integer> wallHeights) {
+        int globalMax = 0;
+        for (int i = 0; i < wallPositions.size()-1; i++) {
+            if (wallPositions.get(i+1) > wallPositions.get(i) + 1) {
+                int  heightDiff = Math.abs(wallHeights.get(i) - wallHeights.get(i+1));
+                int gap = wallPositions.get(i + 1) - wallPositions.get(i) - 1;
+                int maxValue = 0;
+                if(gap > heightDiff) {
+                    int taller = Math.max(wallHeights.get(i), wallHeights.get(i+1));
+                    //get the shorter one to same height and then take the mid point value for increment
+                    maxValue = taller + ((gap - heightDiff - 1)/ 2) + 1;
+                }else {
+                    //when the height diff is larger than the gap then max would be gap added to shorter wall
+                    maxValue = Math.min(wallHeights.get(i), wallHeights.get(i+1)) + gap;
+                }
+                globalMax = Math.max(globalMax, maxValue);
+            }
+        }
+        return globalMax;
+    }
+
+}
+```
+
+## References