Kompresja algorytmem LZ78

void compress(const string& filein, const string& fileout) {
	map<string, int> dict; int n = 1; string c{ "" }, result{}, content{}, line{}, przec{ "," };
	dict[""] = 0;
	ofstream wyj(fileout, ios::out);
	ifstream inp(filein, ios::in);
	if (!inp.good()) {
		cout << "Something wrong";
		return;
	}
	while (getline(inp, line)) {
		for (string::iterator it = line.begin(); it != line.end(); ++it) {
			if (!dict.count(c + *it)) {
				if (c == "") {
					content = *it;
					result += "(0" + przec + content + ")";
					dict.insert({ content, n });
				}
				else {
					content = *it;
					string x = to_string(dict[c]);
					result += '(' + x + przec + content + ')';
					dict.insert({ c + content,n });
					c = "";
				}
				n++;
			}
			else {
				c += *it;
				if (it == line.end() - 1) {
					//string x(c); //string x(1, *it);
					result+='(' + to_string(dict[c]) + przec + ')';  //dict[x]
					c = "";
				}
			}
		}
		wyj << result;
		result = "";
		wyj << endl;
	}
	inp.close();
	wyj.close();
}

void decompress(const string& filein, const string& fileout) {
	map<int, string> dict; int n = 1; string result{}, temp{}, line{};
	dict[0] = "";
	const std::regex reg(R"((\d+),(.{1}))");
	std::pair<int, char> com{};
	ofstream wyj(fileout);
	ifstream inp(filein, ios::in);
	if (!inp.good()) {
		cout << "Something wrong"; return;
	}
	while (getline(inp, line)) {
		for (std::smatch sm; std::regex_search(line, sm, reg); line = sm.suffix()) {
			com = { std::stoi(sm.str(1)), sm.str(2)[0] };
			if (com.first == 0) {
				dict[n] = com.second;
				result += com.second;
				n++;
			}
			else if (com.second == ')') {
				result += dict[com.first];
			}
			else {
				auto search = dict.find(com.first);
				temp += search->second + com.second;
				result += temp;
				dict[n] = temp;
				temp = "";
				n++;
			}
			
		}
		wyj << result;
		wyj << endl;
		result = "";
	}
	inp.close();
	wyj.close();
}

void compress(const string& filein, const string& fileout) {
    // Tworzymy mapę oraz inne potrzebne zmienne
    map<string, int> dict;
    int n = 1;
    string c{ "" }, result{}, content{}, line{};
    dict[""] = 0;
    // Otwieramy plik wyjściowy jako binarny
    ofstream wyj(fileout, ios::binary);
    ifstream inp(filein, ios::in);
    if (!inp.good()) {
        cout << "Something wrong";
        return;
    }
    while (getline(inp, line)) {
        for (string::iterator it = line.begin(); it != line.end(); ++it) {
            if (!dict.count(c + *it)) {
                if (c == "") {
                    content = it;
                    // Konwertujemy indeks na binarny i zapisujemy do pliku
                    int index = dict[content];
                    wyj.put((char)index);
                    // Dodajemy nowy ciąg do słownika
                    dict.insert({ content, n });
                }
                else {
                    content = it;
                    int index = dict[c];
                    wyj.put((char)index);
                    wyj.put(*it);
                    dict.insert({ c + content,n });
                    c = "";
                }
                n++;
            }
            else {
                c += *it;
                if (it == line.end() - 1) {
                    int index = dict[c];
                    wyj.put((char)index);
                    c = "";
                }
            }
        }
    }
    inp.close();
    wyj.close();
}

namespace LZ78 {
using count_t = unsigned int;

struct EncodedItem {
    EncodedItem(count_t index,
        char ch)
        : index { index }
        , ch { ch }
    {
    }

    count_t index;
    char ch;
};

using EncodedItems = std::vector<EncodedItem>;

class Encoder {
    std::unordered_map<std::string, count_t> dic { { {}, 0 } };
    size_t n = 1;
    std::string c;
    EncodedItems result;

public:
    void add(char s)
    {
        auto newC = c + s;
        if (dic.count(newC)) {
            c = newC;
        } else {
            result.emplace_back(dic[c], s);
            dic[newC] = n++;
            c = "";
        }
    }

    void add(std::string_view s)
    {
        for (auto ch : s) {
            add(ch);
        }
    }

    EncodedItems itemResult() const
    {
        auto r = result;
        if (!c.empty()) {
            r.emplace_back(dic.at(c.substr(0, c.size() - 1)), c.back());
        }
        return r;
    }
};

class Decoder {
    std::unordered_map<count_t, std::string> dic { { 0, {} } };
    size_t n = 1;
    std::string result;

    void append(std::string_view s)
    {
        result.append(s);
    }

    void append(char s)
    {
        append(std::string_view(&s, 1));
    }

public:
    void add(const EncodedItem& data)
    {
        dic[n] = dic[data.index] + data.ch;
        append(dic[n]);
        ++n;
    }

    void add(const EncodedItems& encoded)
    {
        for (auto item : encoded) {
            add(item);
        }
    }

    std::string str() const
    {
        return result;
    }
};

unsigned oldesBit(unsigned x)
{
    unsigned r = 0;
    while (x) {
        ++r;
        x >>= 1;
    }
    return r;
}

namespace detail {
    unsigned char minumumBytesPerIndex(const EncodedItems& items)
    {
        if (items.empty())
            return 0;
        auto max_index = max_element(begin(items), end(items), [](const EncodedItem& a, const EncodedItem& b) {
            return a.index < b.index;
        })->index;
        return std::max(1u, (oldesBit(max_index) + 7) / 8);
    }

    void writeIndexUsingNrOfBytes(std::ostream& out, unsigned index, unsigned byteCount)
    {
        while (byteCount--) {
            out.put(static_cast<char>(index & 0xff));
            index >>= 8;
        }
    }
}

void toBinary(std::ostream& out, const EncodedItems& items)
{
    using namespace detail;
    auto bytesPerIndex = minumumBytesPerIndex(items);
    out.put(bytesPerIndex);

    for (const auto& item : items) {
        writeIndexUsingNrOfBytes(out, item.index, bytesPerIndex);
        out.put(item.ch);
    }
}

namespace detail {
    std::istream& readIndexUsingNrOfBytes(std::istream& in, unsigned& index, unsigned byteCount)
    {
        index = 0;
        while (byteCount--) {
            char ch;
            in.get(ch);
            index = (index << 8) + static_cast<unsigned char>(ch);
        }
        return in;
    }
}

void fromBinary(std::istream& in, EncodedItems& items)
{
    using namespace detail;
    char bytesPerIndex;
    items.clear();
    if (in.get(bytesPerIndex) && bytesPerIndex) {
        EncodedItem item { 0, 0 };
        while (readIndexUsingNrOfBytes(in, item.index, bytesPerIndex)) {
            char ch;
            if (in.get(ch)) {
                item.ch = ch;
            } else {
                item.ch = {};
            }
            items.push_back(item);
        }
    }
}
}