2 курс. Программирование на C++. Турнир 1, осень 2021

вход курсы / турниры задачи участники консоль модули компиляторы ключевые слова результаты

ru en cn

5815972

Пользователь

Абакаев Дени Исмаилович

Время

25.11.2021 23:03 (5 д. 04:59) 23:04>>

Обработка

23:03 ... 23:03 (9,16 сек.)

Файл

5815972.cpp (CLang++ 5.0.0 + Address Sanitizer)

Турнир

2 курс. Программирование на C++. Турнир 1, осень 2021

Задача

C: Set

Набор тестов

Ограничения

Время: 1с Память: 512Мб

Состояние [?]

LI	Ошибка проверки исходного кода

код | результаты

set.h:6:  private: should be indented +1 space inside class Set  [whitespace/indent] [3]
set.h:11:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:12:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:50:  Missing space before {  [whitespace/braces] [5]
set.h:59:  public: should be indented +1 space inside class Set  [whitespace/indent] [3]
set.h:66:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:96:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:172:  Could not find a newline character at the end of the file.  [whitespace/ending_newline] [5]
Done processing set.h
Total errors found: 8

[печатать | | ]

≡

#include <iostream>
#include <vector>
#include <algorithm>
class Set {
private:
    std::vector<int64_t> vector;
    static Set mergeSet(Set const first, Set const second) {
        std::vector<int64_t> vector = {};
        Set new_set(vector);
        new_set.vector.insert(new_set.vector.end(), first.vector.begin(), first.vector.end());
        new_set.vector.insert(new_set.vector.end(), first.vector.begin(), first.vector.end());
        return new_set;
    }
    int64_t position(std::vector<int64_t> array,
                     int64_t number, int64_t left,
                     int64_t right
    ) {
        int64_t mid = (left + right) / 2;
        int64_t midNumber = array[mid];
        if (number == midNumber) {
            return -1;
        }
        if (left + 1 == right)
            return mid ? mid + 1 : 0;
        if (number > midNumber) {
            return position(array, number, mid, right);
        } else {
            return position(array, number, left, mid);
        }
    }

int64_t searchRemove(std::vector<int64_t> array,
                         int64_t number,
                         int64_t left,
                         int64_t right) {
        int64_t mid = (left + right) / 2;
        int64_t numberMid = array[mid];
        if (number == numberMid)
            return mid;
        if (left + 1 == right) {
            return -1;
        }
        if (number > numberMid) {
            return searchRemove(array, number, mid, right);
        } else {
            return searchRemove(array, number, left, mid);
        }
    }
    static void deleteDuplicate(Set *set, std::vector<int64_t> array){
        set->vector.push_back(array[0]);
        for (size_t i = 1; i < array.size(); i++) {
            if (array[i] != set->vector[set->vector.size() - 1]) {
                set->vector.push_back(array[i]);
            }
        }
    }

public:
    explicit Set(std::vector<int64_t> array) {
        sort(array.begin(), array.end());
        deleteDuplicate(this, array);
    }
    void Add(int64_t number) {
        if (!this->vector.empty()) {
            int64_t pos = position(this->vector, number, 0, this->vector.size());
            if (pos != -1) {
                this->vector.insert(vector.begin() + pos, number);
            }
        } else {
            this->vector.push_back(number);
        }
    }
    void Remove(int64_t number) {
        int64_t pos = searchRemove(vector, number, 0, vector.size());
        if (pos != -1) {
            int64_t s = vector.size() - 1;
            for (int64_t i = pos; i < s; i++) {
                this->vector[i] = vector[i + 1];
            }
            this->vector.pop_back();
        }
    }
    bool Contains(int64_t number) {
        if (position(vector, number, 0, vector.size()) == -1) {
            return true;
        } else {
            return false;
        }
    }
    std::vector<int64_t> Data() {
        return this->vector;
    }
    Set &operator=(const Set &other) {
        this->vector.clear();
        this->vector.insert(this->vector.end(), other.vector.begin(), other.vector.end());
        return *this;
    }
    std::vector<int64_t> &operator=(const std::vector<int64_t> &other) {
        std::vector<int64_t> v;
        std::vector<int64_t> *p = &v;
        v.insert(this->vector.end(), other.begin(), other.end());
        return *p;
    }
    Set Union(const Set &second) {
        Set tmp_s(this->vector);
        int64_t s_tmp = tmp_s.vector.size() - 1;
        int64_t s_s = second.vector.size() - 1;
        if (tmp_s.vector[0] > second.vector[s_s]) {
            return mergeSet(second, tmp_s);
        } else if ((tmp_s.vector[s_tmp] < second.vector[0])) {
            return mergeSet(tmp_s, second);
        } else {
            for (int64_t i = 0; i < s_s + 1; i++) {
                tmp_s.Add(second.vector[i]);
            }
        }
        return tmp_s;
    }
    Set Intersection(const Set &second) {
        std::vector<int64_t> vector = {};
        Set new_set(vector);
        int64_t s_s = second.vector.size() - 1;
        int64_t s = this->vector.size();
        if (this->vector[0] > second.vector[s_s] ||
            (this->vector[s - 1] < second.vector[0])) {
            return new_set;
        } else {
            for (auto x : this->vector) {
                if (std::find(second.vector.begin(),
                              second.vector.end(), x) != second.vector.end()) {
                    new_set.Add(x);
                }
            }
            return new_set;
        }
    }
    Set Difference(const Set &second) {
        std::vector<int64_t> vector = {};
        Set new_set(vector);
        int64_t s_s = second.vector.size() - 1;
        if (this->vector[0] > second.vector[s_s] ||
            (this->vector[this->vector.size() - 1] < second.vector[0])) {
            return *this;
        } else {
            for (int64_t i : this->vector) {
                if (searchRemove(second.vector, i,
                                 0, second.vector.size()) == -1) {
                    new_set.Add(i);
                }
            }
        }
        return new_set;
    }
    Set SymmetricDifference(const Set &second) {
        std::vector<int64_t> vector = {};
        Set new_set(vector);
        for (auto x : this->vector) {
            if (std::find(second.vector.begin(),
                          second.vector.end(), x) == second.vector.end()) {
                new_set.Add(x);
            }
        }
        for (auto x : second.vector) {
            if (std::find(this->vector.begin(),
                          this->vector.end(), x) == this->vector.end()) {
                new_set.Add(x);
            }
        }
        return new_set;
    }
};

(5 907 b)

0.274s 0.009s 10