How to make string of numbers shorter?

[Krakatioison]

My sites navigation is like this:

http://www.newsbackup.com/index.php?n=000000000040900000

, depending on the variable "n" (which is always a number), it will take me
anywhere on the site... this number is always changing as I have hundreds of
thousand of pages of text on my site.

Problem:
- in my opinion this just not only look weird, but the variable "n" (number)
is too long.

I need a way to somehow express this number in shorter form. Some encoding
and decoding way to express this number as something shorter.
For example: 000000000040900000 could become something like : AhD7
so the link: http://www.newsbackup.com/index.php?n=000000000040900000
would look like: http://www.newsbackup.com/index.php?n=AhD7

You know what I mean.

So, I tried to think about it, and I played with the idea to use of gzencode
or gzcompress. Tried it, but these will generate the short code full of
characters out of normal ascii, spaces and so.... I can't use that, then my
site won't be search engine friendly.

Please, do you have any suggestions?
Or some short encoding decoding script? Your script can be forever part of
my site.

Joe

[Michael]

.oO(Krakatioison)
 

If n is a real number (so that leading zeros don't matter), then you
could try base_convert:

print base_convert('000000000040900000', 10, 36); // ouput: ocmn4
print base_convert('ocmn4', 36, 10); // output: 40900000

http://www.php.net/base_convert

HTH
Micha

[Joep]

base64? (without the leading zeroes of course)

"Michael Fesser" <net> wrote in message
news:com... 
>
> If n is a real number (so that leading zeros don't matter), then you
> could try base_convert:
>
> print base_convert('000000000040900000', 10, 36); // ouput: ocmn4
> print base_convert('ocmn4', 36, 10); // output: 40900000
>
> http://www.php.net/base_convert
>
> HTH
> Micha[/ref]

[Krakatioison]

Problem is that I need those leading zeros. It will just not work without
them.
Hm... But great Idea. Thanks a lot.
Any better idea? Which would never cut my leading zeros?

Joe




"Joep" <nl> wrote in message
news:41800ddd$0$78749$xs4all.nl... 
>>
>> If n is a real number (so that leading zeros don't matter), then you
>> could try base_convert:
>>
>> print base_convert('000000000040900000', 10, 36); // ouput: ocmn4
>> print base_convert('ocmn4', 36, 10); // output: 40900000
>>
>> http://www.php.net/base_convert
>>
>> HTH
>> Micha[/ref]
>
>[/ref]

[Krakatioison]

So I played with your idea a bit and wrote this script:

<?

$str= '1000000000040900000';

echo "Original string:".$str."<br>";

$encoded = base_convert($str, 10, 36); //

echo "Encoded string:".$encoded."<br>";

$decoded = base_convert($encoded, 36, 10);

echo "Decoded string:".$decoded."<br>";

?>



Result from the screen looks like this:

Original string: 1000000000040900000
Encoded string: 7lieey0lh7k0
Decoded string: 1000000000040900008

My idea was to add number 1 to the from which I would just cut off. But it's
not working... Decoded string has number 8 at the end. Not 0, as original
had.

Geez... what is happening, am I going blind?

Joe

[Ethan]

Krakatioison <com> wrote: 

The docs for that function (base_convert) mention a loss of precision when
using large numbers, and those are definitely large numbers. That's probably
why the 8 is appearing.

--
eth'nT

[Michael]

.oO(Krakatioison)
 

Nope, it's probably because of the way base_convert() works.
My fault, I should have read the warning on the manual page:

"base_convert() may lose precision on large numbers due to properties
related to the internal "double" or "float" type used."

A while ago I wrote a function for calulating permutations, it is also
usable for converting from the decimal system to any other base. I have
to check if it can be adjusted to work with such large numbers ...

Maybe there's another and better way.

Micha

[Krakatioison]

Micha, Ethan,

I thought there must be something like it. But I wasn't sure.
So now I am really puzzled. What would be a best way to deal with this
problem?
I was wondering about using dechex and hexdec.... but that is using
alphabeth only till it gets to F, so as a solution it wouldn't be the best
possible.

Any other ideas?

Joe

[Michael]

.oO(Krakatioison)
 

A quick 'n dirty hack, using the BCMath extension (should be compiled-in
by default) for converting any (really big) number from base 10 to any
base you like and back:

function encode($number, $alphabet) {
$base = strlen($alphabet);
$result = '';
while (bccomp($number, 0) == 1) {
$result = $alphabet{bcmod($number, $base)}.$result;
$number = bcdiv($number, $base, 0);
}
return $result;
}

function decode($number, $alphabet) {
$base = strlen($alphabet);
$alphabet = array_flip(str_split($alphabet));
$c = strlen($number)-1;
$result = 0;
for ($i = 0; $i <= $c; $i++) {
$temp = bcmul($alphabet[$number{$i}], bcpow($base, $c-$i));
$result = bcadd($result, $temp);
}
return $result;
}


The str_split() function is PHP5, if you don't have it you can use this
one instead:

function str_split($string) {
return preg_split('##', $string, -1, PREG_SPLIT_NO_EMPTY);
}


Test results:

Alphabet: 01
Original string: 1000000000040900000
Encoded string: 11011110000010110110101100111010100111010100000101 0110100000
Decoded string: 1000000000040900000

Alphabet: 0123456789ABCDEF
Original string: 1000000000040900000
Encoded string: DE0B6B3A9D415A0
Decoded string: 1000000000040900000

Alphabet: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
Original string: 1000000000040900000
Encoded string: 7LIEEY0LH7KW
Decoded string: 1000000000040900000

With the last alphabet the encoding saves 7 chars ... not that much ...

HTH
Micha

[Pedro]

["Followup-To:" header set to comp.lang.php.]
Krakatioison wrote: 

Are your numbers 'n' always 18 digits long?

php$ cat longn.php
<?php
function test($str) {
if (strlen($str) != 18) {echo "$str: Oops, wrong length\n\n"; return;}
$str1 = substr($str, 0, 9);
$str2 = substr($str, 9, 9);
echo 'Original string: ', $str, ' ==> ';

$encoded = base_convert($str1, 10, 36);
$encoded .= '-' . base_convert($str2, 10, 36);
echo 'Encoded string: ', $encoded, "\n";

$enc = explode('-', $encoded);
$decoded = substr('00000000' . base_convert($enc[0], 36, 10), -9);
$decoded .= substr('00000000' . base_convert($enc[1], 36, 10), -9);
echo ' Decoded string: ', $decoded, "\n\n";
}

/* test data */
$str= '000000000040900000'; test($str);
$str= '000000000040900001'; test($str);
$str= '900000000040900000'; test($str);
$str= '900000000040900001'; test($str);
$str= '123456789012345678'; test($str);
$str= '987654321098765432'; test($str);
$str= '111111111111111111'; test($str);
$str= '555555555555555555'; test($str);
$str= '999999999999999999'; test($str);
$str= '000000000000000000'; test($str);
?>

php$ php longn.php
Original string: 000000000040900000 ==> Encoded string: 0-ocmn4
Decoded string: 000000000040900000

Original string: 000000000040900001 ==> Encoded string: 0-ocmn5
Decoded string: 000000000040900001

Original string: 900000000040900000 ==> Encoded string: evu4g0-ocmn4
Decoded string: 900000000040900000

Original string: 900000000040900001 ==> Encoded string: evu4g0-ocmn5
Decoded string: 900000000040900001

Original string: 123456789012345678 ==> Encoded string: 21i3v9-7clzi
Decoded string: 123456789012345678

Original string: 987654321098765432 ==> Encoded string: gc0uy9-1msvw8
Decoded string: 987654321098765432

Original string: 111111111111111111 ==> Encoded string: 1u5hvr-1u5hvr
Decoded string: 111111111111111111

Original string: 555555555555555555 ==> Encoded string: 96rher-96rher
Decoded string: 555555555555555555

Original string: 999999999999999999 ==> Encoded string: gjdgxr-gjdgxr
Decoded string: 999999999999999999

Original string: 000000000000000000 ==> Encoded string: 0-0
Decoded string: 000000000000000000


--
USENET would be a better place if everybody read: | to mail me: simply |
http://www.catb.org/~esr/faqs/smart-questions.html | "reply" to this post, |
http://www.netmeister.org/news/learn2quote2.html | *NO* MIME, plain text |
http://www.expita.com/nomime.html | and *NO* attachments. |

[Krakartioison]

Dear Michael,
thanks a lot for helping me with this code.
I had to do a small changes with leading zeros and added some additional
coding to add these missing zeros.
But it all came to work out just perfectly. I really appreciate your help.
I used alphabet like this:
0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN OPQRSTUVWXYZ
You can see it working now : http://www.newsbackup.com/index.php?n=Gnte
Wherever you click on the site now it ends with characters out of mentioned
alphabet, most I've seen was 6 decimal places...which is nice comparing to
starting 18 decimal places.
Great job.
Joe

[Krakartioison]

There is yet another question here:
- when you look at this address (http://www.newsbackup.com/index.php?n=Gnte)
, it has small and capital letters and in some cases numbers as well.

Do you guys think it will be indexed properly by Google?
Can Google see the difference between small and capital letters?

Joe

[Wakeley]

Krakatioison wrote:
 

It looks like your number always has a lot of repeating '0's. That makes it
a good candidate for Run Length Encoding (RLE). Pick a character to
introduce a sequence of zeros and add a count of how many to represent. For
example, using 'Z' as the introducer:

000000000040900000 has 10 leading '0's, so we can compress the first 9 to
'Z9'. Now we have Z9040900000. You can also replace the trailing '0's with
'Z5'. Then you wind up with Z90409Z5.

'course you have to write the code ot encode it 8).

--
Wake

[Gordon]

>My sites navigation is like this: 

Ok, here's the brute force method:

Make a list of all possible values of "n". (Arrange to keep updating
the list if more can be added). Put these in a database table.
Assign a sequence number to each of them, starting from 0. Look
up the value, replace it with the sequence number, possibly in
base64 to make it even shorter.

When you get the new value of "n", (un-base64 it if necessary),
look it up in the same database table, for a matching sequence
number, then get the corresponding long form. Then use it.
 

Gordon L. Burditt

[Simon]

Wakeley Purple <me.iglou.com> wrote: 

Or just use characters to represent sequences of zero:
0 -> 0, 00 -> A, 000 -> B, 0000 -> C, 00000 -> D, ...
Then you would get: I409D

Another way would be to run through the sequence, converting each two
digits into an integer, converting this integer into the corresponding
character and encode it using base64 (enforces a sequence with an even
number of digits: /^(\d\d)+$/):

-----BEGIN PHP CODE BLOCK-----
function encode($str) {
$enc = '';
while (strlen($str)) {
$tmp = substr($str, 0, 2);
$tmp = (int) $tmp;
$enc .= chr($tmp);
$str = substr($str, 2);
}
return base64_encode($enc);
}

function decode($str) {
$dec = '';
$len=strlen($str);
for ($i=0; $i<$len; $i++) {
$tmp = ord($str{$i});
$tmp = str_pad($tmp, 2, '0', STR_PAD_LEFT);
$dec .= $tmp;
}
return $dec;
}
------END PHP CODE BLOCK------

or, in the short version:

-----BEGIN PHP CODE BLOCK-----
function encode($str) {
$enc = ''; $str = ' '.$str;
while (strlen($str = substr($str, 2)))
$enc .= chr((int) substr($str, 0, 2))
return base64_encode($enc);
}

function decode($str) {
$dec = '';
for ($i=0, $len=strlen($str); $i<$len; $i++)
$dec .= str_pad(ord($str{$i}), 2, '0', STR_PAD_LEFT);
return $dec;
}
------END PHP CODE BLOCK------

(code is untested)

HTH
--
Simon Stienen <http://dangerouscat.net> <http://slashlife.de>
»What you do in this world is a matter of no consequence,
The question is, what can you make people believe that you have done.«
-- Sherlock Holmes in "A Study in Scarlet" by Sir Arthur Conan Doyle

[L�ʻie]

On Wed, 27 Oct 2004 23:40:14 -0400, Krakartioison wrote:
 

It can for URLs. I believe it doesn't distinguish case for the page's
body, however, unless one of the search terms is in mixed case.

HTH,
La'ie Techie