[친환경사과] Week 3

product-of-array-except-self/EcoFriendlyAppleSu.kt

@@ -0,0 +1,43 @@
+package leetcode_study
+
+/*
+* 주어진 배열에서 자신 요소를 제외한 나머지 요소의 곱한 배열을 구하는 문제
+* 문제에세 O(n)의 시간 복잡도를 요구하였으나 방법이 떠오르지 않아 고민 후 정답 참조.
+* 기준 요소를 중심으로 왼쪽의 총 곱, 오른쪽의 총 곱을 진행하게 되었을 때, 문제를 O(n)의 시간 복잡도로 해결할 수 있음.
+* 시간 복잡도: O(n^2)
+* 공간 복잡도: O(n)
+* */
+fun productExceptSelf00(nums: IntArray): IntArray {
+    val result = mutableListOf<Int>()
+
+    for (i in nums.indices) {
+        var temp = 1
+        for (j in nums.indices) {
+            if (i == j) continue
+            temp *= nums[j]
+        }
+        result.add(temp)
+    }
+    return result.toIntArray()
+}
+
+/*
+* 시간 복잡도: O(n)
+* 공간 복잡도: O(n)
+* */
+fun productExceptSelf01(nums: IntArray): IntArray {
+    val result = IntArray(nums.size)
+
+    var leftProduct = 1
+    for (i in nums.indices) {
+        result[i] = leftProduct
+        leftProduct = leftProduct * nums[i]
+    }
+
+    var rightProduct = 1
+    for (i in nums.indices.reversed()) {
+        result[i] = result[i] * rightProduct
+        rightProduct = rightProduct * nums[i]
+    }
+    return result
+}

reverse-bits/EcoFriendlyAppleSu.kt

@@ -0,0 +1,50 @@
+package leetcode_study
+
+/*
+* 주어진 32 bits unsigned integer를 뒤집는 문제
+* Bit 연산에 대한 개념이 전무해 String으로 치환 후 문제 해결
+* 작은 수는 표현할 수 있었지만 아래와 같이 문제를 해결할 경우 큰 수가 입력되었을 경우 부호 비트를 인식하여 음수로 표기합니다.
+* 또한 32 bit를 구성하기 위해 부족한 문자열을(자릿수) 추가하기 때문에 연산이 더해집니다.
+* */
+fun reverseBits1(n:Int):Int {
+    val nStr = n.toString(2)
+    val totalLength = nStr.length
+    var temp = ""
+    if (totalLength != 32) {
+        for (i in 0 until 32 - totalLength) {
+            temp += "0"
+        }
+    }
+    val fullBitString = temp + nStr
+    var result = 0
+
+    for (i in (fullBitString.length - 1) downTo 0) {
+        val eachBitValue = 2.0.pow(i).toInt()
+        if (fullBitString[i] == '0') {
+            continue
+        } else {
+            result += eachBitValue
+        }
+    }
+    println(result.toString(2))
+    return result
+}
+
+/*
+* Bit 연산을 통한 Reverse Bit 구성
+* 시간 복잡도: O(32) (32비트의 숫자에 대해 반복)
+* 공간 복잡도: O(1) (상수 공간 사용)
+* */
+fun reverseBits(n: Int): Int {
+    var input = n
+    var result = 0
+
+    for (i in 0 until 32) {
+        // 결과에 현재 비트 추가
+        result = (result shl 1) or (input and 1)
+        // 입력 비트를 오른쪽으로 이동
+        input = input shr 1
+    }
+
+    return result
+}

two-sum/EcoFriendlyAppleSu.kt

@@ -0,0 +1,42 @@
+package leetcode_study
+
+/**
+ * 주어진 숫자 배열에서 두 개의 숫자를 더해 Target을 만들 수 있는 배열의 Index를 구하는 문제
+ * 조합을 사용해 문제 해결
+ * 시간 복잡도: O(n^2)
+ * -> 두 번의 순회를 통해 모든 경우의 수를 계산하는 경우
+ * 공간 복잡도: O(1)
+ * -> 결과를 저장하는 result, 배열의 index를 가리키는 indices는 두 개의 값을 담기 때문에 O(1)
+ */
+fun twoSum(nums: IntArray, target: Int): IntArray {
+    val result = IntArray(2)
+    val k = 2
+    val maxSize = nums.size
+    val indices = IntArray(k)
+    for (i in 0 until k ) {
+        indices[i] = i
+    }
+
+    while (indices[k-1] < maxSize) {
+        if (nums[indices[0]] + nums[indices[1]] == target) {
+            result[0] = indices[0]
+            result[1] = indices[1]
+            return result
+        }
+
+        var i = k - 1
+        while (i >= 0 && indices[i] == i + maxSize - k) {
+            i--
+        }
+
+        if (i >= 0) {
+            indices[i]++
+            for (j in i + 1 until k) {
+                indices[j] = indices[j - 1] + 1
+            }
+        } else {
+            break
+        }
+    }
+    return result
+}