Skip to main content Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/pluginagentmarketplace/custom-plugin-cpp --skill algorithmsThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... More from this repository Production-grade skill for C++ build infrastructure. Covers CMake, Make, Ninja, package managers (Conan, vcpkg), cross-platform builds, and CI/CD integration.
Production-grade skill for C++ concurrency and parallel programming. Covers threads, synchronization primitives, atomics, async programming, parallel algorithms, and lock-free data structures.
Production-grade skill for safe and efficient C++ memory management. Covers RAII, smart pointers, custom allocators, memory pools, and leak detection techniques.
Related occupations SOC
Based on SOC occupation classification
name algorithms version 3.0.0 description Production-grade skill for algorithm design and data structure implementation in C++. Covers complexity analysis, sorting, searching, graphs, dynamic programming, and STL algorithm mastery.
sasmp_version 1.3.0 skill_version 3.0.0 bonded_agent cpp-algorithms-agent bond_type PRIMARY_BOND category learning parameters {"algorithm_type":{"type":"string","required":false,"enum":["sorting","searching","graph","dynamic_programming","greedy","divide_conquer"],"description":"Category of algorithm to focus on"},"complexity_target":{"type":"string","required":false,"enum":["constant","logarithmic","linear","linearithmic","quadratic","exponential"],"description":"Target time complexity"},"data_structure":{"type":"string","required":false,"enum":["array","vector","list","tree","graph","heap","hash_table"],"description":"Data structure to use"},"explanation_depth":{"type":"string","required":false,"enum":["brief","standard","detailed","visual"],"default":"standard","description":"Level of explanation detail"}} error_handling {"retry_logic":{"max_attempts":3,"backoff":"exponential","initial_delay_ms":500,"max_delay_ms":8000,"jitter":true},"fallback":{"on_complexity_analysis_fail":"use_empirical_measurement","on_implementation_error":"provide_pseudocode_first","on_optimization_fail":"explain_tradeoffs"},"validation":{"verify_complexity_claims":true,"test_edge_cases":true,"check_algorithm_correctness":true}}
Algorithms Skill
Production-Grade Learning Skill | Algorithms & Data Structures
Master algorithm design and implementation in C++ with complexity analysis.
Complexity Analysis
Big O Notation Reference
Complexity Name Example Operations (n=1000) O(1) Constant Array access 1 O(log n) Logarithmic Binary search 10 O(n) Linear Linear search 1,000 O(n log n) Linearithmic Merge sort 10,000 O(n²) Quadratic Bubble sort 1,000,000 O(2^n) Exponential Recursive fib 10^301
Complexity Analysis Framework
int findMax (const std::vector<int >& v) int max = v[0 ];
for (int i = 1 ; i < v.size (); ++i) {
if (v[i] > max) {
max = v[i];
}
}
return max;
}
Sorting Algorithms
STL Sorting #include <algorithm>
#include <vector>
std::vector<int > v = {5 , 2 , 8 , 1 , 9 };
std::sort (v.begin (), v.end ());
std::stable_sort (v.begin (), v.end ());
std::partial_sort (v.begin (), v.begin () + 3 , v.end ());
std::nth_element (v.begin (), v.begin () + v.size ()/2 , v.end ());
std::sort (v.begin (), v.end (), std::greater <int >());
std::ranges::sort (v, {}, [](int x) { return std::abs (x); });
Sorting Algorithm Comparison Algorithm Best Average Worst Space Stable Quick Sort O(n log n) O(n log n) O(n²) O(log n) No Merge Sort O(n log n) O(n log n) O(n log n) O(n) Yes Heap Sort O(n log n) O(n log n) O(n log n) O(1) No Insertion Sort O(n) O(n²) O(n²) O(1) Yes Tim Sort O(n) O(n log n) O(n log n) O(n) Yes
Searching Algorithms
Binary Search #include <algorithm>
std::vector<int > v = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };
bool found = std::binary_search (v.begin (), v.end (), 5 );
auto it = std::lower_bound (v.begin (), v.end (), 5 );
auto it2 = std::upper_bound (v.begin (), v.end (), 5 );
auto [lo, hi] = std::equal_range (v.begin (), v.end (), 5 );
template <typename T, typename Pred>
T binary_search_first_true (T lo, T hi, Pred pred) while (lo < hi) {
T mid = lo + (hi - lo) / 2 ;
if (pred (mid)) {
hi = mid;
} else {
lo = mid + 1 ;
}
}
return lo;
}
Graph Algorithms
Graph Representations
std::vector<std::vector<int >> adj (n);
adj[0 ].push_back (1 );
std::vector<std::vector<std::pair<int , int >>> adj (n);
adj[0 ].push_back ({1 , weight});
std::vector<std::vector<int >> adj (n, std::vector <int >(n, 0 ));
adj[0 ][1 ] = 1 ;
BFS - Breadth First Search std::vector<int > bfs (int start, const std::vector<std::vector<int >>& adj) {
std::vector<int > dist (adj.size(), -1 ) ;
std::queue<int > q;
dist[start] = 0 ;
q.push (start);
while (!q.empty ()) {
int node = q.front ();
q.pop ();
for (int neighbor : adj[node]) {
if (dist[neighbor] == -1 ) {
dist[neighbor] = dist[node] + 1 ;
q.push (neighbor);
}
}
}
return dist;
}
DFS - Depth First Search void dfs (int node, const std::vector<std::vector<int >>& adj,
std::vector<bool >& visited, std::vector<int >& result) true ;
result.push_back (node);
for (int neighbor : adj[node]) {
if (!visited[neighbor]) {
dfs (neighbor, adj, visited, result);
}
}
}
Dijkstra's Algorithm std::vector<int > dijkstra (int start,
const std::vector<std::vector<std::pair<int ,int >>>& adj) {
std::vector<int > dist (adj.size(), INT_MAX) ;
std::priority_queue<std::pair<int ,int >,
std::vector<std::pair<int ,int >>,
std::greater<>> pq;
dist[start] = 0 ;
pq.push ({0 , start});
while (!pq.empty ()) {
auto [d, u] = pq.top ();
pq.pop ();
if (d > dist[u]) continue ;
for (auto [v, w] : adj[u]) {
if (dist[u] + w < dist[v]) {
dist[v] = dist[u] + w;
pq.push ({dist[v], v});
}
}
}
return dist;
}
Dynamic Programming
DP Framework
int lis (const std::vector<int >& nums) int n = nums.size ();
std::vector<int > dp (n, 1 ) ;
for (int i = 1 ; i < n; ++i) {
for (int j = 0 ; j < i; ++j) {
if (nums[j] < nums[i]) {
dp[i] = std::max (dp[i], dp[j] + 1 );
}
}
}
return *std::max_element (dp.begin (), dp.end ());
}
int lisOptimized (const std::vector<int >& nums) int > tails;
for (int x : nums) {
auto it = std::lower_bound (tails.begin (), tails.end (), x);
if (it == tails.end ()) {
tails.push_back (x);
} else {
*it = x;
}
}
return tails.size ();
}
Common DP Patterns Pattern Example State Complexity Linear Fibonacci dp[i] O(n) 2D Grid Path count dp[i][j] O(n×m) Interval Matrix chain dp[i][j] O(n³) Subset Knapsack dp[mask] O(2^n) Tree Tree DP dp[node] O(n)
Algorithm Selection Flowchart What type of problem?
├── Searching
│ ├── Sorted data? → Binary Search O(log n)
│ └── Unsorted? → Linear Search O(n) or Hash O(1)
├── Sorting
│ ├── Need stable? → std::stable_sort
│ ├── Partial sort? → std::partial_sort
│ └── General? → std::sort
├── Optimization
│ ├── Overlapping subproblems? → Dynamic Programming
│ └── Greedy choice property? → Greedy Algorithm
├── Graph
│ ├── Shortest path (unweighted)? → BFS
│ ├── Shortest path (weighted)? → Dijkstra/Bellman-Ford
│ ├── All pairs shortest? → Floyd-Warshall
│ └── Minimum spanning tree? → Kruskal/Prim
└── String
├── Pattern matching? → KMP/Rabin-Karp
└── Longest common? → DP
Troubleshooting Decision Tree Algorithm not working correctly?
├── Wrong output
│ ├── Check base cases
│ ├── Verify loop bounds
│ ├── Test edge cases (empty, single element)
│ └── Print intermediate values
├── Time Limit Exceeded (TLE)
│ ├── Check complexity matches constraint
│ ├── Look for unnecessary recomputation
│ ├── Consider memoization/DP
│ └── Use better data structure
├── Memory Limit Exceeded (MLE)
│ ├── Reduce DP state dimensions
│ ├── Use rolling array technique
│ └── Clear visited sets between runs
└── Runtime Error
├── Check array bounds
├── Check integer overflow
└── Check stack overflow (recursion depth)
Unit Test Template #include <gtest/gtest.h>
#include "algorithms.hpp"
class AlgorithmTest : public ::testing::Test {
protected :
void SetUp () override 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };
unsorted_vec = {5 , 2 , 8 , 1 , 9 , 3 , 7 , 4 , 6 , 10 };
}
std::vector<int > sorted_vec;
std::vector<int > unsorted_vec;
};
TEST_F (AlgorithmTest, BinarySearchFindsElement) {
EXPECT_TRUE (std::binary_search (sorted_vec.begin (), sorted_vec.end (), 5 ));
EXPECT_FALSE (std::binary_search (sorted_vec.begin (), sorted_vec.end (), 11 ));
}
TEST_F (AlgorithmTest, SortProducesOrderedOutput) {
std::sort (unsorted_vec.begin (), unsorted_vec.end ());
EXPECT_TRUE (std::is_sorted (unsorted_vec.begin (), unsorted_vec.end ()));
}
TEST_F (AlgorithmTest, BFSFindsShortestPath) {
std::vector<std::vector<int >> adj = {{1 , 2 }, {0 , 3 }, {0 , 3 }, {1 , 2 }};
auto dist = bfs (0 , adj);
EXPECT_EQ (dist[0 ], 0 );
EXPECT_EQ (dist[1 ], 1 );
EXPECT_EQ (dist[3 ], 2 );
}
TEST_F (AlgorithmTest, LISHandlesEdgeCases) {
EXPECT_EQ (lis ({}), 0 );
EXPECT_EQ (lis ({1 }), 1 );
EXPECT_EQ (lis ({3 , 2 , 1 }), 1 );
EXPECT_EQ (lis ({1 , 2 , 3 }), 3 );
}
Integration Points Component Interface stl-masterContainer selection performance-optimizerAlgorithm optimization modern-cpp-expertRanges and concepts cpp-fundamentals-agentBasic concepts
C++ Plugin v3.0.0 - Production-Grade Learning Skill
