[gmlwls96] Week2

3sum/gmlwls96.kt

@@ -0,0 +1,18 @@
+class Solution {
+    // 시간 복잡도 : O(n^2)
+    fun threeSum(nums: IntArray): List<List<Int>> {
+        val mutableSet = mutableSetOf<List<Int>>() // 결과를 담기 위한 set. 중복을 없애야되서 set으로 만듬.
+        nums.sort() // 1. nums array를 정렬해주고
+        for (i in 0..nums.size - 3) {
+            for (j in i + 1..nums.size - 2) {
+                for (k in j + 1..nums.lastIndex) {
+                    // 2. nums의 3숫자를 뽑아내기 위해 i, j, k를 순차적으로 조회하면서 합했을때 0이 되는지 체크.
+                    if (nums[i] + nums[j] + nums[k] == 0) {
+                        mutableSet.add(listOf(nums[i], nums[j], nums[k]))
+                    }
+                }
+            }
+        }
+        return mutableSet.toList() // 3. 최종적으로 뽑아낸 결과를 return값에 맞게 set > list로 변환.
+    }
+}

climbing-stairs/gmlwls96.kt

@@ -0,0 +1,12 @@
+class Solution {
+    // 시간복잡도 : O(n)
+    fun climbStairs(n: Int): Int {
+        val dp = IntArray(n+1)
+        dp[1] = 1
+        dp[2] = 2
+        for(i in 3..n){ // 3부터 n까지 for문.
+            dp[i] = dp[i-1] + dp[i-2]
+        }
+        return dp[n]
+    }
+}

construct-binary-tree-from-preorder-and-inorder-traversal/gmlwls96.kt

@@ -0,0 +1,25 @@
+class Solution {
+    // 시간 : O(n^2)
+    fun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {
+        if (preorder.isEmpty() || inorder.isEmpty()) {
+            return null
+        }
+        val value = preorder[0]
+        var mid = inorder.indexOf(value)
+        if (mid < 0) {
+            mid = 0
+        }
+        val leftNode = buildTree(
+            preorder.slice(1..preorder.lastIndex).toIntArray(),
+            inorder.slice(0 until mid).toIntArray())
+        val rightNode = buildTree(
+            preorder.slice(2..preorder.lastIndex).toIntArray(),
+            inorder.slice(mid + 1..inorder.lastIndex).toIntArray()
+        )
+
+        return TreeNode(value).apply {
+            left = leftNode
+            right = rightNode
+        }
+    }
+}

valid-anagram/gmlwls96.kt

@@ -0,0 +1,8 @@
+class Solution {
+    // 시간 복잡도 : O(nlog(n))
+    fun isAnagram(s: String, t: String): Boolean {
+        val sortS = s.toCharArray().apply { sort() } // string을 char array로 변환 후 정렬.
+        val sortT = t.toCharArray().apply { sort() }
+        return sortS.concatToString() == sortT.concatToString() // 정렬된 char array를 string으로 만든후 비교.
+    }
+}