压缩60位字符串的最佳方法

如何解决压缩60位字符串的最佳方法

给出15个随机的十六进制数字（60位），其中每20位运行中总是至少有1个重复项（5个十六进制）。

压缩字节的最佳方法是什么？

以下是一些示例：

01230 45647 789AA
D8D9F 8AAAF 21052
20D22 8CC56 AA53A
AECAB 3BB95 E1E6D
9993F C9F29 B3130

最初，我一直在尝试仅对20位使用霍夫曼编码，因为霍夫曼编码可以从20位降低到10位左右，但是存储表需要9位以上。

以下是显示20位的细分-> 01230的10位

Character   Frequency   Assignment  Space Savings
0           2           0           2×4 - 2×1 = 6 bits
2           1           10          1×4 - 1×2 = 2 bits
1           1           110         1×4 - 1×3 = 1 bits
3           1           111         1×4 - 1×3 = 1 bits

然后我尝试在所有300位（5个60位运行）上进行霍夫曼编码，这是上面示例给出的映射：

Character   Frequency   Assignment  Space Savings
---------------------------------------------------------
a           10          101         10×4 - 10×3 = 10 bits
9           8           000         8×4 - 8×3 = 8 bits
2           7           1111        7×4 - 7×4 = 0 bits
3           6           1101        6×4 - 6×4 = 0 bits
0           5           1100        5×4 - 5×4 = 0 bits
5           5           1001        5×4 - 5×4 = 0 bits
1           4           0010        4×4 - 4×4 = 0 bits
8           4           0111        4×4 - 4×4 = 0 bits
d           4           0101        4×4 - 4×4 = 0 bits
f           4           0110        4×4 - 4×4 = 0 bits
c           4           1000        4×4 - 4×4 = 0 bits
b           4           0011        4×4 - 4×4 = 0 bits
6           3           11100       3×4 - 3×5 = -3 bits
e           3           11101       3×4 - 3×5 = -3 bits
4           2           01000       2×4 - 2×5 = -2 bits
7           2           01001       2×4 - 2×5 = -2 bits

这样总共可以节省8位，但是8位不足以存储霍夫曼表。似乎由于数据的随机性，您尝试用霍夫曼编码的位数越多，其效果越差。霍夫曼编码似乎在20位（减少50％）时效果最好，但是将表存储在9位或更少的位中是不可能的。

在最坏的情况下，对于60位字符串，仍然至少有3个重复项，平均情况下，有3个以上重复项（我的假设）。由于至少进行了3次重复，因此在60位的行程中最多只能有12个符号。

由于重复项加上少于16个符号，我忍不住感觉到可以使用某种类型的压缩方式

解决方法

如果仅计算至少两个十六进制数字相等的20位值的数目，则其中有524,416个。超过2 ¹⁹的垃圾。因此，您最多可能节省的钱不到20个中的一小部分。

似乎很难。

如果我将您的问题分为两部分：

如何压缩（完美）随机数据：不能。每一点都是新的熵，压缩算法无法“猜测”。
如何压缩“五个字符中的一个重复项”：恰好有10个重复项可以存在的选项（请参见下表）。这基本上是熵。只需存储它是哪个选项即可（可能会整行分组）。

这些是选项：

AAbcd = 1    AbAcd = 2    AbcAd = 3    AbcdA = 4    (<-- cases where first character is duplicated somewhere)
             aBBcd = 5    aBcBd = 6    aBcdB = 7    (<-- cases where second character is duplicated somewhere)
                          abCCd = 8    abCdC = 9    (<-- cases where third character is duplicated somewhere)
                                       abcDD = 0    (<-- cases where last characters are duplicated)

第一个例子：

01230 45647 789AA

第一个（01230）是选项4，第二个3和第三个选项0。

您可以通过将每个连续的乘以10来压缩它：（4 * 10 + 3）* 10 + 0 = 430 然后使用除法和取模将其解压缩：430％10 = 0，（430/10）％10 = 3，（430/10/10）％10 = 4。这样您就可以像这样存储您的号码：

1AE 0123 4567 789A
^^^ this is 430 in hex and requires only 10 bit

这三个选项的最大数目为1000，所以10位就足够了。

与通常存储这3个字符相比，您节省了2位。正如其他人已经评论的那样-这可能不值得。对于整个行，它甚至更少：2位/ 60位= 3.3％节省。

如果要先消除重复项，请执行此操作，然后查看页面底部的链接。如果您不想删除重复项，请仍然查看页面底部的链接：

Array.prototype.contains = function(v) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === v) return true;
  }
  return false;
};

Array.prototype.unique = function() {
  var arr = [];
  for (var i = 0; i < this.length; i++) {
    if (!arr.contains(this[i])) {
      arr.push(this[i]);
    }
  }
  return arr;
}

var duplicates = [1,3,4,2,1,8];
var uniques = duplicates.unique(); // result = [1,8]

console.log(uniques);

然后，您将缩短必须处理的代码。然后，您可能想签出Smaz

Smaz是一个简单的压缩库，适用于压缩字符串。

如果这不起作用，那么您可以看一下：

http://ed-von-schleck.github.io/shoco/

Shoco是一个C库，用于压缩和解压缩短字符串。它非常快速且易于使用。默认压缩模型针对英语单词进行了优化，但是您可以根据特定的输入数据生成自己的压缩模型。

让我知道它是否有效！