TCS.cpp

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stdlib.h>
#include <windows.h>

using namespace std;

const int Min_Count = 40; /// ìèíèìàëüíûé äîïóñòèìûé ðàçìåð ìàññèâà, â êîòîðûé ìîãóò äîáàâëÿòüñÿ íîâûå çàäà÷è
const int inf = 9999; /// òèïà áåñêîíå÷íîñòü(íåëüçÿ äåëàòü ñëèøêîì áîëüøèì, âîçíèêíåò ïåðåïîëíåíèå)
const int Max_Reserve_Size = 100; /// ìàêñèìàëüíûé ðàçìåð ðåçåðâíîãî ìàññèâà
int Count = 0, q_add = 1; /// êîë-âî ýëåìåíòîâ â ôàéëå solve_problems è êîë-âî íîâûõ äîáàâëåííûõ çàäà÷
int Reserve_Size = 0;
bool tip = true; /// îòâå÷àåò çà ïîäñêàçêè(åñëè = true, òî îíè áóäóò âûâîäèòüñÿ)
bool tip_important = true; /// îòâå÷àåò çà âàæíûå ïîäñêàçêè(òèïà ââîäà êîíöåíòðàöèè)
bool tip_encumbering = true; /// ýòî ìåøàþùèå ïîäñêàçêè(òèïà Input numbers, ïðè add)
int Current_position = 0; /// ïîêàçûâàåò ïîçèöèþ â ôàéëå Buffer â äàííûé ìîìåíò
int q_buff; /// ïîêàçûâàåò, äî êàêîãî ýëåìåíòà íóæíî ñ÷èòûâàòü, ÷òîáû çàïèñàòü â áóôåð(â ðåàëüíîñòè, ýòî ñëèøêîì çàïóòàííàÿ øòêóà)
int Position; /// ïîêàçûâàåò, â êàêîì ñòîëáöå(â ôàéëå BP or BBP) íàõîäèòñÿ íóæíûé íàì ýëåìåíò
int Min_in_BP = -inf, Max_in_BP = inf; /// ïîêàçûâàåò íà ìàêñ è ìèí ýëåìåíòû â ôàéëå
/// BP(èçíà÷àëüíî îíè äîñòèãàþò ñâîåãî ìàêñèìóìàëüíîé àìïëèòóäû, ÷òîáû íå âîçíèêàëî
/// îøèáîê â óäàëåíèè èç BP

/// ðåàëüíîå êîë-âî ýëåìåíòîâ â ìàññèâå Solve_Problems = Count+q_add-1
int Reserve[Max_Reserve_Size+1]; /// ðåçåðâíûé ìàññèâ
bool flag_Recover_Back_Back_Up = false; /// åñëè îí ðàâåí true, òî ïðîèñõîäèò âîññòàíîâëåíèå ôàéëà Back_Back_Up
int count_Recover_Back_Back_Up; /// íîìåð íîìåðà â ôàéëå BBUp, äî êîòîðîãî ïîëüçîâàòåëü õî÷åò âîññòàíîâèòü
/// åñëè count_Recover_Back_Back_Up = 0, çíà÷èò íàäî âîññòàíîâèòü âñå

void print(int *F, int l, int r); /// âûâîäèò íà ýêðàí ó÷àñòîê ìàññèâà
void generation(int *F, int start, int finish, int concentration); /// ãåíåðèðóåò çàäà÷è èç äèàïîçîíà
void Add(int *F, int number); /// äîáàâëÿåò â íàáîð ðåøåííûõ çàäà÷ çàäà÷ó ïîä íîìåðîì number(change q_add)
void Delete(int *F, int number); /// óäàëÿåò èç íàáîðà ðåøåííûõ çàäà÷ çàäà÷ó ïîä íîìåðîì number(change q_add)
void Back_Up(int *F); /// çàïèñûâàåò â ôàéë áýêàï èçìåíåíèÿ, êîòîðûå ïðîèçîøëè
void Back_Back_Up(int *T, bool flag); /// çàïèñûâàåò â ôàéë áýêàïà îò áýêàïà îñíîâíîãî
/// ôàéëà(ñäåëàíî äëÿ óñêîðåíèÿ ïðîãðàììû). Åñëè flag = true, çíà÷èò ìû äîáàâëÿåì äàííûé îáúåêò, åñëè false - delete
void Buffer_Save(int *Buf, int n, int flag); /// äîáàâëÿåò â áóôôåð
void Add_in_BP(int *F, int n); /// äîáàâëÿåò â BP ýëåìåíòû èç ìàññèâà F

void return_min_max(int A[], int n, int &Min, int &Max){
    Max = Min = A[1];
    for (int i = 2; i < n+1; i++){
        if (A[i] < Min) Min = A[i];
        if (A[i] > Max) Max = A[i];
    }
}

void Counting_Sort(int A[], int n){
    int Min, Max;
    return_min_max(A, n, Min, Max);
    int B[n+1], C[Max-Min+1];

    for (int i = 0; i < Max-Min+1; i++)
        C[i] = 0;
    for (int i = 1; i < n+1; i++)
        C[A[i]-Min] += 1;

    for (int j = 1; j < Max-Min+1; j++)
        C[j] += C[j-1];

    for (int i = 1; i < n+1; i++){
       B[C[A[i]-Min]] = A[i];
     C[A[i]-Min]--;
    }

    for (int i = 1; i < n+1; i++)
        A[i] = B[i];
}

void Counting_Sort_with_Linking(int A[], int n, int Linking[]){
    int Min, Max;
    return_min_max(A, n, Min, Max);
    int B[n+1], C[Max-Min+1], B_link[n+1];

    for (int i = 0; i < Max-Min+1; i++)
        C[i] = 0;
    for (int i = 1; i < n+1; i++)
        C[A[i]-Min] += 1;

    for (int j = 1; j < Max-Min+1; j++)
        C[j] += C[j-1];

    for (int i = 1; i < n+1; i++){
       B[C[A[i]-Min]] = A[i];
    B_link[C[A[i]-Min]] = Linking[i];
     C[A[i]-Min]--;
    }

    for (int i = 1; i < n+1; i++){
        A[i] = B[i];
            Linking[i] = B_link[i];
    }
}


int bin_search(int *F, int l, int r, int key)
{
    int mid;
    while (r - l > 1)
    {
        mid = (r+l)/2;
        if (F[mid] > key) r = mid-1;
        else l = mid;
    }
    if (F[l] == key) return l;
    if (F[r] == key) return r;
    return -1;
}
/*
    ôóíêöèÿ âîçâðàùàåò, â ñëó÷àå, åñëè key = true, òî ñàìûé áîëüøîé ýëåìåíò ñðåäè
    ìåíüøèõ èëè ðàâíûõ ýòîãî ÷èñëà, â ïðîòèâíîì ñëó÷àå, ñàìûé ìàëåíüêèé
    ñðåäè áîëüøèõ èëè ðàâíûõ åìó(òî÷íåå, èíäåêñ â ìàññèâå)
    íèõ.
*/
int bin_search_in_range(int *F, int l, int r, int value, bool key)
{
    if (key)
    {
        int mid;
        while (r - l > 1)
        {
            mid = (r+l)/2;
            if (F[mid] < value) l = mid+1;
            else r = mid;
        }
       if (F[l] >= value) return l;
       if (F[r] >= value) return r;
       return -1;
    }
    else
    {
       int mid;
        while (r - l > 1)
        {
            mid = (r+l)/2;
            if (F[mid] > value) r = mid - 1;
            else l = mid;
        }
       if (F[r] <= value) return r;
       if (F[l] <= value) return l;
       return -1;

    }
}
 /*
    Âûâîäèò íà ýêðàí ñîäåðæèìîå ìàññèâà Solve_Problems(â èäåàëå ïðîèçâîëüíîãî, íî
    áóäåò èñïîëüçîâàòüñÿ òîëüêî ýòîò ìàññèâ(ñêîðåå âñåãî))
 */
void print(int *F, int l, int r)
{
    for (int i = l; i <= r; i++)
        cout << F[i] << " ";
    cout << "\n\n";
}
/*
    Âûâîäèò íà ýêðàí ñîäåðæèìîå ôàéëà Back_Up
*/
void Print()
{
    FILE *back_up = fopen(".tcs/Back_Up.txt", "r");
    int count; fscanf(back_up, "%d", &count);
    int data;
    if (count == 0) {cout << "No solve problems\n"; return;}
    for (int i = 0; i < count; i++)
    {
        fscanf(back_up, "%d", &data);
        cout << data << " ";
    }
    cout << "\n\n";
    fclose(back_up);
}

/*
    Îáðàáàòûâàåò çàïðîñ ïîëüçîâàòåëÿ(ââîä) äëÿ îïðåäåëåíèÿ äèàïîçîíà íîìåðîâ,
    êîòîðûå íóæíî âûâåñòè(ò.å., òå íîìåðà, êîòîðûå >= start, è <= finish).
    Òàê æå, ýòà ôóíêöèÿ îòâå÷àåò çà ñàì âûâîä ýòîãî íà ýêðàí.
*/

void print_range(int *F, int n)
{
    int start, finish;
  if (tip)  cout << "If you want to break, enter -1\n";
    while (true)
    {
       if (tip_encumbering) cout << "Input start number: ";
        cin >> start; if (start == -1) break;
        if (tip_encumbering) cout << "Input finish number: ";
        cin >> finish; if (finish == -1) break;
        if (start > finish)
        {
            cout << "The start number is greater than finish number. Try again\n";
        }
        else
        {
            if (n == 0) {cout << "Range is empty\n\n"; break;}
            else
            {
            int a = bin_search_in_range(F, 1, n, start, true);
            int b = bin_search_in_range(F, 1, n, finish, false);
            if (a == -1 || b == -1) cout << "Range is empty\n\n";
            else print(F, a, b);
            break;
            }
        }
    }
}

/*
    Ïðîèçâîäèò íàñòðîéêè ïîäñêàçîê.
*/

void tip_install()
{
    char s[20];
    if (tip) cout << "If you want to break, then enter 'exit'\n";

    while (true)
    {
        if (tip) cout << "\nTip install command: ";
        cin >> s;
        if (!strcmp(s, "exit")) break;
        else if (!strcmp(s, "print"))
        {
            cout << "\n";
            cout << "tip_encumbering is really bad tip!\n";
            cout << "tip is normal thing\n";
            cout << "tip_important is really important thing\n\n";
        }
        else if (!strcmp(s, "tip"))
        {
            while (true)
            {
            char command[10];
            if (tip) cout << "If you want to break, then enter 'exit'\n";
            if (tip_encumbering) cout << "Tip command(off or on): ";
            cin >> command;
            if (!strcmp(command, "exit")) break;
            else if (!strcmp(command, "off")) {tip = false; break;}
            else if (!strcmp(command, "on")) {tip = true; break;}
            }
            break;
        }
        else if (!strcmp(s, "tip_important"))
        {
             while (true)
            {
            char command[10];
            if (tip) cout << "If you want to break, then enter 'exit'\n";
            if (tip_encumbering) cout << "Tip_important command(off or on): ";
            cin >> command;
            if (!strcmp(command, "exit")) break;
            else if (!strcmp(command, "off")) {tip_important = false; break; }
            else if (!strcmp(command, "on")) {tip_important = true; break;}
            }
            break;
        }
        else if (!strcmp(s, "tip_encumbering"))
        {
             while (true)
            {
            char command[10];
            if (tip) cout << "If you want to break, then enter 'exit'\n";
            if (tip_encumbering) cout << "Tip_encumbering command(off or on): ";
            cin >> command;
            if (!strcmp(command, "exit")) break;
            else if (!strcmp(command, "off")) {tip_encumbering = false; break;}
            else if (!strcmp(command, "on")) {tip_encumbering = true; break; }
            }
            break;
        }
        else if (!strcmp(s, "all"))
        {
             while (true)
            {
            char command[10];
            if (tip) cout << "If you want to break, then enter 'exit'\n";
            if (tip_encumbering) cout << "All tip command(off or on): ";
            cin >> command;
            if (!strcmp(command, "exit")) break;
            else if (!strcmp(command, "off")) {
                tip_encumbering = false; tip_important = false; tip = false; break;}
            else if (!strcmp(command, "on")) {
                tip_encumbering = true; tip_important = true; tip = true; break;}
            }
            break;
        }
    }
}
/*
    Âûâîäèò íà ýêðàí ñîîáùåíèå. Åñëè key = true, òî on. Else, off.
    Íóæíî äëÿ òîãî, ÷òîáû êîä áûë ìåíüøåãî îáúåìà, èáî ýòî ïðèìåíÿåòñÿ â tip_print.
*/
void logic_show(bool key)
{
    if (key) cout << "on";
    else cout << "off";
}

void tip_print()
{
    cout << "\n\n";
    cout << "tip_encumbering: "; logic_show(tip_encumbering);
    cout << "\ntip: "; logic_show(tip);
    cout << "\ntip_important: "; logic_show(tip_important);
    cout << "\n\n";
}

void Add(int *F, int number)
{
    if (Count+q_add == 1 || bin_search(F, 1, Count+q_add-1, number) == -1){
    F[Count+q_add] = number;
        q_add++;
        Counting_Sort(F, Count+q_add-1);
    }
}

/*
    Ïðîèçâîäèò äîáàâëåíèå ýëåìåíòîâ èç äèàïîçîíà(ò.å., íàïðèìåð, îò 1 äî 50)
*/

void add_range(int *F)
{
    int n = Count + q_add - 1; /// Ðàçìåð ìàññèâà Solve_Problems[1..n]
    if (tip) cout << "If you want to break, enter '-1'\n\n";
    while (true)
 {
   int start, finish;
        if (tip_encumbering) cout << "Input start number: ";
        cin >> start;
        if (start == -1) break;
        if (tip_encumbering) cout << "Input finish number: ";
        cin >> finish; if (finish == -1) break;
        if (start < 0 || start > finish) cout << "Input not correct. Try again.\n\n";
        else
        {
            int count = finish-start+1;
            int buff[count+1], w = 0; /// íóæíî äëÿ òîãî, ÷òîáû äîáàâèòü â áóôôåð
            for ( ; start <= finish; start++)
            {
                if (bin_search(F, 1, Count+q_add-1, start) == -1)
                {
                    buff[++w] = start;
                }
                Add(F, start);
            }
            Buffer_Save(buff, w, 1); /// äîáàâëÿåì â áóôôåð äîáàâëåííûå ýëåìåíòû
            return;
        }
 }
}

void Delete(int *F, int number)
{
    if (Count + q_add > 1) /// åñëè åñòü õîòü ÷òî-òî â ìàññèâå
    {
        int q = bin_search(F, 1, Count+q_add, number);
        if (q != -1)
        {
            F[q] = inf;
            q_add--;
            Counting_Sort(F, Count+q_add);
        }
    }
}

/*
    Ïðîèçâîäèò óäàëåíèå âñåõ íîìåðîâ ñ äàííîãî äèàïîçîíà(ò.å., íàïðèìåð, ñ 1 ïî 50 íîìåðà)
*/

void delete_range(int *F)
{
    int n = Count + q_add - 1; /// Ðàçìåð ìàññèâà Solve_Problems[1..n]
    if (tip) cout << "If you want to break, enter '-1'\n\n";
 while (true)
 {
   int start, finish;
        if (tip_encumbering) cout << "Input start number: ";
        cin >> start;
        if (start == -1) break;
        if (tip_encumbering) cout << "Input finish number: ";
        cin >> finish; if (finish == -1) break;
        if (start < F[1] || finish > F[n] || start > finish)
        {
            while (true)
            {
                cout << "You sure, that range is correct?";
                if (tip) cout << "(yes or no)"; cout << ": ";
                char command[10];
                cin >> command;
                if (!strcmp(command, "yes"))
                {
                    int buf_count = 0, start1 = start; /// ñîõðàíÿåì start, èáî îí
                    /// áóäåò ïîòåðÿí â öèêëå íèæå
                    for ( ; start <= finish; start++)
                        {
                            if (start <= F[n] && start >= F[1])
                            {
                            if (bin_search(F, 1, n, start) != -1)
                                buf_count++;
                            }
                            else if (start > F[n]) break;
                        }
/*
Ïðîõîäèì åùå ðàç ýòîò ïðîìåæóòîê, ïî ñëåäóþùèì ïðè÷èíàì:
    Äåëî â òîì, ÷òî ïîëüçîâàòåëü ìîæåò ââåñòè ñëèøêîì áîëüøîé ïðîìåæóòîê, íàïðèìåð
    îò -2 äî 100000000. Ïðîãðàììà ôèêñèðóåò ìîìåíò, êîãäà ìû äîøëè äî ñàìîãî
    áîëüøîãî ÷èñëà èç ìàññèâà, è âûõîäèò èç öèêëà, ÷òîáû áåññìûññëåííî íå
    ïðîñìàòðèâàòü îñòàëüíûå ÷èñëà, êîòîðûå, î÷åâèäíî, ò.ê. áîëüøå ñàìîãî áîëüøîãî
    ÷èñëà èç ìàññèâà, íå íàõîäÿòñÿ â ìàññèâå. Òàê âîò, ìû áû ïðîõîäèëè ýòîò
    ïðîìåæóòîê 1 ðàç, åñëè áû çàðàíåå ñîçäàëè áû íóæíîãî ðàçìåðà ìàññèâ, äëÿ çàïèñè
    åãî â áóôôåð. Îäíàêî, ïîëüçîâàòåëü ìîæåò ââåñòè ëþáîãî ðàçìåðà ïðîìåæóòîê, òàê
    ÷òî, äëÿ áåçîïàñíîñòè îò àâàðèéíûõ ñèòóàöèé è èñïîëüçîâàíèÿ êàê ìîæíî ìåíüøåãî
    îáúåìà ïàìÿòè, ìû ïðîéäåìñÿ åùå ðàç ïî ýòîìó ïðîìåæóòêó, íî óæå çíàÿ, ñêîëüêî
    ýëåìåíòîâ íóæíî óäàëèòü(ìû ýòî ïîäñ÷èòûâàëè, êîãäà ïðîõîäèëèñü 1 ðàç ïî
    ïðîìåæóòêó).
*/
    int buff[buf_count+1], w = 0;
    for ( ; start1 <= finish; start1++)
    {
        if (start1 <= F[n] && start1 >= F[1])
        {
            if (bin_search(F, 1, n, start1) != -1)
                buff[++w] = start1;
            Delete(F, start1);
        }
        else if (start1 > F[n]) break;
    }
    Buffer_Save(buff, w, -1); /// äîáàâëÿåì â áóôôåð
                        return; /// âûõîäèì íàôèã èç ôóíêöèè
                }
                else if (!strcmp(command, "no")) break;
            }
        }
        else
        {
            int buf_count = finish-start+1;
            int buff[buf_count+1], w = 0;
            for ( ; start <= finish; start++)
                        {
                            if (bin_search(F, 1, Count+q_add-1, start) != -1)
                                buff[++w] = start;
                             Delete(F, start);
                        }

            Buffer_Save(buff, w, -1); /// Äîáàâëÿåì â áóôôåð
                    return;
        }

 }
}

 /* â ôàéëå Back_Back_Up íà ïåðâîì ìåñòå èäåò flag - ïîêàçûâàåò, ÷òî ìû äåëàåì ñ
äàííûìè íîìåðàìè. Åñëè flag = 1 - äîáàâëåíèå, flag = 0 - óäàëåíèå, flag = -1 - ïóñòî
 */
void Back_Back_Up(int *T, int count, bool flag)
{
    FILE *back_back_up = fopen(".tcs/Back_Back_Up.txt", "w");
    if (count == -1) {fprintf(back_back_up, "%d%s", -1, "\n"); fclose(back_back_up);return;}
    fprintf(back_back_up, "%d%s", flag, "\n");
    fprintf(back_back_up, "%d%s", count, "\n");
    for (int i = 1; i <= count; i++)
        fprintf(back_back_up, "%d%s", T[i], " ");
    fclose(back_back_up);
}

void Back_Up(int *F)
{
     FILE *back_up = fopen(".tcs/Back_Up.txt", "w");
     fprintf(back_up, "%d%s", Count+q_add-1, "\n");
     for (int i = 1; i < Count + q_add; i++)
        fprintf(back_up, "%d%s", F[i], " ");
        fclose(back_up);
}

/*
    Êîïèðóåò ôàéë Buffer, â ôàéë Buf_Buffer
*/

void Buffer_Copy()
{
    FILE *buffer = fopen(".tcs/Buffer.txt", "r");
    FILE *buf_buffer = fopen(".tcs/Buf_Buffer.txt", "w");


    int data, Count, count;
    fscanf(buffer, "%d",&Count);///ñ÷èòûâàåì Count
    fprintf(buf_buffer, "%d%s%", Current_position, "\n");

    for (int i = 0; i < Current_position; i++)
    {
        fscanf(buffer, "%d", &count);
        fprintf(buf_buffer, "%d%s", count, " ");
        for (int j = 0; j < count + 1; j++) /// ñ÷èòûâàåì äî count + 1, èáî îïåðàöèÿ òîæå ó÷èòûâàåòñÿ
        {
            fscanf(buffer, "%d", &data);
            fprintf(buf_buffer, "%d%s", data, " ");
        }
        fprintf(buf_buffer, "%s", "\n");
    }
    fclose(buffer);
    fclose(buf_buffer);

}

/*
    Çàïèñûâàåò â ìàññèâ Buffer äîïîëíèòåëüíûå äàííûå äëÿ áóôåðà
*/

void Buffer_Save(int *Buf, int n, int flag) /// flag = 1 - äîáàâëåíèå, -1 - óäàëåíèå
{
    Buffer_Copy(); /// äåëàåì êîïèþ ôàéëà Buffer.txt
    /// Äåëàåì îáðàòíóþ êîïèþ
    FILE *buffer = fopen(".tcs/Buffer.txt", "w");
    FILE *buf_buffer = fopen(".tcs/Buf_Buffer.txt", "r");
    int data, Count, count;
    fscanf(buf_buffer, "%d", &Count);
    fprintf(buffer, "%d%s", Count+1, "\n");
    Current_position++;
    for (int i = 0; i < Count; i++)
    {
        fscanf(buf_buffer, "%d", &count);
        fprintf(buffer, "%d%s", count, " ");
        for (int j = 0; j < count + 1; j++)
        {
            fscanf(buf_buffer, "%d", &data);
            fprintf(buffer, "%d%s", data, " ");
        }
        fprintf(buffer, "%s", "\n");
    }
    /// Ïîñëå ïî÷òè ïîëíîé êîïèè(êðîìå ïåðâûõ ÷èñåë, óâåëè÷åííûõ íà 1)
    /// ìîæíî ïðèñòóïàòü ê äîáàâëåíèþ íîâîé ñòðîêè
    fprintf(buffer, "%d%s%d%s", n, " ", flag, " ");
    for (int i = 1; i <= n; i++)
        fprintf(buffer, "%d%s", Buf[i], " ");
    fclose(buffer);
    fclose(buf_buffer);
}

/*
    Ïðîèçâîäèò ÀÊÊÓÐÀÒÍÎÅ äîáàâëåíèå íîâîé èíôîðìàöèè â áóôôåð.
    Èìååòñÿ ââèäó, ÷òî íåëüçÿ ïðîñòî ñîõðàíÿòü â ìàññèâ ñïèñîê çàäà÷, êîòîðûå
    ïîëüçîâàòåëü õî÷åò äîáàâèòü\óäàëèòü, èáî ñðåäè íèõ ìîãóò áûòü çàäà÷è, êîòîðûå
    óæå ÿâëÿþòñÿ ðåøåííûìè, è åñëè ìû èõ äîáàâèì â áóôôåð, òî ïðè âûçîâå
    ïîëüçîâàòåëåì áóôôåðà äëÿ âîññòàíîâëåíèÿ äàííûõ, íåêîòîðûå äàííûå ìîãóò
    íåïðàâèëüíî äîáàâèòüñÿ îáðàòíî, èëè, äàæå óäàëèòüñÿ! Èç-çà ýòîãî, ïðè äîáàâëåíèè
    â áóôåð, ìû äîëæíû ïðîâåðèòü, åñòü ëè ýòîò ýëåìåíò â ìàññèâå èëè åãî íåòó.
    Åñëè ïîëüçîâàòåëü õî÷åò äîáàâèòü ýëåìåíò, òî ìû äîëæíû ïðîâåðèòü, ÷òî åãî íåòó
    â ñïèñêå ðåøåííûõ çàäà÷. À åñëè õî÷åò óäàëèòü, òî ïðîâåðÿåì, ÷òî òàêîé ýëåìåíò
    åñòü â ñïèñêå.
    flag = 1 - çíà÷èò äîáàâëåíèå, -1 - óäàëåíèå
*/

void Add_Buffer(int *Solve_Problems, int *F, int n, int flag)
{
    if (flag == 1)
    {
        int buff[n+1], q = 0;
        for (int i = 1; i <= n; i++)
            if (bin_search(Solve_Problems, 1, Count+q_add-1, F[i]) == -1)
            {
                buff[++q] = F[i];
            }
        if (q > 0) Buffer_Save(buff, q, 1);
    }
    else if (flag == -1)
    {
        int buff[n+1], q = 0;
        for (int i = 1; i <= n; i++)
            if (bin_search(Solve_Problems, 1, Count+q_add-1, F[i]) != -1)
                buff[++q] = F[i];
        if (q > 0) Buffer_Save(buff, q, -1);
    }
}

/*
    Ïðîèçâîäèò çàïèñü èç ôàéëà Buffer â ìàññèâ Solve_Problems
    Ò.å., ôàêòè÷åñêè, îòâå÷àåò çà âîññòàíîâëåíèå èç äàííûõ èç áóôôåðà.
    if back = 1, òî ñ÷èòûâàåì íàçàä èç áóôåðà(òî, ÷òî áûëî)
        else, if back = 0, òî ñ÷èòûâàåì âïåðåä
*/

void Buffer_overwrite(int *solve_problems, int back)
{
    int data, Count, count, operation;
    FILE *buffer = fopen(".tcs/Buffer.txt", "r");
    fscanf(buffer, "%d", &Count);
    back--;
    Current_position -= back;
    if (Current_position > Count) Current_position--;
    /// åñëè ìîæíî ñ÷èòàòü áóôôåð, òî ñ÷èòûâàåì
    if (Current_position >= 1 && Current_position <= Count)
    {
        for (int j = 0; j < Current_position - 1; j++) /// äîõîäèì äî íóæíîé íàì
           {                                        /// ñ÷èòûâàåìîé ñòðîêè
            fscanf(buffer, "%d%d", &count, &operation);
            for (int k = 0; k < count; k++) fscanf(buffer, "%d", &data);
           }
           fscanf(buffer, "%d%d", &count, &operation);
           if (!back) operation *= -1; /// ìåíÿåì îïåðàöèþ íà ïðîòèâîïîëîæíóþ
           /// åñëè èäåì íàçàä. Åñëè âïåðåä, òî íå ìåíÿåì, à îñòàâëÿåì êàê åñòü
        if (operation == 1) /// äîáàâëåíèå
        {
            for (int i = 0; i < count; i++)
            {
                fscanf(buffer, "%d", &data);
                Add(solve_problems, data);
            }
        }
        else if (operation == -1) /// óäàëåíèå
        {
            for (int i = 0; i < count; i++)
            {
                fscanf(buffer, "%d", &data);
                Delete(solve_problems, data);
            }
        }
        if (!back) Current_position --;
    }
    fclose(buffer);
}

/*
    Ôóíêöèÿ, âûâîäÿùàÿ íà ýêðàí ïîìîùü â êîìàíäàõ BP.
*/

void help_BP()
{
    cout << "\n";
    cout << "Command 'add' adds items to a file BP\n";
    cout << "Construction: add count number1 ... number_count[add 2 67 94]\n\n";
    cout << "Command 'delete' deletes items to a file BP\n";
    cout << "Construction: delete count number1 ... number_count [delete 2 56 87]\n\n";
    cout << "Command 'add:' adds a task list\n";
    cout << "Construction: add start finish [add: 34 57]\n\n";
    cout << "Command 'delete' deletes a task list\n";
    cout << "Construction: delete start finish [delete: 1 20]\n\n";
    cout << "Command 'copy' copies the BP file to the BBP file\n";
    cout << "Construction: copy\n\n";
    cout << "Command 'search' searches for an item in the BP file\n";
    cout << "Construction: search number [search 127]\n\n";
    cout << "Command 'print' displays the BP file\n";
    cout << "Construction: print\n\n";
    cout << "Command 'print:' displays the range of tasks from the BP file\n";
    cout << "Construction: print: start finish [print: 25 68]\n\n";
}

/*
    Èùåò â îäíîì èç ôàéëîâ (BP or BBP)
    Return -1, åñëè íå íàøåë.  ïðîòèâíîì ñëó÷àå, âîçâðàùàåò íîìåð ñòðîêè â ôàéëå
    Îäíîâðåìåííî ñ ýòèì, ãëîáàëüíàÿ ïåðåìåííàÿ Position
    (â ñëó÷àå, åñëè íàøåëñÿ ýëåìåíò)
    âîçâðàùàåò ïîçèöèþ â ñòðîêå(ò.å. íîìåð ñòîëáöà), ãäå ëåæèò íóæíûé ýëåìåíò.
*/
int search_in_BP(int key, bool flag)
{
    FILE *f;
    if (flag)
    {
        f = fopen(".tcs/Base_Problems.txt", "r");
    }
    else
    {
        f = fopen(".tcs/Base_Base_Problems.txt", "r");
    }
    int Count, count;
    fscanf(f, "%d", &Count);
    for (int i = 0; i < Count; i++)
    {
        fscanf(f, "%d", &count);
        int H[count+1];
        for (int j = 0; j < count; j++)
        {
            fscanf(f, "%d", &H[j+1]);
        }
        int ind = bin_search(H, 1, count, key);
        if (ind != -1) /// íàøëè ýëåìåíò
        {
            Position = ind;
            return (i+1);
        }
    }
    return -1;
}

/*
    if flag == true, òî Ïðîèçâîäèò êîïèðîâàíèå ôàéëà BP â ôàéë BBP.
        Else, íàîáîðîò, êîïèþ BBP â BP.
*/

void Copy_BP(bool flag)
{
    FILE *bp;
     FILE *bbp;
     if (flag)
     {
         bp = fopen(".tcs/Base_Problems.txt", "r");
         bbp = fopen(".tcs/Base_Base_Problems.txt", "w");
     }
     else
     {
         bp = fopen(".tcs/Base_Base_Problems.txt", "r");
         bbp = fopen(".tcs/Base_Problems.txt", "w");
     }
    int data, Count, count;
    fscanf(bp, "%d", &Count);
    fprintf(bbp, "%d%s", Count, "\n");
    for (int i = 0; i < Count; i++)
    {
        fscanf(bp, "%d", &count);
        fprintf(bbp, "%d%s", count, " ");
        for (int j = 0; j < count; j++)
        {
            fscanf(bp, "%d", &data);
            fprintf(bbp, "%d%s", data, " ");
        }
        fprintf(bbp, "%s", "\n");
    }
    fclose(bp); fclose(bbp);
}

/*
    Ïðîèçâîäèò îáíîâëåííóþ êîïèþ ôàéëà BBP â ôàéë BP ñ ó÷åòîì êîððåêòèðîâêè
    êîë-âà Count(óâåëè÷èâàåì íà 1) è äîáàâëåíèåì â êîíöå ôàéëà íîâîãî ìàññèâà
*/

void Copy_new_BP(int *H, int q)
{
    FILE *bp = fopen(".tcs/Base_Problems.txt", "w");
    FILE *bbp = fopen(".tcs/Base_Base_Problems.txt", "r");
    int data, Count, count;
    fscanf(bbp, "%d", &Count);
    fprintf(bp, "%d%s", Count+1, "\n");
    for (int i = 0; i < Count; i++)
    {
        fscanf(bbp, "%d", &count);
        fprintf(bp, "%d%s", count, " ");
        for (int j = 0; j < count; j++)
        {
            fscanf(bbp, "%d", &data);
            fprintf(bp, "%d%s", data, " ");
        }
        fprintf(bp, "%s", "\n");
    }
    fprintf(bp, "%d%s", q, " ");
    for (int i = 0; i < q; i++)
        fprintf(bp, "%d%s", H[i], " ");
    fclose(bp); fclose(bbp);
}

/*
    Ôóíêöèÿ ïðîèçâîäèò äîáàâëåíèå(ñîõðàíåíèå) íîìåðîâ, ïðè ýòîì ïðåäúÿâëÿåòñÿ ìàññèâ
    F, èçâåñòåí åãî ðàçìåð(îí íà÷èíàåòñÿ ñ 1), ââîäèòñÿ ñòàðò è ôèíèø.
    Ïðîèçâîäèì äîáàâëåíèå îò ñòàðò äî ôèíèøà òîëüêî òåõ íîìåðîâ, êîòîðûå ëåæàò â F.
    Íîìåðà start and finish ïðåäïîëàãàþòñÿ ââåäåííûìè êîððåêòíî!
*/

void Save_in_BP(int *F, int n, int start, int finish)
{
    int st = bin_search(F, 1, n, start);
    int fn = bin_search(F, 1, n, finish);
    if (st <= fn)
    {
        if (st != -1 && fn != -1)
        {
            int H[fn-st+1], q = 0;
            for (int i = st; i <= fn; i++)
                H[q++] = F[i];
            Add_in_BP(H, q);
        }
    }
}

/*
    Ïðîèçâîäèò äîáàâëåíèå â ôàéë BP ñïèñêà çàäà÷, êîòîðûå ïîëüçîâàòåëü ðåøèë
    ñîõðàíèòü(÷òîáû ðåøèòü ïîòîì). Íóæíî ïðîïèñàòü ñèñòåìó îïðåäåëåíèÿ àëãîðèòìà
    ïîäñ÷åòà(åñëè ïàìÿòè ìíîãî, òî ïóñòü âûäåëÿåò ïàìÿòü, à íå ïðîõîäèò 2 ðàçà
    öèêë, ðàäè ñîõðàíåíèÿ ïàìÿòè. Åñëè æå, íàîáîðîò, î÷åíü îïàñíàÿ ñèòóàöèÿ ñ
    ïàìÿòüþ, òî ïóñòü æåðòâóåòñÿ ñêîðîñòü ðàáîòû, íî íå âûäåëÿåòñÿ ìíîãî ïàìÿòè,
    íåæåëè íåîáõîäèìî(èáî ïîäâèñàíèå ñèñòåìû íà ìàëåíüêîå âðåìÿ ëó÷øå àâàðèéíîãî
    âûõîäà èç ïðîãðàììû. Òàê æå, ïåðåïîëíåíèå îïàñíî äëÿ âñåé ñèñòåìû, èáî ìîãóò
    áûòü ñòåðòû âàæíûå ôàéëû äëÿ ÎÑ).
*/

void Add_in_BP(int *F, int n) /// Ìàññèâ F íà÷èíàåòñÿ ñ 0 è äî n-1 !!!
{
    Copy_BP(true); /// êîïèðóåì ôàéë BP â BBP
    int q = 0; /// ñ÷åò÷èê
    /*
        Öèêëîì ïðîñìàòðèâàåì, ñêîëüêî çàäà÷ èç ìàññèâà F íóæíî äîáàâèòü â BP(èáî
        íåêîòîðûå èç çàäà÷ òàì óæå ëåæàò)
    */
    for (int i = 0; i < n; i++)
        if (search_in_BP(F[i], false) == -1) q++;
    int H[q], w = 0;
    /*
        Ïðîáëåìà â òîì, ÷òî ìû âî 2 ðàç ïðîõîäèìñÿ ïî ìàññèâó, ïðè ýòîì ïðîèçâîäÿ
        ïîèñê â îãðîìíîì ôàéëå BP, âìåñòî òîãî, ÷òîáû ÷óòü áîëüøå âûäåëèòü ïàìÿòè.
        Ýòî íåâûãîäíî ïî âðåìåíè, ïîýòîìó, ïîçæå, ëó÷øå ïðîðàáîòàòü ñèñòåìó îïðå-
        äåëåíèÿ íàãðóçêè íà ïàìÿòü è â ñëó÷àå, åñëè ïàìÿòü åñòü, òî âûäåëèòü
        åå, à íå ïðîõîäèòüñÿ ïî ìíîãó ðàç ïî îãðîìíûì ôàéëàì!
    */
    for (int i = 0; i < n; i++)
        if (search_in_BP(F[i], false) == -1) H[w++] = F[i];///Ýòî íå âûãîäíî ïî âðåìåíè
    if (q) /// åñëè åñòü ÷òî äîáàâèòü íîâîãî â ôàéë BP
    {
        Copy_new_BP(H, q);
    }
}

/*
    Äîñòàòî÷íî äîëãîå(ïî âðåìåíè) óäàëåíèå. Èäåÿ çàêëþ÷àåòñÿ â òîì, ÷òî
    ìû, âíà÷àëå, êîïèðóåì ôàéë BP â BBP, ïîñëå ÷åãî íà÷èíàåì èäòè ïî BBP.
    Êàæäóþ ñòðî÷êó BBP ñðàíèâàåì íà íàëè÷èå â ìàññèâå F. Åñëè åñòü ýëåìåíòû, òî
    íå äîáàâëÿåì èõ â íîâûé ôàéë BP.
*/

void Delete_in_BP(int *F, int n) /// ìàññèâ F íà÷èíàåòñÿ ñ 1 è äî n !!!
{
    Copy_BP(true);
    FILE *bp = fopen(".tcs/Base_Problems.txt", "w");
    FILE *bbp = fopen(".tcs/Base_Base_Problems.txt", "r");
    int data, Count, count, new_Count = 0; /// new_Count - íîâûé ñ÷åò÷èê äëÿ
    /// ôàéëà BP, ÷òîáû ïîñëå çàïèñè òåõ çàäà÷, êîòîðûå íå ïîäëåæàò óäàëåíèþ, ìû
    /// çàïèñàëè íàø ôàéë â íîðìàëüíîì âèäå(íåîáõîäèìîì äëÿ êîððåêòíîé ðàáîòû
    /// è êîððåêòíîãî ñïîñîáà õðàíåíèÿ èíôîðìàöèè)
    fscanf(bbp, "%d", &Count);
    for (int i = 0; i < Count; i++)
    {
        fscanf(bbp, "%d", &count);
        int H[count], q = 0; /// ìàññèâ, â êîòîðûé áóäåì äîáàâëÿòü òå çàäà÷è, êîòîðûõ
        /// íåòó â ìàññèâå F(äëÿ çàïèñè â ôàéë BP). q - ñ÷åò÷èê
        for (int j = 0; j < count; j++)
        {
            fscanf(bbp, "%d", &data);
            if (bin_search(F, 1, n, data) == -1) H[q++] = data;
        }
        if (q) /// åñëè åñòü ÷òî äîáàâèòü â ôàéë BP, òî...
        {
            fprintf(bp, "%d%s", q, " ");
            for (int k = 0; k < q; k++)
                fprintf(bp, "%d%s", H[k], " ");
            fprintf(bp, "%s", "\n");
            new_Count++;
        }
    }
    fclose(bp); fclose(bbp);
    /// Òåïåðü ïåðåçàïèøåì íàø ôàéë â íîðìàëüíîì âèäå(âíà÷àëî íóæíî äîáàâèòü
     /// new_Count, âñå îñòàëüíîå îñòàâèòü êàê åñòü(ïîñëå èçìåíåíèé).
     bbp = fopen(".tcs/Base_Base_Problems.txt", "w");
     bp = fopen(".tcs/Base_Problems.txt", "r");
     fprintf(bbp, "%d%s", new_Count, "\n");
    for (int i = 0; i < new_Count; i++)
    {
        fscanf(bp, "%d", &count);
        fprintf(bbp, "%d%s", count, " ");
        for (int j = 0; j < count; j++)
        {
            fscanf(bp, "%d", &data);
            fprintf(bbp, "%d%s", data, " ");
        }
        fprintf(bbp, "%s", "\n");
    }
    fclose(bp); fclose(bbp);
    Copy_BP(false);

}

/*
    Ïðîõîäèòñÿ ïî ôàéëó BP è íàõîäèò ìàêñèìàëüíûé è ìèíèìàëüíûé ýëåìåíòû, è çàïè-
    ñûâàåò èõ(ò.å. ýòè çíà÷åíèÿ ìàêñèìóìà è ìèíèìóìà) â ïåðåìåííûå Min_in_BP and
    Max_in_BP. Ýòî íóæíî äëÿ Delete_range_in_BP.
*/

void Extremum_in_BP()
{
    FILE *f = fopen(".tcs/Base_Problems.txt", "r");
    int Min = inf, Max = -inf;
    int Count, count, data;
    fscanf(f, "%d", &Count);
    for (int i = 0; i < Count; i++)
    {
        fscanf(f, "%d", &count);
        for (int j = 0; j < count; j++)
        {
            fscanf(f, "%d", &data);
            if (data > Max) Max = data;
            if (data < Min) Min = data;
        }
    }
    if (Count) /// åñëè â BP åñòü õîòü ÷òî-òî, òî òîëüêî òîãäà ìåíÿåì
    {
    Min_in_BP = Min;
    Max_in_BP = Max;
    }
}

/*
    Ïðîèçâîäèò óäàëåíèå èç ôàéëà BP ïîñëåäîâàòåëüíî, îïðåäåëåííîãî ïîëüçîâàòåëåì,
    ñïèñêà íîìåðîâ. Áóäåò ðåàëèçîâûâàòüñÿ ñëåäóþùèì îáðàçîì:
    Ò.ê. ïîëüçîâàòåëü ìîæåò ââåñòè ñëèøêîì îãðîìíûé äèàïîçîí, òî ìû áóäåì äåëàòü
    âñå àêêóðàòíî: áóäåì ñìîòðåòü íà òå íîìåðà, êîòîðûå ââåë ïîëüçîâàòåëü, è åñëè
    íîìåðà âûõîäÿò çà ïðåäåëû ìàêñèìàëüíî è ìèíèìàëüíî âîçìîæíîãî â ôàéëå BP, òî
    ìû èãíîðèì îñòàòîê, ýòî äàñò íàì ïðåèìóùåñòâî â ñêîðîñòè ðàáîòû è îãðàäèò îò
    âîçìîæíîãî çàâèñàíèÿ ñèñòåìû.

*/
void Delete_range_in_BP()
{
    Extremum_in_BP(); /// îáíîâèëè ìèí è ìàêñ â ÂÐ
    int start, finish;
    while (true)
    {
       if (tip_encumbering) cout << "Input start number: ";
       cin >> start;
       if (tip_encumbering) cout << "Input finish number: ";
       cin >> finish;
       if (start < Min_in_BP || finish > Max_in_BP)
       {
           cout << "Are you sure, that is's correct? ";
           char s[15];
           cin >> s;
           if (!strcmp(s, "yes")) break;
       }
       else break;
    }
    if (start < Min_in_BP) start = Min_in_BP;
    if (finish > Max_in_BP) finish = Max_in_BP;
    int H[finish-start+2], q = 0;
    for ( ; start <= finish; start++)
        H[++q] = start;
    Delete_in_BP(H, q);
}

/*
    Åùå îäíà òàêàÿ æå ôóíêöèÿ, íî òóò óæå çàðàíåå èçâåñòíû çíà÷åíèÿ start and finish
    Îíè íå ïðîâåðÿþòñÿ íà êîððåêòíîñòü, èáî âûçîâ ïðîèçâîäèòñÿ âíóòðè ïðîãðàììû, à
    íå ïîëüçîâàòåëåì, òàê ÷òî îøèáîê çäåñü áûòü íå ìîæåò(ïîýòîìó íåò ïðîâåðêè
    êîððåêòíîñòè ââîäà start and finish).
*/

void Delete_range_in_BP(int start, int finish)
{
    if (start < Min_in_BP) start = Min_in_BP;
    if (finish > Max_in_BP) finish = Max_in_BP;
    int H[finish-start+2], q = 0;
    for ( ; start <= finish; start++)
        H[++q] = start;
    Delete_in_BP(H, q);
}

/*
    Ïðîèçâîäèò óäàëåíèå âñåõ çàäà÷ â ôàéëå BP.
*/

void delete_all_in_BP()
{
    Extremum_in_BP();
    Delete_range_in_BP(Min_in_BP, Max_in_BP);
}

void add_range_in_BP()
{
    Extremum_in_BP(); /// îáíîâèëè ìèí è ìàêñ â ÂÐ
    int start, finish;
    while (true)
    {
       if (tip_encumbering) cout << "Input start number: ";
       cin >> start;
       if (tip_encumbering) cout << "Input finish number: ";
       cin >> finish;
       if (start < 0) cout << "Not correct. Start number < 0. Try again\n";
       else if (finish > inf) cout << "Not correct. Finish number > inf. Try again\n";
       else break;
    }
  int H[finish-start+1], q = 0;
  for ( ; start <= finish; start++)
    H[q++] = start;
    Add_in_BP(H, q);
}

/*
    Ïðîèçâîäèò âûâîä çàäà÷, êîòîðûå áûëè ïîñëåäíèìè äîáàâëåíû â BP.
*/

void print_last_BP()
{
    FILE *f = fopen(".tcs/Base_Problems.txt", "r");
    int Count, count, data;
    fscanf(f, "%d", &Count);
    if (!Count) cout << "In the BP file there are no tasks\n\n";
    else
    {
         for (int i = 0; i < Count-1; i++)
         {
             fscanf(f, "%d", &count);
             for (int j = 0; j < count; j++)
             {
                 fscanf(f, "%d", &data);
             }
         }
         fscanf(f, "%d", &count);
         for (int j = 0; j < count; j++)
         {
             fscanf(f, "%d", &data);
             cout << data << " ";
         }
         cout << "\n\n";
    }
}

/*
    Âûâîäèò íà ýêðàí âñå ñîäåðæèìîå ôàéëà BP
*/

void print_BP()
{
    FILE *f = fopen(".tcs/Base_Problems.txt", "r");
    int Count, count, data;
    fscanf(f, "%d", &Count);
    if (!Count) cout << "BP file is empty\n";
    else
    {
    for (int i = 0; i < Count; i++)
    {
        fscanf(f, "%d", &count);
        for (int j = 0; j < count; j++)
        {
            fscanf(f, "%d", &data);
            cout << data << " ";
        }
    }
    }
    cout << "\n";
}

/*
    Âûâîäèò íà ýêðàí äèàïîçîí çàäà÷ èç BP. Ïðåèìóùåñòâî îòäàíî ïàìÿòè, ò.å. îíà
    ðàáîòàåò òàê: ïðîõîäèìñÿ ïî äèàïîçîíó(ïðè ýòî ïðîèçâåäÿ êîððåêòèðîâêó, ò.å.
    åñëè ïîëüçîâàòåëü ââåë ñëèøêîì áîëüøîé íîìåð, òî ìû êîððåêòèðóåì íà îñíîâå òîãî,
    ÷òî ìû çíàåì ìèí è ìàêñ â ôàéëå  BP (start >= Min_in_BP - âñåãäà, òîæå ñàìîå è
    ñ ìàêñèìóìîì). Ìû ïðîõîäèìñÿ ïî äèàïîçîíó è èùåì êàæäûé ýëåìåíò. Êàê âèäíî, ýòî
    äîëãî, íî çàòî, ìû íå âûäåëÿåì ìíîãî ïàìÿòè.
*/

void print_range_BP()
{
    Extremum_in_BP();
    int start, finish;
    if (tip_encumbering) cout << "Input start number: ";
    cin >> start;
    if (tip_encumbering) cout << "Input finish number: ";
    cin >> finish;
    if (start < Min_in_BP) start = Min_in_BP;
    if (finish > Max_in_BP) finish = Max_in_BP;
    bool flag = false; /// íóæåí, ÷òîáû âûâåñòè, åñòü ëè â äèàïîçîíå õîòü 1 ýëåìåíò
    for ( ; start <= finish; start++)
        if (search_in_BP(start, true) != -1) {cout << start << " "; flag = true; }
    if (!flag) cout << "This range in BP file is empty";
    cout << "\n";
}

void generation(int *F, int start, int finish, int concentration)
{
    int Acces_Problems[finish+2-start]; /// ìàññèâ äîñòóïíûõ çàäà÷
    int q = 0;
    for (int i = start; i <= finish; i++)
        if (bin_search(F, 1, Count+q_add, i) == -1) Acces_Problems[q++] = i;
        int count = q*concentration/100;
    for (int i = 1; i <= count; i++)
    {
        int a = rand()%q;
        Reserve[++Reserve_Size] = Acces_Problems[a];
    }
    Counting_Sort(Reserve, count);
    print(Reserve, 1, count);
}

bool Union(int *F, int number)
{
    int q = -1;
    for (int i = 1; i <= Reserve_Size; i++)
        if (Reserve[i] == number) {q = i; break;}

    if (q == -1) return false; /// ïîëüçîâàòåëü ââåë íåïðàâèëüíûé íîìåð, êîòîðîãî íåò
    //if (Count+q_add == 0) Count = 1;
     q_buff = q; /// äî ñþäà íóæíî ñ÷èòûâàòü èç ìàññèâà Reserve, ÷òîáû çàïèñàòü
     /// â áóôôåð(ñäåëàíî äëÿ òîãî, ÷òîáû êîä íå áûë íåïîíÿòíûì, à âñå ñòðóêòóðû
    /// øëè â ëîãè÷åñêîì ïîðÿäêå
     for (int i = 1; i <= q; i++)
    {
        if (bin_search(F, 1, Count+q_add, Reserve[i]) == -1)
        {
            F[Count+q_add] = Reserve[i]; q_add++;
            Counting_Sort(F, Count+q_add-1);
        }
    }
    return true;
}
/*
    ïðîèçâîäèò ñîõðàíåíèå äàííûõ â ôàéëå solve_problems
*/
void save(int *F)
{
    FILE *solve_problems = fopen(".tcs/solve_problems.txt", "w");
    fprintf(solve_problems, "%d%s", Count+q_add-1, "\n");
    for (int i = 1; i < Count+q_add; i++)
        fprintf(solve_problems, "%d%s", F[i], " ");
    fclose(solve_problems);
}

/*
    Âîññòàíàâëèâàåò äàííûå èç ôàéëà Back_Back_Up. Ïðè÷åì, åñëè count = -1, òî
    âîññòàíàâëèâàåò âñå. Åñëè íåò, ò.å. êàêîìó òî ïîëîæèòåëüíîìó ÷èñëó, òî
    âîññòàíàâëèâàåòñÿ âñå, äî ýòîé çàäà÷è âêëþ÷èòåëüíî.
    Âîçâðàùàåò true, åñëè òàêîé íîìåð íàéäåí è âñå ïðîøëî óñïåøíî, è false, åñëè òàêîãî íîìåðà íåò,
    èáî ïîëüçîâàòåëü ìîã ñëó÷àéíî îøèáèòüñÿ, ïîýòîìó åìó áóäåò äàíà åùå îäíà ïîïûòêà
*/

void Recover_Back_Back_Up(int *solve_problems)
{
    FILE *back_back_up = fopen(".tcs/Back_Back_Up.txt", "r");
    int key; int data; int count;
    fscanf(back_back_up, "%d", &key);
    fscanf(back_back_up, "%d", &count);
    if (count_Recover_Back_Back_Up == 0) /// âîññòàíàâëèâàåì âñ¸
    {
        if (key == 1)
        {
            for (int i = 0; i < count; i++)
            {
                fscanf(back_back_up, "%d", &data);
                Add(solve_problems, data);
            }
        }
        else if (key == 0)
        {
            for (int i = 0; i < count; i++)
            {
                fscanf(back_back_up, "%d", &data);
                Delete(solve_problems, data);
            }
        }
    }
    else
    {
        if (key == 1)
        {
            while (true)
            {
                fscanf(back_back_up, "%d", &data);
                Add(solve_problems, data);
                if (data == count_Recover_Back_Back_Up) break;
            }
        }
        else if (key == 0)
        {
            while (true)
            {
                fscanf(back_back_up, "%d", &data);
                Delete(solve_problems, data);
                if (data == count_Recover_Back_Back_Up) break;
            }
        }
    }
    save(solve_problems);
    fclose(back_back_up);
}

bool Recover_Back_Back_Up(int count1)
{

    if (count1 == 0) {flag_Recover_Back_Back_Up = true; count_Recover_Back_Back_Up = 0; return true;}
    if (count1 == -1) {flag_Recover_Back_Back_Up = false; return true;} /// ýòî çíà÷èò, ÷òî ïîëüçîâàòåëü íå õî÷åò âîññòàíàâëèâàòü
    FILE *back_back_up = fopen(".tcs/Back_Back_Up.txt", "r");
    int key; int count; fscanf(back_back_up, "%d", &key); int data;
    fscanf(back_back_up, "%d", &count);
    bool found = false;
    for (int i = 0; i < count; i++)
    {
        fscanf(back_back_up, "%d", &data);
        if (data == count1) {found = true; break;}
    }
    fclose(back_back_up);
    if (found) {count_Recover_Back_Back_Up = count1;
        flag_Recover_Back_Back_Up = true;return true;}
    flag_Recover_Back_Back_Up = false;
    return false;
}

/*
    Âîññòàíàâëèâàåò äàííûå èç ôàéëà Back_Up
*/
void Recover_Back_Up()
{
    FILE *back_up = fopen(".tcs/Back_Up.txt", "r");
    FILE *solve_problems = fopen(".tcs/solve_problems.txt", "w");
    int count; fscanf(back_up, "%d", &count);
    fprintf(solve_problems, "%d%s", count, "\n");
    int data;

    for (int i = 0; i < count; i++)
    {
        fscanf(back_up, "%d", &data);
        fprintf(solve_problems, "%d%s", data, " ");
    }
    fclose(back_up); fclose(solve_problems);
}

void Recover()
{
      FILE *back_up = fopen(".tcs/Back_Up.txt", "r");
    int key;
     fscanf(back_up, "%d", &key);
     if (key != -1)
     {
         while (true)
        {
         cout << "Do you want to restore data since the last run?: ";
         char command[20];
         cin >> command;
         if (!strcmp(command, "yes"))
         {
            Recover_Back_Up();
            break;
         }
         else if (!strcmp(command, "no")) break;
         else if (!strcmp(command, "print")) Print();
        }
     }
     cout << "\n";
     FILE *back_back_up = fopen(".tcs/Back_Back_Up.txt", "r");
     fscanf(back_back_up, "%d", &key);
     if (key != -1)
     {
         int count; fscanf(back_back_up, "%d", &count);
         int Back_Back_Up_Turn_Array[count+1];
         cout << "At the last start, you want";
         if (key == 1) cout << " add"; else if (key == 0) cout << " delete";
        cout <<  " these problems: \n";
         for (int i = 1; i <= count; i++)
         {
            fscanf(back_back_up, "%d", &Back_Back_Up_Turn_Array[i]);
            cout << Back_Back_Up_Turn_Array[i] << " ";
         }
         cout << "\nDo you want recover?: ";
         char command[20];
         cin >> command;
         while (true)
         {
             if (!strcmp(command, "yes"))
             {
                 cout << "How much?: ";
                 char command1[20];
                 cin >> command1;
                 if (!strcmp(command1, "all")) {Recover_Back_Back_Up(0);break;}
                 else if (!strcmp(command1, "stop"))
                    {
                        while (true)
                        {
                            int a;
                            cin >> a;
                            if (Recover_Back_Back_Up(a)) break;
                            cout << "This number not found. Try again. Input number: ";
                        }
                        break;
                    }
                    else if (!strcmp(command1, "exit")) break;
             }
             else if (!strcmp(command, "no")) break;
         }
     }
    cout << "\n";
}

void buffer_print()
{
    cout << "\n";
    FILE *buf = fopen(".tcs/Buffer.txt", "r");
    int data, Count, count, operation;
    fscanf(buf, "%d", &Count);
    if (!Count) cout << "Buffer is empty\n\n";
    else
    {
        for (int i = 0; i < Count; i++)
        {
            fscanf(buf, "%d%d", &count, &operation);
            if (operation == 1) cout << "add: ";
            else if (operation == -1) cout << "delete: ";
            for (int j = 0; j < count; j++)
            {
                fscanf(buf, "%d", &data);
                cout << data << " ";
            }
            cout << "\n";
        }
        cout << "\n\n";
    }
    fclose(buf);
}

/*
    Ïðîèçâîäèò ïåðâîíà÷àëüíóþ ïðîâåðêó(ñ ìîìåíòà çàïóñêà ïðîãðàììû) íà òî, î÷èùåí
    ëè áóôôåð èëè íåò. Åñëè íåò, òî âûâîäèòñÿ íà êîíñîëü ñîîáùåíèå ïîëüçîâàòåëþ,
    ÷òîáû îí âûáðàë, õî÷åò ëè îí, ÷òîáû áóôôåð ñîõðàíèëñÿ, èëè æå î÷èñòèòü åãî.
*/

void Recover_Buffer(int *Solve_Problems)
{
    FILE *buf = fopen(".tcs/Buffer.txt", "r");
    int data;
    fscanf(buf, "%d", &data);
    fclose(buf);
    if (data)
    {

    cout << "After the previous start, the buffer remained unclean\n";
    cout << "Do you want to clean it?\n";
    char Command[10];
    while (true)
    {
       if (tip_important) cout << "Buffer command: ";
       cin >> Command;
       if (!strcmp(Command, "no")) {Current_position = data; break;}
       else if (!strcmp(Command, "yes"))
       {
            buf = fopen(".tcs/Buffer.txt", "w");
            fprintf(buf, "%d", 0);
            fclose(buf);
            break;
       }
       else if (!strcmp(Command, "print")) buffer_print();
       else if (!strcmp(Command, "problems") || !strcmp(Command, "print_problems"))
       {
           if (Count+q_add-1 == 0) cout << "You have not solve problems\n";
        else cout << "You have " << Count+q_add-1 << " solve problems:\n Numbers: ";
        print(Solve_Problems, 1, Count+q_add-1);
       }
    }
    cout << "\n";
    }
}

/*
    Ïðîâåðÿåò, ñóùåñòâóåò ëè â äàííîé äèðåêòîðèè ôàéë ñ èìåíåì s.
    Åñëè äà, òî âîçâðàùàåò true, else return false.
*/

bool exists(char *s)
{
    FILE *f = fopen(s, "r");
    if (f == NULL) return false;
    return true;
}

/*
    Ïðîèçâîäèò èíèöèàëèçàöèþ ôàéëîâ. Ñîçäàåò íåîáõîäèìûå ôàéëû(Base_Problems, ...),
    ÷òîáû íå ïàðèòüñÿ íàñ÷åò ñîçäàíèÿ ôàéëîâ, à ïðîñòî çàïóñòèòü ïðîãðàììó, à îíà
    ñîçäàñò âñå íåîáõîäèìûå ôàéëû â äàííîé äèðåêòîðèè.
*/

void initialize()
{
    if (!exists(".tcs/solve_problems.txt"))
    {
        system("md .tcs");
        system("attrib +s +h .tcs");
        FILE *f = fopen(".tcs/solve_problems.txt", "w");
        fprintf(f, "%d", 0);
        fclose(f);
    }
    if (!exists(".tcs/Back_Up.txt"))
    {
        FILE *f = fopen(".tcs/Back_Up.txt", "w");
        FILE *g = fopen(".tcs/Back_Back_Up.txt", "w");
        fprintf(f, "%d", -1);
        fprintf(g, "%d", -1);
        fclose(f); fclose(g);
    }
    if (!exists(".tcs/Buffer.txt"))
    {
        FILE *f = fopen(".tcs/Buffer.txt", "w");
        FILE *g = fopen(".tcs/Buf_Buffer.txt", "w");
        fprintf(f, "%d", 0);
        fprintf(g, "%d", 0);
        fclose(f); fclose(g);
    }
    if (!exists(".tcs/Base_Problems.txt"))
    {
        FILE *f = fopen(".tcs/Base_Problems.txt", "w");
        FILE *g = fopen(".tcs/Base_Base_Problems.txt", "w");
        fprintf(f, "%d", 0);
        fprintf(g, "%d", 0);
        fclose(f); fclose(g);
    }
}

int main(){
    initialize(); ///ïðîèçâîäèì èíèöèàëèçàöèþ ôàéëîâ(ñîçäàåì íåîáõîäèìûå äëÿ ðàáîòû)
  Recover();

    FILE *solve_problems = fopen(".tcs/solve_problems.txt", "r");
    fscanf(solve_problems, "%d", &Count);
    int Size = max(Count*2, Min_Count);
    int Solve_Problems[Size+1];
    for (int i = 1; i <= Count; i++)
        fscanf(solve_problems, "%d", &Solve_Problems[i]);

    fclose(solve_problems);
    /*
         ïðîâåðÿåì, î÷èùåí ëè áóôôåð. Ýòî äåëàåòñÿ ïîñëå çàãðóçêè îñíîâíîãî ìàññèâà
         ðåøåííûõ çàäà÷, èáî:
         1. Ýòî ïîçâîëèò âûâåñòè ïîëüçîâàòåëþ íûíåøíþþ ñèòóàöèþ ñ çàäà÷àìè.
         2. Ýòî íèêàê íå ìåøàåò ïðîèçâîäèòåëüíîñòè ïðîãðàììû, èáî ýòîò ôàéë, â
         îòëè÷èè îò áýêàïà, íèêàê íå ìåíÿåò íûíåøíèé ìàññèâ, à ïðîñòî ñîõðàíÿåò
         ôàéë è íå î÷èùàåò åãî. Ïîýòîìó, òî, ÷òî ýòî ñäåëàíî ïîñëå çàãðóçêè
         îñíîâíîãî ìàññèâà, íèêàê íå ïðèíîñèò âðåä îïòèìèçàöèè ïðîãðàììû(åå ñêîðîñòè
         èëè îáúåìó èñïîëüçóåìîé ïàìÿòè), à, íàîáîðîò, óâåëè÷èâàåò þçàáèëèòè,
         èáî ïîëüçîâàòåëþ òàê áóäåò óäîáíåå, à ýòî ãëàâíîå!
    */
Recover_Buffer(Solve_Problems);

    if (flag_Recover_Back_Back_Up) Recover_Back_Back_Up(Solve_Problems); /// âîññòàíàâëèâàåì èç ôàéëà BBUp
    Back_Back_Up(Solve_Problems, -1, true);
char Command[15];


while (true){
       if (tip_important) cout << "Command: ";
    cin >> Command;
    if (!strcmp(Command, "go"))
    {
        int start, finish, concentration;
       if (tip_important) cout << "Input start number: "; cin >> start;
       if (tip_important) cout << "Input finish number: "; cin >> finish;
       if (tip_important) cout << "Input concentration: "; cin >> concentration;
        generation(Solve_Problems, start, finish, concentration);
        Back_Back_Up(Reserve, Reserve_Size, true);
        while (true)
        {
            cout << "What do you think?: ";
        char Command1[15];
        cin >> Command1;
        if (!strcmp(Command1, "ok"))
            {
            Union(Solve_Problems, Reserve[Reserve_Size]);
            Back_Up(Solve_Problems);
            Buffer_Save(Reserve, Reserve_Size, 1); /// äîáàâëÿåì â áóôôåð
            Back_Back_Up(Reserve, -1, true);
            Delete_in_BP(Reserve, Reserve_Size); /// óäàëÿåì èç BP òî, ÷òî äîáàâëåíî
            /// â ðåøåííûå
            break;
            }
        else if (!strcmp(Command1, "stop"))
        {
            while (true)
            {
                if (tip_encumbering) cout << "Input number: ";
                int number;
                cin >> number;
          if (number == -1) break;
                if (Union(Solve_Problems, number) == true) break;
            }
            Back_Up(Solve_Problems);
            /*
             äîáàâëÿåì â ôàéë Buffer äî q_buff, êîòîðûé ðàâåí â ìàññèâå Reserve,
            íîìåðó, íà êîòîðîì ïîëüçîâàòåëü ðåøèë îñòàíîâèòüñÿ
            */
            Buffer_Save(Reserve, q_buff, 1);
            Back_Back_Up(Reserve, -1, true); /// î÷èñòêà ôàéëà Back_Back_Up
             Delete_in_BP(Reserve, q_buff);/// óäàëÿåì èç BP òî, ÷òî äîáàâëåíî
            /// â ðåøåííûå
            break;
        }
         else if (!strcmp(Command1, "exit") || !strcmp(Command1, "break")) break;
         else if (!strcmp(Command1, "save"))
          {
            char Command2[30];
            cin >> Command2;
            if (!strcmp(Command2, "all"))
            {
                Save_in_BP(Reserve, Reserve_Size, Reserve[1], Reserve[Reserve_Size]);
            }
            else if (!strcmp(Command2, "stop"))
            {
                int number; cin >> number;
                int q = -1;
                for (int i = 1; i <= Reserve_Size; i++)
                    if (Reserve[i] == number) {q = i; break;}
                    q_buff = q;
                Save_in_BP(Reserve, Reserve_Size, Reserve[1], Reserve[q_buff]);
            }
            else if (!strcmp(Command2, "diap"))
            {
                int start, finish;
                while (true)
                {
                    cin >> start >> finish;
                    if (start == -1) break;
                    if (start < 0 || start > finish || finish > inf)
                        cout << "Not correct. Try again\nInput: ";
                    else break;
                }
                Save_in_BP(Reserve, Reserve_Size, start, finish);
            }
          }
        }
        Reserve_Size = 0;
    }
    else if (!strcmp(Command, "add"))
    {
        int count;
        cin >> count;
        int back_back_up[count+1];
        int s[2];
       if (tip_encumbering) cout << "Input numbers: ";
        for (int i = 1, numbers; i <= count; i++)
            {cin >> numbers;
            s[1] = numbers;
            back_back_up[i] = numbers;
            Add_Buffer(Solve_Problems, s, 1, 1); /// äîáàâëÿåì â áóôôåð
            Add(Solve_Problems, numbers);
            Back_Back_Up(back_back_up, i, true);
            Delete_in_BP(s, 1); /// óäàëÿåì èç BP ðåøåííóþ çàäà÷ó(äîëãî ïî âðåìåíè)
            }

        Back_Up(Solve_Problems);
       /// Buffer_Save(back_back_up, count, 1);
        Back_Back_Up(back_back_up, -1, true); /// ñòèðàåì ôàéë Back_Back_Up
    }
    else if (!strcmp(Command, "delete"))
    {
        int count;
        cin >> count;
        int back_back_up[count+1];
        int s[2];
        if (tip_encumbering) cout << "Input numbers: ";
        for (int i = 1, numbers; i <= count; i++)
            {cin >> numbers;
            s[1] = numbers;
            back_back_up[i] = numbers;
            Add_Buffer(Solve_Problems, s, 1, -1); /// äîáàâëÿåì â áóôôåð
            Delete(Solve_Problems, numbers);
                Back_Back_Up(back_back_up, i, false);}

            //Counting_Sort(Solve_Problems, Count+q_add-1);
        Back_Up(Solve_Problems);
        ///Buffer_Save(back_back_up, count, -1);
        Back_Back_Up(back_back_up, -1, true); /// î÷èùàåì ôàéë Back_Back_Up
    }
    else if (!strcmp(Command, "exit"))
    {
        break;
    }
    else if (!strcmp(Command, "print"))
    {
        if (Count+q_add-1 == 0) cout << "You have not solve problems\n";
        else cout << "You have " << Count+q_add-1 << " solve problems:\n Numbers: ";
        print(Solve_Problems, 1, Count+q_add-1);
    }
    else if (!strcmp(Command, "delete_all"))
        {
            /*
                ãîâîðèì, ÷òî óäàëÿåì âñå, è çàïèñûâàåì ýòî â áóôôåð
            */
            Buffer_Save(Solve_Problems, Count+q_add-1, -1);

            Count = 0;
            q_add = 1;
            Back_Up(Solve_Problems);
        }
    else if (!strcmp(Command, "print:") || !strcmp(Command, "print_range"))
    {
        print_range(Solve_Problems, Count+q_add-1);
    }
    else if (!strcmp(Command, "tip")) tip_install();
    else if (!strcmp(Command, "delete:") || !strcmp(Command, "delete_range"))
    {
        delete_range(Solve_Problems);
        Back_Up(Solve_Problems);
    }
    else if (!strcmp(Command, "add:") || !strcmp(Command, "add_range"))
    {
        add_range(Solve_Problems);
        Back_Up(Solve_Problems);
    }
    else if (!strcmp(Command, "back")) Buffer_overwrite(Solve_Problems, 1);
    else if (!strcmp(Command, "next")) Buffer_overwrite(Solve_Problems, 0);
    else if (!strcmp(Command, "cur")) cout << Current_position << "\n";
    else if (!strcmp(Command, "clear") || !strcmp(Command, "cls"))
    {
        system("cls");
    }
    else if (!strcmp(Command, "buf_clear") || !strcmp(Command, "buf_cls"))
    {
        FILE *buf = fopen(".tcs/Buffer.txt", "w");
        fprintf(buf, "%d", 0);
        fclose(buf);
    }
    else if (!strcmp(Command, "buf_print")) buffer_print();
    else if (!strcmp(Command, "tip_print")) tip_print();
    else if (!strcmp(Command, "copy_bp")) Copy_BP(true);
    else if (!strcmp(Command, "add_bp"))
    {
        int count;
        cin >> count;
        int H[count];
       if (tip_encumbering) cout << "Input numbers: ";
        for (int i = 0; i < count; i++)
            cin >> H[i];
        Add_in_BP(H, count);
    }
    else if (!strcmp(Command, "search_bp"))
    {
        if (tip_encumbering) cout << "Input number: ";
        int key;
        cin >> key;
        cout << search_in_BP(key, true) << "\n\n";
    }
    else if (!strcmp(Command, "delete_bp"))
    {
        int count;
        cin >> count;
        int H[count+1];
        if (tip_encumbering) cout << "Input numbers: ";
        for (int i = 0; i < count; i++)
            cin >> H[i+1];
        Delete_in_BP(H, count);
    }
    else if (!strcmp(Command, "delete_bp:"))
    {
        Delete_range_in_BP();
    }
    else if (!strcmp(Command, "add_bp:"))
    {
        add_range_in_BP();
    }
    else if (!strcmp(Command, "print_bp")) print_BP();
    else if (!strcmp(Command, "print_bp:")) print_range_BP();
    else if (!strcmp(Command, "print_last_bp")) print_last_BP();
    else if (!strcmp(Command, "delete_all_bp")) delete_all_in_BP();
    else if (!strcmp(Command, "bp"))
    {
        cout << "\n";
        char Command1[40];
        while (true)
        {
            if (tip_important) cout << "BP command: ";
            cin >> Command1;
            if (!strcmp(Command1, "copy")) Copy_BP(true);
            else if (!strcmp(Command1, "add"))
            {
                int count;
                cin >> count;
                int H[count];
                if (tip_encumbering) cout << "Input numbers: ";
                for (int i = 0; i < count; i++)
                    cin >> H[i];
                Add_in_BP(H, count);
            }
            else if (!strcmp(Command1, "search"))
            {
                if (tip_encumbering) cout << "Input number: ";
                int key;
                cin >> key;
                cout << search_in_BP(key, true) << "\n\n";
            }
            else if (!strcmp(Command1, "delete"))
            {
                int count;
                cin >> count;
                int H[count+1];
                if (tip_encumbering) cout << "Input numbers: ";
                for (int i = 0; i < count; i++)
                    cin >> H[i+1];
                Delete_in_BP(H, count);
            }
            else if (!strcmp(Command1, "delete:"))  Delete_range_in_BP();
            else if (!strcmp(Command1, "delete_all")) delete_all_in_BP();
            else if (!strcmp(Command1, "add:")) add_range_in_BP();
            else if (!strcmp(Command1, "print")) print_BP();
            else if (!strcmp(Command1, "print:")) print_range_BP();
            else if (!strcmp(Command1, "print_last")) print_last_BP();
            else if (!strcmp(Command1, "help")) help_BP();
            else if (!strcmp(Command1, "exit")) break;
            else if (!strcmp(Command1, "cls") || !strcmp(Command1, "clear"))
            {
                system("cls");
            }
        }
    }
}

    solve_problems = fopen(".tcs/solve_problems.txt", "w");
    fprintf(solve_problems, "%d%s", Count+q_add-1, "\n");
    for (int i = 1; i < Count + q_add; i++)
        fprintf(solve_problems, "%d%s", Solve_Problems[i], " ");

    FILE *back_up = fopen(".tcs/Back_Up.txt", "w");
    fprintf(back_up, "%d", -1);
    back_up = fopen(".tcs/Back_Back_Up.txt", "w");
    fprintf(back_up, "%d", -1);
    back_up = fopen(".tcs/Buffer.txt", "w");
    fprintf(back_up, "%d", 0);

    return 0;
}