The Operating System for AI Consensus

Covers the “JOIN + GROUP BY” half of the common GM SQL bar: align keys, bucket rows, aggregate. Stepped viz + Type It.

JOIN + GROUP BY + SUM

Medium Join + Aggregate

Anti-join: keep rows in A with no match in B. Classic “customers who never ordered” pattern vs NOT EXISTS.

LEFT JOIN + IS NULL

Medium Anti-join

WHERE filters rows; HAVING filters groups after COUNT / SUM. COUNT(DISTINCT …) for “more than N unique products.”

GROUP BY + HAVING

Medium Aggregate filter

LAG(col) OVER (PARTITION BY … ORDER BY …) for session gaps, day-over-day deltas, and ordered comparisons per entity.

LAG — previous row

Medium Window — LAG

Top 3 salaries / department

DENSE_RANK + PARTITION BY inside a derived table, then WHERE rank <= 3 — the subquery form interviewers expect (CTE variant optional).

Medium Window — rank

Date functions (PG / MySQL / SQL Server)

Staff-level expectation: EXTRACT, month truncation, and CURRENT_DATE idioms per dialect — quick reference + stepped tour.

Easy Reference

Monthly sales change (LAG + dates)

Bucket by month, aggregate, then LAG(total) OVER (ORDER BY month) for month-over-month — pairs with the date cheatsheet.

Medium LAG + time

Avg sales by year & model

JOIN facts to dimensions, GROUP BY model + EXTRACT(YEAR FROM sale_date), AVG(amount).

Medium JOIN + EXTRACT

Average mileage per model

Single-table AVG(mpg) GROUP BY model — the simple aggregate bar before joins and windows.

Easy AVG + GROUP BY

Inner query references the outer row (e.g. salary vs department average). Contrast with a join rewrite and when the planner might do either.

Correlated subquery

Medium Subquery

Set semantics on two SELECT lists: anti-pattern with EXCEPT, overlap with INTERSECT (and duplicate rules).

EXCEPT & INTERSECT

Medium Set ops

Bit Manipulation

2 / 2 problems

LeetCode #191

Number of 1 Bits

Hamming weight: n&1, count, n>>=1 until zero. Foundation for XOR and bit-trick problems.

Easy Bit scan

LeetCode #190

Reverse Bits

32 iterations: shift result left, OR in LSB of n, shift n right. Produces reversed 32-bit unsigned.

Easy Bit shift

Tries

2 / 3 problems

LeetCode #208

Implement Trie (Prefix Tree)

26-way tree for prefix storage. insert, search, startsWith in O(m). Iterative or recursive.

Medium Trie (Iterative + Recursive)

LeetCode #212

Word Search II

Build trie from words. DFS from each cell. When trie node is word end, add to result. O(mn·4^L).

Hard Trie + DFS

LeetCode #211

Design Add and Search Words

Trie with wildcard '.' in search. DFS when you hit a dot.

Medium Trie + DFS

Two Pointers

5 / 5 problems

LeetCode #167

Two Sum II

Find two numbers in a sorted array that sum to a target using two pointers converging from both ends.

Medium Two pointers

LeetCode #15

3Sum

Find all unique triplets that sum to zero using sorting and two-pointer elimination.

Medium Sort + two pointers

LeetCode #125

Valid Palindrome

Two pointers converge: skip non-alphanumeric, compare case-insensitive. Return True if palindrome.

Easy Two pointers

LeetCode #392

Is Subsequence

Two pointers: i on s, j on t. Match s[i]==t[j] → advance i; always advance j. Iterative or recursive.

Easy Two pointers

LeetCode #11

Container With Most Water

Two pointers at both ends. Area = width × min(h[left], h[right]). Move the shorter pointer. Iterative or recursive.

Medium Two pointers

Trees

16 / 16 problems

LeetCode #230

Kth Smallest in BST

Inorder visits BST in sorted order. Iterative: stack-based inorder. Recursive: inorder DFS. Return k-th value.

Medium Inorder / Stack

LeetCode #199

Binary Tree Right Side View

BFS: take last node of each level. DFS: right-first traversal, first node at each depth.

Medium BFS / DFS

LeetCode #100

Same Tree

Compare two trees node-by-node using a queue of pairs. Watch BFS check structural equality in lockstep.

Easy BFS / DFS

LeetCode #572

Subtree of Another Tree

BFS the root tree, calling isSameTree at each node. Watch the outer traversal find and verify the matching subtree.

Easy BFS + isSameTree

LeetCode #102

Level Order Traversal

BFS the tree level-by-level, collecting values top-down. The classic BFS pattern — foundation for #107.

Medium BFS + Queue

LeetCode #103

Zigzag Level Order Traversal

Recursive DFS with level parity — use a deque per level to insert at either end in O(1). Watch the call stack build the zigzag.

Medium Recursive DFS

LeetCode #107

Level Order Traversal II

BFS the tree level-by-level, collecting values bottom-up using a deque. Watch the queue grow and levels stack.

Medium BFS + Deque

LeetCode #226

Invert Binary Tree

Swap left and right children at every node. Iterative (stack) or recursive DFS — watch the tree mirror itself.

Easy DFS (Iterative + Recursive)

LeetCode #104

Maximum Depth of Binary Tree

Count levels using BFS. Watch depth increment as each level is fully processed.

Easy BFS Level Count

LeetCode #111

Minimum Depth of Binary Tree

BFS with early exit — return immediately when the first leaf is found at the shallowest level.

Easy BFS Early Exit

LeetCode #98

Validate Binary Search Tree

Inorder must be strictly increasing. Iterative: stack + prev. Recursive: DFS with (min, max) bounds.

Medium Inorder / DFS bounds

LeetCode #235

LCA of BST

Use BST property: if p,q < root go left, if p,q > root go right, else root is LCA. Iterative or recursive.

Easy BST traversal

LeetCode #543

Diameter of Binary Tree

Longest path between any two nodes. DFS: at each node diameter = left_depth + right_depth. Track max globally.

Easy DFS

LeetCode #124

Binary Tree Maximum Path Sum

DFS: path_through = node + left_gain + right_gain. Return max single-branch. Track max path globally.

Hard DFS

LeetCode #105

Construct Binary Tree from Preorder and Inorder

Preorder gives root order; inorder splits left/right subtrees. Hash inorder indices. Iterative stack variant.

Medium Divide & conquer

LeetCode #297

Serialize and Deserialize Binary Tree

Preorder DFS: visit node, left, right. Use "N" for null. Comma-separated string. Deserialize: split and build recursively.

Hard Preorder DFS

Graphs

8 / 8 problems

LeetCode #733

Flood Fill

DFS/BFS from (sr,sc). Replace all 4-connected cells with same color. Iterative stack or recursive.

Easy DFS / BFS

LeetCode #323

Connected Components

BFS from each unvisited node to discover connected components. Count how many BFS calls = components.

Medium BFS + Component Count

LeetCode #207

Course Schedule

Directed graph: finish all courses iff no cycle. Kahn (indegree) or 3-color DFS. Diff vs undirected components.

Medium Topo sort / DFS

LeetCode #210 · template

Topological Sort (Kahn)

Indegree counts, queue of zeros, pop and relax. Returns order; length < n if a directed cycle exists (same core as C++ topoSort).

Medium BFS / Kahn

LeetCode #200

Number of Islands

BFS/DFS flood fill on a 2D grid. Each '1' cell triggers a search that marks the entire island.

Medium BFS Flood Fill

LeetCode #79

Word Search

DFS + backtrack on a letter grid: match the word without reusing cells. Contrast with Word Search II (trie batch).

Medium Backtracking / DFS

LeetCode #547

Number of Provinces

Adjacency matrix as undirected graph: Union-Find unions edges, count roots — or DFS/BFS components.

Medium Union-Find / DFS

LeetCode #417

Pacific Atlantic Water Flow

Reverse BFS/DFS from ocean edges. Mark Pacific- and Atlantic-reachable cells. Return intersection. Diff BFS vs DFS.

Medium BFS / DFS

Sliding Window

8 / 8 problems

LeetCode #438

Find All Anagrams in a String

Fixed-size window = len(p). Build p freq map. Slide window, compare freq. O(n) time.

Medium Sliding window + freq

LeetCode #424

Longest Repeating Character Replacement

Expand and shrink a sliding window to find the longest substring after at most k replacements.

Medium Sliding window + frequency

LeetCode #209

Minimum Size Subarray Sum

Find minimal length of a contiguous subarray with sum ≥ target. Expand right, shrink left.

Medium Sliding window

LeetCode #121

Best Time to Buy and Sell Stock

Track min_price so far. Profit if sold today = price − min_price. Iterative or recursive.

Easy Single pass

LeetCode #3

Longest Substring Without Repeating

Expand and contract a window to find the longest unique-character substring. Set tracks chars in window.

Medium Sliding window + set

LeetCode #76

Minimum Window Substring

Find the smallest window in s containing all chars from t. need/have maps, expand then shrink while valid.

Hard Sliding window + hash map

LeetCode #239

Sliding Window Maximum

Monotonic deque: indices in decreasing order. Front = max. Pop from back when smaller. O(n).

Hard Monotonic deque

LeetCode #340

Longest Substring K Distinct

Sliding window + char count map. Expand right, shrink from left when distinct > k. O(n) time.

Hard Sliding window + hash map

Intervals

2 / 2 problems

LeetCode #56

Merge Intervals

Sort by start, then merge overlapping intervals. Iterative and recursive solutions.

Medium Sort + linear scan

LeetCode #57

Insert Interval

Three phases: add before, merge overlapping, add after. No sorting needed — input already sorted. Diff vs Merge Intervals.

Medium Linear scan

Design

3 / 3 problems

LeetCode #146

LRU Cache

Hash map + doubly linked list. get/put O(1). Evict LRU when full. Head=MRU, tail=LRU.

Medium Hash + DLL

LeetCode #155

Min Stack

Two stacks: main + min. push/pop/top/getMin in O(1). Push min when val ≤ current min.

Medium Stack

LeetCode #622

Design Circular Queue

Fixed array, front/rear wrap. enQueue/deQueue/Front/Rear/isEmpty/isFull in O(1).

Medium Array

Stack

3 / 3 problems

LeetCode #20

Valid Parentheses

Stack: push open brackets, pop and match on close. Map close to open. Empty stack at end = valid.

Easy Stack

LeetCode #84

Largest Rectangle in Histogram

Monotonic stack: pop while stack top > current, area = height[pop] × width. O(n) time, O(n) space.

Hard Monotonic stack

LeetCode #739

Daily Temperatures

Monotonic decreasing stack of indices. Pop while current temp is warmer. answer[j] = i - j. Diff vs Histogram.

Medium Monotonic stack

Category Roadmap

Linked Lists

Arrays & Hashing

Two Pointers

Trees

Tries

Sliding Window

Intervals

Binary Search

Stacks & Queues

Graphs / BFS / DFS

Dynamic Programming

System design — step-through lessons on distributed systems: tradeoffs (CAP/PACELC), caches, databases, messaging, APIs, observability, and full design walkthroughs (URL shortener, news feed). Completion is stored locally as sd_completed. Open the standalone hub for a compact list.

Topics

Completed (this browser)

Foundations

Scalability & building blocks

Horizontal vs vertical scale, stateless tiers, separate concerns.

~18 min

CAP & PACELC

Consistency, availability, partitions; what to say in interviews.

~20 min

SLOs & reliability

SLIs, error budgets, timeouts, graceful degradation.

~16 min

Core concepts

Load balancing, caching & CDN

L4/L7, Redis, invalidation, edge caching.

~22 min

Databases & sharding

Replication, quorum, shard keys, hot partitions.

~24 min

Consistent hashing

Hash ring, virtual nodes, minimal remapping.

~16 min

Rate limiting

Token bucket, sliding window, distributed counters, 429 semantics.

~14 min

Idempotency

Idempotency keys, dedup, safe retries with at-least-once delivery.

~14 min

Messaging & async

Queues, delivery semantics, Kafka-style logs, backpressure.

~20 min

API design & resilience

Rate limits, retries, circuit breakers, bulkheads.

~18 min

Observability

Logs, metrics, traces, SLOs and alerts.

~16 min

Design interviews

Chat / messaging

WebSockets, history, presence, fan-out for groups.

~26 min

Search autocomplete

Prefix index, ranking, caching, debouncing.

~22 min

URL shortener

Encoding, storage, redirect path, cache, abuse.

~28 min

Distributed news feed

Fan-out on write vs read, ranking, hot users.

~28 min

New problems added weekly. Built by IFusionSoft — the team behind Model Pile.

Unlock all problems — $8/mo or $20/quarter →

Interview Prep →

support@ifusionsoft.com

AlgoVision v2025.03.22

← IFusionSoft home AlgoVision (DSA & system design) →

Discuss in AIs Social

RoboVision

Robotics · visualization · control

Start with vision–language–action (how models like OpenVLA map pixels + goals to motion), then 3D kinematics (Three.js) for geometry intuition. Open the standalone hub or start below.

Tier 1-2 Foundations

VLA policy loop (OpenVLA-style)

Step through the stack: observations → fused vision + language → action tokens → decode to commands → robot bridge.

Step-through · ~20 min

Sim Loop & Reward Shaping

RL training loop: observation, policy, action, reward, replay buffer, and episode lifecycle.

Step-through · ~20 min · SVG

Demo Collection Pipeline

How robot demonstrations become training data: recording, annotation, formats, validation.

Step-through · ~18 min · SVG

Planar 2-DOF arm & IK

Two revolute joints, analytic inverse kinematics, 3D visualization. Drag the target or step through the math.

3-DOF Arm & Orientation

Wrist joint for tool orientation. Redundancy, null-space motion, and joint limits.

Jacobian & Velocity IK

Numerical IK via the Jacobian matrix. Live matrix display, condition number, and damped least-squares.

Tier 3 · Bridging Sim & Real

Sim-to-Real Transfer

Domain randomization, system identification, progressive transfer.

Multi-Task Policy

Language conditioning, task embeddings, curriculum learning.

Grasp Planning & Contact

Force closure, antipodal grasps, grasp quality, friction.

Trajectory Planning

C-space, RRT, spline smoothing, velocity profiles.

Tier 4 · Perception & 3D

Vision-Language Grounding

CLIP, open-vocabulary detection, grounding, spatial reasoning.

World Models & Prediction

Latent dynamics, MPC, Dreamer, planning in imagination.

6-DOF Manipulation

Quaternions, 6×6 Jacobian, numerical IK, 7-DOF redundancy.

Force Control & Compliance

Impedance control, stiffness, hybrid force-position, peg insertion.

Tier 5 · Full Integration

End-to-End Deployment

Camera → VLA → action chunk → safety → IK → robot. The capstone.

Failure Recovery & Safety

OOD detection, workspace limits, force monitoring, E-stop, recovery.