files added

Author: Prakash-sa

docs/app.js

@@ -239,6 +239,66 @@ function escapeHtml(text) {
   );
 }
 
+function normalizeRepoPath(basePath, href) {
+  if (!href) return null;
+  if (
+    href.startsWith("http://") ||
+    href.startsWith("https://") ||
+    href.startsWith("mailto:") ||
+    href.startsWith("#")
+  ) {
+    return null;
+  }
+
+  let raw = href;
+  try {
+    raw = decodeURIComponent(href);
+  } catch {
+    raw = href;
+  }
+
+  // Strip optional leading slash or current-dir prefix used in markdown links.
+  raw = raw.replace(/^\.?\//, "");
+
+  const baseParts = basePath ? basePath.split("/").slice(0, -1) : [];
+  const parts = raw.split("/").filter(Boolean);
+  const resolved = raw.startsWith("/") ? [] : [...baseParts];
+
+  for (const part of parts) {
+    if (part === ".") continue;
+    if (part === "..") {
+      resolved.pop();
+      continue;
+    }
+    resolved.push(part);
+  }
+
+  return resolved.join("/");
+}
+
+function wireMarkdownLinks(container, currentPath) {
+  container.querySelectorAll("a[href]").forEach((link) => {
+    const href = link.getAttribute("href");
+    const targetPath = normalizeRepoPath(currentPath, href);
+    if (!targetPath) {
+      if (/^https?:\/\//.test(href || "")) {
+        link.target = "_blank";
+        link.rel = "noreferrer";
+      }
+      return;
+    }
+
+    const exists = state.allFiles.some((file) => file.path === targetPath);
+    if (!exists) return;
+
+    link.setAttribute("href", `?path=${encodeURIComponent(targetPath)}`);
+    link.addEventListener("click", (event) => {
+      event.preventDefault();
+      loadFile(targetPath);
+    });
+  });
+}
+
 function pathFromUrl() {
   const params = new URLSearchParams(window.location.search);
   return params.get("path") ? decodeURIComponent(params.get("path")) : null;
@@ -717,6 +777,7 @@ async function loadFile(path) {
       const html = window.marked.parse(text);
       const clean = window.DOMPurify ? window.DOMPurify.sanitize(html) : html;
       markdownContent.innerHTML = clean;
+      wireMarkdownLinks(markdownContent, path);
       markdownContent.classList.remove("hidden");
       // Re-highlight code blocks inside markdown
       markdownContent.querySelectorAll("pre code").forEach((block) => {

docs/content/2 Pointers/strings/151. Reverse Words in a String.py

@@ -46,28 +46,40 @@ def reverseWords(self, s: str) -> str:
             ans.append(s.pop())
         return " ".join(ans)
 
+
+# since strings in python are immutable so have to convert that into the list
 class Solution:
-    def reverseWords(self, s: str) -> str:
-        left,right=0,len(s)-1
 
-        while left<=right and s[left]==" ":
+    def reverse(self,arr,left,right):
+        while left<right:
+            arr[left],arr[right]=arr[right],arr[left]
             left+=1
-
-        while left<=right and s[right]==" ":
             right-=1
 
-        d,word=deque(),[]
-
-        while left<=right:
-            if s[left]==" " and word:
-                d.appendleft("".join(word))
-                word=[]
-            elif s[left]!=" ":
-                word.append(s[left])
-            left+=1
-        d.appendleft("".join(word))
-
-        return " ".join(d)
+    def reverseWords(self, s: str) -> str:
+        arr=list(s)
+        n=len(arr)
+
+        self.reverse(arr,0,n-1)
+
+        write=0
+        read=0
+
+        while read<n:
+            if arr[read]!=' ':
+                if write!=0:
+                    arr[write]=' '
+                    write+=1
+                start=write
+                while read<n and arr[read]!=' ':
+                    arr[write]=arr[read]
+                    write+=1
+                    read+=1
+
+                self.reverse(arr,start,write-1)
+            else:
+                read+=1
+        return ''.join(arr[:write])
 
 
 # Complexity Analysis

docs/content/2 Pointers/strings/5. Longest Palindromic Substring.py

@@ -88,3 +88,54 @@ def check(i,j):
 
 # Space complexity: O(1)
 # We don't count the answer as part of the space complexity. Thus, all we use are a few integer variables.
+
+
+# Manacher's Algorithm
+
+class Solution:
+    def longestPalindrome(self,s: str) -> str:
+        # 1. Insert separators to handle even-length cases uniformly
+        t = "#" + "#".join(s) + "#"
+        n = len(t)
+        
+        # array to store palindrome radii
+        p = [0] * n
+        
+        # current right boundary and center of the longest known palindrome
+        center = right = 0
+        
+        for i in range(n):
+            mirror = 2*center - i   # mirrored index relative to current center
+            
+            # 2. Use previously known palindrome if inside boundary
+            if i < right:
+                p[i] = min(right - i, p[mirror])
+            
+            # 3. Try to expand around i
+            while (i + p[i] + 1 < n and i - p[i] - 1 >= 0 and 
+                t[i + p[i] + 1] == t[i - p[i] - 1]):
+                p[i] += 1
+            
+            # 4. Update center + right boundary if extended
+            if i + p[i] > right:
+                center = i
+                right = i + p[i]
+        
+        # 5. Find longest radius
+        max_len = max(p)
+        max_center = p.index(max_len)
+        
+        # convert center back to original indices (remove '#')
+        start = (max_center - max_len) // 2
+        return s[start: start + max_len]
+
+
+# Complexity Analysis
+# Given n as the length of s,
+
+# Time complexity: O(n)
+# From Wikipedia (the implementation they describe is slightly different from the above code, but it's the same algorithm):
+# The algorithm runs in linear time. This can be seen by noting that Center strictly increases after each outer loop and the sum Center + Radius is non-decreasing. Moreover, the number of operations in the first inner loop is linear in the increase of the sum Center + Radius while the number of operations in the second inner loop is linear in the increase of Center. Since Center ≤ 2n+1 and Radius ≤ n, the total number of operations in the first and second inner loops is O(n) and the total number of operations in the outer loop, other than those in the inner loops, is also O(n). The overall running time is therefore O(n).
+
+# Space complexity: O(n)
+# We use sPrime and palindromeRadii, both of length O(n).

docs/content/Binary Search/Binary Search.md

@@ -0,0 +1 @@
+1. Minimize the Maximum or Maximize the minimum.

docs/content/Binary Search/Sweep Coverage/2064. Minimized Maximum of Products Distributed to Any Store.py

@@ -0,0 +1,49 @@
+# https://leetcode.com/problems/minimized-maximum-of-products-distributed-to-any-store/description/
+
+'''
+You are given an integer n indicating there are n specialty retail stores. There are m product types of varying amounts, which are given as a 0-indexed integer array quantities, where quantities[i] represents the number of products of the ith product type.
+
+You need to distribute all products to the retail stores following these rules:
+
+A store can only be given at most one product type but can be given any amount of it.
+After distribution, each store will have been given some number of products (possibly 0). Let x represent the maximum number of products given to any store. You want x to be as small as possible, i.e., you want to minimize the maximum number of products that are given to any store.
+Return the minimum possible x.
+
+ 
+
+Example 1:
+
+Input: n = 6, quantities = [11,6]
+Output: 3
+Explanation: One optimal way is:
+- The 11 products of type 0 are distributed to the first four stores in these amounts: 2, 3, 3, 3
+- The 6 products of type 1 are distributed to the other two stores in these amounts: 3, 3
+The maximum number of products given to any store is max(2, 3, 3, 3, 3, 3) = 3.
+Example 2:
+
+Input: n = 7, quantities = [15,10,10]
+Output: 5
+Explanation: One optimal way is:
+- The 15 products of type 0 are distributed to the first three stores in these amounts: 5, 5, 5
+- The 10 products of type 1 are distributed to the next two stores in these amounts: 5, 5
+- The 10 products of type 2 are distributed to the last two stores in these amounts: 5, 5
+The maximum number of products given to any store is max(5, 5, 5, 5, 5, 5, 5) = 5.
+Example 3:
+
+Input: n = 1, quantities = [100000]
+Output: 100000
+Explanation: The only optimal way is:
+- The 100000 products of type 0 are distributed to the only store.
+The maximum number of products given to any store is max(100000) = 100000.
+ 
+
+Constraints:
+
+m == quantities.length
+1 <= m <= n <= 105
+1 <= quantities[i] <= 105
+'''
+
+
+
+

…stems/Concurrency/Dining Philosophers.py …ch/Sweep Coverage/Painter's Partition.pydocs/content/Operating Systems/Concurrency/Dining Philosophers.py renamed to docs/content/Binary Search/Sweep Coverage/Painter's Partition.py docs/content/Operating Systems/Concurrency/Dining Philosophers.py renamed to docs/content/Binary Search/Sweep Coverage/Painter's Partition.py

@@ -0,0 +1,67 @@
+# https://leetcode.com/problems/maximum-non-negative-product-in-a-matrix/description/
+
+'''
+You are given a m x n matrix grid. Initially, you are located at the top-left corner (0, 0), and in each step, you can only move right or down in the matrix.
+Among all possible paths starting from the top-left corner (0, 0) and ending in the bottom-right corner (m - 1, n - 1), find the path with the maximum non-negative product. The product of a path is the product of all integers in the grid cells visited along the path.
+Return the maximum non-negative product modulo 109 + 7. If the maximum product is negative, return -1.
+Notice that the modulo is performed after getting the maximum product.
+
+
+Example 1:
+Input: grid = [[-1,-2,-3],[-2,-3,-3],[-3,-3,-2]]
+Output: -1
+Explanation: It is not possible to get non-negative product in the path from (0, 0) to (2, 2), so return -1.
+
+Example 2:
+Input: grid = [[1,-2,1],[1,-2,1],[3,-4,1]]
+Output: 8
+Explanation: Maximum non-negative product is shown (1 * 1 * -2 * -4 * 1 = 8).
+
+Example 3:
+Input: grid = [[1,3],[0,-4]]
+Output: 0
+Explanation: Maximum non-negative product is shown (1 * 0 * -4 = 0).
+ 
+Constraints:
+m == grid.length
+n == grid[i].length
+1 <= m, n <= 15
+-4 <= grid[i][j] <= 4
+'''
+
+class Solution:
+    MOD=10**9+7
+    def maxProductPath(self, grid: List[List[int]]) -> int:
+        m,n=len(grid),len(grid[0])
+        maxgt=[[0]*n for _ in range(m)]
+        minlt=[[0]*n for _ in range(m)]
+
+        maxgt[0][0]=minlt[0][0]=grid[0][0]
+
+        for i in range(1,n):
+            maxgt[0][i]=minlt[0][i]=maxgt[0][i-1]*grid[0][i]
+        for i in range(1,m):
+            maxgt[i][0]=minlt[i][0]=maxgt[i-1][0]*grid[i][0]
+        
+        for i in range(1,m):
+            for j in range(1,n):
+                if grid[i][j]>=0:
+                    maxgt[i][j]=max(maxgt[i][j-1],maxgt[i-1][j])*grid[i][j]
+                    minlt[i][j]=min(minlt[i][j-1],minlt[i-1][j])*grid[i][j]
+                else:
+                    maxgt[i][j]=min(minlt[i][j-1],minlt[i-1][j])*grid[i][j]
+                    minlt[i][j]=max(maxgt[i][j-1],maxgt[i-1][j])*grid[i][j]
+
+        return maxgt[m-1][n-1]%self.MOD if maxgt[m-1][n-1]>=0 else -1
+
+
+'''
+Complexity Analysis
+Let m and n be the number of rows and columns of the matrix.
+
+Time complexity: O(mn).
+We traverse each cell once, and each transition takes constant time.
+
+Space complexity: O(mn).
+We maintain two matrices of size m×n.
+'''