Сжатие больших целых чисел в наименьшую возможную строку

Ответ 1

Да. GZIP - это алгоритм сжатия, который требует сжимаемых данных и имеет накладные расходы (кадрирование и словари и т.д.). Вместо этого следует использовать алгоритм кодирования.

"Простой" метод заключается в использовании кодировки base-64.

То есть, преобразуйте число (которое представлено в качестве основы 10 в строке) к фактической серии байтов, которые представляют число (5 байтов будут содержать десятизначное десятичное число), а затем результат base-64. Каждый символ base-64 хранит 6 бит информации (до десятичных знаков ~ 3.3 бит/символ) и, таким образом, приводит к размеру примерно чуть более половины (в этом случае требуются выходные символы 6 * base-64).

Кроме того, поскольку длины ввода/вывода могут быть получены из самих данных, "123" может быть изначально (до кодирования с базой 64), преобразованного как 1 байт, "30000" как 2 байта и т.д. Это было бы выгодно если не все числа примерно одинаковой длины.

Счастливое кодирование.

* Использование base-64 требует 6 выходных символов.

Изменить: я ошибался вначале, когда я сказал "2.3 бит / char" для десятичного числа и предложил, чтобы было меньше половины символов. Я обновил ответ выше и покажу математику (должен быть правильной) здесь, где lg(n) зарегистрирован на базе 2.

Количество входных битов, необходимых для представления входного номера, составляет bits/char * chars → lg(10) * 10 (или просто lg(9999999999)) → ~33.2 bits. Используя jball-манипуляцию, чтобы сначала сдвинуть номер, требуется количество бит: lg(8999999999) → ~33.06 bits. Однако это преобразование не способно повысить эффективность в этом конкретном случае (количество входных бит должно быть уменьшено до 30 или ниже, чтобы иметь здесь значение).

Итак, мы пытаемся найти x (количество символов в кодировке base-64), чтобы:

lg(64) * x = 33.2 → 6 * x = 33.2 → x ~ 5.53. Конечно, пять с половиной символов бессмысленно, поэтому мы выбираем 6 как максимальное количество символов, необходимых для кодирования значения до 999999999 в кодировке base-64. Это немного больше, чем половина из 10 символов.

Однако следует отметить, что для получения только 6 символов в выводе base-64 требуется нестандартный кодер base-64 или немного манипуляции (большинство кодов base-64 работают только на целых байтах). Это работает, потому что из исходных 5 "обязательных байтов" используется только 34 из 40 бит (верхние 6 бит всегда равны 0). Для кодирования всех 40 бит потребуется 7 символов base-64.

Ниже приведена модификация кода, который Guffa опубликовал в своем ответе (если вам это нравится, попробуйте дать ему голосование), для которого требуется только 6 символов base-64. См. Другие примечания в ответе Гуффа и Base64 для приложений URL, поскольку нижеприведенный метод не использует URL-совместимое сопоставление.

byte[] data = BitConverter.GetBytes(value);
// make data big-endian if needed
if (BitConverter.IsLittleEndian) {
   Array.Reverse(data);
}
// first 5 base-64 character always "A" (as first 30 bits always zero)
// only need to keep the 6 characters (36 bits) at the end 
string base64 = Convert.ToBase64String(data, 0, 8).Substring(5,6);

byte[] data2 = new byte[8];
// add back in all the characters removed during encoding
Convert.FromBase64String("AAAAA" + base64 + "=").CopyTo(data2, 0);
// reverse again from big to little-endian
if (BitConverter.IsLittleEndian) {
   Array.Reverse(data2);
}
long decoded = BitConverter.ToInt64(data2, 0);

Сделать это "красивее"

Поскольку base-64 было определено, чтобы использовать 6 символов, тогда любой вариант кодирования, который все еще кодирует входные биты на 6 символов, создаст такой же небольшой результат. Использование base-32 encoding не совсем сделает разрез, так как в кодировке base-32 6 символ может хранить только 30 бит информации (lg(32) * 6).

Однако такой же размер вывода может быть достигнут с помощью специальной кодировки base-48 (или 52/62). (Преимущество базы 48-62 состоит в том, что они требуют только подмножества буквенно-цифровых символов и не нуждаются в символах; необязательно "двусмысленные" символы, такие как 1, и "I" можно избежать для вариантов). В системе base-48 6 символов могут кодировать ~ 33,5 бит (lg(48) * 6) информации, которая находится чуть выше бит ~ 33.2 (или ~ 33.06) (lg(10) * 10).

Вот доказательство концепции:

// This does not "pad" values
string Encode(long inp, IEnumerable<char> map) {
    Debug.Assert(inp >= 0, "not implemented for negative numbers");

    var b = map.Count();
    // value -> character
    var toChar = map.Select((v, i) => new {Value = v, Index = i}).ToDictionary(i => i.Index, i => i.Value);
    var res = "";
    if (inp == 0) {
      return "" + toChar[0];
    }
    while (inp > 0) {
      // encoded least-to-most significant
      var val = (int)(inp % b);
      inp = inp / b;
      res += toChar[val];
    }
    return res;
}

long Decode(string encoded, IEnumerable<char> map) {
    var b = map.Count();
    // character -> value
    var toVal = map.Select((v, i) => new {Value = v, Index = i}).ToDictionary(i => i.Value, i => i.Index);      
    long res = 0;
    // go in reverse to mirror encoding
    for (var i = encoded.Length - 1; i >= 0; i--) {
      var ch = encoded[i];
      var val = toVal[ch];
      res = (res * b) + val;
    }
    return res;
}

void Main()
{
    // for a 48-bit base, omits l/L, 1, i/I, o/O, 0
    var map = new char [] {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',
        'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
        'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
        'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't',
        'u', 'v', 'x', 'y', 'z', '2', '3', '4',
    };
    var test = new long[] {0, 1, 9999999999, 4294965286, 2292964213, 1000000000};
    foreach (var t in test) {
        var encoded = Encode(t, map);
        var decoded = Decode(encoded, map);
        Console.WriteLine(string.Format("value: {0} encoded: {1}", t, encoded));
        if (t != decoded) {
            throw new Exception("failed for " + t);
        }
    }
}

Результат:

value: 0 encoded: A
value: 1 encoded: B
value: 9999999999 encoded: SrYsNt
value: 4294965286 encoded: ZNGEvT
value: 2292964213 encoded: rHd24J
value: 1000000000 encoded: TrNVzD

Вышеприведенное рассматривает случай, когда цифры являются "случайными и непрозрачными"; то есть нет ничего, что можно было бы определить о внутренностях числа. Однако, если есть определенная структура (например, 7-й, 8-й и 9-й бит всегда равны нулю, а 2-й и 15-й бит всегда совпадают), тогда - тогда и только тогда, когда из входного сигнала можно исключить 4 или более бит информации - - потребуется только 5 базовых 64 символов. Добавленные сложности и зависимость от структуры, скорее всего, перевешивают любой маржинальный выигрыш.

Ответ 2

Вы можете использовать кодировку base64, чтобы уменьшить количество данных до семи символов. Вам нужно пять байтов для представления числа, и они могут быть закодированы в восемь символов с использованием base64, но этот последний символ всегда является наполнителем =, поэтому его можно удалить:

long value = 4294965286;

// get the value as an eight byte array (where the last three are zero)
byte[] data = BitConverter.GetBytes(value);
// encode the first five bytes
string base64 = Convert.ToBase64String(data, 0, 5).Substring(0, 7);
Console.WriteLine(base64);

Вывод:

Jvj//wA

Чтобы декодировать текст, вы снова добавляете =, декодируете его и читаете его как число:

// create an eight byte array
byte[] data = new byte[8];
// decode the text info five bytes and put in the array
Convert.FromBase64String(base64 + "=").CopyTo(data, 0);
// get the value from the array
long value = BitConverter.ToInt64(data, 0);

Console.WriteLine(value);

Вывод:

4294965286

Два из символов, используемых base64, не подходят для использования в URL-адресе, поэтому вы можете заменить их другими символами и затем заменить их. Символы + и / могут быть заменены, например, на - и _.

Ответ 3

В дополнение к изменению базы кодирования (pst, и у меня была такая же мысль примерно в то же время), так как все ваши цифры составляют 10 десятичных цифр, вы может вычесть наименьшее 10-значное число (10E9) из каждого номера перед его кодированием, а затем добавить его обратно после декодирования. Это переместит ваши закодированные числа в диапазон от 0 до 8999999999, что позволит использовать меньшие строки после изменения базы.

Ответ 4

Как насчет преобразования большого числа в формулу: вместо 21312312312 я мог бы использовать 4 ^ 34. http://mathforum.org/library/drmath/view/65726.html

Ответ 5

Я думаю, что вы ищете Hash IDs: http://hashids.org/

У них есть реализации на многих языках, хотя похоже, что С# не является одним из них.

Я привел пример для вас в JavaScript: http://codepen.io/codycraven/pen/MbWwQm

var hashids = new Hashids('my salt', 1, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890');
var input = 4294965286;
var hex = input.toString(16); // 8 characters: fffff826
var hashid = hashids.encode(input); // 7 characters: 0LzaR1Y
var base64 = window.btoa(input).replace(/=+/, ''); // 14 characters: NDI5NDk2NTI4Ng

Обратите внимание, что библиотеки HashIDs защищают ваши хэши от включения нецензурного выражения.