Numbers in base 10 that are palindromic in bases 2, 4, and 16: Difference between revisions

← Older edit

Numbers in base 10 that are palindromic in bases 2, 4, and 16 (view source)

Revision as of 11:38, 6 January 2024

25,756 bytes added , 4 months ago

m

→‎{{header|Wren}}: Minor tidy

PureFox

9,476

edits

Revision as of 22:03, 24 June 2021 (view source) Not a robot (talk \| contribs) (Add BASIC) ← Older edit		Latest revision as of 11:38, 6 January 2024 (view source) PureFox (talk \| contribs) m (→‎{{header\|Wren}}: Minor tidy)
(40 intermediate revisions by 22 users not shown)
Line 1: {{Draft task}} ;Task: Find numbers in base 10 that are palindromic in bases 2, 4, and 16, where '''n < ~~25000~~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}}== <~~lang~~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 # Line 46 ⟶ 112: is palindromic END; # print the numbers in decimal that are palendromic ~~primes~~ in bases 2, 4 and 16 # # as noted by the REXX sample, even numbers ( other than 0 ) aren't # ~~FOR n FROM 0 TO max number DO~~ # 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 Line 56 ⟶ 125: FI OD END~~</lang>~~ </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(rbase) + 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}}== <~~lang~~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 Line 75 ⟶ 249: 120 R=RB+N MOD B 130 N=N\B 140 GOTO 110</~~lang~~syntaxhighlight> {{out}} <pre> 0 1 3 5 15 Line 84 ⟶ 258: =={{header\|BCPL}}== <~~lang~~syntaxhighlight lang="bcpl">get "libhdr" manifest $( MAXIMUM = 25000 $) Line 101 ⟶ 275: for i = 0 to MAXIMUM if palindrome(i,2) & palindrome(i,4) & palindrome(i,16) do writef("%NN", i)</~~lang~~syntaxhighlight> {{out}} <pre>0 Line 126 ⟶ 300: 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 = rbase + 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 <- ` '''formal''' n; '''formal''' base; '''begin''' '''new''' v; '''new''' lPos; '''new''' rPos; '''new''' isPalendromic; '''new''' digit; '''label''' vGT0; '''label''' rGTl; digit <- '''list''' 64; rPos <- 0; v <- n; vGT0: '''if''' v > 0 '''then''' '''begin''' rPos <- rPos + 1; digit[ rPos ] <- v '''mod''' base; v <- v % base; '''goto''' vGT0 '''end''' '''else''' 0; isPalendromic <- '''true'''; lPos <- 1; rGTl: '''if''' rPos > lPos '''and''' isPalendromic '''then''' '''begin''' isPalendromic <- digit[ lPos ] = digit[ rPos ]; lPos <- lPos + 1; rPos <- rPos - 1; '''goto''' rGTl '''end''' '''else''' 0; isPalendromic '''end''' ' ; '''out''' 0; n <- -1; forN: '''if''' [ n <- n + 2 ] < 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}} <~~lang~~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</~~lang~~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}} <~~lang~~syntaxhighlight lang="go">package main import ( Line 179 ⟶ 679: } fmt.Println("\n\nFound", len(numbers), "such numbers.") }</~~lang~~syntaxhighlight> {{out}} Line 190 ⟶ 690: 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}}== <!--<~~lang~~syntaxhighlight ~~Phix~~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> Line 202 ⟶ 860: <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> <!--</~~lang~~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 = RB + 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 = rbase + 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" ~~perl6~~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 } }</~~lang~~syntaxhighlight> {{out}} <pre>23 such numbers: Line 226 ⟶ 989: This REXX version takes advantage that no   ''even''   integers need be tested   (except for the single exception:   zero), <br>this makes the execution twice as fast. <~~lang~~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./ Line 263 ⟶ 1,026: 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</~~lang~~syntaxhighlight> {{out\|output\|text=  when using the default inputs:}} <pre> Line 277 ⟶ 1,040: =={{header\|Ring}}== <~~lang~~syntaxhighlight lang="ring"> load "stdlib.ring" see "working..." + nl Line 320 ⟶ 1,083: binList = substr(binList,nl,"") return binList </syntaxhighlight> ~~</lang>~~ {{out}} <pre> Line 332 ⟶ 1,095: 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 ~~{{libheader\|Wren-seq}}~~ ~~<lang ecmascript>import "/fmt" for Conv, Fmt~~ ~~import "/seq" for Lst~~ System.print("Numbers under 25,000 in base 10 which are palindromic in bases 2, 4 and 16:") Line 352 ⟶ 1,237: } } ~~for (chunk in Lst.chunks(numbers, 8))~~ Fmt.~~print~~tprint("$,6d", ~~chunk~~numbers, 8) System.print("\nFound %(numbers.count) such numbers.")</~~lang~~syntaxhighlight> {{out}} Line 366 ⟶ 1,251: =={{header\|XPL0}}== <~~lang~~syntaxhighlight ~~XPL0~~lang="xpl0">func Reverse(N, Base); \Reverse order of digits in N for given Base int N, Base, M; [M:= 0; Line 389 ⟶ 1,274: Text(0, " such numbers found. "); ]</~~lang~~syntaxhighlight> {{out}}