initial commit

guipleite · guipleite · commit fbe5af0eb840 · 2020-09-15T10:02:03.000-03:00
diff --git a/1a.py b/1a.py
@@ -0,0 +1,29 @@
+
+def check_pal(inp):
+    word = inp.lower()
+
+    dict_count = {}
+
+    odd_flag = False
+
+    for i in range(len(word)):
+        if word[i] != ' ':
+            dict_count[word[i]] = 0
+
+    for c in word:
+        if c != ' ':
+            dict_count[c]+=1
+
+    for key in dict_count:
+        if dict_count[key]%2 != 0:
+
+            if not odd_flag:
+                odd_flag  = True
+            else:
+                return False 
+
+    return True
+
+
+inp = "azAZ"
+print(check_pal(inp))
diff --git a/bitwise-ors-of-subarrays.py b/bitwise-ors-of-subarrays.py
@@ -0,0 +1,17 @@
+class Solution:
+    def subarrayBitwiseORs(self, A: List[int]) -> int:
+        ans =set()
+        cur = set()
+        
+        for i in A:
+            buff = set()
+            
+            buff.add(i)
+            
+            for j in cur:
+                buff.add(i|j)
+                
+            cur = buff 
+            ans.update(cur)
+            
+        return len(ans)
diff --git a/ent01.py b/ent01.py
@@ -0,0 +1,46 @@
+def one_edit_away(s1,s2):
+
+    if s1 == s2:
+        return True
+
+    elif len(s1) == len(s2):
+        return check_replace(s1,s2)
+
+    elif abs(len(s1)-len(s2)) == 1:
+        if len(s1) > len(s2):
+            return check_insert(s1,s2)
+        else:
+            return check_insert(s2,s1)
+
+    else:
+        return False
+
+def check_replace(s1,s2):
+    counter = 0
+
+    for i in range(len(s1)):
+        if s1[i] != s2[i]:
+            counter+=1
+        
+        if counter > 1:
+            return False
+
+    return True
+
+def check_insert(s1,s2):
+    j=0
+    for i in range(len(s1)):
+        if i==len(s2)-1:
+            return True
+
+        elif s1[i] != s2[j] :
+            j-=1
+       
+        j+=1
+
+    if i!=j:
+        print(i,j)
+        return False
+    else:
+        return True
+
diff --git a/ent2b.py b/ent2b.py
@@ -0,0 +1,18 @@
+def nth_to_last(head,k): 
+
+    if head != None:
+        p1 = head
+
+        for i in range(k):
+            if head != None:
+                head = head.next
+            else:
+                return
+
+        p2 = head
+
+        while p2 != None:
+            p1 = p1.next
+            p2 = p2.next
+
+        return p1
diff --git a/ent3a.py b/ent3a.py
@@ -0,0 +1,47 @@
+# How would you design a stack which, in addition to push and pop, has a function min which returns the minimum element? Push, pop and min should all operate in O(1) time.
+
+class Stack:
+    def __init__(self):
+        # Your subclass must not access this attribute
+        self._items = []
+        self._mitems = []
+
+    def push(self, value):
+        self._items.append(value)
+        StackWithMin.check_min_push(self,value)
+
+    def pop(self):
+        value = self._items.pop()
+        StackWithMin.check_min_pop(self,value)
+        return value
+
+    def peek(self):
+        return self._items[-1]
+
+    def empty(self):
+        return len(self) == 0
+
+    def __len__(self):
+        return len(self._items)
+
+class StackWithMin(Stack):
+    def __init__(self):
+        self._items = []
+        self._mitems = []
+        
+    def check_min_push(self, value):
+        if self._mitems:
+            if value <= self.minimum() :
+                self._mitems.append(value)
+
+        else:
+             self._mitems.append(value)
+
+    def check_min_pop(self, value):
+        if self._mitems:
+            if value<= self.minimum():
+                self._mitems.pop()
+
+    def minimum(self):
+        if self._mitems:
+            return self._mitems[-1]
diff --git a/ent4a.py b/ent4a.py
@@ -0,0 +1,36 @@
+class TreeNode:
+    def __init__(self, value=None, left=None, right=None, parent=None):
+        self.value = value
+        self.left = left
+        self.right = right
+        self.parent = parent
+
+def in_order_succ(node: TreeNode) -> TreeNode:
+
+    if node is not None:
+        if node.right is not None:
+            buff = node.right
+            
+            while buff.left is not None:
+                buff = buff.left
+
+            return buff
+            
+        elif node.parent is not None:
+            if node.parent.value < node.value:
+                buff = node.parent
+
+                while buff and buff.value < node.value:
+                    buff = buff.parent
+
+                return buff
+
+            else:
+                return node.parent
+            
+        else:
+            return None
+
+    else:
+        return None
+        
diff --git a/entrevista3.py b/entrevista3.py
@@ -0,0 +1,52 @@
+# DO NOT CHANGE THIS CLASS
+class Stack:
+    def __init__(self):
+        self._items = []
+
+    def push(self, value):
+        self._items.append(value)
+
+    def pop(self):
+        return self._items.pop()
+
+    def peek(self):
+        return self._items[-1]
+
+    def is_empty(self):
+        return len(self) == 0
+
+    def __len__(self):
+        return len(self._items)
+
+
+# IMPLEMENT YOUR SOLUTION HERE (DO NOT CHANGE THE ARGUMENTS)
+def sort_stack(stack):
+    stack2 = Stack()
+    
+    if stack.is_empty():
+        return stack
+    tmp = stack.pop()
+    stack2.push(tmp)
+    tmp = None
+
+    while True:
+        if stack.__len__() == 0:
+            break
+        elif tmp == None:
+            tmp = stack.pop()
+        
+        if stack2.is_empty():
+            stack2.push(tmp)
+            tmp = None
+        elif stack2.peek() > tmp:
+            stack.push(stack2.pop())
+        else:
+            stack2.push(tmp)
+            tmp = None
+    
+    while stack2.__len__() != 0:
+        stack.push(stack2.pop())
+
+    
+    return stack
+
diff --git a/tests.py b/tests.py
@@ -0,0 +1,69 @@
+from strtest import str_test
+
+
+class Node:
+    def __init__(self, v=None, n=None):
+        self.value = v
+        self.next = n
+
+
+class TestCase(str_test.TestCaseWrapper):
+    TIMEOUT = 1
+
+    def _make_list(self, l):
+        nodes = []
+        for v in l:
+            n = Node(v)
+            if nodes:
+                nodes[-1].next = n
+            nodes.append(n)
+        return nodes
+
+    def _strlist(self, l):
+        s = []
+        while l:
+            s.append(f'{l.value}')
+            l = l.next
+        return '->'.join(s) or 'Empty'
+
+    def _check(self, values, k):
+        head = None
+        expected = None
+        if values:
+            l = self._make_list(values)
+            head = l[0]
+            if k <= len(l):
+                expected = l[-k]
+        ret = self.function(head, k)
+        e = f'Não funcionou para a lista "{self._strlist(head)}" e k={k}'
+        self.assertEqual(expected, ret, msg=e)
+
+    def test_1(self):
+        self._check(None, 10)
+
+    def test_2(self):
+        self._check([1, 1, 1, 1, 1, 1], 3)
+
+    def test_3(self):
+        self._check(range(1, 11), 1)
+
+    def test_4(self):
+        self._check(range(1, 11), 10)
+
+    def test_5(self):
+        self._check(range(1, 11), 20)
+
+    def test_6(self):
+        self._check(range(1, 11), 2)
+
+    def test_7(self):
+        self._check(range(1, 11), 3)
+
+    def test_8(self):
+        self._check(range(1, 11), 4)
+
+    def test_9(self):
+        self._check(range(1, 11), 5)
+
+    def test_10(self):
+        self._check(range(1, 11), 6)
diff --git a/trapping-rain-water.py b/trapping-rain-water.py
@@ -0,0 +1,34 @@
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        left = 0
+        left_pointer = left
+
+        right = len(height)-1
+        right_pointer = right
+        
+        vol = 0
+
+        while left_pointer < right_pointer :
+            
+            if height[left_pointer] <= height[right_pointer]:
+                left_pointer+=1
+                
+                if height[left_pointer] <= height[left]:
+                    vol+= abs(height[left_pointer]-height[left])
+                    
+                else:
+                    left=left_pointer
+                    
+            else:
+                right_pointer-=1
+                
+                if height[right_pointer] <= height[right]:
+                    vol+= abs(height[right_pointer]-height[right])
+                
+                else:
+                    right=right_pointer
+                    
+        return vol
+
+                
+            
diff --git a/twosum.py b/twosum.py
@@ -0,0 +1,7 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        
+       for i in range(len(nums)):
+            for j in range(i+1, len(nums)):
+                if nums[i] + nums[j] == target:
+                    return [i, j]
diff --git a/zigzag.py b/zigzag.py
@@ -0,0 +1,27 @@
+class Solution:
+    def convert(self, s: str, numRows: int) -> str:
+        if numRows <=1:
+            return s
+        
+        row = 0
+        fixed = ['']*(len(s))
+        
+        for i in range(len(s)):
+            fixed[row]+=s[i]
+            
+            if row == numRows-1: 
+                flag = False
+                    
+            elif row == 0: 
+                flag = True
+  
+            if flag: 
+                row += 1
+            else: 
+                row -= 1
+                
+        fixed = ''.join(fixed)
+            
+        return fixed
+        
+        
