string

---

1. String Creation

std::string str1 = "Hello, World!";  // Initializing with a literal
std::string str2(10, 'a');  // Initializing with a character repeated 10 times

2. String Concatenation

std::string str1 = "Hello";
std::string str2 = ", World!";
std::string str3 = str1 + str2;  // Concatenating str1 and str2

3. String Comparison

std::string str1 = "Apple";
std::string str2 = "Orange";
bool result = (str1 == str2);  // Comparing str1 and str2

4. String Search

std::string str = "This is a sample string";
size_t pos = str.find("sample");  // Finding the first occurrence of "sample"

5. String Replacement

std::string str = "Replace this";
str.replace(0, 6, "Something else");  // Replacing the first 6 characters

6. String Extraction

std::string str = "This is a sample string";
std::string substring = str.substr(5, 5);  // Extracting the substring starting at index 5 for 5 characters

7. String Conversion

std::string str = "123";
int number = std::stoi(str);  // Converting the string to an integer

8. String Formatting

std::string str = std::format("The number is %d", 10);  // Formatting a string using sprintf syntax

9. String Tokenization

std::string str = "Hello, World!";
std::vector<std::string> tokens;
std::istringstream(str) >> tokens;  // Tokenizing the string into a vector

10. String Uppercase/Lowercase

std::string str = "Hello";
str.to_upper();  // Converting to uppercase
str.to_lower();  // Converting to lowercase

11. String Trim

std::string str = "  Hello, World!  ";
str.trim();  // Trimming leading and trailing whitespace

12. String Split

std::string str = "Hello,World,How,Are,You";
std::vector<std::string> parts = split(str, ',');  // Splitting the string by commas

13. String Join

std::vector<std::string> words = {"Hello", "World", "How", "Are", "You"};
std::string result = join(words, ",");  // Joining the vector into a comma-separated string

14. String Comparison (STL)

std::string str1 = "Apple";
std::string str2 = "Orange";
bool result = (str1 < str2);  // Comparing str1 and str2 using STL lexicographical comparison

15. String Validation

std::string str = "Hello, World!";
bool valid = std::regex_match(str, std::regex("[a-zA-Z0-9 ]+"));  // Validating the string using a regular expression

16. String Hashing

std::string str = "Hello, World!";
size_t hash = std::hash<std::string>()(str);  // Hashing the string using the STL hash function

17. String Encapsulation

class Person {
public:
    std::string name;
    // Constructor, getter, setter
};

18. String Manipulation in Loop

for (int i = 0; i < str.length(); i++) {
    // Do something with str[i]
}

19. String Iteration with Range-Based For Loop

for (char ch : str) {
    // Do something with ch
}

20. String Search with Regular Expression

std::regex pattern("world", std::regex::icase);
if (std::regex_search(str, pattern)) {
    // Do something
}

21. String Formatting with Format Specifiers

std::string formatted = std::format("%s %d", "Hello", 10);

22. String Utility Headers

#include <string>
#include <sstream>
#include <regex>

23. String Reversal

std::string str = "Hello, World!";
std::reverse(str.begin(), str.end());

24. String Rot13 Encryption

std::string rot13(const std::string& str) {
    std::string result;
    for (char ch : str) {
        if (ch >= 'a' && ch <= 'z') {
            result += ((ch - 'a' + 13) % 26) + 'a';
        } else if (ch >= 'A' && ch <= 'Z') {
            result += ((ch - 'A' + 13) % 26) + 'A';
        } else {
            result += ch;
        }
    }
    return result;
}

25. String Character Count

std::map<char, int> char_counts;
for (char ch : str) {
    char_counts[ch]++;
}

26. String Palindrome Check

bool is_palindrome(const std::string& str) {
    std::string reversed = str;
    std::reverse(reversed.begin(), reversed.end());
    return str == reversed;
}

27. String Vector

std::vector<std::string> str_vector = {"Hello", "World", "How", "Are", "You"};

28. String List

std::list<std::string> str_list = {"Hello", "World", "How", "Are", "You"};

29. String Set

std::set<std::string> str_set = {"Hello", "World", "How", "Are", "You"};

30. String Map

std::map<std::string, int> str_map = {{"Hello", 1}, {"World", 2}, {"How", 3}, {"Are", 4}, {"You", 5}};

31. String Anagram

bool is_anagram(const std::string& str1, const std::string& str2) {
    if (str1.size() != str2.size()) {
        return false;
    }
    std::unordered_map<char, int> char_counts;
    for (char ch : str1) {
        char_counts[ch]++;
    }
    for (char ch : str2) {
        if (char_counts[ch] == 0) {
            return false;
        }
        char_counts[ch]--;
    }
    return true;
}

32. String Longest Common Prefix

std::string longest_common_prefix(const std::vector<std::string>& strs) {
    if (strs.empty()) {
        return "";
    }
    std::string prefix = strs[0];
    for (int i = 1; i < strs.size(); i++) {
        while (strs[i].find(prefix) != 0) {
            prefix = prefix.substr(0, prefix.size() - 1);
        }
    }
    return prefix;
}

33. String Isogram

bool is_isogram(const std::string& str) {
    std::set<char> char_set;
    for (char ch : str) {
        if (char_set.find(ch) != char_set.end()) {
            return false;
        }
        char_set.insert(ch);
    }
    return true;
}

34. String Pangram

bool is_pangram(const std::string& str) {
    std::set<char> char_set;
    for (char ch = 'a'; ch <= 'z'; ch++) {
        char_set.insert(ch);
    }
    for (char ch : str) {
        if (char_set.find(ch) != char_set.end()) {
            char_set.erase(ch);
        }
    }
    return char_set.empty();
}

35. String Zigzag Conversion

std::string convert(const std::string& str, int num_rows) {
    if (num_rows == 1) {
        return str;
    }
    std::vector<std::string> rows(num_rows);
    int row = 0;
    int direction = 1;
    for (char ch : str) {
        rows[row += direction] += ch;
        if (row == 0 || row == num_rows - 1) {
            direction *= -1;
        }
    }
    std::string result;
    for (const std::string& row : rows) {
        result += row;
    }
    return result;
}

36. String Wildcard Matching

bool is_wildcard_match(const std::string& str, const std::string& pattern) {
    int i = 0;