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

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

ru en cn

5453907

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

Росляков Владимир Олегович

Время

17:13<< 07.10.2021 17:14 (22 д. 07:47) 17:16>>

Обработка

17:14 ... 17:14 (12,63 сек.)

Файл

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

Турнир

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

Задача

C: Set

Набор тестов

Ограничения

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

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

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

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

set.h:5:  Do not use namespace using-directives.  Use using-declarations instead.  [build/namespaces] [5]
set.h:9:  Do not leave a blank line after "private:"  [whitespace/blank_line] [3]
set.h:10:  Use int16/int64/etc, rather than the C type long  [runtime/int] [4]
set.h:17:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:22:  Else clause should be indented at the same level as if. Ambiguous nested if/else chains require braces.  [readability/braces] [4]
set.h:24:  Else clause should never be on same line as else (use 2 lines)  [whitespace/newline] [4]
set.h:26:  Else clause should never be on same line as else (use 2 lines)  [whitespace/newline] [4]
set.h:29:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:36:  Else clause should never be on same line as else (use 2 lines)  [whitespace/newline] [4]
set.h:40:  Do not leave a blank line after "public:"  [whitespace/blank_line] [3]
set.h:41:  Use int16/int64/etc, rather than the C type long  [runtime/int] [4]
set.h:41:  Single-parameter constructors should be marked explicit.  [runtime/explicit] [5]
set.h:58:  Redundant blank line at the end of a code block should be deleted.  [whitespace/blank_line] [3]
set.h:72:  Redundant blank line at the start of a code block should be deleted.  [whitespace/blank_line] [2]
set.h:76:  Use int16/int64/etc, rather than the C type long  [runtime/int] [4]
set.h:88:  Use int16/int64/etc, rather than the C type long  [runtime/int] [4]
set.h:89:  Use int16/int64/etc, rather than the C type long  [runtime/int] [4]
set.h:90:  Use int16/int64/etc, rather than the C type long  [runtime/int] [4]
set.h:111:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:111:  Extra space before ( in function call  [whitespace/parens] [4]
set.h:111:  Use operator || instead of or  [readability/alt_tokens] [2]
set.h:115:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:119:  Redundant blank line at the end of a code block should be deleted.  [whitespace/blank_line] [3]
set.h:126:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:126:  Extra space before ( in function call  [whitespace/parens] [4]
set.h:126:  Use operator || instead of or  [readability/alt_tokens] [2]
set.h:130:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:138:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
set.h:138:  Extra space before ( in function call  [whitespace/parens] [4]
set.h:138:  Use operator || instead of or  [readability/alt_tokens] [2]
set.h:146:  Redundant blank line at the end of a code block should be deleted.  [whitespace/blank_line] [3]
Done processing set.h
Total errors found: 31

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

≡

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

using namespace std;

class Set {
 private:

vector<long long> 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(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)
      if (mid)return mid + 1;
      else return 0;
    if (digit > Digit_mid) return BinSearchPosition(v, digit, mid, right);
    else return BinSearchPosition(v, digit, left, mid);
  }

int64_t BinSearch_Remove(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:

Set(vector<long long> 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) {
    int64_t pos = BinSearchPosition(this->vec, digit, 0, vec.size());
    if (pos != -1) {
      this->vec.insert(vec.begin() + pos, digit);
    }

}

void Remove(int64_t digit) {
    int64_t pos = BinSearch_Remove(vec, digit, 0, vec.size());
    if (pos != -1) {
      for (int64_t i = pos; i < vec.size() - 1; i++) {
        this->vec[i] = vec[i + 1];
      }
      this->vec.pop_back();
    }
  }

bool Contains(int64_t digit) {

return BinSearchPosition(vec, digit, 0, vec.size()) == -1 ? true : false;
  }

vector<long long> Data() {
//    for (size_t i = 0; i < vec.size(); i++) {
//      cout << this->vec[i] << " ";
//    }
//    cout << "\n";
    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;
  }
    vector<long long> &operator=(vector<long long> other) {
    vector<long long> v;
    vector<long long> *p = &v;
    v.insert(this->vec.end(), other.begin(), other.end());
    return *p;
  }

Set Union(const Set &second) {
    Set tmp_s(this->vec);
    if (tmp_s.vec[0] > second.vec[second.vec.size() - 1]) {
      return MergeSet(second, tmp_s);
    } else if ((tmp_s.vec[tmp_s.vec.size() - 1] < second.vec[0])) {
      return MergeSet(tmp_s, second);
    } else {
      for (int64_t i = 0; i < second.vec.size(); i++) {
        tmp_s.Add(second.vec[i]);
      }
    }
    return tmp_s;
  }

Set Intersection(const Set &second) {
    Set TMP;
    if (this->vec[0] > second.vec[second.vec.size() - 1] or (this->vec[this->vec.size() - 1] < second.vec[0])) {
      return TMP;
    } else {
      for (int64_t i = 0; i < this->vec.size(); i++) {
        if (BinSearch_Remove(second.vec, this->vec[i], 0, second.vec.size()) != -1) {
          TMP.Add(this->vec[i]);
        }
      }

}
    return TMP;
  }

Set Difference(const Set &second) {
    Set TMP;
    if (this->vec[0] > second.vec[second.vec.size() - 1] or (this->vec[this->vec.size() - 1] < second.vec[0])) {
      return TMP;
    } else {
      for (int64_t i = 0; i < this->vec.size(); i++) {
        if (BinSearch_Remove(second.vec, this->vec[i], 0, second.vec.size()) == -1) {
          TMP.Add(this->vec[i]);
        }
      }
    }
    return TMP;
  }
  Set SymmetricDifference(const Set &second) {
    if (this->vec[0] > second.vec[second.vec.size() - 1] or (this->vec[this->vec.size() - 1] < second.vec[0])) {
      return MergeSet(*this, second);
    } else {
      vector<int64_t> tmp_vec(this->vec);
      tmp_vec.insert(tmp_vec.end(), second.vec.begin(), second.vec.end());
      return Set(tmp_vec);
    }
  }

};

(4 249 b)

0.064s 0.010s 10