lab14

/*
    Лабораторная работа №14
    Шильцин Влад
    Вариант-46.
    Ввести последовательность натуральных чисел.
    Если последовательность упорядочена по не убыванию первой или последней цифры,
    удалить из последовательности числа, в которые входят цифры 2 и 3 (одновременно),
    и продублировать числа, начинающиеся цифрой 5.
    В противном случае упорядочить последовательность по не убыванию.
    Последовательность хранить в односвязном списке.
*/

#include <iostream>
#include <Windows.h>
#include <limits.h>

using namespace std;

class List
{
public:
    List();
    ~List();

    void add(int data);
    void pop_front();
    void push_front(int data);
    void insert(int data, int index);
    void removeAt(int index);
    void clear();
    int get_size() { return size; }
    int& operator[](const int index);

private:
    class Node
    {
    public:
        Node *next;
        int data;
        Node(int data = -1, Node *next = nullptr)
        {
            this->data = data;
            this->next = next;
        }
    };

    Node *head;
    int size;
};

List::List()
{
    size = 0;
    head = nullptr;
}

List::~List()
{
    clear();
}

void List::add(int data)
{
    if (head == nullptr)
        head = new Node(data);
    else
    {
        Node* current = this->head;

        while (current->next != nullptr)
        {
            current = current->next;
        }

        current->next = new Node(data);
    }
    size++;
}

void List::pop_front()
{
    Node* temp_head = head;
    head = head->next;
    delete temp_head;
    size--;
}

void List::push_front(int data)
{
    head = new Node(data, head);
    size++;
}

void List::insert(int data, int index)
{
    if (index == 0)
        push_front(data);
    else
    {
        Node* previous = this->head;
        for (int i = 0; i < index - 1; i++)
            previous = previous->next;

        Node* newNode = new Node(data, previous->next);
        previous->next = newNode;

        size++;
    }
}

void List::removeAt(int index)
{
    if (index == 0)
        pop_front();
    else
    {
        Node* previous = this->head;
        for (int i = 0; i < index - 1; i++)
            previous = previous->next;

        Node* temp_node = previous->next;
        previous->next = temp_node->next;
        delete temp_node;

        size--;
    }
}

void List::clear()
{
    while (size)
        pop_front();
}

int& List::operator[](const int index)
{
    int counter = 0;
    Node* current = this->head;

    while (current != nullptr)
    {
        if (counter == index)
            return current->data;

        current = current->next;
        counter++;
    }
}

int first_digit(int digit)
{
    while (digit > 9)
        digit /= 10;

    return digit;
}

int last_digit(int digit)
{
    return digit % 10;
}

void m_swap(int& a, int& b)
{
    int t = b;
    b = a;
    a = t;
}

bool contains_2_and_3(int digit)
{
    bool contains2 = false;
    bool contains3 = false;
    while (digit)
    {
        int t = digit % 10;

        if (t == 2)
            contains2 = true;
        if (t == 3)
            contains3 = true;

        digit /= 10;
    }

    if (contains2 && contains3)
        return true;

    return false;
}

int main()
{
    List list;

    int n = 0;
    int previous_first_digit = -1;
    int previous_last_digit = -1;

    bool first_digit_streamlined = true;
    bool last_digit_streamlined = true;

    scanf_s("%d", &n);

    for (int i = 0; i < n; i++)
    {
        int t = 0;
        scanf_s("%d", &t);

        int temp_first = first_digit(t);
        int temp_last = last_digit(t);

        if (previous_first_digit > temp_first)
            first_digit_streamlined = false;
        else
            previous_first_digit = temp_first;

        if (previous_last_digit > temp_last)
            last_digit_streamlined = false;
        else
            previous_last_digit = temp_last;

        list.add(t);
    }

    if (last_digit_streamlined || first_digit_streamlined)
    {
        for (int i = 0; i < list.get_size(); i++)
            if (contains_2_and_3(list[i]))
            {
                list.removeAt(i);
                i--;
            }

        for (int i = 0; i < list.get_size(); i++)
            if (first_digit(list[i]) == 5)
            {
                list.insert(list[i], i);
                i++;
            }
    }
    else
    {
        for (int i = 0; i < list.get_size() - 1; i++)
        {
            bool is_changed = false;
            for (int j = i + 1; j < list.get_size(); j++)
                if (list[i] > list[j])
                {
                    m_swap(list[i], list[j]);
                    is_changed = true;
                }

            if (!is_changed) break;
        }
    }

    for (int i = 0; i < list.get_size(); i++)
        cout << list[i] << " ";

    return 0;
}