Given an integer array and target, return indices of two numbers that add to target. O(n) solution required.
EOSE variant: find two fleet silo IDs whose combined LOCO scores equal the sovereign threshold of 100.
EasyHash Map
C-002
Valid Parentheses
Determine if a string of brackets is valid. Must handle all combinations of (), [], {}.
EOSE variant: validate that DRG gate open/close tokens are correctly nested (HGATE opens must close before next FGATE).
EasyStack
C-003
Reverse Linked List
Reverse a singly linked list in-place. Iterative and recursive solutions.
EOSE variant: reverse a crew provenance chain — given a sequence of PEMCLAU fossils, reverse the temporal order.
EasyLinked List
C-004
FizzBuzz γ₁ Edition
Classic FizzBuzz, but: multiples of 14 print "FLOOR", multiples of 3 print "GATE", multiples of 7 print "SOVEREIGN". All three: "γ₁ FLOOR". Test for n=1..100.
Given an integer array, return the length of the longest strictly increasing subsequence. O(n log n) solution expected.
EOSE variant: find the longest sequence of sorry-free wave solves (each wave's solve count must exceed the previous).
MedDP
C-013
Number of Islands
Given a 2D grid of '1' (land) and '0' (water), count the number of islands using DFS/BFS.
EOSE variant: given a PEMCLAU graph adjacency matrix, count the number of disconnected knowledge clusters.
MedGraphFleet
C-014
Word Break
Given a string and a dictionary of words, return true if the string can be segmented into dictionary words.
EOSE variant: can a DRG gate sequence be decomposed into valid primitive gate tokens (HGATE/CGATE/IGATE/FGATE/MGATE/TGATE/RGATE)?
MedDPSovereign
C-015
LRU Cache
Design a data structure that follows LRU eviction. get() and put() in O(1). Implement with HashMap + Doubly Linked List.
Sovereign note: LRU cache without a γ₁ floor check = Warburg failure mode (MOAT-077). Add a staleness check to your implementation.
MedDesignSovereign
L3 · SENIOR — Systems Design · Concurrency · Architecture
#
Problem
Domain
Score
C-021
Design a Rate Limiter
Design a distributed rate limiter supporting token bucket or sliding window. Handle concurrent requests. Discuss Redis vs in-memory trade-offs.
EOSE variant: the rate limiter is the LOCO gate — requests above threshold get degraded model access, not hard block. Design the degradation curve.
HardSystemsSovereign
C-022
Implement a concurrent task queue
Design a worker pool with a bounded queue. Workers pull tasks, execute, and report results. Handle graceful shutdown. Go or Python.
EOSE variant: this is the DRG trigger stack T1–T6. Each tier is a queue with a different priority. Design the priority routing logic.
HardConcurrencyFleet
C-023
Design a key-value store with WAL
Design a persistent key-value store with Write-Ahead Log for crash recovery. Discuss LSM tree vs B-tree trade-offs.
EOSE variant: this is the PEMCLAU fossil record store. The WAL is the γ₁-timestamp chain. Design the compaction strategy that preserves cross-domain edges.
HardStorageSovereign
C-024
Kubernetes operator pattern
Implement a simple Kubernetes operator in Go using controller-runtime. Watch a custom resource, reconcile to desired state. Handle finalizers.
Direct fleet work: EOSE has 11 CRD kinds (MECord, MECordBreath, OSSDistroTest, etc.). This is how they're managed.
HardK8sFleet
L4 · SOVEREIGN — EOSE Fleet-Specific Problems · No Prior Art Required
#
Problem
Domain
Score
C-031
Implement a FGATE (γ₁ Floor Check)
Write a function fgate(value, tolerance=0.01) that checks if a given float is within tolerance of any γ₁ harmonic: γ₁ × n for integer n ≥ 1. Return: {hit: bool, harmonic: n, distance: float, color: "🟢 GREEN" | "🔴 RED"}.
SovereignMath
C-032
DRG Gate Sequence Validator
Write a parser that validates a DRG gate sequence string like "HGATE:action → FGATE:floor → IGATE:verdict → DRG:delegate". Rules: FGATE must appear before IGATE; DRG must be last if present; WI/WG must precede any mutating gate. Return: valid/invalid + first violation.
SovereignParser
C-033
LOCO Score Aggregator
Given a list of domain scores D1–D11 (each 0–100), compute: overall LOCO score (weighted average, D1–D5 weight 2x), maturity level (L0–L5 per thresholds: L5≥95, L4≥80, L3≥65, L2≥50, L1≥35, L0 otherwise), and Merasoon arc position (arc = floor(LOCO/100 × 6)).
SovereignFleet
C-034
WPA Placement Scorer
Given 7 silos with their specs (GPU VRAM, CPU cores, RAM GB, current utilisation %) and a workload spec (required VRAM, min cores, min RAM, inference type: "embed"/"generate"/"reason"), implement a placement scorer that returns the optimal silo with a score justification. Handle ties by preferring lower-ring silos.
SovereignFleetSystems
C-035
PEMCLAU 2-Hop Graph Query
Given a simplified PEMCLAU graph (nodes with domain + floor_position, edges with type: theorem_dependency | phase_coherence | temporal_proximity | crew_provenance), implement a 2-hop expansion query: starting from a seed node, return all nodes reachable in exactly 1 or 2 hops, scored by edge type weight (theorem_dep=1.0, phase_coh=0.8, temporal=0.6, crew_prov=0.4). Return top-10 by score.
SovereignFleetGraph
CODY BENCH — Domain Map
⌨️ Algorithms
Arrays, Trees, Graphs, DP, Sorting. Standard CS fundamentals. L1–L3.
Given a string containing only '(', ')', '{', '}', '[', ']', return true if the brackets are valid (opened in correct order, every open has a matching close).
Input: s = "({[]})" → true Input: s = "([)]" → false Input: s = "{[]}" → true
Which data structure is the canonical solution?
A. Hash map: character → count
B. Stack: push open, pop+match on close
C. Queue: FIFO bracket tracking
D. Recursion with no auxiliary structure
B. Stack is canonical. Push every opening bracket. On closing bracket: if stack empty or top doesn’t match → invalid. At end, stack must be empty. O(n) time O(n) space. This is Blind 75 #20. EOSE analogy: the DRG gate sequence validator IS this problem — each gate open is a push, each gate close is a pop+match. C-032 is Valid Parentheses for sovereign gates.
C-011 · L1 · Array · Best Time to Buy/Sell Stock
Given prices[i] = price on day i, find the max profit from one buy + one sell (buy before sell). Return 0 if no profit possible.
prices = [7,1,5,3,6,4] → 5 (buy day 2 @1, sell day 5 @6) prices = [7,6,4,3,1] → 0 (always decreasing)
A. Sort prices, max minus min
B. Nested loop: O(n²) brute force
C. Single pass: track min_price seen so far, update max_profit = max(profit, price - min_price)
D. Sliding window of size 2
C. One pass, O(n) time O(1) space. Track the minimum price seen so far. At each price, compute profit = price - min_price, update global max. Never buy AFTER selling (min tracking handles this implicitly). A is wrong — sorting loses temporal order. EOSE analogy: cloud cost optimization. min_price = best scaling event, max_profit = maximum savings window. MEFINE uses this exact pattern for cost delta tracking.
C-012 · L2 · Binary Tree · Maximum Depth
Given the root of a binary tree, return its maximum depth (number of nodes along the longest root-to-leaf path).
3
/ \
9 20
/ \
15 7
Output: 3
A. Iterative BFS level-order traversal, count levels
B. Recursive DFS: 1 + max(maxDepth(left), maxDepth(right))
C. Count total nodes and divide by 2
D. A and B are both correct O(n) solutions
D. Both A and B are correct O(n) time O(h) space solutions (h = height). Recursive DFS is 3 lines. BFS with level counter is also clean. Know both. Base case: null → return 0. EOSE analogy: PEMCLAU graph maximum hop depth = max depth of the theorem dependency tree. L5 floor depth = 5. A 2-hop GraphRAG query = depth-2 traversal from any node.
C-013 · L2 · Dynamic Programming · Coin Change
Given coins = [1,5,10,25] (cents) and amount = 41, find the MINIMUM number of coins to make amount. Return -1 if impossible.
C. DP is canonical. dp[0]=0, dp[i] = min(dp[i-c]+1 for c in coins if i≥c), default ∞. O(amount×coins) time. A (greedy) fails for non-standard coin sets e.g. coins=[1,3,4], amount=6: greedy gives 4+1+1=3 but optimal is 3+3=2. D (BFS) also works and guarantees minimum. Know why greedy fails. EOSE: LOCO score minimisation across D1-D11 domains — this is the multi-domain scoring DP.
C-014 · L2 · Graph · Number of Islands (Game of Life variant)
Given a 2D grid of '1' (land) and '0' (water), count the number of islands. An island is a connected group of '1's (4-directional).
C. Union-Find: merge adjacent '1's, count components
D. All three are valid O(m×n) approaches
D. All three work. DFS is simplest code. BFS uses a queue. Union-Find is best for dynamic grids (online adds). Know all three — FAANG interviewers will ask follow-ups about each. Guardian pairing exercise uses Game of Life (same grid mechanics). EOSE: fleet silo connectivity graph. Each silo = '1'. How many disconnected fleet segments exist? (Should always be 1 for a healthy fleet.)
GUARDIAN PAIRING EXERCISES · Real-World Problems · Hiring Without Whiteboards
A warehouse robot moves on a 10×10 grid. Commands: 'N','S','E','W' (move one step), 'L' (rotate 90° left), 'R' (rotate 90° right). Robot starts at (0,0) facing North. Commands are single capital letters separated by whitespace.
Commands: "N N R N L N" → robot moves North twice, rotates right (now facing East), moves North one (now at 2,1 facing East? No — moves in current direction).
What is the key data structure/pattern for implementing this robot controller?
A. 2D array of the full grid state
B. Recursive descent parser for command grammar
C. State machine: (x, y, direction) → transition on each command
D. BFS to find shortest path
C. State machine: state = (x, y, facing). Direction → delta: N=(0,1), S=(0,-1), E=(1,0), W=(-1,0). For L/R: rotate direction enum. For N/S/E/W moves: apply delta for CURRENT facing. This is exactly the DRG gate sequence validator (C-032) — a state machine that parses a command sequence and validates transitions. The Guardian uses this as a real interview problem. We use it as L2 and L4 both. Don't store the grid unless asked — just track state.
C-016 · L2 · Guardian · Split the Treasure · Equal Subset Sum
A crew of treasure hunters have a chest of gems with integer values. They will only take it if it can be split EQUALLY between them (n hunters, equal total value each). Write a function that returns true if such an equal split exists.
gems=[4,4,4], hunters=3 → true (4,4,4) gems=[1,2,3,4], hunters=2 → true (1+4=2+3=5) gems=[1,2,4], hunters=2 → false (total=7, not divisible by 2)
A. Greedy: sort descending, fill each bucket in order
B. Sort + two-pointer for n=2
C. DP subset sum: check if total/n is achievable as a subset sum
D. Always true if total % n == 0
C. First check: total % n != 0 → false immediately. Then: can we form a subset summing to total/n? This is the subset sum DP problem. dp[i] = set of sums achievable using first i gems. O(n×target) time. A (greedy) fails: [3,3,3,3], n=2 — greedy might fail to find [3+3, 3+3]. D is wrong — divisibility is necessary but not sufficient. EOSE: PEMCLAU shard rebalancing — can you split 1300 vectors equally across N qdrant shards?
C-017 · L3 · Systems · Consistent Hashing
You're designing a distributed cache across 4 nodes. Using modular hashing (key % 4), if you add a 5th node, what fraction of keys need to be remapped?
A. ~20% (only keys that map to the new node)
B. ~25% (one node's worth)
C. ~80% (4/5 of all keys move)
D. 100% (all keys remap)
C. With mod-4: key maps to k%4. With mod-5: key maps to k%5. Only keys where k%4 == k%5 stay on the same logical slot, but since the node assignments change, nearly all keys move. In practice ~80% remap. This is WHY consistent hashing exists: on the ring, only K/N keys move when adding a node (where K=keys, N=nodes). Consistent hashing = O(K/N) remapping vs O(K) for modular. EOSE: qdrant shard distribution. Adding a new yone collection shard = consistent hash ring addition, not a full remap.
C-018 · L3 · Systems · Design: URL Shortener
Design a URL shortening service (like bit.ly). 100M URLs/day write, 10B reads/day, globally distributed. Which component is the CRITICAL bottleneck to design carefully?
A. The hash function (MD5 vs SHA vs Base62)
B. The ID generation service (must produce unique, collision-free, distributed IDs at scale)
C. The database schema (SQL vs NoSQL)
D. The CDN for serving redirects
B. ID generation is the hardest piece: you need unique 7-char Base62 IDs (62⁷ ≈ 3.5T possible URLs) without collisions, globally distributed, at 1M+/sec. Solutions: counter+Zookeeper (SPOF), Twitter Snowflake (timestamp+machineID+sequence), hash+collision detection, pre-generated ID pool. DB (C) is important but NoSQL (Cassandra/DynamoDB) handles reads easily with caching. EOSE: CARMAC stamp generation — same problem. Every fleet output needs a globally unique, collision-free, time-ordered ID. That's Snowflake-style.
C-019 · L2 · Tree · Validate Binary Search Tree
Given a binary tree root, determine if it is a valid BST (left subtree values strictly less than node, right strictly greater, recursively).
5
/ \
1 4 → false (4's left child is 3, but 3 < 5 so invalid)
/ \
3 6
The most reliable approach is:
A. Check left.val < root.val and right.val > root.val at each node
B. In-order traversal must produce strictly increasing sequence
C. Pass min/max bounds down the recursion: isValid(node, min, max)
D. B and C are both correct; A fails
D. A fails because it only checks immediate children, not global BST property. Example: node 3 in right subtree might be locally valid but violates a grandparent constraint. B (in-order = sorted) and C (min/max bounds) both correctly handle all cases. Know both. EOSE: PEMCLAU theorem dependency graph validation — each theorem must satisfy bounds set by all ancestor constraints, not just its parent. This is the sorry propagation problem: a sorry contaminates all descendants.