Proper divisors: Difference between revisions
→{{header|langur}}
Langurmonkey (talk | contribs) |
|||
(22 intermediate revisions by 13 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 198:
=={{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.
<
INT i,max
BYTE count
Line 256:
OD
PrintF("%I has %I proper divisors%E",ind,max)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Proper_divisors.png Screenshot from Atari 8-bit computer]
Line 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 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 363:
Natural'Image(Number_Count) & " proper divisors.");
end;
end Proper_Divisors; </
{{out}}
Line 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 473:
, " divisors"
, newline
) )</
{{out}}
<pre>
Line 492:
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 Linux) the heap size must be increased, see [[ALGOL_68_Genie#Using_a_Large_Heap]].
<
# find the first/only number in 1 : 20 000 and 1 : 64 000 000 with #
# the most divisors #
Line 529:
max number := 64 000 000
OD
END</
{{out}}
Line 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 611:
END
</syntaxhighlight>
{{out}}
<pre>
Line 633:
===Functional===
{{Trans|JavaScript}}
<
-- properDivisors :: Int -> [Int]
Line 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 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 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 884:
(div-lists 20000)
;; This took about 10 minutes on my machine.
</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="arc">
(1 0)
(2 1)
Line 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,080:
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
{{Output}}
<pre>
Line 1,110:
=={{header|Arturo}}==
<
(factors x) -- x
Line 1,127:
]
print ["The number with the most proper divisors (" maxProperDivisors ") is" maxN]</
{{out}}
Line 1,144:
=={{header|AutoHotkey}}==
<
Array := []
if n = 1
Line 1,157:
Array[i] := true
return Array
}</
Examples:<
loop, 10
{
Line 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,193:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f PROPER_DIVISORS.AWK
BEGIN {
Line 1,230:
return
}
</syntaxhighlight>
<p>output:</p>
<pre>
Line 1,252:
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<
IF number < 2 THEN CountProperDivisors = 0
count = 0
Line 1,290:
PRINT
PRINT most; " has the most proper divisors, namely "; maxCount
END</
{{out}}
<pre>
Line 1,297:
==={{header|BASIC256}}===
<
if limit < 1 then return
for i = 1 to limit
Line 1,338:
print
print most; " has the most proper divisors, namely "; maxCount
end</
{{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}}===
<
IF number < 2 THEN LET CountProperDivisors = 0
LET count = 0
Line 1,382 ⟶ 1,456:
PRINT
PRINT most; "has the most proper divisors, namely"; maxCount
END</
{{out}}
<pre>
Line 1,389 ⟶ 1,463:
==={{header|Yabasic}}===
<
if limit < 1 then return : fi
for i = 1 to limit
Line 1,429 ⟶ 1,503:
print
print most, " has the most proper divisors, namely ", maxCount
end</
{{out}}
<pre>
Line 1,437 ⟶ 1,511:
=={{header|BaCon}}==
<
FUNCTION ProperDivisor(nr, show)
Line 1,468 ⟶ 1,542:
PRINT "Most proper divisors for number in the range 1-20000: ", MagicNumber, " with ", MaxDivisors, " divisors."
</syntaxhighlight>
{{out}}
<pre>
Line 1,487 ⟶ 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,530 ⟶ 1,604:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,547 ⟶ 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,617 ⟶ 1,691:
return 0;
}
</syntaxhighlight>
=={{header|C sharp}}==
<
{
using System;
Line 1,651 ⟶ 1,725:
}
}
}</
{{out}}
<pre>1: {}
Line 1,666 ⟶ 1,740:
=={{header|C++}}==
<
#include <iostream>
#include <algorithm>
Line 1,704 ⟶ 1,778:
return 0 ;
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,731 ⟶ 1,805:
=={{header|Ceylon}}==
<
function divisors(Integer int) =>
Line 1,752 ⟶ 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,768 ⟶ 1,842:
=={{header|Clojure}}==
<
(:gen-class))
Line 1,803 ⟶ 1,877:
(println n " has " (count factors) " divisors"))
</syntaxhighlight>
{{Output}}
<pre>
Line 1,823 ⟶ 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,858 ⟶ 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,878 ⟶ 1,952:
=={{header|Component Pascal}}==
{{Works with|Black Box Component Builder}}
<
MODULE RosettaProperDivisor;
IMPORT StdLog;
Line 1,934 ⟶ 2,008:
^Q RosettaProperDivisor.Do~
</syntaxhighlight>
{{out}}
<pre>
Line 1,955 ⟶ 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,963 ⟶ 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,971 ⟶ 2,045:
=={{header|Delphi}}==
{{trans|C#}}
<syntaxhighlight lang="delphi">
program ProperDivisors;
Line 2,038 ⟶ 2,112:
readln;
end.
</syntaxhighlight>
{{out}}
<pre>
Line 2,055 ⟶ 2,129:
Version with TParallel.For
<syntaxhighlight lang="delphi">
program ProperDivisors;
Line 2,123 ⟶ 2,197:
readln;
end.
</syntaxhighlight>
=={{header|Dyalect}}==
Line 2,129 ⟶ 2,203:
{{trans|Swift}}
<
if n == 1 {
yield break
Line 2,153 ⟶ 2,227:
}
print("\(num): \(max)")</
{{out}}
Line 2,168 ⟶ 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 2,214 ⟶ 2,321:
</syntaxhighlight>
{{out}}
<
(for ((i (in-range 1 11))) (writeln i (divs i)))
1 null
Line 2,237 ⟶ 2,344:
(lib 'bigint)
(numdivs 95952222101012742144) → 666 ;; 🎩
</syntaxhighlight>
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
class
APPLICATION
Line 2,293 ⟶ 2,400:
end
</syntaxhighlight>
{{out}}
<pre>
Line 2,311 ⟶ 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,330 ⟶ 2,437:
IO.puts "#{n}: #{inspect Proper.divisors(n)}"
end)
Proper.most_divisors(20000)</
{{out}}
Line 2,349 ⟶ 2,456:
=={{header|Erlang}}==
<
-export([divs/1,sumdivs/1,longest/1]).
Line 2,375 ⟶ 2,482:
longest(L,Acc,A,Acc+1);
true -> longest(L,Current,CurLeng,Acc+1)
end.</
{{out}}
<pre>
Line 2,396 ⟶ 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,416 ⟶ 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,434 ⟶ 2,541:
=={{header|Factor}}==
<
math.primes.factors math.ranges prettyprint sequences ;
Line 2,443 ⟶ 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,461 ⟶ 2,568:
=={{header|Fermat}}==
<
[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}
Line 2,484 ⟶ 2,591:
od;
!!('The number up to 20,000 with the most divisors was ',champ,' with ',record,' divisors.');</
{{out}}<pre>
Line 2,504 ⟶ 2,611:
{{works with|gforth|0.7.3}}
<
dup 1 ?do
dup i mod 0= if i . then
Line 2,531 ⟶ 2,638:
;
rosetta-proper-divisors</
{{out}}
Line 2,551 ⟶ 2,658:
=={{header|Fortran}}==
Compiled using G95 compiler, run on x86 system under Puppy Linux
<syntaxhighlight lang="fortran">
function icntprop(num )
Line 2,582 ⟶ 2,689:
print *,maxj,' has max proper divisors: ',maxcnt
end
</syntaxhighlight>
{{out}}
<pre>
Line 2,620 ⟶ 2,727:
=={{header|FreeBASIC}}==
<
' FreeBASIC v1.05.0 win64
Line 2,668 ⟶ 2,775:
Sleep
End
</syntaxhighlight>
{{out}}
Line 2,687 ⟶ 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,708 ⟶ 2,816:
properDivisors[n] := allFactors[n, true, false, true]
</syntaxhighlight>
{{out}}
<pre>
Line 2,723 ⟶ 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,803 ⟶ 2,964:
RETURN count%-1
ENDFUNC
</syntaxhighlight>
Output is:
Line 2,822 ⟶ 2,983:
=={{header|Go}}==
{{trans|Kotlin}}
<
import (
Line 2,883 ⟶ 3,044:
fmt.Println(n)
}
}</
{{out}}
Line 2,907 ⟶ 3,068:
=={{header|Haskell}}==
<
import Data.List
Line 2,919 ⟶ 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,937 ⟶ 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,962 ⟶ 3,123:
print $
maximumBy (comparing snd) $
(,) <*> (length . properDivisors) <$> [1 .. 20000]</
{{Out}}
<pre>Proper divisors of 1 to 10:
Line 2,983 ⟶ 3,144:
and we can also define properDivisors in terms of primeFactors:
<
import Data.List (group, maximumBy, sort)
import Data.Ord (comparing)
Line 3,015 ⟶ 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 3,041 ⟶ 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 3,056 ⟶ 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 3,074 ⟶ 3,235:
=={{header|Java}}==
{{works with|Java|1.5+}}
<
import java.util.LinkedList;
import java.util.List;
Line 3,106 ⟶ 3,267:
System.out.println(x + ": " + count);
}
}</
{{out}}
<pre>1: []
Line 3,124 ⟶ 3,285:
===ES5===
<
// Proper divisors
Line 3,192 ⟶ 3,353:
);
})();</
{{out}}
Line 3,227 ⟶ 3,388:
===ES6===
<
'use strict';
Line 3,336 ⟶ 3,497:
// MAIN ---
return main();
})();</
{{Out}}
<pre>Proper divisors of [1..10]:
Line 3,356 ⟶ 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,376 ⟶ 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,384 ⟶ 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,402 ⟶ 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,446 ⟶ 3,608:
println(nlst, " have the maximum proper divisor count of ", maxdiv, ".")
</syntaxhighlight>
{{out}}
Line 3,467 ⟶ 3,629:
=={{header|Kotlin}}==
<
fun listProperDivisors(limit: Int) {
Line 3,506 ⟶ 3,668:
println("The following number(s) have the most proper divisors, namely " + maxCount + "\n")
for (n in most) println(n)
}</
{{out}}
Line 3,527 ⟶ 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,561 ⟶ 3,770:
end
end
print(answer .. " has " .. mostDivs .. " proper divisors.")</
{{out}}
<pre>1:
Line 3,578 ⟶ 3,787:
A Function that yields the proper divisors of an integer n:
<
Proper divisors of n from 1 to 10:
<
{{out}}
<pre>1 {}
Line 3,595 ⟶ 3,804:
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,654 ⟶ 3,863:
=={{header|Modula-2}}==
<
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
Line 3,707 ⟶ 3,916:
ReadChar
END ProperDivisors.</
=={{header|Nim}}==
{{trans|C}}
<
proc properDivisors(n: int) =
Line 3,752 ⟶ 3,961:
maxI = i
echo fmt"{maxI} with {max} divisors"</
{{out}}
<pre>
Line 3,769 ⟶ 3,978:
=={{header|Oberon-2}}==
<
MODULE ProperDivisors;
IMPORT
Line 3,866 ⟶ 4,075:
END
END ProperDivisors.
</syntaxhighlight>
{{out}}
<pre>
Line 3,886 ⟶ 4,095:
=={{header|Objeck}}==
<
class Proper{
Line 3,929 ⟶ 4,138:
}
}
</syntaxhighlight>
Output:
Line 3,948 ⟶ 4,157:
=={{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,968 ⟶ 4,177:
=={{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,978 ⟶ 4,187:
{{works with|Free Pascal}}
Using prime factorisation
<
uses
sysutils;
Line 4,197 ⟶ 4,406:
j := CntProperDivs(primeDecomp);
PrimeFacOut(primeDecomp);writeln(' ',j:10,' factors'); writeln;
END.</
1 :
2 : 1
Line 4,218 ⟶ 4,427:
===Using a module for divisors===
{{libheader|ntheory}}
<
sub proper_divisors {
my $n = shift;
Line 4,240 ⟶ 4,449:
no warnings 'numeric';
say max(map { scalar(proper_divisors($_)) . " $_" } 1..20000);
}</
{{out}}
<pre>1:
Line 4,259 ⟶ 4,468:
=={{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 4,291 ⟶ 4,500:
<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 4,312 ⟶ 4,521:
<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 4,330 ⟶ 4,539:
=={{header|PHP}}==
<
function ProperDivisors($n) {
yield 1;
Line 4,367 ⟶ 4,576:
echo "They have ", key($divisorsCount), " divisors.\n";
</syntaxhighlight>
Outputs:
Line 4,385 ⟶ 4,594:
=={{header|Picat}}==
<
println(11111=proper_divisors(11111)),
nl,
Line 4,424 ⟶ 4,633:
println(maxN=MaxN),
println(maxLen=MaxLen),
nl.</
{{out}}
Line 4,443 ⟶ 4,652:
maxLen = 79</pre>
===Larger tests===
Some larger tests of most number of divisors:
<
time(find_most_divisors(100_000)),
nl,
time(find_most_divisors(1_000_000)),
nl.</
{{out}}
Line 4,459 ⟶ 4,668:
=={{header|PicoLisp}}==
<
(de propdiv (N)
(head -1 (filter
Line 4,468 ⟶ 4,677:
(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,490 ⟶ 4,699:
(maxi
countdiv
(range 1 20000) ) )</
===Factorization===
<
(if (assoc Key (val Var))
(con @ (inc (cdr @)))
Line 4,515 ⟶ 4,724:
factor
(range 1 20000) )
@@ ) )</
Output:
<pre>
Line 4,523 ⟶ 4,732:
=={{header|PL/I}}==
<
(subrg):
cpd: Proc Options(main);
Line 4,586 ⟶ 4,795:
End;
End;</
{{out}}
<pre>
Line 4,606 ⟶ 4,815:
=={{header|PowerShell}}==
===version 1===
<syntaxhighlight lang="powershell">
function proper-divisor ($n) {
if($n -ge 2) {
Line 4,624 ⟶ 4,833:
"$(proper-divisor 496)"
"$(proper-divisor 2048)"
</syntaxhighlight>
===version 2===
<syntaxhighlight lang="powershell">
function proper-divisor ($n) {
if($n -ge 2) {
Line 4,643 ⟶ 4,852:
"$(proper-divisor 496)"
"$(proper-divisor 2048)"
</syntaxhighlight>
===version 3===
<syntaxhighlight lang="powershell">
function eratosthenes ($n) {
if($n -gt 1){
Line 4,696 ⟶ 4,905:
"$(proper-divisor 496)"
"$(proper-divisor 2048)"
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 4,710 ⟶ 4,919:
Taking a cue from [http://stackoverflow.com/a/171779 an SO answer]:
<
UpperBound is round(sqrt(N)),
between(1, UpperBound, D),
Line 4,757 ⟶ 4,966:
proper_divisor_count(N, Count) ),
max(MaxCount, Num) ),
Result = (num(Num)-divisor_count(MaxCount)).</
Output:
<
2:[1]
3:[1]
Line 4,775 ⟶ 4,984:
?- find_most_proper_divisors_in_range(1,20000,Result).
Result = num(15120)-divisor_count(79).
</syntaxhighlight>
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
EnableExplicit
Line 4,835 ⟶ 5,044:
CloseConsole()
EndIf
</syntaxhighlight>
{{out}}
Line 4,858 ⟶ 5,067:
===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,869 ⟶ 5,078:
>>> length
79
>>> </
Line 4,887 ⟶ 5,096:
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,931 ⟶ 5,140:
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,941 ⟶ 5,150:
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 5,054 ⟶ 5,263:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>Proper divisors of [1..10]:
Line 5,074 ⟶ 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.
<
factors = []
for divisor in range(1,1+num//2):
Line 5,113 ⟶ 5,322:
print()
showcount(20000)
showcount(25000)</
{{out}}
<pre style="white-space: pre-wrap;">There are no proper divisors of 1
Line 5,135 ⟶ 5,344:
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
<
10 times [ i^ 1+ properdivisors echo cr ]
Line 5,146 ⟶ 5,355:
else drop ]
swap echo say " has "
echo say " proper divisors." cr</
{{out}}
Line 5,166 ⟶ 5,375:
===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 5,178 ⟶ 5,387:
===Filter solution===
<
properDivisors <- function(N) Filter(function(x) N %% x == 0, seq_len(N %/% 2))
Line 5,198 ⟶ 5,407:
" proper divisors.")
}
mostProperDivisors(20000)</
{{Output}}
Line 5,241 ⟶ 5,450:
=== Short version ===
<
(require math)
(define (proper-divisors n) (drop-right (divisors n) 1))
Line 5,251 ⟶ 5,460:
(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 5,270 ⟶ 5,479:
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 5,307 ⟶ 5,516:
#: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 5,317 ⟶ 5,526:
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 5,335 ⟶ 5,544:
}
say "max = {@candidates - 1}, candidates = {@candidates.tail}";</
{{out}}
<pre>1 []
Line 5,351 ⟶ 5,560:
=={{header|REXX}}==
===version 1===
<
/*REXX*/
Line 5,400 ⟶ 5,609:
count_proper_divisors: Procedure
Parse Arg n
Return words(proper_divisors(n))</
{{out}}
<pre>1 ->
Line 5,426 ⟶ 5,635:
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,467 ⟶ 5,676:
/* [↓] 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,498 ⟶ 5,707:
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,543 ⟶ 5,752:
/* [↓] 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,550 ⟶ 5,759:
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,602 ⟶ 5,811:
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,623 ⟶ 5,832:
see nl
next
</syntaxhighlight>
Output:
<pre>
Line 5,636 ⟶ 5,845:
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,656 ⟶ 5,889:
select.each do |n|
puts "#{n} has #{size} divisors"
end</
{{out}}
Line 5,675 ⟶ 5,908:
===An Alternative Approach===
<
#Nigel Galloway: December 23rd., 2014
require "prime"
Line 5,681 ⟶ 5,914:
(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,696 ⟶ 5,929:
=={{header|Rust}}==
<
fn proper_divisors(&self) -> Option<Vec<u64>>;
}
Line 5,734 ⟶ 5,967:
most_divisors.len());
}
</syntaxhighlight>
{{out}}
<pre>Proper divisors of 1: []
Line 5,750 ⟶ 5,983:
=={{header|S-BASIC}}==
<syntaxhighlight lang="basic">
$lines
$constant false = 0
$constant true = FFFFH
Line 5,812 ⟶ 6,047:
end
</syntaxhighlight>
{{out}}
<pre>
Line 5,834 ⟶ 6,069:
===Simple proper divisors===
<
def format(i: Int, divisors: Seq[Int]) = f"$i%5d ${divisors.length}%2d ${divisors mkString " "}"
Line 5,846 ⟶ 6,081:
}
list.foreach( number => println(f"$number%5d ${properDivisors(number).length}") )</
{{out}}
<pre> n cnt PROPER DIVISORS
Line 5,866 ⟶ 6,101:
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,883 ⟶ 6,118:
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,932 ⟶ 6,167:
end for;
writeln(max_i <& " with " <& max <& " divisors");
end func;</
{{out}}
Line 5,951 ⟶ 6,186:
=={{header|Sidef}}==
{{trans|Raku}}
<
n.divisors.
}
Line 5,969 ⟶ 6,204:
}
say "max = #{max}, candidates = #{candidates}"</
{{out}}
<pre>
Line 5,987 ⟶ 6,222:
=={{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 6,011 ⟶ 6,246:
return sorted(result)
}</
Rest of the task:
<
println("\(i): \(properDivs(i))")
}
Line 6,025 ⟶ 6,260:
}
println("\(num): \(max)")</
{{out}}
<pre>1: []
Line 6,041 ⟶ 6,276:
=={{header|tbas}}==
<syntaxhighlight lang="vb">
dim _proper_divisors(100)
Line 6,091 ⟶ 6,326:
print "A maximum at ";
show_proper_divisors(maxindex, false)
</syntaxhighlight>
<pre>
>tbas proper_divisors.bas
Line 6,114 ⟶ 6,349:
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 6,139 ⟶ 6,374:
}
}
puts "max: $maxI => (...$maxC…)"</
{{out}}
<pre>
Line 6,155 ⟶ 6,390:
</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 6,183 ⟶ 6,480:
End If
S = t
End Function</
{{out}}
<pre>Proper divisor of 1 :
Line 6,200 ⟶ 6,497:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Function ProperDivisors(number As Integer) As IEnumerable(Of Integer)
Line 6,215 ⟶ 6,512:
End Sub
End Module</
{{out}}
<pre>1: {}
Line 6,232 ⟶ 6,529:
{{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 6,247 ⟶ 6,544:
}
}
System.print("%(number) which has %(maxDivs) proper divisors.")</
{{out}}
Line 6,267 ⟶ 6,564:
=={{header|XPL0}}==
<
int N, Show, D, C;
[C:= 0;
Line 6,299 ⟶ 6,596:
];
IntOut(0, SN); ChOut(0, ^ ); IntOut(0, Max); CrLf(0);
]</
{{out}}
Line 6,310 ⟶ 6,607:
{{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>
|