Fikes

template <typename T>
typename T::size_type levenshtein_distance(const T & src, const T & dst)
{
    const typename T::size_type m = src.size();
    const typename T::size_type n = dst.size();
    if (m == 0)
    {
        return n;
    }
    if (n == 0)
    {
        return m;
    }

    std::vector<std::vector<typename T::size_type>> matrix(m + 1);

    for (typename T::size_type i = 0; i <= m; ++i)
    {
        matrix[i].resize(n + 1);
        matrix[i][0] = i;
    }
    for (typename T::size_type i = 0; i <= n; ++i)
    {
        matrix[0][i] = i;
    }

    typename T::size_type above_cell, left_cell, diagonal_cell, cost;

    for (typename T::size_type i = 1; i <= m; ++i)
    {
        for (typename T::size_type j = 1; j <= n; ++j)
        {
            cost = src[i - 1] == dst[j - 1] ? 0 : 1;
            above_cell = matrix[i - 1][j];
            left_cell = matrix[i][j - 1];
            diagonal_cell = matrix[i - 1][j - 1];
            matrix[i][j] = std::min(std::min(above_cell + 1, left_cell + 1), diagonal_cell + cost);
        }
    }

    return matrix[m][n];
}

string make_path(string str)
{
    string extension = "";
    unsigned int j;
    if (str.length() >= 4)
    {
        j = str.length() - 4;
        for (int i = 0; i < 4; i++)
        {
            extension.push_back(str[j]);
            j++;
        }
    }
    if (extension == ".txt")
        str = "Books/" + str;
    else
        str = "Books/" + str + ".txt";
    return str;
}

void filling_strings(vector<string>& vec)
{
    unsigned int max_l = 0;
    for (unsigned int i = 0; i < vec.size(); i++)
    {
        if (vec[i].length() > max_l)
            max_l = vec[i].size();
    }
    for (unsigned int i = 0; i < vec.size(); i++)
    {
        while (vec[i].length() < max_l)
            vec[i].push_back(' ');
    }
}

string shorting_string(string str)
{
    while (str[str.length() - 1] == ' ')
        str.pop_back();
    return str;
}

string vec_search(const vector<string>& vec, const string& str)
{
    unsigned int i = 0, k = 0, dist = 100;
    while (k < vec.size())
    {
        if (levenshtein_distance(vec[k], str) < dist)
        {
            dist = levenshtein_distance(vec[k], str);
            i = k;
        }
        k++;
    }
    return vec[i];
}

bool empty(const string& str)
{
    bool empty = true;
    if (!str.empty())
    {
        for (unsigned int i = 0; i < str.length(); i++)
        {
            if (str[i] != ' ')
            {
                empty = false;
            }
        }
    }
    return empty;
}

void files(vector<string>& vec)
{
    for (auto p : directory_iterator("Books"))
    {
        vec.push_back(p.path().string());
    }
    filling_strings(vec);
}

void check_files(vector<string>& vec)
{
    unsigned int i;
    vector<string> vec_2;
    bool same_name = true;
    for (auto p : directory_iterator("Books"))
    {
        vec_2.push_back(p.path().string());
    }
    filling_strings(vec_2);
    if (vec_2.size() != vec.size())
    {
        vec.clear();
        vec = vec_2;
        filling_strings(vec);
    }
    else
    {
        if (vec.size() > vec_2.size())
            i = vec_2.size();
        else
            i = vec.size();
        for (unsigned j = 0; j < i; j++)
        {
            if (vec[j] != vec_2[j])
            {
                vec = vec_2;
                return;
            }
        }
    }
}