diff --git a/leetcode/1.py b/leetcode/1.py
new file mode 100644
index 0000000..8586a80
--- /dev/null
+++ b/leetcode/1.py
@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        answer=()
+        for i in range(len(nums)):
+            for j in range(i+1,len(nums)):
+                if nums[i]+nums[j]==target:
+                    answer=(i,j)
+        return list(answer)
diff --git a/leetcode/101.py b/leetcode/101.py
new file mode 100644
index 0000000..5f8713d
--- /dev/null
+++ b/leetcode/101.py
@@ -0,0 +1,38 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def leftSearch(self,stack:List[TreeNode],now:Optional[TreeNode]):
+        if now==None:
+            stack.append(None)
+        else:
+            stack.append(now.val)
+            self.leftSearch(stack,now.left)
+            self.leftSearch(stack,now.right)
+    def rightSearch(self,stack:List[TreeNode],now:Optional[TreeNode]) -> bool:
+        if len(stack)<1:
+            return False
+        if now==None:
+            if not(stack.pop()==now):
+                return False
+            return True
+        elif not self.rightSearch(stack,now.left):
+            return False
+        elif not self.rightSearch(stack,now.right):
+            return False
+        elif not stack.pop()==now.val:
+            return False
+        return True
+
+    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
+        stack=[]
+        self.leftSearch(stack,root.left)
+        isSym=self.rightSearch(stack,root.right)
+
+        if isSym and len(stack)==0:
+            return True
+        else:
+            return False
diff --git a/leetcode/104.py b/leetcode/104.py
new file mode 100644
index 0000000..17c3371
--- /dev/null
+++ b/leetcode/104.py
@@ -0,0 +1,13 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def depth(self,now:Optional[TreeNode],depth:int):
+        if now==None:
+            return depth-1
+        return max(self.depth(now.left,depth+1),self.depth(now.right,depth+1),depth)
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        return self.depth(root,1)
diff --git a/leetcode/118.py b/leetcode/118.py
new file mode 100644
index 0000000..715e349
--- /dev/null
+++ b/leetcode/118.py
@@ -0,0 +1,11 @@
+class Solution:
+    def generate(self, numRows: int) -> List[List[int]]:
+        arr=[[1]]
+
+        for r in range(2,numRows+1):
+            nr=[1]
+            for i in range(1,r-1):
+                nr.append(arr[r-2][i-1]+arr[r-2][i])
+            nr.append(1)
+            arr.append(nr)
+        return arr
diff --git a/leetcode/121.py b/leetcode/121.py
new file mode 100644
index 0000000..40daae6
--- /dev/null
+++ b/leetcode/121.py
@@ -0,0 +1,9 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        result=0
+        mi=prices[0]
+
+        for i in range(1,len(prices)):
+            mi=min(prices[i],mi)
+            result=max(prices[i]-mi,result)
+        return result
diff --git a/leetcode/125.py b/leetcode/125.py
new file mode 100644
index 0000000..efe46d7
--- /dev/null
+++ b/leetcode/125.py
@@ -0,0 +1,11 @@
+import re
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        ns=re.sub(r"[^A-Za-z0-9]","",s).lower()
+        
+        isPal=True
+        for i in range(len(ns)//2):
+            if not ns[i]==ns[-i-1]:
+                isPal=False
+                break
+        return isPal
diff --git a/leetcode/13.py b/leetcode/13.py
new file mode 100644
index 0000000..388ad08
--- /dev/null
+++ b/leetcode/13.py
@@ -0,0 +1,16 @@
+class Solution:
+    def romanToInt(self, s: str) -> int:
+        sv={'M':1000,'D':500,'C':100,'L':50,'X':10,'V':5,'I':1}
+        msv={'C':set(['D','M']),'X':set(['L','C']),'I':set(['V','X'])}
+        r=0
+        mc=''
+
+        for c in s:
+            r+=sv[c]
+            if mc in msv and c in msv[mc]:
+                r-=(sv[mc]*2)
+            if c in msv:
+                mc=c
+            else:
+                mc=''
+        return r
diff --git a/leetcode/136.py b/leetcode/136.py
new file mode 100644
index 0000000..189d373
--- /dev/null
+++ b/leetcode/136.py
@@ -0,0 +1,15 @@
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        nums.sort()
+        last=nums[0]
+        count=1
+
+        for i in range(1,len(nums)):
+            if not last==nums[i]:
+                if count==1:
+                    break
+                last=nums[i]
+                count=1
+            else:
+                count+=1
+        return last
diff --git a/leetcode/14.py b/leetcode/14.py
new file mode 100644
index 0000000..2e72cab
--- /dev/null
+++ b/leetcode/14.py
@@ -0,0 +1,14 @@
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        last=strs[0]
+        for i in range(1,len(strs)):
+            if len(last)<1:
+                break
+
+            for j in range(min(len(last),len(strs[i]))):
+                if not last[j]==strs[i][j]:
+                    last=last[0:j]
+                    break
+            if len(last)>len(strs[i]):
+                last=last[0:len(strs[i])]
+        return last
diff --git a/leetcode/141.py b/leetcode/141.py
new file mode 100644
index 0000000..2f9dac7
--- /dev/null
+++ b/leetcode/141.py
@@ -0,0 +1,15 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        h2=head
+        while h2 and h2.next:
+            head=head.next
+            h2=h2.next.next
+            if head==h2:
+                return True
+        return False
diff --git a/leetcode/160.py b/leetcode/160.py
new file mode 100644
index 0000000..372a8bf
--- /dev/null
+++ b/leetcode/160.py
@@ -0,0 +1,23 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
+        al=set()
+
+        r=None
+        a=headA
+        b=headB
+        while a:
+            al.add(a)
+            a=a.next
+        while b:
+            if b in al:
+                r=b
+                break
+            b=b.next
+        
+        return r
diff --git a/leetcode/169.py b/leetcode/169.py
new file mode 100644
index 0000000..b54e14c
--- /dev/null
+++ b/leetcode/169.py
@@ -0,0 +1,16 @@
+class Solution:
+    def majorityElement(self, nums: List[int]) -> int:
+        nums.sort()
+        print(nums)
+        last=(nums[0],1)
+        mx=last
+
+        for i in range(1,len(nums)):
+            if nums[i]==last[0]:
+                last=(last[0],last[1]+1)
+            else:
+                last=(nums[i],1)
+
+            if mx[1]<last[1]:
+                mx=last
+        return mx[0]
diff --git a/leetcode/171.py b/leetcode/171.py
new file mode 100644
index 0000000..1380954
--- /dev/null
+++ b/leetcode/171.py
@@ -0,0 +1,11 @@
+class Solution:
+    def titleToNumber(self, columnTitle: str) -> int:
+        dnum={}
+        for i in range(26):
+            dnum[chr(ord('A')+i)]=i+1
+
+        result=0
+        for i in range(1,len(columnTitle)+1):
+            c=columnTitle[-i]
+            result+=dnum[c]*(26**(i-1))
+        return result
diff --git a/leetcode/190.py b/leetcode/190.py
new file mode 100644
index 0000000..9c08728
--- /dev/null
+++ b/leetcode/190.py
@@ -0,0 +1,11 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        r=""
+        b=bin(n)
+
+        for i in range(1,32+1):
+            if i>len(b)-2:
+                r+="0"
+            else:
+                r+=b[-i]
+        return int(r,2)
diff --git a/leetcode/191.py b/leetcode/191.py
new file mode 100644
index 0000000..409475c
--- /dev/null
+++ b/leetcode/191.py
@@ -0,0 +1,9 @@
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        count=0
+        b=bin(n)
+
+        for i in range(2,len(b)):
+            if b[i]=="1":
+                count+=1
+        return count
diff --git a/leetcode/2.py b/leetcode/2.py
new file mode 100644
index 0000000..3425828
--- /dev/null
+++ b/leetcode/2.py
@@ -0,0 +1,26 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        v1=""
+        v2=""
+
+        while not l1==None:
+            v1=str(l1.val)+v1
+            l1=l1.next
+        while not l2==None:
+            v2=str(l2.val)+v2
+            l2=l2.next
+            
+        vr=str(int(v1)+int(v2))
+        r=ListNode()
+        now=r
+        for i in range(1,len(vr)+1):
+            now.val=vr[-i]
+            if i<len(vr):
+                now.next=ListNode()
+                now=now.next
+        return r
diff --git a/leetcode/20.py b/leetcode/20.py
new file mode 100644
index 0000000..29432fa
--- /dev/null
+++ b/leetcode/20.py
@@ -0,0 +1,21 @@
+class Solution:
+    def isValid(self, s: str) -> bool:
+        arr=[]
+
+        for c in s:
+            if c in ['(','{','[']:
+                arr.append(c)
+                continue
+
+            if c in [')','}',']']:
+                if len(arr)<0+1:
+                    return False
+                p=arr.pop()
+
+                if not((c==')' and p=='(') or (c=='}' and p=='{') or (c==']' and p=='[')):
+                    return False
+
+        if len(arr)>0:
+            return False
+        else:
+            return True
diff --git a/leetcode/202.py b/leetcode/202.py
new file mode 100644
index 0000000..427219f
--- /dev/null
+++ b/leetcode/202.py
@@ -0,0 +1,13 @@
+class Solution:
+    def isHappy(self, n: int) -> bool:
+        s=str(n)
+        while not len(s)==1:
+            r=0
+            for i in range(len(s)):
+                r+=int(s[i])**2
+            s=str(r)
+        
+        if s=="1" or s=="7":
+            return True
+        else:
+            return False
diff --git a/leetcode/206.py b/leetcode/206.py
new file mode 100644
index 0000000..182c782
--- /dev/null
+++ b/leetcode/206.py
@@ -0,0 +1,19 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        l=[]
+        while not head==None:
+            n=ListNode(head.val)
+            l.append(n)
+            head=head.next
+        
+        r=ListNode()
+        rt=r
+        while len(l)>0:
+            rt.next=l.pop()
+            rt=rt.next
+        return r.next
diff --git a/leetcode/21.py b/leetcode/21.py
new file mode 100644
index 0000000..c53dd03
--- /dev/null
+++ b/leetcode/21.py
@@ -0,0 +1,37 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        result=ListNode()
+        re=result
+        li1=list1
+        li2=list2
+
+        while not li1==None and not li2==None:
+            n=ListNode()
+            if li1.val<li2.val:
+                n.val=li1.val
+                li1=li1.next
+            else:
+                n.val=li2.val
+                li2=li2.next
+            re.next=n
+            re=re.next
+        
+        while not li1==None:
+            n=ListNode()
+            n.val=li1.val
+            re.next=n
+            re=re.next
+            li1=li1.next
+        while not li2==None:
+            n=ListNode()
+            n.val=li2.val
+            re.next=n
+            re=re.next
+            li2=li2.next
+        
+        return result.next
diff --git a/leetcode/217.py b/leetcode/217.py
new file mode 100644
index 0000000..3ce8002
--- /dev/null
+++ b/leetcode/217.py
@@ -0,0 +1,11 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        l=set()
+        isDu=False
+        for i in nums:
+            if i in l:
+                isDu=True
+                break
+            else:
+                l.add(i)
+        return isDu
diff --git a/leetcode/234.py b/leetcode/234.py
new file mode 100644
index 0000000..169a7de
--- /dev/null
+++ b/leetcode/234.py
@@ -0,0 +1,16 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def isPalindrome(self, head: Optional[ListNode]) -> bool:
+        l=[]
+        while not head==None:
+            l.append(head.val)
+            head=head.next
+        
+        for i in range(len(l)//2):
+            if not l[i]==l[-i-1]:
+                return False
+        return True
diff --git a/leetcode/242.py b/leetcode/242.py
new file mode 100644
index 0000000..8d6c89a
--- /dev/null
+++ b/leetcode/242.py
@@ -0,0 +1,21 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        d={}
+
+        if not len(s)==len(t):
+            return False
+        for i in s:
+            if i in d:
+                d[i]+=1
+            else:
+                d[i]=1
+        for i in t:
+            if i in d:
+                d[i]-=1
+            else:
+                return False
+        
+        for i in d.keys():
+            if not d[i]==0:
+                return False
+        return True
diff --git a/leetcode/26.py b/leetcode/26.py
new file mode 100644
index 0000000..bc07fe9
--- /dev/null
+++ b/leetcode/26.py
@@ -0,0 +1,8 @@
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        arr=sorted(list(set(nums)))
+        count=len(arr)
+
+        for i in range(count):
+            nums[i]=arr[i]
+        return count
diff --git a/leetcode/268.py b/leetcode/268.py
new file mode 100644
index 0000000..a5c8bb0
--- /dev/null
+++ b/leetcode/268.py
@@ -0,0 +1,11 @@
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        last=-1
+        nums.sort()
+        for i in range(len(nums)):
+            if not last+1==nums[i]:
+                break
+            else:
+                last+=1
+        
+        return last+1
diff --git a/leetcode/28.py b/leetcode/28.py
new file mode 100644
index 0000000..4bb939b
--- /dev/null
+++ b/leetcode/28.py
@@ -0,0 +1,3 @@
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+        return haystack.find(needle)
diff --git a/leetcode/283.py b/leetcode/283.py
new file mode 100644
index 0000000..2773f09
--- /dev/null
+++ b/leetcode/283.py
@@ -0,0 +1,17 @@
+class Solution:
+    def moveZeroes(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        s=0
+        z=0
+        for i in range(len(nums)):
+            v=nums[i]
+
+            if v==0:
+                z+=1
+            else:
+                nums[s]=v
+                s+=1
+        for i in range(1,z+1):
+            nums[-i]=0
diff --git a/leetcode/326.py b/leetcode/326.py
new file mode 100644
index 0000000..3cf6d43
--- /dev/null
+++ b/leetcode/326.py
@@ -0,0 +1,9 @@
+class Solution:
+    def isPowerOfThree(self, n: int) -> bool:
+        last=1
+        while last<n:
+            last*=3
+        if last==n:
+            return True
+        else:
+            return False
diff --git a/leetcode/344.py b/leetcode/344.py
new file mode 100644
index 0000000..fb4b9e2
--- /dev/null
+++ b/leetcode/344.py
@@ -0,0 +1,7 @@
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
+        """
+        Do not return anything, modify s in-place instead.
+        """
+        for i in range(len(s)//2):
+            s[i],s[-i-1]=s[-i-1],s[i]
diff --git a/leetcode/350.py b/leetcode/350.py
new file mode 100644
index 0000000..f443950
--- /dev/null
+++ b/leetcode/350.py
@@ -0,0 +1,15 @@
+class Solution:
+    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        result=[]
+        check={}
+
+        for i in nums1:
+            if i in check:
+                check[i]+=1
+            else:
+                check[i]=1
+        for i in nums2:
+            if i in check and check[i]>0:
+                check[i]-=1
+                result.append(i)
+        return result
diff --git a/leetcode/387.py b/leetcode/387.py
new file mode 100644
index 0000000..7374d30
--- /dev/null
+++ b/leetcode/387.py
@@ -0,0 +1,15 @@
+class Solution:
+    def firstUniqChar(self, s: str) -> int:
+        d={}
+
+
+        for i in range(len(s)):
+            if s[i] in d:
+                d[s[i]]=-1
+            else:
+                d[s[i]]=i
+        
+        for i in d.values():
+            if i>-1:
+                return i
+        return -1
diff --git a/leetcode/412.py b/leetcode/412.py
new file mode 100644
index 0000000..1858ca7
--- /dev/null
+++ b/leetcode/412.py
@@ -0,0 +1,13 @@
+class Solution:
+    def fizzBuzz(self, n: int) -> List[str]:
+        result=[]
+        for i in range(1,n+1):
+            s=""
+            if i%3==0:
+                s+="Fizz"
+            if i%5==0:
+                s+="Buzz"
+            if s=="":
+                s=str(i)
+            result.append(s)
+        return result
diff --git a/leetcode/66.py b/leetcode/66.py
new file mode 100644
index 0000000..2b2db0e
--- /dev/null
+++ b/leetcode/66.py
@@ -0,0 +1,21 @@
+class Solution:
+    def plusOne(self, digits: List[int]) -> List[int]:
+        arr=[]
+        isUp=False
+
+        digits[-1]+=1
+        for i in range(1,len(digits)+1):
+            if isUp:
+                digits[-i]+=1
+                isUp=False
+            
+            if digits[-i]>9:
+                isUp=True
+                digits[-i]=0
+        
+        if isUp:
+            arr.append(1)
+        for i in digits:
+            arr.append(i)
+        
+        return arr
diff --git a/leetcode/70.py b/leetcode/70.py
new file mode 100644
index 0000000..0db9a48
--- /dev/null
+++ b/leetcode/70.py
@@ -0,0 +1,8 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dp=[0,1,2]
+
+        for i in range(3,n+1):
+            dp.append(dp[i-2]+dp[i-1])
+        
+        return dp[n]
diff --git a/leetcode/88.py b/leetcode/88.py
new file mode 100644
index 0000000..46f85a1
--- /dev/null
+++ b/leetcode/88.py
@@ -0,0 +1,24 @@
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        narr=[]
+        cnt1=0
+        cnt2=0
+
+        while cnt1<m and cnt2<n:
+            v=0
+            if nums1[cnt1]<nums2[cnt2]:
+                v=nums1[cnt1]
+                cnt1+=1
+            else:
+                v=nums2[cnt2]
+                cnt2+=1
+            narr.append(v)
+        while cnt1<m:
+            narr.append(nums1[cnt1])
+            cnt1+=1
+        while cnt2<n:
+            narr.append(nums2[cnt2])
+            cnt2+=1
+
+        for i in range(n+m):
+            nums1[i]=narr[i]
diff --git a/leetcode/94.py b/leetcode/94.py
new file mode 100644
index 0000000..0af7348
--- /dev/null
+++ b/leetcode/94.py
@@ -0,0 +1,20 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def inorder(self, now: Optional[TreeNode], result: List[int]):
+        if not now.left==None:
+            self.inorder(now.left,result)
+        result.append(now.val)
+        if not now.right==None:
+            self.inorder(now.right,result)
+
+    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        result=[]
+        if not root==None:
+            self.inorder(root,result)
+        
+        return result