Amicable pairs: Difference between revisions

 

=={{header|11l}}==

R I n < 2 {0} E sum((1 .. n I/ 2).filter(it -> (@n % it) == 0))

 

V m = sum_proper_divisors(n)

I m > n & sum_proper_divisors(m) == n

 

=={{header|8080 Assembly}}==

;;; Calculate proper divisors of 2..20000

lxi h,pdiv + 4 ; 2 bytes per entry

nbuf: db ' $'

nl: db 13,10,'$'

{{out}}

<pre>220 284

 

=={{header|8086 Assembly}}==

cpu 8086

org 100h

nbuf: db ' $'

nl: db 13,10,'$'

{{out}}

<pre>220 284

12285 14595

17296 18416</pre>

=={{header|Ada}}==

 

[[http://rosettacode.org/wiki/Proper_divisors#Ada]].

 

procedure Amicable_Pairs is

end if;

end loop;

{{Out}}

<pre>

=={{header|ALGOL 60}}==

{{works with|A60}}

begin

 

begin

end;

 

sum := 1;

f1 := 2;

begin

if mod(n, f1) = 0 then

 

comment - main program begins here;

outstring(1,"Searching up to 20000 for amicable pairs\n");

found := 0;

if b > a then

begin

begin

found := found + 1;

 

end

{{out}}

<pre>

 

=={{header|ALGOL 68}}==

FI

OD

{{out}}

<pre>

</pre>

 

 

 

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

 

 

-- amicablePairsUpTo :: Int -> Int

end script

end if

{{Out}}

 

=={{header|Arturo}}==

(factors x) -- x

 

]

 

 

{{out}}

 

=={{header|ATS}}==

(* ****** ****** *)

//

 

(* ****** ****** *)

 

{{out}}

 

=={{header|AutoHotkey}}==

Loop, 20000

{

}

MsgBox % final

{{out}}

<pre>

 

=={{header|AWK}}==

#!/bin/awk -f

function sumprop(num, i,sum,root) {

}

}

{{out}}

<pre>

17296 18416

</pre>

 

=={{header|BCPL}}==

 

manifest $(

if amicable(pds, x, y) do

writef("%N, %N*N", x, y)

 

{{out}}

=={{header|Befunge}}==

 

1>$$:28*:*:*%\28*:*:*/`06p28*:*:*/\2v %%^:*:<>*v

+|!:-1g60/*:*:*82::+**:*:<<>:#**#8:#<*^>.28*^8 :

:v>>*:*%/\28*:*:*%+\v>8+#$^#_+#`\:#0<:\`1/*:*2#<

2v^:*82\/*:*:*82:::_v#!%%*:*:*82\/*:*:*82::<_^#<

 

{{out}}

 

The program will overflow and error in all sorts of ways when given a commandline argument >= UINT_MAX/2 (generally 2^31)

#include <stdlib.h>

 

printf("\nTop %u count : %u\n",top,cnt);

return 0;

{{out}}

<pre>

</pre>

 

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>

 

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

#include <vector>

#include <unordered_map>

std::cout << count << " amicable pairs discovered" << std::endl;

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(ns example

(:gen-class))

(doseq [q find-pairs]

(println q))

{{Out}}

<pre>

#{10744 10856}

</pre>

 

=={{header|Common Lisp}}==

(defun sum-proper-divisors (n)

(or (gethash n cache)

collect (list x sum-divs)))

 

{{out}}

<pre>((220 284) (1184 1210) (2620 2924) (5020 5564) (6232 6368) (10744 10856)

 

=={{header|Cowgol}}==

 

const LIMIT := 20000;

end loop;

i := i + 1;

{{out}}

<pre>220, 284

 

=={{header|Crystal}}==

MX = 524_000_000

N = Math.sqrt(MX).to_u32

end

}

{{out}}

<pre>

=={{header|D}}==

{{trans|Python}}

import std.stdio, std.algorithm, std.range, std.typecons, std.array;

 

writefln("Amicable pair: %d and %d with proper divisors:\n %s\n %s",

n, divSum, properDivs(n), properDivs(divSum));

{{out}}

<pre>Amicable pair: 220 and 284 with proper divisors:

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Amicable_pairs#Pascal Pascal].

 

=={{header|EchoLisp}}==

;; using (sum-divisors) from math.lib

 

→ (... (802725 . 863835) (879712 . 901424) (898216 . 980984) (947835 . 1125765) (998104 . 1043096))

 

 

=={{header|Ela}}==

{{trans|Haskell}}

 

divisors n = filter ((0 ==) << (n `mod`)) [1..(n `div` 2)]

pairs = [(n, m) \\ (n, nd) <- divs, (m, md) <- divs | n < m && nd == m && md == n]

 

 

{{out}}

=={{header|Elena}}==

{{trans|C#}}

import system'routines;

{

ProperDivisors

get AmicablePairs()

var divsums := Range

.new(0, self + 1)

.toArray();

^ 1.repeatTill(divsums.Length)

{

var ii := i;

^ (i < sum) && (sum < divsums.Length) && (divsums[sum] == i)

}

}

}

public program()

{

{

console.printLine(pair.Item1, " ", pair.Item2)

}

{{out}}

<pre>

</pre>

=== Alternative variant using strong-typed closures ===

import system'routines'stex;

import system'collections;

{

Enumerator<int> ProperDivisors

get AmicablePairs()

auto divsums := new List<int>(

cast Enumerator<int>(

^ new Range(0, divsums.Length)

{

auto sum := divsums[i];

^ (i < sum) && (sum < divsums.Length) && (divsums[sum] == i)

}

}

}

public program()

{

{

console.printLine(pair.Item1, " ", pair.Item2)

}

=== Alternative variant using yield enumerator ===

import system'routines'stex;

import system'collections;

{

Enumerator<int> function(int number)

}

yieldable Tuple<int, int> next()

{

{

int sum := divsums[i];

if(i < sum && sum <= divsums.Length && divsums[sum] == i) {

}

};

{

auto e := new AmicablePairs(Limit);

{

console.printLine(pair.Item1, " ", pair.Item2)

}

{{out}}

<pre>

{{works with|Elixir|1.2}}

With [[proper_divisors#Elixir]] in place:

def divisors(1), do: []

def divisors(n), do: [1 | divisors(2,n,:math.sqrt(n))] |> Enum.sort

Enum.filter(map, fn {n,sum} -> map[sum] == n and n < sum end)

|> Enum.sort

 

{{out}}

Very slow solution. Same functions by and large as in proper divisors and co.

 

-module(properdivs).

-export([amicable/1,divs/1,sumdivs/1]).

sumdivs(N) -> lists:sum(divs(N)).

{{out}}

<pre>

[See the talk section &nbsp; '''amicable pairs, out of order''' &nbsp; for this Rosetta Code task.]

 

friendly(Limit) ->

List = [{X,properdivs:sumdivs(X)} || X <- lists:seq(3,Limit)],

io:format("L: ~w~n", [Final]).

 

{{output}}

 

 

We might answer a challenge by saying:

friendly(Limit) ->

List = [{X,properdivs:sumdivs(X)} || X <- lists:seq(3,Limit)],

end.

{{out}}

<pre>

 

=={{header|ERRE}}==

 

CONST LIMIT=20000

IF (N=M2 AND N<M1) THEN PRINT(N,M1)

END FOR

{{out}}

<pre>Amicable pairs < 20000

</pre>

 

[2..20000 - 1]

|> List.map (fun n-> n, ([1..n/2] |> List.filter (fun x->n % x = 0) |> List.sum))

|> List.map List.head

|> List.iter (printfn "%A")

{{out}}

<pre>

This solution focuses on the language's namesake: factoring code into small words which are subsequently composed to form more powerful — yet just as simple — words. Using this approach, the final word naturally arrives at the solution. This is often referred to as the bottom-up approach, which is a way in which Factor (and other concatenative languages) commonly differs from other languages.

 

USING: grouping math.primes.factors math.ranges ;

 

 

print-am

{{out}}

<pre>

{ 17296 18416 }

</pre>

 

=={{header|Fortran}}==

Amicable! 17296 18416

 

MODULE FACTORSTUFF !This protocol evades the need for multiple parameters, or COMMON, or one shapeless main line...

Concocted by R.N.McLean, MMXV.

END DO !On to the next.

END !Done.

 

=={{header|FreeBASIC}}==

===using Mod===

' FreeBASIC v1.05.0 win64

 

Sleep

End

 

{{out}}

</pre>

===using "Sieve of Erathosthenes" style===

' compile with: fbc -s console

' replaced the function with 2 FOR NEXT loops

Print : Print : Print " Hit any key to end program"

Sleep

<pre>

The pairs of amicable numbers below 20,000 are :

=={{header|Frink}}==

This example uses Frink's built-in efficient factorization algorithms. It can work for arbitrarily large numbers.

n = 1

seen = new set

}

} while n <= 20000

{{out}}

<pre>

This program is much too parallel and manifests all the pairs, which requires a giant amount of memory.

 

fun divisors(n: int): []int =

filter (fn x => n%x == 0) (map (1+) (iota (n/2)))

let amicable = filter amicable (map (getPair divs) (iota (upper*upper)))

in map (fn (np,mp) => [#1 np, #1 mp]) amicable

 

=={{header|GFA Basic}}==

 

OPENW 1

CLEARW 1

RETURN sum%

ENDFUNC

 

Output is:

 

=={{header|Go}}==

 

import "fmt"

}

}

 

{{output}}

 

=={{header|Haskell}}==

divisors n = filter ((0 ==) . (n `mod`)) [1 .. (n `div` 2)]

 

pairs = [(n, m) | (n, nd) <- divs, (m, md) <- divs,

n < m, nd == m, md == n]

{{out}}

<pre>[(220,284),(1184,1210),(2620,2924),(5020,5564),(6232,6368),(10744,10856),(12285,14595),(17296,18416)]</pre>

Or, deriving proper divisors above the square root as cofactors (for better performance)

 

 

amicablePairsUpTo :: Int -> [(Int, Int)]

 

main :: IO ()

{{Out}}

<pre>(220,284)

[[Proper divisors#J|Proper Divisor implementation]]:

 

 

Amicable pairs:

 

220 284

1184 1210

10744 10856

12285 14595

 

=={{header|Java}}==

{{works with|Java|8}}

import java.util.function.Function;

import java.util.stream.Collectors;

return LongStream.rangeClosed(1, (n + 1) / 2).filter(i -> n % i == 0).sum();

}

 

<pre>220 284

===ES5===

 

// Proper divisors

) + '\n\n' + JSON.stringify(pairs);

 

{{out}}

|}

 

 

===ES6===

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>[220,284]

 

=={{header|jq}}==

def proper_divisors:

. as $n

end ;

 

{{out}}

220 and 284 are amicable

1184 and 1210 are amicable

10744 and 10856 are amicable

12285 and 14595 are amicable

 

=={{header|Julia}}==

Given <code>factor</code>, it is not necessary to calculate the individual divisors to compute their sum. See [[Abundant,_deficient_and_perfect_number_classifications#Julia|Abundant, deficient and perfect number classifications]] for the details.

It is safe to exclude primes from consideration; their proper divisor sum is always 1. This code also uses a minor trick to ensure that none of the numbers identified are above the limit. All numbers in the range are checked for an amicable partner, but the pair is cataloged only when the greater member is reached.

 

function pcontrib(p::Int64, a::Int64)

 

amicables()

<pre>

Amicable pairs not greater than 20000000

15 => 100485, 124155

16 => 122265, 139815

138 => 18655744, 19154336

139 => 16871582, 19325698

140 => 17844255, 19895265

141 => 17754165, 19985355

</pre>

 

=={{header|K}}==

propdivs:{1+&0=x!'1+!x%2}

(8,2)#v@&{(x=+/propdivs[a])&~x=a:+/propdivs[x]}' v:1+!20000

12285 14595

17296 18416)

 

=={{header|Kotlin}}==

 

fun sumProperDivisors(n: Int): Int {

}

}

 

{{out}}

 

=={{header|Lua}}==

local sum = 1

for d = 2, math.sqrt(n) do

if sumDivs(m) == n then print(n, m) end

end

 

{{out}}<pre>

12285 14595

17296 18416

</pre>

 

=={{header|MAD}}==

 

DIMENSION DIVS(20000)

PRINT COMMENT $ AMICABLE PAIRS$

VECTOR VALUES AMI = $I6,I6*$

 

{{out}}

{{output?}}

 

with(NumberTheory):

pairs:=[];

end do;

pairs;

 

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

Module[{sum = Total[Most@Divisors@n]},

sum != n && n == Total[Most@Divisors@sum]]

 

 

{{out}}<pre>

 

=={{header|MATLAB}}==

tic

N=2:1:20000; aN=[];

K=1:ceil(x/2);

D=K(~(rem(x, K)));

 

{{out}}

Being a novice, I submitted my code to the Nim community for review and received much feedback and advice.

They were instrumental in fine-tuning this code for style and readability, I can't thank them enough.

from math import sqrt

 

if m != 0 and n == sumProperDivisors(m, false):

echo $n, " ", $m

{{out}}

<pre>

Here's a second version that uses a large amount of memory but runs in 2m32seconds.

Again, thanks to the Nim community

from math import sqrt

 

if n < m and n != 0 and m == x[n] + 1:

echo n, " ", m

{{out}}

<pre>

 

=={{header|Oberon-2}}==

MODULE AmicablePairs;

IMPORT

END

END AmicablePairs.

{{Out}}

<pre>

Using properDivs implementation tasks without optimization (calculating proper divisors sum without returning a list for instance) :

 

 

Integer method: properDivs -- []

[ i, j ] over add

]

 

{{out}}

[[220, 284], [1184, 1210], [2620, 2924], [5020, 5564], [6232, 6368], [10744, 10856], [12285, 14595], [17296, 18416]]

</pre>

 

=={{header|PARI/GP}}==

{{out}}

<pre>220 284

Amicable! 17296,18416,

 

Program SumOfFactors; uses crt; {Perpetrated by R.N.McLean, December MCMXCV}

//{$DEFINE ShowOverflow}

end;

Close (outf);

 

===More expansive.===

a "normal" Version. Nearly fast as perl using nTheory.

{$IFDEF FPC}

{$MODE DELPHI}

writeln('Time to find amicable pairs ',FormatDateTime('HH:NN:SS.ZZZ' ,T2-T1));

{$IFNDEF UNIX} readln;{$ENDIF}

Output

<pre> 1 220 284 ratio 1.2909091

Using "Sieve of Erathosthenes"-style

 

{find amicable pairs in a limited region 2..MAX

beware that >both< numbers must be smaller than MAX

readln;

{$ENDIF}

output

<pre>

Not particularly clever, but instant for this example, and does up to 20 million in 11 seconds.

{{libheader|ntheory}}

for my $x (1..20000) {

my $y = divisor_sum($x)-$x;

say "$x $y" if $y > $x && $x == divisor_sum($y)-$y;

{{out}}

<pre>220 284

 

=={{header|Phix}}==

<span style="color: #008080;">for</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20000</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">m</span><span style="color: #0000FF;"><</span><span style="color: #000000;">n</span> <span style="color: #008080;">and</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">then</span> <span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">}</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

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

{{out}}

<pre>

 

=={{header|Phixmonti}}==

var n

1 var sum n sqrt

endfor

 

 

=={{header|PHP}}==

 

 

function sumDivs ($n) {

}

 

{{out}}

<pre>220 284

12285 14595

17296 18416</pre>

 

=={{header|PicoLisp}}==

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

(< I X)

(= I (factor-sum X))

{{output}}

<pre>

=={{header|PL/I}}==

{{trans|REXX}}

ami: Proc Options(main);

p9a=time();

Return((p9c-p9b)/1000);

End;

{{out}}

<pre> sum(pd) computed in 0.510 seconds elapsed

17296 18416 found after 2.240 seconds

2.250 seconds total search time</pre>

 

=={{header|PL/M}}==

/* CP/M CALLS */

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

/* TEST EACH PAIR */

DO I=2 TO 20$000;

CALL PRINT$NUMBER(I);

CALL PRINT(.', $');

 

CALL EXIT;

{{out}}

<pre>220, 284

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

function Get-ProperDivisorSum ( [int]$N )

{

 

Get-AmicablePairs 20000

{{out}}

<pre>

With some guidance from other solutions here:

 

UpperBound is round(sqrt(N)),

between(1, UpperBound, D),

amicable_pairs_under_20000(Pairs) :-

assoc_num_divsSum_in_range(1,20000, Assoc),

 

Output:

 

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

=={{header|Python}}==

Importing [[Proper_divisors#Python:_From_prime_factors|Proper divisors from prime factors]]:

 

def amicable(rangemax=20000):

for num, divsum in amicable():

print('Amicable pair: %i and %i With proper divisors:\n %r\n %r'

 

{{out}}

Or, supplying our own '''properDivisors''' function, and defining the harvest in terms of a generic '''concatMap''':

 

 

from itertools import chain

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>(220, 284)

<code>properdivisors</code> is defined at [[Proper divisors#Quackery]].

 

dup size 0 = iff

[ drop 0 ] done

nested join ] ] ] is amicables ( n --> [ )

 

{{out}}

=={{header|R}}==

 

divisors <- function (n) {

Filter( function (m) 0 == n %% m, 1:(n/2) )

cat(n, " ", m, "\n")

}

 

{{out}}

=={{header|Racket}}==

With [[Proper_divisors#Racket]] in place:

(require "proper-divisors.rkt")

(define SCOPE 20000)

EOS

n m n (proper-divisors n) m (proper-divisors m)))

 

{{out}}

(formerly Perl 6)

{{Works with|Rakudo|2019.03.1}}

my @l = 1 if x > 1;

(2 .. x.sqrt.floor).map: -> \d {

my $j = propdivsum($i);

say "$i $j" if $j > $i and $i == propdivsum($j);

{{out}}

<pre>220 284

 

=={{header|REBOL}}==

 

sum-of-divisors: func[n /local sum][

if n = sum-of-divisors m [ print [n tab m] ]

]

 

{{out}}

12285 14595

17296 18416

</pre>

 

=={{header|REXX}}==

===version 1, with factoring===

/*REXX*/

 

sum=sum+word(list,i)

End

{{out}}

<pre>sum(pd) computed in 48.502000 seconds

 

CPU time consumption note: &nbsp; for every doubling of &nbsp; '''H''' &nbsp; (the upper limit for searches), &nbsp; the CPU time consumed triples.

parse arg H .; if H=='' | H=="," then H= 20000 /*get optional arguments (high limit).*/

w= length(H) ; low= 220 /*W: used for columnar output alignment*/

/* ___ */

if j*j==x then return s + j /*Was X a square? If so, add √ X */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

The optimization makes it about <u>another</u> &nbsp; '''30%''' &nbsp; faster when searching for amicable numbers up to one million.

parse arg H .; if H=='' | H=="," then H=20000 /*get optional arguments (high limit).*/

w=length(H) ; low=220 /*W: used for columnar output alignment*/

/* ___ */

if j*j==x then return s + j /*Was X a square? If so, add √ X */

{{out|output|text=&nbsp; is identical to the 2^nd REXX version.}} <br><br>

 

 

The optimization makes it about <u>another</u> &nbsp; '''20%''' &nbsp; faster when searching for amicable numbers up to one million.

parse arg H .; if H=='' | H=="," then H=20000 /*get optional arguments (high limit).*/

w= length(H) ; low= 220 /*W: used for columnar output alignment*/

/* ___ */

if j*j==x then return s + j /*Was X a square? If so, add √ X */

{{out|output|text=&nbsp; is identical to the 2^nd REXX version.}} <br><br>

 

 

The optimization makes it about <u>another</u> &nbsp; '''15%''' &nbsp; faster when searching for amicable numbers up to one million.

parse arg H .; if H=='' | H=="," then H=20000 /*get optional arguments (high limit).*/

w= length(H) ; low= 220 /*W: used for columnar output alignment*/

/* ___ */

if j*j==x then return s + j /*Was X a square? If so, add √ X */

{{out|output|text=&nbsp; is identical to the 2^nd REXX version.}} <br><br>

 

=={{header|Ring}}==

size = 18500

for n = 1 to size

next

return sum

 

=={{header|Ruby}}==

With [[proper_divisors#Ruby]] in place:

(1..20_000).each{|n| h[n] = n.proper_divisors.sum }

h.select{|k,v| h[v] == k && k < v}.each do |key,val| # k<v filters out doubles and perfects

puts "#{key} and #{val}"

end

{{out}}<pre>

220 and 284

 

=={{header|Run BASIC}}==

for n = 1 to size

m = amicable(n)

if nr mod d = 0 then amicable = amicable + d + nr / d

next

<pre>

220 and 284

=={{header|Rust}}==

 

(1..val/2+1).filter(|n| val % n == 0)

.fold(0, |sum, n| sum + n)

}

}

{{out}}

<pre>

14595 12285

18416 17296

</pre>

 

=={{header|Scala}}==

val divisorsSum = (1 to 20000).map(i => i -> properDivisors(i).sum).toMap

val result = divisorsSum.filter(v => v._1 < v._2 && divisorsSum.get(v._2) == Some(v._1))

 

{{out}}

<pre>5020 -> 5564, 220 -> 284, 6232 -> 6368, 17296 -> 18416, 2620 -> 2924, 10744 -> 10856, 12285 -> 14595, 1184 -> 1210</pre>

=={{header|Scheme}}==

 

(import (scheme base)

(scheme inexact)

(loop-j (+ 1 j))))

(loop-i (+ 1 i))))

 

{{out}}

Amicable pair: 17296 18416

</pre>

 

=={{header|Sidef}}==

n.sigma - n

}

var j = propdivsum(i)

say "#{i} #{j}" if (j>i && i==propdivsum(j))

{{out}}

<pre>

 

=={{header|Swift}}==

 

func sqrt(x:Int) -> Int { return Int(sqrt(Double(x))) }

}

}

===Alternative===

 

func sqrt(x:Int) -> Int { return Int(sqrt(Double(x))) }

}

 

{{out}}

<pre>(220, 284)

 

=={{header|tbas}}==

dim sums(20000)

 

next

next

<pre>

>tbas amicable_pairs.bas

 

=={{header|Tcl}}==

if {$n == 1} return

set divs 1

puts "\t$m : $md"

puts "\t$n : $nd"

{{out}}

<pre>

 

=={{header|Transd}}==

#lang transd

 

(textout (+ @idx 1) ", " i "\n")

)))))

<pre>

284, 220

 

=={{header|uBasic/4tH}}==

Print "Amicable pairs < ";l

 

 

If (b@ > 1) c@ = c@ * (b@+1)

{{Out}}

<pre>Limit: 20000

 

=={{header|UTFool}}==

···

http://rosettacode.org/wiki/Amicable_pairs

m +: n \ i = 0 ? i + (i = n / i ? 0 ! n / i) ! 0

⏎ m

 

=={{header|VBA}}==

Public Sub AmicablePairs()

If n Mod j = 0 Then S = j + S

Next

{{out}}

<pre>Execution Time : 7,95703125 seconds.

=={{header|VBScript}}==

Not at all optimal. :-(

Set nlookup = CreateObject("Scripting.Dictionary")

Set uniquepair = CreateObject("Scripting.Dictionary")

Next

 

{{out}}

<pre>220:284

17296:18416

Execution Time: 162 seconds</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

 

var a = List.filled(20000, 0)

var m = a[n]

if (m > n && m < 20000 && n == a[m]) {

}

 

{{out}}

12285 and 14595

17296 and 18416

</pre>

 

=={{header|Yabasic}}==

{{trans|Lua}}

local sum, d

next

 

 

=={{header|zkl}}==

Slooooow

const N=20000;

sums:=[1..N].pump(T(-1),fcn(n){ properDivs(n).sum(0) });

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|AWK}}

20 PRINT "Amicable pairs < ";limit

30 FOR n=1 TO limit

1070 IF num/root=INT (num/root) THEN LET sum=sum+root

1080 LET num=sum

{{out}}

<pre>Amicable pairs < 20000