#include <iostream>
#include <vector>

class Vector {
private:
    int* array_;
    size_t size_;
    size_t capacity_;

public:
    Vector() : size_(0), capacity_(0), array_(nullptr) {
    }

    explicit Vector(size_t size) : size_(size), capacity_(size) {
        array_ = new int[capacity_];
        for (size_t i = 0; i < size_; ++i) {
            array_[i] = 0;
        }
    }

    Vector(std::initializer_list<int> list) : size_(list.size()), capacity_(list.size()) {
        array_ = new int[capacity_];
        size_t i = 0;
        for (int it : list){
            array_[i] = it;
            ++i;
        }
    }

    Vector(const Vector& rhs): size_(rhs.size_), capacity_(rhs.capacity_) {
        array_ = new int[capacity_];
        for (size_t i = 0; i < size_; ++i) {
            array_[i] = rhs.array_[i];
        }
    }

    Vector(Vector&& rhs): size_(rhs.size_), capacity_(rhs.capacity_), array_(rhs.array_) {
        rhs.array_ = nullptr;
        rhs.size_ = 0;
        rhs.capacity_ = 0;
    }

    Vector& operator=(Vector rhs) {
        delete[] array_;
        size_ = rhs.size_;
        capacity_ = rhs.capacity_;
        array_ = rhs.array_;
        rhs.array_ = nullptr;
        rhs.size_ = 0;
        rhs.capacity_ = 0;
        return *this;
    }

    ~Vector() {
        delete[] array_;
    }

    size_t Capacity() const {
        return capacity_;
    }

    size_t Size() const {
        return size_;
    }

    int& operator[](size_t ind) {
        return array_[ind];
    }

    int operator[](size_t ind) const {
        return array_[ind];
    }

    void PopBack() {
        --size_;
    }

    void Clear() {
        size_ = 0;
    }

    void PushBack(int elem) {
        if (size_ < capacity_) {
            array_[size_] = elem;
            ++size_;
        } else {

            if (capacity_ == 0) {
                capacity_ = 1;
            } else {
                capacity_ *= 2;
            }
            int* new_arr = new int[capacity_];
            for (size_t i = 0; i < size_; ++i) {
                new_arr[i] = array_[i];
            }
            new_arr[size_] = elem;
            ++size_;
            delete[] array_;
            array_ = new_arr;
        }
    }

    void Reserve(size_t cap) {
        if (capacity_ >= cap) {
            return;
        }
        capacity_ = cap;
        int* new_arr = new int[capacity_];
        for (size_t i = 0; i < size_; ++i) {
            new_arr[i] = array_[i];
        }
        delete[] array_;
        array_ = new_arr;
    }

    void Swap(Vector& rhs) {
        std::swap(size_, rhs.size_);
        std::swap(capacity_, rhs.capacity_);
        std::swap(array_, rhs.array_);
    }

class Iterator: public std::iterator<std::random_access_iterator_tag, int> {
    private:
        int* ptr_;

    public:
        Iterator() {
            ptr_ = nullptr;
        }

        Iterator(int *ptr) {
            ptr_ = ptr;
        }

        Iterator& operator++() {
            ++ptr_;
            return *this;
        }

        Iterator operator++(int) {
            Iterator cpy(*this);
            ++ptr_;
            return cpy;
        }

        Iterator operator--(int) {
            Iterator cpy(*this);
            --ptr_;
            return cpy;
        }

        Iterator& operator--() {
            --ptr_;
            return *this;
        }

        int& operator*() {
            return *ptr_;
        }

        bool operator==(const Iterator& rhs) const {
            return ptr_ == rhs.ptr_;
        }

        bool operator!=(const Iterator& rhs) const {
            return ptr_ != rhs.ptr_;
        }

        Iterator& operator+=(int rhs) {
            ptr_ += rhs;
            return *this;
        }

        Iterator& operator-=(int rhs) {
            ptr_ -= rhs;
            return *this;
        }

        Iterator operator+(int rhs) {
            Iterator iter(ptr_ + rhs);
            return iter;
        }

        int operator-(const Iterator& rhs) const {
            return ptr_ - rhs.ptr_;
        }

        int*& operator->() {
            return ptr_;
        }
    };

    Iterator begin() { //NOLINT
        return Iterator(array_);
    }

    Iterator end() { //NOLINT
        return Iterator(array_ + size_);
    }

    Iterator Begin() {
        return Iterator(array_);
    }

    Iterator End() {
        return Iterator(array_ + size_);
    }

};