From 49b65853493517b665875c6d7f836f8ae613397c Mon Sep 17 00:00:00 2001 From: yhkee0404 Date: Fri, 3 Oct 2025 11:38:32 +0900 Subject: [PATCH 1/6] missing number solution --- missing-number/yhkee0404.scala | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 missing-number/yhkee0404.scala diff --git a/missing-number/yhkee0404.scala b/missing-number/yhkee0404.scala new file mode 100644 index 000000000..efd274f18 --- /dev/null +++ b/missing-number/yhkee0404.scala @@ -0,0 +1,5 @@ +object Solution { + def missingNumber(nums: Array[Int]): Int = { + (1 to nums.length).reduce(_ ^ _) ^ nums.reduce(_ ^ _) + } +} From d9f2cc3fd366d4e1ae823943ddc02bd33174ba81 Mon Sep 17 00:00:00 2001 From: yhkee0404 Date: Fri, 3 Oct 2025 18:14:34 +0900 Subject: [PATCH 2/6] missing number solution with complexities --- missing-number/yhkee0404.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/missing-number/yhkee0404.scala b/missing-number/yhkee0404.scala index efd274f18..8d828cc1a 100644 --- a/missing-number/yhkee0404.scala +++ b/missing-number/yhkee0404.scala @@ -1,5 +1,5 @@ object Solution { def missingNumber(nums: Array[Int]): Int = { - (1 to nums.length).reduce(_ ^ _) ^ nums.reduce(_ ^ _) + (1 to nums.length).reduce(_ ^ _) ^ nums.reduce(_ ^ _) // T(n) = O(n), S(n) = O(1) } } From 6128f9ef05cf1686d04e695f65c9c59cad819556 Mon Sep 17 00:00:00 2001 From: yhkee0404 Date: Fri, 3 Oct 2025 22:38:32 +0900 Subject: [PATCH 3/6] reorder list solution --- reorder-list/yhkee0404.swift | 37 ++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 reorder-list/yhkee0404.swift diff --git a/reorder-list/yhkee0404.swift b/reorder-list/yhkee0404.swift new file mode 100644 index 000000000..ec8369797 --- /dev/null +++ b/reorder-list/yhkee0404.swift @@ -0,0 +1,37 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * public var val: Int + * public var next: ListNode? + * public init() { self.val = 0; self.next = nil; } + * public init(_ val: Int) { self.val = val; self.next = nil; } + * public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; } + * } + */ +class Solution { + func reorderList(_ head: ListNode?) { + let temp = ListNode(0, head) + solve(temp, temp, false) + } + func solve(_ tortoise: ListNode, _ hare: ListNode?, _ odd: Bool) -> ListNode? { + guard let safeHare = hare else { + let tail = ListNode(0, tortoise.next) + tortoise.next = nil + return tail + } + let tail = solve(odd ? tortoise : tortoise.next!, safeHare.next, !odd) + if !odd { + return tail + } + guard let safeTail = tail else { + return nil + } + if safeTail.val == 0 { + return safeTail.next + } + let next = safeTail.next + safeTail.next = tortoise.next + tortoise.next = safeTail + return next + } +} From 8771fb8eb6da513c1fa5eb79add435aa844d5985 Mon Sep 17 00:00:00 2001 From: yhkee0404 Date: Sun, 5 Oct 2025 16:13:56 +0900 Subject: [PATCH 4/6] graph valid tree solution --- graph-valid-tree/yhkee0404.kt | 48 +++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 graph-valid-tree/yhkee0404.kt diff --git a/graph-valid-tree/yhkee0404.kt b/graph-valid-tree/yhkee0404.kt new file mode 100644 index 000000000..7dbb7ca88 --- /dev/null +++ b/graph-valid-tree/yhkee0404.kt @@ -0,0 +1,48 @@ +class Solution { + /** + * @param n: An integer + * @param edges: a list of undirected edges + * @return: true if it's a valid tree, or false + */ + fun validTree(n: Int, edges: Array): Boolean { + // write your code here + val adj = List(n) {mutableListOf()} // S(V, E) = O(V + E) + edges.forEach { + adj[it[0]].add(it[1]) + adj[it[1]].add(it[0]) + } + var t = 0 + val tortoiseStack = mutableListOf>(mutableListOf(0, 0, -1)) + val hareStack = mutableListOf>(mutableListOf(0, 0, -1)) + var tortoise = listOf(-1) + while (! hareStack.isEmpty()) { // T(V, E) = O(V + E) + val hare = hareStack.last() + if (hare[1] == adj[hare[0]].size) { + hareStack.removeLast() + } else if (adj[hare[0]][hare[1]] != hare[2]) { + hareStack.add(mutableListOf(adj[hare[0]][hare[1]], 0, hare[0])) + } + if (hare[1]++ != 0) { + continue + } + if ((t++ and 1) == 1) { + while (! tortoiseStack.isEmpty()) { + tortoise = tortoiseStack.last() + if (tortoise[1] == adj[tortoise[0]].size) { + tortoiseStack.removeLast() + } else if (adj[tortoise[0]][tortoise[1]] != tortoise[2]) { + tortoiseStack.add(mutableListOf(adj[tortoise[0]][tortoise[1]], 0, tortoise[0])) + } + if (tortoise[1]++ != 0) { + continue + } + break + } + } + if (hare[0] == tortoise[0]) { + return false + } + } + return t == n + } +} From d128b77faabecb27fdea4beef65039c19abad672 Mon Sep 17 00:00:00 2001 From: yhkee0404 Date: Sun, 5 Oct 2025 17:34:33 +0900 Subject: [PATCH 5/6] merge intervals solution --- merge-intervals/yhkee0404.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 merge-intervals/yhkee0404.rs diff --git a/merge-intervals/yhkee0404.rs b/merge-intervals/yhkee0404.rs new file mode 100644 index 000000000..b3d111514 --- /dev/null +++ b/merge-intervals/yhkee0404.rs @@ -0,0 +1,21 @@ +use itertools::Itertools; +use std::cmp::max; + +impl Solution { + pub fn merge(intervals: Vec>) -> Vec> { + let mut intervals: Vec<_> = intervals.iter() + .cloned() + .sorted_by(|a, b| a.cmp(b)) // T(n) = O(nlogn) + .collect(); + let mut ans: Vec> = vec![]; + let mut end = -1; + for interval in intervals { + if ans.is_empty() || ans.last().unwrap()[1] < interval[0] { + ans.push(interval) // S(n) = O(n) + } else { + ans.last_mut().unwrap()[1] = max(ans.last().unwrap()[1], interval[1]) + } + } + ans + } +} From fa374ae4426b1453f060d17a23c1993828394c3b Mon Sep 17 00:00:00 2001 From: yhkee0404 Date: Sun, 5 Oct 2025 18:52:09 +0900 Subject: [PATCH 6/6] binary tree maximum path sum solution --- binary-tree-maximum-path-sum/yhkee0404.go | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 binary-tree-maximum-path-sum/yhkee0404.go diff --git a/binary-tree-maximum-path-sum/yhkee0404.go b/binary-tree-maximum-path-sum/yhkee0404.go new file mode 100644 index 000000000..ea1221f8b --- /dev/null +++ b/binary-tree-maximum-path-sum/yhkee0404.go @@ -0,0 +1,23 @@ +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func maxPathSum(root *TreeNode) int { + ans, _ := solve(root) + return ans +} + +func solve(root *TreeNode) (int, int) { + if root == nil { + return -30_000_000, -30_000_000 + } + leftAns, leftRootAns := solve(root.Left) + rightAns, rightRootAns := solve(root.Right) + rootAns := root.Val + max(0, leftRootAns, rightRootAns,) + ans := max(leftAns, rightAns, root.Val + max(0, leftRootAns,) + max(0, rightRootAns,)) + return ans, rootAns +}