Rare numbers: Difference between revisions
→{{header|langur}}
(Added Easylang) |
Langurmonkey (talk | contribs) |
||
| (7 intermediate revisions by 4 users not shown) | |||
Line 3,894:
=== not optimized ===
It could look something like the following (ignoring whatever optimizations the other examples are using), if it was fast enough. I did not have the time/processor to test finding the first 5. The
<syntaxhighlight lang="langur">
val
val
if
val
val
}
val
for[=[]]
if
_for ~= [
}
}
val findandprint = impure fn(mx) {
for[cnt=0] i = 0; cnt < mx ; i += 1 {
if israre(i) {
writeln "\n rare ", i, " "
cnt += 1
}
}
Line 3,917 ⟶ 3,925:
# if you have the time...
writeln "the first 5 rare numbers: ",
</syntaxhighlight>
=={{header|Lua}}==
{{Trans|Phix|niave version, via FreeBASIC and Algol 68}}
<syntaxhighlight lang="lua">
do -- find the first five rare numbers
local function revn ( na )
local n, r = na, 0
while n > 0 do
r = r * 10 r = r + ( n % 10 )
n = math.floor( n / 10 )
end
return r
end -- revn
local nd, count, lim, n = 2, 0, 90, 20
local oddNd = nd % 2 == 1
while true do
n = n + 1
local r = revn( n )
if r < n then
local s, d = n + r, n - r
local tryThis = false
if oddNd
then tryThis = d % 1089 == 0
else tryThis = s % 121 == 0
end
if tryThis then
local rootS = math.sqrt( s )
if rootS == math.floor(rootS )
then
local rootD = math.sqrt( d )
if rootD == math.floor( rootD )
then
count = count + 1
io.write( count, ": ", n, "\n" )
if count >= 5 then os.exit() end
end
end
end
if n == lim
then
lim = lim * 10
nd = nd + 1
oddNd = not oddNd
n = math.floor( lim / 9 ) * 2
end
end
end
end
</syntaxhighlight>
{{out}}
<pre>
1: 65
2: 621770
3: 281089082
4: 2022652202
5: 2042832002
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Line 4,821 ⟶ 4,885:
621770
281089082</pre>
=={{header|Racket}}==
===naive===
<syntaxhighlight lang="racket" line>; 20231024 Racket programming naive solution
#lang racket
(require control)
(require text-block/text)
(define (is-palindrome n)
(define (digit-list n)
(if (zero? n)
'()
(cons (remainder n 10) (digit-list (quotient n 10)))))
(define (reverse-list lst)
(if (null? lst)
'()
(append (reverse-list (cdr lst)) (list (car lst)))))
(define digits (digit-list n))
(equal? digits (reverse-list digits)))
(define (perfect-square? n)
(if (rational? (sqrt n))
(= n (expt (floor (sqrt n)) 2))
false))
(define (reverse-number n)
(string->number (string-reverse (number->string n))))
(define (find-rare-numbers count)
(define rare-numbers '())
(define i 1)
(define (is-rare? n)
(and (not (is-palindrome n))
(let* ((r (reverse-number n))
(sum (+ n r))
(diff (- n r)))
(and (perfect-square? sum)
(perfect-square? diff)))))
(define start-time (current-inexact-milliseconds))
(while (< (length rare-numbers) count)
(cond [(is-rare? i)
(displayln (format "Number: ~a | Elapsed time: ~a ms" i (round (- (current-inexact-milliseconds) start-time))))
(set! rare-numbers (cons i rare-numbers))])
(set! i (+ i 1)))
(reverse rare-numbers))
(displayln "The first 5 rare numbers are:")
(for-each (λ (x) (display x) (display "\n")) (find-rare-numbers 5))
</syntaxhighlight>
=={{header|Raku}}==
Line 6,398 ⟶ 6,517:
===Traditional===
About 9.5 minutes to find the first 25 rare numbers.
<syntaxhighlight lang="
import "./fmt" for Fmt
class Term {
Line 6,672 ⟶ 6,791:
===Turbo===
Ruffles the feathers a little with a time 5 times quicker than the 'traditional' version.
<syntaxhighlight lang="
import "./fmt" for Fmt
import "./date" for Date
class Z2 {
| |||