[Jay-Mo-99] Week 1

contains-duplicate/Jay-Mo-99.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def containsDuplicate(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        #해석
+        #sets는 복수 요소를 허용하지 않는다(sets don't allow duplicate elements.)
+        #만약 set에 기반된 list가 기존 nums와 길이가 다르다면 duplicate element가 있었다는 뜻이다. 
+        #If the length of the set created from nums is different from the original list(nums), It means there are duplicates. 
+
+        #Big O
+        #N: 주어진 배열 nums의 길이(Length of the input list nums)
+
+        #Time Complexity: O(N)
+        #- set은 nums의 길이 n에 기반하여 생성된다(Creating a set from nums): O(N)
+        #- 생성된 list와 기존 nums와의 비교는 상수(Comparing the lengths between created list and original list) : O(1)
+
+        #Space Complexity: O(N)
+        #-set은 nums의 길이에 의해 생성되므로 n에 영향받음(The set requires extra space depends on the size of nums) : O(N) 
+        return len(list(set(nums))) != len(nums) #set된 list와 기존 nums의 len이 일치하지 않는다면 true(duplicate), 아니면 false
+
+

house-robber/Jay-Mo-99.py

@@ -0,0 +1,37 @@
+# --- 해석 ---
+#매개변수 nums 를 순회하면서 nums[i] 일때의 최대 누적값을 업데이트 한다
+#prev1은 현재까지의 최고 누적금액, prev2는 이전 집까지의 최고 누적금액이다. 
+#현재 집 nums[i] 를 도둑질 하려면, 이전 집까지의 최고금액(prev2) + 현재 집(nums[i])이다.
+#현재 집 nums[i]를 도둑질에 제외하려면 현재까지의 최고 금엑(prev1) 이다. 
+#loop 당 저 둘의 최댓값을 선택하여 current변수에 update해준다. 
+
+# --- Big O
+#N: 매개변수 nums의 길이가 N이다. 
+
+# Time Complexity: O(N)
+#- for loop 는 nums[0] 부터 nums[len(nums)]만큼 순회: O(N)
+
+# Space Complexity: O(1)
+#-current,prev1,prev2 는 nums와 무관한 상수 메로리 할당: O(1)
+
+
+class Solution(object):
+    def rob(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        #prev1: 현재 집까지의 최고 금액
+        #prev2: 이이전 집까지의 최고 금액 
+        prev1,prev2=0,0
+
+        for num in nums:
+            #current는 prev1과 prev2+num 중 큰 값을 update
+            current = max(prev1,prev2+num)
+            prev2 = prev1 #current업데이트 이후 prev1(현재 최고금액) 이 prev2(이어진 집까지 최고금액)가된다
+            prev1= current #prev1은 현 num까지 고려된 current의 값이다. (현재 최고 금액액)
+        return prev1
+nums = [2,7,9,3,1]
+solution = Solution()
+solution.rob(nums)
+

longest-consecutive-sequence/Jay-Mo-99.py

@@ -0,0 +1,49 @@
+# --- 해석 ---
+#매개변수 nums 를 set으로 바꿔서 중복제거
+#set을 list로 전환하여 sort하여 오름차순으로 변환
+#for loop 로 nums[1]부터 nums[len(nums)-1] 에 접근
+#nums[i]-nums[i-1] =1 이면 변수 current를 증가, longest는 current의 최댓값을 업데이트
+#만약 해당 조건을 만족하지 않는다면 current를 1로 초기화, 이후 longest 값 return   
+
+# --- Big O
+#N: 매개변수 nums의 길이가 N이다. 
+
+# Time Complexity: O(N)
+#- set(nums)는 nums의모든 요소를 하나씩 순회하며 중복 제거 : O(N)
+#- list(set(nums)) 는 data type을 변환하면서 nums의 갯수만큼 data를 추가 생성: O(N)
+#- for loop 는 nums[1] 부터 nums[len(nums)-1]만큼 순회: O(N)
+
+# Space Complexity: O(N)
+#-nums = list(set(nums)): list(),set(),dict() 이런 data type을 변환할때마다 N만큼 공간 추가할당: O(N)
+#-longest,current 변수는 상수 : O(1)
+
+class Solution(object):
+    def longestConsecutive(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        #If the nums doesn't have elements, return 0 
+        if len(nums) ==0:
+            return 0
+        #중복제거 set 
+        nums = list(set(nums))
+        #sort 
+        nums.sort()    
+        print(nums)
+
+        #Variables
+        longest = 1
+        current = 1
+
+        #Approah all element of nums for checking the sequnece number or not
+        for i in range(1,len(nums)):
+            if nums[i] == nums[i-1] + 1:
+                current +=1 #current는 nums[i]와 nums[i-1]의 차이가 1이면 +1해줌. 
+                longest = max(longest, current) #return값을 위해 currrent가 가장 크도록 업데이트 
+            else:#연속 되지 않을 시 current 1로 초기화
+                current =1 
+        print(longest)
+        return longest
+
+

top-k-frequent-elements/Jay-Mo-99.py

@@ -0,0 +1,43 @@
+        #해석
+        #nums를 dictionary로 전환한다. nums의 기존 element가 key, element의 갯수를 value값으로 지정한다.
+        #value값이 큰 순서대로 dictionary의 요소를 정렬한다
+        #그중 0에서 k-1까지의 key값만을 반환한다. 
+
+        #Big O
+        #N: 주어진 list의 길이 nums (Length of the input list nums)
+        #M: count 딕셔너리의 고유한 key 의 갯수 
+
+        #Time Complexity: O(NLogN)
+        #- count: N의 길이에 기반하여 생성된다 : O(N)
+        #- sorted_count: 파이썬의 sorted 메소드는 Timesort 알고리즘 기반의 비교 기반 정렬 알고리즘 
+        #                리스트의 길이가 M이면 sorted()는 요소들을 쪼개고 병합하여 정렬한다. 대략 M개의 요소를 logM번 비교 
+
+        #Space Complexity: O(N)
+        #- count: M개에 기반하여 Dictionary 공간 저장: O(M)
+        #- sorted_count: count.items의 갯수에 기반하여 공간 저장 : O(M)
+        #- dic_count: 상위 요소 갯수(k개) 만큼 저장 : O(k)
+        #- 최종: O(N) + O(M) + O(k): k는 최대 M개 만큼 가능하고 M은 최대 N개만큼 가능하다. 
+
+class Solution(object):
+    def topKFrequent(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: List[int]
+        """
+
+        #Create dictionary which have a key(element of nums) and value(count num of the element)
+        count = {}
+        for i in nums:
+            try: count[i] += 1
+            except: count[i] = 1
+
+        #Sort depends on the value descending order
+        sorted_count = sorted(count.items(),key=lambda x:x[1],reverse=True)
+        #k까지의 요소만을 dictionary data type으로 convert 
+        dic_count = dict(sorted_count[:k])
+        #Return keys 
+        return dic_count.keys()
+
+
+

valid-palindrome/Jay-Mo-99.py

@@ -0,0 +1,38 @@
+# --- 해석 ---
+#매개변수 s를 소문자로 변환 후 non alpha numeric(알파벳과 숫자 이외의 모든 것)을 제거하고 빈칸을 replace로 제거한 후 temp에 저장한다
+#temp와 temp를 뒤집힌 string(temp[::-1])을 비교하여, 둘이 같으면 palindrome이다. 
+
+# --- Big O
+#N: 매개변수 s의 길이가 N이다. 
+
+# Time Complexity: O(N)
+#- temp는 s의 길이에 기반하여 생성된다: O(N)
+#- 문자열 뒤집기(temp[::-1])도 s의 길이에 기반한다 : O(N)
+#- temp == temp[::-1]는 두 문자열이 길이와 문자 하나하나가 같은지 확인 :O(N)
+
+# Space Complexity: O(N)
+#-temp는 s의 길이에 의해 생성되므로 n에 영향받음(The temp requires extra space depends on the size of s) : O(N) 
+
+class Solution(object):
+    def isPalindrome(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+
+        #removes all non alpha numeric(only accept alphabet and number) items from the s
+        temp = lower(s)
+        temp = " ".join(re.split("[^a-zA-Z0-9]*",temp)).replace(" ","")
+        #Compare with temp and reverse temp 
+        #If they are same, it is palindrome
+        return temp == temp[::-1]
+
+
+
+
+
+
+
+
+
+