Ruth-Aaron numbers: Difference between revisions

Line 37:

This uses a large amount of memory - too much for Algol 68G under Windows (and possibly under Linux).

With max number set to 1 000 000, Algol 68G can find the first triple using factors in a few seconds (the loop to find the first divisors triple must be commented out or removed) - Real time: 0.941 s on TIO.RUN for the cutdown version.

<~~lang~~ algol68>BEGIN # find Ruth-Aaron pairs - pairs of consecutive integers where the sum #

<syntaxhighlight lang="algol68">BEGIN # find Ruth-Aaron pairs - pairs of consecutive integers where the sum #

# of the prime factors or divisors are equal #

INT max number = 99 000 000; # max number we will consider #

Line 139:

print( ( newline, "First Ruth-Aaron triple (factors): ", whole( fra3, 0 ) ) );

print( ( newline, "First Ruth-Aaron triple (divisors): ", whole( dra3, 0 ) ) )

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 157:

=={{header|C++}}==

This takes about 2 minutes 24 seconds (3.2GHz Quad-Core Intel Core i5).

<~~lang~~ cpp>#include <iomanip>

<syntaxhighlight lang="cpp">#include <iomanip>

#include <iostream>

Line 243:

dsum2 = dsum3;

}

}</~~lang~~>

}</syntaxhighlight>

Line 264:

=={{header|Factor}}==

<~~lang~~ factor>USING: assocs.extras grouping io kernel lists lists.lazy math

<syntaxhighlight lang="factor">USING: assocs.extras grouping io kernel lists lists.lazy math

math.primes.factors prettyprint ranges sequences ;

Line 283:

"First 30 Ruth-Aaron numbers (divisors):" print

RA-d list.</~~lang~~>

RA-d list.</syntaxhighlight>

<pre>

Line 301:

Takes about 4.5 minutes.

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 382:

fmt.Println("\nFirst Ruth-Aaron triple (divisors):")

fmt.Println(resT[0])

}</~~lang~~>

}</syntaxhighlight>

Line 400:

=={{header|Haskell}}==

<~~lang~~ haskell>import qualified Data.Set as S

<syntaxhighlight lang="haskell">import qualified Data.Set as S

import Data.List.Split ( chunksOf )

Line 450:

putStrLn "First 30 Ruth-Aaron numbers( divisors ):"

mapM_ (\nlin -> putStrLn $ foldl1 ( ++ ) $ map (\st -> formatNumber (maxlen2 + 2) st )

nlin ) numberlines2</~~lang~~>

nlin ) numberlines2</syntaxhighlight>

<pre>First 30 Ruth-Aaaron numbers ( factors ) :

Line 470:

Thus:

<~~lang~~ J> NB. using factors

<syntaxhighlight lang="j"> NB. using factors

30{.1 2+/~I. 2 =/\ +/@q: 1+i.100000

5 6

Line 534:

26642 26643

35456 35457

40081 40082</~~lang~~>

40081 40082</syntaxhighlight>

=={{header|Julia}}==

<~~lang~~ julia>using Lazy

<syntaxhighlight lang="julia">using Lazy

using Primes

Line 563:

println("\nRuth Aaron triple starts at: ", findfirst(ruthaarontriple, 1:100000000))

println("\nRuth Aaron factor triple starts at: ", findfirst(ruthaaronfactorstriple, 1:10000000))

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

30 Ruth Aaron numbers:

Line 583:

==={{header|Free Pascal}}===

all depends on fast prime decomposition.

<~~lang~~ pascal>program RuthAaronNumb;

<syntaxhighlight lang="pascal">program RuthAaronNumb;

// gets factors of consecutive integers fast

// limited to 1.2e11

Line 989:

writeln('First Ruth-Aaron triple (divisors):');

writeln(findfirstTripplesFactor(false):10);

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 1,012:

=={{header|Perl}}==

<~~lang~~ perl>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict;

Line 1,037:

$n++;

}

print "divisors:\n\n@answers\n" =~ s/.{60}\K /\n/gr;</~~lang~~>

print "divisors:\n\n@answers\n" =~ s/.{60}\K /\n/gr;</syntaxhighlight>

<pre>

Line 1,056:

You can run this online [http://phix.x10.mx/p2js/ruthaaron.htm here].

with javascript_semantics

procedure ruth_aaron(bool d, integer n=30, l=2, i=1)

Line 1,090:

ruth_aaron(true, 1, 3, 89460000) -- (0.1s)

--ruth_aaron(true, 1, 3) -- (24 minutes 30s)

<pre>

Line 1,110:

<code>primefactors</code> is defined at [[Prime decomposition#Quackery]].

<~~lang~~ ~~Quackery~~> [ behead dup dip nested rot

<syntaxhighlight lang="quackery"> [ behead dup dip nested rot

witheach

[ tuck != if

Line 1,149:

raf echo

cr cr

rad echo</~~lang~~>

rad echo</syntaxhighlight>

Line 1,160:

=={{header|Raku}}==

<lang ~~perl6~~>use Prime::Factor;

<syntaxhighlight lang="raku" line>use Prime::Factor;

my @pf = lazy (^∞).hyper(:1000batch).map: *.&prime-factors.sum;

Line 1,178:

# Really, really, _really_ slow. 186(!) minutes... but with no cheating or "leg up".

put "\nFirst Ruth-Aaron triple (Divisors):\n" ~

(1..∞).first: { @upf[$_] == @upf[$_ + 1] == @upf[$_ + 2] }</~~lang~~>

(1..∞).first: { @upf[$_] == @upf[$_ + 1] == @upf[$_ + 2] }</syntaxhighlight>

<pre>First 30 Ruth-Aaron numbers (Factors):

Line 1,193:

=={{header|Sidef}}==

<~~lang~~ ruby>say "First 30 Ruth-Aaron numbers (factors):"

<syntaxhighlight lang="ruby">say "First 30 Ruth-Aaron numbers (factors):"

say 30.by {|n| (sopfr(n) == sopfr(n+1)) && (n > 0) }.join(' ')

say "\nFirst 30 Ruth-Aaron numbers (divisors):"

say 30.by {|n| ( sopf(n) == sopf(n+1)) && (n > 0) }.join(' ')</~~lang~~>

say 30.by {|n| ( sopf(n) == sopf(n+1)) && (n > 0) }.join(' ')</syntaxhighlight>

Line 1,215:

However, with nearly 90 million trios of numbers to slog through, it takes around 68 minutes to find the first triple based on divisors.

<~~lang~~ ecmascript>import "./math" for Int, Nums

<syntaxhighlight lang="ecmascript">import "./math" for Int, Nums

import "./seq" for Lst

import "./fmt" for Fmt

Line 1,292:

System.print("\nFirst Ruth-Aaron triple (divisors):")

System.print(resT[0])</~~lang~~>

System.print(resT[0])</syntaxhighlight>

Line 1,310:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>func DivSum(N, AllDiv); \Return sum of divisors

<syntaxhighlight lang="xpl0">func DivSum(N, AllDiv); \Return sum of divisors

int N, AllDiv; \all divisors vs. only prime divisors

int F, F0, S, Q;

Line 1,345:

CrLf(0);

Ruth(false);

]</~~lang~~>

]</syntaxhighlight>