Achilles numbers: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program achilleNumber.s */

/***************************************************/

.include "../includeARM64.inc"

<pre>

First 50 Achilles Numbers:

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

{{libheader|ALGOL 68-primes}}

# twice (i.e. if p is a prime factor, so is p^2) and cannot be #

# expressed as m^k for any integer m, k > 1 #

OD

END

{{out}}

<pre>First 50 Achilles Numbers:

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI */

/* program achilleNumber.s */

/***************************************************/

.include "../affichage.inc"

<pre>

First 50 Achilles Numbers:

Numbers with 6 digits : 664

</pre>

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

{{trans|Wren}}

{{libheader|Boost}}

#include <chrono>

#include <cmath>

std::chrono::duration<double> duration(end - start);

std::cout << "\nElapsed time: " << duration.count() << " seconds\n";

 

{{out}}

</pre>

 

 

=={{header|FreeBASIC}}==

Return Iif(d = 0, n, GCD(d, n Mod d))

End Function

Print i; " digits:"; num

Next i

{{out}}

<pre>First 50 Achilles numbers:

{{trans|Wren}}

Based on Version 2, takes around 19 seconds.

 

import (

fmt.Printf("%2d digits: %d\n", d, ac)

}

 

{{out}}

Implementation:

 

 

Task examples:

 

72 108 200 288 392 432 500 648 675 800

864 968 972 1125 1152 1323 1352 1372 1568 1800

192

+/achilles (+i.)/1 9*10^<:6

 

Explanation of the code:

 

<tt>(#~ predicate) list</tt> selects the elements of <tt>list</tt> where <tt>predicate</tt> is true.

 

=={{header|Julia}}==

 

isAchilles(n) = (p = [x[2] for x in factor(n).pe]; all(>(1), p) && gcd(p) == 1)

 

teststrongachilles()

<pre>

First 50 Achilles numbers:

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

PowerfulNumberQ[n_Integer] := AllTrue[FactorInteger[n][[All, 2]], GreaterEqualThan[2]]

AchillesNumberQ[n_Integer] := Module[{divs},

]][[2, 1]]

 

{{out}}

<pre>{72, 108, 200, 288, 392, 432, 500, 648, 675, 800, 864, 968, 972, 1125, 1152, 1323, 1352, 1372, 1568, 1800, 1944, 2000, 2312, 2592, 2700, 2888, 3087, 3200, 3267, 3456, 3528, 3872, 3888, 4000, 4232, 4500, 4563, 4608, 5000, 5292, 5324, 5400, 5408, 5488, 6075, 6125, 6272, 6728, 6912, 7200}

6 664

7 2242</pre>

 

=={{header|Perl}}==

Borrowed, and lightly modified, code from [[Powerful_numbers]]

{{libheader|ntheory}}

use warnings;

use feature <say current_sub>;

use experimental 'signatures';

 

 

sub powerful_numbers ($n, $k = 2) {

__SUB__->($m * ipow($v, $r), $r - 1);

}

sort { $a <=> $b } @powerful;

}

 

!is_power($_) and push @achilles, $_ and $Ahash{$_}++ for @P;

$Ahash{euler_phi $_} and push @strong, $_ for @achilles;

 

say "First 30 strong Achilles numbers:\n" . table 10, head 30, @strong;

say "Number of Achilles numbers with:\n";

say "$l digits: $c";

{{out}}

<pre>First 50 Achilles numbers:

9 digits: 24008</pre>

Here is a translation from Wren version 2, as an alternative.

use warnings;

 

for my $d (2..$maxDigits) {

printf "%2d digits: %d\n", $d, scalar getAchilles($d-1, $d)

Output is the same.

 

You can run this online [http://phix.x10.mx/p2js/achilles.htm here], though [slightly outdated and] you should expect a blank screen for about 9s.

{{trans|Wren}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- [join_by(fmt)]</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Python}}==

from sympy import factorint

 

test_strong_Achilles(50, 100)

<pre>

First 50 Achilles numbers:

[10000, 99999]: 192

[100000, 999999]: 664

</pre>

 

=={{header|Raku}}==

Timing is going to be system / OS dependent.

use Math::Root;

 

say "$_ digits: " ~ +$achilles{$_} // 0 for 2..9;

 

{{out}}

<pre>First 50 Achilles numbers:

 

410.4 total elapsed seconds

</pre>

 

=={{header|Rust}}==

{{trans|Wren}}

let mut powers = Vec::<u128>::new();

let sqrt = (n as f64).sqrt() as u128;

let duration = t0.elapsed();

println!("\nElapsed time: {} milliseconds", duration.as_millis());

 

{{out}}

 

Elapsed time: 12608 milliseconds

</pre>

 

===Version 1 (Brute force)===

This finds the number of 6 digit Achilles numbers in 2.5 seconds, 7 digits in 51 seconds but 8 digits needs a whopping 21 minutes!

import "./seq" for Lst

import "./fmt" for Fmt

var limit = 10.pow(maxDigits)

var c = Int.primeSieve(limit-1, false)

 

var isPerfectPower = Fn.new { |n|

var isStrongAchilles = Fn.new { |n|

if (!isAchilles.call(n)) return false

return isAchilles.call(tot)

}

n = n + 1

}

 

System.print("\nFirst 30 strong Achilles numbers:")

n = n + 1

}

 

System.print("\nNumber of Achilles numbers with:")

System.print("%(i) digits: %(count)")

pow = pow * 10

 

{{out}}

 

Ridiculously fast compared to the previous method: 12 digits can now be reached in 1.03 seconds, 13 digits in 3.7 seconds, 14 digits in 12.2 seconds and 15 digits in 69 seconds.

import "./seq" for Lst

import "./fmt" for Fmt

 

var pps = Set.new()

 

System.print("First 50 Achilles numbers:")

 

System.print("\nFirst 30 strong Achilles numbers:")

var n = 0

while (count < 30) {

if (achillesSet.contains(tot)) {

strongAchilles.add(achilles[n])

n = n + 1

}

 

System.print("\nNumber of Achilles numbers with:")

var ac = getAchilles.call(d-1, d).count

Fmt.print("$2d digits: $d", d, ac)

 

{{out}}

 

=={{header|XPL0}}==

int N, D; \numerator and denominator

int R;

IntOut(0, Cnt); CrLf(0);

];

 

{{out}}