#include <cstddef>
#include <iostream>
#include <cstring>
#include <ostream>
#include <cassert>

class String{
    // вывод из потока
    friend std::ostream& operator<<(std::ostream& os, const String& s) {
        os << s.str;
        return os;
    }
    // ввод в поток
    friend std::istream& operator>>(std::istream& is, const String& s) {
        is >> s.str;
        return is;
    }
private:
    char* str = nullptr; // указатель на массив
    size_t sz = 0; // размер
    size_t maxsz = 1; // максимально возможный размер str

    void growBuffer() {
        maxsz *= 2;
        char* newstr = new char[maxsz];
        memcpy(newstr, str, sz);

        delete[] str;
        str = newstr;
    }

    void cutBuffer() {
        maxsz /= 2;
        char* newstr = new char[maxsz];
        memcpy(newstr, str, sz);

        delete[] str;
        str = newstr;

    }

public:
    // Конструктор по умолчанию
    String() {}

    // Конструктор от C-style строки
    String(const char* s): str(new char[strlen(s)]), sz(strlen(s)), maxsz(strlen(s)) {
        memcpy(str, s, sz);
    }
    // Конструктор от двух параметров (size, char)
    String(const size_t n, const char c): str(new char[n]), sz(n), maxsz(n) {
        memset(str, c, n);
    }

    // Конструктор копирования
    String(const String &s): str(new char[s.sz]), sz(s.sz), maxsz(s.sz)  {
       memcpy(str, s.str, s.sz);
    }

    // Оператор присваивания
    String& operator=(const String& other) {
        String copy = other;
        sz = copy.sz;

        maxsz = other.maxsz;
        delete[] str;

        str = new char[maxsz];
        memcpy(str, copy.str, sz);

        return *this;
    }

    // Оператор ==, проверка строк на совпадение
    bool operator==(const String& s) {
        if (this->sz != s.sz) {
            return false;
        } else {
            for (size_t i = 0; i < this->sz; ++i) {
                if (this->str[i] != s.str[i]) {
                    return false;
                }
            }
            return true;
        }
    }

    // Квадратные скобки для конст. строк
    const char& operator[](const size_t pos) const {
        return str[pos];
    }
    // Квадратные скобки для неконст. строк
    char& operator[](const size_t pos) {
        return str[pos];
    }

    // length() - размер строки
    int length() const {
        return sz;
    }

    // push_back(char), pop_back() за O(1) амортизиованно
    void Push_back(const char c) {
        if (sz == maxsz) {
            growBuffer();
        }
        str[sz] = c;
        sz++;
    }

    void Pop_back() {
        if (sz <= (maxsz / 4)) {
            cutBuffer();
        }
        --sz;
    }
    // front(), back() - ссылка на начальный и на последний символы строки

    char& front() const {
        return str[0];
    }

    char& back() const {
        return str[sz - 1];
    }

    // += - добавить к строке символ или строку. Символ за O(1) учётно.
    String& operator+=(const String& s) {
        for (size_t i = 0; i < s.sz; ++i) {
            Push_back(s[i]);
        }
        return *this;
    }

    String& operator+=(const char c) {
        Push_back(c);
        return *this;
    }
    // + -  оператор складывания 1) строки с символом 2) символ и строка 3) строка и строка
    String& operator+(const String& s) {
        *this += s;
        return *this;
    }
    // find(substring), rfind(substring) - индекс вхождения строки с начала и с конца (length - в противном случае)

    size_t find(const String& subStr) const {
        int flag = 1;
        for (size_t i = 0; i < sz; ++i) {
            for (size_t j = 0; j < subStr.sz; ++j) {
                if (i + j >= sz) {
                    flag = 0;
                    break;
                }
                if (str[i + j] != subStr.str[j]) {
                    flag = 0;
                    break;
                }
            }
            if (flag == 1) {
                return i;
            }
            flag = 1;
        }
        return sz;
    }

    size_t rfind(const String& subStr) const {
        int flag = 1;
        for (size_t i = 0; i < sz; ++i) {
            for (size_t j = 0; j < subStr.sz; ++j) {
                if ((sz - 1 - i + j) >= sz) {
                    flag = 0;
                    break;
                }
                if (str[sz - 1 - i + j] != subStr.str[j]) {
                    flag = 0;
                    break;
                }
            }

            if (flag == 1) {
                return sz - 1 - i;
            }
            flag = 1;
        }
        return sz;
    }
    // substr(start, count) - вернуть подстроку длины count начиная со start
    String substr(size_t start, size_t count) const {
        String res(count, '\0');
        for (size_t i = start; i < start + count; ++i) {
            res.str[i] = str[i];
        }
        return res;
    }

    // empty() - проверка на пустоту
    bool empty() const {
        if (sz == 0) {
            return true;
        } else {
            return false;
        }
    }

    // clear() - очистка строки
    void clear() {
        delete[] str;
        sz = 0;
        maxsz = 1;
        str = nullptr;
    }
    // ~ Деструктор
    ~String() {
        delete[] str;
    }
};