Largest palindrome product: Difference between revisions
Added Easylang
m (→Version 2: removed some left code that was used for testing) |
(Added Easylang) |
||
| (25 intermediate revisions by 15 users not shown) | |||
Line 13:
Find the largest palindrome made from the product of two n-digit numbers, where n ranges beyond 7,
<br><br>
=={{header|11l}}==
{{trans|Wren}}
<syntaxhighlight lang="11l">F reverse(=n)
V r = Int64(0)
L n > 0
r = n % 10 + r * 10
n I/= 10
R r
V po = Int64(10)
L(n) 2..7
V low = po * 9
po *= 10
V high = po - 1
V nextN = 0B
L(i) (high .. low).step(-1)
V j = reverse(i)
V p = i * po + j
V k = high
L k > low
I k % 10 != 5
V l = p I/ k
I l > high
L.break
I p % k == 0
print(‘Largest palindromic product of two ’n‘-digit integers: ’k‘ x ’l‘ = ’p)
nextN = 1B
L.break
k -= 2
I nextN
L.break</syntaxhighlight>
{{out}}
<pre>
Largest palindromic product of two 2-digit integers: 99 x 91 = 9009
Largest palindromic product of two 3-digit integers: 993 x 913 = 906609
Largest palindromic product of two 4-digit integers: 9999 x 9901 = 99000099
Largest palindromic product of two 5-digit integers: 99979 x 99681 = 9966006699
Largest palindromic product of two 6-digit integers: 999999 x 999001 = 999000000999
Largest palindromic product of two 7-digit integers: 9998017 x 9997647 = 99956644665999
</pre>
=={{header|ALGOL 68}}==
{{Trans|Wren}}
<
# returns n with the digits reversed #
PROC reverse = ( LONG INT v )LONG INT:
Line 61 ⟶ 104:
OD
OD
END</
{{out}}
Line 75 ⟶ 118:
{{Trans|Ring}}
Also showing the maximum for 2 and 4 .. 7 digit numbers. Tests for a better product before testing for palindromicity.
<
PROC is pal = ( LONG INT n )BOOL:
BEGIN
Line 133 ⟶ 176:
limit start *:= 10
OD
END</
{{out}}
<pre>
Line 144 ⟶ 187:
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">
palindrome?: function [n]->
(to :string n) = reverse to :string n
getAllMuls: function [n][
result: []
limFrom: 10^ n-1
limTo: dec 10^n
loop limFrom..limTo 'a [
loop limFrom..limTo 'b [
m: a*b
if palindrome? m ->
'result ++ @[@[a, b, a*b]]
]
]
return result
]
largestPal: maximum getAllMuls 3 'x -> last x
print ["Largest palindromic product of two 3-digit integers:" largestPal\0 "x" largestPal\1 "=" largestPal\2]</syntaxhighlight>
{{out}}
<pre>Largest palindromic product of two 3-digit integers: 913 x 993 = 906609</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f LARGEST_PALINDROME_PRODUCT.AWK
BEGIN {
main(9)
main(99)
main(999)
main(9999)
exit(0)
}
function main(n, i,j,max_i,max_j,max_product,product) {
for (i=1; i<=n; i++) {
for (j=1; j<=n; j++) {
product = i * j
if (product > max_product) {
if (product ~ /^9/ && product ~ /9$/) {
if (product == reverse(product)) {
max_product = product
max_i = i
max_j = j
}
}
}
}
}
printf("%1d: %4s * %-4s = %d\n",length(n),max_i,max_j,max_product)
}
function reverse(str, i,rts) {
for (i=length(str); i>=1; i--) {
rts = rts substr(str,i,1)
}
return(rts)
}
</syntaxhighlight>
{{out}}
<pre>
1: 1 * 9 = 9
2: 91 * 99 = 9009
3: 913 * 993 = 906609
4: 9901 * 9999 = 99000099
</pre>
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
# Largest palindrome product of two 3-digit numbers
# # Variables:
#
typeset -si MINFACT=913 # From 'Paper & Pencil' solution
typeset -si MAXFACT=999
# # Functions:
#
# # Function _ispalindrome(n) - return 1 for palindromic number
#
function _ispalindrome {
typeset _n ; integer _n="$1"
(( _n != $(_flipit ${_n}) )) && return 0
return 1
}
# # Function _flipit(string) - return flipped string
#
function _flipit {
typeset _buf ; _buf="$1"
typeset _tmp ; unset _tmp
typeset _i ; typeset -si _i
for (( _i=$(( ${#_buf}-1 )); _i>=0; _i-- )); do
_tmp="${_tmp}${_buf:${_i}:1}"
done
echo "${_tmp}"
}
######
# main #
######
integer prod MAXPPROD=0
for (( i=MINFACT; i<=MAXFACT; i++)); do
for (( j=MINFACT; j<=MAXFACT; j++)); do
(( prod = i * j ))
_ispalindrome ${prod}
(( $? )) && (( prod > MAXPPROD )) && MAXPPROD=${prod}
done
done
print "Largest palindrome product of two 3-digit factors = ${MAXPPROD}"
</syntaxhighlight>
{{out}}<pre>
Largest palindrome product of two 3-digit factors = 906609</pre>
=={{header|C#|CSharp}}==
===Main Task===
{{trans|Paper & Pencil}}
<
class Program {
Line 185 ⟶ 350:
Console.Write("{0} {1} μs", bs, sw.Elapsed.TotalMilliseconds * 1000.0);
}
}</
{{out|Output @ Tio.run}}
<pre>913 x 993 = 906609 245.2 μs</pre>
===Stretch===
<
class Program {
Line 241 ⟶ 406:
Console.Write("{0} sec", sw.Elapsed.TotalSeconds);
}
}</
{{out|Output @ Tio.run}}
Showing results for 2 through 10 digit factors.
Line 255 ⟶ 420:
10 9999900001 x 9999999999 = 99999000000000099999
2.1622142 sec</pre>Wow! how did that go so fast? The results for the even-number-of-digit factors were manufactured by string manipulation instead of calculation (since the pattern was obvious). This algorithm can easily be adapted to BigIntegers for higher n-digit factors, but the execution time is unspectacular.
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|uses Windows,SysUtils,StdCtrls,Math}}
<syntaxhighlight lang="Delphi">
type TProgress = procedure(Percent: integer);
function ReverseNum(N: int64): int64;
{Reverse the digit order of a number}
begin
Result:=0;
while N>0 do
begin
Result:=(Result*10)+(N mod 10);
N:=N div 10;
end;
end;
function IsPalindrome(N: int64): boolean;
{If the number is the same in }
{reverse order it is a palindrome}
var N1: int64;
begin
N1:=ReverseNum(N);
Result:=N = N1;
end;
procedure ShowPalindrome(Memo: TMemo; D,N1,N2: int64);
begin
Memo.Lines.Add(Format('%5D %5D %5D %10D',[D,N1,N2,N1 * N2]));
end;
procedure FindPalindromes(Digits: integer; var C1,C2: int64; Prog: TProgress);
{Find the largest palindrome derrived from two}
{ terms with the specified number of digits}
var I,J: cardinal;
var Prd,MinNum,MaxNum,Best: int64;
begin
Best:=0;
{Find the minimum and maximum values}
{ with the specified number of digits}
MinNum:=Trunc(Power(10,Digits-1));
MaxNum:=Trunc(Power(10,Digits))-1;
for I:=MinNum to MaxNum do
begin
{We can eliminate even factors and number ending in 5}
if ((I and 1)=0) or ((I mod 10)=5) then continue;
for J:=I+1 to MaxNum do
begin
{We can eliminate even factors and number ending in 5}
if ((J and 1)=0) or ((J mod 10)=5) then continue;
Prd:=I * J;
if not IsPalindrome(Prd) then continue;
if Assigned(Prog) then Prog(MulDiv(100,I-MinNum,MaxNum-MinNum));
{Save the largest palindromes}
if Prd>Best then
begin
Best:=Prd;
C1:=I; C2:=J;
end;
end;
end;
end;
procedure FindPalindromeMax(Memo: TMemo; Prog: TProgress);
var N1,N2: Int64;
var I: integer;
begin
Memo.Lines.Add('Digits F1 F2 Palindrome');
Memo.Lines.Add('-------------------------------');
for I:=2 to 4 do
begin
FindPalindromes(I,N1,N2,Prog);
ShowPalindrome(Memo,I,N1,N2);
end;
end;
</syntaxhighlight>
{{out}}
<pre>
Digits F1 F2 Palindrome
-------------------------------
2 91 99 9009
3 913 993 906609
4 9901 9999 99000099
</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
fastfunc rev n .
while n > 0
r = r * 10 + n mod 10
n = n div 10
.
return r
.
for i = 100 to 999
for j = i to 999
p = i * j
if p > max and p = rev p
max = p
.
.
.
</syntaxhighlight>
{{out}}
<pre>
906609
</pre>
=={{header|F_Sharp|F#}}==
<
// Largest palindrome product. Nigel Galloway: November 3rd., 2021
let fN g=let rec fN g=[yield g%10; if g>=10 then yield! fN(g/10)] in let n=fN g in n=List.rev n
printfn "%d" ([for n in 100..999 do for g in n..999->n*g]|>List.filter fN|>List.max)
</syntaxhighlight>
{{out}}
<pre>
Line 269 ⟶ 551:
=={{header|FreeBASIC}}==
===Version 1===
<
'turn a number into a palindrom with twice as many digits
dim as string ns, ret
Line 301 ⟶ 583:
next n
nextd: 'yes, I used a goto. sue me.
next d</
{{out}}
<pre>99 * 91 = 9009
Line 310 ⟶ 592:
9998017 * 9997647 = 99956644665999</pre>
===Version 2===
This version is based on Version 1 with only a few changes and some extra code based on the fact that one divisor can be divided by 11, this speeds it even more up and a option for using goto, exit or continue.
<
' compile with: fbc -s console
Line 329 ⟶ 611:
End Function
Dim As ULongInt np, tmp
Dim As Double t1 =Timer
For d As UInteger = 2 To 9
For n As UInteger = 10^d -
tmp = tmp - (10^d - 1 - tmp)
tmp = tmp - tmp Mod 11
If (tmp And 1) = 0 Then tmp = tmp + 11
For f As UInteger = tmp To 10^d -1 Step 22
If np Mod f = 0 Then
If np \ f > (10^d) Then Continue For
Print f; " * "; np \ f; " = "; np
#If (option_ = 2)
Line 350 ⟶ 635:
Next n
#If (option_ <> 2 Or option_ <> 3)
nextd:
#EndIf
Next d
Print Timer-t1
' empty keyboard buffer
While InKey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre>99 * 91 = 9009
Line 372 ⟶ 658:
{{trans|Wren}}
18 digit integers are within the range of Go's uint64 type though finding the result for 9-digit number products takes a while - around 15 seconds on my machine.
<
import "fmt"
Line 412 ⟶ 698:
}
}
}</
{{out}}
Line 425 ⟶ 711:
Largest palindromic product of two 9-digit integers: 999980347 x 999920317 = 999900665566009999
</pre>
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]'''
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">def reverseNumber:
tostring|explode|reverse|implode|tonumber;
def task:
{ pow: 10}
| foreach range(2;8) as $n (.;
(.pow * 9) as $low
| .pow *= 10
| (.pow - 1) as $high
| .emit = null
| .nextN = false
| label $out
| foreach range($high; $low - 1; -1) as $i (.;
($i|reverseNumber) as $j
| ($i * .pow + $j) as $p
# k can't be even nor end in 5 to produce a product ending in 9
| .k = $high
| .done = false
| until(.k <= $low or .done;
if (.k % 10 != 5)
then ($p / .k) as $l
| if $l > $high
then .done = true
elif $p % .k == 0
then .emit = "Largest palindromic product of two \($n)-digit integers: \(.k) x \($l) = \($p)"
| .nextN = true
| .done = true
else .
end
else .
end
| .k += -2 )
| if .nextN then ., break $out else . end;
select(.emit) );
.emit ) ;
task</syntaxhighlight>
{{out}}
<pre>
Largest palindromic product of two 2-digit integers: 99 x 91 = 9009
Largest palindromic product of two 3-digit integers: 993 x 913 = 906609
Largest palindromic product of two 4-digit integers: 9999 x 9901 = 99000099
Largest palindromic product of two 5-digit integers: 99979 x 99681 = 9966006699
Largest palindromic product of two 6-digit integers: 999999 x 999001 = 999000000999
Largest palindromic product of two 7-digit integers: 9998017 x 9997647 = 99956644665999
</pre>
=={{header|Julia}}==
<
function twoprodpal(factorlength)
Line 460 ⟶ 798:
twoprodpal(i)
end
</
<pre>
For factor length 2, 91 * 99 = 9009
Line 473 ⟶ 811:
For factor length 11, 99999943851 * 99999996349 = 9999994020000204999999
For factor length 12, 999999000001 * 999999999999 = 999999000000000000999999
</pre>
=== Faster version ===
{{trans|Python}}
<syntaxhighlight lang="julia">""" taken from https://leetcode.com/problems/largest-palindrome-product/discuss/150954/Fast-algorithm-by-constrains-on-tail-digits """
const T = [Set([(0, 0)])]
function double(it)
arr = empty(it)
for p in it
push!(arr, p, reverse(p))
end
return arr
end
""" Construct a pair of n-digit numbers such that their product ends with 99...9 pattern """
function tails(n)
if length(T) <= n
l = Set()
for i in 0:9, j in i:9
I = i * 10^(n-1)
J = j * 10^(n-1)
it = collect(tails(n - 1))
I != J && (it = double(it))
for (t1, t2) in it
if ((I + t1) * (J + t2) + 1) % 10^n == 0
push!(l, (I + t1, J + t2))
end
end
end
push!(T, l)
end
return T[n + 1]
end
""" find the largest palindrome that is a product of n-digit numbers """
function largestpalindrome(n)
m, tail = 0, n ÷ 2
head = n - tail
up = 10^head
for L in 1 : 9 * 10^(head-1)
# Consider small shell (up-L)^2 < (up-i)*(up-j) <= (up-L)^2, 1<=i<=L<=j
m, sol = 0, (0, 0)
for i in 1:L
lo = max(Int128(i), Int128(up - (up - L + 1)^2 ÷ (up - i)) + 1)
hi = Int128(up - (up - L)^2 ÷ (up - i))
for j in lo:hi
I = (up - i) * 10^tail
J = (up - j) * 10^tail
it = collect(tails(tail))
I != J && (it = double(it))
for (t1, t2) in it
val = (I + t1) * (J + t2)
s = string(val)
if s == reverse(s) && val > m
sol = (I + t1, J + t2)
m = val
end
end
end
end
if m > 0
println(lpad(n, 2), " ", lpad(m % 1337, 4), " $sol $(sol[1] * sol[2])")
return m % 1337
end
end
return 0
end
@time for k in 1:16
largestpalindrome(k)
end
</syntaxhighlight>{{out}}
<pre>
1 9 (9, 1) 9
2 987 (91, 99) 9009
3 123 (993, 913) 906609
4 597 (9901, 9999) 99000099
5 677 (99979, 99681) 9966006699
6 1218 (999001, 999999) 999000000999
7 877 (9998017, 9997647) 99956644665999
8 475 (99990001, 99999999) 9999000000009999
9 1226 (999980347, 999920317) 999900665566009999
10 875 (9999986701, 9999996699) 99999834000043899999
11 108 (99999943851, 99999996349) 9999994020000204999999
12 378 (999999000001, 999999999999) 999999000000000000999999
13 1097 (9999999993349, 9999996340851) 99999963342000024336999999
14 959 (99999990000001, 99999999999999) 9999999000000000000009999999
15 465 (999999998341069, 999999975838971) 999999974180040040081479999999
16 51 (9999999900000001, 9999999999999999) 99999999000000000000000099999999
62.575515 seconds (241.50 M allocations: 16.491 GiB, 25.20% gc time, 0.07% compilation time)
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">palindromeQ[n_] := (* faster than built in test PalindromeQ *)
Block[{digits = IntegerDigits@n}, digits == Reverse[digits]]
nextPair[n_] := (* outputs next pair of candidate divisors *)
Block[{next =
NestWhile[# - 11 &, n, ! MemberQ[{1, 3, 7, 9}, Mod[#, 10]] &],
len = Last@RealDigits@n},
{next, 10^len - Switch[Mod[next, 10], 1, 1, 3, 7, 7, 3, 9, 9]}]
search[n_] :=
Block[{resetLimit = 10^(n - Floor[n/2]) (10^Floor[n/2] - 1), cands},
cands =
Partition[
Flatten[
Reap[
NestWhile[(If[palindromeQ[Times @@ #], Sow[#]];
If[Last@# < resetLimit,
nextPair[First@# - 11], # - {0, 10}]) &,
nextPair@If[EvenQ@n, 10^n - 1, 10^n - 21],
First@# > resetLimit &]]], 2];
Flatten@cands[[Ordering[Times @@@ cands, -1]]]]
Grid[Join[{{"factors", "largest palindrome"}}, {#, Times @@ #} & /@
Table[search[n], {n, 2, 7}]], Alignment -> {Left, Baseline}]</syntaxhighlight>
{{out}}<pre>
factors largest palindrome
{99,91} 9009
{913,993} 906609
{9999,9901} 99000099
{99979,99681} 9966006699
{999999,999001} 999000000999
{9997647,9998017} 99956644665999
</pre>
=={{header|Paper & Pencil}}==
<syntaxhighlight lang="text">find two 3-digit factors, that when multiplied together, yield the highest 6-digit palindrome.
lowest possible 6 digit palindrome starting with 9 is 900009
Line 503 ⟶ 969:
979 x 931 = 911449, not a palindrome, so continue
979 x 921 = 901659, not a palindrome, and less than the best found so far, so stop
done because 979 + 22 = 1001</
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use feature 'say';
Line 519 ⟶ 985:
say "Largest palindromic product of two @{[$l]}-digit integers: $f[1] × $f[0] = $p" and last LOOP;
}
}</
{{out}}
<pre>Largest palindromic product of two 2-digit integers: 91 × 99 = 9009
Line 529 ⟶ 995:
=={{header|Phix}}==
{{libheader|Phix/online}}
Translated from python by Lucy_Hedgehog as found on page 5 of the project euler discussion page (dated 25 Sep 2011),
and further optimised as per the C# comments (on this very rosettacode page).
You can run this online [http://phix.x10.mx/p2js/Largest_palindrome_product.htm here].
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\Largest_palindrome_product.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
Line 636 ⟶ 1,104:
<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: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sx</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sy</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 657 ⟶ 1,125:
Largest palindromic product of two 15-digit integers: 999999974180040040081479999999 = 999999998341069 x 999999975838971 (1 minute and 12s)
Largest palindromic product of two 16-digit integers: 99999999000000000000000099999999 = 9999999999999999 x 9999999900000001 (0s)
</pre>
=={{header|Python}}==
Original author credit to user peijunz at Leetcode.
<syntaxhighlight lang="python">""" taken from https://leetcode.com/problems/largest-palindrome-product/discuss/150954/Fast-algorithm-by-constrains-on-tail-digits """
T=[set([(0, 0)])]
def double(it):
for a, b in it:
yield a, b
yield b, a
def tails(n):
'''Construct pair of n-digit numbers that their product ends with 99...9 pattern'''
if len(T)<=n:
l = set()
for i in range(10):
for j in range(i, 10):
I = i*10**(n-1)
J = j*10**(n-1)
it = tails(n-1)
if I!=J: it = double(it)
for t1, t2 in it:
if ((I+t1)*(J+t2)+1)%10**n == 0:
l.add((I+t1, J+t2))
T.append(l)
return T[n]
def largestPalindrome(n):
""" find largest palindrome that is a product of two n-digit numbers """
m, tail = 0, n // 2
head = n - tail
up = 10**head
for L in range(1, 9*10**(head-1)+1):
# Consider small shell (up-L)^2 < (up-i)*(up-j) <= (up-L)^2, 1<=i<=L<=j
m = 0
sol = None
for i in range(1, L + 1):
lo = max(i, int(up - (up - L + 1)**2 / (up - i)) + 1)
hi = int(up - (up - L)**2 / (up - i))
for j in range(lo, hi + 1):
I = (up-i) * 10**tail
J = (up-j) * 10**tail
it = tails(tail)
if I!=J: it = double(it)
for t1, t2 in it:
val = (I + t1)*(J + t2)
s = str(val)
if s == s[::-1] and val>m:
sol = (I + t1, J + t2)
m = val
if m:
print("{:2d}\t{:4d}".format(n, m % 1337), sol, sol[0] * sol[1])
return m % 1337
return 0
if __name__ == "__main__":
for k in range(1, 14):
largestPalindrome(k)
</syntaxhighlight>{{out}}
<pre>
1 9 (9, 1) 9
2 987 (91, 99) 9009
3 123 (993, 913) 906609
4 597 (9901, 9999) 99000099
5 677 (99979, 99681) 9966006699
6 1218 (999001, 999999) 999000000999
7 877 (9998017, 9997647) 99956644665999
8 475 (99990001, 99999999) 9999000000009999
9 1226 (999980347, 999920317) 999900665566009999
10 875 (9999986701, 9999996699) 99999834000043899999
11 108 (99999943851, 99999996349) 9999994020000204999999
12 378 (999999000001, 999999999999) 999999000000000000999999
13 1097 (9999999993349, 9999996340851) 99999963342000024336999999
</pre>
=={{header|Quackery}}==
The largest product of two 3 digit numbers is 999*999 = 998001.
The smallest product of two 3 digit numbers is 100*100 = 10000.
Therefore we need only consider 6 and 5 digit palindromic numbers.
Considering 6 digit palindromic numbers:
The largest is 999999.
The smallest is 100001.
These can be costructed from the numbers 100 to 999.
Therefore there are 899 6 digit palindromic numbers.
The same applies to 5 digit palindromic numbers:
The largest is 99999.
The smallest is 10001.
These can be costructed from the numbers 100 to 999.
Therefore there are 899 5 digit palindromic numbers.
'''Method:'''
* Construct the 6 digit palindromic numbers in reverse numerical order.
* Test each one to see if it is divisible by a 3 digit number with a 3 digit result, starting with 999.
* If it is, the solution has been found.
* If no solution found, consider 5 digit palindromes.
A six digit solution was found, and as it was found virtually instantaneously I did not feel that any optimisations were necessary.
I went on to find the largest five digit soultion, even though the task did not call for it, as it was a trivial exercise.
<syntaxhighlight lang="Quackery"> [ [] swap
[ 10 /mod
rot join swap
dup 0 = until ]
drop ] is ->digits ( n --> [ )
[ behead swap
witheach
[ swap 10 * + ] ] is ->number ( [ --> n )
[ ->digits
dup reverse join
->number ] is evenpal ( n --> n )
[ ->digits
dup reverse
behead drop join
->number ] is oddpal ( n --> n )
[ 2dup mod 0 != iff
[ 2drop false ]
done
/ 100 1000 within ] is solution ( n n --> b )
false
899 times
[ i 100 + evenpal
899 times
[ dup i 100 +
solution if
[ dip not
conclude ] ]
over iff
[ nip conclude ]
else drop ]
dup iff
[ say "Six digit solution found: " echo ]
else
[ drop say "No six digit solution found." ]
cr
false
899 times
[ i 100 + oddpal
899 times
[ dup i 100 +
solution if
[ dip not
conclude ] ]
over iff
[ nip conclude ]
else drop ]
dup iff
[ say "Five digit solution found: " echo ]
else
[ drop say "No five digit solution found." ]
</syntaxhighlight>
{{out}}
<pre>Six digit solution found: 906609
Five digit solution found: 99899
</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
my $p5 = Inline::Perl5.new();
$p5.use: 'ntheory';
Line 686 ⟶ 1,323:
}
$p
}</
<pre>Largest palindromic product of two 2-digit integers: 91 × 99 = 9009
Largest palindromic product of two 3-digit integers: 913 × 993 = 906609
Line 700 ⟶ 1,337:
=={{header|Ring}}==
<
prod = 1
Line 748 ⟶ 1,385:
ok
end
return true</
{{out}}
<pre>working...
Line 754 ⟶ 1,391:
Found in 6 iterations
done...</pre>
=={{header|RPL}}==
≪ "" OVER SIZE 1 '''FOR''' j
OVER j DUP SUB +
-1 '''STEP''' NIP
≫ '<span style="color:blue">REVSTR</span>' STO
≪ 1 CF
'''DO'''
1 -
DUP →STR DUP <span style="color:blue">REVSTR</span> + STR→
DUP DIVIS SORT
1 OVER SIZE '''FOR''' j
DUP j GET
DUP XPON 2
'''CASE'''
DUP2 < '''THEN''' 3 DROPN '''END'''
> '''THEN''' DROP DUP SIZE 'j' STO '''END'''
PICK3 SWAP /
'''IF''' XPON 2 == '''THEN''' 1 SF '''END'''
'''END'''
'''NEXT''' DROP2
'''UNTIL''' 1 FS? '''END'''
→STR DUP <span style="color:blue">REVSTR</span> + STR→
≫ '<span style="color:blue">P004</span>' STO
1000 <span style="color:blue">P004</span>
{{out}}
<pre>
1: 906609
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func largest_palindrome_product (n) {
for k in ((10**n - 1) `downto` 10**(n-1)) {
var t = Num("#{k}#{Str(k).flip}")
t.divisors.each {|d|
if ((d.len == n) && ((t/d).len == n)) {
return (d, t/d)
}
}
}
}
for n in (2..9) {
var (a,b) = largest_palindrome_product(n)
say "Largest palindromic product of two #{n}-digit integers: #{a} * #{b} = #{a*b}"
}</syntaxhighlight>
{{out}}
<pre>
Largest palindromic product of two 2-digit integers: 91 * 99 = 9009
Largest palindromic product of two 3-digit integers: 913 * 993 = 906609
Largest palindromic product of two 4-digit integers: 9901 * 9999 = 99000099
Largest palindromic product of two 5-digit integers: 99681 * 99979 = 9966006699
Largest palindromic product of two 6-digit integers: 999001 * 999999 = 999000000999
Largest palindromic product of two 7-digit integers: 9997647 * 9998017 = 99956644665999
Largest palindromic product of two 8-digit integers: 99990001 * 99999999 = 9999000000009999
Largest palindromic product of two 9-digit integers: 999920317 * 999980347 = 999900665566009999
</pre>
=={{header|Wren}}==
The approach here is to manufacture palindromic numbers of length 2n in decreasing order and then see if they're products of two n-digit numbers.
<
var r = 0
while (n > 0) {
Line 792 ⟶ 1,490:
if (nextN) break
}
}</
{{out}}
Line 805 ⟶ 1,503:
=={{header|XPL0}}==
<
int A, B;
[B:= 0;
Line 823 ⟶ 1,521:
];
IntOut(0, Max);
]</
{{out}}
| |||