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

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

Revision as of 11:38, 6 January 2024

19,892 bytes added , 4 months ago

m

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

PureFox

9,476

edits

Revision as of 23:05, 24 June 2021 (view source) Not a robot (talk \| contribs) (Add COBOL) ← Older edit		Revision as of 11:38, 6 January 2024 (view source) PureFox (talk \| contribs) m (→‎{{header\|Wren}}: Minor tidy) Newer edit →
(32 intermediate revisions by 19 users not shown)
Line 4: <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> Line 64 ⟶ 180: =={{header\|APL}}== {{works with\|Dyalog APL}} <~~lang~~syntaxhighlight lang="apl">(⊢(/⍨)(2 4 16∧.((⊢≡⌽)(⊥⍣¯1))⊢)¨)0,⍳24999</~~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\|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 81 ⟶ 249: 120 R=RB+N MOD B 130 N=N\B 140 GOTO 110</~~lang~~syntaxhighlight> {{out}} <pre> 0 1 3 5 15 Line 90 ⟶ 258: =={{header\|BCPL}}== <~~lang~~syntaxhighlight lang="bcpl">get "libhdr" manifest $( MAXIMUM = 25000 $) Line 107 ⟶ 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 134 ⟶ 302: =={{header\|C}}== <~~lang~~syntaxhighlight lang="c">#include <stdio.h> #define MAXIMUM 25000 Line 160 ⟶ 328: printf("\n"); return 0; }</~~lang~~syntaxhighlight> {{out}} <pre> 0 1 3 5 15 17 51 85 255 257 273 771 Line 166 ⟶ 334: =={{header\|COBOL}}== <~~lang~~syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. PROGRAM-ID. PALINDROMIC-BASE-2-4-16. Line 209 ⟶ 377: ADD REV-DGT TO REVERSED MOVE REV-NEXT TO REV-REST GO TO REV-LOOP.</~~lang~~syntaxhighlight> {{out}} <pre> 0 Line 236 ⟶ 404: =={{header\|Cowgol}}== <~~lang~~syntaxhighlight lang="cowgol">include "cowgol.coh"; const MAXIMUM := 25000; Line 265 ⟶ 433: i := i + 1; end loop; print_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\|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 322 ⟶ 679: } fmt.Println("\n\nFound", len(numbers), "such numbers.") }</~~lang~~syntaxhighlight> {{out}} Line 333 ⟶ 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 345 ⟶ 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> Line 352 ⟶ 867: =={{header\|PL/M}}== <~~lang~~syntaxhighlight lang="plm">100H: /* CP/M CALLS / BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS; Line 403 ⟶ 918: END; CALL EXIT; EOF</~~lang~~syntaxhighlight> {{out}} <pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 Line 409 ⟶ 924: =={{header\|Python}}== <~~lang~~syntaxhighlight lang="python">def reverse(n, base): r = 0 while n > 0: Line 425 ⟶ 940: print("{:5}".format(i), end=" \n"[cnt % 12 == 0]) print()</~~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\|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 448 ⟶ 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 485 ⟶ 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 499 ⟶ 1,040: =={{header\|Ring}}== <~~lang~~syntaxhighlight lang="ring"> load "stdlib.ring" see "working..." + nl Line 542 ⟶ 1,083: binList = substr(binList,nl,"") return binList </syntaxhighlight> ~~</lang>~~ {{out}} <pre> Line 554 ⟶ 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}}== <~~lang~~syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; const func boolean: palindrome (in string: input) is Line 572 ⟶ 1,204: end if; end for; end func;</~~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\|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 596 ⟶ 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 610 ⟶ 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 633 ⟶ 1,274: Text(0, " such numbers found. "); ]</~~lang~~syntaxhighlight> {{out}}