C++ String Exercises

#include <iostream>
#include <string>

int main() {
    std::string user_string;

    // Prompt the user for input
    std::cout << "Enter a string: ";
    // Read the entire line, including spaces
    std::getline(std::cin, user_string);

    // Calculate the length
    int length = user_string.length();

    // Print the result
    std::cout << "The length of the string is: " << length << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The solution uses std::string to store the user’s input.
• The std::getline(std::cin, user_string) function is essential here as it allows the program to read the entire line of input, including spaces, until the user presses Enter.
• Finally, the .length() method of the std::string object is called to retrieve and display the character count.

#include <iostream>
#include <string>

int main() {
    std::string str1, str2;

    // Get the first string
    std::cout << "Enter the first string: ";
    std::getline(std::cin, str1);

    // Get the second string
    std::cout << "Enter the second string: ";
    std::getline(std::cin, str2);

    // Concatenate the two strings using the '+' operator
    std::string combined_string = str1 + " " + str2;

    // Print the concatenated string
    std::cout << "The combined string is: " << combined_string << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Two std::string variables, str1 and str2, are read from the user.
• The core operation is the use of the + operator (str1 + " " + str2).
• This operator creates a new std::string object by appending str2 to str1, with an added space literal in between for readability, demonstrating simple string concatenation.

#include <iostream>
#include <string>

int main() {
    std::string str = "PYnative";

    // Access the first character (index 0)
    char first_char = str[0];

    // Access the last character (index length - 1)
    char last_char = str[str.length() - 1];

    std::cout << "First character: " << first_char << std::endl;
    std::cout << "Last character: " << last_char << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The characters are accessed using the array-like subscript operator []. The first character is always at index 0 (str[0]).
• The length of the string is retrieved using str.length(), and since indexing is zero-based, the last character’s index is calculated as str.length() - 1.
• A necessary check for an empty string (str.empty()) is included to prevent an out-of-bounds error.

#include <iostream>
#include <string>

int main() {
    std::string text = "PYnative";
    char target_char = 't';

    // Use the find() method
    size_t found_pos = text.find(target_char);

    // The find() method returns std::string::npos if the character is not found
    if (found_pos != std::string::npos) {
        std::cout << "SUCCESS: The character '" << target_char 
                  << "' was found at index " << found_pos << "." << std::endl;
    } else {
        std::cout << "FAILURE: The character '" << target_char 
                  << "' was NOT found in the string." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

This solution utilizes the .find() method of the std::string class.

It searches for the target_char within the text string. If the character is found, find() returns the index of the first occurrence. If it is not found, it returns the constant std::string::npos (which stands for ‘no position’). The program checks the return value against std::string::npos to report the outcome.

#include <iostream>
#include <string>

int main() {
    // 1. Define the source string
    std::string original_string = "Hello, C++ World!";
    
    // 2. Declare the destination string
    std::string copied_string;

    // 3. Perform the copy using the assignment operator
    copied_string = original_string;

    // 4. Modify the original string to prove it's a value copy
    original_string = "The original string has been changed.";

    // Print both strings
    std::cout << "Original String (after modification): " << original_string << std::endl;
    std::cout << "Copied String (remains unchanged): " << copied_string << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

C++ std::string implements value semantics, which means when you use the assignment operator (copied_string = original_string;), a deep copy of the character sequence is performed.

The copied_string now holds its own independent copy of the data “Hello, C++ World!”. The modification to the original_string afterward does not affect the copied_string, confirming a true copy was made.

#include <iostream>
#include <string>
#include <algorithm> // Required for std::reverse

int main() {
    std::string str;
    std::cout << "Enter a string to reverse: ";
    std::getline(std::cin, str);

    // Create a copy to reverse (optional, but good practice if you need the original)
    std::string reversed_str = str;

    // Use the std::reverse algorithm on the iterators
    // str.begin() points to the first element
    // str.end() points past the last element
    std::reverse(reversed_str.begin(), reversed_str.end());

    std::cout << "Original string: " << str << std::endl;
    std::cout << "Reversed string: " << reversed_str << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise demonstrates the most idiomatic C++ way to reverse a sequence: using the std::reverse algorithm found in the <algorithm> header.

It takes two arguments: an iterator pointing to the beginning of the range to be reversed (reversed_str.begin()) and an iterator pointing one past the end of the range (reversed_str.end()). The algorithm efficiently swaps the characters in place within the reversed_str copy.

#include <iostream>
#include <string>
#include <cctype> // Required for tolower() and isalpha()

int main() {
    std::string str;
    int vowel_count = 0;
    int consonant_count = 0;

    std::cout << "Enter a string: ";
    std::getline(std::cin, str);

    for (char c : str) {
        // 1. Check if the character is an alphabet letter
        if (std::isalpha(c)) {
            // 2. Convert to lowercase for easy comparison
            char lower_c = std::tolower(c);

            // 3. Check if it is a vowel
            if (lower_c == 'a' || lower_c == 'e' || lower_c == 'i' || lower_c == 'o' || lower_c == 'u') {
                vowel_count++;
            } 
            // 4. If it is a letter but not a vowel, it's a consonant
            else {
                consonant_count++;
            }
        }
        // Ignore spaces, digits, and punctuation
    }

    std::cout << "Vowel Count: " << vowel_count << std::endl;
    std::cout << "Consonant Count: " << consonant_count << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

The solution uses a range-based for loop for clean iteration.

The crucial functions from the <cctype> header are: std::isalpha(c) to ensure only letters are processed, and std::tolower(c) to convert any uppercase letters to lowercase, simplifying the vowel check to only five comparisons (a, e, i, o, u). This logic correctly counts vowels and consonants while ignoring other characters like spaces or numbers.

#include <iostream>
#include <string>
#include <cctype>   // For std::toupper and std::tolower
#include <algorithm> // For std::transform

int main() {
    std::string str = "PYnative C++ String Exercises";
    std::cout << "Original: " << str << std::endl;

    // 1. Convert to UPPERCASE
    std::string upper_str = str; // Make a copy
    std::transform(upper_str.begin(), upper_str.end(), upper_str.begin(), 
                   [](unsigned char c){ return std::toupper(c); });

    std::cout << "Uppercase: " << upper_str << std::endl;

    // 2. Convert to LOWERCASE
    std::string lower_str = str; // Use the original again
    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), 
                   [](unsigned char c){ return std::tolower(c); });

    std::cout << "Lowercase: " << lower_str << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

The most modern and efficient way to perform bulk character-by-character transformations is using the std::transform algorithm from the <algorithm> header.

This function applies a specified operation (in this case, std::toupper or std::tolower via a lambda function) to every element in the source range (defined by .begin() and .end() iterators) and stores the result back into the specified destination range (upper_str.begin()).

#include <iostream>
#include <string>
#include <algorithm> // Required for std::remove_if
#include <cctype>    // Required for std::isspace

int main() {
    std::string str = "This String Has Multiple Spaces.";

    std::cout << "Original string: \"" << str << "\"" << std::endl;

    // 1. Use std::remove_if to move all unwanted characters (spaces) to the end
    // The lambda function checks if a character is a space using std::isspace.
    str.erase(
        std::remove_if(str.begin(), str.end(), 
                       [](unsigned char x){ return std::isspace(x); }),
        str.end()
    );

    std::cout << "String without spaces: \"" << str << "\"" << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

This solution uses a standard library idiom: std::remove_if followed by .erase(). std::remove_if moves all characters that satisfy the predicate (i.e., spaces, checked by std::isspace) to the end of the string and returns an iterator to the new logical end of the valid data.

The .erase() method then uses this iterator to physically cut off the unwanted characters, resulting in an efficient in-place space removal.

#include <iostream>
#include <string>
#include <algorithm>

int main() {
    std::string original;
    std::cout << "Enter a string to check for palindrome: ";
    std::getline(std::cin, original);

    // 2. Create the reversed copy
    std::string reversed = original;
    std::reverse(reversed.begin(), reversed.end());

    // 3. Compare the cleaned original with the reversed copy
    if (original.empty()) {
        std::cout << "The string is empty." << std::endl;
    }
    else if (original == reversed) {
        std::cout << "\"" << original << "\" IS a palindrome." << std::endl;
    } else {
        std::cout << "\"" << original << "\" IS NOT a palindrome." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The std::reverse algorithm creates a reversed copy of this cleaned string. A simple equality check (clean_original == reversed) is then sufficient to determine if the string meets the palindrome criteria.

#include <iostream>
#include <string>
#include <sstream> // Required for std::stringstream

int main() {
    std::string sentence;
    int word_count = 0;

    std::cout << "Enter a sentence or paragraph: ";
    std::getline(std::cin, sentence);

    // Create a stringstream object from the input string
    std::stringstream ss(sentence);
    
    // Temporary string to hold each extracted word
    std::string word;

    // The while loop extracts words until the stringstream is empty
    while (ss >> word) {
        word_count++;
    }

    std::cout << "Total word count: " << word_count << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The solution leverages the std::stringstream class. Initializing ss with the input string places the string’s content into a stream buffer.
• The expression ss >> word is the key: the stream extraction operator (>>) skips leading whitespace and reads characters until it encounters the next whitespace character, effectively extracting one word at a time into the word variable.
• The loop continues and increments word_count until the stream is empty.

#include <iostream>
#include <string>

int main() {
    std::string main_string;
    std::string sub_string;

    std::cout << "Enter the main text string: ";
    std::getline(std::cin, main_string);

    std::cout << "Enter the substring to search for: ";
    std::getline(std::cin, sub_string);

    // Use the find() method
    size_t found_index = main_string.find(sub_string);

    if (found_index != std::string::npos) {
        std::cout << "Substring found!" << std::endl;
        std::cout << "Starting index: " << found_index << std::endl;
    } else {
        std::cout << "Substring not found in the main text." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise is efficiently solved using the built-in std::string::find() method.
• The method returns a size_t value, which is an unsigned integer type used for sizes and indices. If the substring is found, found_index holds the index.
• If it is not found, found_index holds the static constant std::string::npos. The if statement checks for this condition to determine the output.

#include <iostream>
#include <string>

int main() {
    std::string text = "The quick brown fox jumps over the quick dog.";
    std::string old_word = "quick";
    std::string new_word = "slow";
    
    std::cout << "Original: " << text << std::endl;

    // Find the first occurrence of the old word
    size_t pos = text.find(old_word);

    // Loop to replace ALL occurrences
    while (pos != std::string::npos) {
        // Replace the old word with the new word
        // Arguments: starting position, length of the text to replace, new text
        text.replace(pos, old_word.length(), new_word);
        
        // Find the next occurrence, starting immediately after the replacement
        pos = text.find(old_word, pos + new_word.length());
    }

    std::cout << "Modified: " << text << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

This solution uses a while loop to find and replace all occurrences.

• Inside the loop, text.find(old_word) locates the substring. The core operation is text.replace().
• After replacing, the next search (text.find(old_word, pos + new_word.length())) is started from the character immediately following the newly inserted replacement word.
• This prevents infinite loops in cases where the replacement word contains the old word.

#include <iostream>
#include <string>
#include <map> // Required for std::map
#include <cctype>

int main() {
    std::string str = "Programming in CPP";
    std::map<char, int> char_counts;

    std::cout << "Analyzing string: " << str << std::endl;

    // 1. Iterate through the string and populate the map
    for (char c : str) {
        if (std::isalpha(c)) {
            // Convert to lowercase and use as the map key
            char_counts[std::tolower(c)]++;
        }
    }

    // 2. Iterate through the map and print the results
    std::cout << "Character Frequencies:" << std::endl;
    for (const auto& pair : char_counts) {
        std::cout << "'" << pair.first << "': " << pair.second << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The std::map<char, int> container is used to store the frequency. The loop processes the input string character by character.
• If a character is a letter (std::isalpha), it’s converted to lowercase (std::tolower) to ensure case-insensitivity (e.g., ‘A’ and ‘a’ count together).
• When a character is used as an index into the map (e.g., char_counts['a']++), if the key doesn’t exist, the map automatically inserts it with a default value of 0 before incrementing, making the counting process very concise.

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>

// Helper to clean and prepare the string
std::string clean_and_sort(const std::string& str) {
    std::string result;
    for (char c : str) {
        if (std::isalpha(c)) {
            result += std::tolower(c);
        }
    }
    std::sort(result.begin(), result.end());
    return result;
}

bool are_anagrams(const std::string& str1, const std::string& str2) {
    return clean_and_sort(str1) == clean_and_sort(str2);
}

int main() {
    std::string s1 = "Astronomer";
    std::string s2 = "Moon starer";

    if (are_anagrams(s1, s2)) {
        std::cout << "\"" << s1 << "\" and \"" << s2 << "\" ARE anagrams." << std::endl;
    } else {
        std::cout << "\"" << s1 << "\" and \"" << s2 << "\" are NOT anagrams." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The core logic resides in the clean_and_sort helper function. This function iterates through a string, keeps only alphabetic characters, converts them to lowercase for case-insensitivity, and then uses std::sort (from <algorithm>) to arrange all characters alphabetically.
• Since anagrams are just rearrangements of the same characters, the two original strings are anagrams if and only if their sorted, cleaned versions are identical.

#include <iostream>
#include <string>
#include <cctype> // Required for isalpha and isdigit

void check_content(const std::string& str) {
    if (str.empty()) {
        std::cout << "String is empty." << std::endl;
        return;
    }

    bool all_letters = true;
    bool all_digits = true;

    for (char c : str) {
        if (!std::isalpha(c)) {
            all_letters = false;
        }
        if (!std::isdigit(c)) {
            all_digits = false;
        }
        // Optimization: if both are false, we can stop early
        if (!all_letters && !all_digits) {
            std::cout << str <<" "<<"Contains a mix of characters and/or symbols." << std::endl;
            return;
        }
    }

    if (all_letters) {
        std::cout << str <<" " <<"Contains only letters." << std::endl;
    } else if (all_digits) {
        std::cout << str <<" "<<"Contains only digits." << std::endl;
    } else {
        // This branch is rarely reached due to the optimization above
        std::cout << str <<"Contains a mix of characters and/or symbols." << std::endl;
    }
}

int main() {
    std::string s1 = "HelloWorld";
    std::string s2 = "12345";
    std::string s3 = "H3llo";
    check_content("HelloWorld"); 
    check_content("12345");      
    check_content("H3llo");      

    return 0;
}Code language: C++ (cpp)

Explanation:

• The loop uses std::isalpha(c) to check if a character is a letter and std::isdigit(c) to check if it’s a digit.
• For a string to be “all letters,” every character must satisfy std::isalpha().
• By initializing both flags to true and setting them to false whenever a character violates the condition, the function correctly determines the string’s composition upon loop completion.

#include <iostream>
#include <string>
#include <cctype> // For isalpha

int count_word_occurrences(const std::string& text, const std::string& target) {
    int count = 0;
    size_t pos = 0;

    // Loop until find() returns std::string::npos
    while ((pos = text.find(target, pos)) != std::string::npos) {
        bool boundary_start = true;
        bool boundary_end = true;

        // Check start boundary: must be at start of text OR preceded by a non-letter
        if (pos > 0) {
            if (std::isalpha(text[pos - 1])) {
                boundary_start = false;
            }
        }
        
        // Check end boundary: must be at end of text OR followed by a non-letter
        if (pos + target.length() < text.length()) {
            if (std::isalpha(text[pos + target.length()])) {
                boundary_end = false;
            }
        }

        if (boundary_start && boundary_end) {
            count++;
        }

        // Start the next search immediately after the current word match
        pos += target.length();
    }
    return count;
}

int main() {
    std::string sentence = "The cat sat on the mat. Cat, cat.";
    std::string word = "cat";
    
    int result = count_word_occurrences(sentence, word);
    std::cout << "The word '" << word << "' appears " << result << " times." << std::endl; // Output: 3

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise requires both string searching and boundary checking.
• The while loop repeatedly calls text.find(target, pos) to find the next possible match, starting the search from pos. Crucially, two boolean flags are used to check for whole word boundaries: the character before the match and the character after the match must not be a letter (std::isalpha()).
• If both boundary checks pass, the match is counted as a whole word, and pos is advanced past the current match to continue the search.

#include <iostream>
#include <string>
#include <algorithm> // Required for std::sort

int main() {
    std::string str = "PYnative";
    
    std::cout << "Original string: " << str << std::endl;

    // Use std::sort on the character range of the string
    // This sorts the characters in place based on their ASCII values
    std::sort(str.begin(), str.end());

    std::cout << "Sorted characters: " << str << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This is a direct application of the std::sort algorithm. By passing the begin() and end() iterators of the std::string to std::sort, the algorithm rearranges the underlying character sequence.
• The default sorting criterion is the lexicographical order based on the character’s ASCII value. Note that in ASCII, capital letters come before lowercase letters, and spaces and punctuation come before letters.

#include <iostream>
#include <string>

int main() {
    std::string s1 = "apple";
    std::string s2 = "apply";

    // Use the string compare() method
    // Returns 0 if equal, < 0 if s1 comes first, > 0 if s2 comes first
    int comparison_result = s1.compare(s2);

    std::cout << "Comparing \"" << s1 << "\" and \"" << s2 << "\"" << std::endl;

    if (comparison_result == 0) {
        std::cout << "The strings are lexicographically equal." << std::endl;
    } else if (comparison_result < 0) {
        std::cout << "\"" << s1 << "\" comes first (Result: " << comparison_result << ")." << std::endl;
    } else {
        std::cout << "\"" << s2 << "\" comes first (Result: " << comparison_result << ")." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The requirement is to avoid using direct operators (<, >). The standard library function for this purpose is std::string::compare(). This method returns an integer value:

• 0: The strings are identical.
• Negative: The calling string (s1) comes first lexicographically.
• Positive: The argument string (s2) comes first lexicographically. This method performs the exact character-by-character comparison required for lexicographical ordering.

#include <iostream>
#include <string>
#include <cctype>

std::string to_title_case(std::string str) {
    bool new_word = true; // Flag to track if the next character is the start of a new word

    for (size_t i = 0; i < str.length(); ++i) {
        if (std::isspace(str[i])) {
            new_word = true;
        } else if (new_word && std::isalpha(str[i])) {
            // First letter of a new word -> uppercase
            str[i] = std::toupper(str[i]);
            new_word = false; // Reset the flag
        } else {
            // Remaining letters -> lowercase
            str[i] = std::tolower(str[i]);
        }
    }
    return str;
}

int main() {
    std::string input = "thIS is a sampLe sEntence to convErt.";
    std::string title_cased = to_title_case(input);
    
    std::cout << "Original: " << input << std::endl;
    std::cout << "Title Case: " << title_cased << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

The solution uses the new_word boolean flag to manage the case logic.

• If a space is found, new_word is set to true, indicating the next non-space character is a word start.
• If the flag is true AND the current character is a letter, that character is capitalized using std::toupper(), and the flag is set to false.
• All subsequent letters until the next space are converted to lowercase using std::tolower(). This ensures the proper Title Case format.

#include <iostream>
#include <string>
#include <unordered_set> // Required for hash set

std::string remove_duplicates(const std::string& str) {
    std::unordered_set<char> seen_chars;
    std::string result = "";

    for (char c : str) {
        // Check if the character has been inserted into the set before
        if (seen_chars.find(c) == seen_chars.end()) {
            // Character is unique:
            // 1. Add it to the result string
            result += c;
            // 2. Insert it into the set to mark it as seen
            seen_chars.insert(c);
        }
    }
    return result;
}

int main() {
    std::string input = "programming in c++";
    std::string unique_chars = remove_duplicates(input);
    
    std::cout << "Original: " << input << std::endl;
    std::cout << "Unique: " << unique_chars << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The solution uses an std::unordered_set<char> for efficient tracking. The key is that checking the existence of an element in a hash set (seen_chars.find(c)) is an average O(1) operation.
• The loop maintains order by building the result string sequentially. If seen_chars.find(c) returns seen_chars.end(), the character is unique, so it is added to both the result and the seen_chars set.

#include <iostream>
#include <string>

bool is_rotation(const std::string& str1, const std::string& str2) {
    // 1. Check if lengths are equal and non-zero
    if (str1.length() != str2.length() || str1.empty()) {
        return false;
    }

    // 2. Concatenate str1 with itself
    std::string temp = str1 + str1;

    // 3. Check if str2 is a substring of temp
    // If str2 is found, it must be a rotation
    if (temp.find(str2) != std::string::npos) {
        return true;
    }

    return false;
}

int main() {
    std::string s1 = "waterbottle";
    std::string s2 = "erbottlewat"; // Rotation

    if (is_rotation(s1, s2)) {
        std::cout << "\"" << s2 << "\" IS a rotation of \"" << s1 << "\"." << std::endl;
    } else {
        std::cout << "\"" << s2 << "\" IS NOT a rotation." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This solution uses an trick. If “CDEAB” is a rotation of “ABCDE”, then if we double the original string (“ABCDEABCDE”), the rotation (“CDEAB”) will be found inside the doubled string as a contiguous substring.
• The function first verifies equal lengths and then uses str1 + str1 to create the doubled string. It then calls temp.find(str2) to check for the substring presence. If find() does not return std::string::npos, it is a rotation.

#include <iostream>
#include <string>
#include <vector>

std::string combine_ends(const std::vector<std::string>& list) {
    std::string result = "";
    int n = list.size();

    // Loop from the outside inwards
    for (int i = 0; i < (n + 1) / 2; ++i) {
        int opposite_i = n - 1 - i;

        // 1. Get first char of the current word
        if (!list[i].empty()) {
            result += list[i].front(); // Use front() for the first char
        }

        // 2. Get last char of the opposite word (only if it's a different word)
        if (i != opposite_i && !list[opposite_i].empty()) {
            result += list[opposite_i].back(); // Use back() for the last char
        }
    }
    return result;
}

int main() {
    std::vector<std::string> names = {"Alpha", "Beta", "Gamma", "Delta", "Epsilon"};
    
    std::string combined = combine_ends(names);

    std::cout << "Names: Alpha, Beta, Gamma, Delta, Epsilon" << std::endl;
    std::cout << "Combined String: " << combined << std::endl; 
    // Output: AaBnGlD

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise combines vector iteration and string character access.
• The key is the loop condition i < (n + 1) / 2, which ensures the loop stops correctly at the middle for both odd- and even-sized vectors.
• The index opposite_i = n - 1 - i efficiently calculates the index for the mirrored element. list[i].front() accesses the first character, and list[opposite_i].back() accesses the last character.
• The conditional check if (i != opposite_i) prevents double-counting the middle word’s characters in an odd-length vector.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

std::string longest_common_prefix(std::vector<std::string>& strs) {
    if (strs.empty()) return "";

    // Sort the vector
    std::sort(strs.begin(), strs.end());

    std::string first = strs.front();
    std::string last = strs.back();
    std::string prefix = "";

    // Compare the first and last strings
    for (size_t i = 0; i < first.length() && i < last.length(); ++i) {
        if (first[i] == last[i]) {
            prefix += first[i];
        } else {
            break;
        }
    }
    return prefix;
}

int main() {
    std::vector<std::string> words = {"flower", "flow", "flight"};
    std::string lcp = longest_common_prefix(words);

    std::cout << "Strings: flower, flow, flight" << std::endl;
    std::cout << "Longest Common Prefix: " << lcp << std::endl; // Output: fl

    return 0;
}Code language: C++ (cpp)

Explanation:

• The key optimization here is sorting. After sorting, the strings are arranged as: {"flight", "flow", "flower"}.
• The problem is simplified because the Longest Common Prefix (LCP) of all strings is guaranteed to be the LCP of the lexicographically smallest string ("flight") and the largest string ("flower").
• The code then iterates character by character, appending to the prefix as long as the characters match between the first and last strings.

#include <iostream>
#include <string>
#include <vector>

void print_all_substrings(const std::string& str) {
    std::cout << "Substrings of \"" << str << "\":" << std::endl;

    // Outer loop: Iterate over all possible starting indices (i)
    for (size_t i = 0; i < str.length(); ++i) {
        // Inner loop: Iterate over all possible lengths (j) from 1 up to (length - i)
        for (size_t j = 1; i + j <= str.length(); ++j) {
            // Use substr(starting position, length)
            std::string sub = str.substr(i, j);
            std::cout << sub << " ";
        }
    }
    std::cout << std::endl;
}

int main() {
    std::string s1 = "abc";
    print_all_substrings(s1); 
    // Output: a ab abc b bc c 

    return 0;
}Code language: C++ (cpp)

Explanation:

• The solution uses two nested for loops.
• The outer loop (i) defines where the substring starts. The inner loop (j) defines the length of the substring. The method str.substr(i, j) extracts the substring beginning at index i and having a length of j.
• This guarantees that every possible contiguous sequence of characters is generated exactly once. For a string of length N, this results in N×(N+1)/2 substrings.

#include <iostream>
#include <string>
#include <algorithm> // Required for std::swap

void find_permutations(std::string str, int l, int r) {
    // Base case: If the starting index (l) equals the end index (r), a full permutation is found
    if (l == r) {
        std::cout << str << std::endl;
    } else {
        // Recursive step
        for (int i = l; i <= r; i++) {
            // 1. Swap the current char (str[l]) with str[i]
            std::swap(str[l], str[i]);

            // 2. Recurse for the remaining part of the string
            find_permutations(str, l + 1, r);

            // 3. Backtrack (undo the swap) to restore the original order
            std::swap(str[l], str[i]);
        }
    }
}

int main() {
    std::string s = "ABC";
    std::cout << "Permutations of " << s << ":" << std::endl;
    find_permutations(s, 0, s.length() - 1);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The find_permutations function uses the indices l (left/start of the current segment) and r (right/end of the string). The base case is when l == r, meaning the entire string has been rearranged, and the permutation is printed.
• In the recursive step, the for loop iterates, swapping the character at the current start position (l) with every character from l to r.
• The recursive call then fixes the new character at position l and solves the subproblem for the rest of the string (l+1 to r).
• Backtracking (the second std::swap) is crucial; it resets the string state so that subsequent iterations of the for loop start from the correct configuration.

#include <iostream>
#include <string>
#include <algorithm>

std::string longest_palindrome(const std::string& s) {
    if (s.length() < 2) return s;

    int start_index = 0;
    int max_length = 1;

    // Helper function (lambda) to expand and find max length from a center
    auto expand_around_center = [&](int left, int right) {
        while (left >= 0 && right < s.length() && s[left] == s[right]) {
            left--;
            right++;
        }
        // Palindrome length is (right - 1) - (left + 1) + 1 = right - left - 1
        int current_length = right - left - 1; 

        if (current_length > max_length) {
            max_length = current_length;
            start_index = left + 1;
        }
    };

    // Iterate through every possible center
    for (int i = 0; i < s.length(); ++i) {
        // Case 1: Odd length (center is one character, e.g., "aba")
        expand_around_center(i, i); 
        // Case 2: Even length (center is between two characters, e.g., "abba")
        expand_around_center(i, i + 1);
    }

    return s.substr(start_index, max_length);
}

int main() {
    std::string s = "babadcabbac";
    std::cout << "String: " << s << std::endl;
    std::cout << "LPS: " << longest_palindrome(s) << std::endl; // Output: bab or abba

    return 0;
}Code language: C++ (cpp)

Explanation:

The solution uses the Expand Around Center dynamic programming technique. Every character and every space between characters can be the center of a palindrome.

• The main for loop iterates through all indices i. For each i, it calls the lambda function expand_around_center twice: once for odd-length palindromes (center i, i) and once for even-length palindromes (center i, i+1).
• The helper function expands outwards (left--, right++) as long as characters match, constantly updating the globally tracked max_length and start_index to record the longest palindrome found so far.