let there be code

Author: soorajsprakash

.gitignore

@@ -0,0 +1 @@
+/temp

README.md

@@ -0,0 +1,7 @@
+# Competitive_Programming_Python
+
+This Repo consists of my Python solutions to various problems of Coderbyte, HackerRank, Leetcode, CodeChef etc.
+
+
+
+* In the solution, there might be both print statement and return for a function, return is for the testcases of them sites, and print is to get output if we run it outside.

bitmapHoles.py

@@ -0,0 +1,66 @@
+# Bitmap_Holes --> CODERBYTE
+
+'''
+Have the function BitmapHoles(strArr) take the array of strings stored in strArr, 
+which will be a 2D matrix of 0 and 1's, and determine how many holes, 
+or contiguous regions of 0's, exist in the matrix. 
+A contiguous region is one where there is a connected group of 0's going in 
+one or more of four directions: up, down, left, or right. 
+For example: if strArr is ["10111", "10101", "11101", "11111"], 
+then this looks like the following matrix:
+
+1 0 1 1 1
+1 0 1 0 1
+1 1 1 0 1
+1 1 1 1 1
+
+For the input above, your program should return 2 because there are 
+two separate contiguous regions of 0's, which create "holes" in the matrix. 
+You can assume the input will not be empty. 
+
+Example1:
+Input: ["01111", "01101", "00011", "11110"]
+Output: 3
+
+Example2
+Input: ["1011", "0010"]
+Output: 2 
+'''
+
+
+count = 0
+def BitmapHoles(strArr):
+    newList = []
+    
+    def horizontalCount(ourList):  
+        global count
+        for each in ourList:
+            z = list(each)
+            index = 0
+            while index < len(z)-1:
+                if z[index] == '0' and z[index+1] == '0':
+                    count += 1
+                    break
+                index +=1
+
+    def transpose():
+        newStr = ""
+        i = 0
+        while i < len(strArr[0]):
+            for each in strArr:
+                newStr += each[i]
+            # print(newStr)
+            newList.append(newStr)
+            newStr = ""
+            i += 1
+
+    # print(f"Sample1: {strArr}")
+    horizontalCount(strArr)
+    # print(f"Initial count: {count}")
+    transpose()
+    # print(f"Transposed Sample: {newList}")
+    horizontalCount(newList)
+    # print(f"Final count: {count}")
+    return count
+
+print(BitmapHoles(["01111", "01101", "00011", "11110"]))

fizzbuzz.py

@@ -0,0 +1,36 @@
+# FizzBuzz --> LEETCODE
+
+'''
+Given an integer n, return a string array answer (1-indexed) where:
+    answer[i] == "FizzBuzz" if i is divisible by 3 and 5.
+    answer[i] == "Fizz" if i is divisible by 3.
+    answer[i] == "Buzz" if i is divisible by 5.
+    answer[i] == i (as a string) if none of the above conditions are true.
+
+Example 1:
+Input: n = 3
+Output: ["1","2","Fizz"]
+
+Example 2:
+Input: n = 5
+Output: ["1","2","Fizz","4","Buzz"]
+'''
+  
+
+def fizzBuzz():
+    list = []
+    n = int(input("enter n: "))
+    for each in range(1, n+1):
+        if each % 3 == 0 and each % 5 ==0:
+            list.append("FizzBuzz")
+        elif each% 5 ==0:
+            list.append("Buzz")
+        elif each % 3 ==0:
+            list.append("Fizz")
+        else:
+            list.append(str(each))
+    print(list)
+    return list
+
+fizzBuzz()
+

treeConstructor.py

@@ -0,0 +1,53 @@
+# Python_tree_constructor (verifier) --> CODERBYTE
+
+'''
+TreeConstructor(strArr) take the array of strings stored in strArr, 
+which will contain pairs of integers in the following format: (i1,i2), 
+where i1 is child node and i2 represents the parent node.
+
+If strArr can form a proper binary tree, return True. If not, return False
+
+            4
+           /
+          2
+        /   \
+      1       7
+
+Example 1
+Input: ["(1,2)", "(2,4)", "(5,7)", "(7,2)", "(9,5)"] 
+Output: true
+Example 2
+Input: ["(1,2)", "(3,2)", "(2,12)", "(5,2)"] 
+Output: false
+
+
+# my_notes:
+# (left, right) --> left is the child, and right is the parent of the child
+'''
+
+
+s = ["(1,2)", "(3,2)", "(2,12)", "(5,2)"]
+childList = []
+parentList = []
+
+
+def TreeConstructor(s):
+    for each in s:
+        childList.append(each[1])
+        parentList.append(each[3])
+    # print(childList)
+    # print(parentList)
+
+    countList = dict((x,parentList.count(x)) for x in set(parentList))
+    # print(countList)
+    # print(list(countList.values()))
+
+    if max(list(countList.values())) >2:
+        print('FALSE')
+        return False
+    else:
+        print('TRUE')
+        return True
+
+
+TreeConstructor(s)