Proper divisors: Difference between revisions

{{trans|Python}}

 

R Array(Set((1 .. (n + 1) I/ 2).filter(x -> @n % x == 0 & @n != x)))

 

 

V (n, leng) = max(((1..20000).map(n -> (n, proper_divs(n).len))), key' pd -> pd[1])

 

{{out}}

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

XDEC DS CL12

YREGS

{{out}}

<pre>

10 has 3 proper divisors: 1 2 5

15120 has 79 proper divisors.

</pre>

 

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

else Process(N, First+1));

 

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

Natural'Image(Number_Count) & " proper divisors.");

end;

 

{{out}}

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

MODE DIVISORLIST = STRUCT( INT divisor, REF DIVISORLIST next );

 

, " divisors"

, newline

{{out}}

<pre>

Proper divisors of: 10: 1 2 5

15120 is the first number upto 20000 with 79 divisors

</pre>

 

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

 

 

END

{{out}}

<pre>

===Functional===

{{Trans|JavaScript}}

 

-- properDivisors :: Int -> [Int]

end script

end if

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

----

 

===Idiomatic===

 

set output to {}

set output to output as text

set AppleScript's text item delimiters to astid

 

{{output}}

2's proper divisors: {1}

3's proper divisors: {1}

 

Largest number of proper divisors for any number from 1 to 20,000: 79

 

=={{header|Arc}}==

 

;; Given num, return num and the list of its divisors

(div-lists 20000)

;; This took about 10 minutes on my machine.

{{Out}}

(1 0)

(2 1)

It is the number 18480.

There are 2 numbers with this trait, and they are (18480 15120)

 

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program proFactor.s */

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

.include "../affichage.inc"

{{Output}}

<pre>

 

=={{header|Arturo}}==

(factors x) -- x

 

]

 

 

{{out}}

 

=={{header|AutoHotkey}}==

Array := []

if n = 1

Array[i] := true

return Array

loop, 10

{

output .= "`nNumber(s) in the range 1 to 20,000 with the most proper divisors:`n" numDiv.Pop() " with " maxDiv " divisors"

MsgBox % output

{{out}}

<pre>Number Divisors Count

 

=={{header|AWK}}==

# syntax: GAWK -f PROPER_DIVISORS.AWK

BEGIN {

return

}

<p>output:</p>

<pre>

18480 79 divisors not shown

</pre>

 

=={{header|BaCon}}==

FUNCTION ProperDivisor(nr, show)

 

 

PRINT "Most proper divisors for number in the range 1-20000: ", MagicNumber, " with ", MaxDivisors, " divisors."

{{out}}

<pre>

===Brute Force===

C has tedious boilerplate related to allocating memory for dynamic arrays, so we just skip the problem of storing values altogether.

#include <stdio.h>

#include <stdbool.h>

return 0;

}

{{out}}

<pre>

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

#include <stdio.h>

#include <stdbool.h>

return 0;

}

 

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

{

using System;

}

}

{{out}}

<pre>1: {}

 

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

#include <iostream>

#include <algorithm>

return 0 ;

}

{{out}}

<pre>

 

=={{header|Ceylon}}==

function divisors(Integer int) =>

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

 

=={{header|Clojure}}==

(:gen-class))

 

(println n " has " (count factors) " divisors"))

 

{{Output}}

<pre>

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

(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~%"

{{out}}

<pre>CL-USER(10): (main)

=={{header|Component Pascal}}==

{{Works with|Black Box Component Builder}}

MODULE RosettaProperDivisor;

IMPORT StdLog;

 

^Q RosettaProperDivisor.Do~

{{out}}

<pre>

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

 

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

=={{header|Delphi}}==

{{trans|C#}}

program ProperDivisors;

 

readln;

end.

{{out}}

<pre>

 

Version with TParallel.For

program ProperDivisors;

 

readln;

end.

 

=={{header|Dyalect}}==

{{trans|Swift}}

 

if n == 1 {

yield break

}

}

for i in 1..10 {

}

for i in 1..20000 {

if count > max {

set (num, max) = (i, count)

}

 

{{out}}

10: [1, 2, 5]

15120: 79</pre>

 

=={{header|EchoLisp}}==

(lib 'list) ;; list-delete

 

 

 

{{out}}

(for ((i (in-range 1 11))) (writeln i (divs i)))

1 null

(lib 'bigint)

(numdivs 95952222101012742144) → 666 ;; 🎩

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def divisors(1), do: []

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

IO.puts "#{n}: #{inspect Proper.divisors(n)}"

end)

 

{{out}}

=={{header|Erlang}}==

 

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

 

longest(L,Acc,A,Acc+1);

true -> longest(L,Current,CurLeng,Acc+1)

{{out}}

<pre>

 

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

// the simple function with the answer

let propDivs n = [1..n/2] |> List.filter (fun x->n % x = 0)

|> Seq.fold (fun a b ->match a,b with | (_,c1,_),(_,c2,_) when c2 > c1 -> b | _-> a) (0,0,[])

|> fun (n,count,_) -> (n,count,[]) |> show

 

{{out}}

 

=={{header|Factor}}==

math.primes.factors math.ranges prettyprint sequences ;

 

10 [1,b] [ dup pprint bl divisors but-last . ] each

20000 [1,b] [ #divisors ] supremum-by dup #divisors

 

{{out}}

15120 with 79 divisors.

</pre>

 

=={{header|Fortran}}==

Compiled using G95 compiler, run on x86 system under Puppy Linux

function icntprop(num )

print *,maxj,' has max proper divisors: ',maxcnt

end

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

' FreeBASIC v1.05.0 win64

 

Sleep

End

 

{{out}}

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

 

properDivisors[n] := allFactors[n, true, false, true]

{{out}}

<pre>

 

[15120, 18480] have 79 factors

</pre>

 

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

 

OPENW 1

CLEARW 1

RETURN count%-1

ENDFUNC

 

Output is:

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Println(n)

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List

 

putStrLn "a number with the most divisors within 1 to 20000 (number, count):"

print $ maximumBy (comparing snd)

{{out}}

<pre>divisors of 1 to 10:

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)

print $

maximumBy (comparing snd) $

{{Out}}

<pre>Proper divisors of 1 to 10:

and we can also define properDivisors in terms of primeFactors:

 

import Data.List (group, maximumBy, sort)

import Data.Ord (comparing)

w = maximum (length . xShow <$> xs)

in unlines $

{{Out}}

<pre>Proper divisors of [1..10]:

So, borrowing from [[Factors of an integer#J|the J implementation]] of that related task:

 

 

Proper divisors of numbers 1 through 10:

 

1 --

2 -- 1

8 -- 1 2 4

9 -- 1 3

 

Number(s) not exceeding 20000 with largest number of proper divisors (and the count of those divisors):

 

15120 79

 

Note that it's a bit more efficient to simply count factors here, when selecting the candidate numbers.

 

15120 79

 

We could also arbitrarily toss either 15120 or 18480 (keeping the other number), if it were important that we produce only one result.

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.LinkedList;

import java.util.List;

System.out.println(x + ": " + count);

}

{{out}}

<pre>1: []

===ES5===

 

 

// Proper divisors

);

 

 

{{out}}

===ES6===

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Proper divisors of [1..10]:

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

( [null, 0];

count( $i | proper_divisors ) as $count

'''The tasks:'''

(range(1;11) as $i | "\($i): \( [ $i | proper_divisors] )"),

"",

"the maximal number proper divisors together with the corresponding",

"count of proper divisors is:",

{{out}}

The proper divisors of the numbers 1 to 10 inclusive are:

1: []

the maximal number proper divisors together with the corresponding

count of proper divisors is:

 

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

0 < n || throw(ArgumentError("number to be factored must be ≥ 0, got $n"))

1 < n || return T[]

f = factor(n)

d = T[one(T)]

 

println(nlst, " have the maximum proper divisor count of ", maxdiv, ".")

 

{{out}}

 

=={{header|Kotlin}}==

 

fun listProperDivisors(limit: Int) {

println("The following number(s) have the most proper divisors, namely " + maxCount + "\n")

for (n in most) println(n)

 

{{out}}

15120

18480

</pre>

 

=={{header|Lua}}==

function propDivs (n)

if n < 2 then return {} end

end

end

{{out}}

<pre>1:

 

A Function that yields the proper divisors of an integer n:

 

Proper divisors of n from 1 to 10:

{{out}}

<pre>1 {}

 

The number with the most divisors between 1 and 20,000:

Last[SortBy[{#1, {#2, Length@ProperDivisors[#2]}}, Last]] &,

{0, 0},

{{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}],

{{out}}

<pre>{15120, 79}</pre>

 

=={{header|MATLAB}}==

K=1:ceil(N/2);

 

{{out}}

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Nim}}==

{{trans|C}}

 

proc properDivisors(n: int) =

maxI = i

 

{{out}}

<pre>

 

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

MODULE ProperDivisors;

IMPORT

END

END ProperDivisors.

{{out}}

<pre>

 

=={{header|Objeck}}==

 

class Proper{

}

}

 

Output:

=={{header|Oforth}}==

 

 

10 seq apply(#[ dup print " : " print properDivs println ])

{{out}}

<pre>

 

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

apply(proper, [1..10])

{{out}}

<pre>%1 = [[], [2], [3], [2, 4], [5], [2, 3, 6], [7], [2, 4, 8], [3, 9], [2, 5, 10]]

{{works with|Free Pascal}}

Using prime factorisation

uses

sysutils;

j := CntProperDivs(primeDecomp);

PrimeFacOut(primeDecomp);writeln(' ',j:10,' factors'); writeln;

1 :

2 : 1

===Using a module for divisors===

{{libheader|ntheory}}

sub proper_divisors {

my $n = shift;

no warnings 'numeric';

say max(map { scalar(proper_divisors($_)) . " $_" } 1..20000);

{{out}}

<pre>1:

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

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

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

 

=={{header|PHP}}==

function ProperDivisors($n) {

yield 1;

echo "They have ", key($divisorsCount), " divisors.\n";

 

 

Outputs:

Numbers with most divisors: 15120, 18480.

They have 79 divisors.</pre>

 

=={{header|PicoLisp}}==

(de propdiv (N)

(head -1 (filter

(mapcar propdiv (range 1 10))

# Output:

===Brute-force===

(cdr

(rot

(maxi

countdiv

===Factorization===

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

factor

(range 1 20000) )

Output:

<pre>

 

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

(subrg):

cpd: Proc Options(main);

End;

 

{{out}}

<pre>

=={{header|PowerShell}}==

===version 1===

function proper-divisor ($n) {

if($n -ge 2) {

"$(proper-divisor 496)"

"$(proper-divisor 2048)"

 

===version 2===

function proper-divisor ($n) {

if($n -ge 2) {

"$(proper-divisor 496)"

"$(proper-divisor 2048)"

 

===version 3===

function eratosthenes ($n) {

if($n -gt 1){

"$(proper-divisor 496)"

"$(proper-divisor 2048)"

<b>Output:</b>

<pre>

Taking a cue from [http://stackoverflow.com/a/171779 an SO answer]:

 

UpperBound is round(sqrt(N)),

between(1, UpperBound, D),

proper_divisor_count(N, Count) ),

max(MaxCount, Num) ),

 

Output:

 

2:[1]

3:[1]

?- find_most_proper_divisors_in_range(1,20000,Result).

Result = num(15120)-divisor_count(79).

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

===Python: Literal===

A very literal interpretation

... return {x for x in range(1, (n + 1) // 2 + 1) if n % x == 0 and n != x}

...

>>> length

79

 

 

 

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

print([proper_divs(n) for n in range(1, 11)])

 

{{out}}

Defining a list of proper divisors in terms of the prime factorization:

{{Works with|Python|3.7}}

 

from itertools import accumulate, chain, groupby, product

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Proper divisors of [1..10]:

 

=== Python: The Simple Way ===

 

 

 

 

 

 

 

=={{header|Quackery}}==

<code>factors</code> is defined at [[Factors of an integer#Quackery]].

 

 

10 times [ i^ 1+ properdivisors echo cr ]

else drop ]

swap echo say " has "

 

{{out}}

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

 

{{Output}}

 

===Filter solution===

 

#Task 2

Vectorize(properDivisors)(1:10)

 

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

{

}

 

{{Output}}

> Vectorize(properDivisors)(1:10)

[[1]]

 

[[2]]

=== Short version ===

 

(require math)

(define (proper-divisors n) (drop-right (divisors n) 1))

(if (< (length (cdr best)) (length divs)) (cons n divs) best)))

(printf "~a has ~a proper divisors\n"

 

{{out}}

 

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)

#:when [> c C])

(values c i)))

 

The output is the same as the short version above.

 

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.

my @l = 1 if x > 1;

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

}

 

{{out}}

<pre>1 []

=={{header|REXX}}==

===version 1===

Do x=1 To 10

Say x '->' proper_divisors(x)

count_proper_divisors: Procedure

Parse Arg n

{{out}}

<pre>1 ->

 

With the (function) optimization, it's over &nbsp; '''20''' &nbsp; 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.*/

say right(n, max(20, w) ) 'has' center(#, 4) "proper divisors: " q

end /*n*/

do r=1 for range; q= Pdivs(r) /*process the second range specified. */

#= words(q); if #<m then iterate /*get proper divs; get number of Pdivs.*/

say right(n, max(20, w) ) 'has' center(#, 4) "proper divisors."

end /*i*/ /* [↑] support extra specified integers*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

Pdivs: procedure; parse arg x,b; x= abs(x); if x==1 then return '' /*unity?*/

/* [↓] adjust for a square. ___*/

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

{{out|output|text=&nbsp; when using the following input: &nbsp; <tt> 0 &nbsp; 10 &nbsp; 1 &nbsp; &nbsp; &nbsp; 20000 &nbsp; &nbsp; &nbsp; 166320 &nbsp; 1441440 &nbsp; 11796480000 </tt>}}

<pre>

 

It accomplishes a faster speed by incorporating the calculation of an &nbsp; ''integer square root'' &nbsp; of an integer &nbsp; (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.*/

say right(n, max(20, w) ) 'has' center(#, 4) "proper divisors: " q

end /*n*/

do r=1 for range; q= Pdivs(r) /*process the second range specified. */

#= words(q); if #<m then iterate /*get proper divs; get number of Pdivs.*/

say right(n, max(20, w) ) 'has' center(#, 4) "proper divisors."

end /*i*/ /* [↑] support extra specified integers*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

Pdivs: procedure; parse arg x 1 z,b; x= abs(x); if x==1 then return '' /*unity?*/

/* [↓] adjust for a square. ___*/

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

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

 

 

For larger numbers, &nbsp; it is about &nbsp; '''7%''' &nbsp; 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.*/

say right(n, max(20, w) ) 'has' center(#, 4) "proper divisors: " q

end /*n*/

do r=1 for range; q= Pdivs(r) /*process the second range specified. */

#= words(q); if #<m then iterate /*get proper divs; get number of Pdivs.*/

say right(n, max(20, w) ) 'has' center(#, 4) "proper divisors."

end /*i*/ /* [↑] support extra specified integers*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

iSqrt: procedure; parse arg x; r=0; q=1; do while q<=x; q=q*4; end

end /*j*/

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

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

 

=={{header|Ring}}==

# Project : Proper divisors

 

see nl

next

Output:

<pre>

9 -> 1 3

10 -> 1 2 5

</pre>

 

=={{header|Ruby}}==

 

class Integer

select.each do |n|

puts "#{n} has #{size} divisors"

 

{{out}}

 

===An Alternative Approach===

#Nigel Galloway: December 23rd., 2014

require "prime"

(1..20000).each{|i| e = i.prime_division.inject(1){|n,g| n * (g[1]+1)}

n, g = e, i if e > n}

 

{{out}}

=={{header|Rust}}==

 

fn proper_divisors(&self) -> Option<Vec<u64>>;

}

most_divisors.len());

}

{{out}}

<pre>Proper divisors of 1: []

 

=={{header|S-BASIC}}==

$constant false = 0

$constant true = FFFFH

 

end

{{out}}

<pre>

 

===Simple proper divisors===

def format(i: Int, divisors: Seq[Int]) = f"$i%5d ${divisors.length}%2d ${divisors mkString " "}"

 

}

 

{{out}}

<pre> n cnt PROPER DIVISORS

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

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

end for;

writeln(max_i <& " with " <& max <& " divisors");

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

}

 

}

 

{{out}}

<pre>

=={{header|Swift}}==

Simple function:

 

return filter (1 ..< n) { n % $0 == 0 }

More efficient function:

 

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

return sorted(result)

Rest of the task:

println("\(i): \(properDivs(i))")

}

}

 

{{out}}

<pre>1: []

 

=={{header|tbas}}==

dim _proper_divisors(100)

 

print "A maximum at ";

show_proper_divisors(maxindex, false)

<pre>

>tbas proper_divisors.bas

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

}

}

{{out}}

<pre>

</pre>

 

=={{header|VBA}}==

Dim t() As Long, i As Long, l As Long, j As Long, c As Long

For i = 1 To 10

End If

S = t

{{out}}

<pre>Proper divisor of 1 :

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function ProperDivisors(number As Integer) As IEnumerable(Of Integer)

End Sub

 

{{out}}

<pre>1: {}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

 

for (i in 1..10) System.print("%(Fmt.d(2, i)) -> %(Int.properDivisors(i))")

}

}

 

{{out}}

The number in the range [1, 20000] with the most proper divisors is:

15120 which has 79 proper divisors.

</pre>

 

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

{{out}}

<pre>