utility

---

1. Array Manipulation with std::iota

int arr[5];
iota(arr, arr + 5, 1); // Initialize array to [1, 2, 3, 4, 5]

2. Find Minimum and Maximum Elements with std::min and std::max

int a = 10, b = 20, c = 30;
int min_val = min({a, b, c}); // min_val = 10
int max_val = max({a, b, c}); // max_val = 30

3. Swap Values with std::swap

int a = 10, b = 20;
swap(a, b); // a = 20, b = 10

4. Check if Two Values Are Equal with std::equal_to

int a = 10, b = 10;
bool are_equal = std::equal_to<int>()(a, b); // are_equal = true

5. Count Occurrences in a Container with std::count

vector<int> v = {1, 2, 3, 4, 1};
int num_of_ones = count(v.begin(), v.end(), 1); // num_of_ones = 2

6. Reverse a Container with std::reverse

vector<int> v = {1, 2, 3, 4, 5};
reverse(v.begin(), v.end()); // v = {5, 4, 3, 2, 1}

7. Copy Elements from One Container to Another with std::copy

vector<int> src = {1, 2, 3, 4, 5};
vector<int> dest;
copy(src.begin(), src.end(), back_inserter(dest)); // dest = {1, 2, 3, 4, 5}

8. Search for an Element in a Container with std::find

vector<int> v = {1, 2, 3, 4, 5};
auto it = find(v.begin(), v.end(), 3); // it points to the element with value 3

9. Insert an Element into a Sorted Container with std::insert

set<int> s = {1, 2, 4, 5};
s.insert(3); // s = {1, 2, 3, 4, 5} (inserted in sorted order)

10. Create a Vector with a Range of Values with std::iota

vector<int> v(10);
iota(v.begin(), v.end(), 1); // v = {1, 2, 3, ..., 10}

11. Sort a Container with std::sort

vector<int> v = {5, 2, 3, 4, 1};
sort(v.begin(), v.end()); // v = {1, 2, 3, 4, 5}

12. Randomize a Container with std::shuffle

vector<int> v = {1, 2, 3, 4, 5};
random_shuffle(v.begin(), v.end()); // v is shuffled randomly

13. Create a Temporary Copy with std::make_unique

unique_ptr<int> p = make_unique<int>(10); // p points to a temporary copy of 10

14. Check if a Container Is Empty with std::empty

vector<int> v;
bool is_empty = v.empty(); // is_empty = true

15. Clear a Container with std::clear

vector<int> v = {1, 2, 3, 4, 5};
v.clear(); // v is empty now

16. Remove an Element from a Container with std::erase

vector<int> v = {1, 2, 3, 4, 5};
v.erase(v.begin() + 2); // removes the third element (element with value 3)

17. Transform a Container with std::transform

vector<int> v = {1, 2, 3, 4, 5};
transform(v.begin(), v.end(), v.begin(), [](int x) { return x * x; }); // v = {1, 4, 9, 16, 25}

18. Reduce a Container with std::accumulate

vector<int> v = {1, 2, 3, 4, 5};
int sum = accumulate(v.begin(), v.end(), 0); // sum = 15

19. Partition a Container with std::partition

vector<int> v = {1, 3, 2, 5, 4};
auto it = partition(v.begin(), v.end(), [](int x) { return x % 2 == 0; }); // it points to the first odd element

20. Convert to Uppercase with std::toupper

string s = "hello";
transform(s.begin(), s.end(), s.begin(), [](char c) { return toupper(c); }); // s = "HELLO"

21. Convert to Lowercase with std::tolower

string s = "HELLO";
transform(s.begin(), s.end(), s.begin(), [](char c) { return tolower(c); }); // s = "hello"

22. Trim Whitespace with std::trim

string s = "  hello  ";
s = trim(s); // s = "hello"

23. Split a String with std::split

string s = "a,b,c,d,e";
vector<string> parts = split(s, ','); // parts = {"a", "b", "c", "d", "e"}

24. Join Container Elements into a String with std::join

vector<string> parts = {"a", "b", "c", "d", "e"};
string s = join(parts, ","); // s = "a,b,c,d,e"

25. Check if a File Exists with std::filesystem::exists

namespace fs = std::filesystem;
bool file_exists = fs::exists("test.txt"); // file_exists = true/false

26. Create a Directory with std::filesystem::create_directory

namespace fs = std::filesystem;
fs::create_directory("my_directory"); // creates a directory named "my_directory"

27. Delete a File with std::filesystem::remove

namespace fs = std::filesystem;
fs::remove("test.txt"); // deletes the file named "test.txt"

28. List Directory Contents with std::filesystem::directory_iterator

namespace fs = std::filesystem;
for (const auto& entry : fs::directory_iterator("my_directory")) {
  // do something with the entry
}

29. Get Current Working Directory with std::filesystem::current_path

namespace fs = std::filesystem;
fs::path current_path = fs::current_path(); // get the current working directory

30. Parse a Command Line with Boost::ProgramOptions

#include <boost/program_options.hpp>
using namespace boost::program_options;
int main(int argc, char** argv) {
  options_description desc("Allowed options");
  desc.add_options()
    ("help", "produce help message")
    ("input", value<string>(), "input file");

  variables_map vm;        
  store(parse_command_line(argc, argv, desc), vm);
  notify(vm);    

  if (vm.count("help")) {
    cout << desc << "\n";
    return 0;
  }

  string input_file = vm["input"].as<string>();
  // do something with the input file
  return 0;
}

31. Create a HTTP Server with Boost::Beast

#include <boost/beast.hpp>
namespace http = boost::beast::http;
int main() {
  http::server server;
  server.listen("0.0.0.0", "8080");
  server.run();
  return 0;
}

32. Parse JSON with RapidJSON

#include "rapidjson/document.h"
rapidjson::Document doc;
doc.Parse(json.c_str()); // parse the JSON string
int value = doc["key"].GetInt(); // get the value of the "key" member

33. Create a WebSocket Server with websocketpp

#include <websocketpp/websocketpp.hpp>
using websocketpp::connection_hdl;
using websocketpp::server;
int main() {
  server<websocketpp::config::asio_tls> s;
  s.listen("0.0.0.0", "9002");
  s.run();
  return 0;
}

34. Send an Email with SmtpClient

#include <SmtpClient.h>
SmtpClient client("smtp.server.com", 587);
client.Login("username", "password");
client.Send("[e-mail]", "[e-mail]", "Subject", "Body");

35. Generate a Random Number with std::random_device

std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> dist(1, 100);
int random_number = dist(gen); // get a random number between 1 and 100

36. Create a Stopwatch with std::chrono

std::chrono::time_point<std::chrono::high_resolution_clock> start = std::chrono::high_resolution_clock::now();
// do some time-consuming operation
std::chrono::time_point<std::chrono::high_resolution_clock> end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> diff = end - start; // get the elapsed time in seconds

37. Log Messages with spdlog

#include "spdlog/spdlog.h"
auto logger = spdlog::stdout_logger_mt("console");
logger->info("This is an info message");
logger->error("This is an error message");

38. Create a Dependency Graph with Boost::Graph

#include <boost/graph/adjacency_list.hpp>
typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS> Graph;
Graph g;
boost::add_edge(0, 1, g); // add an edge between vertices 0 and 1

39. Create a Regular Expression with Boost::Regex

#include <boost/regex.hpp>
boost::regex re("^a(b+)*$"); // create a regular expression for matching strings that start with "a" followed by any number of "b"s
bool match = boost::regex_match("abbb", re); // check if the string "abbb" matches the regular expression

40. Perform a CPU-Intensive Task with std::thread and std::atomic

std::atomic<int> counter = 0;
std::thread t1([&counter]() {
  for (int i = 0; i < 1000000; i++) {
    counter++;
  }
});
std::thread t2([&counter]() {
  for (int i = 0; i < 1000000; i++) {
    counter--;
  }
});
t1.join();
t2.join();
cout << counter << endl; // prints a random value near zero

41. Create a Non-Blocking Socket with Boost::ASIO

#include <boost/asio.hpp>
int main() {
  boost::asio::io_service io_service;
  boost::asio::ip::tcp::acceptor acceptor(io_service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 8080));
  for (;;) {
    boost::asio::ip::tcp::socket socket(io_service);
    acceptor.accept(socket);
    // handle the connection
  }
  return 0;
}

42. Create a Binary Tree with Boost::Tree

#include <boost/tree/tree.hpp>
typedef boost::tree<char> Tree;
Tree t;
t.insert(t.begin(), 'A');
t.append_child(t.begin(), 'B');
t.append_child(t.begin()->begin(), 'C');

43. Perform Image Processing with OpenCV

#include <opencv2/opencv.hpp>
cv::Mat image = cv::imread("image.jpg");
cv::cvtColor(image, image, cv::COLOR_BGR2GRAY); // convert to grayscale
cv::blur(image, image, cv::Size(3, 3)); // blur the image
cv::imshow("Gray Image", image); // show the image in a window
cv::waitKey(0); // wait for a key press

44. Create a Data Structure with Boost::MultiIndex

#include <boost/multi_index_container.hpp>
typedef boost::multi_index_container<
  int,
  boost::multi_index::indexed_by<
    boost::multi_index::sequenced<boost::multi_index::identity<int>>,
    boost::multi_index::random_access<boost::multi_index::identity<int>>,
    boost::multi_index::hashed_non_unique<int>
  >
> IntSet;
IntSet s;
s.insert(1);
s.insert(2);
s.insert(3);

45. Generate a UUID with Boost::UUID

#include <boost/uuid/uuid.hpp>
boost::uuids::uuid uuid = boost::uuids::random_uuid(); // generate a random UUID
string uuid_str = boost::uuids::to_string(uuid); // convert the UUID to a string

46. Compress Data with zlib

#include <zlib.h>
int main() {
  char* uncompressed_data = "Hello, world!";
  unsigned long uncompressed_size = strlen(uncompressed_data);
  unsigned long compressed_size = compressBound(uncompressed_size);
  char* compressed_data = new char[compressed_size];
  int result = compress(compressed_data, &compressed_size, uncompressed_data, uncompressed_size);
  // decompress the data
  char* decompressed_data = new char[uncompressed_size];
  int result = uncompress(decompressed_data, &uncompressed_size, compressed_data, compressed_size);
  cout << decompressed_data << endl; // prints "Hello, world!"
  delete[] compressed_data;
  delete[] decompressed_data;
  return 0;
}

47. Check if a URL is Valid with Boost::URL

#include <boost/url.hpp>
boost::url::url u;
try {
  u = boost::url::url("http://example.com/path/to/file.html");
  cout << "URL: " << u.protocol() << "://" << u.host() << u.path() << endl;
} catch (const boost::url::bad_url_exception& e) {
  cout << "Invalid URL: " << e.what() << endl;
}

48. Create a Random Forest with scikit-learn

from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

49. Perform a Natural Language Processing Task with spaCy

import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Hello, world!")
for token in doc:
  print(f"{token.text} ({token.pos_})")

50. Create a REST API with Flask

from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route("/api/todos", methods=["GET"])
def get_todos():
  return jsonify([{"id": 1, "title": "Buy milk"}, {"id": 2, "title": "Do laundry"}])
app.run()