Added tasks 3451-3459

Author: javadev

src/main/kotlin/g3401_3500/s3451_find_invalid_ip_addresses/readme.md

@@ -0,0 +1,61 @@
+3451\. Find Invalid IP Addresses
+
+Hard
+
+Table: `logs`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | log_id      | int     |
+    | ip          | varchar |
+    | status_code | int     |
+    +-------------+---------+
+    log_id is the unique key for this table.
+    Each row contains server access log information including IP address and HTTP status code. 
+
+Write a solution to find **invalid IP addresses**. An IPv4 address is invalid if it meets any of these conditions:
+
+*   Contains numbers **greater than** `255` in any octet
+*   Has **leading zeros** in any octet (like `01.02.03.04`)
+*   Has **less or more** than `4` octets
+
+Return _the result table_ _ordered by_ `invalid_count`, `ip` _in **descending** order respectively_.
+
+The result format is in the following example.
+
+**Example:**
+
+**Input:**
+
+logs table:
+
+    +--------+---------------+-------------+
+    | log_id | ip            | status_code |
+    +--------+---------------+-------------+
+    | 1      | 192.168.1.1   | 200         |
+    | 2      | 256.1.2.3     | 404         |
+    | 3      | 192.168.001.1 | 200         |
+    | 4      | 192.168.1.1   | 200         |
+    | 5      | 192.168.1     | 500         |
+    | 6      | 256.1.2.3     | 404         |
+    | 7      | 192.168.001.1 | 200         |
+    +--------+---------------+-------------+ 
+
+**Output:**
+
+    +---------------+--------------+
+    | ip            | invalid_count|
+    +---------------+--------------+
+    | 256.1.2.3     | 2            |
+    | 192.168.001.1 | 2            |
+    | 192.168.1     | 1            |
+    +---------------+--------------+ 
+
+**Explanation:**
+
+*   256.1.2.3 is invalid because 256 > 255
+*   192.168.001.1 is invalid because of leading zeros
+*   192.168.1 is invalid because it has only 3 octets
+
+The output table is ordered by invalid\_count, ip in descending order respectively.

src/main/kotlin/g3401_3500/s3451_find_invalid_ip_addresses/script.sql

@@ -0,0 +1,15 @@
+# Write your MySQL query statement below
+# #Hard #2025_02_16_Time_383_ms_(85.47%)_Space_0.0_MB_(100.00%)
+WITH cte_invalid_ip AS (
+    SELECT log_id, ip
+    FROM logs
+    WHERE NOT regexp_like(ip, '^(?:[1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:[.](?:[1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}$')
+  ),
+  cte_invalid_ip_count AS (
+    SELECT ip, count(log_id) as invalid_count
+    FROM cte_invalid_ip
+    GROUP BY ip
+  )
+SELECT ip, invalid_count
+FROM cte_invalid_ip_count
+ORDER BY invalid_count DESC, ip DESC;

src/main/kotlin/g3401_3500/s3452_sum_of_good_numbers/Solution.kt

@@ -0,0 +1,23 @@
+package g3401_3500.s3452_sum_of_good_numbers
+
+// #Easy #Array #2025_02_18_Time_1_ms_(100.00%)_Space_38.08_MB_(84.85%)
+
+class Solution {
+    fun sumOfGoodNumbers(nums: IntArray, k: Int): Int {
+        var totalSum = 0
+        val n = nums.size
+        for (i in 0..<n) {
+            var isGood = true
+            if (i - k >= 0 && nums[i] <= nums[i - k]) {
+                isGood = false
+            }
+            if (i + k < n && nums[i] <= nums[i + k]) {
+                isGood = false
+            }
+            if (isGood) {
+                totalSum += nums[i]
+            }
+        }
+        return totalSum
+    }
+}

src/main/kotlin/g3401_3500/s3452_sum_of_good_numbers/readme.md

@@ -0,0 +1,33 @@
+3452\. Sum of Good Numbers
+
+Easy
+
+Given an array of integers `nums` and an integer `k`, an element `nums[i]` is considered **good** if it is **strictly** greater than the elements at indices `i - k` and `i + k` (if those indices exist). If neither of these indices _exists_, `nums[i]` is still considered **good**.
+
+Return the **sum** of all the **good** elements in the array.
+
+**Example 1:**
+
+**Input:** nums = [1,3,2,1,5,4], k = 2
+
+**Output:** 12
+
+**Explanation:**
+
+The good numbers are `nums[1] = 3`, `nums[4] = 5`, and `nums[5] = 4` because they are strictly greater than the numbers at indices `i - k` and `i + k`.
+
+**Example 2:**
+
+**Input:** nums = [2,1], k = 1
+
+**Output:** 2
+
+**Explanation:**
+
+The only good number is `nums[0] = 2` because it is strictly greater than `nums[1]`.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 100`
+*   `1 <= nums[i] <= 1000`
+*   `1 <= k <= floor(nums.length / 2)`

src/main/kotlin/g3401_3500/s3453_separate_squares_i/Solution.kt

@@ -0,0 +1,42 @@
+package g3401_3500.s3453_separate_squares_i
+
+// #Medium #Array #Binary_Search #2025_02_18_Time_134_ms_(30.30%)_Space_95.92_MB_(93.94%)
+
+class Solution {
+    private fun helper(line: Double, squares: Array<IntArray>): Double {
+        var aAbove = 0.0
+        var aBelow = 0.0
+        for (square in squares) {
+            val y = square[1]
+            val l = square[2]
+            val total = l.toDouble() * l
+            if (line <= y) {
+                aAbove += total
+            } else if (line >= y + l) {
+                aBelow += total
+            } else {
+                // The line intersects the square.
+                val aboveHeight = (y + l) - line
+                val belowHeight = line - y
+                aAbove += l * aboveHeight
+                aBelow += l * belowHeight
+            }
+        }
+        return aAbove - aBelow
+    }
+
+    fun separateSquares(squares: Array<IntArray>): Double {
+        var lo = 0.0
+        var hi = 2 * 1e9
+        for (i in 0..59) {
+            val mid = (lo + hi) / 2.0
+            val diff = helper(mid, squares)
+            if (diff > 0) {
+                lo = mid
+            } else {
+                hi = mid
+            }
+        }
+        return hi
+    }
+}

src/main/kotlin/g3401_3500/s3453_separate_squares_i/readme.md

@@ -0,0 +1,48 @@
+3453\. Separate Squares I
+
+Medium
+
+You are given a 2D integer array `squares`. Each <code>squares[i] = [x<sub>i</sub>, y<sub>i</sub>, l<sub>i</sub>]</code> represents the coordinates of the bottom-left point and the side length of a square parallel to the x-axis.
+
+Find the **minimum** y-coordinate value of a horizontal line such that the total area of the squares above the line _equals_ the total area of the squares below the line.
+
+Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+
+**Note**: Squares **may** overlap. Overlapping areas should be counted **multiple times**.
+
+**Example 1:**
+
+**Input:** squares = [[0,0,1],[2,2,1]]
+
+**Output:** 1.00000
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/01/06/4062example1drawio.png)
+
+Any horizontal line between `y = 1` and `y = 2` will have 1 square unit above it and 1 square unit below it. The lowest option is 1.
+
+**Example 2:**
+
+**Input:** squares = [[0,0,2],[1,1,1]]
+
+**Output:** 1.16667
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/01/15/4062example2drawio.png)
+
+The areas are:
+
+*   Below the line: `7/6 * 2 (Red) + 1/6 (Blue) = 15/6 = 2.5`.
+*   Above the line: `5/6 * 2 (Red) + 5/6 (Blue) = 15/6 = 2.5`.
+
+Since the areas above and below the line are equal, the output is `7/6 = 1.16667`.
+
+**Constraints:**
+
+*   <code>1 <= squares.length <= 5 * 10<sup>4</sup></code>
+*   <code>squares[i] = [x<sub>i</sub>, y<sub>i</sub>, l<sub>i</sub>]</code>
+*   `squares[i].length == 3`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>9</sup></code>
+*   <code>1 <= l<sub>i</sub> <= 10<sup>9</sup></code>

src/main/kotlin/g3401_3500/s3454_separate_squares_ii/Solution.kt

@@ -0,0 +1,160 @@
+package g3401_3500.s3454_separate_squares_ii
+
+// #Hard #Array #Binary_Search #Segment_Tree #Line_Sweep
+// #2025_02_18_Time_277_ms_(100.00%)_Space_96.52_MB_(33.33%)
+
+class Solution {
+    fun separateSquares(squares: Array<IntArray>): Double {
+        val n = squares.size
+        val m = 2 * n
+        val events = createEvents(squares, m)
+        val xsRaw = createXsRaw(squares, m)
+        events.sortWith<Event?> { a, b: Event? -> a!!.y.compareTo(b!!.y) }
+        val xs = compress(xsRaw)
+        val totalUnionArea = calculateTotalUnionArea(events, xs, m)
+        val target = totalUnionArea / 2.0
+        return findSplitPoint(events, xs, m, target)
+    }
+
+    private fun createEvents(squares: Array<IntArray>, m: Int): Array<Event?> {
+        val events = arrayOfNulls<Event>(m)
+        var idx = 0
+        for (sq in squares) {
+            val x = sq[0].toDouble()
+            val y = sq[1].toDouble()
+            val l = sq[2].toDouble()
+            val x2 = x + l
+            val y2 = y + l
+            events[idx++] = Event(y, x, x2, 1)
+            events[idx++] = Event(y2, x, x2, -1)
+        }
+        return events
+    }
+
+    private fun createXsRaw(squares: Array<IntArray>, m: Int): DoubleArray {
+        val xsRaw = DoubleArray(m)
+        var xIdx = 0
+        for (sq in squares) {
+            val x = sq[0].toDouble()
+            val l = sq[2].toDouble()
+            xsRaw[xIdx++] = x
+            xsRaw[xIdx++] = x + l
+        }
+        return xsRaw
+    }
+
+    private fun calculateTotalUnionArea(events: Array<Event?>, xs: DoubleArray, m: Int): Double {
+        val segTree = SegmentTree(xs)
+        var totalUnionArea = 0.0
+        var lastY = events[0]!!.y
+        var i = 0
+        while (i < m) {
+            val curY = events[i]!!.y
+            if (curY > lastY) {
+                val unionX = segTree.query()
+                totalUnionArea += unionX * (curY - lastY)
+                lastY = curY
+            }
+            while (i < m && events[i]!!.y == curY) {
+                val indices = findIndices(xs, events[i]!!)
+                segTree.update(1, 0, xs.size - 1, indices[0], indices[1], events[i]!!.type)
+                i++
+            }
+        }
+        return totalUnionArea
+    }
+
+    private fun findSplitPoint(events: Array<Event?>, xs: DoubleArray, m: Int, target: Double): Double {
+        val segTree = SegmentTree(xs)
+        var lastY = events[0]!!.y
+        var cumArea = 0.0
+        var i = 0
+        while (i < m) {
+            val curY = events[i]!!.y
+            if (curY > lastY) {
+                val unionX = segTree.query()
+                val dy = curY - lastY
+                if (cumArea + unionX * dy >= target - 1e-10) {
+                    return lastY + (target - cumArea) / unionX
+                }
+                cumArea += unionX * dy
+                lastY = curY
+            }
+            while (i < m && events[i]!!.y == curY) {
+                val indices = findIndices(xs, events[i]!!)
+                segTree.update(1, 0, xs.size - 1, indices[0], indices[1], events[i]!!.type)
+                i++
+            }
+        }
+        return lastY
+    }
+
+    private fun findIndices(xs: DoubleArray, event: Event): IntArray {
+        var lIdx = xs.binarySearch(event.x1)
+        if (lIdx < 0) {
+            lIdx = -lIdx - 1
+        }
+        var rIdx = xs.binarySearch(event.x2)
+        if (rIdx < 0) {
+            rIdx = -rIdx - 1
+        }
+        return intArrayOf(lIdx, rIdx)
+    }
+
+    private fun compress(arr: DoubleArray): DoubleArray {
+        arr.sort()
+        var cnt = 1
+        for (i in 1..<arr.size) {
+            if (arr[i] != arr[i - 1]) {
+                cnt++
+            }
+        }
+        val res = DoubleArray(cnt)
+        res[0] = arr[0]
+        var j = 1
+        for (i in 1..<arr.size) {
+            if (arr[i] != arr[i - 1]) {
+                res[j++] = arr[i]
+            }
+        }
+        return res
+    }
+
+    private class Event(var y: Double, var x1: Double, var x2: Double, var type: Int)
+
+    private class SegmentTree(var xs: DoubleArray) {
+        var n: Int
+        var tree: DoubleArray
+        var count: IntArray
+
+        init {
+            this.n = xs.size
+            tree = DoubleArray(4 * n)
+            count = IntArray(4 * n)
+        }
+
+        fun update(idx: Int, l: Int, r: Int, ql: Int, qr: Int, `val`: Int) {
+            if (qr <= l || ql >= r) {
+                return
+            }
+            if (ql <= l && r <= qr) {
+                count[idx] += `val`
+            } else {
+                val mid = (l + r) shr 1
+                update(idx shl 1, l, mid, ql, qr, `val`)
+                update(idx shl 1 or 1, mid, r, ql, qr, `val`)
+            }
+            if (count[idx] > 0) {
+                tree[idx] = xs[r] - xs[l]
+            } else if (r - l == 1) {
+                tree[idx] = 0.0
+            } else {
+                tree[idx] = tree[idx shl 1] + tree[idx shl 1 or 1]
+            }
+        }
+
+        fun query(): Double {
+            return tree[1]
+        }
+    }
+}