Update repos

.github/ISSUE_TEMPLATE/submit-a-leetcode-problem.md

@@ -2,7 +2,7 @@
 name: Submit a LeetCode Problem
 about: Use this Template to submit a new LeetCode Problem
 title: 00## - LeetCode Problem Title
-labels: 'hacktoberfest, help wanted, good first issue'
+labels: 'hacktoberfest'
 assignees: ''
 
 ---

CONTRIBUTING.md

@@ -4,12 +4,18 @@
 Please make sure your file is in the `LeetCode`-Folder and Named like this:
 `0001_TwoSum.py` -> 4-digit Number of the LeetCode Issue, Underscore, LeetCodeName
 
-## Pull Requests
+### Opening Issues
+When you open an issue, please make sure the Problem is not already implemented (Look at Code/Leetcode for the Problemnumber). 
+Opened Issues by existing Problem will be closed & PR made to this Issue marked as **spam**
+The Contributer who opened an issue will be assigned prefered to the issue. If there is no PR within about 7 Days the issue will be assigned to another Contributer.
+
+### Pull Requests
 Only Pull Requests **joined with an Issue** and matching the **naming-conventions** (See Folders and Files) will be merged!
 If there is no Issue joined in the PR your PR will be labeld as **spam** and closed.
-If your code don't passes the Check on LeetCode.com your PR will be labeld as **"invalid"** and the Issue stays open for the next PR!
+If your code don't passes the Check on LeetCode.com your PR will be labled as **"invalid"** and the Issue stays open for the next PR!
+If your PR doesn' follow the Contributing Guidelines of this Repository it will be also marked as **spam** and closed!
 
-## Which PR will be accepted?
+## Which PR's will be accepted?
 * Ones you are assigned to
 * Your PR has to link the Issue
 * Your Solution must be correct - you can check ist on LeetCode (submit) if it works on different test-cases

LeetCode/0003_Longest_Substring_Without_Repeating_Characters.py

@@ -0,0 +1,14 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        map_chars = {}
+        longest = 0
+        j = 0
+
+        for i in range(0, len(s)):
+            if s[i] in map_chars.keys():
+                j = max(j, map_chars[s[i]] + 1)
+
+            longest = max(longest, i - j + 1)
+            map_chars[s[i]] = i
+
+        return longest

LeetCode/0005_Longest_Palindromic_Substring.py

@@ -0,0 +1,38 @@
+'''
+Problem:-
+
+Given a string s, find the longest palindromic substring in s. 
+You may assume that the maximum length of s is 1000.
+
+Example 1:
+    Input: "babad"
+    Output: "bab"
+    Note: "aba" is also a valid answer.
+
+'''
+
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        res = ""
+        resLen = 0
+
+        for i in range(len(s)):
+            # odd length
+            l, r = i, i
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                if (r - l + 1) > resLen:
+                    res = s[l:r + 1]
+                    resLen = r - l + 1
+                l -= 1
+                r += 1
+
+            # even length
+            l, r = i, i + 1
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                if (r - l + 1) > resLen:
+                    res = s[l:r + 1]
+                    resLen = r - l + 1
+                l -= 1
+                r += 1
+
+        return res

LeetCode/0008_String_to_Integer.py

@@ -0,0 +1,26 @@
+class Solution:
+    def myAtoi(self, s: str) -> int:
+        INT_MAX = (1 << 31) - 1
+        INT_MIN = -(1 << 31)
+
+        ret = 0
+        s = s.strip()
+
+        if s == "":
+            return ret
+
+        negate = -1 if s[0] == '-' else 1
+
+        if s[0] in ('+', '-'):
+            s = s[1::]
+
+        for c in s:
+            if not '0' <= c <= '9':
+                break
+
+            ret = ret * 10 + ord(c) - ord('0')
+
+        ret *= negate
+        ret = min(max(ret, INT_MIN), INT_MAX)
+
+        return ret

LeetCode/0009_Palindrom_Number.py

@@ -0,0 +1,12 @@
+class Solution:
+    def isPalindrome(self, x: int) -> bool:
+        if x > 0 and x < 10:
+            return True
+
+        copyNumber = x
+        newNumber = 0
+        while copyNumber > 0:
+            newNumber = int(newNumber * 10 + (copyNumber % 10))
+            copyNumber = int(copyNumber / 10)
+
+        return newNumber == x

LeetCode/0010_Regular_Expression_Matching.py

@@ -0,0 +1,20 @@
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        string, pattern = [], []
+        string[:0], pattern[:0] = s, p
+        string.insert(0, 0) 
+        pattern.insert(0, 0)
+        s, p = len(string), len(pattern)
+        dp = [[False for _ in range(p)] for __ in range(s)]
+        dp[0][0] = True
+        for i in range(p):
+            if pattern[i] is '*' and dp[0][i-2]: dp[0][i] = True 
+        for i in range(1, s):
+            for j in range(1, p):
+                if pattern[j] is string[i] or pattern[j] is '.':
+                    dp[i][j] = dp[i-1][j-1]
+                elif pattern[j] is '*' and (pattern[j-1] is string[i] or pattern[j-1] is '.'):
+                    dp[i][j] = dp[i][j-2] or dp[i-1][j]
+                elif pattern[j] is '*' and not (pattern[j-1] is string[i] or pattern[j-1] is '.'):
+                    dp[i][j] = dp[i][j-2]
+        return dp[s-1][p-1]

LeetCode/0011 - Container With Most Water.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def maxArea(self, height):
+        i=0
+        j=len(height)-1
+        a=0
+        b=0
+        while i<j:
+            if height[i]<height[j]:
+                b=(j-i)*height[i]
+                i+=1
+            else:
+                b=(j-i)*height[j]
+                j-=1
+            if b>a:
+                a=b
+        return a

LeetCode/0013_Roman to Integer.py

@@ -0,0 +1,32 @@
+class Solution:
+    def romanToInt(self, s: str) -> int:
+
+        symbolValDict = {
+            'I':1,
+            'V':5,
+            'X':10,
+            'L':50,
+            'C':100,
+            'D':500,
+            'M':1000
+        }
+
+
+        i = 0
+        finalDigit = 0
+        while(i<len(s)):
+            firstDigit = symbolValDict[s[i]]
+            if(i+1 < len(s)):
+                nextDigit = symbolValDict[s[i+1]]
+                if firstDigit >= nextDigit:
+                    finalDigit += firstDigit
+                    i+=1
+                else:
+                    finalDigit += nextDigit - firstDigit
+                    i+=2
+            else:
+                finalDigit += firstDigit
+                i+=1
+
+
+        return finalDigit

LeetCode/0017_Letter_Combinations_of_a_Phone_Number.py

@@ -0,0 +1,19 @@
+import itertools
+from typing import List
+
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        keyboard = {
+            '2': "abc",
+            '3': "def",
+            '4': "ghi",
+            '5': "jkl",
+            '6': "mno",
+            '7': "pqrs",
+            '8': "tuv",
+            '9': "wxyz",
+        }
+
+        pressed = [keyboard[c] for c in digits]
+
+        return [''.join(p) for p in itertools.product(*pressed) if p != ()]

LeetCode/0020_Valid_Parentheses.py

@@ -0,0 +1,16 @@
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = []
+        openbrackets = ('(', '[', '{')
+        matches = ('()', '[]', '{}')
+
+        for c in s:
+            if c in openbrackets:
+                stack.append(c)
+            else:
+                if len(stack) < 1 or stack[-1] + c not in matches:
+                    return False
+
+                stack.pop()
+
+        return len(stack) == 0

LeetCode/0022_GenerateParenthesis.py

@@ -0,0 +1,25 @@
+class Solution:
+    def generateParenthesis(self, n: int) -> List[str]:
+        def isValid(s: str) -> bool:
+            stk = []
+            for b in s:
+                if b == '(':
+                    stk.append(b)
+                else:
+                    if stk and stk[-1] == '(':
+                        stk.pop()
+                    else:
+                        return False
+            return stk == []
+
+        ans = []
+        for mask in range(1<<(2*n)):
+            s = ""
+            for bit in range(2*n):
+                if mask & (1<<bit):
+                    s += '('
+                else:
+                    s += ')'
+            if isValid(s):
+                ans.append(s)
+        return ans

LeetCode/0024_ Swap_Nodes_in_Pairs.py

@@ -0,0 +1,27 @@
+'''
+Problem:-
+
+Given a linked list, swap every two adjacent nodes and return its head.
+You may not modify the values in the list's nodes, only nodes itself may be changed.
+
+Example:
+- Given 1->2->3->4, you should return the list as 2->1->4->3.
+
+'''
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def swapPairs(self, head: ListNode) -> ListNode:
+        pre, pre.next = self, head
+        while pre.next and pre.next.next:
+            a = pre.next
+            b = a.next
+            pre.next, b.next, a.next = b, a, b.next
+            pre = a
+        return self.next
+
+

LeetCode/0028_strStr.py

@@ -0,0 +1,22 @@
+class Solution(object):
+   def strStr(self, haystack, needle):
+
+      i = 0
+      j = 0
+      m = len(needle)
+      n = len(haystack)
+      if m ==0:
+         return 0
+      while i<n and n-i+1>=m:
+         if haystack[i] == needle[j]:
+            temp = i
+            while j<m and i<n and needle[j]==haystack[i]:
+               i+=1
+               j+=1
+            if j == m:
+               return temp
+            i= temp+1
+            j = 0
+         else:
+            i+=1
+      return -1

LeetCode/0032_Longest_Valid_Parentheses.py

@@ -0,0 +1,44 @@
+from typing import List, Dict
+
+class Solution:
+    def _score(self, position: List[int], state: Dict[int,bool]) -> List[int]:
+        score = 0
+        scores = list()
+        for pos in position:
+            matched = state.get(pos)
+            if not matched:
+                scores.append(score)
+                score = 0
+
+            else:
+                score = score + 2
+
+        scores.append(score)
+
+        return scores
+
+    def longestValidParentheses(self, s: str) -> int:
+        scores = [0]
+        state = dict()
+        position = list()
+        opened = list()
+        closed = list()
+        for p, paren in enumerate(s):
+            if paren == "(":
+                opened.append(p)
+                position.append(p)
+                state[p] = False
+
+            elif paren == ")" and len(opened) > 0:
+                op = opened.pop()
+                state[op] = True
+
+            else:
+                scores.extend(self._score(position, state))
+                state = dict()
+                position = list()
+                opened = list()
+                closed = list()
+
+        scores.extend(self._score(position, state))
+        return max(scores)