How to Check if a Vector Contains an Element in C++

#include <iostream>
#include <vector>

// Function to check if the vector contains the given element
bool contains(const std::vector<int>& vec, int element) {
    for (const int& value : vec) { // Iterate through each element in the vector
        if (value == element) {   // Check if the current element matches the target
            return true;          // Return true if a match is found
        }
    }
    return false;                 // Return false if no match is found
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5}; // Initialize a vector with integers

    // Check if vector contains 3
    if (contains(numbers, 3)) {
        std::cout << "Vector contains 3\n"; // Print message if 3 is found
    }

    // Check if vector contains 6
    if (!contains(numbers, 6)) {
        std::cout << "Vector does not contain 6\n"; // Print message if 6 is not found
    }

    return 0; // End of program
}

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5}; // Initialize a vector with integers

    // Using std::find to check for element 3
    auto it = std::find(numbers.begin(), numbers.end(), 3); // Search for the element '3'
    if (it != numbers.end()) { // Check if the element was found
        std::cout << "Found " << *it << " at position: "
                  << (it - numbers.begin()) << "\n"; // Print the element and its position
    }

    // Checking for a non-existent element
    it = std::find(numbers.begin(), numbers.end(), 6); // Search for the element '6'
    if (it == numbers.end()) { // Check if the element was not found
        std::cout << "Element 6 not found\n"; // Print message indicating element is not found
    }

    return 0; // End of program
}

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

// Define a struct to represent a person with a name and age
struct Person {
    std::string name;
    int age;
};

int main() {
    // Initialize a vector of Person objects
    std::vector<Person> people = {
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 35}
    };

    // Use std::find_if to find the first person older than 32
    auto it = std::find_if(people.begin(), people.end(),
        [](const Person& p) { return p.age > 32; }); // Lambda function checks age condition

    if (it != people.end()) { // Check if a matching person was found
        std::cout << "Found person: " << it->name
                  << " (age " << it->age << ")\n"; // Print the person's name and age
    }

    return 0; // End of program
}

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // Initialize a sorted vector
    // Vector must be sorted for binary_search!

    // Use std::binary_search to check if 5 is in the vector
    bool found = std::binary_search(numbers.begin(),
                                  numbers.end(), 5);

    // Print whether 5 is present or not
    std::cout << "Number 5 is "
              << (found ? "present" : "not present") << "\n";

    // Check for a non-existent number (11)
    found = std::binary_search(numbers.begin(),
                             numbers.end(), 11);

    // Print whether 11 is present or not
    std::cout << "Number 11 is "
              << (found ? "present" : "not present") << "\n";

    return 0; // End of program
}

#include <iostream>
#include <vector>
#include <ranges>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // Using ranges::find
    auto it = std::ranges::find(numbers, 3);
    if (it != numbers.end()) {
        std::cout << "Vector contains 3\n";
    }

    // Using ranges with complex conditions
    bool hasEvenNumber = std::ranges::any_of(numbers,
        [](int n) { return n % 2 == 0; });

    std::cout << "Vector "
              << (hasEvenNumber ? "contains" : "does not contain")
              << " even numbers\n";

    // Using ranges::find with views
    auto greaterThan4 = numbers | std::views::filter(
        [](int n) { return n > 4; });

    if (!std::ranges::empty(greaterThan4)) {
        std::cout << "Found numbers greater than 4\n";
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>
#include <ranges>
#include <numeric>

void testPerformance() {
    const size_t size = 1000000; // Vector size
    const int searchElement = size - 1; // Element to search

    std::vector<int> vec(size);
    std::iota(vec.begin(), vec.end(), 0); // Fill vector with sequential numbers

    // Measure Basic Loop
    auto start = std::chrono::high_resolution_clock::now();
    bool found = false;
    for (const int& val : vec) {
        if (val == searchElement) {
            found = true;
            break;
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto basicLoopTime = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Measure std::find
    start = std::chrono::high_resolution_clock::now();
    auto it = std::find(vec.begin(), vec.end(), searchElement);
    end = std::chrono::high_resolution_clock::now();
    auto findTime = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Measure std::binary_search
    start = std::chrono::high_resolution_clock::now();
    bool binaryFound = std::binary_search(vec.begin(), vec.end(), searchElement);
    end = std::chrono::high_resolution_clock::now();
    auto binarySearchTime = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Measure ranges::find
    start = std::chrono::high_resolution_clock::now();
    auto rangeIt = std::ranges::find(vec, searchElement);
    end = std::chrono::high_resolution_clock::now();
    auto rangeFindTime = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Output results
    std::cout << "Basic Loop: " << basicLoopTime << " µs\n";
    std::cout << "std::find: " << findTime << " µs\n";
    std::cout << "std::binary_search: " << binarySearchTime << " µs\n";
    std::cout << "ranges::find: " << rangeFindTime << " µs\n";
}

int main() {
    testPerformance();
    return 0;
}