#include <iostream>
#include <vector>
#include <cassert>
using namespace std;

vector <int> vector_map_key;
vector <int> vector_map_value;

void destroy_vector_map() {
    vector_map_key.clear();
    vector_map_value.clear();
}

int get_element(int key) {
    for (int i = 0; i < vector_map_key.size(); i++) {
        if (vector_map_key[i] == key) {
            return vector_map_value[i];
        }
    }
    throw std::runtime_error("invalid key");
}

bool find_element(int key) {
    for (int i = 0; i < vector_map_key.size(); i++) {
        if (vector_map_key[i] == key) {
            return true;
        }
    }
    return false;
}

void add_element(int key, int value) {
    if (!find_element(key)) {
        vector_map_key.push_back(key);
        vector_map_value.push_back(value);
        return;
    }
    for (int i = 0; i < vector_map_key.size(); i++) {
        if (vector_map_key[i] == key) {
            vector_map_value[i] = value;
        }
    }
}

bool delete_element(int key) {
    for (int i = 0; i < vector_map_key.size(); i++) {
        if (vector_map_key[i] == key) {
            vector_map_key.erase(vector_map_key.begin() + i);
            vector_map_value.erase(vector_map_value.begin() + i);
            return true;
        }
    }
    return false;
}

//Тесты

void can_add_elements_to_vector_map_test() {
    destroy_vector_map();

    for (int i = 0; i < 2000; i += 5) {
        add_element(i, i + 2);
    }
    for (int i = 0; i < 2000; i += 5) {
        assert(get_element(i) == i + 2);
    }
}

void can_add_existed_elements_to_vector_map_test() {
    destroy_vector_map();

    for (int i = 0; i < 2000; i += 5) {
        add_element(i, i + 2);
    }
    for (int i = 0; i < 2000; i += 5) {
        assert(find_element(i) == true);
    }

    for (int i = 0; i < 2000; i += 5) {
        add_element(i, i + 10);
        int current_element = get_element(i);
        assert(current_element == i + 10);
    }
    for (int i = 0; i < 2000; i += 5) {
        assert(find_element(i) == true);
    }
}

void cannot_delete_not_existed_element_test() {
    destroy_vector_map();

    for (int i = 0; i < 1000; i++) {
        add_element(i, i + 2);
    }

    assert(delete_element(1000) == false);
    assert(delete_element(2000) == false);
    assert(delete_element(2500) == false);
    assert(delete_element(3000) == false);
}

void can_delete_existed_element_test() {
    destroy_vector_map();

    for (int i = 0; i < 10; i++) {
        add_element(i, i + 2);
    }

    assert(delete_element(2) == true);
    assert(delete_element(5) == true);
    assert(delete_element(6) == true);

    assert(find_element(2) == false);
    assert(find_element(5) == false);
    assert(find_element(0) == true);
    assert(find_element(4) == true);
}

void can_find_element_with_valid_key_test() {
    destroy_vector_map();

    for (int i = 0; i < 10; i++) {
        add_element(i, i + 2);
    }

    for (int i = 0; i < 10; i++) {
        assert(find_element(i) == true);
    }
}

void cannot_find_element_with_invalid_key_test() {
    destroy_vector_map();

    for (int i = 0; i < 10; i++) {
        add_element(i, i + 2);
    }

    for (int i = 10; i < 100; i++) {
        assert(find_element(i) == false);
    }
}

void can_get_element_with_valid_key_test() {
    destroy_vector_map();

    for (int i = 0; i < 1000; i++) {
        add_element(i, i + 2);
    }

    for (int i = 0; i < 1000; i++) {
        int current_element = get_element(i);
        assert(current_element == i + 2);
    }

    bool valid_key = true;

    try {
        get_element(10);
    }
    catch (...) {
        valid_key = false;
    }

    assert(valid_key == true);

    valid_key = true;

    try {
        get_element(10);
    }
    catch (...) {
        valid_key = false;
    }

    assert(valid_key == true);

}

void cannot_get_element_with_invalid_key_test() {
    destroy_vector_map();

    for (int i = 0; i < 100; i++) {
        add_element(i, i + 2);
    }

    bool invalid_key = false;

    try {
        get_element(-1);
    }
    catch (...) {
        invalid_key = true;
    }

    assert(invalid_key == true);

    invalid_key = false;

    try {
        get_element(1000);
    }
    catch (...) {
        invalid_key = true;
    }

    assert(invalid_key == true);
}

int main() {
    can_add_elements_to_vector_map_test();
    can_add_existed_elements_to_vector_map_test();
    cannot_delete_not_existed_element_test;
    can_delete_existed_element_test();
    can_find_element_with_valid_key_test();
    cannot_find_element_with_invalid_key_test();
    can_get_element_with_valid_key_test();
    cannot_get_element_with_invalid_key_test();

    system("PAUSE");
    return 0;
}