Proper divisors: Difference between revisions
→{{header|langur}}
m (→Faster Proper Divisor Counting: Added note on running under Algol 68G) |
Langurmonkey (talk | contribs) |
||
(35 intermediate revisions by 22 users not shown) | |||
Line 30:
{{trans|Python}}
<
R Array(Set((1 .. (n + 1) I/ 2).filter(x -> @n % x == 0 & @n != x)))
Line 36:
V (n, leng) = max(((1..20000).map(n -> (n, proper_divs(n).len))), key' pd -> pd[1])
print(n‘ ’leng)</
{{out}}
Line 47:
{{trans|Rexx}}
This program uses two ASSIST macros (XDECO, XPRNT) to keep the code as short as possible.
<
PROPDIV CSECT
USING PROPDIV,R13 base register
Line 180:
XDEC DS CL12
YREGS
END PROPDIV</
{{out}}
<pre>
Line 194:
10 has 3 proper divisors: 1 2 5
15120 has 79 proper divisors.
</pre>
=={{header|Action!}}==
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.
<syntaxhighlight lang="action!">BYTE FUNC GetDivisors(INT a INT ARRAY divisors)
INT i,max
BYTE count
max=a/2
count=0
FOR i=1 TO max
DO
IF a MOD i=0 THEN
divisors(count)=i
count==+1
FI
OD
RETURN (count)
PROC Main()
DEFINE MAXNUM="20000"
INT i,j,count,max,ind
INT ARRAY divisors(100)
BYTE ARRAY pdc(MAXNUM+1)
FOR i=1 TO 10
DO
count=GetDivisors(i,divisors)
PrintF("%I has %I proper divisors: [",i,count)
FOR j=0 TO count-1
DO
PrintI(divisors(j))
IF j<count-1 THEN
Put(32)
FI
OD
PrintE("]")
OD
PutE() PrintE("Searching for max number of divisors:")
FOR i=1 TO MAXNUM
DO
pdc(i)=1
OD
FOR i=2 TO MAXNUM
DO
FOR j=i+i TO MAXNUM STEP i
DO
pdc(j)==+1
OD
OD
max=0 ind=0
FOR i=1 TO MAXNUM
DO
count=pdc(i)
IF count>max THEN
max=count ind=i
FI
OD
PrintF("%I has %I proper divisors%E",ind,max)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Proper_divisors.png Screenshot from Atari 8-bit computer]
<pre>
1 has 0 proper divisors: []
2 has 1 proper divisors: [1]
3 has 1 proper divisors: [1]
4 has 2 proper divisors: [1 2]
5 has 1 proper divisors: [1]
6 has 3 proper divisors: [1 2 3]
7 has 1 proper divisors: [1]
8 has 3 proper divisors: [1 2 4]
9 has 2 proper divisors: [1 3]
10 has 3 proper divisors: [1 2 5]
Searching for max number of divisors:
15120 has 79 proper divisors
</pre>
Line 204 ⟶ 283:
[[http://rosettacode.org/wiki/Amicable_pairs#Ada]], we define this routine as a function of a generic package:
<
type Result_Type (<>) is limited private;
None: Result_Type;
Line 222 ⟶ 301:
else Process(N, First+1));
end Generic_Divisors;</
Now we instantiate the ''generic package'' to solve the other two parts of the task. Observe that there are two different instantiations of the package: one to generate a list of proper divisors, another one to count the number of proper divisors without actually generating such a list:
<
procedure Proper_Divisors is
Line 284 ⟶ 363:
Natural'Image(Number_Count) & " proper divisors.");
end;
end Proper_Divisors; </
{{out}}
Line 303 ⟶ 382:
===As required by the Task===
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
<
MODE DIVISORLIST = STRUCT( INT divisor, REF DIVISORLIST next );
Line 394 ⟶ 473:
, " divisors"
, newline
) )</
{{out}}
<pre>
Line 412 ⟶ 491:
===Faster Proper Divisor Counting===
Alternative version that uses a sieve-like approach for faster proper divisor counting.
<br><br>Note, in order to run this with Algol 68G under Windows (and possibly
<
# find the first/only number in 1 : 20 000 and 1 : 64 000 000 with #
# the most divisors #
Line 450 ⟶ 529:
max number := 64 000 000
OD
END</
{{out}}
Line 460 ⟶ 539:
=={{header|ALGOL-M}}==
Algol-M's maximum allowed integer value of 16,383 prevented searching up to 20,000 for the number with the most divisors, so the code here searches only up to 10,000.
<
BEGIN
Line 532 ⟶ 611:
END
</syntaxhighlight>
{{out}}
<pre>
Line 554 ⟶ 633:
===Functional===
{{Trans|JavaScript}}
<
-- properDivisors :: Int -> [Int]
Line 683 ⟶ 762:
end script
end if
end mReturn</
{{Out}}
<
{num:4, divisors:{1, 2}}, {num:5, divisors:{1}}, {num:6, divisors:{1, 2, 3}},
{num:7, divisors:{1}}, {num:8, divisors:{1, 2, 4}}, {num:9, divisors:{1, 3}},
{num:10, divisors:{1, 2, 5}}},
mostDivisors:{num:18480, divisors:79}}</
----
===Idiomatic===
<
set output to {}
Line 740 ⟶ 819:
set output to output as text
set AppleScript's text item delimiters to astid
return output</
{{output}}
<
2's proper divisors: {1}
3's proper divisors: {1}
Line 755 ⟶ 834:
Largest number of proper divisors for any number from 1 to 20,000: 79
Numbers with this many: 15120, 18480"</
=={{header|Arc}}==
<syntaxhighlight lang="arc">
;; Given num, return num and the list of its divisors
Line 805 ⟶ 884:
(div-lists 20000)
;; This took about 10 minutes on my machine.
</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="arc">
(1 0)
(2 1)
Line 828 ⟶ 907:
It is the number 18480.
There are 2 numbers with this trait, and they are (18480 15120)
</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program proFactor.s */
Line 1,001 ⟶ 1,080:
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
{{Output}}
<pre>
Line 1,031 ⟶ 1,110:
=={{header|Arturo}}==
<
(factors x) -- x
Line 1,048 ⟶ 1,127:
]
print ["The number with the most proper divisors (" maxProperDivisors ") is" maxN]</
{{out}}
Line 1,065 ⟶ 1,144:
=={{header|AutoHotkey}}==
<
Array := []
if n = 1
Line 1,078 ⟶ 1,157:
Array[i] := true
return Array
}</
Examples:<
loop, 10
{
Line 1,096 ⟶ 1,175:
output .= "`nNumber(s) in the range 1 to 20,000 with the most proper divisors:`n" numDiv.Pop() " with " maxDiv " divisors"
MsgBox % output
return</
{{out}}
<pre>Number Divisors Count
Line 1,114 ⟶ 1,193:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f PROPER_DIVISORS.AWK
BEGIN {
Line 1,151 ⟶ 1,230:
return
}
</syntaxhighlight>
<p>output:</p>
<pre>
Line 1,169 ⟶ 1,248:
18480 79 divisors not shown
</pre>
=={{header|BASIC}}==
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FUNCTION CountProperDivisors (number)
IF number < 2 THEN CountProperDivisors = 0
count = 0
FOR i = 1 TO number \ 2
IF number MOD i = 0 THEN count = count + 1
NEXT i
CountProperDivisors = count
END FUNCTION
SUB ListProperDivisors (limit)
IF limit < 1 THEN EXIT SUB
FOR i = 1 TO limit
PRINT USING "## ->"; i;
IF i = 1 THEN PRINT " (None)";
FOR j = 1 TO i \ 2
IF i MOD j = 0 THEN PRINT " "; j;
NEXT j
PRINT
NEXT i
END SUB
most = 1
maxCount = 0
PRINT "The proper divisors of the following numbers are: "; CHR$(10)
ListProperDivisors (10)
FOR n = 2 TO 20000
'' It is extremely slow in this loop
count = CountProperDivisors(n)
IF count > maxCount THEN
maxCount = count
most = n
END IF
NEXT n
PRINT
PRINT most; " has the most proper divisors, namely "; maxCount
END</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC o PureBasic.
</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">subroutine ListProperDivisors(limit)
if limit < 1 then return
for i = 1 to limit
print i; " ->";
if i = 1 then
print " (None)"
continue for
end if
for j = 1 to i \ 2
if i mod j = 0 then print " "; j;
next j
print
next i
end subroutine
function CountProperDivisors(number)
if number < 2 then return 0
dim cont = 0
for i = 1 to number \ 2
if number mod i = 0 then cont += 1
next i
return cont
end function
most = 1
maxCount = 0
print "The proper divisors of the following numbers are:"
print
call ListProperDivisors(10)
for n = 2 to 20000
cont = CountProperDivisors(n)
if cont > maxCount then
maxCount = cont
most = n
end if
next n
print
print most; " has the most proper divisors, namely "; maxCount
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC o PureBasic.
</pre>
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">let m = 1
let l = 10
if l >= 1 then
for i = 1 to l
if i = 1 then
print i, " : (None)"
else
for j = 1 to int(i / 2)
if i % j = 0 then
print i, " :", j
endif
next j
endif
next i
endif
for n = 2 to 20000
let c = 0
if n >= 2 then
for i = 1 to int(n / 2)
if n % i = 0 then
let c = c + 1
endif
next i
endif
if c > x then
let x = c
let m = n
endif
wait
next n
print m, " has the most proper divisors", comma, " namely ", x</syntaxhighlight>
{{out| Output}}<pre>
1 : (None)
2 : 1
3 : 1
4 : 1 2
5 : 1
6 : 1 2 3
7 : 1
8 : 1 2 4
9 : 1 3
10 : 1 2 5
15120 has the most proper divisors, namely 79
</pre>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION CountProperDivisors (number)
IF number < 2 THEN LET CountProperDivisors = 0
LET count = 0
FOR i = 1 TO INT(number / 2)
IF MOD(number, i) = 0 THEN LET count = count + 1
NEXT i
LET CountProperDivisors = count
END FUNCTION
SUB ListProperDivisors (limit)
IF limit < 1 THEN EXIT SUB
FOR i = 1 TO limit
PRINT i; " ->";
IF i = 1 THEN PRINT " (None)";
FOR j = 1 TO INT(i / 2)
IF MOD(i, j) = 0 THEN PRINT " "; j;
NEXT j
PRINT
NEXT i
END SUB
LET most = 1
LET maxCount = 0
PRINT "The proper divisors of the following numbers are: "; CHR$(10)
CALL LISTPROPERDIVISORS (10)
FOR n = 2 TO 20000
LET count = CountProperDivisors(n)
IF count > maxCount THEN
LET maxCount = count
LET most = n
END IF
NEXT n
PRINT
PRINT most; "has the most proper divisors, namely"; maxCount
END</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC o PureBasic.
</pre>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">sub ListProperDivisors(limit)
if limit < 1 then return : fi
for i = 1 to limit
print i, " ->";
if i = 1 then
print " (None)"
continue //for
endif
for j = 1 to int(i / 2)
if mod(i, j) = 0 then print " ", j; : fi
next j
print
next i
end sub
sub CountProperDivisors(number)
if number < 2 then return 0 : fi
count = 0
for i = 1 to int(number / 2)
if mod(number, i) = 0 then count = count + 1 : fi
next i
return count
end sub
most = 1
maxCount = 0
print "The proper divisors of the following numbers are: \n"
ListProperDivisors(10)
for n = 2 to 20000
count = CountProperDivisors(n)
if count > maxCount then
maxCount = count
most = n
endif
next n
print
print most, " has the most proper divisors, namely ", maxCount
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC o PureBasic.
</pre>
=={{header|BaCon}}==
<
FUNCTION ProperDivisor(nr, show)
Line 1,202 ⟶ 1,542:
PRINT "Most proper divisors for number in the range 1-20000: ", MagicNumber, " with ", MaxDivisors, " divisors."
</syntaxhighlight>
{{out}}
<pre>
Line 1,221 ⟶ 1,561:
===Brute Force===
C has tedious boilerplate related to allocating memory for dynamic arrays, so we just skip the problem of storing values altogether.
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdbool.h>
Line 1,264 ⟶ 1,604:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,281 ⟶ 1,621:
===Number Theoretic===
There is no need to go through all the divisors if only the count is needed, this implementation refines the brute force approach by solving the second part of the task via a Number Theory formula. The running time is noticeably faster than the brute force method above. Output is same as the above.
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdbool.h>
Line 1,351 ⟶ 1,691:
return 0;
}
</syntaxhighlight>
=={{header|C sharp}}==
<
{
using System;
Line 1,385 ⟶ 1,725:
}
}
}</
{{out}}
<pre>1: {}
Line 1,400 ⟶ 1,740:
=={{header|C++}}==
<
#include <iostream>
#include <algorithm>
Line 1,438 ⟶ 1,778:
return 0 ;
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,465 ⟶ 1,805:
=={{header|Ceylon}}==
<
function divisors(Integer int) =>
Line 1,486 ⟶ 1,826:
print("the number(s) with the most divisors between ``start`` and ``end`` is/are:
``mostDivisors?.item else "nothing"`` with ``mostDivisors?.key else "no"`` divisors");
}</
{{out}}
<pre>1 => []
Line 1,502 ⟶ 1,842:
=={{header|Clojure}}==
<
(:gen-class))
Line 1,537 ⟶ 1,877:
(println n " has " (count factors) " divisors"))
</syntaxhighlight>
{{Output}}
<pre>
Line 1,557 ⟶ 1,897:
=={{header|Common Lisp}}==
Ideally, the smallest-divisor function would only try prime numbers instead of odd numbers.
<
"(int,list)->list::Function to find all proper divisors of a +ve integer."
Line 1,592 ⟶ 1,932:
(dotimes (i 10) (format t "~A:~A~%" (1+ i) (proper-divisors-recursive (1+ i))))
(format t "Task 2:Count & list of numbers <=20,000 with the most Proper Divisors:~%~A~%"
(task #'proper-divisors-recursive)))</
{{out}}
<pre>CL-USER(10): (main)
Line 1,612 ⟶ 1,952:
=={{header|Component Pascal}}==
{{Works with|Black Box Component Builder}}
<
MODULE RosettaProperDivisor;
IMPORT StdLog;
Line 1,668 ⟶ 2,008:
^Q RosettaProperDivisor.Do~
</syntaxhighlight>
{{out}}
<pre>
Line 1,689 ⟶ 2,029:
{{trans|Python}}
Currently the lambda of the filter allocates a closure on the GC-managed heap.
<
import std.stdio, std.algorithm, std.range, std.typecons;
Line 1,697 ⟶ 2,037:
iota(1, 11).map!properDivs.writeln;
iota(1, 20_001).map!(n => tuple(properDivs(n).count, n)).reduce!max.writeln;
}</
{{out}}
<pre>[[], [1], [1], [1, 2], [1], [1, 2, 3], [1], [1, 2, 4], [1, 3], [1, 2, 5]]
Line 1,705 ⟶ 2,045:
=={{header|Delphi}}==
{{trans|C#}}
<syntaxhighlight lang="delphi">
program ProperDivisors;
Line 1,772 ⟶ 2,112:
readln;
end.
</syntaxhighlight>
{{out}}
<pre>
Line 1,789 ⟶ 2,129:
Version with TParallel.For
<syntaxhighlight lang="delphi">
program ProperDivisors;
Line 1,857 ⟶ 2,197:
readln;
end.
</syntaxhighlight>
=={{header|Dyalect}}==
Line 1,863 ⟶ 2,203:
{{trans|Swift}}
<
if n == 1 {
yield break
Line 1,873 ⟶ 2,213:
}
}
for i in 1..10 {
print("\(i): \(properDivs(i).
}
Line 1,881 ⟶ 2,221:
for i in 1..20000 {
let count = properDivs(i).
if count > max {
set (num, max) = (i, count)
Line 1,887 ⟶ 2,227:
}
print("\(num): \(max)")</
{{out}}
Line 1,902 ⟶ 2,242:
10: [1, 2, 5]
15120: 79</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
proc propdivs n . divs[] .
divs[] = [ ]
if n < 2
return
.
divs[] &= 1
sqr = sqrt n
for d = 2 to sqr
if n mod d = 0
divs[] &= d
if d <> sqr
divs[] &= n / d
.
.
.
.
for i to 10
propdivs i d[]
write i & ":"
print d[]
.
for i to 20000
propdivs i d[]
if len d[] > max
max = len d[]
maxi = i
.
.
print maxi & " has " & max & " proper divisors."
</syntaxhighlight>
=={{header|EchoLisp}}==
<
(lib 'list) ;; list-delete
Line 1,948 ⟶ 2,321:
</syntaxhighlight>
{{out}}
<
(for ((i (in-range 1 11))) (writeln i (divs i)))
1 null
Line 1,971 ⟶ 2,344:
(lib 'bigint)
(numdivs 95952222101012742144) → 666 ;; 🎩
</syntaxhighlight>
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
class
APPLICATION
Line 2,027 ⟶ 2,400:
end
</syntaxhighlight>
{{out}}
<pre>
Line 2,045 ⟶ 2,418:
=={{header|Elixir}}==
{{trans|Erlang}}
<
def divisors(1), do: []
def divisors(n), do: [1 | divisors(2,n,:math.sqrt(n))] |> Enum.sort
Line 2,064 ⟶ 2,437:
IO.puts "#{n}: #{inspect Proper.divisors(n)}"
end)
Proper.most_divisors(20000)</
{{out}}
Line 2,083 ⟶ 2,456:
=={{header|Erlang}}==
<
-export([divs/1,sumdivs/1,longest/1]).
Line 2,109 ⟶ 2,482:
longest(L,Acc,A,Acc+1);
true -> longest(L,Current,CurLeng,Acc+1)
end.</
{{out}}
<pre>
Line 2,130 ⟶ 2,503:
=={{header|F_Sharp|F#}}==
<
// the simple function with the answer
let propDivs n = [1..n/2] |> List.filter (fun x->n % x = 0)
Line 2,150 ⟶ 2,523:
|> Seq.fold (fun a b ->match a,b with | (_,c1,_),(_,c2,_) when c2 > c1 -> b | _-> a) (0,0,[])
|> fun (n,count,_) -> (n,count,[]) |> show
</syntaxhighlight>
{{out}}
Line 2,168 ⟶ 2,541:
=={{header|Factor}}==
<
math.primes.factors math.ranges prettyprint sequences ;
Line 2,177 ⟶ 2,550:
10 [1,b] [ dup pprint bl divisors but-last . ] each
20000 [1,b] [ #divisors ] supremum-by dup #divisors
"%d with %d divisors.\n" printf</
{{out}}
Line 2,193 ⟶ 2,566:
15120 with 79 divisors.
</pre>
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">Func Divisors(n) =
[d]:=[(1)]; {start divisor list with just 1, which is a divisor of everything}
for i = 2 to n\2 do {loop through possible divisors of n}
if Divides(i, n) then [d]:=[d]_[(i)] fi
od;
.;
for n = 1 to 10 do
Divisors(n);
!!(n,' ',[d);
od;
record:=0;
champ:=1;
for n=2 to 20000 do
Divisors(n);
m:=Cols[d]; {this gets the length of the array}
if m > record then
champ:=n;
record:=m;
fi;
od;
!!('The number up to 20,000 with the most divisors was ',champ,' with ',record,' divisors.');</syntaxhighlight>
{{out}}<pre>
1 1
2 1
3 1
4 1, 2
5 1
6 1, 2, 3
7 1
8 1, 2, 4
9 1, 3
10 1, 2, 5
The number up to 20,000 with the most divisors was 15120 with 79 divisors.</pre>
=={{header|Forth}}==
{{works with|gforth|0.7.3}}
<syntaxhighlight lang="forth">: .proper-divisors
dup 1 ?do
dup i mod 0= if i . then
loop cr drop
;
: proper-divisors-count
0 swap
dup 1 ?do
dup i mod 0= if swap 1 + swap then
loop drop
;
: rosetta-proper-divisors
cr
11 1 do
i . ." : " i .proper-divisors
loop
1 0
20000 2 do
i proper-divisors-count
2dup < if nip nip i swap else drop then
loop
swap cr . ." has " . ." divisors" cr
;
rosetta-proper-divisors</syntaxhighlight>
{{out}}
<pre>1 :
2 : 1
3 : 1
4 : 1 2
5 : 1
6 : 1 2 3
7 : 1
8 : 1 2 4
9 : 1 3
10 : 1 2 5
15120 has 79 divisors
ok</pre>
=={{header|Fortran}}==
Compiled using G95 compiler, run on x86 system under Puppy Linux
<syntaxhighlight lang="fortran">
function icntprop(num )
Line 2,227 ⟶ 2,689:
print *,maxj,' has max proper divisors: ',maxcnt
end
</syntaxhighlight>
{{out}}
<pre>
Line 2,265 ⟶ 2,727:
=={{header|FreeBASIC}}==
<
' FreeBASIC v1.05.0 win64
Line 2,313 ⟶ 2,775:
Sleep
End
</syntaxhighlight>
{{out}}
Line 2,332 ⟶ 2,794:
15120 has the most proper divisors, namely 79
</pre>
=={{header|Frink}}==
Frink's built-in factorization routines efficiently find factors of arbitrary-sized integers.
<
for n = 1 to 10
println["$n\t" + join[" ", properDivisors[n]]]
Line 2,353 ⟶ 2,816:
properDivisors[n] := allFactors[n, true, false, true]
</syntaxhighlight>
{{out}}
<pre>
Line 2,368 ⟶ 2,831:
[15120, 18480] have 79 factors
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn ProperDivisors( n as long ) as CFArrayRef
CFMutableArrayRef array = fn MutableArrayWithCapacity(0)
if ( n < 2 ) then exit fn
long i
for i = 1 to n - 1
if ( n mod i == 0 )
MutableArrayAddObject( array, @(i) )
end if
next
end fn = array
void local fn DoIt
long n, count, num, max = 0
for n = 1 to 10
printf @"%2ld: %@",n,fn ArrayComponentsJoinedByString( fn ProperDivisors( n ), @" " )
next
for n = 1 to 20000
count = len( fn Properdivisors( n ) )
if ( count > max )
max = count
num = n
end if
next
print: print num;@" has the most proper divisors with ";max
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
1:
2: 1
3: 1
4: 1 2
5: 1
6: 1 2 3
7: 1
8: 1 2 4
9: 1 3
10: 1 2 5
15120 has the most proper divisors with 79
</pre>
=={{header|GFA Basic}}==
<syntaxhighlight lang="text">
OPENW 1
CLEARW 1
Line 2,448 ⟶ 2,964:
RETURN count%-1
ENDFUNC
</syntaxhighlight>
Output is:
Line 2,467 ⟶ 2,983:
=={{header|Go}}==
{{trans|Kotlin}}
<
import (
Line 2,528 ⟶ 3,044:
fmt.Println(n)
}
}</
{{out}}
Line 2,552 ⟶ 3,068:
=={{header|Haskell}}==
<
import Data.List
Line 2,564 ⟶ 3,080:
putStrLn "a number with the most divisors within 1 to 20000 (number, count):"
print $ maximumBy (comparing snd)
[(n, length $ divisors n) | n <- [1 .. 20000]]</
{{out}}
<pre>divisors of 1 to 10:
Line 2,582 ⟶ 3,098:
For a little more efficiency, we can filter only up to the root – deriving the higher proper divisors from the lower ones, as quotients:
<
import Data.Ord (comparing)
import Data.Bool (bool)
Line 2,607 ⟶ 3,123:
print $
maximumBy (comparing snd) $
(,) <*> (length . properDivisors) <$> [1 .. 20000]</
{{Out}}
<pre>Proper divisors of 1 to 10:
Line 2,628 ⟶ 3,144:
and we can also define properDivisors in terms of primeFactors:
<
import Data.List (group, maximumBy, sort)
import Data.Ord (comparing)
Line 2,660 ⟶ 3,176:
w = maximum (length . xShow <$> xs)
in unlines $
s : fmap (((++) . rjust w ' ' . xShow) <*> ((" -> " ++) . fxShow . f)) xs</
{{Out}}
<pre>Proper divisors of [1..10]:
Line 2,686 ⟶ 3,202:
So, borrowing from [[Factors of an integer#J|the J implementation]] of that related task:
<
properDivisors=: factors -. ]</
Proper divisors of numbers 1 through 10:
<
1 --
2 -- 1
Line 2,701 ⟶ 3,217:
8 -- 1 2 4
9 -- 1 3
10 -- 1 2 5</
Number(s) not exceeding 20000 with largest number of proper divisors (and the count of those divisors):
<
15120 79
18480 79</
Note that it's a bit more efficient to simply count factors here, when selecting the candidate numbers.
<
15120 79
18480 79</
We could also arbitrarily toss either 15120 or 18480 (keeping the other number), if it were important that we produce only one result.
Line 2,719 ⟶ 3,235:
=={{header|Java}}==
{{works with|Java|1.5+}}
<
import java.util.LinkedList;
import java.util.List;
Line 2,751 ⟶ 3,267:
System.out.println(x + ": " + count);
}
}</
{{out}}
<pre>1: []
Line 2,769 ⟶ 3,285:
===ES5===
<
// Proper divisors
Line 2,837 ⟶ 3,353:
);
})();</
{{out}}
Line 2,872 ⟶ 3,388:
===ES6===
<
'use strict';
Line 2,981 ⟶ 3,497:
// MAIN ---
return main();
})();</
{{Out}}
<pre>Proper divisors of [1..10]:
Line 3,001 ⟶ 3,517:
{{works with|jq|1.4}}
In the following, proper_divisors returns a stream. In order to count the number of items in the stream economically, we first define "count(stream)":
<
# unordered
Line 3,021 ⟶ 3,537:
( [null, 0];
count( $i | proper_divisors ) as $count
| if $count > .[1] then [$i, $count] else . end);</
'''The tasks:'''
<
(range(1;11) as $i | "\($i): \( [ $i | proper_divisors] )"),
"",
Line 3,029 ⟶ 3,545:
"the maximal number proper divisors together with the corresponding",
"count of proper divisors is:",
most_proper_divisors(20000) </
{{out}}
<
The proper divisors of the numbers 1 to 10 inclusive are:
1: []
Line 3,047 ⟶ 3,563:
the maximal number proper divisors together with the corresponding
count of proper divisors is:
[15120,79]</
=={{header|Julia}}==
Use <code>factor</code> to obtain the prime factorization of the target number. I adopted the argument handling style of <code>factor</code> in my <code>properdivisors</code> function.
<syntaxhighlight lang="julia">
using Primes
function properdivisors(n::T) where {T<:Integer}
0 < n || throw(ArgumentError("number to be factored must be ≥ 0, got $n"))
1 < n || return T[]
!isprime(n) || return T[one(T)
f = factor(n)
d = T[one(T)]
Line 3,091 ⟶ 3,608:
println(nlst, " have the maximum proper divisor count of ", maxdiv, ".")
</syntaxhighlight>
{{out}}
Line 3,112 ⟶ 3,629:
=={{header|Kotlin}}==
<
fun listProperDivisors(limit: Int) {
Line 3,151 ⟶ 3,668:
println("The following number(s) have the most proper divisors, namely " + maxCount + "\n")
for (n in most) println(n)
}</
{{out}}
Line 3,172 ⟶ 3,689:
15120
18480
</pre>
=={{header|langur}}==
{{trans|Go}}
<syntaxhighlight lang="langur">val .getproper = fn .x: for[=[]] .i of .x \ 2 { if .x div .i: _for ~= [.i] }
val .cntproper = fn .x: for[=0] .i of .x \ 2 { if .x div .i: _for += 1 }
val .listproper = fn(.x) {
if .x < 1: return null
for[=""] .i of .x {
_for ~= "{{.i:2}} -> {{.getproper(.i)}}\n"
}
}
writeln "The proper divisors of the following numbers are :"
writeln .listproper(10)
var .max = 0
var .most = []
for .n in 2 .. 20_000 {
val .cnt = .cntproper(.n)
if .cnt == .max {
.most = more .most, .n
} else if .cnt > .max {
.max, .most = .cnt, [.n]
}
}
writeln "The following number(s) <= 20000 have the most proper divisors ({{.max}})"
writeln .most
</syntaxhighlight>
{{out}}
<pre>The proper divisors of the following numbers are :
1 -> []
2 -> [1]
3 -> [1]
4 -> [1, 2]
5 -> [1]
6 -> [1, 2, 3]
7 -> [1]
8 -> [1, 2, 4]
9 -> [1, 3]
10 -> [1, 2, 5]
The following number(s) <= 20000 have the most proper divisors (79)
[15120, 18480]
</pre>
=={{header|Lua}}==
<
function propDivs (n)
if n < 2 then return {} end
Line 3,206 ⟶ 3,771:
end
end
print(answer .. " has " .. mostDivs .. " proper divisors.")</
{{out}}
<pre>1:
Line 3,223 ⟶ 3,788:
A Function that yields the proper divisors of an integer n:
<
Proper divisors of n from 1 to 10:
<
{{out}}
<pre>1 {}
Line 3,240 ⟶ 3,805:
The number with the most divisors between 1 and 20,000:
<syntaxhighlight lang="mathematica">Fold[
Last[SortBy[{#1, {#2, Length@ProperDivisors[#2]}}, Last]] &,
{0, 0},
Range[20000]]</
{{out}}
<pre>{18480, 79}</pre>
An alternate way to find the number with the most divisors between 1 and 20,000:
<
Table[
{n, Length@ProperDivisors[n]},
{n, 1, 20000}],
Last]</
{{out}}
<pre>{15120, 79}</pre>
=={{header|MATLAB}}==
<
K=1:ceil(N/2);
D=K(~(rem(N, K)));</
{{out}}
Line 3,299 ⟶ 3,864:
=={{header|Modula-2}}==
<
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
Line 3,352 ⟶ 3,917:
ReadChar
END ProperDivisors.</
=={{header|Nim}}==
{{trans|C}}
<
proc properDivisors(n: int) =
Line 3,397 ⟶ 3,962:
maxI = i
echo fmt"{maxI} with {max} divisors"</
{{out}}
<pre>
Line 3,414 ⟶ 3,979:
=={{header|Oberon-2}}==
<
MODULE ProperDivisors;
IMPORT
Line 3,511 ⟶ 4,076:
END
END ProperDivisors.
</syntaxhighlight>
{{out}}
<pre>
Line 3,531 ⟶ 4,096:
=={{header|Objeck}}==
<
class Proper{
Line 3,574 ⟶ 4,139:
}
}
</syntaxhighlight>
Output:
Line 3,593 ⟶ 4,158:
=={{header|Oforth}}==
<
10 seq apply(#[ dup print " : " print properDivs println ])
20000 seq map(#[ dup properDivs size Pair new ]) reduce(#maxKey) println</
{{out}}
<pre>
Line 3,613 ⟶ 4,178:
=={{header|PARI/GP}}==
<
apply(proper, [1..10])
r=at=0; for(n=1,20000, t=numdiv(n); if(t>r, r=t; at=n)); [at, numdiv(t)-1]</
{{out}}
<pre>%1 = [[], [2], [3], [2, 4], [5], [2, 3, 6], [7], [2, 4, 8], [3, 9], [2, 5, 10]]
Line 3,623 ⟶ 4,188:
{{works with|Free Pascal}}
Using prime factorisation
<
uses
sysutils;
Line 3,842 ⟶ 4,407:
j := CntProperDivs(primeDecomp);
PrimeFacOut(primeDecomp);writeln(' ',j:10,' factors'); writeln;
END.</
1 :
2 : 1
Line 3,863 ⟶ 4,428:
===Using a module for divisors===
{{libheader|ntheory}}
<
sub proper_divisors {
my $n = shift;
Line 3,885 ⟶ 4,450:
no warnings 'numeric';
say max(map { scalar(proper_divisors($_)) . " $_" } 1..20000);
}</
{{out}}
<pre>1:
Line 3,904 ⟶ 4,469:
=={{header|Phix}}==
The factors routine is an auto-include. The actual implementation of it, from builtins\pfactors.e is
<!--<
<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">include1</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">--
Line 3,936 ⟶ 4,501:
<span style="color: #008080;">return</span> <span style="color: #000000;">lfactors</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">hfactors</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<!--</
The compiler knows where to find that, so the main program is just:
<!--<
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">10</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)})</span>
Line 3,957 ⟶ 4,522:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d divisors: %v\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">maxd</span><span style="color: #0000FF;">,</span><span style="color: #000000;">candidates</span><span style="color: #0000FF;">})</span>
<!--</
{{out}}
<pre>
Line 3,975 ⟶ 4,540:
=={{header|PHP}}==
<
function ProperDivisors($n) {
yield 1;
Line 4,012 ⟶ 4,577:
echo "They have ", key($divisorsCount), " divisors.\n";
</syntaxhighlight>
Outputs:
Line 4,028 ⟶ 4,593:
Numbers with most divisors: 15120, 18480.
They have 79 divisors.</pre>
=={{header|Picat}}==
<syntaxhighlight lang="picat">go =>
println(11111=proper_divisors(11111)),
nl,
foreach(N in 1..10)
println(N=proper_divisors(N))
end,
nl,
find_most_divisors(20_000),
nl.
% Proper divisors of number N
proper_divisors(N) = Divisors =>
Div1 = [ I : I in 1..ceiling(sqrt(N)), N mod I == 0],
Divisors = (Div1 ++ [N div I : I in Div1]).sort_remove_dups().delete(N).
% Find the number(s) with the most proper divisors below Limit
find_most_divisors(Limit) =>
MaxN = [],
MaxNumDivisors = [],
MaxLen = 1,
foreach(N in 1..Limit, not prime(N))
D = proper_divisors(N),
Len = D.len,
% Get all numbers with most proper divisors
if Len = MaxLen then
MaxN := MaxN ++ [N],
MaxNumDivisors := MaxNumDivisors ++ [[N=D]]
elseif Len > MaxLen then
MaxLen := Len,
MaxN := [N],
MaxNumDivisors := [N=D]
end
end,
println(maxN=MaxN),
println(maxLen=MaxLen),
nl.</syntaxhighlight>
{{out}}
<pre>11111 = [1,41,271]
1 = []
2 = [1]
3 = [1]
4 = [1,2]
5 = [1]
6 = [1,2,3]
7 = [1]
8 = [1,2,4]
9 = [1,3]
10 = [1,2,5]
maxN = [15120,18480]
maxLen = 79</pre>
===Larger tests===
Some larger tests of most number of divisors:
<syntaxhighlight lang="picat">go2 =>
time(find_most_divisors(100_000)),
nl,
time(find_most_divisors(1_000_000)),
nl.</syntaxhighlight>
{{out}}
<pre>maxN = [83160,98280]
maxLen = 127
maxN = [720720,831600,942480,982800,997920]
maxLen = 239</pre>
=={{header|PicoLisp}}==
<
(de propdiv (N)
(head -1 (filter
Line 4,039 ⟶ 4,678:
(mapcar propdiv (range 1 10))
# Output:
# (NIL (1) (1) (1 2) (1) (1 2 3) (1) (1 2 4) (1 3) (1 2 5))</
===Brute-force===
<
(cdr
(rot
Line 4,061 ⟶ 4,700:
(maxi
countdiv
(range 1 20000) ) )</
===Factorization===
<
(if (assoc Key (val Var))
(con @ (inc (cdr @)))
Line 4,086 ⟶ 4,725:
factor
(range 1 20000) )
@@ ) )</
Output:
<pre>
Line 4,094 ⟶ 4,733:
=={{header|PL/I}}==
<
(subrg):
cpd: Proc Options(main);
Line 4,157 ⟶ 4,796:
End;
End;</
{{out}}
<pre>
Line 4,177 ⟶ 4,816:
=={{header|PowerShell}}==
===version 1===
<syntaxhighlight lang="powershell">
function proper-divisor ($n) {
if($n -ge 2) {
Line 4,195 ⟶ 4,834:
"$(proper-divisor 496)"
"$(proper-divisor 2048)"
</syntaxhighlight>
===version 2===
<syntaxhighlight lang="powershell">
function proper-divisor ($n) {
if($n -ge 2) {
Line 4,214 ⟶ 4,853:
"$(proper-divisor 496)"
"$(proper-divisor 2048)"
</syntaxhighlight>
===version 3===
<syntaxhighlight lang="powershell">
function eratosthenes ($n) {
if($n -gt 1){
Line 4,267 ⟶ 4,906:
"$(proper-divisor 496)"
"$(proper-divisor 2048)"
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 4,281 ⟶ 4,920:
Taking a cue from [http://stackoverflow.com/a/171779 an SO answer]:
<
UpperBound is round(sqrt(N)),
between(1, UpperBound, D),
Line 4,328 ⟶ 4,967:
proper_divisor_count(N, Count) ),
max(MaxCount, Num) ),
Result = (num(Num)-divisor_count(MaxCount)).</
Output:
<
2:[1]
3:[1]
Line 4,346 ⟶ 4,985:
?- find_most_proper_divisors_in_range(1,20000,Result).
Result = num(15120)-divisor_count(79).
</syntaxhighlight>
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
EnableExplicit
Line 4,406 ⟶ 5,045:
CloseConsole()
EndIf
</syntaxhighlight>
{{out}}
Line 4,429 ⟶ 5,068:
===Python: Literal===
A very literal interpretation
<
... return {x for x in range(1, (n + 1) // 2 + 1) if n % x == 0 and n != x}
...
Line 4,440 ⟶ 5,079:
>>> length
79
>>> </
Line 4,458 ⟶ 5,097:
This version is over an order of magnitude faster for generating the proper divisors of the first 20,000 integers; at the expense of simplicity.
<
from functools import lru_cache, reduce
from collections import Counter
Line 4,502 ⟶ 5,141:
print([proper_divs(n) for n in range(1, 11)])
print(*max(((n, len(proper_divs(n))) for n in range(1, 20001)), key=lambda pd: pd[1]))</
{{out}}
Line 4,512 ⟶ 5,151:
Defining a list of proper divisors in terms of the prime factorization:
{{Works with|Python|3.7}}
<
from itertools import accumulate, chain, groupby, product
Line 4,625 ⟶ 5,264:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>Proper divisors of [1..10]:
Line 4,644 ⟶ 5,283:
=== Python: The Simple Way ===
Not all the code submitters realized that it's a tie for the largest number of factors inside the limit. The task description clearly indicates only one answer is needed. But both numbers are provided for the curious. Also shown is the result for 25000, as there is no tie for that, just to show the program can handle either scenario.
<syntaxhighlight lang="python">def pd(num):
factors = []
for
if num % divisor == 0: factors.append(divisor)
return factors
def pdc(num):
count = 0
for divisor in range(1,1+num//2):
if num % divisor == 0: count += 1
return count
def fmtres(title, lmt, best, bestc):
return "The " + title + " number up to and including " + str(lmt) + " with the highest number of proper divisors is " + str(best) + ", which has " + str(bestc)
def showcount(limit):
best, bestc, bh, bhc = 0, 0, 0, 0
for i in range(limit+1):
divc = pdc(i)
if divc > bestc: bestc, best = divc, i
if divc >= bhc: bhc, bh = divc, i
if best == bh:
print(fmtres("only", limit, best, bestc))
else:
print(fmtres("lowest", limit, best, bestc))
print(fmtres("highest", limit, bh, bhc))
print()
for i in range(1, lmt + 1):
divs = pd(i)
if len(divs) == 0:
print("There are no proper divisors of", i)
print(divs[0], "is the only proper divisor of", i)
else:
print(divs, "are the proper divisors of", i)
print()
showcount(20000)
showcount(25000)</syntaxhighlight>
{{out}}
<pre style="white-space: pre-wrap;">There are no proper divisors of 1
1 is the only proper divisor of 2
1 is the only proper divisor of 3
[1, 2] are the proper divisors of 4
1 is the only proper divisor of 5
[1, 2, 3] are the proper divisors of 6
1 is the only proper divisor of 7
[1, 2, 4] are the proper divisors of 8
[1, 3] are the proper divisors of 9
[1, 2, 5] are the proper divisors of 10
The lowest number up to and including 20000 with the highest number of proper divisors is 15120, which has 79
The highest number up to and including 20000 with the highest number of proper divisors is 18480, which has 79
The only number up to and including 25000 with the highest number of proper divisors is 20160, which has 83</pre>
=={{header|Quackery}}==
Line 4,713 ⟶ 5,345:
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
<
10 times [ i^ 1+ properdivisors echo cr ]
Line 4,724 ⟶ 5,356:
else drop ]
swap echo say " has "
echo say " proper divisors." cr</
{{out}}
Line 4,744 ⟶ 5,376:
===Package solution===
{{Works with|R|3.3.2 and above}}
<
require(numbers);
V <- sapply(1:20000, Sigma, k = 0, proper = TRUE); ind <- which(V==max(V));
cat(" *** max number of divisors:", max(V), "\n"," *** for the following indices:",ind, "\n");</
{{Output}}
Line 4,756 ⟶ 5,388:
===Filter solution===
<
properDivisors <- function(N) Filter(function(x) N %% x == 0, seq_len(N %/% 2))
#Task 2
Vectorize(properDivisors)(1:10)
Line 4,773 ⟶ 5,399:
#Be aware that this solution uses both length and lengths. It would not work if the index of the
#desired number was not also the number itself. However, this is always the case.
mostProperDivisors <- function(N)
{
divisorList <- Vectorize(properDivisors)(
numberWithMostDivisors <- which.max(lengths(divisorList))
" proper divisors.")
}
mostProperDivisors(20000)</
{{Output}}
Line 4,787 ⟶ 5,414:
> Vectorize(properDivisors)(1:10)
[[1]]
integer(0)
[[2]]
Line 4,824 ⟶ 5,451:
=== Short version ===
<
(require math)
(define (proper-divisors n) (drop-right (divisors n) 1))
Line 4,834 ⟶ 5,461:
(if (< (length (cdr best)) (length divs)) (cons n divs) best)))
(printf "~a has ~a proper divisors\n"
(car most-under-20000) (length (cdr most-under-20000)))</
{{out}}
Line 4,853 ⟶ 5,480:
The '''main''' module will only be executed when this file is executed. When used as a library, it will not be used.
<
(provide fold-divisors ; name as per "Abundant..."
proper-divisors)
Line 4,890 ⟶ 5,517:
#:when [> c C])
(values c i)))
(printf "~a has ~a proper divisors\n" I C))</
The output is the same as the short version above.
Line 4,900 ⟶ 5,527:
There really isn't any point in using concurrency for a limit of 20_000. The setup and bookkeeping drowns out any benefit. Really doesn't start to pay off until the limit is 50_000 and higher. Try swapping in the commented out race map iterator line below for comparison.
<syntaxhighlight lang="raku"
my @l = 1 if x > 1;
(2 .. x.sqrt.floor).map: -> \d {
Line 4,918 ⟶ 5,545:
}
say "max = {@candidates - 1}, candidates = {@candidates.tail}";</
{{out}}
<pre>1 []
Line 4,934 ⟶ 5,561:
=={{header|REXX}}==
===version 1===
<
/*REXX*/
Line 4,983 ⟶ 5,610:
count_proper_divisors: Procedure
Parse Arg n
Return words(proper_divisors(n))</
{{out}}
<pre>1 ->
Line 5,009 ⟶ 5,636:
With the (function) optimization, it's over '''20''' times faster.
<
parse arg bot top inc range xtra /*obtain optional arguments from the CL*/
if bot=='' | bot=="," then bot= 1 /*Not specified? Then use the default.*/
Line 5,050 ⟶ 5,677:
/* [↓] adjust for a square. ___*/
if j*j==x then return a j b /*Was X a square? If so, add √ X */
return a b /*return the divisors (both lists). */</
{{out|output|text= when using the following input: <tt> 0 10 1 20000 166320 1441440 11796480000 </tt>}}
<pre>
Line 5,081 ⟶ 5,708:
It accomplishes a faster speed by incorporating the calculation of an ''integer square root'' of an integer (without using any floating point arithmetic).
<
parse arg bot top inc range xtra /*obtain optional arguments from the CL*/
if bot=='' | bot=="," then bot= 1 /*Not specified? Then use the default.*/
Line 5,126 ⟶ 5,753:
/* [↓] adjust for a square. ___*/
if j*j==x then return a j b /*Was X a square? If so, add √ X */
return a b /*return the divisors (both lists). */</
{{out|output|text= is identical to the 2<sup>nd</sup> REXX version when using the same inputs.}} <br><br>
Line 5,133 ⟶ 5,760:
For larger numbers, it is about '''7%''' faster.
<
parse arg bot top inc range xtra /*obtain optional arguments from the CL*/
if bot=='' | bot=="," then bot= 1 /*Not specified? Then use the default.*/
Line 5,185 ⟶ 5,812:
end /*j*/
if r*r==x then return a j b /*Was X a square? If so, add √ X */
return a b /*return proper divisors (both lists).*/</
{{out|output|text= is identical to the 2<sup>nd</sup> REXX version when using the same inputs.}} <br><br>
=={{header|Ring}}==
<
# Project : Proper divisors
Line 5,206 ⟶ 5,833:
see nl
next
</syntaxhighlight>
Output:
<pre>
Line 5,219 ⟶ 5,846:
9 -> 1 3
10 -> 1 2 5
</pre>
=={{header|RPL}}==
{{works with|HP|49}}
≪ DIVIS REVLIST TAIL REVLIST <span style="color:grey">@ or DIVIS 1 OVER SIZE 1 - SUB</span>
≫ '<span style="color:blue">PDIVIS</span>' STO
≪ 0 → max n
≪ 0
1 max '''FOR''' j
j <span style="color:blue">PDIVIS</span> SIZE
'''IF''' DUP2 < '''THEN''' SWAP j 'n' STO '''END'''
DROP
'''NEXT'''
DROP n DUP <span style="color:blue">PDIVIS</span> SIZE
≫ ≫ '<span style="color:blue">TASK2</span>' STO
≪ n <span style="color:blue">PDIVIS</span> ≫ 'n' 1 10 1 SEQ
20000 <span style="color:blue">TASK2</span>
{{out}}
<pre>
3: {{} {1} {1} {1 2} {1} {1 2 3} {1} {1 2 4} {1 3} {1 2 5}}
2: 15120
1: 39
</pre>
=={{header|Ruby}}==
<
class Integer
Line 5,239 ⟶ 5,890:
select.each do |n|
puts "#{n} has #{size} divisors"
end</
{{out}}
Line 5,258 ⟶ 5,909:
===An Alternative Approach===
<
#Nigel Galloway: December 23rd., 2014
require "prime"
Line 5,264 ⟶ 5,915:
(1..20000).each{|i| e = i.prime_division.inject(1){|n,g| n * (g[1]+1)}
n, g = e, i if e > n}
puts "#{g} has #{n-1} proper divisors"</
{{out}}
Line 5,279 ⟶ 5,930:
=={{header|Rust}}==
<
fn proper_divisors(&self) -> Option<Vec<u64>>;
}
Line 5,317 ⟶ 5,968:
most_divisors.len());
}
</syntaxhighlight>
{{out}}
<pre>Proper divisors of 1: []
Line 5,333 ⟶ 5,984:
=={{header|S-BASIC}}==
<syntaxhighlight lang="basic">
$lines
$constant false = 0
$constant true = FFFFH
Line 5,395 ⟶ 6,048:
end
</syntaxhighlight>
{{out}}
<pre>
Line 5,417 ⟶ 6,070:
===Simple proper divisors===
<
def format(i: Int, divisors: Seq[Int]) = f"$i%5d ${divisors.length}%2d ${divisors mkString " "}"
Line 5,429 ⟶ 6,082:
}
list.foreach( number => println(f"$number%5d ${properDivisors(number).length}") )</
{{out}}
<pre> n cnt PROPER DIVISORS
Line 5,449 ⟶ 6,102:
If ''Long''s are enough to you you can replace every ''BigInt'' with ''Long'' and the one ''BigInt(1)'' with ''1L''
<
def factorize(x: BigInt): List[BigInt] = {
Line 5,466 ⟶ 6,119:
val products = (1 until factors.length).flatMap(i => factors.combinations(i).map(_.product).toList).toList
(BigInt(1) :: products).filter(_ < n)
}</
=={{header|Seed7}}==
<
const proc: writeProperDivisors (in integer: n) is func
Line 5,515 ⟶ 6,168:
end for;
writeln(max_i <& " with " <& max <& " divisors");
end func;</
{{out}}
Line 5,534 ⟶ 6,187:
=={{header|Sidef}}==
{{trans|Raku}}
<
n.divisors.
}
Line 5,552 ⟶ 6,205:
}
say "max = #{max}, candidates = #{candidates}"</
{{out}}
<pre>
Line 5,570 ⟶ 6,223:
=={{header|Swift}}==
Simple function:
<
return filter (1 ..< n) { n % $0 == 0 }
}</
More efficient function:
<
func sqrt(x:Int) -> Int { return Int(sqrt(Double(x))) }
Line 5,594 ⟶ 6,247:
return sorted(result)
}</
Rest of the task:
<
println("\(i): \(properDivs(i))")
}
Line 5,608 ⟶ 6,261:
}
println("\(num): \(max)")</
{{out}}
<pre>1: []
Line 5,624 ⟶ 6,277:
=={{header|tbas}}==
<syntaxhighlight lang="vb">
dim _proper_divisors(100)
Line 5,674 ⟶ 6,327:
print "A maximum at ";
show_proper_divisors(maxindex, false)
</syntaxhighlight>
<pre>
>tbas proper_divisors.bas
Line 5,697 ⟶ 6,350:
Note that if a number, <math>k</math>, greater than 1 divides <math>n</math> exactly, both <math>k</math> and <math>n/k</math> are
proper divisors. (The raw answers are not sorted; the pretty-printer code sorts.)
<
if {$n == 1} return
set divs 1
Line 5,722 ⟶ 6,375:
}
}
puts "max: $maxI => (...$maxC…)"</
{{out}}
<pre>
Line 5,738 ⟶ 6,391:
</pre>
=={{header|uBasic/4tH}}==
{{trans|True BASIC}}
<syntaxhighlight lang="text">LET m = 1
LET c = 0
PRINT "The proper divisors of the following numbers are:\n"
PROC _ListProperDivisors (10)
FOR n = 2 TO 20000
LET d = FUNC(_CountProperDivisors(n))
IF d > c THEN
LET c = d
LET m = n
ENDIF
NEXT
PRINT
PRINT m; " has the most proper divisors, namely "; c
END
_CountProperDivisors
PARAM (1)
LOCAL (2)
IF a@ < 2 THEN RETURN (0)
LET c@ = 0
FOR b@ = 1 TO a@ / 2
IF a@ % b@ = 0 THEN LET c@ = c@ + 1
NEXT
RETURN (c@)
_ListProperDivisors
PARAM (1)
LOCAL (2)
IF a@ < 1 THEN RETURN
FOR b@ = 1 TO a@
PRINT b@; " ->";
IF b@ = 1 THEN PRINT " (None)";
FOR c@ = 1 TO b@ / 2
IF b@ % c@ = 0 THEN PRINT " "; c@;
NEXT
PRINT
NEXT
RETURN</syntaxhighlight>
{{Out}}
<pre>The proper divisors of the following numbers are:
1 -> (None)
2 -> 1
3 -> 1
4 -> 1 2
5 -> 1
6 -> 1 2 3
7 -> 1
8 -> 1 2 4
9 -> 1 3
10 -> 1 2 5
15120 has the most proper divisors, namely 79
0 OK, 0:415</pre>
=={{header|VBA}}==
<
Dim t() As Long, i As Long, l As Long, j As Long, c As Long
For i = 1 To 10
Line 5,766 ⟶ 6,481:
End If
S = t
End Function</
{{out}}
<pre>Proper divisor of 1 :
Line 5,783 ⟶ 6,498:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Function ProperDivisors(number As Integer) As IEnumerable(Of Integer)
Line 5,798 ⟶ 6,513:
End Sub
End Module</
{{out}}
<pre>1: {}
Line 5,815 ⟶ 6,530:
{{libheader|Wren-fmt}}
{{libheader|Wren-math}}
<
import "./math" for Int
for (i in 1..10) System.print("%(Fmt.d(2, i)) -> %(Int.properDivisors(i))")
Line 5,830 ⟶ 6,545:
}
}
System.print("%(number) which has %(maxDivs) proper divisors.")</
{{out}}
Line 5,847 ⟶ 6,562:
The number in the range [1, 20000] with the most proper divisors is:
15120 which has 79 proper divisors.
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">func PropDiv(N, Show); \Count and optionally show proper divisors of N
int N, Show, D, C;
[C:= 0;
if N > 1 then
[D:= 1;
repeat if rem(N/D) = 0 then
[C:= C+1;
if Show then
[if D > 1 then ChOut(0, ^ );
IntOut(0, D);
];
];
D:= D+1;
until D >= N;
];
return C;
];
int N, SN, Cnt, Max;
[for N:= 1 to 10 do
[ChOut(0, ^[); PropDiv(N, true); ChOut(0, ^]);
ChOut(0, ^ );
];
CrLf(0);
Max:= 0;
for N:= 1 to 20000 do
[Cnt:= PropDiv(N, false);
if Cnt > Max then
[Max:= Cnt; SN:= N];
];
IntOut(0, SN); ChOut(0, ^ ); IntOut(0, Max); CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
[] [1] [1] [1 2] [1] [1 2 3] [1] [1 2 4] [1 3] [1 2 5]
15120 79
</pre>
Line 5,852 ⟶ 6,608:
{{trans|D}}
This is the simple version :
<
This version is MUCH faster (the output isn't ordered however):
<
if(n==1) return(T);
( pd:=[1..(n).toFloat().sqrt()].filter('wrap(x){ n%x==0 }) )
.pump(pd,'wrap(pd){ if(pd!=1 and (y:=n/pd)!=pd ) y else Void.Skip })
}</
<
[1..20_001].apply('wrap(n){ T(properDivs(n).len(),n) })
.reduce(fcn([(a,_)]ab, [(c,_)]cd){ a>c and ab or cd },T(0,0))
.println();</
{{out}}
<pre>
|