Enumerate all number that are palindromic in at least two of base 2, 8, 10, 16 or 64 Multi palindromic numbers

Finding all number for which at least two** representation are palindromic, with more than one** characters, if in decimal, octal, hexadecimal, binary or in base64.

** have to be editable, see Variables below.

Edited: After lot of reflexion  about comment from @DavidCarraher, I found an important issue about the range to be used. Mostly in the goal of reducing ratio operation/output. For this, variables section of this question was modified.

Details

Representation of numbers are:


binary     : 01
octal      : 01234567
decimal    : 0123456789
hexadecimal: 0123456789abcdef   (in lower case)
base64     : 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@_ Nota:&nbsp;This&nbsp;representation is compatible with bash: printf "%o" $((64#r0r)) give 330033 (r0r is a palindrome in both base64 and octal)


The ouput present first a count of palindromes, than all 5 variantes from smaller representation to bigger:

Count Base64 Hexa   Decimal  Octal    Binary
3     11     41     65       101      1000001
3     33     c3     195      303      11000011
3     55     145    325      505      101000101
3     77     1c7    455      707      111000111
4     99     249    585      1111     1001001001
3     ll     555    1365     2525     10101010101
3     rr     6db    1755     3333     11011011011
3     JJ     b6d    2925     5555     101101101101
3     ZL     f6f    3951     7557     111101101111
4     __     fff    4095     7777     111111111111
4     101    1001   4097     10001    1000000000001
3     111    1041   4161     10101    1000001000001
3     202    2002   8194     20002    10000000000010
4     303    3003   12291    30003    11000000000011
3     333    30c3   12483    30303    11000011000011


Nota this sample display number that's palindromes in at least 3 representation, not 2, see Variables below.

Variables


Minimum of palindrome length, default to 2
Minimum number of palindrome by number, default to  2 (/5). There are 5 representation. Print a number when at least 2 of them are palindromic.
Range to check for: could be from 1 to 2^31 or smaller. This could be an array BoundRange=(1,1000) or two variables: RangeSta=1 RangeEnd=1000.


This variables have to be changeables in simple way (modification of code at only one place or given as argument).

Output

No formating needed, only 6 colons, space separated will suffice.

2 9 9 9 11 1001
2 h 11 17 21 10001
2 r 1b 27 33 11011
2 x 21 33 41 100001
2 J 2d 45 55 101101
2 P 33 51 63 110011
2 _ 3f 63 77 111111
3 11 41 65 101 1000001
2 19 49 73 111 1001001
2 1l 55 85 125 1010101


Limits (range)

There is no real consideration of maximum useable of the range as this is depending on language used, But a range have to be fixed:


min: 1 (notation in octal!)
max: depending on language used, but 2^31 seem to be an overall minimum.


For tests, the range could be fixed to somthing smaller...

Goal

The more efficient algorithm with less operation count by line of output will win. (This may have to be explained)**.


Ratio  operation count / output line count
Shortness of code, but with readable variables ie: One variable is one. Regardless of his name length. (don't obfusc)
Quickness of execution (comparission only by language, not accross different languages. Ie: I won't try to compare a c version with a bash one. )


Operations count

The count of operation are mainly theorical. Meaning, a simple conversion is one operation whenever it is done by builtin functions, like printf or by more complex routine like sub base in Dom Hastings's answer

**As I don't know all languages, and there is some place to unusual ideas, subtles algorithms may need to be explained...
Mathematica
f[number,minPalindromeLength,minCount]works as follows If number is a palindrome with minPalindromeLength in at least minCount bases, f returns the information about that number.
g[max,minPalindromeLength,minCount] makes an table of &quot;palindrome numbers&quot; from 1 through max.
f[number_,minPalindromeLength_:2,minCount_:2]:=Module[{print,palindromeQ,count, 
convert64=Thread[Range[0,63]-&gt;Characters[&quot;0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@_&quot;]],
digits=IntegerDigits[number,#]&amp;/@(bases={64,16,10,8,2})},
palindromeQ[dig_]:=(dig==Reverse[dig]);
count = Total@Boole[palindromeQ/@ Cases[digits,x_/;Length[x]&gt;minPalindromeLength-1]];
If[count&gt;minCount-1,Join[{count,Subscript[StringJoin[IntegerDigits[number,64]/.convert64],64]},BaseForm[number,#]&amp;/@Rest[bases]],Sequence[]]];

g[max_,minPalindromeLength_:2,minCount_:2]:=
(Print[&quot;\nPalindromes: minPalindromeLength = &quot;,minPalindromeLength &quot;\tand minCount &quot;, minCount ]; 
DeleteCases[Table[f[z,minPalindromeLength,minCount],{z,9,max}],Null]//Grid);

g[5000,2,3]
g[5000,3,3]
g[5000,4,2]