Strings
#include <iostream>
#include <string>
#include <algorithm> // For transform, sort, etc.
#include <cctype> // For toupper, tolower
#include <vector> // For splitting into a list of characters
int main() {
std::string my_string = "Hello World";
// Convert to uppercase
std::transform(my_string.begin(), my_string.end(), my_string.begin(), ::toupper);
std::cout << "Uppercase: " << my_string << std::endl;
// Convert to lowercase
std::transform(my_string.begin(), my_string.end(), my_string.begin(), ::tolower);
std::cout << "Lowercase: " << my_string << std::endl;
// Check if all characters are alphabetic
bool is_alpha = std::all_of(my_string.begin(), my_string.end(), ::isalpha);
std::cout << "Is alphabetic: " << is_alpha << std::endl;
// Check if string is alphanumeric
bool is_alnum = std::all_of(my_string.begin(), my_string.end(), ::isalnum);
std::cout << "Is alphanumeric: " << is_alnum << std::endl;
// ASCII value of the first character
int ascii_value = static_cast<int>(my_string[0]);
std::cout << "ASCII value of first character: " << ascii_value << std::endl;
// Reverse the string
std::reverse(my_string.begin(), my_string.end());
std::cout << "Reversed: " << my_string << std::endl;
// Split string into a list of characters
std::vector<char> char_list(my_string.begin(), my_string.end());
std::cout << "Split into characters: ";
for (char c : char_list) std::cout << c << " ";
std::cout << std::endl;
// Check if a string contains a substring
std::string substring = "World";
if (my_string.find(substring) != std::string::npos) {
std::cout << "Substring found!" << std::endl;
}
// Split a string based on a delimiter (space in this case)
std::string str = "This is a test";
std::vector<std::string> words;
size_t pos = 0;
std::string delimiter = " ";
while ((pos = str.find(delimiter)) != std::string::npos) {
words.push_back(str.substr(0, pos));
str.erase(0, pos + delimiter.length());
}
words.push_back(str); // Add the last word
std::cout << "Split based on spaces: ";
for (const auto& word : words) std::cout << word << " ";
std::cout << std::endl;
// Replace a substring
std::string my_string2 = "Hello World";
std::string old_substring = "World";
std::string new_substring = "C++";
size_t start_pos = my_string2.find(old_substring);
if (start_pos != std::string::npos) {
my_string2.replace(start_pos, old_substring.length(), new_substring);
}
std::cout << "After replacement: " << my_string2 << std::endl;
// Get index of a character
char search_char = 'l';
size_t index = my_string2.find(search_char);
if (index != std::string::npos) {
std::cout << "Character '" << search_char << "' found at index: " << index << std::endl;
}
// Sort a string (lexicographically)
std::string my_str = "hello";
std::string sorted_str = my_str;
std::sort(sorted_str.begin(), sorted_str.end());
std::cout << "Sorted string: " << sorted_str << std::endl;
// Get sorted list of characters
std::vector<char> sorted_char_list(my_str.begin(), my_str.end());
std::sort(sorted_char_list.begin(), sorted_char_list.end());
std::cout << "Sorted list of characters: ";
for (char c : sorted_char_list) std::cout << c << " ";
std::cout << std::endl;
return 0;
}
Vectors
#include <vector>
#include <algorithm> // For sort, min, max, etc.
#include <numeric> // For accumulate
#include <iostream> // For input/output
#include <iterator> // For iterators
int main() {
std::vector<int> vec = {1, 2, 3, 4, 5};
std::vector<int> vec2 = {3, 4, 5, 6, 7};
// Add elements to vector
vec.push_back(6); // Adds element to the end
vec.pop_back(); // Removes the last element
// Access elements
int first = vec.front(); // First element
int last = vec.back(); // Last element
int atIndex = vec.at(2); // Access by index with bounds checking
// Enumerate using index (manual)
for (size_t i = 0; i < vec.size(); ++i) {
std::cout << "Index " << i << ": " << vec[i] << std::endl;
}
// Enumerate using iterators
for (auto it = vec.begin(); it != vec.end(); ++it) {
std::cout << *it << std::endl;
}
// Sort the vector (ascending or descending)
std::sort(vec.begin(), vec.end()); // Ascending
std::sort(vec.begin(), vec.end(), std::greater<>()); // Descending
// Subtract indices of two vectors (similar to Python zip)
std::vector<int> result;
std::transform(vec.begin(), vec.end(), vec2.begin(), std::back_inserter(result),
[](int a, int b) { return b - a; });
// Slicing (manually with iterators)
std::vector<int> subvector(vec.begin() + 1, vec.begin() + 3); // Slicing vec[1:3]
// Reverse the vector
std::reverse(vec.begin(), vec.end());
// Get a copy of the vector
std::vector<int> copy = vec; // Copy of vector
// Find min and max in a vector
int min_value = *std::min_element(vec.begin(), vec.end());
int max_value = *std::max_element(vec.begin(), vec.end());
// Find an element in a vector
auto it = std::find(vec.begin(), vec.end(), 3);
if (it != vec.end()) {
std::cout << "Element found at index " << std::distance(vec.begin(), it) << std::endl;
}
// Sum of elements in a vector
int sum = std::accumulate(vec.begin(), vec.end(), 0);
// Remove elements from a vector
vec.erase(vec.begin() + 1); // Remove element at index 1
vec.erase(std::remove(vec.begin(), vec.end(), 3), vec.end()); // Remove all occurrences of 3
// Clear the vector
vec.clear();
return 0;
}
Maps
#include <iostream>
#include <map> // For std::map
#include <unordered_map> // For std::unordered_map
#include <algorithm> // For std::equal
int main() {
// Initialize a map
std::map<std::string, int> my_map = {{"apple", 1}, {"banana", 2}, {"orange", 3}};
// Remove all elements
my_map.clear();
// Try to pop or return a specified default
std::string key_to_pop = "apple";
auto it = my_map.find(key_to_pop);
int value = (it != my_map.end()) ? it->second : -1; // Default value is -1 if key not found
if (it != my_map.end()) {
my_map.erase(it); // Remove the key-value pair
}
std::cout << "Popped value: " << value << std::endl;
// Pop last key-item pair
if (!my_map.empty()) {
auto last_it = --my_map.end(); // Get iterator to the last element
std::cout << "Popped last key-value pair: " << last_it->first << " -> " << last_it->second << std::endl;
my_map.erase(last_it); // Erase the last element
}
// Copy elements
std::map<std::string, int> other_map = my_map; // Copy the map
// Copy elements from keys
std::map<std::string, int> from_keys_map;
std::vector<std::string> keys = {"apple", "banana", "cherry"};
for (const auto& key : keys) {
from_keys_map[key] = 0; // Default value
}
// Get elements
std::string key = "banana";
int retrieved_value = (my_map.find(key) != my_map.end()) ? my_map[key] : -1; // Default value is -1 if key not found
std::cout << "Retrieved value: " << retrieved_value << std::endl;
// Insert an element if key is not present
std::string new_key = "pear";
my_map.insert({new_key, 5}); // Will not insert if key already exists
// Get all key-value pairs
for (const auto& pair : my_map) {
std::cout << pair.first << " -> " << pair.second << std::endl;
}
// Get all keys
for (const auto& pair : my_map) {
std::cout << "Key: " << pair.first << std::endl;
}
// Get all values
for (const auto& pair : my_map) {
std::cout << "Value: " << pair.second << std::endl;
}
// Update elements
std::map<std::string, int> update_map = {{"cherry", 4}, {"banana", 7}};
my_map.insert(update_map.begin(), update_map.end()); // Insert or update elements
// Compare two maps
std::map<std::string, int> my_map2 = {{"apple", 1}, {"banana", 2}};
bool are_equal = (my_map == my_map2);
std::cout << "Are maps equal? " << are_equal << std::endl;
return 0;
}
Sets
#include <iostream>
#include <set>
int main() {
// Create a set
std::set<int> my_set; // Empty set
std::set<int> my_set2 = {1, 2, 3}; // Initialize with values
// Set size
std::cout << "Set size: " << my_set2.size() << std::endl;
// Add elements
my_set2.insert(4); // Add an element to the set
// Remove elements
my_set2.erase(3); // Remove an element (throws no error if item not found)
// Discard (same as erase in C++ since it does not raise an error if the element is not found)
my_set2.erase(2); // Erase item if it exists, no error if it doesn't
// Union of sets
std::set<int> set1 = {1, 2, 3};
std::set<int> set2 = {3, 4, 5};
std::set<int> union_set;
std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(),
std::inserter(union_set, union_set.begin()));
// Intersection of sets
std::set<int> intersection_set;
std::set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(),
std::inserter(intersection_set, intersection_set.begin()));
// Difference of sets
std::set<int> difference_set;
std::set_difference(set1.begin(), set1.end(), set2.begin(), set2.end(),
std::inserter(difference_set, difference_set.begin()));
// Check if a set is a subset
bool is_subset = std::includes(set2.begin(), set2.end(), set1.begin(), set1.end());
std::cout << "Is set1 a subset of set2? " << is_subset << std::endl;
// Check if a set is a superset (reverse of subset)
bool is_superset = std::includes(set1.begin(), set1.end(), set2.begin(), set2.end());
std::cout << "Is set1 a superset of set2? " << is_superset << std::endl;
// Check if two sets are disjoint
bool is_disjoint = std::none_of(set1.begin(), set1.end(),
[&](int elem){ return set2.find(elem) != set2.end(); });
std::cout << "Are set1 and set2 disjoint? " << is_disjoint << std::endl;
return 0;
}
Data Structures
#include <iostream>
#include <array>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <functional> // For std::greater
int main() {
// --- Array (Fixed size) ---
std::array<int, 5> arr = {1, 2, 3, 4, 5};
std::cout << "Array first element: " << arr[0] << std::endl;
// --- Vector (Dynamic array) ---
std::vector<int> vec = {1, 2, 3};
vec.push_back(4); // Add an element
std::cout << "Vector last element: " << vec.back() << std::endl;
// --- Deque (Double-ended queue) ---
std::deque<int> deq = {1, 2, 3};
deq.push_front(0);
deq.push_back(4);
std::cout << "Deque front: " << deq.front() << ", back: " << deq.back() << std::endl;
// --- Queue (FIFO) ---
std::queue<int> q;
q.push(10); q.push(20);
std::cout << "Queue front: " << q.front() << std::endl;
q.pop();
// --- Stack (LIFO) ---
std::stack<int> stack;
stack.push(10); stack.push(20);
std::cout << "Stack top: " << stack.top() << std::endl;
stack.pop();
// --- Priority Queue (Max Heap) ---
std::priority_queue<int> max_heap;
max_heap.push(10); max_heap.push(5); max_heap.push(30);
std::cout << "Max Heap top: " << max_heap.top() << std::endl;
// --- Priority Queue (Min Heap) ---
std::priority_queue<int, std::vector<int>, std::greater<int>> min_heap;
min_heap.push(10); min_heap.push(5); min_heap.push(30);
std::cout << "Min Heap top: " << min_heap.top() << std::endl;
// --- Set (Ordered set of unique elements) ---
std::set<int> s = {3, 1, 4};
s.insert(2);
std::cout << "Set smallest element: " << *s.begin() << std::endl;
// --- Unordered Set (Unordered unique elements) ---
std::unordered_set<int> us = {3, 1, 4};
us.insert(2);
if (us.find(4) != us.end()) std::cout << "4 is in the unordered set" << std::endl;
// --- Map (Ordered key-value pairs) ---
std::map<std::string, int> my_map;
my_map["apple"] = 10; my_map["banana"] = 20;
std::cout << "Map value for 'apple': " << my_map["apple"] << std::endl;
// --- Unordered Map (Unordered key-value pairs) ---
std::unordered_map<std::string, int> umap;
umap["apple"] = 10; umap["banana"] = 20;
std::cout << "Unordered map value for 'apple': " << umap["apple"] << std::endl;
return 0;
}
Leave a Reply