View source for Numbers in base 10 that are palindromic in bases 2, 4, and 16

{{Draft task}}

;Task: Find numbers in base 10 that are palindromic in bases 2, 4, and 16, where '''n < 25,000'''

<br><br>

=={{header|11l}}==
{{trans|Python}}

<syntaxhighlight lang="11l">F reverse(=n, base)
   V r = 0
   L n > 0
      r = r * base + n % base
      n I/= base
   R r

F palindrome(n, base)
   R n == reverse(n, base)

V cnt = 0
L(i) 25000
   I all((2, 4, 16).map(base -> palindrome(@i, base)))
      cnt++
      print(‘#5’.format(i), end' " \n"[cnt % 12 == 0])

print()</syntaxhighlight>

{{out}}
<pre>
    0     1     3     5    15    17    51    85   255   257   273   771
  819  1285  1365  3855  4095  4097  4369 12291 13107 20485 21845 
</pre>

=={{header|Action!}}==
<syntaxhighlight lang="action!">BYTE FUNC IsPalindrome(INT x BYTE base)
  CHAR ARRAY digits="0123456789abcdef",s(16)
  BYTE d,i,len

  len=0
  DO
    d=x MOD base
    len==+1
    s(len)=digits(d+1)
    x==/base
  UNTIL x=0
  OD
  s(0)=len

  FOR i=1 TO len/2
  DO
    IF s(i)#s(len-i+1) THEN
      RETURN (0)
    FI
  OD
RETURN (1)

PROC Main()
  INT i

  FOR i=0 TO 24999
  DO
    IF IsPalindrome(i,16)=1 AND IsPalindrome(i,4)=1 AND IsPalindrome(i,2)=1 THEN
      PrintI(i) Put(32)
    FI
  OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Numbers_in_base_10_that_are_palindromic_in_bases_2,_4,_and_16.png Screenshot from Atari 8-bit computer]
<pre>
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN # show numbers in decimal that are palindromic in bases 2, 4 and 16 #
    INT max number = 25 000;    # maximum number to consider #
    INT min base   = 2;         # smallest base needed #
    INT max digits = BEGIN      # number of digits max number has in the smallest base #
                         INT d := 1;
                         INT v := max number;
                         WHILE v >= min base DO
                             v OVERAB min base;
                             d PLUSAB 1
                         OD;
                         d
                     END;
    # returns the digits of n in the specified base #
    PRIO DIGITS = 9;
    OP   DIGITS = ( INT n, INT base )[]INT:
         IF   INT v := ABS n;
              v < base
         THEN v # single dogit #
         ELSE   # multiple digits #
            [ 1 : max digits ]INT result;
            INT d pos := UPB result + 1;
            INT v     := ABS n;
            WHILE v > 0 DO
                result[ d pos -:= 1 ] := v MOD base;
                v OVERAB base
            OD;
            result[ d pos : UPB result ]
         FI # DIGITS # ;
    # returns TRUE if the digits in d form a palindrome, FALSE otherwise #
    OP   PALINDROMIC = ( []INT d )BOOL:
         BEGIN
             INT  left := LWB d, right := UPB d;
             BOOL is palindromic := TRUE;
             WHILE left < right AND is palindromic DO
                 is palindromic := d[ left ] = d[ right ];
                 left          +:= 1;
                 right         -:= 1
             OD;
             is palindromic
         END;
    # print the numbers in decimal that are palendromic in bases 2, 4 and 16 #
    # as noted by the REXX sample, even numbers ( other than 0 ) aren't      #
    # applicable as even numbers end in 0 in base 2 so can't be palendromic  #
    print( ( " 0" ) );              # clearly, 0 is palendromic in all bases #
    FOR n BY 2 TO max number DO
        IF PALINDROMIC ( n DIGITS 16 ) THEN
            IF PALINDROMIC ( n DIGITS 4 ) THEN
                IF PALINDROMIC ( n DIGITS 2 ) THEN
                    print( ( " ", whole( n, 0 ) ) )
                FI
            FI
        FI
    OD
END
</syntaxhighlight>
{{out}}
<pre>
 0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">
begin % find numbers palendromic in bases 2, 4, and 16                             %

    % returns true if n is palendromic in the specified base, false otherwide      %
    logical procedure palendromic( integer value n, base ) ;
    begin
        integer array digit( 1 :: 32 );
        integer dPos, v, lPos, rPos;
        logical isPalendromic;
        dPos := 0;
        v    := n;
        while v > 0 do begin
            dPos          := dPos + 1;
            digit( dPos ) := v rem base;
            v             := v div base
        end while_v_gt_0 ;
        isPalendromic := true;
        lPos          := 1;
        rPos          := dPos;
        while rPos > lPos and isPalendromic do begin
            isPalendromic := digit( lPos ) = digit( rPos );
            lPos          := lPos + 1;
            rPos          := rPos - 1
        end while_rPos_gt_lPos_and_isPalendromic ;
        isPalendromic
    end palendromic ;
    % as noted by the REXX sample, all even numbers end in 0 in base 2             %
    % so 0 is the only possible even number, note 0 is palendromic in all bases    %
    write( " 0" );
    for n := 1 step 2 until 24999 do begin
        if palendromic( n, 16 ) then begin
            if palendromic( n, 4 ) then begin
                if palendromic( n, 2 ) then begin
                    writeon( i_w := 1, s_w := 0, " ", n )
                end if_palendromic__n_2
            end if_palendromic__n_4
        end if_palendromic__n_16
    end for_n
end.
</syntaxhighlight>
{{out}}
<pre>
 0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">(⊢(/⍨)(2 4 16∧.((⊢≡⌽)(⊥⍣¯1))⊢)¨)0,⍳24999</syntaxhighlight>
{{out}}
<pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845</pre>

=={{header|Arturo}}==

<syntaxhighlight lang="arturo">multiPalindromic?: function [n][
    if (digits.base:2 n) <> reverse digits.base:2 n -> return false
    if (digits.base:4 n) <> reverse digits.base:4 n -> return false
    if (digits.base:16 n) <> reverse digits.base:16 n -> return false
    return true
]

mpUpTo25K: select 0..25000 => multiPalindromic?

loop split.every: 12 mpUpTo25K 'x ->
    print map x 's -> pad to :string s 5</syntaxhighlight>

{{out}}

<pre>    0     1     3     5    15    17    51    85   255   257   273   771 
  819  1285  1365  3855  4095  4097  4369 12291 13107 20485 21845</pre>

=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f NUMBERS_IN_BASE_10_THAT_ARE_PALINDROMIC_IN_BASES_2_4_AND_16.AWK
# converted from C
BEGIN {
    start = 0
    stop = 24999
    for (i=start; i<stop; i++) {
      if (palindrome(i,2) && palindrome(i,4) && palindrome(i,16)) {
         printf("%5d%1s",i,++count%10?"":"\n")
      }
    }
    printf("\nBase 10 numbers that are palindromes in bases 2, 4, and 16: %d-%d: %d\n",start,stop,count)
    exit(0)
}
function palindrome(n,base) {
    return n == reverse(n,base)
}
function reverse(n,base,  r) {
    for (r=0; n; n=int(n/base)) {
      r = int(r*base) + n%base
    }
    return(r)
}
</syntaxhighlight>
{{out}}
<pre>
    0     1     3     5    15    17    51    85   255   257
  273   771   819  1285  1365  3855  4095  4097  4369 12291
13107 20485 21845
Base 10 numbers that are palindromes in bases 2, 4, and 16: 0-24999: 23
</pre>

=={{header|BASIC}}==
<syntaxhighlight lang="basic">10 DEFINT A-Z: DEFDBL R
20 FOR I=1 TO 25000
30 B=2: GOSUB 100: IF R<>I GOTO 70
40 B=4: GOSUB 100: IF R<>I GOTO 70
50 B=16: GOSUB 100: IF R<>I GOTO 70
60 PRINT I,
70 NEXT
80 END
100 R=0: N=I
110 IF N=0 THEN RETURN
120 R=R*B+N MOD B
130 N=N\B
140 GOTO 110</syntaxhighlight>
{{out}}
<pre> 0             1             3             5             15
 17            51            85            255           257
 273           771           819           1285          1365
 3855          4095          4097          4369          12291
 13107         20485         21845</pre>

=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
manifest $( MAXIMUM = 25000 $)

let reverse(n, base) = valof
$(  let r = 0
    while n > 0
    $(  r := r*base + n rem base
        n := n / base
    $)
    resultis r
$)

let palindrome(n, base) = n = reverse(n, base)

let start() be 
    for i = 0 to MAXIMUM
        if palindrome(i,2) & palindrome(i,4) & palindrome(i,16)
            do writef("%N*N", i)</syntaxhighlight>
{{out}}
<pre>0
1
3
5
15
17
51
85
255
257
273
771
819
1285
1365
3855
4095
4097
4369
12291
13107
20485
21845</pre>

=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#define MAXIMUM 25000

int reverse(int n, int base) {
    int r;
    for (r = 0; n; n /= base)
        r = r*base + n%base;
    return r;
}

int palindrome(int n, int base) {
    return n == reverse(n, base);
}

int main() {
    int i, c = 0;
    
    for (i = 0; i < MAXIMUM; i++) {
        if (palindrome(i, 2) &&
            palindrome(i, 4) &&
            palindrome(i, 16)) {
            printf("%5d%c", i, ++c % 12 ? ' ' : '\n');
        }
    }
    printf("\n");
    return 0;
}</syntaxhighlight>
{{out}}
<pre>    0     1     3     5    15    17    51    85   255   257   273   771
  819  1285  1365  3855  4095  4097  4369 12291 13107 20485 21845</pre>

=={{header|COBOL}}==
<syntaxhighlight lang="cobol">       IDENTIFICATION DIVISION.
       PROGRAM-ID. PALINDROMIC-BASE-2-4-16.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 VARIABLES.
          02 CUR-NUM           PIC 9(5).
          02 REV-BASE          PIC 99.
          02 REV-REST          PIC 9(5).
          02 REV-NEXT          PIC 9(5).
          02 REV-DGT           PIC 99.
          02 REVERSED          PIC 9(5).
       
       01 OUTPUT-FORMAT.
          02 OUT-NUM           PIC Z(4)9.
       
       PROCEDURE DIVISION.
       BEGIN.
           PERFORM 2-4-16-PALINDROME
               VARYING CUR-NUM FROM ZERO BY 1
               UNTIL CUR-NUM IS NOT LESS THAN 25000.
           STOP RUN.
       
       2-4-16-PALINDROME.
           MOVE 16 TO REV-BASE, PERFORM REVERSE THRU REV-LOOP
           IF CUR-NUM IS EQUAL TO REVERSED
               MOVE 4 TO REV-BASE, PERFORM REVERSE THRU REV-LOOP
               IF CUR-NUM IS EQUAL TO REVERSED
                   MOVE 2 TO REV-BASE, PERFORM REVERSE THRU REV-LOOP
                   IF CUR-NUM IS EQUAL TO REVERSED
                       MOVE CUR-NUM TO OUT-NUM
                       DISPLAY OUT-NUM.
       
       REVERSE.
           MOVE ZERO TO REVERSED.
           MOVE CUR-NUM TO REV-REST.
       REV-LOOP.
           IF REV-REST IS GREATER THAN ZERO
               DIVIDE REV-BASE INTO REV-REST GIVING REV-NEXT
               COMPUTE REV-DGT = REV-REST - REV-NEXT * REV-BASE
               MULTIPLY REV-BASE BY REVERSED
               ADD REV-DGT TO REVERSED
               MOVE REV-NEXT TO REV-REST
               GO TO REV-LOOP.</syntaxhighlight>
{{out}}
<pre>    0
    1
    3
    5
   15
   17
   51
   85
  255
  257
  273
  771
  819
 1285
 1365
 3855
 4095
 4097
 4369
12291
13107
20485
21845</pre>

=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
const MAXIMUM := 25000;

sub reverse(n: uint16, base: uint16): (r: uint16) is
    r := 0;
    while n != 0 loop
        r := r * base + n % base;
        n := n / base;
    end loop;
end sub;

var i: uint16 := 0;
var c: uint8 := 0;
while i < MAXIMUM loop
    if reverse(i,2) == i
    and reverse(i,4) == i
    and reverse(i,16) == i 
    then
        c := c + 1;
        print_i16(i);
        if c == 15 then
            print_nl();
            c := 0;
        else
            print_char(' ');
        end if;
    end if;
    i := i + 1;
end loop;
print_nl();</syntaxhighlight>
{{out}}
<pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365
3855 4095 4097 4369 12291 13107 20485 21845</pre>

=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}


<syntaxhighlight lang="Delphi">

function GetRadixString(L: Integer; Radix: Byte): string;
{Converts integer a string of any radix}
const RadixChars: array[0..35] Of char =
    ('0', '1', '2', '3', '4', '5', '6', '7',
     '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
     'G','H', 'I', 'J', 'K', 'L', 'M', 'N',
     'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
     'W', 'X', 'Y', 'Z');
var I: integer;
var S: string;
var Sign: string[1];
begin
Result:='';
If (L < 0) then
	begin
	Sign:='-';
	L:=Abs(L);
	end
else Sign:='';
S:='';
repeat
	begin
	I:=L mod Radix;
	S:=RadixChars[I] + S;
	L:=L div Radix;
	end
until L = 0;
Result:=Sign + S;
end;


function IsPalindrome(N, Base: integer): boolean;
{Test if number is the same forward or backward}
{For a specific Radix}
var S1,S2: string;
begin
S1:=GetRadixString(N,Base);
S2:=ReverseString(S1);
Result:=S1=S2;
end;

function IsPalindrome2416(N: integer): boolean;
{Is N palindromic for bases 2, 4 and 16}
begin
Result:=IsPalindrome(N,2) and
	IsPalindrome(N,4) and
	IsPalindrome(N,16);
end;

procedure ShowPalindrome2416(Memo: TMemo);
{Show all numbers Palindromic for bases 2, 4 and 16}
var S: string;
var I,Cnt: integer;
begin
S:='';
Cnt:=0;
for I:=0 to 25000-1 do
 if IsPalindrome2416(I) then
	begin
	Inc(Cnt);
	S:=S+Format('%8D',[I]);
	If (Cnt mod 5)=0 then S:=S+#$0D#$0A;
	end;
Memo.Lines.Add('Count='+IntToStr(Cnt));
Memo.Lines.Add(S);
end;

</syntaxhighlight>
{{out}}
<pre>
Count=23
       0       1       3       5      15
      17      51      85     255     257
     273     771     819    1285    1365
    3855    4095    4097    4369   12291
   13107   20485   21845
</pre>


=={{header|Euler}}==
 '''begin'''
 
     '''new''' palendromic; '''new''' n; '''label''' forN;
 
     palendromic
         &lt;- ` '''formal''' n; '''formal''' base;
              '''begin'''
                  '''new''' v; '''new''' lPos; '''new''' rPos; '''new''' isPalendromic;
                  '''new''' digit;
                  '''label''' vGT0; '''label''' rGTl;
                  digit &lt;- '''list''' 64;
                  rPos  &lt;- 0;
                  v     &lt;- n;
 vGT0:            '''if''' v &gt; 0 '''then''' '''begin'''
                      rPos          &lt;- rPos + 1;
                      digit[ rPos ] &lt;- v '''mod''' base;
                      v             &lt;- v  %  base;
                      '''goto''' vGT0
                  '''end''' '''else''' 0;
                  isPalendromic &lt;- '''true''';
                  lPos          &lt;- 1;
 rGTl:            '''if''' rPos &gt; lPos '''and''' isPalendromic '''then''' '''begin'''
                      isPalendromic &lt;- digit[ lPos ] = digit[ rPos ];
                      lPos          &lt;- lPos + 1;
                      rPos          &lt;- rPos - 1;
                      '''goto''' rGTl
                  '''end''' '''else''' 0;
                  isPalendromic
              '''end'''
            &apos;
          ;
 
          '''out''' 0;
          n &lt;- -1;
 forN:    '''if''' [ n &lt;- n + 2 ] &lt; 25000 '''then''' '''begin'''
              '''if'''      '''not''' palendromic( n, 16 ) '''then''' 0
              '''else''' '''if''' '''not''' palendromic( n,  4 ) '''then''' 0
              '''else''' '''if'''     palendromic( n,  2 ) '''then''' '''out''' n
              '''else'''                                  0
              ;
              '''goto''' forN
          '''end''' '''else''' 0
 
 '''end''' $
 
{{out}}
<pre>
    NUMBER                   0
    NUMBER                   1
    NUMBER                   3
    NUMBER                   5
    NUMBER                  15
    NUMBER                  17
    NUMBER                  51
    NUMBER                  85
    NUMBER                 255
    NUMBER                 257
    NUMBER                 273
    NUMBER                 771
    NUMBER                 819
    NUMBER                1285
    NUMBER                1365
    NUMBER                3855
    NUMBER                4095
    NUMBER                4097
    NUMBER                4369
    NUMBER               12291
    NUMBER               13107
    NUMBER               20485
    NUMBER               21845
</pre>

=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Palindromic numbers in bases 2,4, and 16. Nigel Galloway: June 25th., 2021
let fG n g=let rec fG n g=[yield n%g; if n>=g then yield! fG(n/g) g] in let n=fG n g in n=List.rev n
Seq.initInfinite id|>Seq.takeWhile((>)25000)|>Seq.filter(fun g->fG g 16 && fG g 4 && fG g 2)|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
{{out}}
<pre>
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: io kernel math.parser prettyprint sequences ;

25,000 <iota> [
    { 2 4 16 } [ >base ] with map [ dup reverse = ] all?
] filter [ pprint bl ] each nl</syntaxhighlight>
{{out}}
<pre>
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845 
</pre>

=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">function ispal( byval n as integer, b as integer ) as boolean
    'determines if n is palindromic in base b
    dim as string ns
    while n
        ns += chr(48+n mod b)       'temporarily represent as a string
        n\=b
    wend
    for i as integer = 1 to len(ns)\2
        if mid(ns,i,1)<>mid(ns,len(ns)-i+1,1) then return false
    next i
    return true
end function

for i as integer = 0 to 25000
    if ispal(i,16) andalso ispal(i,4) andalso ispal(i,2) then print i;"  ";
next i</syntaxhighlight>
{{out}}<pre>0   1   3   5   15   17   51   85   255   257   273   771   819   1285   1365   3855   4095   4097   4369   12291   13107   20485   21845</pre>

=={{header|Go}}==
{{libheader|Go-rcu}}
<syntaxhighlight lang="go">package main

import (
    "fmt"
    "rcu"
    "strconv"
)

func reverse(s string) string {
    chars := []rune(s)
    for i, j := 0, len(chars)-1; i < j; i, j = i+1, j-1 {
        chars[i], chars[j] = chars[j], chars[i]
    }
    return string(chars)
}

func main() {
    fmt.Println("Numbers under 25,000 in base 10 which are palindromic in bases 2, 4 and 16:")
    var numbers []int
    for i := int64(0); i < 25000; i++ {
        b2 := strconv.FormatInt(i, 2)
        if b2 == reverse(b2) {
            b4 := strconv.FormatInt(i, 4)
            if b4 == reverse(b4) {
                b16 := strconv.FormatInt(i, 16)
                if b16 == reverse(b16) {
                    numbers = append(numbers, int(i))
                }
            }
        }
    }
    for i, n := range numbers {
        fmt.Printf("%6s ", rcu.Commatize(n))
        if (i+1)%10 == 0 {
            fmt.Println()
        }
    }
    fmt.Println("\n\nFound", len(numbers), "such numbers.")
}</syntaxhighlight>

{{out}}
<pre>
Numbers under 25,000 in base 10 which are palindromic in bases 2, 4 and 16:
     0      1      3      5     15     17     51     85    255    257 
   273    771    819  1,285  1,365  3,855  4,095  4,097  4,369 12,291 
13,107 20,485 21,845 

Found 23 such numbers.
</pre>

=={{header|J}}==
<syntaxhighlight lang="j">   palinbase=: (-: |.)@(#.inv)"0
   I. (2&palinbase * 4&palinbase * 16&palinbase) i.25e3
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</syntaxhighlight>

=={{header|jq}}==
{{works with|jq}}
'''Also works with gojq and fq, the Go implementations'''

'''With minor tweaks, also works with jaq, the Rust implementation'''

This entry, which uses a stream-oriented approach to illustrate an
economical use of memory, uses `tobase` as found in the Wikipedia article on jq; it works for
bases up to 36 inclusive.

Use gojq or fq for unbounded-precision integer arithmetic.
<syntaxhighlight lang=jq>
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

# nwise/2 assumes that null can be taken as the eos marker
def nwise(stream; $n):
  foreach (stream, null) as $x ([];
    if length == $n then [$x] else . + [$x] end;
    if (.[-1] == null) and length>1 then .[:-1]
    elif length == $n then .
    else empty
    end);

def tobase($b):
  def digit: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[.:.+1];
  def mod: . % $b;
  def div: ((. - mod) / $b);
  def digits: recurse( select(. > 0) | div) | mod ;
  # For jq it would be wise to protect against `infinite` as input, but using `isinfinite` confuses gojq
  select( (tostring|test("^[0-9]+$")) and 2 <= $b and $b <= 36)
  | if . == 0 then "0"
    else [digits | digit] | reverse[1:] | add
    end;

# boolean
def palindrome: explode as $in | ($in|reverse) == $in;

# boolean
def palindrome($b):
  tobase($b) | palindrome;
   
def task($n):
  "Numbers under \($n) in base 10 which are palindromic in bases 2, 4 and 16:",
  (nwise(range(0;$n) | select(palindrome(2) and palindrome(4) and palindrome(16)); 5)
   | map( lpad(6) ) | join(" "));

task(25000)
</syntaxhighlight>
{{output}}
<pre>
Numbers under 25000 in base 10 which are palindromic in bases 2, 4 and 16:
     0      1      3      5     15
    17     51     85    255    257
   273    771    819   1285   1365
  3855   4095   4097   4369  12291
 13107  20485  21845
</pre>

=={{header|Julia}}==
<syntaxhighlight lang="julia">palinbases(n, bases = [2, 4, 16]) = all(b -> (d = digits(n, base = b); d == reverse(d)), bases)

foreach(p -> print(rpad(p[2], 7), p[1] % 11 == 0 ? "\n" : ""), enumerate(filter(palinbases, 1:25000)))
</syntaxhighlight>{{out}}
<pre>
1      3      5      15     17     51     85     255    257    273    771    
819    1285   1365   3855   4095   4097   4369   12291  13107  20485  21845
</pre>

=={{header|Lua}}==
<syntaxhighlight lang="lua">
do -- find numbers palendromic in bases 2, 4, and 16

    local function palendromic( n, base )
        local digits, v = "", n
        while v > 0 do
            local dPos = ( v % base ) + 1
            digits = digits..string.sub( "0123456789abcdef", dPos, dPos )
            v = math.floor( v / base )
        end
        return digits == string.reverse( digits )
    end
    -- as noted by the REXX sample, all even numbers end in 0 in base 2
    -- so 0 is the only possible even number, note 0 is palendromic in all bases
    io.write( " 0" )
    for n = 1, 24999, 2 do
        if palendromic( n, 16 ) then
            if palendromic( n, 4 ) then
                if palendromic( n, 2 ) then
                    io.write( " ", n )
                end
            end
        end
    end
end
</syntaxhighlight>
{{out}}
<pre>
 0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[PalindromeBaseQ, Palindrom2416Q]
PalindromeBaseQ[n_Integer, b_Integer] := PalindromeQ[IntegerDigits[n, b]]
Palindrom2416Q[n_Integer] := PalindromeBaseQ[n, 2] \[And] PalindromeBaseQ[n, 4] \[And] PalindromeBaseQ[n, 16]
Select[Range[0, 24999], Palindrom2416Q]
Length[%]</syntaxhighlight>
{{out}}
<pre>{0, 1, 3, 5, 15, 17, 51, 85, 255, 257, 273, 771, 819, 1285, 1365, 3855, 4095, 4097, 4369, 12291, 13107, 20485, 21845}
23</pre>

=={{header|Nim}}==
<syntaxhighlight lang="nim">import strutils, sugar

type Digit = 0..15

func toBase(n: Natural; b: Positive): seq[Digit] =
  if n == 0: return @[Digit 0]
  var n = n
  while n != 0:
    result.add n mod b
    n = n div b

func isPalindromic(s: seq[Digit]): bool =
  for i in 1..(s.len div 2):
    if s[i-1] != s[^i]: return false
  result = true

let list = collect(newSeq):
             for n in 0..<25_000:
               if n.toBase(2).isPalindromic and
                  n.toBase(4).isPalindromic and
                  n.toBase(16).isPalindromic: n

echo "Found ", list.len, " numbers which are palindromic in bases 2, 4 and 16:"
echo list.join(" ")</syntaxhighlight>

{{out}}
<pre>Found 23 numbers which are palindromic in bases 2, 4 and 16:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845</pre>

=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl">use strict;
use warnings;
use ntheory 'todigitstring';

sub pb { my $s = todigitstring(shift,shift); return $s eq join '', reverse split '', $s }

pb($_,2) and pb($_,4) and pb($_,16) and print "$_ " for 1..25000;</syntaxhighlight>
{{out}}
<pre>1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845</pre>

=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 <span style="color: #008080;">function</span> <span style="color: #000000;">palindrome</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
 <span style="color: #008080;">function</span> <span style="color: #000000;">p2416</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
     <span style="color: #008080;">return</span> <span style="color: #000000;">palindrome</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%a"</span><span style="color: #0000FF;">,{{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">}}))</span>
        <span style="color: #008080;">and</span> <span style="color: #000000;">palindrome</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%a"</span><span style="color: #0000FF;">,{{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">}}))</span>
        <span style="color: #008080;">and</span> <span style="color: #000000;">palindrome</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%a"</span><span style="color: #0000FF;">,{{</span><span style="color: #000000;">16</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">}}))</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
 <span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">25000</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">),</span><span style="color: #000000;">p2416</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">)</span>
 <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d found: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
23 found: 0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|PL/M}}==
<syntaxhighlight lang="plm">100H:
/* CP/M CALLS */
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;

DECLARE MAXIMUM LITERALLY '25$000';

/* PRINT A NUMBER */
PRINT$NUMBER: PROCEDURE (N);
    DECLARE S (7) BYTE INITIAL ('..... $');
    DECLARE (N, P) ADDRESS, C BASED P BYTE;
    P = .S(5);
DIGIT:
    P = P - 1;
    C = N MOD 10 + '0';
    N = N / 10;
    IF N > 0 THEN GO TO DIGIT;
    CALL PRINT(P);
END PRINT$NUMBER;

/* REVERSE NUMBER GIVEN BASE */
REVERSE: PROCEDURE (N, B) ADDRESS;
    DECLARE (N, R) ADDRESS, B BYTE;
    R = 0;
    DO WHILE N > 0;
        R = R*B + N MOD B;
        N = N/B;
    END;
    RETURN R;
END REVERSE;

/* CHECK IF NUMBER IS PALINDROME */
PALIN: PROCEDURE (N, B) BYTE;
    DECLARE N ADDRESS, B BYTE;
    RETURN N = REVERSE(N, B);
END PALIN;

DECLARE I ADDRESS, C BYTE;
C = 0;
DO I = 0 TO MAXIMUM;
    IF PALIN(I,2) AND PALIN(I,4) AND PALIN(I,16) THEN DO;
        CALL PRINT$NUMBER(I);
        C = C + 1;
        IF C = 15 THEN DO;
            CALL PRINT(.(13,10,'$'));
            C = 0;
        END;
    END;
END;
CALL EXIT;
EOF</syntaxhighlight>
{{out}}
<pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365
3855 4095 4097 4369 12291 13107 20485 21845</pre>

=={{header|Python}}==
<syntaxhighlight lang="python">def reverse(n, base):
    r = 0
    while n > 0:
        r = r*base + n%base
        n = n//base
    return r
    
def palindrome(n, base):
    return n == reverse(n, base)
    
cnt = 0
for i in range(25000):
    if all(palindrome(i, base) for base in (2,4,16)):
        cnt += 1
        print("{:5}".format(i), end=" \n"[cnt % 12 == 0])

print()</syntaxhighlight>
{{out}}
<pre>    0     1     3     5    15    17    51    85   255   257   273   771
  819  1285  1365  3855  4095  4097  4369 12291 13107 20485 21845</pre>

=={{header|Quackery}}==

<syntaxhighlight lang="Quackery">
  [ temp put
    0
    [ over 0 > while
      temp share tuck *
      dip /mod +
      again ]
    temp release
    nip ]               is rev ( n n --> n )

  [ dip dup rev = ]     is pal ( n n --> b )

  []
  25000 times
    [ i^ 16 pal while
      i^  4 pal while
      i^  2 pal while
      i^ join ]
  echo</syntaxhighlight>

{{out}}

<pre>[ 0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845 ]</pre>

=={{header|Raku}}==
<syntaxhighlight lang="raku" line>put "{+$_} such numbers:\n", .batch(10)».fmt('%5d').join("\n") given
(^25000).grep: -> $n { all (2,4,16).map: { $n.base($_) eq $n.base($_).flip } }</syntaxhighlight>
{{out}}
<pre>23 such numbers:
    0     1     3     5    15    17    51    85   255   257
  273   771   819  1285  1365  3855  4095  4097  4369 12291
13107 20485 21845</pre>

=={{header|REXX}}==
Programming note: &nbsp; the conversions of a decimal number to another base (radix) was ordered such that the fastest 
<br>base conversion was performed before the other conversions. 

The use of REXX's BIFs to convert decimal numbers to binary and hexadecimal were used &nbsp; (instead of the &nbsp; '''base''' &nbsp; 
<br>function) &nbsp; because they are much faster).

This REXX version takes advantage that no &nbsp; ''even'' &nbsp; integers need be tested &nbsp; (except for the single exception: &nbsp; zero), 
<br>this makes the execution twice as fast.
<syntaxhighlight lang="rexx">/*REXX pgm finds non─neg integers that are palindromes in base 2, 4, and 16, where N<25k*/
numeric digits 100                               /*ensure enough dec. digs for large #'s*/
parse arg n cols .                               /*obtain optional argument from the CL.*/
if    n=='' |    n==","  then   n = 25000        /*Not specified?  Then use the default.*/
if cols=='' | cols==","  then cols=    10        /* "      "         "   "   "     "    */
w= 10                                            /*width of a number in any column.     */
title= ' non-negative integers that are palindromes in base 2, 4, and 16,  where  N  < ' ,
       commas(n)
say ' index │'center(title, 1 + cols*(w+1)     ) /*display the title for the output.    */
say '───────┼'center(""   , 1 + cols*(w+1), '─') /*   "     a   sep   "   "     "       */
$= right(0, w+1)                                 /*list of numbers found  (so far).     */
found= 1                                         /*# of finds (so far), the only even #.*/
idx= 1                                           /*set the IDX  (index) to unity.       */
       do j=1  by 2  to n-1                      /*find int palindromes in bases 2,4,16.*/
          h= d2x(j)                              /*convert dec. # to hexadecimal.       */
       if h\==reverse(h)          then iterate   /*Hex    number not palindromic?  Skip.*/    /* ◄■■■■■■■■ a filter. */
          b= x2b( d2x(j) ) + 0                   /*convert dec. # to hex, then to binary*/
       if b\==reverse(b)          then iterate   /*Binary number not palindromic?  Skip.*/    /* ◄■■■■■■■■ a filter. */
          q= base(j, 4)                          /*convert a decimal integer to base 4. */
       if q\==reverse(q)          then iterate   /*Base 4 number not palindromic?  Skip.*/    /* ◄■■■■■■■■ a filter. */
       found= found + 1                          /*bump number of found such numbers.   */
       $= $  right( commas(j), w)                /*add the found number  ───►  $  list. */
       if found // cols \== 0     then iterate   /*have we populated a line of output?  */
       say center(idx, 7)'│'  substr($, 2); $=   /*display what we have so far  (cols). */
       idx= idx + cols                           /*bump the  index  count for the output*/
       end   /*j*/

if $\==''  then say center(idx, 7)"│"  substr($, 2)  /*possible display residual output.*/
say '───────┴'center(""   , 1 + cols*(w+1), '─')     /*display the foot sep for output. */
say
say 'Found '          found          title
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?;  do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
base:   procedure; parse arg #,t,,y;  @= 0123456789abcdefghijklmnopqrstuvwxyz /*up to 36*/
        @@= substr(@, 2);    do while #>=t;   y= substr(@, #//t + 1, 1)y;         #= # % t
                             end;                       return substr(@, #+1, 1)y</syntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
 index │             non-negative integers that are palindromes in base 2, 4, and 16,  where  N  <  25,000
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │          0          1          3          5         15         17         51         85        255        257
  11   │        273        771        819      1,285      1,365      3,855      4,095      4,097      4,369     12,291
  21   │     13,107     20,485     21,845
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

Found  23  non-negative integers that are palindromes in base 2, 4, and 16,  where  N  <  25,000
</pre>

=={{header|Ring}}==
<syntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
see "Numbers in base 10 that are palindromic in bases 2, 4, and 16:" + nl

row = 0
limit = 25000

for n = 1 to limit
    base2 = decimaltobase(n,2)
    base4 = decimaltobase(n,4)
    base16 = hex(n)
    bool = ispalindrome(base2) and ispalindrome(base4) and ispalindrome(base16)
    if bool = 1
       see "" + n + " "
       row = row + 1
       if row%5 = 0
          see nl
       ok
    ok
next

see nl + "Found " + row + " numbers" + nl
see "done..." + nl

func decimaltobase(nr,base)
     decList = 0:15
     baseList = ["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]

     binList = [] 
     binary = 0
     remainder = 1
     while(nr != 0)
          remainder = nr % base
          ind = find(decList,remainder)
          rem = baseList[ind]
          add(binList,rem)
          nr = floor(nr/base) 
     end
     binlist = reverse(binList)
     binList = list2str(binList)
     binList = substr(binList,nl,"")  
     return binList
</syntaxhighlight>
{{out}}
<pre>
working...
Numbers in base 10 that are palindromic in bases 2, 4, and 16:
1 3 5 15 17 
51 85 255 257 273 
771 819 1285 1365 3855 
4095 4097 4369 12291 13107 
20485 21845 
Found 22 numbers
done...
</pre>

=={{header|RPL}}==
{{works with|HP|48}}
====Brute force====
 « "" 
   OVER SIZE 1 '''FOR''' j
     OVER j DUP SUB + 
   '''NEXT''' SWAP DROP
 » '<span style="color:blue">REVSTR</span>' STO 
 
 « → base 
   « ""
     '''WHILE''' OVER '''REPEAT'''
        SWAP base MOD LASTARG / IP
        "0123456789ABCDEF" ROT 1 + DUP SUB ROT +
     '''END''' SWAP DROP
 » » '<span style="color:blue">D→B</span>' STO 
 
 « '''CASE'''
      HEX DUP R→B →STR 3 OVER SIZE SUB DUP <span style="color:blue">REVSTR</span> ≠ '''THEN''' DROP 0 '''END'''
      DUP 4 <span style="color:blue">D→B</span> DUP <span style="color:blue">REVSTR</span> ≠                        '''THEN''' DROP 0 '''END'''
      BIN DUP R→B →STR 3 OVER SIZE SUB DUP <span style="color:blue">REVSTR</span> ==
   '''END'''
 » '<span style="color:blue">PAL2416</span>' STO 
 
 « { 0 }
   1 25000 '''FOR''' n
      '''IF''' n <span style="color:blue">PAL2416</span> '''THEN''' n + '''END'''
   2 '''STEP'''
 » '<span style="color:blue">TASK</span>' STO 
Runs in 42 minutes on a HP-48SX.

====Much faster approach====
The task generates palindromes in base 16, which must then be verified as palindromes in the other two bases.
 « BIN 1 SF 
   R→B →STR 3 OVER SIZE 1 - SUB 
   0 1 '''FOR''' b
      '''IF''' DUP SIZE b 1 + MOD '''THEN''' "0" SWAP + '''END'''
      "" 
      OVER SIZE b - 1 '''FOR''' j 
         OVER j DUP b + SUB +
     -1 b - '''STEP'''
     '''IF''' OVER ≠ '''THEN''' 1 CF 1 'b' STO '''END'''
  '''NEXT''' DROP
  1 FS?
 » '<span style="color:blue">PAL24?</span>' STO
 
 « HEX R→B →STR → h 
   « "#"
     h SIZE 1 - 3 '''FOR''' j 
        h j DUP SUB + 
     -1 '''STEP'''
     "h" + STR→ B→R
 » » ‘<span style="color:blue">REVHEX</span>’ STO
 
 « { }
  0 15 '''FOR''' b 
     '''IF''' b <span style="color:blue">PAL24?</span> '''THEN''' b + '''END NEXT'''
  1 2 '''FOR''' x
     -1 15 '''FOR''' m
        16 x 1 - ^ 16 x ^ 1 - '''FOR''' b
           b
           '''IF''' m 0 ≥ '''THEN''' 16 * m + '''END'''
           16 x ^ *
           b <span style="color:blue">REVHEX</span> + 
           '''IF''' DUP <span style="color:blue">PAL24?</span> '''THEN''' +
           '''ELSE IF''' 25000 ≥ '''THEN''' KILL '''END'''  <span style="color:grey">@ not idiomatic but useful to exit 3 nested loops</span>
           '''END'''
  '''NEXT NEXT NEXT'''
  SORT
 » '<span style="color:blue">TASK</span>' STO 

 <span style="color:blue">TASK</span> SORT
Runs in 2 minutes 16 on a HP-48SX: 18 times faster than brute force!
{{out}}
<pre>
1: { 0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845 }
</pre>

=={{header|Ruby}}==
<syntaxhighlight lang="ruby">res = (0..25000).select do |n|
  [2, 4, 16].all? do |base|
    b = n.to_s(base)
    b == b.reverse
  end
end
puts res.join(" ")</syntaxhighlight>
{{out}}
<pre>
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

const func boolean: palindrome (in string: input) is
  return input = reverse(input);

const proc: main is func
  local
    var integer: n is 1;
  begin
    write("0 ");
    for n range 1 to 24999 step 2 do
      if palindrome(n radix 2) and palindrome(n radix 4) and palindrome(n radix 16) then
        write(n <& " ");
      end if;
    end for;
  end func;</syntaxhighlight>
{{out}}
<pre>
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
</pre>

=={{header|Sidef}}==
<syntaxhighlight lang="ruby">say gather {
    for (var k = 0; k < 25_000; k = k.next_palindrome(16)) {
        take(k) if [2, 4].all{|b| k.is_palindrome(b) }
    }
}</syntaxhighlight>
{{out}}
<pre>
[0, 1, 3, 5, 15, 17, 51, 85, 255, 257, 273, 771, 819, 1285, 1365, 3855, 4095, 4097, 4369, 12291, 13107, 20485, 21845]
</pre>

=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Conv, Fmt

System.print("Numbers under 25,000 in base 10 which are palindromic in bases 2, 4 and 16:")
var numbers = []
for (i in 0..24999) {
    var b2 = Conv.itoa(i, 2)
    if (b2 == b2[-1..0]) {
        var b4 = Conv.itoa(i, 4)
        if (b4 == b4[-1..0]) {
            var b16 = Conv.itoa(i, 16)
            if (b16 == b16[-1..0]) numbers.add(i)
        }
    }
}
Fmt.tprint("$,6d", numbers, 8)
System.print("\nFound %(numbers.count) such numbers.")</syntaxhighlight>

{{out}}
<pre>
Numbers under 25,000 in base 10 which are palindromic in bases 2, 4 and 16:
     0      1      3      5     15     17     51     85
   255    257    273    771    819  1,285  1,365  3,855
 4,095  4,097  4,369 12,291 13,107 20,485 21,845

Found 23 such numbers.
</pre>

=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">func Reverse(N, Base);  \Reverse order of digits in N for given Base
int  N, Base, M;
[M:= 0;
repeat  N:= N/Base;
        M:= M*Base + rem(0);
until   N=0;
return M;
];

int Count, N;
[Count:= 0;
for N:= 1 to 25000-1 do
    if N = Reverse(N, 2) &
       N = Reverse(N, 4) &
       N = Reverse(N, 16) then
        [IntOut(0, N);
        Count:= Count+1;
        if rem(Count/10) = 0 then CrLf(0) else ChOut(0, 9\tab\);
        ];
CrLf(0);
IntOut(0, Count);
Text(0, " such numbers found.
");
]</syntaxhighlight>

{{out}}
<pre>
1       3       5       15      17      51      85      255     257     273
771     819     1285    1365    3855    4095    4097    4369    12291   13107
20485   21845   
22 such numbers found.
</pre>