Numbers in base 10 that are palindromic in bases 2, 4, and 16: Difference between revisions
Content added Content deleted
(→{{header|J}}: base 4, not base 8) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 8: | Line 8: | ||
{{trans|Python}} |
{{trans|Python}} |
||
< |
<syntaxhighlight lang="11l">F reverse(=n, base) |
||
V r = 0 |
V r = 0 |
||
L n > 0 |
L n > 0 |
||
Line 24: | Line 24: | ||
print(‘#5’.format(i), end' " \n"[cnt % 12 == 0]) |
print(‘#5’.format(i), end' " \n"[cnt % 12 == 0]) |
||
print()</ |
print()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 33: | Line 33: | ||
=={{header|Action!}}== |
=={{header|Action!}}== |
||
< |
<syntaxhighlight lang="action!">BYTE FUNC IsPalindrome(INT x BYTE base) |
||
CHAR ARRAY digits="0123456789abcdef",s(16) |
CHAR ARRAY digits="0123456789abcdef",s(16) |
||
BYTE d,i,len |
BYTE d,i,len |
||
Line 64: | Line 64: | ||
FI |
FI |
||
OD |
OD |
||
RETURN</ |
RETURN</syntaxhighlight> |
||
{{out}} |
{{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] |
[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] |
||
Line 72: | Line 72: | ||
=={{header|ALGOL 68}}== |
=={{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 max number = 25 000; # maximum number to consider # |
||
INT min base = 2; # smallest base needed # |
INT min base = 2; # smallest base needed # |
||
Line 122: | Line 122: | ||
FI |
FI |
||
OD |
OD |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 130: | Line 130: | ||
=={{header|APL}}== |
=={{header|APL}}== |
||
{{works with|Dyalog APL}} |
{{works with|Dyalog APL}} |
||
< |
<syntaxhighlight lang="apl">(⊢(/⍨)(2 4 16∧.((⊢≡⌽)(⊥⍣¯1))⊢)¨)0,⍳24999</syntaxhighlight> |
||
{{out}} |
{{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> |
<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}}== |
=={{header|AWK}}== |
||
<syntaxhighlight lang="awk"> |
|||
<lang AWK> |
|||
# syntax: GAWK -f NUMBERS_IN_BASE_10_THAT_ARE_PALINDROMIC_IN_BASES_2_4_AND_16.AWK |
# syntax: GAWK -f NUMBERS_IN_BASE_10_THAT_ARE_PALINDROMIC_IN_BASES_2_4_AND_16.AWK |
||
# converted from C |
# converted from C |
||
Line 157: | Line 157: | ||
return(r) |
return(r) |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 167: | Line 167: | ||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
< |
<syntaxhighlight lang="basic">10 DEFINT A-Z: DEFDBL R |
||
20 FOR I=1 TO 25000 |
20 FOR I=1 TO 25000 |
||
30 B=2: GOSUB 100: IF R<>I GOTO 70 |
30 B=2: GOSUB 100: IF R<>I GOTO 70 |
||
Line 179: | Line 179: | ||
120 R=R*B+N MOD B |
120 R=R*B+N MOD B |
||
130 N=N\B |
130 N=N\B |
||
140 GOTO 110</ |
140 GOTO 110</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 1 3 5 15 |
<pre> 0 1 3 5 15 |
||
Line 188: | Line 188: | ||
=={{header|BCPL}}== |
=={{header|BCPL}}== |
||
< |
<syntaxhighlight lang="bcpl">get "libhdr" |
||
manifest $( MAXIMUM = 25000 $) |
manifest $( MAXIMUM = 25000 $) |
||
Line 205: | Line 205: | ||
for i = 0 to MAXIMUM |
for i = 0 to MAXIMUM |
||
if palindrome(i,2) & palindrome(i,4) & palindrome(i,16) |
if palindrome(i,2) & palindrome(i,4) & palindrome(i,16) |
||
do writef("%N*N", i)</ |
do writef("%N*N", i)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 |
<pre>0 |
||
Line 232: | Line 232: | ||
=={{header|C}}== |
=={{header|C}}== |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
#define MAXIMUM 25000 |
#define MAXIMUM 25000 |
||
Line 258: | Line 258: | ||
printf("\n"); |
printf("\n"); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 1 3 5 15 17 51 85 255 257 273 771 |
<pre> 0 1 3 5 15 17 51 85 255 257 273 771 |
||
Line 264: | Line 264: | ||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
< |
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
||
PROGRAM-ID. PALINDROMIC-BASE-2-4-16. |
PROGRAM-ID. PALINDROMIC-BASE-2-4-16. |
||
Line 307: | Line 307: | ||
ADD REV-DGT TO REVERSED |
ADD REV-DGT TO REVERSED |
||
MOVE REV-NEXT TO REV-REST |
MOVE REV-NEXT TO REV-REST |
||
GO TO REV-LOOP.</ |
GO TO REV-LOOP.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 |
<pre> 0 |
||
Line 334: | Line 334: | ||
=={{header|Cowgol}}== |
=={{header|Cowgol}}== |
||
< |
<syntaxhighlight lang="cowgol">include "cowgol.coh"; |
||
const MAXIMUM := 25000; |
const MAXIMUM := 25000; |
||
Line 363: | Line 363: | ||
i := i + 1; |
i := i + 1; |
||
end loop; |
end loop; |
||
print_nl();</ |
print_nl();</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 |
<pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 |
||
Line 369: | Line 369: | ||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp"> |
||
// Palindromic numbers in bases 2,4, and 16. Nigel Galloway: June 25th., 2021 |
// 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 |
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 "" |
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> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 381: | Line 381: | ||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
{{works with|Factor|0.99 2021-06-02}} |
{{works with|Factor|0.99 2021-06-02}} |
||
< |
<syntaxhighlight lang="factor">USING: io kernel math.parser prettyprint sequences ; |
||
25,000 <iota> [ |
25,000 <iota> [ |
||
{ 2 4 16 } [ >base ] with map [ dup reverse = ] all? |
{ 2 4 16 } [ >base ] with map [ dup reverse = ] all? |
||
] filter [ pprint bl ] each nl</ |
] filter [ pprint bl ] each nl</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 392: | Line 392: | ||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
< |
<syntaxhighlight lang="freebasic">function ispal( byval n as integer, b as integer ) as boolean |
||
'determines if n is palindromic in base b |
'determines if n is palindromic in base b |
||
dim as string ns |
dim as string ns |
||
Line 407: | Line 407: | ||
for i as integer = 0 to 25000 |
for i as integer = 0 to 25000 |
||
if ispal(i,16) andalso ispal(i,4) andalso ispal(i,2) then print i;" "; |
if ispal(i,16) andalso ispal(i,4) andalso ispal(i,2) then print i;" "; |
||
next 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> |
{{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}}== |
=={{header|Go}}== |
||
{{libheader|Go-rcu}} |
{{libheader|Go-rcu}} |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 450: | Line 450: | ||
} |
} |
||
fmt.Println("\n\nFound", len(numbers), "such numbers.") |
fmt.Println("\n\nFound", len(numbers), "such numbers.") |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 463: | Line 463: | ||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j"> palinbase=: (-: |.)@(#.inv)"0 |
||
I. (2&palinbase * 4&palinbase * 16&palinbase) i.25e3 |
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 |
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Julia}}== |
=={{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))) |
foreach(p -> print(rpad(p[2], 7), p[1] % 11 == 0 ? "\n" : ""), enumerate(filter(palinbases, 1:25000))) |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
1 3 5 15 17 51 85 255 257 273 771 |
1 3 5 15 17 51 85 255 257 273 771 |
||
Line 479: | Line 479: | ||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">ClearAll[PalindromeBaseQ, Palindrom2416Q] |
||
PalindromeBaseQ[n_Integer, b_Integer] := PalindromeQ[IntegerDigits[n, b]] |
PalindromeBaseQ[n_Integer, b_Integer] := PalindromeQ[IntegerDigits[n, b]] |
||
Palindrom2416Q[n_Integer] := PalindromeBaseQ[n, 2] \[And] PalindromeBaseQ[n, 4] \[And] PalindromeBaseQ[n, 16] |
Palindrom2416Q[n_Integer] := PalindromeBaseQ[n, 2] \[And] PalindromeBaseQ[n, 4] \[And] PalindromeBaseQ[n, 16] |
||
Select[Range[0, 24999], Palindrom2416Q] |
Select[Range[0, 24999], Palindrom2416Q] |
||
Length[%]</ |
Length[%]</syntaxhighlight> |
||
{{out}} |
{{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>{0, 1, 3, 5, 15, 17, 51, 85, 255, 257, 273, 771, 819, 1285, 1365, 3855, 4095, 4097, 4369, 12291, 13107, 20485, 21845} |
||
Line 489: | Line 489: | ||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
< |
<syntaxhighlight lang="nim">import strutils, sugar |
||
type Digit = 0..15 |
type Digit = 0..15 |
||
Line 512: | Line 512: | ||
echo "Found ", list.len, " numbers which are palindromic in bases 2, 4 and 16:" |
echo "Found ", list.len, " numbers which are palindromic in bases 2, 4 and 16:" |
||
echo list.join(" ")</ |
echo list.join(" ")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 520: | Line 520: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
{{libheader|ntheory}} |
{{libheader|ntheory}} |
||
< |
<syntaxhighlight lang="perl">use strict; |
||
use warnings; |
use warnings; |
||
use ntheory 'todigitstring'; |
use ntheory 'todigitstring'; |
||
Line 526: | Line 526: | ||
sub pb { my $s = todigitstring(shift,shift); return $s eq join '', reverse split '', $s } |
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;</ |
pb($_,2) and pb($_,4) and pb($_,16) and print "$_ " for 1..25000;</syntaxhighlight> |
||
{{out}} |
{{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> |
<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}}== |
=={{header|Phix}}== |
||
<!--< |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
<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;">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 541: | Line 541: | ||
<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: #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> |
<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}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 548: | Line 548: | ||
=={{header|PL/M}}== |
=={{header|PL/M}}== |
||
< |
<syntaxhighlight lang="plm">100H: |
||
/* CP/M CALLS */ |
/* CP/M CALLS */ |
||
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS; |
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS; |
||
Line 599: | Line 599: | ||
END; |
END; |
||
CALL EXIT; |
CALL EXIT; |
||
EOF</ |
EOF</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 |
<pre>0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 |
||
Line 605: | Line 605: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">def reverse(n, base): |
||
r = 0 |
r = 0 |
||
while n > 0: |
while n > 0: |
||
Line 621: | Line 621: | ||
print("{:5}".format(i), end=" \n"[cnt % 12 == 0]) |
print("{:5}".format(i), end=" \n"[cnt % 12 == 0]) |
||
print()</ |
print()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 1 3 5 15 17 51 85 255 257 273 771 |
<pre> 0 1 3 5 15 17 51 85 255 257 273 771 |
||
Line 627: | Line 627: | ||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
<lang |
<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 } }</ |
(^25000).grep: -> $n { all (2,4,16).map: { $n.base($_) eq $n.base($_).flip } }</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>23 such numbers: |
<pre>23 such numbers: |
||
Line 644: | Line 644: | ||
This REXX version takes advantage that no ''even'' integers need be tested (except for the single exception: zero), |
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. |
<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*/ |
numeric digits 100 /*ensure enough dec. digs for large #'s*/ |
||
parse arg n cols . /*obtain optional argument from the CL.*/ |
parse arg n cols . /*obtain optional argument from the CL.*/ |
||
Line 681: | Line 681: | ||
base: procedure; parse arg #,t,,y; @= 0123456789abcdefghijklmnopqrstuvwxyz /*up to 36*/ |
base: procedure; parse arg #,t,,y; @= 0123456789abcdefghijklmnopqrstuvwxyz /*up to 36*/ |
||
@@= substr(@, 2); do while #>=t; y= substr(@, #//t + 1, 1)y; #= # % t |
@@= substr(@, 2); do while #>=t; y= substr(@, #//t + 1, 1)y; #= # % t |
||
end; return substr(@, #+1, 1)y</ |
end; return substr(@, #+1, 1)y</syntaxhighlight> |
||
{{out|output|text= when using the default inputs:}} |
{{out|output|text= when using the default inputs:}} |
||
<pre> |
<pre> |
||
Line 695: | Line 695: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
load "stdlib.ring" |
load "stdlib.ring" |
||
see "working..." + nl |
see "working..." + nl |
||
Line 738: | Line 738: | ||
binList = substr(binList,nl,"") |
binList = substr(binList,nl,"") |
||
return binList |
return binList |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 753: | Line 753: | ||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
< |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
const func boolean: palindrome (in string: input) is |
const func boolean: palindrome (in string: input) is |
||
Line 768: | Line 768: | ||
end if; |
end if; |
||
end for; |
end for; |
||
end func;</ |
end func;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 775: | Line 775: | ||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
< |
<syntaxhighlight lang="ruby">say gather { |
||
for (var k = 0; k < 25_000; k = k.next_palindrome(16)) { |
for (var k = 0; k < 25_000; k = k.next_palindrome(16)) { |
||
take(k) if [2, 4].all{|b| k.is_palindrome(b) } |
take(k) if [2, 4].all{|b| k.is_palindrome(b) } |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 788: | Line 788: | ||
{{libheader|Wren-fmt}} |
{{libheader|Wren-fmt}} |
||
{{libheader|Wren-seq}} |
{{libheader|Wren-seq}} |
||
< |
<syntaxhighlight lang="ecmascript">import "/fmt" for Conv, Fmt |
||
import "/seq" for Lst |
import "/seq" for Lst |
||
Line 804: | Line 804: | ||
} |
} |
||
for (chunk in Lst.chunks(numbers, 8)) Fmt.print("$,6d", chunk) |
for (chunk in Lst.chunks(numbers, 8)) Fmt.print("$,6d", chunk) |
||
System.print("\nFound %(numbers.count) such numbers.")</ |
System.print("\nFound %(numbers.count) such numbers.")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 817: | Line 817: | ||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">func Reverse(N, Base); \Reverse order of digits in N for given Base |
||
int N, Base, M; |
int N, Base, M; |
||
[M:= 0; |
[M:= 0; |
||
Line 840: | Line 840: | ||
Text(0, " such numbers found. |
Text(0, " such numbers found. |
||
"); |
"); |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
{{out}} |
Revision as of 00:04, 28 August 2022
Numbers in base 10 that are palindromic in bases 2, 4, and 16 is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
- Task
- Find numbers in base 10 that are palindromic in bases 2, 4, and 16, where n < 25,000
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()
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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
- Output:
Screenshot from Atari 8-bit computer
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
ALGOL 68
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 #
FOR n FROM 0 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
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
APL
(⊢(/⍨)(2 4 16∧.((⊢≡⌽)(⊥⍣¯1))⊢)¨)0,⍳24999
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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)
}
- Output:
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
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
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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)
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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;
}
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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.
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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();
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
F#
// 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 ""
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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.")
}
- Output:
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.
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
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)))
- Output:
1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
Mathematica/Wolfram Language
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[%]
- Output:
{0, 1, 3, 5, 15, 17, 51, 85, 255, 257, 273, 771, 819, 1285, 1365, 3855, 4095, 4097, 4369, 12291, 13107, 20485, 21845} 23
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(" ")
- Output:
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
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;
- Output:
1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
Phix
with javascript_semantics function palindrome(string s) return s=reverse(s) end function function p2416(integer n) return palindrome(sprintf("%a",{{2,n}})) and palindrome(sprintf("%a",{{4,n}})) and palindrome(sprintf("%a",{{16,n}})) end function sequence res = apply(filter(tagset(25000,0),p2416),sprint) printf(1,"%d found: %s\n",{length(res),join(res)})
- Output:
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
PL/M
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
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
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()
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
Raku
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 } }
- Output:
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
REXX
Programming note: the conversions of a decimal number to another base (radix) was ordered such that the fastest
base conversion was performed before the other conversions.
The use of REXX's BIFs to convert decimal numbers to binary and hexadecimal were used (instead of the base
function) because they are much faster).
This REXX version takes advantage that no even integers need be tested (except for the single exception: zero),
this makes the execution twice as fast.
/*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
- output when using the default inputs:
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
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
- Output:
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...
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;
- Output:
0 1 3 5 15 17 51 85 255 257 273 771 819 1285 1365 3855 4095 4097 4369 12291 13107 20485 21845
Sidef
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) }
}
}
- Output:
[0, 1, 3, 5, 15, 17, 51, 85, 255, 257, 273, 771, 819, 1285, 1365, 3855, 4095, 4097, 4369, 12291, 13107, 20485, 21845]
Wren
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:")
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)
}
}
}
for (chunk in Lst.chunks(numbers, 8)) Fmt.print("$,6d", chunk)
System.print("\nFound %(numbers.count) such numbers.")
- Output:
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.
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.
");
]
- Output:
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.