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:

{{trans|Wren}}

{{libheader|Boost}}

#include <chrono>

#include <cmath>

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

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

{{out}}

=={{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:

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}

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

{{libheader|ntheory}}

use warnings;

use feature <say current_sub>;

my $c; $l == length and $c++ for @achilles;

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:

=={{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:

=={{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}}

===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

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 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}}