Pro Algorithmic Workspace

A Claude Code skill for designing, implementing, and visualizing algorithms and data structures. Covers algorithm design patterns, complexity analysis, optimization techniques, and interactive algorithm visualization for learning and development.

When to Use This Skill

Choose Pro Algorithmic Workspace when:

• You need to design or optimize algorithms for specific problem types
• You want to analyze time and space complexity of your code
• You're preparing for coding interviews and need algorithm practice
• You need to choose the right data structure for a performance-critical feature
• You want to implement classic algorithms with modern best practices

Consider alternatives when:

• You need system design guidance (use a system design skill)
• You want database query optimization (use a database skill)
• You need general code review (use a code review skill)

Quick Start

Copy
# Install the skill
claude install pro-algorithmic-workspace

# Analyze algorithm complexity
claude "What's the time and space complexity of this function? [paste code]. Can it be optimized?"

# Choose the right data structure
claude "I need to find the top K elements from a stream of 1 million items. What's the best approach?"

# Implement an algorithm
claude "Implement Dijkstra's shortest path algorithm in TypeScript with a priority queue"

Core Concepts

Algorithm Design Patterns

Pattern	When to Use	Example Problems
Two Pointers	Sorted arrays, pair finding	Two sum, container with water
Sliding Window	Contiguous subarray problems	Max subarray sum, substring search
Divide and Conquer	Recursive decomposition	Merge sort, binary search
Dynamic Programming	Overlapping subproblems	Knapsack, LCS, edit distance
Greedy	Local optimal = global optimal	Activity selection, Huffman coding
Backtracking	Exhaustive search with pruning	N-Queens, sudoku solver
Graph Traversal	Network/relationship problems	Shortest path, cycle detection

Complexity Reference

O(1)        → Hash map lookup, array index access
O(log n)    → Binary search, balanced BST operations
O(n)        → Linear scan, single pass
O(n log n)  → Efficient sorting (merge sort, heap sort)
O(n²)       → Nested loops, brute force pairs
O(2^n)      → Recursive subsets, brute force combinations
O(n!)       → Permutations, brute force TSP

Space Complexity:
O(1)    → In-place algorithms
O(n)    → Hash maps, auxiliary arrays
O(n²)   → 2D matrices, DP tables

Data Structure Selection

Need	Data Structure	Time Complexity
Fast lookup by key	HashMap / Object	O(1) average
Sorted order + fast lookup	Balanced BST / TreeMap	O(log n)
Fast min/max	Heap / Priority Queue	O(log n) insert, O(1) peek
FIFO processing	Queue	O(1) enqueue/dequeue
LIFO processing	Stack	O(1) push/pop
Range queries	Segment Tree / BIT	O(log n) query/update
Unique elements	Set / HashSet	O(1) add/check
Graph relationships	Adjacency list / matrix	Varies by algorithm

Configuration

Parameter	Type	Default	Description
language	string	"typescript"	Implementation language
optimization_goal	string	"time"	Optimize for: time, space, readability
include_tests	boolean	true	Include unit tests with implementations
complexity_analysis	boolean	true	Include Big-O analysis in output
visualization	boolean	false	Include ASCII visualization of algorithm steps

Best Practices

1. Start with brute force, then optimize — Write the naive O(n²) or O(2^n) solution first. Make sure it's correct. Then optimize step by step. A correct slow solution is infinitely better than an incorrect fast one.

2. Choose data structures before algorithms — The right data structure often makes the algorithm obvious. Need O(1) lookups? Use a hash map. Need sorted data with fast inserts? Use a balanced BST. The data structure constrains and guides your algorithm.

3. Test with edge cases first — Empty input, single element, all duplicates, already sorted, reverse sorted, maximum size. Edge cases reveal bugs that normal inputs hide.

4. Measure, don't assume — Big-O tells you the growth rate, not the actual speed. An O(n log n) algorithm with high constant factors can be slower than O(n²) for small inputs. Profile with your actual data sizes.

5. Prefer readable code over clever code — A clear O(n log n) implementation that everyone can understand and maintain is better than an O(n) implementation that requires a PhD to debug. Optimize for correctness and readability first.

Common Issues

Solution works but times out — Check for hidden quadratic behavior: string concatenation in loops, array copying, unnecessary sorting inside loops. A seemingly O(n) algorithm can become O(n²) through expensive operations inside the loop.

Off-by-one errors — The most common bug in algorithm implementation. Use inclusive/exclusive range conventions consistently. When in doubt, trace through a small example (n=3) step by step.

Stack overflow in recursion — Convert deep recursion to iteration using an explicit stack, or use tail-call optimization where supported. For DP problems, switch from top-down (recursive) to bottom-up (iterative) tabulation.