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

=={{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 amicable64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

<pre>

220 : 284

Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.

{{libheader|Action! Sieve of Eratosthenes}}

 

CARD FUNC SumDivisors(CARD x)

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Amicable_pairs.png Screenshot from Atari 8-bit computer]

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

 

procedure Amicable_Pairs is

end if;

end loop;

{{Out}}

<pre>

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

{{works with|A60}}

begin

 

 

end

{{out}}

<pre>

 

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

# if n = 1, 0 or -1, we return 0 #

PROC sum proper divisors = ( INT n )INT:

FI

OD

{{out}}

<pre>

{{Trans|GFA Basic}}

 

110 CLEAR

120 !

460 END IF

470 LET sum_proper_divisors = sum

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

 

 

-- amicablePairsUpTo :: Int -> Int

end script

end if

{{Out}}

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

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

/* ARM assembly Raspberry PI or android with termux */

/* program amicable.s */

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

.include "../affichage.inc"

<pre>

220 : 284

</pre>

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

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

if number < 2 then return 0

sum = 0

end if

next n

{{out}}

<pre>The pairs of amicable numbers below 20,000 are :

 

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

 

=={{header|C sharp|C#}}==

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>

 

=={{header|CLU}}==

proper_divisors = proc (max: int) returns (array[int])

divs: array[int] := array[int]$fill(1, max, 0)

end

end

{{out}}

<pre>220, 284

 

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

* P[n] is the sum of proper divisors of N */

proc nonrec propdivs([*] word p) void:

od

od

{{out}}

<pre> 220, 284

 

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

{{trans|C#}}

ELENA 5.0 :

import system'routines;

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

}

{{out}}

<pre>

</pre>

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

import system'routines'stex;

import system'collections;

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

}

=== Alternative variant using yield enumerator ===

import system'routines'stex;

import system'collections;

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

 

=={{header|F_Sharp|F#}}==

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

Calculate many times the divisors.

 

dup 2 / 1+ 1 ?do

dup i mod 0= if i swap then

loop ;

 

 

{{out}}

Use memory to store sum of divisors, a little quicker.

 

 

: proper-divisors ( n -- 1..n )

build-amicable-table .amicables ;

 

 

{{out}}

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>

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

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

 

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

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

 

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

0.02 of a second in 16 lines of code.

The vital trick is to just set m to the sum of n's proper divisors each time. That way you only have to test the reverse, dividing your run time by half the loop limit (ie. 10,000)!

local sum = 1

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

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

end

 

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

 

=={{header|OCaml}}==

if n = 1 then 1

else let _n = isqrt (n - 1) in

if (sum_divs m) = n then Printf.printf "%d %d\n" n m;

done

{{out}}

<pre>220 284

 

=={{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: #004080;">integer</span> <span style="color: #000000;">n</span>

<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

 

Also, the calculation of the sum of divisors is tabled (the table is cleared between each run).

N = 20000,

 

sum_divisors(I,N,Sum0,Sum) =>

sum_divisors(I+1,N,Sum0,Sum).

 

{{out}}

 

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

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

Rather than populating an array with the sum of the proper divisors and then searching, the approach here performs an direct test, saving memory, and at a minimal penalty in execution speed, even though about 25% more calls are made to sumf() than would be required simply to initialize an array.

amicable: procedure options (main);

 

 

end amicable;

{{out}}

<pre>

 

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

/* CP/M CALLS */

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

 

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

 

=={{header|ReScript}}==

Belt.Float.toInt(

sqrt(Belt.Int.toFloat(v)))

}

}

{{output}}

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

 

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

 

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

 

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

=={{header|Vlang}}==

{{trans|Go}}

mut sum := 0

for p := 1;p <= i/2;p++{

}

}

 

{{output}}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "/math" for Int, Nums

 

System.print(" %(Fmt.d(5, n)) and %(Fmt.d(5, m))")

}

 

{{out}}

 

=={{header|XPL0}}==

int Num, Div, Sum, Quot;

[Div:= 2;

];

];

 

{{out}}

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

 

// Fill up a given array with arr[n] = sum(propDivs(n))

}

}

{{out}}

<pre>220, 284

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