5

#include <iostream>

using namespace std;

struct Node {
    char val;
    Node* next;

    Node(char _val) : val(_val ), next(nullptr) {}
};

struct list {
    Node* first;
    Node* last;

    list() : first(nullptr), last(nullptr) {}

    bool is_empty() {
        return first == nullptr;
    }

    void push_back(char _val) {
        Node* p = new Node(_val);
        if (is_empty()) {
            first = p;
            last = p;
            return;
        }
        last->next = p;
        last = p;
    }

    void push_begin(char _val)
    {
        Node* p = new Node(_val);
        if (is_empty()) {
            first = p;
            last = p;
            return;
        }
        p->val = _val;
        p->next = first;
        first = p;
    }

    void print() {
        if (is_empty()) return;
        Node* p = first;
        while (p) {
            cout << p->val << " ";
            p = p->next;
        }
        cout << endl;
    }

    Node* find(char _val) {
        Node* p = first;
        while (p && p->val != _val) p = p->next;
        return (p && p->val == _val) ? p : nullptr;
    }

    void remove_first() {
        if (is_empty()) return;
        Node* p = first;
        first = p->next;
        delete p;
    }

    void remove_last() {
        if (is_empty()) return;
        if (first == last) {
            remove_first();
            return;
        }
        Node* p = first;
        while (p->next != last) p = p->next;
        p->next = nullptr;
        delete last;
        last = p;
    }

    void remove(char _val) {
        if (is_empty()) return;
        if (first->val == _val) {
            remove_first();
            return;
        }
        else if (last->val == _val) {
            remove_last();
            return;
        }
        Node* slow = first;
        Node* fast = first->next;
        while (fast && fast->val != _val) {
            fast = fast->next;
            slow = slow->next;
        }
        if (!fast) {
            cout << "Элемент не найден" << endl;
            return;
        }
        slow->next = fast->next;
        delete fast;
    }

    void longestSequence() {
        Node* p = first;
        int maxLength = 0;      // длина самой длинной последовательности
        Node* start = nullptr;  // указатель на начало самой длинной последовательности
        Node* current = p;   // текущий элемент списка

        while (current != nullptr) {
            Node* temp = current;   // временный указатель на текущий элемент
            int length = 0;         // длина текущей последовательности
            while (temp->next != nullptr && temp->val == temp->next->val) {
                temp = temp->next;
                length++;
            }
            if (length > maxLength) {
                maxLength = length;
                start = current;
            }
            current = temp->next;
        }

        if (maxLength == 0) {
            cout << "No matching sequence found." << endl;
        }
        else {
            cout << "Самая длинная последовательность: ";
            for (int i = 0; i <= maxLength; i++) {
                cout << start->val;
                start = start->next;
            }
            cout << endl;
        }
    }

    void removeDuplicates() {
        Node* p = first;
        Node* curr = p;

        while (curr != nullptr) {
            Node* temp = curr->next;
            while (temp != nullptr && temp->val == curr->val) {
                curr->next = temp->next;
                delete temp;
                temp = curr->next;
            }
            curr = curr->next;
        }
    }

   /* void insertSorted(int value) {
        Node* p = first;
        Node* newNode = new Node(value);
        if (p == nullptr || value < p->val) {
            newNode->next = p;
            p = newNode;
        }
        else {
            Node* current = p;
            while (current->next != nullptr && current->next->val < value) {
                current = current->next;
            }
            newNode->next = current->next;
            current->next = newNode;
        }
    }

    Node* createNewList() {
        Node* p = first;
        Node* newList = nullptr;
        while (p) {
            int value = p->val;
            while (value > 0) {
                int digit = value % 10;
                insertSorted(digit);
                value /= 10;
            }
            p = p->next;
        }
        return newList;
    }*/
};

int main()
{
    setlocale(0, "");
    int n, size;
    char a;
    cout << "Использовать готовый список или создать новый? 1 2: "; cin >> n;
    if (n == 1)
    {
        list l;
        l.push_back('1');
        l.push_back('2');
        l.push_back('2');
        l.push_back('8');
        l.push_back('7');
        l.print();
        l.remove('7');
        l.print();
        l.push_begin('5');
        l.print();
        l.longestSequence();
        l.removeDuplicates();
        l.print();
    }
    else
    {
        list l;
        cout << "Введите размер списка: "; cin >> size;
        for (int i = 0; i < size; i++)
        {
            cout << "Введите элемент #" << i + 1 << ": "; cin >> a;
            l.push_back(a);
        }
        l.print();
        l.remove('3');
        l.print();
        l.push_begin('5');
        l.print();
        l.longestSequence();
        l.removeDuplicates();
        l.print();
    }

    return 0;
    system("pause");
}

 /*Функция longestSequence() принимает строку и возвращает самую длинную последовательность одинаковых символов в этой строке.

 Функция removeDuplicates() принимает строку и возвращает эту же строку, но без повторяющихся символов в каждой последовательности одинаковых символов.

  Функция createNewList() принимает исходный список и возвращает новый список, в котором элементы отсортированы по возрастанию и не повторяются.

 Пример использования функций включен в функцию main().*/