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

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

ru en cn

5788359

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

Самойленко Павел Олегович

Время

16.11.2021 23:46 (27 д. 21:46) 23:47>>

Обработка

23:46 ... 23:46 (3,28 сек.)

Файл

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

Турнир

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

Задача

F: Code format visitor

Набор тестов

Ограничения

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

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

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

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

format_visitor.h:19:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:20:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:37:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:42:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:44:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:53:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:54:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:59:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:59:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:62:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:62:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:71:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:71:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:74:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:76:  Missing space before ( in if(  [whitespace/parens] [5]
format_visitor.h:81:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:83:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:92:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:93:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:98:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:98:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:101:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:101:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:110:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:110:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:113:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:115:  Missing space before ( in if(  [whitespace/parens] [5]
format_visitor.h:120:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:122:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:128:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:130:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:134:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:135:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:140:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:140:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:143:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:143:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:152:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
format_visitor.h:152:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
format_visitor.h:156:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:172:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:223:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
format_visitor.h:237:  "private:" should be preceded by a blank line  [whitespace/blank_line] [3]
format_visitor.h:240:  Could not find a newline character at the end of the file.  [whitespace/ending_newline] [5]
Done processing format_visitor.h
Total errors found: 44

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

≡

#pragma once

#include <vector>
#include <string>

class FormatVisitor : public BaseVisitor {
 public:
    void Visit(const BaseNode* node) override {
        node->Visit(this);
    }

void Visit(const ClassDeclarationNode* node) override {
        if (!formatted_code.size()) {
            formatted_code.push_back("class " + node->ClassName() + " {");
        } else {
            std::string spaces;
            bool flag = true;
            std::string word;
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            for (const auto& letter : formatted_code[formatted_code.size() - 2]) {
                if (letter != ' ') {
                    flag = false;
                    word += letter;
                } else if (flag) {
                    spaces+=' ';
                } else {
                    break;
                }
            }
            if (word == "private:" ||
                word == "public:" ||
                word == "protected:") {
                formatted_code.back() += spaces + "  ";
            } else {
                formatted_code.back() += spaces;
            }
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            formatted_code.back() += "class " + node->ClassName() + " {";
        }
        if (node->PublicFields().size()) {
            formatted_code.push_back("public:");
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            formatted_code.back() += findWord() + "  ";
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            for (const auto& fields : node->PublicFields()) {
                formatted_code.push_back("");
                Visit(fields);
                if (formatted_code.back().back() != ';')
                    formatted_code.back() += ";";
                std::string spaces;
                bool flag = true;
                std::string word;
                std::reverse(formatted_code.back().begin(), formatted_code.back().end());
                for (const auto& letter : formatted_code[formatted_code.size() - 2]) {
                    if (letter != ' ') {
                        flag = false;
                        word += letter;
                    }
                    else if (flag) {
                        spaces += ' ';
                    }
                    else {
                        break;
                    }
                }
                if (word == "private:" ||
                    word == "public:" ||
                    word == "protected:") {
                    formatted_code.back() += spaces + "  ";
                }
                else {
                    formatted_code.back() += spaces;
                }
                std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            }
            if(node->ProtectedFields().size() || node->PrivateFields().size())
                formatted_code.push_back("");
        }
        if (node->ProtectedFields().size()) {
            formatted_code.push_back("protected:");
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            formatted_code.back() += findWord() + "  ";
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            for (const auto& fields : node->ProtectedFields()) {
                formatted_code.push_back("");
                Visit(fields);
                if (formatted_code.back().back() != ';')
                    formatted_code.back() += ";";
                std::string spaces;
                bool flag = true;
                std::string word;
                std::reverse(formatted_code.back().begin(), formatted_code.back().end());
                for (const auto& letter : formatted_code[formatted_code.size() - 2]) {
                    if (letter != ' ') {
                        flag = false;
                        word += letter;
                    }
                    else if (flag) {
                        spaces += ' ';
                    }
                    else {
                        break;
                    }
                }
                if (word == "private:" ||
                    word == "public:" ||
                    word == "protected:") {
                    formatted_code.back() += spaces + "  ";
                }
                else {
                    formatted_code.back() += spaces;
                }
                std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            }
            if(node->PrivateFields().size())
                formatted_code.push_back("");
        }
        if (node->PrivateFields().size()) {
            formatted_code.push_back("private:");
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            formatted_code.back() += findWord() + "  ";
            std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            for (const auto& fields : node->PrivateFields()) {
                formatted_code.push_back("");
                Visit(fields);
                if (formatted_code.back().back() != ';')
                    formatted_code.back() += ";";
                std::reverse(formatted_code.back().begin(), formatted_code.back().end());
                if (formatted_code.back()[1] != '}') {
                    std::reverse(formatted_code.back().begin(), formatted_code.back().end());
                    std::string spaces;
                    bool flag = true;
                    std::string word;
                    std::reverse(formatted_code.back().begin(), formatted_code.back().end());
                    for (const auto& letter : formatted_code[formatted_code.size() - 2]) {
                        if (letter != ' ') {
                            flag = false;
                            word += letter;
                        }
                        else if (flag) {
                            spaces += ' ';
                        }
                        else {
                            break;
                        }
                    }
                    if (word == "private:" ||
                        word == "public:" ||
                        word == "protected") {
                        formatted_code.back() += spaces + "  ";
                    }
                    else {
                        formatted_code.back() += spaces;
                    }
                }
                std::reverse(formatted_code.back().begin(), formatted_code.back().end());
            }
        }
        formatted_code.push_back("");
        formatted_code.back() += (findWordAnother());
        formatted_code.back() += "};";
        counter++;
    }
    void Visit(const VarDeclarationNode* node) override {
        formatted_code.back() += node->TypeName() + " " + node->VarName();
    }
    void Visit(const MethodDeclarationNode* node) override {
        formatted_code.back() += node->ReturnTypeName()
            + " "
            + node->MethodName()
            + "(";
        for (std::uint32_t i = 0; i < node->Arguments().size()-1 && node->Arguments().size(); ++i) {
            Visit(node->Arguments()[i]);
            formatted_code.back() += ", ";
        }
        if (node->Arguments().size()) {
            Visit(node->Arguments().back());
        }
        formatted_code.back() += ")";
    }

std::string findWord() {
        std::string word;
        std::reverse(formatted_code.begin(), formatted_code.end());
        for (const auto& word_ : formatted_code) {
            std::string true_word, word = "";
            std::uint16_t j = 0;
            while (word_[j] == ' ') {
                j++;
                word += " ";
            }
            if (word_.size() > j + 5) {
                for (std::uint32_t i = j; i < j + 5; ++i) {
                    true_word += word_[i];
                }
                if (true_word == "class") {
                    std::reverse(formatted_code.begin(), formatted_code.end());
                    return word;
                }
            }
        }
        std::reverse(formatted_code.begin(), formatted_code.end());
        return word + "  ";
    }

std::string findWordAnother() {
        std::string word;
        std::uint32_t counter_copy = 0;
        std::reverse(formatted_code.begin(), formatted_code.end());
        for (const auto& word_ : formatted_code) {
            std::string true_word, word = "";
            std::uint16_t j = 0;
            while (word_[j] == ' ') {
                j++;
                word += " ";
            }
            if (word_.size() > j + 5) {
                for (std::uint32_t i = j; i < j + 5; ++i) {
                    true_word += word_[i];
                }
                if (true_word == "class") {
                    if (counter_copy == counter) {
                        std::reverse(formatted_code.begin(), formatted_code.end());
                        return word;
                    }
                    counter_copy++;
                }
            }
        }
        std::reverse(formatted_code.begin(), formatted_code.end());
        return word;
    }

const std::vector<std::string>& GetFormattedCode() const {
        return formatted_code;
    }
 private:
     std::vector<std::string> formatted_code;
     std::uint32_t counter = 0;
};

(9 730 b)

0.092s 0.009s 10