Añadiendo algún valor a las respuestas anteriores. Siguiendo groovy script imprime valores intermedios.

String getBits(long l) {
return Long.toBinaryString(l).padLeft(8,'0');
}

for (long l = 4946144450195624l; l > 0; l >>= 5){
    println ''
    print String.valueOf(l).toString().padLeft(16,'0')
    print '|'+ getBits((l & 31 ))
    print '|'+ getBits(((l & 31 | 64)))
    print '|'+ getBits(((l & 31 | 64)  % 95))
    print '|'+ getBits(((l & 31 | 64)  % 95 + 32))

    print '|';
    System.out.print((char) (((l & 31 | 64) % 95) + 32));
}

Aquí está

4946144450195624|00001000|01001000|01001000|01101000|h
0154567014068613|00000101|01000101|01000101|01100101|e
0004830219189644|00001100|01001100|01001100|01101100|l
0000150944349676|00001100|01001100|01001100|01101100|l
0000004717010927|00001111|01001111|01001111|01101111|o
0000000147406591|00011111|01011111|00000000|00100000| 
0000000004606455|00010111|01010111|01010111|01110111|w
0000000000143951|00001111|01001111|01001111|01101111|o
0000000000004498|00010010|01010010|01010010|01110010|r
0000000000000140|00001100|01001100|01001100|01101100|l
0000000000000004|00000100|01000100|01000100|01100100|d

Interesante!

Los caracteres ASCII estándar que son visibles están en un rango de 32 a 127.

Es por eso que ves 32, y 95 (127 - 32) allí.

De hecho, cada carácter se asigna a 5 bits aquí, (puede encontrar lo que es una combinación de 5 bits para cada carácter), y luego todos los bits se concatenan para formar un gran número.

Los longs positivos son números de 63 bits, lo suficientemente grandes como para contener una forma cifrada de 12 caracteres. Por lo tanto, es lo suficientemente grande como para contener Hello word, pero para textos más grandes usted debe utilizar números más grandes, o incluso un BigInteger.

En una aplicación queríamos transferir caracteres visibles en Inglés, Caracteres Persas y Símbolos a través de SMS. Como puede ver, hay 32 (number of Persian chars) + 95 (number of English characters and standard visible symbols) = 127 valores posibles, que se pueden representar con 7 bits.

Convertimos cada carácter UTF-8 (16 bits) a 7 bits, y ganamos más del 56% de relación de compresión. Así que podríamos enviar textos con dos veces de longitud en el mismo número de SMS. (Es de alguna manera lo mismo sucedió aquí).

Está obteniendo un resultado que resulta ser char representación de los valores inferiores

104 -> h
101 -> e
108 -> l
108 -> l
111 -> o
32  -> (space)
119 -> w
111 -> o
114 -> r
108 -> l
100 -> d

Ha codificado caracteres como valores de 5 bits y empaquetado 11 de ellos en un largo de 64 bits.

(packedValues >> 5*i) & 31 es el i-ésimo valor codificado con un rango 0-31.

La parte difícil, como usted dice, es codificar el espacio. Las letras inglesas minúsculas ocupan el rango contiguo 97-122 en Unicode (y ascii, y la mayoría de las otras codificaciones), pero el espacio es 32.

Para superar esto, usaste algo de aritmética. ((x+64)%95)+32 es casi lo mismo que x + 96 (tenga en cuenta cómo bitwise OR es equivalente a la suma, en este case), pero cuando x=31, obtenemos 32.

Imprime "hola mundo" por una razón similar:

for (int k=1587463874; k>0; k>>=3)
     System.out.print((char) (100 + Math.pow(2,2*(((k&7^1)-1)>>3 + 1) + (k&7&3)) + 10*((k&7)>>2) + (((k&7)-7)>>3) + 1 - ((-(k&7^5)>>3) + 1)*80));

Pero por una razón algo diferente a esta:

for (int k=2011378; k>0; k>>=2)
    System.out.print((char) (110 + Math.pow(2,2*(((k^1)-1)>>21 + 1) + (k&3)) - ((k&8192)/8192 + 7.9*(-(k^1964)>>21) - .1*(-((k&35)^35)>>21) + .3*(-((k&120)^120)>>21) + (-((k|7)^7)>>21) + 9.1)*10));

Sin una etiqueta Oracle, era difícil ver esta pregunta. Active bounty me trajo aquí. Desearía que la pregunta tuviera otras etiquetas tecnológicas relevantes también : - (

Trabajo principalmente con Oracle database, así que usaría algo de Oracle conocimiento para interpretar y explicar : -)

Vamos a convertir el número 4946144450195624 en binary. Para eso utilizo un pequeño functionllamado dec2bin, es decir, decimal a binario .

SQL> CREATE OR REPLACE FUNCTION dec2bin (N in number) RETURN varchar2 IS
  2    binval varchar2(64);
  3    N2     number := N;
  4  BEGIN
  5    while ( N2 > 0 ) loop
  6       binval := mod(N2, 2) || binval;
  7       N2 := trunc( N2 / 2 );
  8    end loop;
  9    return binval;
 10  END dec2bin;
 11  /

Function created.

SQL> show errors
No errors.
SQL>

Usemos la función para obtener el valor binario -

SQL> SELECT dec2bin(4946144450195624) FROM dual;

DEC2BIN(4946144450195624)
--------------------------------------------------------------------------------
10001100100100111110111111110111101100011000010101000

SQL>

Ahora la captura es la conversión 5-bit. Comience a agrupar de derecha a izquierda con 5 dígitos en cada grupo. Obtenemos :-

100|01100|10010|01111|10111|11111|01111|01100|01100|00101|01000

Finalmente nos quedaríamos con solo 3 dígitos en el final a la derecha. Porque, tuvimos un total de 53 dígitos en la conversión binaria.

SQL> SELECT LENGTH(dec2bin(4946144450195624)) FROM dual;

LENGTH(DEC2BIN(4946144450195624))
---------------------------------
                               53

SQL>

hello world total ha 11 caracteres (incluyendo el espacio), por lo que tenemos que añadir 2 bits al último grupo donde nos quedamos con solo 3 bits después de la agrupación.

So, ahora tenemos :-

00100|01100|10010|01111|10111|11111|01111|01100|01100|00101|01000

Ahora, necesitamos convertirlo al valor ascii de 7 bits. Para los personajes es fácil, solo tenemos que establecer el bit 6 y 7. Agregue 11 a cada grupo de 5 bits arriba a la izquierda.

Que da: -

1100100|1101100|1110010|1101111|1110111|1111111|1101111|1101100|1101100|1100101|1101000

Interpretemos los valores binarios, usaré binary to decimal conversion function.

SQL> CREATE OR REPLACE FUNCTION bin2dec (binval in char) RETURN number IS
  2    i                 number;
  3    digits            number;
  4    result            number := 0;
  5    current_digit     char(1);
  6    current_digit_dec number;
  7  BEGIN
  8    digits := length(binval);
  9    for i in 1..digits loop
 10       current_digit := SUBSTR(binval, i, 1);
 11       current_digit_dec := to_number(current_digit);
 12       result := (result * 2) + current_digit_dec;
 13    end loop;
 14    return result;
 15  END bin2dec;
 16  /

Function created.

SQL> show errors;
No errors.
SQL>

Veamos cada valor binario -

SQL> set linesize 1000
SQL>
SQL> SELECT bin2dec('1100100') val,
  2    bin2dec('1101100') val,
  3    bin2dec('1110010') val,
  4    bin2dec('1101111') val,
  5    bin2dec('1110111') val,
  6    bin2dec('1111111') val,
  7    bin2dec('1101111') val,
  8    bin2dec('1101100') val,
  9    bin2dec('1101100') val,
 10    bin2dec('1100101') val,
 11    bin2dec('1101000') val
 12  FROM dual;

       VAL        VAL        VAL        VAL        VAL        VAL        VAL        VAL        VAL     VAL           VAL
---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------
       100        108        114        111        119        127        111        108        108     101           104

SQL>

Veamos qué caracteres son: -

SQL> SELECT chr(bin2dec('1100100')) character,
  2    chr(bin2dec('1101100')) character,
  3    chr(bin2dec('1110010')) character,
  4    chr(bin2dec('1101111')) character,
  5    chr(bin2dec('1110111')) character,
  6    chr(bin2dec('1111111')) character,
  7    chr(bin2dec('1101111')) character,
  8    chr(bin2dec('1101100')) character,
  9    chr(bin2dec('1101100')) character,
 10    chr(bin2dec('1100101')) character,
 11    chr(bin2dec('1101000')) character
 12  FROM dual;

CHARACTER CHARACTER CHARACTER CHARACTER CHARACTER CHARACTER CHARACTER CHARACTER CHARACTER CHARACTER CHARACTER
--------- --------- --------- --------- --------- --------- --------- --------- --------- --------- ---------
d         l         r         o         w         ⌂         o         l         l         e         h

SQL>

Entonces, ¿qué obtenemos en la salida?

D l r o w {o l l e h

Eso es hola world mundo al revés. El único problema es el espacio . Y la razón está bien explicada por @higuaro en su respuesta. Honestamente no pude interpretar el tema del espacio yo mismo al primer intento, hasta que vi la explicación dada en su respuesta.

Encontré el código un poco más fácil de entender cuando se traduce a PHP, de la siguiente manera:

<?php

$result=0;
$bignum = 4946144450195624;
for (; $bignum > 0; $bignum >>= 5){
    $result = (( $bignum & 31 | 64) % 95) + 32;
    echo chr($result);
}

Ver código vivo

Fuera.println ((char) ((l & 31 | 64) % 95) + 32 / 1002439 * 1002439));

Para hacer que las tapas: 3