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

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

ru en cn

5408384

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

Новожилов Илья Сергеевич

Время

18:49<< 25.09.2021 18:49 (10 д. 09:23) 18:56>>

Обработка

18:49 ... 18:49 (6,92 сек.)

Файл

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

Турнир

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

Задача

C: Set

Набор тестов

Ограничения

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

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

CE	Ошибка компиляции

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

In file included from main.cpp:16:0:
set.h: In member function 'void Set::Add(int64_t)':
set.h:17:27: error: comparison between signed and unsigned integer expressions [-Werror=sign-compare]
         for (int i = 0; i < this->v.size(); i++)
                         ~~^~~~~~~~~~~~~~~~
set.h: In member function 'void Set::Remove(int64_t)':
set.h:26:27: error: comparison between signed and unsigned integer expressions [-Werror=sign-compare]
         for (int i = 0; i < this->v.size(); i++)
                         ~~^~~~~~~~~~~~~~~~
set.h: In member function 'bool Set::Contains(int64_t) const':
set.h:34:27: error: comparison between signed and unsigned integer expressions [-Werror=sign-compare]
         for (int i = 0; i < this->v.size(); i++)
                         ~~^~~~~~~~~~~~~~~~
main.cpp: In function 'int main()':
main.cpp:37:29: error: no matching function for call to 'Set::Set()'
         Set s1(v1), s2(v2), s3;
                             ^~
In file included from main.cpp:16:0:
set.h:7:14: note: candidate: Set::Set(const std::vector<long int>&)
     explicit Set(const std::vector<int64_t>& v) {
              ^~~
set.h:7:14: note:   candidate expects 1 argument, 0 provided
set.h:3:7: note: candidate: Set::Set(const Set&)
 class Set {
       ^~~
set.h:3:7: note:   candidate expects 1 argument, 0 provided
set.h:3:7: note: candidate: Set::Set(Set&&)
set.h:3:7: note:   candidate expects 1 argument, 0 provided
cc1plus: all warnings being treated as errors

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

≡

#include <iostream>
#include <vector>
class Set {
 public:
    std::vector<int64_t> v;

explicit Set(const std::vector<int64_t>& v) {
        this->v = v;
    }

std::vector<int64_t> Data() const {
        return this->v;
    }

void Add(int64_t number) {
        bool is_new = true;
        for (int i = 0; i < this->v.size(); i++)
            if (number == this->v[i]) {
                is_new = false;
                break;
            }
        if (is_new) this->v.push_back(number);
    }

void Remove(int64_t number) {
        for (int i = 0; i < this->v.size(); i++)
            if (this->v[i] == number) {
                this->v.erase(this->v.begin() + i);
                break;
            }
    }

bool Contains(int64_t number) const {
        for (int i = 0; i < this->v.size(); i++)
            if (this->v[i] == number) return true;
        return false;
    }

Set Union(const Set& other) const {
        auto this_set = Data();
        auto other_set = other.Data();
        int size_other = other_set.size();
        int this_size = this_set.size();
        std::vector<int64_t> new_v;
        bool is_new = true;
        for (int i = 0; i < this_size; i++)
            new_v.push_back(this_set[i]);
        for (int i = 0; i < size_other; i++) {
            is_new = true;
            for (int j = 0; j < this_size; j++) {
                if (other_set[i] == this_set[j]) {
                    is_new = false;
                    break;
                }
            }
            if (is_new == true) new_v.push_back(other_set[i]);
        }
        return Set(new_v);
    }

Set Intersection(const Set& other) const {
        auto this_set = Data();
        auto other_set = other.Data();
        int size_other = other_set.size();
        int this_size = this_set.size();
        std::vector<int64_t> new_v;
        for (int i = 0; i < this_size; i++) {
            for (int j = 0; j < size_other; j++) {
                if (other_set[j] == this_set[i]) {
                    new_v.push_back(this_set[i]);
                    break;
                }
            }
        }
        return Set(new_v);
    }

Set Difference(const Set& other) const {
        auto this_set = Data() > other.Data() ? Data() : other.Data();
        auto other_set = Data() < other.Data() ? Data() : other.Data();
        int size_other = other_set.size();
        int this_size = this_set.size();
        bool is_different = true;
        std::vector<int64_t> new_v;
        for (int i = 0; i < this_size; i++) {
            is_different = true;
            for (int j = 0; j < size_other; j++) {
                if (other_set[j] == this_set[i]) {
                    is_different = false;
                    break;
                }
            }
            if (is_different)
                new_v.push_back(this_set[i]);
        }

return Set(new_v);
    }

Set SymmetricDifference(const Set& other) const {
        auto this_set = Data();
        auto other_set = other.Data();
        int size_other = other_set.size();
        int this_size = this_set.size();
        std::vector<int64_t> new_v;
        for (int i = 0; i < this_size; i++) {
            if (!other.Contains(this_set[i])) new_v.push_back(this_set[i]);
        }
        for (int i = 0; i < size_other; i++) {
            if (!Contains(other_set[i])) new_v.push_back(other_set[i]);
        }
        return Set(new_v);
    }
};

(3 562 b)

0.086s 0.010s 10