Merge pull request #987 from gmlwls96/main

[gmlwls96] week9

Author: SamTheKorean

find-minimum-in-rotated-sorted-array/gmlwls96.kt

@@ -0,0 +1,24 @@
+class Solution {
+    // 시간 : O(logN) 공간 : O(1)
+    // 이분탐색.
+    fun findMin(nums: IntArray): Int {
+        var left = 0
+        var right = nums.lastIndex
+
+        while (left <= right){
+            val mid = (left + right)/2
+            when{
+                nums[mid-1] > nums[mid] -> {
+                    return nums[mid]
+                }
+                nums[0] < nums[mid] -> {
+                    left = mid + 1
+                }
+                else -> {
+                    right = mid -1
+                }
+            }
+        }
+        return nums[0]
+    }
+}

linked-list-cycle/gmlwls96.kt

@@ -0,0 +1,16 @@
+class Solution {
+    // 시간 : O(n)
+    // 세트에 head.val 값을 추가하면서 동일한 값이 있는지 체크. 동일한 값이 존재하면 순회한다고 판단.
+    fun hasCycle(head: ListNode?): Boolean {
+        val set = mutableSetOf<Int>()
+        var next = head
+        while (next != null) {
+            if (set.contains(next.`val`)) {
+                return true
+            }
+            set.add(next.`val`)
+            next = next.next
+        }
+        return false
+    }
+}

longest-substring-without-repeating-characters/gmlwls96.kt

@@ -0,0 +1,15 @@
+class Solution {
+    fun maxProduct(nums: IntArray): Int {
+        var max = 1
+        var min = 1
+        var result = nums[0]
+        nums.forEach { num ->
+            val v1 = min * num
+            val v2 = max * num
+            min = min(min(v1, v2), num)
+            max = max(max(v1, v2), num)
+            result = max(max, result)
+        }
+        return result
+    }
+}

maximum-product-subarray/gmlwls96.kt

@@ -0,0 +1,32 @@
+class Solution {
+    fun minWindow(s: String, t: String): String {
+        if (s.length < t.length) {
+            return ""
+        }
+        val containIndexList = mutableListOf<Int>()
+        for (i in s.indices) {
+            if (t.contains(s[i])) {
+                containIndexList.add(i)
+            }
+        }
+        var answer = ""
+        val regex =
+            t.toCharArray().joinToString(separator = "", prefix = "^", postfix = ".+$") { """(?=.*${it})""" }.toRegex()
+        for (i in 0..containIndexList.size - t.length) {
+            val startIndex = containIndexList[i]
+            for (l in t.length..containIndexList.size - i) {
+                val endIndex = containIndexList[(i + l) - 1] + 1
+                val subStr = s.substring(startIndex, endIndex)
+                if (regex.containsMatchIn(subStr)) {
+                    if (answer.isEmpty()) {
+                        answer = subStr
+                    } else if (subStr.length < answer.length) {
+                        answer = subStr
+                    }
+                    break
+                }
+            }
+        }
+        return answer
+    }
+}