feat: new color for sidebar

fezcode · fezcode · commit 37b9e587a2af · 2025-11-07T01:47:55.000+03:00
diff --git a/craco.config.js b/craco.config.js
@@ -1,10 +1,10 @@
 module.exports = {
   devServer: {
     proxy: {
-      '/api': {
+      '/api/show-my-ip': {
         target: 'https://api.ipify.org',
         changeOrigin: true,
-        pathRewrite: { '^/api': '' },
+        pathRewrite: { '^/api/show-my-ip': '' },
       },
     },
   },
diff --git a/public/posts/algos/lowest-common-ancestor-of-a-binary-search-tree.txt b/public/posts/algos/lowest-common-ancestor-of-a-binary-search-tree.txt
@@ -7,7 +7,7 @@ This post will take you on a journey from the basics of trees to a specific type
 
 ## What is a Tree?
 
-In computer science, a **Tree** is a hierarchical data structure that consists of nodes connected by edges. 
+In computer science, a **Tree** is a hierarchical data structure that consists of nodes connected by edges.
 
 Unlike linear data structures like arrays or linked lists, trees are non-linear and are used to represent hierarchical relationships.
 
@@ -27,7 +27,7 @@ Trees are used in various applications, such as file systems, organization chart
 
 ## Binary Search Trees (BSTs)
 
-A **Binary Search Tree (BST)** is a special type of binary tree where the nodes are ordered in a specific way. 
+A **Binary Search Tree (BST)** is a special type of binary tree where the nodes are ordered in a specific way.
 
 This ordering makes operations like searching, insertion, and deletion very efficient.
 
@@ -60,7 +60,7 @@ Let's explore how to implement some of these fundamental tree algorithms in Go.
 
 ### Finding the Height/Depth of a Binary Tree
 
-The **height** of a binary tree is the number of edges on the longest path from the root node to a leaf node. A tree with only a root node has a height of 0. 
+The **height** of a binary tree is the number of edges on the longest path from the root node to a leaf node. A tree with only a root node has a height of 0.
 
 The concept is closely related to the **depth** of a node, which is its distance from the root. The height of the tree is, therefore, the maximum depth of any node in the tree.
 
@@ -138,7 +138,7 @@ func postOrderTraversal(node *TreeNode) {
 
 ## LeetCode 235: Lowest Common Ancestor of a Binary Search Tree
 
-Now, let's apply our knowledge to a classic problem. 
+Now, let's apply our knowledge to a classic problem.
 
 The **Lowest Common Ancestor (LCA)** of two nodes, `p` and `q`, in a tree is the lowest (i.e., deepest) node that has both `p` and `q` as descendants.
 
@@ -165,15 +165,15 @@ For example, consider the following BST:
 
 ### The Solution
 
-The properties of a BST make finding the LCA particularly efficient. 
+The properties of a BST make finding the LCA particularly efficient.
 
 We can start at the root of the tree and use the values of `p` and `q` to decide where to go next.
 
 Let's consider the current node we are at, let's call it `current`.
 
 1.  If both `p` and `q` are **greater** than `current.val`, it means that the LCA must be in the **right** subtree. So, we move to the right child.
 2.  If both `p` and `q` are **less** than `current.val`, it means that the LCA must be in the **left** subtree. So, we move to the left child.
-3.  If one of `p` or `q` is greater than `current.val` and the other is less than `current.val` (or if one of them is equal to `current.val`), then `current` is the LCA. 
+3.  If one of `p` or `q` is greater than `current.val` and the other is less than `current.val` (or if one of them is equal to `current.val`), then `current` is the LCA.
 
 This is because `p` and `q` are on opposite sides of the current node, meaning it's the split point and thus the lowest common ancestor.
 
@@ -233,12 +233,57 @@ func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
 }
 ```
 
-Both of these solutions are very efficient, with a time complexity of O(H), where H is the height of the tree. In a balanced BST, this is O(log N), where N is the number of nodes. 
+Both of these solutions are very efficient, with a time complexity of O(H), where H is the height of the tree. In a balanced BST, this is O(log N), where N is the number of nodes.
 
 The space complexity for the iterative solution is O(1), while the recursive solution has a space complexity of O(H) due to the call stack.
 
+### Alternative: Stack-Based Solution
+
+Another way to solve this problem is by finding the path from the root to each of the two nodes, `p` and `q`. Once we have both paths, we can compare them to find the last common node, which is the LCA.
+
+This method is more generic and would also work for a regular binary tree, but it's less efficient for a BST than the previous solutions because it requires traversing parts of the tree multiple times and uses extra space to store the paths.
+
+Here is the implementation in Go:
+
+```go
+// Helper function to find the path from the root to a target node
+func getPath(root, target *TreeNode) []*TreeNode {
+    path := []*TreeNode{}
+    current := root
+    for current != nil {
+        path = append(path, current)
+        if target.Val < current.Val {
+            current = current.Left
+        } else if target.Val > current.Val {
+            current = current.Right
+        } else {
+            break // Found the target
+        }
+    }
+    return path
+}
+
+func lowestCommonAncestorWithStacks(root, p, q *TreeNode) *TreeNode {
+    pathP := getPath(root, p)
+    pathQ := getPath(root, q)
+
+    var lca *TreeNode
+
+    // Iterate through both paths until they diverge
+    for i := 0; i < len(pathP) && i < len(pathQ); i++ {
+        if pathP[i] == pathQ[i] {
+            lca = pathP[i]
+        } else {
+            break
+        }
+    }
+
+    return lca
+}
+```
+
 ## Conclusion
 
-Trees and Binary Search Trees are powerful data structures that are essential for any programmer's toolkit. By understanding their properties and the algorithms that operate on them, you can solve a wide range of problems efficiently. 
+Trees and Binary Search Trees are powerful data structures that are essential for any programmer's toolkit. By understanding their properties and the algorithms that operate on them, you can solve a wide range of problems efficiently.
 
 The Lowest Common Ancestor problem is a perfect example of how the structure of a BST can be leveraged to find an elegant and optimal solution.
diff --git a/public/rss.xml b/public/rss.xml
@@ -9,14 +9,24 @@
             <link>https://fezcode.com</link>
         </image>
         <generator>RSS for Node</generator>
-        <lastBuildDate>Thu, 06 Nov 2025 22:19:40 GMT</lastBuildDate>
+        <lastBuildDate>Thu, 06 Nov 2025 22:37:00 GMT</lastBuildDate>
         <atom:link href="https://fezcode.com/rss.xml" rel="self" type="application/rss+xml"/>
-        <pubDate>Thu, 06 Nov 2025 22:19:40 GMT</pubDate>
+        <pubDate>Thu, 06 Nov 2025 22:37:00 GMT</pubDate>
         <copyright><![CDATA[2025 Ahmed Samil Bulbul]]></copyright>
         <language><![CDATA[en]]></language>
         <managingEditor><![CDATA[samil.bulbul@gmail.com (Ahmed Samil Bulbul)]]></managingEditor>
         <webMaster><![CDATA[samil.bulbul@gmail.com (Ahmed Samil Bulbul)]]></webMaster>
         <ttl>60</ttl>
+        <item>
+            <title><![CDATA[Lowest Common Ancestor with Binary Search Tree]]></title>
+            <description><![CDATA[[object Object]]]></description>
+            <link>https://fezcode.com/#/blog/lca</link>
+            <guid isPermaLink="false">https://fezcode.com/#/blog/lca</guid>
+            <dc:creator><![CDATA[Ahmed Samil Bulbul]]></dc:creator>
+            <pubDate>Fri, 07 Nov 2025 00:00:00 GMT</pubDate>
+            <content:encoded><![CDATA[<h1>Understanding Trees, Binary Search Trees, and Finding the Lowest Common Ancestor</h1>
+<p><a href="https://fezcode.com/#/blog/lca">Read more...</a></p>]]></content:encoded>
+        </item>
         <item>
             <title><![CDATA[Monotonic Stack with Daily Temperatures]]></title>
             <description><![CDATA[[object Object]]]></description>
diff --git a/src/components/Sidebar.js b/src/components/Sidebar.js
@@ -65,7 +65,7 @@ const Sidebar = ({ isOpen, toggleSidebar, toggleModal }) => {
   const getLinkClass = ({ isActive }) =>
     `flex items-center space-x-3 px-3 py-1 rounded-md transition-colors ${
       isActive
-        ? 'text-primary-400 bg-gray-800'
+        ? 'text-article bg-article-alpha-10'
         : 'text-gray-100 hover:text-white hover:bg-gray-800'
     }`;
 
@@ -120,10 +120,10 @@ const Sidebar = ({ isOpen, toggleSidebar, toggleModal }) => {
             <button
               onClick={() => setIsMainOpen(!isMainOpen)}
               className={`flex items-center justify-between w-full text-sm font-normal uppercase tracking-wider mb-4 focus:outline-none ${
-                isMainActive ? 'text-red-400' : 'text-gray-100'
+                isMainActive ? 'text-article' : 'text-gray-100'
               }`}
             >
-              <span className={`flex items-center gap-2 font-sans ${isMainActive ? 'text-rose-400' : 'text-white'}`}>
+              <span className={`flex items-center gap-2 font-sans ${isMainActive ? 'text-article' : 'text-white'}`}>
                 <AsteriskSimpleIcon size={16} />
                 <span>Main</span>
               </span>
@@ -155,10 +155,10 @@ const Sidebar = ({ isOpen, toggleSidebar, toggleModal }) => {
             <button
               onClick={() => setIsContentOpen(!isContentOpen)}
               className={`flex items-center justify-between w-full text-sm font-normal uppercase tracking-wider mb-4 focus:outline-none ${
-                isContentActive ? 'text-red-400' : 'text-gray-100'
+                isContentActive ? 'text-article' : 'text-gray-100'
               }`}
             >
-               <span className={`flex items-center gap-2 font-sans ${isContentActive ? 'text-rose-400' : 'text-white'}`}>
+               <span className={`flex items-center gap-2 font-sans ${isContentActive ? 'text-article' : 'text-white'}`}>
                 <BooksIcon size={16} />
                 <span>Content</span>
               </span>
@@ -196,10 +196,10 @@ const Sidebar = ({ isOpen, toggleSidebar, toggleModal }) => {
             <button
               onClick={() => setIsAppsOpen(!isAppsOpen)}
               className={`flex items-center justify-between w-full text-sm font-normal uppercase tracking-wider mb-4 focus:outline-none ${
-                isAppsActive ? 'text-red-400' : 'text-gray-100'
+                isAppsActive ? 'text-article' : 'text-gray-100'
               }`}
             >
-              <span className={`flex items-center gap-2 font-sans ${isAppsActive ? 'text-rose-400' : 'text-white'}`}>
+              <span className={`flex items-center gap-2 font-sans ${isAppsActive ? 'text-article' : 'text-white'}`}>
                 <SquaresFourIcon size={16} />
                 <span>Apps</span>
               </span>
diff --git a/src/pages/apps/IpPage.js b/src/pages/apps/IpPage.js
@@ -13,7 +13,7 @@ function IpPage() {
   const { addToast } = useToast();
 
   useEffect(() => {
-    fetch('/api?format=json')
+    fetch('/api/show-my-ip?format=json')
       .then(response => {
         if (!response.ok) {
           throw new Error('Network response was not ok');
