vector.h

Go to the documentation of this file.

 
#ifndef VECTOR_H
#define VECTOR_H
 
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <sstream>
 
template <typename T>
class Vector : public std::vector<T> {
public:
    using std::vector<T>::vector;
 
    [[nodiscard]] auto argmin() const {
        return std::distance(std::cbegin(*this),
            std::min_element(std::cbegin(*this), std::cend(*this)));
    }
 
    [[nodiscard]] auto argmax() const {
        return std::distance(std::cbegin(*this),
            std::max_element(std::cbegin(*this), std::cend(*this)));
    }
 
    void sort() {
        std::sort(std::begin(*this), std::end(*this));
    }
 
    [[nodiscard]] T min() const
    {
        return *std::min_element(std::cbegin(*this), std::cend(*this));
    }
 
    [[nodiscard]] T max() const
    {
        return *std::max_element(std::cbegin(*this), std::cend(*this));
    }
 
    [[nodiscard]] T sum() const
    {
        return std::accumulate(std::cbegin(*this), std::cend(*this), T{});
    }
 
    [[nodiscard]] int index(const T& element) const
    {
        auto it = std::find(std::cbegin(*this), std::cend(*this), element);
        return it != std::cend(*this) ? std::distance(std::cbegin(*this), it) : -1;
    }
 
    [[nodiscard]] bool exist(const T& element) const
    {
        return std::find(std::cbegin(*this), std::cend(*this), element) != std::cend(*this);
    }
 
    [[nodiscard]] bool hasCommonElement(const Vector<T>& other) const {
        for (const auto& elem : other) {
            if (std::find(this->begin(), this->end(), elem) != this->end()) {
                return true;
            }
        }
        return false;
    }
 
 
    bool isSubsetOf(const Vector<T>& other) const {
        for (const auto& elem : *this) {
            if (std::find(other.begin(), other.end(), elem) == other.end()) {
                return false;
            }
        }
        return true;
    }
 
    void insertToEnd(const std::vector<T>& other_vector) {
        if (other_vector.empty()) {
            return;
        }
        this->reserve(this->size() + other_vector.size());
        this->insert(this->end(), other_vector.begin(), other_vector.end());
    }
 
    bool removeValue(const T& value) {
        auto iter = std::find(this->begin(), this->end(), value);
        if (iter != this->end()) {
            this->erase(iter);
            return true;
        }
        return false;
    }
 
    std::string toString() const {
        std::stringstream ss = std::stringstream("");
        bool first = true;
        ss << "[ ";
        for (const auto& elem : *this) {
            if (!first) {
                ss << ", ";
            }
            ss << elem;
            first = false;
        }
        ss << "]";
        return ss.str();
    }
 
    std::string toNotFormattedString() const {
        std::stringstream ss = std::stringstream("");
        bool first = true;
        for (const auto& elem : *this) {
            if (!first) {
                ss << ",";
            }
            ss << elem;
            first = false;
        }
        return ss.str();
    }
};
 
#endif  // VECTOR_H