Engineering on Vijay Pagare

The Pattern Behind Kadane's Algorithm

Sun, 12 Apr 2026 00:04:00 +0530

Kadane’s Algorithm is a classic dynamic programming technique used to find the Maximum Subarray Sum within a one-dimensional array of numbers. It’s famous for its efficiency, turning what could be a brute-force $O(N^2)$ problem into a sleek $O(N)$ linear scan.

1. What is Kadane’s Algorithm?

The algorithm iterates through an array, keeping track of the maximum sum ending at the current position. It makes a simple choice at every element:

Design: Activity Feed

Wed, 08 Apr 2026 20:40:39 +0530

The Problem

In an activity feed (like LinkedIn or Instagram), we need to track which posts a user has already seen.

The Scale: Millions of active users.
The Volume: Every scroll generates a “Seen” event. This is a massive write-heavy workload.
The Goal: Ensure we don’t show the same post twice to the same user upon refresh.

1. The Storage Strategy (The Write Path)

If we use a traditional SQL database, every “seen” event requires the DB to find a specific row and update it. This involves “Random I/O,” which is slow. At 100k+ events per second, a standard relational database will struggle with locking and disk contention.

Overview: System Design

Wed, 08 Apr 2026 20:32:43 +0530

Shoutout – https://paperdraw.dev (System Design w/ simulations)

System Design ain’t about developing features or writing code, it’s about managing trade-offs between speed, reliability, and cost. Below is the “index” of topics required to navigate top-tier architecture discussions.

1. The Storage Layer: Beyond CRUD

Understanding how data is physically stored determines how your system scales.

B-Trees vs. LSM-Trees: The fundamental trade-off between Read-optimization (SQL) and Write-optimization (NoSQL).
Storage Paradigms: When to use Relational (ACID compliance), Document (flexible schema), Key-Value (low latency), or Graph (complex relationships).

2. Distributed Communication

How services talk to each other defines the user experience and system resilience.

Design: URL Shortener

Mon, 06 Apr 2026 16:27:00 +0530

Started learning system design and architecture seriously. I’ll be posting daily notes on whatever i learn about the subject going forward. Here’s the first one–enjoy!

1. The Core: Base62 Encoding

To keep URLs short, we use Base62 encoding ([a-z, A-Z, 0-9]).

A 7-character string gives us 3.5 Trillion combinations.
Why not Base64? Base64 includes + and /, which are not URL-safe and can break paths.

2. The Coordination Problem: Key Generation Service (KGS)

In a distributed system, we must prevent “collisions” where two servers generate the same ID.

Academic AI Fundamentals

Tue, 16 Sep 2025 01:45:39 +0530

Lord Rama, was doing BFS search until he met Jatayu, then he started DFS.

Note - This document was created on notion. It looks more readable there.

Search Methods for Problem Solving.

State space search

should be precise
be able to analyse
S = { S, A, Action(s), Result(s,a), Cost(s,a) }

Uninformed	Informed
search without information	search with information
no knowledge	use knowledge to find steps to solution
time consuming	quicker solution
more complexity (time, space)	less complexity (time, space)
DFS, BFS	A*, Heuristic DFS, Best first search

BFS - uninformed - breadth first search

uninformed search technique
FIFO (queue)
Shallowest node
complete (means it will provide the answer)
optimal (shortest result/cost)
time complexity = O(V + E) in Data Structures; in AI → O(b^d) where b: branch factor and d: depth (of tree)
example: tree

DFS - uninformed - depth first search

uninformed search technique
stack (LIFO)
deepest node
incomplete (possible that dfs doesn’t give a solution gets stuck in a loop or infinite search space)
non-optimal ()
time complexity = O(V+E); in AI → O (b^d); b: branching factor, d: depth
space complexity = O(b*d)
example: tree

DFS family - Depth Bounded, Iterative Deepening

Depth-Limited Search (DLS)	Iterative Deepening Depth-First Search (IDDFS)
Depth is fixed — search is restricted to a certain depth so that it doesn’t encounter a loop or go into infinitely deep space.	Iteratively first checks for depth 1, then 2, then 3, and so on... till the goal is found.
Completeness: NO (if the solution is beyond the depth limit)	Completeness: YES (if the branching factor 'b' is finite)
Optimality: NO (it might find a non-optimal solution if a solution exists at a shallower depth but is not explored due to the limit)	Optimality: YES (it is guaranteed to find the shallowest goal)
Time Complexity: $O(b^l)$ where 'l' is the depth limit.	Time Complexity: $O(b^d)$ where 'd' is the depth of the shallowest solution. (This is asymptotically equivalent to BFS and DFS for large d)
Space Complexity: $O(bl)$ where 'l' is the depth limit. (Same as DFS)	Space Complexity: $O(bd)$ where 'd' is the depth of the shallowest solution. (Same as DFS)

Bidirectional search (extension of BFS, DFS)

Two simultaneous searches - from initial to goal & from goal to initial, stops when two meets.
time complexity = O(2* b^d/2)
complete in BFS, not complete in DFS

Heuristics - Informed search

Used to solve a problem quickly
For solving non-polynomial problem (i.e. the ones having exponential complexity) in polynomial times.
a good enough solution will be reached (may not be the optimal)
Technique:
- eucledian distance
- manhatten distance or no. of misplaced tiles (8 puzzle problem - complexity O(3^20))

Greedy best first search

Combines BFS and DFS to form best first search
use of heuristic
admissibility: h(n) ≤ h*(n) i.e. h(n) should always be less than or equal to actual cost. (heuristic function should not over estimate.)
if f(n) = h(n) → optimal solution. (i.e. actual cost = heuristic function); sometimes the solution can be optimal even if actual cost is greater. [but actual cost cant be less]
completeness - NO, optimality - NO
time and space complexity = O(b^m)

A* - informed search

f(n) = g(n) + h(n) where g(n) is actual cost from start node to n; h(n) is estimation cost from n to goal node.
Example - directed graph
optimal
time and space complexity = O(b^d)

A* admissibility - underestimate, overestimate

h(n) ≤ h*(n) → underestimation [ optimal solution ]
- h(n) is heuristic value and h*(n) is the actual/optimal value
- we always get optimal solution in case of underestimation
h(n) ≥ h*(n) → overestimation (may not be the optimal)
example

Hill climbing - Local search algorithm

Local search algorithm, no backtracking
Algorithm:
1. Evaluate initial state
2. Loop until a solution is found or there are no operators left
  1. select and apply a new operator
  2. evaluate the new state
  3. if goal then quit
  4. if better than current state then it is new current state
Problems: local maxima, plateau/flat maxima, ridge
Good for a few problems.
Better space complexity

tbd: