Karma with DSA

// Two Pointer — the karma of balance
// Meeting in the middle: past and future converging
function isPalindrome(s) {
  let left = 0, right = s.length - 1;
  while (left < right) {
    if (s[left] !== s[right]) return false; // imbalance
    left++;   // karma moves inward from the past
    right--;  // karma moves inward from the future
  }
  return true; // balance achieved — moksha
}

// Sliding Window — present-moment awareness
// Never leaping ahead, never clinging to what passed
function maxSumWindow(arr, k) {
  let windowSum = arr.slice(0, k).reduce((a, b) => a + b, 0);
  let maxSum = windowSum;
  for (let i = k; i < arr.length; i++) {
    windowSum += arr[i] - arr[i - k]; // release the past, receive the present
    maxSum = Math.max(maxSum, windowSum);
  }
  return maxSum;
}

// Reverse a Linked List — karma's full circle
function reverseList(head) {
  let prev = null;   // the void before the first action
  let curr = head;  // the present moment
  while (curr) {
    let next = curr.next;  // remember what comes next
    curr.next = prev;       // redirect: face what was before
    prev = curr;           // the past becomes the new present
    curr = next;           // move forward
  }
  return prev; // the last becomes first
}

// Floyd's Cycle Detection — the tortoise and the hare
// In karma: if a cycle exists, you will keep meeting your past
function hasCycle(head) {
  let slow = head; // the deliberate pilgrim
  let fast = head; // the rushed one
  while (fast && fast.next) {
    slow = slow.next;            // one step
    fast = fast.next.next;      // two steps — always rushing
    if (slow === fast) return true; // the rushed meets the deliberate in a cycle
  }
  return false; // no cycle — linear karma, resolves and ends
}

class TreeNode {
  constructor(val) {
    this.val   = val;
    this.left  = null;  // lesser karma — actions of lesser weight
    this.right = null;  // greater karma — actions of greater weight
  }
}

function insert(root, val) {
  if (!root) return new TreeNode(val);        // a new moment arrives
  if (val < root.val)  root.left  = insert(root.left,  val);
  else if (val > root.val) root.right = insert(root.right, val);
  return root;
}

function search(root, val) {
  if (!root)              return false;   // karma does not exist here
  if (root.val === val)   return true;    // found — this moment exists
  if (val < root.val)    return search(root.left,  val);
  return search(root.right, val);
}

// In-order — yields sorted sequence (the dharmic order)
function inOrder(node) {
  if (!node) return;
  inOrder(node.left);    // resolve all lesser karma first
  console.log(node.val); // be present with this moment
  inOrder(node.right);   // then face the greater
}

// Pre-order — act before knowing consequences
function preOrder(node) {
  if (!node) return;
  console.log(node.val); // the leader who acts first
  preOrder(node.left);
  preOrder(node.right);
}

// Post-order — the sage who resolves all before speaking
function postOrder(node) {
  if (!node) return;
  postOrder(node.left);
  postOrder(node.right);
  console.log(node.val); // only then, the root speaks
}

// BFS — karma rippling outward, layer by layer
function bfs(graph, start) {
  const visited = new Set();
  const queue   = [start];
  visited.add(start);
  while (queue.length) {
    const node = queue.shift();  // nearest karma first
    console.log(node);
    for (const n of graph[node]) {
      if (!visited.has(n)) { visited.add(n); queue.push(n); }
    }
  }
}

// DFS — follow one thread to its deepest consequence
function dfs(graph, node, visited = new Set()) {
  if (visited.has(node)) return; // already resolved — no repeat
  visited.add(node);
  console.log(node);
  for (const n of graph[node]) dfs(graph, n, visited);
}

// Naive recursion — karma with no memory
// Suffering the same lesson exponentially
function fib(n) {
  if (n <= 1) return n;                // base case — moksha
  return fib(n - 1) + fib(n - 2);   // two recursive paths of karma
}
// fib(5) generates ~O(2^n) calls — exponential samsara
// fib(3) computed twice, fib(2) computed three times…

// Memoized recursion — samskara applied
// Each lesson learned once, never re-suffered
function fibMemo(n, memo = {}) {
  if (n in memo) return memo[n];  // wisdom already earned
  if (n <= 1)    return n;          // moksha
  memo[n] = fibMemo(n-1, memo) + fibMemo(n-2, memo);
  return memo[n]; // store before returning
}
// Time: O(n) — each subproblem solved exactly once

// Climbing Stairs — bottom-up DP (tabulation)
// How many ways to reach stair n, taking 1 or 2 steps at a time?
function climbStairs(n) {
  if (n <= 2) return n;
  const dp = new Array(n + 1);
  dp[1] = 1; // one way to reach stair 1
  dp[2] = 2; // two ways to reach stair 2
  for (let i = 3; i <= n; i++) {
    dp[i] = dp[i-1] + dp[i-2]; // the present is the sum of two recent pasts
  }
  return dp[n];
}
// This IS Fibonacci. Stair paths and recursive sequences
// share the same underlying structure. Samsara and DSA are
// the same pattern, wearing different names.