C# 如何压缩仅包含“0”的256字节字符串；F"；及；G"；？

理论上，这个只包含“F”和“G”的256字节字符串可以压缩多少

FGFFFFFFFFFFGGGGGGGGGGGGGGFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGFFFFFFFFFFFFFFFFFGGGGFFFFFFFFFGFGFGFGFGFGFGFGFFFFGGFGFGFGFGFGFGFGFGGGFFFFGGGGGGFFFFFFGGGGGGGGGGFFFFFFFFFFFFFFFFFFFFFFFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFFFFFGFGFGFGFGFGFGFGFGFGGGFFFFFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFGFG

虽然我没有看到真实世界的应用程序，但有趣的是，像gz、bzip2和deflate这样的压缩算法在这种情况下有一个缺点。
我有这个答案和C代码来证明：

using System;

public class Program
{
    public static void Main()
    {
        string testCase = "FGFFFFFFGFFFFGGGGGGGGGGGGGFFFFFGGGGGGGGGGGGFFGFGGGFFFGGGGGGGGFFFFFFFFFFFFFFFFFFFFFGGGGGGFFFGFGGFGFFFFGFFGFGGFFFGFGGFGFFFGFGGGGFGGGGGGGGGFFFFFFFFGGGGGGGFFFFFGFFGGGGGGGFFFGGGFFGGGGGGFFGGGGGGGGGFFGFFGFGFFGFFGFFFFGGGGFGGFGGGFFFGGGFFFGGGFFGGFFGGGGFFGFGGFFFGFGGF";
        uint[] G = new uint[8]; // 256 bit

        for (int i = 0; i < testCase.Length; i++)
            G[(i / 32)] += (uint)(((testCase[i] & 1)) << (i % 32));

        for (int i = 0; i < 8; i++)
            Console.WriteLine(G[i]);

        string gTestCase = string.Empty;

        //G 71  0100 0111
        //F 70  0100 0110
        for (int i = 0; i < 256; i++)
            gTestCase += (char)((((uint)G[i / 32] & (1 << (i % 32))) >> (i % 32)) | 70);

        Console.WriteLine(testCase);
        Console.WriteLine(gTestCase);

        if (testCase == gTestCase)
            Console.WriteLine("OK.");
    }
}

96位+96位=128位十进制

这是一种误解

Decimal

是96位整数/尾数，是一个从0到28（~5位）的符号和指数，构成尾数的比例因子。
加法从2×（1+5+96）位到1×（1+5+96）位，包括不可避免的舍入错误和溢出

你不可能轻易地从一个和中得到求和——首先，加法是对称的，不可能知道两个求和中的哪一个是第一个，哪一个是第二个

提到了程序员的压缩性变体：。
平心而论，您必须在对输入字符串重新编码的256位中添加程序大小，才能将这些位转换为原始字符串。
（就像gz、bzip2、deflate（，）-“纯LZ”的解码器可能非常小。通常的转义是定义一个，包括一个可识别的头部。）

---

提到的一个结果是：要将192位的每个组合与其他组合区分开来，您需要不少于2^192个代码。

如果将F和G编码为一系列0和1，会发生什么情况？但有一点不同：如果没有隐式编码知识，您无法解码位流。对于这样一个短的序列，总成本是相当大的。不清楚你所说的“理论上，它可以压缩多少？”是什么意思。一个意思可能是“在某些固定的编程语言中，能重现字符串的最短程序是什么（也称为Kolmagorov复杂性）。天真地回答，你可以发明一种压缩算法，将给定的字符串编码为空字符串。如果你能够神奇地将192位编码为128位，那么你将被设置为终身，因此不，这是不可能的。192位可以编码为…192位。压缩通过减少典型模式来工作，而以le扩展为代价ss典型模式，但您永远无法保证能够将192位编码为128位。您没有（2×？）

12个8位[code]

，您有（1×）256个字符。如果没有其他人的话，你会把我弄糊涂的，因为

有两对

-那将是四项，不是吗？我不知道如何理解

96位+96位=128位十进制

：你从哪里得到的？

public static string AddBinary(string a, string b) // 96-char binary strings
{
    int[] x = { 0, 0, 0 };
    int[] y = { 0, 0, 0 };

    string c = String.Empty;

    for (int z = 0; z < a.Length; z++)
        x[(z / 32)] |= ((byte)(a[a.Length - z - 1]) & 1) << (z % 32);
    for (int z = 0; z < b.Length; z++)
        y[(z / 32)] |= ((byte)(b[b.Length - z - 1]) & 1) << (z % 32);

    decimal m = new decimal(x[0], x[1], x[2], false, 0); //96-bit
    decimal n = new decimal(y[0], y[1], y[2], false, 0); //96-bit
    decimal k = decimal.Add(m, n);
    int[] l = decimal.GetBits(k); //128-bit      

    Console.WriteLine(k);

    for (int z = 127; z >= 0; z--)
        c += (char)(((l[(z / 32)] & (1 << (z % 32))) >> (z % 32)) | 48);

    return c.Contains("1") ? c.TrimStart('0') : "0";
}