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

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

ru en cn

5482132

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

Цикора Яна Константиновна

Время

13.10.2021 22:45 (28 д. 13:19) 22:48>>

Обработка

22:45 ... 22:46 (5,50 сек.)

Файл

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

Турнир

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

Задача

C: Set

Набор тестов

Ограничения

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

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

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

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

set.h:9:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:16:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:25:  Did you mean "else if"? If not, start a new line for "if".  [readability/braces] [4]
set.h:44:  Did you mean "else if"? If not, start a new line for "if".  [readability/braces] [4]
set.h:61:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:64:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:75:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:78:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:87:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:95:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:99:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:105:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:112:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:127:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:132:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:145:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:149:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:162:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
set.h:165:  Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]
Done processing set.h
Total errors found: 19

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

≡

#include <iostream>
#include <vector>
#include <algorithm>

class Set {
 private:
  std::vector<int64_t> vec;
  
  Set MergeSet(Set const second, Set const first) {
    Set tmp;
    tmp.vec.insert(tmp.vec.end(), second.vec.begin(), second.vec.end());
    tmp.vec.insert(tmp.vec.end(), first.vec.begin(), first.vec.end());
    return tmp;
  }
  
  int64_t BinSearchPosition(std::vector<int64_t> v,
                            int64_t digit, int64_t left,
                            int64_t right
  ) {
    int64_t mid = (left + right) / 2;
    int64_t Digit_mid = v[mid];
    if (digit == Digit_mid) {
      return -1;
    } if (left + 1 == right)
      return mid ? mid + 1 : 0;
    if (digit > Digit_mid) {
      return BinSearchPosition(v, digit, mid, right);
    } else {
      return BinSearchPosition(v, digit, left, mid);
    }
  }

int64_t BinSearch_Remove(std::vector<int64_t> v,
                           int64_t digit,
                           int64_t left,
                           int64_t right) {
    int64_t mid = (left + right) / 2;
    int64_t Digit_mid = v[mid];
    if (digit == Digit_mid)
      return mid;
    if (left + 1 == right) {
      return -1;
    } if (digit > Digit_mid) {
      return BinSearch_Remove(v, digit, mid, right);
    } else {
      return BinSearch_Remove(v, digit, left, mid);
    }
  }

public:
  explicit Set(std::vector<int64_t> v) {
    sort(v.begin(), v.end());
    this->vec.push_back(v[0]);
    for (size_t i = 1; i < v.size(); i++) {
      if (v[i] != this->vec[this->vec.size() - 1]) {
        this->vec.push_back(v[i]);
      }
    }
  }
  
  Set() {
  }
  
  void Add(int64_t digit) {
    if (this->vec.size() != 0) {
      int64_t pos = BinSearchPosition(this->vec, digit, 0, this->vec.size());
      if (pos != -1) {
        this->vec.insert(vec.begin() + pos, digit);
      }
    } else {
      this->vec.push_back(digit);
    }
  }
  
  void Remove(int64_t digit) {
    int64_t pos = BinSearch_Remove(vec, digit, 0, vec.size());
    
    if (pos != -1) {
      int64_t s = vec.size() - 1;
      for (int64_t i = pos; i < s; i++) {
        this->vec[i] = vec[i + 1];
      }
      this->vec.pop_back();
    }
  }
  
  bool Contains(int64_t digit) {
    if (BinSearchPosition(vec, digit, 0, vec.size()) == -1) {
      return true;
    } else {
      return false;
    }
  }
  
  std::vector<int64_t> Data() {
    return this->vec;
  }
  
  Set &operator=(const Set &other) {
    this->vec.clear();
    this->vec.insert(this->vec.end(), other.vec.begin(), other.vec.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->vec.end(), other.begin(), other.end());
    return *p;
  }
  
  Set Union(const Set &second) {
    Set tmp_s(this->vec);
    int64_t s_tmp = tmp_s.vec.size() - 1;
    int64_t s_s = second.vec.size() - 1;
    if (tmp_s.vec[0] > second.vec[s_s]) {
      return MergeSet(second, tmp_s);
    } else if ((tmp_s.vec[s_tmp] < second.vec[0])) {
      return MergeSet(tmp_s, second);
    } else {
      for (int64_t i = 0; i < s_s + 1; i++) {
        tmp_s.Add(second.vec[i]);
      }
    } return tmp_s;
  }
  
  Set Intersection(const Set &second) {
    Set TMP;
    int64_t s_s = second.vec.size() - 1;
    int64_t s = this->vec.size();
    
    if (this->vec[0] > second.vec[s_s] ||
        (this->vec[s - 1] < second.vec[0])) {
      return TMP;
    } else {
      for (auto x : this->vec) {
        if (std::find(second.vec.begin(),
                      second.vec.end(), x) != second.vec.end()) {
          TMP.Add(x);
        }
      } return TMP;
    }
  }
  
  Set Difference(const Set &second) {
    Set TMP;
    int64_t s_s = second.vec.size() - 1;
    
    if (this->vec[0] > second.vec[s_s] ||
        (this->vec[this->vec.size() - 1] < second.vec[0])) {
      return *this;
    } else {
      for (int64_t i : this->vec) {
        if (BinSearch_Remove(second.vec, i,
                             0, second.vec.size()) == -1) {
          TMP.Add(i);
        }
      }
    } return TMP;
  }
  
  Set SymmetricDifference(const Set &second) {
    Set Tmp;
    
    for (auto x : this->vec) {
      if (std::find(second.vec.begin(),
                    second.vec.end(), x) == second.vec.end()) {
        Tmp.Add(x);
      }
    }
    for (auto x : second.vec) {
      if (std::find(this->vec.begin(),
                    this->vec.end(), x) == this->vec.end()) {
        Tmp.Add(x);
      }
    } return Tmp;
  }
};

(4 536 b)

0.050s 0.009s 10