initialized repo

Author: kartik-at-sopra

.github/workflows/update-readme.yml

@@ -0,0 +1,34 @@
+name: Generate README
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  generate-readme:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Checkout the repo
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      # Set up Node.js
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+
+      # Run your README generator
+      - name: Run generateReadme.js
+        run: node generateReadme.js
+
+      # Commit the updated README
+      - name: Commit changes
+        run: |
+          git config --local user.name "github-actions[bot]"
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git add README.md
+          git diff --quiet || git commit -m "chore: update README.md"
+          git push

Algorithms/cycleDetectionDirected.js

@@ -0,0 +1,29 @@
+// Detect cycle in directed graph using DFS
+function hasCycle(n, edges) {
+  const graph = Array.from({ length: n }, () => [])
+  for (const [u, v] of edges) graph[u].push(v)
+
+  const visited = new Set()
+  const inStack = new Set()
+
+  function dfs(node) {
+    if (inStack.has(node)) return true
+    if (visited.has(node)) return false
+
+    visited.add(node)
+    inStack.add(node)
+
+    for (const nei of graph[node]) {
+      if (dfs(nei)) return true
+    }
+
+    inStack.delete(node)
+    return false
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (!visited.has(i) && dfs(i)) return true
+  }
+
+  return false
+}

Algorithms/dijkstra.js

@@ -0,0 +1,25 @@
+const MinHeap = require('../data_structures/minHeap')
+
+// Dijkstra's Algorithm
+function dijkstra(graph, src) {
+  const dist = Array(graph.length).fill(Infinity)
+  dist[src] = 0
+
+  const pq = new MinHeap()
+  pq.push([0, src]) // [dist, node]
+
+  while (pq.h.length) {
+    const [d, node] = pq.pop()
+    if (d > dist[node]) continue
+
+    for (const [nei, w] of graph[node]) {
+      const nd = d + w
+      if (nd < dist[nei]) {
+        dist[nei] = nd
+        pq.push([nd, nei])
+      }
+    }
+  }
+
+  return dist
+}

Algorithms/kadane.js

@@ -0,0 +1,11 @@
+// Kadane’s Algorithm
+function kadane(arr) {
+  let best = -Infinity
+  let cur = 0
+
+  for (const x of arr) {
+    cur = Math.max(x, cur + x)
+    best = Math.max(best, cur)
+  }
+  return best
+}

Algorithms/topoSort.js

@@ -0,0 +1,29 @@
+// Kahn's Algorithm (BFS)
+function topoSort(n, edges) {
+  const graph = Array.from({ length: n }, () => [])
+  const indegree = Array(n).fill(0)
+
+  for (const [u, v] of edges) {
+    graph[u].push(v)
+    indegree[v]++
+  }
+
+  const q = []
+  for (let i = 0; i < n; i++) {
+    if (indegree[i] === 0) q.push(i)
+  }
+
+  const res = []
+
+  while (q.length) {
+    const node = q.shift()
+    res.push(node)
+
+    for (const nei of graph[node]) {
+      indegree[nei]--
+      if (indegree[nei] === 0) q.push(nei)
+    }
+  }
+
+  return res.length === n ? res : []
+}

DSA patterns/binarySearchOnAnswer.js

@@ -0,0 +1,25 @@
+// Binary Search on Answer pattern
+function minCapacity(weights, days) {
+  let l = Math.max(...weights),
+    r = weights.reduce((a, b) => a + b)
+
+  const can = (cap) => {
+    let need = 1,
+      load = 0
+    for (const w of weights) {
+      if (load + w > cap) {
+        need++
+        load = 0
+      }
+      load += w
+    }
+    return need <= days
+  }
+
+  while (l < r) {
+    const mid = Math.floor((l + r) / 2)
+    if (can(mid)) r = mid
+    else l = mid + 1
+  }
+  return l
+}

DSA patterns/monotonicStack.js

@@ -0,0 +1,15 @@
+// Next Greater Element using Monotonic Stack
+function nextGreater(arr) {
+  const res = Array(arr.length).fill(-1)
+  const stack = [] // indexes
+
+  for (let i = 0; i < arr.length; i++) {
+    while (stack.length && arr[i] > arr[stack[stack.length - 1]]) {
+      const idx = stack.pop()
+      res[idx] = arr[i]
+    }
+    stack.push(i)
+  }
+
+  return res
+}

DSA patterns/prefixSumPattern.js

@@ -0,0 +1,16 @@
+// Subarray sum == k using prefix sums
+function subarraySum(nums, k) {
+  let count = 0
+  const map = { 0: 1 }
+  let sum = 0
+
+  for (const n of nums) {
+    sum += n
+    if (map[sum - k]) count += map[sum - k]
+    map[sum] = (map[sum] || 0) + 1
+  }
+
+  return count
+}
+
+module.exports = subarraySum

DSA patterns/twoPointers.js

@@ -0,0 +1,16 @@
+// Two pointers for sorted array pair sum
+function pairSumSorted(arr, target) {
+  let l = 0,
+    r = arr.length - 1
+
+  while (l < r) {
+    const sum = arr[l] + arr[r]
+    if (sum === target) return [l, r]
+    if (sum < target) l++
+    else r--
+  }
+
+  return -1
+}
+
+module.exports = pairSumSorted

Data Structures/graph/trie.js

@@ -0,0 +1,39 @@
+class TrieNode {
+  constructor() {
+    this.children = {}
+    this.isEnd = false
+  }
+}
+
+class Trie {
+  constructor() {
+    this.root = new TrieNode()
+  }
+
+  insert(word) {
+    let cur = this.root
+    for (const ch of word) {
+      if (!cur.children[ch]) cur.children[ch] = new TrieNode()
+      cur = cur.children[ch]
+    }
+    cur.isEnd = true
+  }
+
+  search(word) {
+    let cur = this.root
+    for (const ch of word) {
+      if (!cur.children[ch]) return false
+      cur = cur.children[ch]
+    }
+    return cur.isEnd
+  }
+
+  startsWith(prefix) {
+    let cur = this.root
+    for (const ch of prefix) {
+      if (!cur.children[ch]) return false
+      cur = cur.children[ch]
+    }
+    return true
+  }
+}