Data commit

Task/Proper-divisors/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Proper_divisors
+note: Prime Numbers

Task/Proper-divisors/00-TASK.txt

@@ -0,0 +1,27 @@
+The   [http://planetmath.org/properdivisor proper divisors]   of a positive integer '''N''' are those numbers, other than '''N''' itself, that divide '''N''' without remainder. 
+
+For '''N''' > 1 they will always include 1,   but for '''N''' == 1 there are no proper divisors.
+
+
+;Examples:
+The proper divisors of     6     are   1, 2, and 3. 
+<br>The proper divisors of &nbsp; 100 &nbsp; are &nbsp; 1, 2, 4, 5, 10, 20, 25, and 50.
+
+
+;Task:
+# Create a routine to generate all the proper divisors of a number.
+# use it to show the proper divisors of the numbers 1 to 10 inclusive.
+# Find a number in the range 1 to 20,000 with the most proper divisors. Show the number and just the count of how many proper divisors it has.
+
+<br>
+Show all output here.
+
+
+;Related tasks:
+* &nbsp; [[Amicable pairs]]
+* &nbsp; [[Abundant, deficient and perfect number classifications]]
+* &nbsp; [[Aliquot sequence classifications]]
+* &nbsp; [[Factors of an integer]]
+* &nbsp; [[Prime decomposition]]
+<br><br>
+

Task/Proper-divisors/11l/proper-divisors.11l

@@ -0,0 +1,7 @@
+F proper_divs(n)
+   R Array(Set((1 .. (n + 1) I/ 2).filter(x -> @n % x == 0 & @n != x)))
+
+print((1..10).map(n -> proper_divs(n)))
+
+V (n, leng) = max(((1..20000).map(n -> (n, proper_divs(n).len))), key' pd -> pd[1])
+print(n‘ ’leng)

Task/Proper-divisors/360-Assembly/proper-divisors.360

@@ -0,0 +1,134 @@
+*        Proper divisors           14/06/2016
+PROPDIV  CSECT
+         USING  PROPDIV,R13        base register
+         B      72(R15)            skip savearea
+         DC     17F'0'             savearea
+         STM    R14,R12,12(R13)    prolog
+         ST     R13,4(R15)         "
+         ST     R15,8(R13)         "
+         LR     R13,R15            "
+         LA     R10,1              n=1
+LOOPN1   C      R10,=F'10'         do n=1 to 10
+         BH     ELOOPN1
+         LR     R1,R10             n
+         BAL    R14,PDIV           pdiv(n)
+         ST     R0,NN              nn=pdiv(n)
+         MVC    PG,PGT             init buffer
+         LA     R11,PG             pgi=0
+         XDECO  R10,XDEC           edit n
+         MVC    0(3,R11),XDEC+9    output n
+         LA     R11,7(R11)         pgi=pgi+7
+         L      R1,NN              nn
+         XDECO  R1,XDEC            edit nn
+         MVC    0(3,R11),XDEC+9    output nn
+         LA     R11,20(R11)        pgi=pgi+20
+         LA     R5,1               i=1
+LOOPNI   C      R5,NN              do i=1 to nn
+         BH     ELOOPNI
+         LR     R1,R5              i
+         SLA    R1,2               *4
+         L      R2,TDIV-4(R1)      tdiv(i)
+         XDECO  R2,XDEC            edit tdiv(i)
+         MVC    0(3,R11),XDEC+9    output tdiv(i)
+         LA     R11,3(R11)         pgi=pgi+3
+         LA     R5,1(R5)           i=i+1
+         B      LOOPNI
+ELOOPNI  XPRNT  PG,80              print buffer
+         LA     R10,1(R10)         n=n+1
+         B      LOOPN1
+ELOOPN1  SR     R0,R0              0
+         ST     R0,M               m=0
+         LA     R10,1              n=1
+LOOPN2   C      R10,=F'20000'      do n=1 to 20000
+         BH     ELOOPN2
+         LR     R1,R10             n
+         BAL    R14,PDIV           nn=pdiv(n)
+         C      R0,M               if nn>m
+         BNH    NNNHM
+         ST     R10,II             ii=n
+         ST     R0,M               m=nn
+NNNHM    LA     R10,1(R10)         n=n+1
+         B      LOOPN2
+ELOOPN2  MVC    PG,PGR             init buffer
+         L      R1,II              ii
+         XDECO  R1,XDEC            edit ii
+         MVC    PG(5),XDEC+7       output ii
+         L      R1,M               m
+         XDECO  R1,XDEC            edit m
+         MVC    PG+9(4),XDEC+8     output m
+         XPRNT  PG,80              print buffer
+         L      R13,4(0,R13)       epilog
+         LM     R14,R12,12(R13)    "
+         XR     R15,R15            "
+         BR     R14                exit
+*------- pdiv   --function(x)----->number of divisors---
+PDIV     ST     R1,X               x
+         C      R1,=F'1'           if x=1
+         BNE    NOTONE
+         LA     R0,0               return(0)
+         BR     R14
+NOTONE   LR     R4,R1              x
+         N      R4,=X'00000001'    mod(x,2)
+         LA     R4,1(R4)           +1
+         ST     R4,ODD             odd=mod(x,2)+1
+         LA     R8,1               ia=1
+         LA     R0,1               1
+         ST     R0,TDIV            tdiv(1)=1
+         SR     R9,R9              ib=0
+         L      R7,ODD             odd
+         LA     R7,1(R7)           j=odd+1
+LOOPJ    LR     R5,R7              do j=odd+1 by odd
+         MR     R4,R7              j*j
+         C      R5,X               while j*j<x
+         BNL    ELOOPJ
+         L      R4,X               x
+         SRDA   R4,32              .
+         DR     R4,R7              /j
+         LTR    R4,R4              if mod(x,j)=0
+         BNZ    ITERJ
+         LA     R8,1(R8)           ia=ia+1
+         LR     R1,R8              ia
+         SLA    R1,2               *4 (F)
+         ST     R7,TDIV-4(R1)      tdiv(ia)=j
+         LA     R9,1(R9)           ib=ib+1
+         L      R4,X               x
+         SRDA   R4,32              .
+         DR     R4,R7              j
+         LR     R2,R9              ib
+         SLA    R2,2               *4 (F)
+         ST     R5,TDIVB-4(R2)     tdivb(ib)=x/j
+ITERJ    A      R7,ODD             j=j+odd
+         B      LOOPJ
+ELOOPJ   LR     R5,R7              j
+         MR     R4,R7              j*j
+         C      R5,X               if j*j=x
+         BNE    JTJNEX
+         LA     R8,1(R8)           ia=ia+1
+         LR     R1,R8              ia
+         SLA    R1,2               *4 (F)
+         ST     R7,TDIV-4(R1)      tdiv(ia)=j
+JTJNEX   LA     R1,TDIV(R1)        @tdiv(ia+1)
+         LA     R2,TDIVB-4(R2)     @tdivb(ib)
+         LTR    R6,R9              do i=ib to 1 by -1
+         BZ     ELOOPI
+LOOPI    MVC    0(4,R1),0(R2)      tdiv(ia)=tdivb(i)
+         LA     R8,1(R8)           ia=ia+1
+         LA     R1,4(R1)           r1+=4
+         SH     R2,=H'4'           r2-=4
+         BCT    R6,LOOPI           i=i-1
+ELOOPI   LR     R0,R8              return(ia)
+         BR     R14                return to caller
+*        ----   ----------------------------------------
+TDIV     DS     80F
+TDIVB    DS     40F
+M        DS     F
+NN       DS     F
+II       DS     F
+X        DS     F
+ODD      DS     F
+PGT      DC     CL80'... has .. proper divisors:'
+PGR      DC     CL80'..... has ... proper divisors.'
+PG       DC     CL80' '
+XDEC     DS     CL12
+         YREGS
+         END    PROPDIV

Task/Proper-divisors/ALGOL-68/proper-divisors-1.alg

@@ -0,0 +1,92 @@
+# MODE to hold an element of a list of proper divisors            #
+MODE DIVISORLIST = STRUCT( INT divisor, REF DIVISORLIST next );
+
+# end of divisor list value                                       #
+REF DIVISORLIST nil divisor list = REF DIVISORLIST(NIL);
+
+# resturns a DIVISORLIST containing the proper divisors of n      #
+# if n = 1, 0 or -1, we return no divisors                        #
+PROC proper divisors = ( INT n )REF DIVISORLIST:
+     BEGIN
+         REF DIVISORLIST result   := nil divisor list;
+         REF DIVISORLIST end list := result;
+         INT abs n  = ABS n;
+         IF abs n > 1 THEN
+             # build the list of divisors backeards, so they are  #
+             # returned in ascending order                        #
+             INT root n = ENTIER sqrt( abs n );
+             FOR d FROM root n BY -1 TO 2 DO
+                 IF abs n MOD d = 0 THEN
+                     # found another divisor                      #
+                     result := HEAP DIVISORLIST
+                            := DIVISORLIST( d, result );
+                     IF end list IS nil divisor list THEN
+                         # first result                           #
+                         end list := result
+                     FI;
+                     IF d * d /= n THEN
+                         # add the other divisor to the end of    #
+                         # the list                               #
+                         next OF end list := HEAP DIVISORLIST
+                                          := DIVISORLIST( abs n OVER d, nil divisor list );
+                         end list         := next OF end list
+                     FI
+                 FI
+             OD;
+             # 1 is always a proper divisor of numbers > 1        #
+             result := HEAP DIVISORLIST
+                    := DIVISORLIST( 1, result )
+         FI;
+         result
+     END # proper divisors # ;
+
+# returns the number of divisors in a DIVISORLIST                 #
+PROC count divisors = ( REF DIVISORLIST list )INT:
+     BEGIN
+        INT result := 0;
+        REF DIVISORLIST divisors := list;
+        WHILE divisors ISNT nil divisor list DO
+            result +:= 1;
+            divisors := next OF divisors
+        OD;
+        result
+     END # count divisors # ;
+
+# find the proper divisors of 1 : 10                              #
+FOR n TO 10 DO
+    REF DIVISORLIST divisors := proper divisors( n );
+    print( ( "Proper divisors of: ", whole( n, -2 ), ": " ) );
+    WHILE divisors ISNT nil divisor list DO
+        print( ( " ", whole( divisor OF divisors, 0 ) ) );
+        divisors := next OF divisors
+    OD;
+    print( ( newline ) )
+OD;
+
+# find the first/only number in 1 : 20 000 with the most divisors  #
+INT max number         = 20 000;
+INT max divisors      :=      0;
+INT has max divisors  :=      0;
+INT with max divisors :=      0;
+FOR d TO max number DO
+    INT divisor count = count divisors( proper divisors( d ) );
+    IF divisor count > max divisors THEN
+        # found a number with more divisors than the previous max  #
+        max divisors       := divisor count;
+        has max divisors   := d;
+        with max divisors  := 1
+    ELIF divisor count = max divisors THEN
+        # found another number with that many divisors             #
+        with max divisors +:= 1
+    FI
+OD;
+print( ( whole( has max divisors, 0 )
+       , " is the "
+       , IF with max divisors < 2 THEN "only" ELSE "first" FI
+       , " number upto "
+       , whole( max number, 0 )
+       , " with "
+       , whole( max divisors, 0 )
+       , " divisors"
+       , newline
+       ) )

Task/Proper-divisors/ALGOL-68/proper-divisors-2.alg

@@ -0,0 +1,38 @@
+BEGIN # count proper divisors using a sieve-like approach              #
+    # find the first/only number in 1 : 20 000 and 1 : 64 000 000 with #
+    # the most divisors                                                #
+    INT max number            := 20 000;
+    TO 2 DO
+        INT max divisors      := 0;
+        INT has max divisors  := 0;
+        INT with max divisors := 0;
+        [ 1 : max number ]INT pdc; pdc[ 1 ] := 0; FOR i FROM 2 TO UPB pdc DO pdc[ i ] := 1 OD;
+        FOR i FROM 2 TO UPB pdc DO
+            FOR j FROM i + i BY i TO UPB pdc DO pdc[ j ] +:= 1 OD
+        OD;
+        FOR d TO max number DO
+            INT divisor count = pdc[ d ];
+            IF divisor count > max divisors THEN
+                # found a number with more divisors than the previous max  #
+                max divisors       := divisor count;
+                has max divisors   := d;
+                with max divisors  := 1
+            ELIF divisor count = max divisors THEN
+                # found another number with that many divisors             #
+                with max divisors +:= 1
+            FI
+        OD;
+        print( ( whole( has max divisors, 0 )
+               , " is the "
+               , IF with max divisors < 2 THEN "only" ELSE "first" FI
+               , " number upto "
+               , whole( max number, 0 )
+               , " with "
+               , whole( max divisors, 0 )
+               , " divisors"
+               , newline
+               )
+             );
+        max number := 64 000 000
+    OD
+END

Task/Proper-divisors/ALGOL-M/proper-divisors.alg

@@ -0,0 +1,71 @@
+BEGIN
+
+% COMPUTE P MOD Q %
+INTEGER FUNCTION MOD (P, Q);
+INTEGER P, Q;
+BEGIN
+    MOD := P - Q * (P / Q);
+END;
+
+% COUNT, AND OPTIONALLY DISPLAY, PROPER DIVISORS OF N %
+INTEGER FUNCTION DIVISORS(N, DISPLAY);
+INTEGER N, DISPLAY;
+BEGIN
+    INTEGER I, LIMIT, COUNT, START, DELTA;
+    IF MOD(N, 2) = 0 THEN
+      BEGIN
+        START := 2;
+        DELTA := 1;
+      END
+    ELSE  % ONLY NEED TO CHECK ODD DIVISORS %
+      BEGIN
+        START := 3;
+        DELTA := 2;
+      END;
+    % 1 IS A DIVISOR OF ANY NUMBER > 1 %
+    IF N > 1 THEN COUNT := 1 ELSE COUNT := 0;
+    IF (DISPLAY <> 0) AND (COUNT <> 0) THEN WRITEON(1);
+    % CHECK REMAINING POTENTIAL DIVISORS %
+    I := START;
+    LIMIT := N / START;
+    WHILE I <= LIMIT DO
+      BEGIN
+        IF MOD(N, I) = 0 THEN
+          BEGIN
+            IF DISPLAY <> 0 THEN WRITEON(I);
+            COUNT := COUNT + 1;
+          END;
+        I := I + DELTA;
+        IF COUNT = 1 THEN LIMIT := N / I;
+      END;
+   DIVISORS := COUNT;
+END;
+
+COMMENT MAIN PROGRAM BEGINS HERE;
+INTEGER I, NDIV, TRUE, FALSE, HIGHDIV, HIGHNUM;
+TRUE := -1;
+FALSE := 0;
+
+WRITE("PROPER DIVISORS OF FIRST TEN NUMBERS:");
+FOR I := 1 STEP 1 UNTIL 10 DO
+  BEGIN
+     WRITE(I, " : ");
+     NDIV := DIVISORS(I, TRUE);
+  END;
+
+WRITE("SEARCHING FOR NUMBER UP TO 10000 WITH MOST DIVISORS ...");
+HIGHDIV := 1;
+HIGHNUM := 1;
+FOR I := 1 STEP 1 UNTIL 10000 DO
+  BEGIN
+     NDIV := DIVISORS(I, FALSE);
+     IF NDIV > HIGHDIV THEN
+       BEGIN
+         HIGHDIV := NDIV;
+         HIGHNUM := I;
+       END;
+  END;
+WRITE("THE NUMBER IS:", HIGHNUM);
+WRITE("IT HAS", HIGHDIV, " DIVISORS");
+
+END

Task/Proper-divisors/ARM-Assembly/proper-divisors.arm

@@ -0,0 +1,168 @@
+/* ARM assembly Raspberry PI  */
+/*  program proFactor.s   */
+
+/* REMARK 1 : this program use routines in a include file
+   see task Include a file language arm assembly
+   for the routine affichageMess conversion10
+   see at end of this program the instruction include */
+/*******************************************/
+/* Constantes                              */
+/*******************************************/
+.equ STDOUT, 1                           @ Linux output console
+.equ EXIT,   1                           @ Linux syscall
+.equ WRITE,  4                           @ Linux syscall
+
+/*******************************************/
+/* Initialized data                        */
+/*******************************************/
+.data
+szMessStartPgm:          .asciz "Program start \n"
+szMessEndPgm:            .asciz "Program normal end.\n"
+szMessError:             .asciz "\033[31mError Allocation !!!\n"
+szCarriageReturn:        .asciz "\n"
+
+/* datas message display */
+szMessEntete:            .ascii "Number :"
+sNumber:                 .space 12,' '
+                         .asciz " Divisors :"
+szMessResult:            .ascii " "
+sValue:                  .space 12,' '
+                         .asciz ""
+szMessDivNumber:         .ascii "\nnumber divisors :"
+sCounter:                .space 12,' '
+                         .asciz "\n"
+szMessNumberMax:         .ascii "Number :"
+sNumberMax:              .space 12,' '
+                         .ascii " has "
+sDivMax:                 .space 12, ' '
+                         .asciz " divisors\n"
+/*******************************************/
+/* UnInitialized data                      */
+/*******************************************/
+.bss
+/*******************************************/
+/*  code section                           */
+/*******************************************/
+.text
+.global main
+main:                               @ program start
+    ldr r0,iAdrszMessStartPgm       @ display start message
+    bl affichageMess
+    mov r2,#1
+1:
+    mov r0,r2                       @  number
+    ldr r1,iAdrsNumber              @ and convert ascii string
+    bl conversion10
+    ldr r0,iAdrszMessEntete         @ display result message
+    bl affichageMess
+    mov r0,r2                       @  number
+    mov r1,#1                       @ display flag
+    bl divisors                     @ display divisors
+    ldr r1,iAdrsCounter              @ and convert ascii string
+    bl conversion10
+    ldr r0,iAdrszMessDivNumber      @ display result message
+    bl affichageMess
+    add r2,r2,#1
+    cmp r2,#10
+    ble 1b
+
+    mov r2,#2
+    mov r3,#0
+    mov r4,#0
+    ldr r5,iMaxi
+2:
+    mov r0,r2
+    mov r1,#0                       @ display flag
+    bl divisors                     @ display divisors
+    cmp r0,r3
+    movgt r3,r0
+    movgt r4,r2
+    add r2,r2,#1
+    cmp r2,r5
+    ble 2b
+    mov r0,r4
+    ldr r1,iAdrsNumberMax           @ and convert ascii string
+    bl conversion10
+    mov r0,r3
+    ldr r1,iAdrsDivMax              @ and convert ascii string
+    bl conversion10
+    ldr r0,iAdrszMessNumberMax
+    bl affichageMess
+
+
+    ldr r0,iAdrszMessEndPgm         @ display end message
+    bl affichageMess
+    b 100f
+99:                                 @ display error message
+    ldr r0,iAdrszMessError
+    bl affichageMess
+100:                                @ standard end of the program
+    mov r0, #0                      @ return code
+    mov r7, #EXIT                   @ request to exit program
+    svc 0                           @ perform system call
+iAdrszMessStartPgm:        .int szMessStartPgm
+iAdrszMessEndPgm:          .int szMessEndPgm
+iAdrszMessError:           .int szMessError
+iAdrszCarriageReturn:      .int szCarriageReturn
+iAdrszMessResult:          .int szMessResult
+iAdrsValue:                .int sValue
+iAdrszMessDivNumber:       .int szMessDivNumber
+iAdrsCounter:              .int sCounter
+iAdrszMessEntete:          .int szMessEntete
+iAdrsNumber:               .int sNumber
+iAdrszMessNumberMax:       .int szMessNumberMax
+iAdrsDivMax:               .int sDivMax
+iAdrsNumberMax:            .int sNumberMax
+iMaxi:                     .int 20000
+/******************************************************************/
+/*     divisors function                         */
+/******************************************************************/
+/* r0 contains the number  */
+/* r1 contains display flag (<>0: display, 0: no display )
+/* r0 return divisors number */
+divisors:
+    push {r1-r8,lr}             @ save  registers
+    cmp r0,#1                   @ = 1 ?
+    movle r0,#0
+    ble 100f
+    mov r7,r0
+    mov r8,r1
+    cmp r8,#0
+    beq 1f
+    mov r0,#1                   @ first divisor = 1
+    ldr r1,iAdrsValue           @ and convert ascii string
+    bl conversion10
+    ldr r0,iAdrszMessResult     @ display result message
+    bl affichageMess
+1:                              @ begin loop
+    lsr r4,r7,#1                @ Maxi
+    mov r6,r4                   @ first divisor
+    mov r5,#1                   @ Counter divisors
+2:
+    mov r0,r7                   @ dividende = number
+    mov r1,r6                   @ divisor
+    bl division
+    cmp r3,#0                   @ remainder = 0 ?
+    bne 3f
+    add r5,r5,#1                @ increment counter
+    cmp r8,#0                   @ display divisor ?
+    beq 3f
+    mov r0,r2                   @ divisor
+    ldr r1,iAdrsValue           @ and convert ascii string
+    bl conversion10
+    ldr r0,iAdrszMessResult     @ display result message
+    bl affichageMess
+3:
+    sub r6,r6,#1                @ decrement divisor
+    cmp r6,#2                   @ End ?
+    bge 2b                      @ no loop
+    mov r0,r5                   @ return divisors number
+
+100:
+    pop {r1-r8,lr}              @ restaur registers
+    bx lr                       @ return
+
+/***************************************************/
+/*      ROUTINES INCLUDE                 */
+/***************************************************/
+.include "../affichage.inc"

Task/Proper-divisors/AWK/proper-divisors.awk

@@ -0,0 +1,36 @@
+# syntax: GAWK -f PROPER_DIVISORS.AWK
+BEGIN {
+    show = 0 # show divisors: 0=no, 1=yes
+    print("    N  cnt  DIVISORS")
+    for (i=1; i<=20000; i++) {
+      divisors(i)
+      if (i <= 10 || i == 100) { # including 100 as it was an example in task description
+        printf("%5d  %3d  %s\n",i,Dcnt,Dstr)
+      }
+      if (Dcnt < max_cnt) {
+        continue
+      }
+      if (Dcnt > max_cnt) {
+        rec = ""
+        max_cnt = Dcnt
+      }
+      rec = sprintf("%s%5d  %3d  %s\n",rec,i,Dcnt,show?Dstr:"divisors not shown")
+    }
+    printf("%s",rec)
+    exit(0)
+}
+function divisors(n,  i) {
+    if (n == 1) {
+      Dcnt = 0
+      Dstr = ""
+      return
+    }
+    Dcnt = Dstr = 1
+    for (i=2; i<n; i++) {
+      if (n % i == 0) {
+        Dcnt++
+        Dstr = sprintf("%s %s",Dstr,i)
+      }
+    }
+    return
+}

Task/Proper-divisors/Action-/proper-divisors.action

@@ -0,0 +1,59 @@
+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

Task/Proper-divisors/Ada/proper-divisors-1.ada

@@ -0,0 +1,19 @@
+generic
+   type Result_Type (<>) is limited private;
+   None: Result_Type;
+   with function One(X: Positive) return Result_Type;
+   with function Add(X, Y: Result_Type) return Result_Type
+      is <>;
+package Generic_Divisors is
+
+  function Process
+    (N: Positive; First: Positive := 1) return Result_Type is
+      (if First**2 > N or First = N then None
+      elsif (N mod First)=0 then
+	(if First = 1 or First*First = N
+	   then Add(One(First), Process(N, First+1))
+	   else Add(One(First),
+		    Add(One((N/First)), Process(N, First+1))))
+      else Process(N, First+1));
+
+end Generic_Divisors;

Task/Proper-divisors/Ada/proper-divisors-2.ada

@@ -0,0 +1,59 @@
+with Ada.Text_IO, Ada.Containers.Generic_Array_Sort, Generic_Divisors;
+
+procedure Proper_Divisors is
+
+begin
+   -- show the proper divisors of the numbers 1 to 10 inclusive.
+   declare
+      type Pos_Arr is array(Positive range <>) of Positive;
+      subtype Single_Pos_Arr is Pos_Arr(1 .. 1);
+      Empty: Pos_Arr(1 .. 0);
+
+      function Arr(P: Positive) return Single_Pos_Arr is ((others => P));
+
+      package Divisor_List is new Generic_Divisors
+	(Result_Type => Pos_Arr, None => Empty, One => Arr, Add =>  "&");
+
+      procedure Sort is new Ada.Containers.Generic_Array_Sort
+	(Positive, Positive, Pos_Arr);
+   begin
+      for I in 1 .. 10 loop
+	 declare
+	    List: Pos_Arr := Divisor_List.Process(I);
+	 begin
+	    Ada.Text_IO.Put
+	      (Positive'Image(I) & " has" &
+		 Natural'Image(List'Length) & " proper divisors:");
+	    Sort(List);
+	    for Item of List loop
+	       Ada.Text_IO.Put(Positive'Image(Item));
+	    end loop;
+	    Ada.Text_IO.New_Line;
+	 end;
+      end loop;
+   end;
+
+   -- find a number 1 .. 20,000 with the most proper divisors
+   declare
+      Number: Positive := 1;
+      Number_Count: Natural := 0;
+      Current_Count: Natural;
+
+      function Cnt(P: Positive) return Positive is (1);
+
+      package Divisor_Count is new Generic_Divisors
+	(Result_Type => Natural, None => 0, One => Cnt, Add =>  "+");
+
+   begin
+      for Current in 1 .. 20_000 loop
+	 Current_Count := Divisor_Count.Process(Current);
+	 if Current_Count > Number_Count then
+	    Number := Current;
+	    Number_Count := Current_Count;
+	 end if;
+      end loop;
+      Ada.Text_IO.Put_Line
+	(Positive'Image(Number) & " has the maximum number of" &
+	   Natural'Image(Number_Count) & " proper divisors.");
+   end;
+end Proper_Divisors;

Task/Proper-divisors/AppleScript/proper-divisors-1.applescript

@@ -0,0 +1,130 @@
+-- PROPER DIVISORS -----------------------------------------------------------
+
+-- properDivisors :: Int -> [Int]
+on properDivisors(n)
+    if n = 1 then
+        {1}
+    else
+        set realRoot to n ^ (1 / 2)
+        set intRoot to realRoot as integer
+        set blnPerfectSquare to intRoot = realRoot
+
+        -- isFactor :: Int -> Bool
+        script isFactor
+            on |λ|(x)
+                n mod x = 0
+            end |λ|
+        end script
+
+        -- Factors up to square root of n,
+        set lows to filter(isFactor, enumFromTo(1, intRoot))
+
+        -- and quotients of these factors beyond the square root,
+
+        -- integerQuotient :: Int -> Int
+        script integerQuotient
+            on |λ|(x)
+                (n / x) as integer
+            end |λ|
+        end script
+
+        -- excluding n itself (last item)
+        items 1 thru -2 of (lows & map(integerQuotient, ¬
+            items (1 + (blnPerfectSquare as integer)) thru -1 of reverse of lows))
+    end if
+end properDivisors
+
+
+-- TEST ----------------------------------------------------------------------
+on run
+    -- numberAndDivisors :: Int -> [Int]
+    script numberAndDivisors
+        on |λ|(n)
+            {num:n, divisors:properDivisors(n)}
+        end |λ|
+    end script
+
+    -- maxDivisorCount :: Record -> Int -> Record
+    script maxDivisorCount
+        on |λ|(a, n)
+            set intDivisors to length of properDivisors(n)
+
+            if intDivisors ≥ divisors of a then
+                {num:n, divisors:intDivisors}
+            else
+                a
+            end if
+        end |λ|
+    end script
+
+    {oneToTen:map(numberAndDivisors, ¬
+        enumFromTo(1, 10)), mostDivisors:foldl(maxDivisorCount, ¬
+        {num:0, divisors:0}, enumFromTo(1, 20000))} ¬
+
+end run
+
+
+-- GENERIC FUNCTIONS ---------------------------------------------------------
+
+-- enumFromTo :: Int -> Int -> [Int]
+on enumFromTo(m, n)
+    if m > n then
+        set d to -1
+    else
+        set d to 1
+    end if
+    set lst to {}
+    repeat with i from m to n by d
+        set end of lst to i
+    end repeat
+    return lst
+end enumFromTo
+
+-- filter :: (a -> Bool) -> [a] -> [a]
+on filter(f, xs)
+    tell mReturn(f)
+        set lst to {}
+        set lng to length of xs
+        repeat with i from 1 to lng
+            set v to item i of xs
+            if |λ|(v, i, xs) then set end of lst to v
+        end repeat
+        return lst
+    end tell
+end filter
+
+-- foldl :: (a -> b -> a) -> a -> [b] -> a
+on foldl(f, startValue, xs)
+    tell mReturn(f)
+        set v to startValue
+        set lng to length of xs
+        repeat with i from 1 to lng
+            set v to |λ|(v, item i of xs, i, xs)
+        end repeat
+        return v
+    end tell
+end foldl
+
+-- map :: (a -> b) -> [a] -> [b]
+on map(f, xs)
+    tell mReturn(f)
+        set lng to length of xs
+        set lst to {}
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, i, xs)
+        end repeat
+        return lst
+    end tell
+end map
+
+-- Lift 2nd class handler function into 1st class script wrapper
+-- mReturn :: Handler -> Script
+on mReturn(f)
+    if class of f is script then
+        f
+    else
+        script
+            property |λ| : f
+        end script
+    end if
+end mReturn

Task/Proper-divisors/AppleScript/proper-divisors-2.applescript

@@ -0,0 +1,5 @@
+{oneToTen:{{num:1, divisors:{1}}, {num:2, divisors:{1}}, {num:3, divisors:{1}},
+{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}}

Task/Proper-divisors/AppleScript/proper-divisors-3.applescript

@@ -0,0 +1,47 @@
+on properDivisors(n)
+    set output to {}
+
+    if (n > 1) then
+        set sqrt to n ^ 0.5
+        set limit to sqrt div 1
+        if (limit = sqrt) then
+            set end of output to limit
+            set limit to limit - 1
+        end if
+        repeat with i from limit to 2 by -1
+            if (n mod i is 0) then
+                set beginning of output to i
+                set end of output to n div i
+            end if
+        end repeat
+        set beginning of output to 1
+    end if
+
+    return output
+end properDivisors
+
+-- Task code.
+local output, astid, i, maxPDs, maxPDNums, pdCount
+set output to {}
+set astid to AppleScript's text item delimiters
+set AppleScript's text item delimiters to ", "
+repeat with i from 1 to 10
+    set end of output to (i as text) & "'s proper divisors:  {" & properDivisors(i) & "}"
+end repeat
+set maxPDs to 0
+set maxPDNums to {}
+repeat with i from 1 to 20000
+    set pdCount to (count properDivisors(i))
+    if (pdCount > maxPDs) then
+        set maxPDs to pdCount
+        set maxPDNums to {i}
+    else if (pdCount = maxPDs) then
+        set end of maxPDNums to i
+    end if
+end repeat
+set end of output to linefeed & "Largest number of proper divisors for any number from 1 to 20,000:  " & maxPDs
+set end of output to "Numbers with this many:  " & maxPDNums
+set AppleScript's text item delimiters to linefeed
+set output to output as text
+set AppleScript's text item delimiters to astid
+return output

Task/Proper-divisors/AppleScript/proper-divisors-4.applescript

@@ -0,0 +1,13 @@
+"1's proper divisors:  {}
+2's proper divisors:  {1}
+3's proper divisors:  {1}
+4's proper divisors:  {1, 2}
+5's proper divisors:  {1}
+6's proper divisors:  {1, 2, 3}
+7's proper divisors:  {1}
+8's proper divisors:  {1, 2, 4}
+9's proper divisors:  {1, 3}
+10's proper divisors:  {1, 2, 5}
+
+Largest number of proper divisors for any number from 1 to 20,000:  79
+Numbers with this many:  15120, 18480"

Task/Proper-divisors/Arc/proper-divisors-1.arc

@@ -0,0 +1,45 @@
+;; Given num, return num and the list of its divisors
+(= divisor (fn (num)
+   (= dlist '())
+   (when (is 1 num) (= dlist '(1 0)))
+   (when (is 2 num) (= dlist '(2 1)))
+   (unless (or (is 1 num) (is 2 num))
+   (up i 1 (+ 1 (/ num 2))
+     (if (is 0 (mod num i))
+         (push i dlist)))
+   (= dlist (cons num dlist)))
+   dlist))
+
+;; Find out what number has the most divisors between 2 and 20,000.
+;; Print a list of the largest known number's divisors as it is found.
+(= div-lists (fn (cnt (o show 0))
+  (= tlist '()) (= clist tlist)
+  (when (> show 0) (prn tlist))
+  (up i 1 cnt
+    (divisor i)
+    (when (is 1 show) (prn dlist))
+    (when (>= (len dlist) (len tlist))
+        (= tlist dlist)
+        (when (is show 2) (prn tlist))
+        (let c (- (len dlist) 1)
+        (push (list i c) clist))))
+
+  (= many-divisors (list ((clist 0) 1)))
+  (for n 0 (is ((clist n) 1) ((clist 0) 1)) (= n (+ 1 n))
+    (push ((clist n) 0) many-divisors))
+  (= many-divisors (rev many-divisors))
+  (prn "The number with the most divisors under " cnt
+       " has " (many-divisors 0) " divisors.")
+  (prn "It is the number "
+  (if (> 2 (len many-divisors)) (cut (many-divisors) 1)
+      (many-divisors 1)) ".")
+  (prn "There are " (- (len many-divisors) 1) " numbers"
+       " with this trait, and they are "
+       (map [many-divisors _] (range 1 (- (len many-divisors) 1))))
+  (prn (map [divisor _] (cut many-divisors 1)))
+  many-divisors))
+
+;; Do the tasks
+(div-lists 10 1)
+(div-lists 20000)
+;; This took about 10 minutes on my machine.

Task/Proper-divisors/Arc/proper-divisors-2.arc

@@ -0,0 +1,20 @@
+(1 0)
+(2 1)
+(3 1)
+(4 2 1)
+(5 1)
+(6 3 2 1)
+(7 1)
+(8 4 2 1)
+(9 3 1)
+(10 5 2 1)
+The number with the most divisors under 10 has 3 divisors.
+It is the number 10.
+There are 3 numbers with this trait, and they are (10 8 6)
+((10 5 2 1) (8 4 2 1) (6 3 2 1))
+'(3 10 8 6)
+
+
+The number with the most divisors under 20000 has 79 divisors.
+It is the number 18480.
+There are 2 numbers with this trait, and they are (18480 15120)

Task/Proper-divisors/Arturo/proper-divisors.arturo

@@ -0,0 +1,18 @@
+properDivisors: function [x] ->
+    (factors x) -- x
+
+loop 1..10 'x ->
+    print ["proper divisors of" x "=>" properDivisors x]
+
+maxN: 0
+maxProperDivisors: 0
+
+loop 1..20000 'x [
+    pd: size properDivisors x
+    if maxProperDivisors < pd [
+        maxN: x
+        maxProperDivisors: pd
+    ]
+]
+
+print ["The number with the most proper divisors (" maxProperDivisors ") is" maxN]

Task/Proper-divisors/AutoHotkey/proper-divisors-1.ahk

@@ -0,0 +1,14 @@
+proper_divisors(n) {
+	Array := []
+	if n = 1
+		return Array
+	Array[1] := true
+	x := Floor(Sqrt(n))
+	loop, % x+1
+		if !Mod(n, i:=A_Index+1) && (floor(n/i) < n)
+			Array[floor(n/i)] := true
+	Loop % n/x
+		if !Mod(n, i:=A_Index+1) && (i < n)
+			Array[i] := true
+	return Array
+}

Task/Proper-divisors/AutoHotkey/proper-divisors-2.ahk

@@ -0,0 +1,18 @@
+output := "Number`tDivisors`tCount`n"
+loop, 10
+{
+	output .= A_Index "`t"
+	for n, bool in x := proper_divisors(A_Index)
+		output .= n " "
+	output .= "`t" x.count() "`n"
+}
+maxDiv := 0, numDiv := []
+loop, 20000
+{
+	Arr := proper_divisors(A_Index)
+	numDiv[Arr.count()] := (numDiv[Arr.count()] ? numDiv[Arr.count()] ", " : "") A_Index
+	maxDiv := maxDiv > Arr.count() ? maxDiv : Arr.count()
+}
+output .= "`nNumber(s) in the range 1 to 20,000 with the most proper divisors:`n" numDiv.Pop() " with " maxDiv " divisors"
+MsgBox % output
+return

Task/Proper-divisors/BASIC/proper-divisors.basic

@@ -0,0 +1,39 @@
+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

Task/Proper-divisors/BASIC256/proper-divisors.basic

@@ -0,0 +1,42 @@
+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

Task/Proper-divisors/BaCon/proper-divisors.bacon

@@ -0,0 +1,30 @@
+FUNCTION ProperDivisor(nr, show)
+
+    LOCAL probe, total
+
+    FOR probe = 1 TO nr-1
+        IF MOD(nr, probe) = 0 THEN
+            IF show THEN PRINT " ", probe;
+            INCR total
+        END IF
+    NEXT
+
+    RETURN total
+
+END FUNCTION
+
+FOR x = 1 TO 10
+    PRINT x, ":";
+    IF ProperDivisor(x, 1) = 0 THEN PRINT " 0";
+    PRINT
+NEXT
+
+FOR x = 1 TO 20000
+    DivisorCount = ProperDivisor(x, 0)
+    IF DivisorCount > MaxDivisors THEN
+        MaxDivisors = DivisorCount
+        MagicNumber = x
+    END IF
+NEXT
+
+PRINT "Most proper divisors for number in the range 1-20000: ", MagicNumber, " with ", MaxDivisors, " divisors."

Task/Proper-divisors/C++/proper-divisors.cpp

@@ -0,0 +1,38 @@
+#include <vector>
+#include <iostream>
+#include <algorithm>
+
+std::vector<int> properDivisors ( int number ) {
+   std::vector<int> divisors ;
+   for ( int i = 1 ; i < number / 2 + 1 ; i++ )
+      if ( number % i == 0 )
+	 divisors.push_back( i ) ;
+   return divisors ;
+}
+
+int main( ) {
+   std::vector<int> divisors ;
+   unsigned int maxdivisors = 0 ;
+   int corresponding_number = 0 ;
+   for ( int i = 1 ; i < 11 ; i++ ) {
+      divisors =  properDivisors ( i ) ;
+      std::cout << "Proper divisors of " << i << ":\n" ;
+      for ( int number : divisors ) {
+	 std::cout << number << " " ;
+      }
+      std::cout << std::endl ;
+      divisors.clear( ) ;
+   }
+   for ( int i = 11 ; i < 20001 ; i++ ) {
+      divisors =  properDivisors ( i ) ;
+      if ( divisors.size( ) > maxdivisors ) {
+	 maxdivisors = divisors.size( ) ;
+	 corresponding_number = i ;
+      }
+      divisors.clear( ) ;
+   }
+
+   std::cout << "Most divisors has " << corresponding_number <<
+      " , it has " << maxdivisors << " divisors!\n" ;
+   return 0 ;
+}

Task/Proper-divisors/C-sharp/proper-divisors.cs

@@ -0,0 +1,32 @@
+namespace RosettaCode.ProperDivisors
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    internal static class Program
+    {
+        private static IEnumerable<int> ProperDivisors(int number)
+        {
+            return
+                Enumerable.Range(1, number / 2)
+                    .Where(divisor => number % divisor == 0);
+        }
+
+        private static void Main()
+        {
+            foreach (var number in Enumerable.Range(1, 10))
+            {
+                Console.WriteLine("{0}: {{{1}}}", number,
+                    string.Join(", ", ProperDivisors(number)));
+            }
+
+            var record = Enumerable.Range(1, 20000).Select(number => new
+            {
+                Number = number,
+                Count = ProperDivisors(number).Count()
+            }).OrderByDescending(currentRecord => currentRecord.Count).First();
+            Console.WriteLine("{0}: {1}", record.Number, record.Count);
+        }
+    }
+}

Task/Proper-divisors/C/proper-divisors-1.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+int proper_divisors(const int n, bool print_flag)
+{
+    int count = 0;
+
+    for (int i = 1; i < n; ++i) {
+        if (n % i == 0) {
+            count++;
+            if (print_flag)
+                printf("%d ", i);
+        }
+    }
+
+    if (print_flag)
+        printf("\n");
+
+    return count;
+}
+
+int main(void)
+{
+    for (int i = 1; i <= 10; ++i) {
+        printf("%d: ", i);
+        proper_divisors(i, true);
+    }
+
+    int max = 0;
+    int max_i = 1;
+
+    for (int i = 1; i <= 20000; ++i) {
+        int v = proper_divisors(i, false);
+        if (v >= max) {
+            max = v;
+            max_i = i;
+        }
+    }
+
+    printf("%d with %d divisors\n", max_i, max);
+    return 0;
+}

Task/Proper-divisors/C/proper-divisors-2.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+int proper_divisors(const int n, bool print_flag)
+{
+    int count = 0;
+
+    for (int i = 1; i < n; ++i) {
+        if (n % i == 0) {
+            count++;
+            if (print_flag)
+                printf("%d ", i);
+        }
+    }
+
+    if (print_flag)
+        printf("\n");
+
+    return count;
+}
+
+int countProperDivisors(int n){
+	int prod = 1,i,count=0;
+	
+	while(n%2==0){
+		count++;
+		n /= 2;
+	}
+	
+	prod *= (1+count);
+
+	for(i=3;i*i<=n;i+=2){
+		count = 0;
+		
+		while(n%i==0){
+			count++;
+			n /= i;
+		}
+		
+		prod *= (1+count);
+	}
+	
+	if(n>2)
+		prod *= 2;
+	
+	return prod - 1;
+}
+
+int main(void)
+{
+    for (int i = 1; i <= 10; ++i) {
+        printf("%d: ", i);
+        proper_divisors(i, true);
+    }
+
+    int max = 0;
+    int max_i = 1;
+
+    for (int i = 1; i <= 20000; ++i) {
+        int v = countProperDivisors(i);
+        if (v >= max) {
+            max = v;
+            max_i = i;
+        }
+    }
+
+    printf("%d with %d divisors\n", max_i, max);
+    return 0;
+}

Task/Proper-divisors/Ceylon/proper-divisors.ceylon

@@ -0,0 +1,22 @@
+shared void run() {
+	
+	function divisors(Integer int) =>
+			if(int <= 1)
+			then {}
+			else (1..int / 2).filter((Integer element) => element.divides(int));
+	
+	for(i in 1..10) {
+		print("``i`` => ``divisors(i)``");
+	}
+	
+	value start = 1;
+	value end = 20k;
+	
+	value mostDivisors =
+			map {for(i in start..end) i->divisors(i).size}
+			.inverse()
+			.max(byKey(byIncreasing(Integer.magnitude)));
+	
+	print("the number(s) with the most divisors between ``start`` and ``end`` is/are:
+	       ``mostDivisors?.item else "nothing"`` with ``mostDivisors?.key else "no"`` divisors");
+}

Task/Proper-divisors/Clojure/proper-divisors.clj

@@ -0,0 +1,34 @@
+(ns properdivisors
+  (:gen-class))
+
+(defn proper-divisors [n]
+  " Proper divisors of n"
+  (if (= n 1)
+    []
+  (filter #(= 0 (rem n %)) (range 1 n))))
+
+;; Property divisors of numbers 1 to 20,000 inclusive
+(def data (for [n (range 1 (inc 20000))]
+            [n (proper-divisors n)]))
+
+;; Find Max
+(defn maximal-key [k x & xs]
+  " Normal max-key only finds one key that produces maximum, while this function finds them all "
+  (reduce (fn [ys x]
+            (let [c (compare (k x) (k (peek ys)))]
+              (cond
+                (pos? c) [x]
+                (neg? c) ys
+                :else    (conj ys x))))
+          [x]
+          xs))
+
+(println "n\tcnt\tPROPER DIVISORS")
+(doseq [n (range 1 11)]
+  (let [factors (proper-divisors n)]
+    (println n "\t" (count factors) "\t" factors)))
+
+(def max-data (apply maximal-key (fn [[i pd]] (count pd)) data))
+
+(doseq [[n factors] max-data]
+  (println n " has " (count factors) " divisors"))

Task/Proper-divisors/Common-Lisp/proper-divisors.lisp

@@ -0,0 +1,36 @@
+(defun proper-divisors-recursive (product &optional (results '(1)))
+   "(int,list)->list::Function to find all proper divisors of a +ve integer."
+
+   (defun smallest-divisor (x)
+      "int->int::Find the smallest divisor of an integer > 1."
+      (if (evenp x) 2
+          (do ((lim (truncate (sqrt x)))
+               (sd 3 (+ sd 2)))
+              ((or (integerp (/ x sd)) (> sd lim)) (if (> sd lim) x sd)))))
+
+   (defun pd-rec (fac)
+      "(int,int)->nil::Recursive function to find proper divisors of a +ve integer"
+      (when (not (member fac results))
+         (push fac results)
+         (let ((hifac (/ fac (smallest-divisor fac))))
+            (pd-rec hifac)
+            (pd-rec (/ product hifac)))))
+
+   (pd-rec product)
+   (butlast (sort (copy-list results) #'<)))
+
+(defun task (method &optional (n 1) (most-pds '(0)))
+   (dotimes (i 19999)
+      (let ((npds (length (funcall method (incf n))))
+            (hiest (car most-pds)))
+         (when (>= npds hiest)
+            (if (> npds hiest)
+                (setf most-pds (list npds (list n)))
+                (setf most-pds (list npds (cons n (second most-pds))))))))
+   most-pds)
+
+(defun main ()
+   (format t "Task 1:Proper Divisors of [1,10]:~%")
+   (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)))

Task/Proper-divisors/Component-Pascal/proper-divisors.pas

@@ -0,0 +1,55 @@
+MODULE RosettaProperDivisor;
+IMPORT StdLog;
+
+PROCEDURE Pd*(n: LONGINT;OUT r: ARRAY OF LONGINT):LONGINT;
+VAR
+	i,j: LONGINT;
+BEGIN
+	i := 1;j := 0;
+	IF n >  1 THEN
+		WHILE (i < n) DO
+			IF (n MOD i) = 0 THEN
+				IF (j < LEN(r)) THEN r[j] := i END; INC(j)
+			END;
+			INC(i)
+		END;
+	END;
+	RETURN j
+END Pd;
+
+PROCEDURE Do*;
+VAR
+	r: ARRAY 128 OF LONGINT;
+	i,j,found,max,idxMx: LONGINT;
+	mx: ARRAY 128 OF LONGINT;
+BEGIN
+	FOR i := 1 TO 10 DO
+		found := Pd(i,r);
+		IF found > LEN(r) THEN (* Error. more pd than r can admit *) HALT(1) END;
+		StdLog.Int(i);StdLog.String("[");StdLog.Int(found);StdLog.String("]:> ");
+		FOR j := 0 TO found - 1 DO
+			StdLog.Int(r[j]);StdLog.Char(' ');
+		END;
+		StdLog.Ln
+	END;
+	
+	max := 0;idxMx := 0;
+  FOR i := 1 TO 20000 DO
+  	found := Pd(i,r);
+  	IF found > max THEN
+    	idxMx:= 0;mx[idxMx] := i;max := found
+	  ELSIF found = max THEN
+    	INC(idxMx);mx[idxMx] := i
+  	END;
+  END;
+	StdLog.String("Found: ");StdLog.Int(idxMx + 1);
+  StdLog.String(" Numbers with the longest proper divisors [");
+	StdLog.Int(max);StdLog.String("]: ");StdLog.Ln;
+	FOR i := 0 TO idxMx DO
+  	StdLog.Int(mx[i]);StdLog.Ln
+	END
+END Do;
+
+END RosettaProperDivisor.
+
+^Q RosettaProperDivisor.Do~

Task/Proper-divisors/Craft-Basic/proper-divisors.basic

@@ -0,0 +1,59 @@
+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

Task/Proper-divisors/D/proper-divisors.d

@@ -0,0 +1,9 @@
+void main() /*@safe*/ {
+    import std.stdio, std.algorithm, std.range, std.typecons;
+
+    immutable properDivs = (in uint n) pure nothrow @safe /*@nogc*/ =>
+        iota(1, (n + 1) / 2 + 1).filter!(x => n % x == 0 && n != x);
+
+    iota(1, 11).map!properDivs.writeln;
+    iota(1, 20_001).map!(n => tuple(properDivs(n).count, n)).reduce!max.writeln;
+}

Task/Proper-divisors/Delphi/proper-divisors-1.delphi

@@ -0,0 +1,66 @@
+program ProperDivisors;
+
+{$APPTYPE CONSOLE}
+
+{$R *.res}
+
+uses
+  System.SysUtils,
+  System.Generics.Collections;
+
+type
+  TProperDivisors = TArray<Integer>;
+
+function GetProperDivisors(const value: Integer): TProperDivisors;
+var
+  i, count: Integer;
+begin
+  count := 0;
+
+  for i := 1 to value div 2 do
+  begin
+    if value mod i = 0 then
+    begin
+      inc(count);
+      SetLength(result, count);
+      Result[count - 1] := i;
+    end;
+  end;
+end;
+
+procedure Println(values: TProperDivisors);
+var
+  i: Integer;
+begin
+  Write('[');
+  if Length(values) > 0 then
+    for i := 0 to High(values) do
+      Write(Format('%2d', [values[i]]));
+  Writeln(']');
+end;
+
+var
+  number, max_count, count, max_number: Integer;
+
+begin
+  for number := 1 to 10 do
+  begin
+    write(number, ': ');
+    Println(GetProperDivisors(number));
+  end;
+
+  max_count := 0;
+  for number := 1 to 20000 do
+  begin
+    count := length(GetProperDivisors(number));
+    if count > max_count then
+    begin
+      max_count := count;
+      max_number := number;
+    end;
+  end;
+
+  Write(max_number, ': ', max_count);
+
+  readln;
+end.

Task/Proper-divisors/Delphi/proper-divisors-2.delphi

@@ -0,0 +1,67 @@
+program ProperDivisors;
+
+{$APPTYPE CONSOLE}
+
+{$R *.res}
+
+uses
+  System.SysUtils,
+  System.Threading,
+  System.SyncObjs;
+
+type
+  TProperDivisors = array of Integer;
+
+function GetProperDivisors(const value: Integer): TProperDivisors;
+var
+  i, count: Integer;
+begin
+  count := 0;
+
+  for i := 1 to value div 2 do
+  begin
+    if value mod i = 0 then
+    begin
+      inc(count);
+      SetLength(result, count);
+      Result[count - 1] := i;
+    end;
+  end;
+end;
+
+procedure Println(values: TProperDivisors);
+var
+  i: Integer;
+begin
+  Write('[');
+  if Length(values) > 0 then
+    for i := 0 to High(values) do
+      Write(Format('%2d', [values[i]]));
+  Writeln(']');
+end;
+
+var
+  number, max_count, count, max_number: Integer;
+
+begin
+  for number := 1 to 10 do
+  begin
+    write(number, ': ');
+    Println(GetProperDivisors(number));
+  end;
+
+  max_count := 0;
+  TParallel.for (1, 20000,
+    procedure(I: Int64)
+    begin
+      count := length(GetProperDivisors(I));
+      if count > max_count then
+      begin
+        TInterlocked.Exchange(max_count, count);
+        TInterlocked.Exchange(max_number, I);
+      end;
+    end);
+
+  Writeln(max_number, ': ', max_count);
+  readln;
+end.

Task/Proper-divisors/Dyalect/proper-divisors.dyalect

@@ -0,0 +1,25 @@
+func properDivs(n) {
+    if n == 1 {
+        yield break
+    }
+    for x in 1..<n {
+        if n % x == 0 {
+            yield x
+        }
+    }
+}
+
+for i in 1..10 {
+    print("\(i): \(properDivs(i).ToArray())")
+}
+
+var (num, max) = (0,0)
+
+for i in 1..20000 {
+    let count = properDivs(i).Length()
+    if count > max {
+        set (num, max) = (i, count)
+    }
+}
+
+print("\(num): \(max)")

Task/Proper-divisors/EchoLisp/proper-divisors-1.l

@@ -0,0 +1,41 @@
+(lib 'list) ;; list-delete
+
+;; let n = product p_i^a_i , p_i prime
+;; number of divisors = product (a_i + 1) - 1
+(define (numdivs n)
+    (1- (apply * (map (lambda(g) (1+ (length g))) (group (prime-factors n))))))
+
+(remember 'numdivs)
+	
+;; prime powers
+;; input : a list g of grouped prime factors ( 3 3 3 ..)
+;; returns (1 3 9 27 ...)
+(define (ppows g (mult 1))
+	(for/fold (ppows '(1)) ((a g))
+	(set! mult (* mult a))
+	(cons mult ppows)))
+
+;; proper divisors
+;; decomp n into ((2 2 ..) ( 3 3 ..)  ) prime factors groups
+;; combines (1 2 4 8 ..) (1 3 9 ..) lists
+;; remove n from the list
+
+(define (divs n)
+   (if (<= n 1) null
+    (list-delete
+        (for/fold (divs'(1)) ((g (map  ppows (group (prime-factors n)))))
+		    (for*/list ((a divs) (b g)) (* a b)))
+    n )))
+
+;; find number(s) with max # of proper divisors
+;; returns list of (n . maxdivs)  for n in range 2..N
+
+(define (most-proper N)
+    (define maxdivs 1)
+    (define ndivs 0)
+    (for/fold (most-proper null) ((n (in-range 2 N)))
+       (set! ndivs (numdivs n))
+        #:continue (< ndivs maxdivs)
+        (when (> ndivs maxdivs)
+        (set!-values (most-proper maxdivs) (values null ndivs)))
+        (cons (cons n maxdivs) most-proper)))

Task/Proper-divisors/EchoLisp/proper-divisors-2.l

@@ -0,0 +1,20 @@
+(for ((i (in-range 1 11))) (writeln i (divs i)))
+1     null
+2     (1)
+3     (1)
+4     (2 1)
+5     (1)
+6     (2 3 1)
+7     (1)
+8     (4 2 1)
+9     (3 1)
+10     (2 5 1)
+
+
+(most-proper 20000)
+    → ((18480 . 79) (15120 . 79))
+(most-proper 1_000_000)
+    → ((997920 . 239) (982800 . 239) (942480 . 239) (831600 . 239) (720720 . 239))
+
+(lib 'bigint)
+(numdivs 95952222101012742144)  → 666 ;; 🎩

Task/Proper-divisors/Eiffel/proper-divisors.e

@@ -0,0 +1,52 @@
+class
+	APPLICATION
+
+create
+	make
+
+feature
+
+	make
+			-- Test the feature proper_divisors.
+		local
+			list: LINKED_LIST [INTEGER]
+			count, number: INTEGER
+		do
+			across
+				1 |..| 10 as c
+			loop
+				list := proper_divisors (c.item)
+				io.put_string (c.item.out + ": ")
+				across
+					list as l
+				loop
+					io.put_string (l.item.out + " ")
+				end
+				io.new_line
+			end
+			across
+				1 |..| 20000 as c
+			loop
+				list := proper_divisors (c.item)
+				if list.count > count then
+					count := list.count
+					number := c.item
+				end
+			end
+			io.put_string (number.out + " has with " + count.out + " divisors the highest number of proper divisors.")
+		end
+
+	proper_divisors (n: INTEGER): LINKED_LIST [INTEGER]
+			-- Proper divisors of 'n'.
+		do
+			create Result.make
+			across
+				1 |..| (n - 1) as c
+			loop
+				if n \\ c.item = 0 then
+					Result.extend (c.item)
+				end
+			end
+		end
+
+end

Task/Proper-divisors/Elixir/proper-divisors.elixir

@@ -0,0 +1,20 @@
+defmodule Proper do
+  def divisors(1), do: []
+  def divisors(n), do: [1 | divisors(2,n,:math.sqrt(n))] |> Enum.sort
+
+  defp divisors(k,_n,q) when k>q, do: []
+  defp divisors(k,n,q) when rem(n,k)>0, do: divisors(k+1,n,q)
+  defp divisors(k,n,q) when k * k == n, do: [k | divisors(k+1,n,q)]
+  defp divisors(k,n,q)                , do: [k,div(n,k) | divisors(k+1,n,q)]
+
+  def most_divisors(limit) do
+    {length,nums} = Enum.group_by(1..limit, fn n -> length(divisors(n)) end)
+                    |> Enum.max_by(fn {length,_nums} -> length end)
+    IO.puts "With #{length}, Number #{inspect nums} has the most divisors"
+  end
+end
+
+Enum.each(1..10, fn n ->
+  IO.puts "#{n}: #{inspect Proper.divisors(n)}"
+end)
+Proper.most_divisors(20000)

Task/Proper-divisors/Erlang/proper-divisors.erl

@@ -0,0 +1,27 @@
+-module(properdivs).
+-export([divs/1,sumdivs/1,longest/1]).
+
+divs(0) -> [];
+divs(1) -> [];
+divs(N) -> lists:sort([1] ++ divisors(2,N,math:sqrt(N))).
+
+divisors(K,_N,Q) when K > Q -> [];
+divisors(K,N,Q) when N rem K =/= 0 ->
+    divisors(K+1,N,Q);
+divisors(K,N,Q) when K * K  == N ->
+    [K] ++ divisors(K+1,N,Q);
+divisors(K,N,Q) ->
+    [K, N div K] ++ divisors(K+1,N,Q).
+
+sumdivs(N) -> lists:sum(divs(N)).
+
+longest(Limit) -> longest(Limit,0,0,1).
+
+longest(L,Current,CurLeng,Acc) when Acc >= L ->
+    io:format("With ~w, Number ~w has the most divisors~n", [CurLeng,Current]);
+longest(L,Current,CurLeng,Acc) ->
+    A = length(divs(Acc)),
+    if A > CurLeng ->
+        longest(L,Acc,A,Acc+1);
+        true -> longest(L,Current,CurLeng,Acc+1)
+    end.

Task/Proper-divisors/F-Sharp/proper-divisors.fs

@@ -0,0 +1,19 @@
+// the simple function with the answer
+let propDivs n = [1..n/2] |> List.filter (fun x->n % x = 0)
+
+// to cache the result length; helpful for a long search
+let propDivDat n = propDivs n |> fun xs -> n, xs.Length, xs
+
+// UI: always the longest and messiest
+let show (n,count,divs) =
+  let showCount = count |> function | 0-> "no proper divisors" | 1->"1 proper divisor" | _-> sprintf "%d proper divisors" count
+  let showDiv = divs |> function | []->"" | x::[]->sprintf ": %d" x | _->divs |> Seq.map string |> String.concat "," |> sprintf ": %s"
+  printfn "%d has %s%s" n showCount showDiv
+
+// generate output
+[1..10] |> List.iter (propDivDat >> show)
+
+// use a sequence: we don't really need to hold this data, just iterate over it
+Seq.init 20000 ( ((+) 1) >> propDivDat)
+|> Seq.fold (fun a b ->match a,b with | (_,c1,_),(_,c2,_) when c2 > c1 -> b | _-> a) (0,0,[])
+|> fun (n,count,_) -> (n,count,[]) |> show

Task/Proper-divisors/Factor/proper-divisors.factor

@@ -0,0 +1,10 @@
+USING: formatting io kernel math math.functions
+math.primes.factors math.ranges prettyprint sequences ;
+
+: #divisors ( m -- n )
+    dup sqrt >integer 1 + [1,b] [ divisor? ] with count dup +
+    1 - ;
+
+10 [1,b] [ dup pprint bl divisors but-last . ] each
+20000 [1,b] [ #divisors ] supremum-by dup #divisors
+"%d with %d divisors.\n" printf

Task/Proper-divisors/Fermat/proper-divisors.fermat

@@ -0,0 +1,24 @@
+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.');

Task/Proper-divisors/Forth/proper-divisors.fth

@@ -0,0 +1,28 @@
+: .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

Task/Proper-divisors/Fortran/proper-divisors.f

@@ -0,0 +1,29 @@
+      function icntprop(num  )
+      icnt=0
+      do i=1 , num-1
+          if (mod(num , i)  .eq. 0)  then
+          icnt = icnt + 1
+          if (num .lt. 11) print *,'    ',i
+          end if
+          end do
+      icntprop =  icnt
+      end function
+
+      limit = 20000
+      maxcnt = 0
+      print *,'N   divisors'
+      do j=1,limit,1
+      if (j .lt. 11) print *,j
+      icnt = icntprop(j)
+
+      if (icnt .gt. maxcnt) then
+      maxcnt = icnt
+      maxj = j
+      end if
+
+      end do
+
+      print *,' '
+      print *,' from 1 to ',limit
+      print *,maxj,' has max proper divisors: ',maxcnt
+      end

Task/Proper-divisors/Free-Pascal/proper-divisors.pas

@@ -0,0 +1,58 @@
+Program ProperDivisors;
+
+Uses fgl;
+
+Type
+  TIntegerList = Specialize TfpgList<longint>;
+
+Var list : TintegerList;
+
+Function GetProperDivisors(x : longint): longint;
+{this function will return the number of proper divisors
+ and put them in the list}
+
+Var i : longint;
+Begin
+  list.clear;
+  If x = 1 Then {by default 1 has no proper divisors}
+    GetProperDivisors := 0
+  Else
+    Begin
+      list.add(1); //add 1 as a proper divisor;
+      i := 2;
+      While i * i < x Do
+        Begin
+          If (x Mod i) = 0 Then //found a proper divisor
+            Begin
+              list.add(i); // add divisor
+              list.add(x Div i); // add result
+            End;
+          inc(i);
+        End;
+      If i*i=x Then list.add(i); //make sure to capture the sqrt only once
+      GetProperDivisors := list.count;
+    End;
+End;
+
+Var i,j,count,most : longint;
+Begin
+
+  list := TIntegerList.Create;
+  For i := 1 To 10 Do
+    Begin
+      write(i:4,' has ', GetProperDivisors(i),' proper divisors:');
+      For j := 0 To pred(list.count) Do
+        write(list[j]:3);
+      writeln();
+    End;
+  count := 0; //store highest number of proper divisors
+  most := 0;  //store number with highest number of proper divisors
+  For i := 1 To 20000 Do
+    If GetProperDivisors(i) > count Then
+      Begin
+        count := list.count;
+        most := i;
+      End;
+  writeln(most,' has ',count,' proper divisors');
+  list.free;
+End.

Task/Proper-divisors/FreeBASIC/proper-divisors.basic

@@ -0,0 +1,47 @@
+' FreeBASIC v1.05.0 win64
+
+Sub ListProperDivisors(limit As Integer)
+  If limit < 1 Then Return
+  For i As Integer = 1 To limit
+     Print Using "##"; i;
+     Print " ->";
+     If i = 1 Then
+       Print " (None)"
+       Continue For
+     End if
+     For j As Integer = 1 To i \ 2
+       If i Mod j = 0 Then Print " "; j;
+     Next j
+     Print
+  Next i
+End Sub
+
+Function CountProperDivisors(number As Integer) As Integer
+  If number < 2 Then Return 0
+  Dim count As Integer = 0
+  For i As Integer = 1 To number \ 2
+    If number Mod i = 0 Then count += 1
+  Next
+  Return count
+End Function
+
+Dim As Integer n, count, most = 1, maxCount = 0
+
+Print "The proper divisors of the following numbers are :"
+Print
+ListProperDivisors(10)
+
+For n As Integer = 2 To 20000
+  count = CountProperDivisors(n)
+  If count > maxCount Then
+    maxCount = count
+    most = n
+  EndIf
+Next
+
+Print
+Print Str(most); " has the most proper divisors, namely"; maxCount
+Print
+Print "Press any key to exit the program"
+Sleep
+End

Task/Proper-divisors/Frink/proper-divisors.frink

@@ -0,0 +1,16 @@
+for n = 1 to 10
+   println["$n\t" + join[" ", properDivisors[n]]]
+
+println[]
+
+d = new dict
+for n = 1 to 20000
+{
+   c = length[properDivisors[n]]
+   d.addToList[c, n]
+}
+
+most = max[keys[d]]
+println[d@most + " have $most factors"]
+
+properDivisors[n] := allFactors[n, true, false, true]

Task/Proper-divisors/FutureBasic/proper-divisors.basic

@@ -0,0 +1,32 @@
+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

Task/Proper-divisors/GFA-Basic/proper-divisors.basic

@@ -0,0 +1,75 @@
+OPENW 1
+CLEARW 1
+'
+' Array f% is used to hold the divisors
+DIM f%(SQR(20000)) ! cannot redim arrays, so set size to largest needed
+'
+' 1. Show proper divisors of 1 to 10, inclusive
+'
+FOR i%=1 TO 10
+  num%=@proper_divisors(i%)
+  PRINT "Divisors for ";i%;":";
+  FOR j%=1 TO num%
+    PRINT " ";f%(j%);
+  NEXT j%
+  PRINT
+NEXT i%
+'
+' 2. Find (smallest) number <= 20000 with largest number of proper divisors
+'
+result%=1 ! largest so far
+number%=0 ! its number of divisors
+FOR i%=1 TO 20000
+  num%=@proper_divisors(i%)
+  IF num%>number%
+    result%=i%
+    number%=num%
+  ENDIF
+NEXT i%
+PRINT "Largest number of divisors is ";number%;" for ";result%
+'
+~INP(2)
+CLOSEW 1
+'
+' find the proper divisors of n%, placing results in f%
+' and return the number found
+'
+FUNCTION proper_divisors(n%)
+  LOCAL i%,root%,count%
+  '
+  ARRAYFILL f%(),0
+  count%=1 ! index of next slot in f% to fill
+  '
+  IF n%>1
+    f%(count%)=1
+    count%=count%+1
+    root%=SQR(n%)
+    FOR i%=2 TO root%
+      IF n% MOD i%=0
+        f%(count%)=i%
+        count%=count%+1
+        IF i%*i%<>n% ! root% is an integer, so check if i% is actual squa- lists:seq(1,10)].
+X: 1, N: []
+X: 2, N: [1]
+X: 3, N: [1]
+X: 4, N: [1,2]
+X: 5, N: [1]
+X: 6, N: [1,2,3]
+X: 7, N: [1]
+X: 8, N: [1,2,4]
+X: 9, N: [1,3]
+X: 10, N: [1,2,5]
+[ok,ok,ok,ok,ok,ok,ok,ok,ok,ok]
+
+2> properdivs:longest(20000).
+With 79, Number 15120 has the most divisors
+re root of n%
+          f%(count%)=n%/i%
+          count%=count%+1
+        ENDIF
+      ENDIF
+    NEXT i%
+  ENDIF
+  '
+  RETURN count%-1
+ENDFUNC

Task/Proper-divisors/Go/proper-divisors.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+    "fmt"
+    "strconv"
+)
+
+func listProperDivisors(limit int) {
+    if limit < 1 {
+        return
+    }
+    width := len(strconv.Itoa(limit))
+    for i := 1; i <= limit; i++ {
+        fmt.Printf("%*d -> ", width, i)
+        if i == 1 {
+            fmt.Println("(None)")
+            continue
+        }
+        for j := 1; j <= i/2; j++ {
+            if i%j == 0 {
+                fmt.Printf(" %d", j)
+            }
+        }
+        fmt.Println()
+    }
+}
+
+func countProperDivisors(n int) int {
+    if n < 2 {
+        return 0
+    }
+    count := 0
+    for i := 1; i <= n/2; i++ {
+        if n%i == 0 {
+            count++
+        }
+    }
+    return count
+}
+
+func main() {
+    fmt.Println("The proper divisors of the following numbers are :\n")
+    listProperDivisors(10)
+    fmt.Println()
+    maxCount := 0
+    most := []int{1}
+    for n := 2; n <= 20000; n++ {
+        count := countProperDivisors(n)
+        if count == maxCount {
+            most = append(most, n)
+        } else if count > maxCount {
+            maxCount = count
+            most = most[0:1]
+            most[0] = n
+        }
+    }
+    fmt.Print("The following number(s) <= 20000 have the most proper divisors, ")
+    fmt.Println("namely", maxCount, "\b\n")
+    for _, n := range most {
+        fmt.Println(n)
+    }
+}

Task/Proper-divisors/Haskell/proper-divisors-1.hs

@@ -0,0 +1,13 @@
+import Data.Ord
+import Data.List
+
+divisors :: (Integral a) => a -> [a]
+divisors n = filter ((0 ==) . (n `mod`)) [1 .. (n `div` 2)]
+
+main :: IO ()
+main = do
+  putStrLn "divisors of 1 to 10:"
+  mapM_ (print . divisors) [1 .. 10]
+  putStrLn "a number with the most divisors within 1 to 20000 (number, count):"
+  print $ maximumBy (comparing snd)
+    [(n, length $ divisors n) | n <- [1 .. 20000]]

Task/Proper-divisors/Haskell/proper-divisors-2.hs

@@ -0,0 +1,26 @@
+import Data.List (maximumBy)
+import Data.Ord (comparing)
+import Data.Bool (bool)
+
+properDivisors
+  :: Integral a
+  => a -> [a]
+properDivisors n =
+  let root = (floor . sqrt . fromIntegral) n
+      lows = filter ((0 ==) . rem n) [1 .. root]
+  in init (lows ++ bool id tail (n == root * root) (reverse (quot n <$> lows)))
+
+main :: IO ()
+main = do
+  putStrLn "Proper divisors of 1 to 10:"
+  mapM_ (print . properDivisors) [1 .. 10]
+  mapM_
+    putStrLn
+    [ ""
+    , "A number in the range 1 to 20,000 with the most proper divisors,"
+    , "as (number, count of proper divisors):"
+    , ""
+    ]
+  print $
+    maximumBy (comparing snd) $
+    (,) <*> (length . properDivisors) <$> [1 .. 20000]

Task/Proper-divisors/Haskell/proper-divisors-3.hs

@@ -0,0 +1,33 @@
+import Data.Numbers.Primes (primeFactors)
+import Data.List (group, maximumBy, sort)
+import Data.Ord (comparing)
+
+properDivisors :: Int -> [Int]
+properDivisors =
+  init . sort . foldr (
+    flip ((<*>) . fmap (*)) . scanl (*) 1
+  ) [1] . group . primeFactors
+
+---------------------------TEST----------------------------
+main :: IO ()
+main = do
+  putStrLn $
+    fTable "Proper divisors of [1..10]:" show show properDivisors [1 .. 10]
+  mapM_
+    putStrLn
+    [ ""
+    , "A number in the range 1 to 20,000 with the most proper divisors,"
+    , "as (number, count of proper divisors):"
+    , ""
+    ]
+  print $
+    maximumBy (comparing snd) $
+    (,) <*> (length . properDivisors) <$> [1 .. 20000]
+
+--------------------------DISPLAY--------------------------
+fTable :: String -> (a -> String) -> (b -> String) -> (a -> b) -> [a] -> String
+fTable s xShow fxShow f xs =
+  let rjust n c = (drop . length) <*> (replicate n c ++)
+      w = maximum (length . xShow <$> xs)
+  in unlines $
+     s : fmap (((++) . rjust w ' ' . xShow) <*> ((" -> " ++) . fxShow . f)) xs

Task/Proper-divisors/J/proper-divisors-1.j

@@ -0,0 +1,2 @@
+factors=: [: /:~@, */&>@{@((^ i.@>:)&.>/)@q:~&__
+properDivisors=: factors -. ]

Task/Proper-divisors/J/proper-divisors-2.j

@@ -0,0 +1,11 @@
+   (,&": ' -- ' ,&": properDivisors)&>1+i.10
+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

Task/Proper-divisors/J/proper-divisors-3.j

@@ -0,0 +1,3 @@
+   (, #@properDivisors)&> 1+I.(= >./) #@properDivisors@> 1+i.20000
+15120 79
+18480 79

Task/Proper-divisors/J/proper-divisors-4.j

@@ -0,0 +1,3 @@
+      (, #@properDivisors)&> 1+I.(= >./) #@factors@> 1+i.20000
+15120 79
+18480 79

Task/Proper-divisors/Java/proper-divisors.java

@@ -0,0 +1,33 @@
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Proper{
+    public static List<Integer> properDivs(int n){
+        List<Integer> divs = new LinkedList<Integer>();
+        if(n == 1) return divs;
+        divs.add(1);
+        for(int x = 2; x < n; x++){
+            if(n % x == 0) divs.add(x);
+        }
+
+        Collections.sort(divs);
+
+        return divs;
+    }
+
+    public static void main(String[] args){
+        for(int x = 1; x <= 10; x++){
+            System.out.println(x + ": " + properDivs(x));
+        }
+
+        int x = 0, count = 0;
+        for(int n = 1; n <= 20000; n++){
+            if(properDivs(n).size() > count){
+                x = n;
+                count = properDivs(n).size();
+            }
+        }
+        System.out.println(x + ": " + count);
+    }
+}

Task/Proper-divisors/JavaScript/proper-divisors-1.js

@@ -0,0 +1,69 @@
+(function () {
+
+    // Proper divisors
+    function properDivisors(n) {
+        if (n < 2) return [];
+        else {
+            var rRoot = Math.sqrt(n),
+                intRoot = Math.floor(rRoot),
+
+                lows = range(1, intRoot).filter(function (x) {
+                    return (n % x) === 0;
+                });
+
+            return lows.concat(lows.slice(1).map(function (x) {
+                return n / x;
+            }).reverse().slice((rRoot === intRoot) | 0));
+        }
+    }
+
+    // [m..n]
+    function range(m, n) {
+        var a = Array(n - m + 1),
+            i = n + 1;
+        while (i--) a[i - 1] = i;
+        return a;
+    }
+
+    var tblOneToTen = [
+            ['Number', 'Proper Divisors', 'Count']
+        ].concat(range(1, 10).map(function (x) {
+            var ds = properDivisors(x);
+
+            return [x, ds.join(', '), ds.length];
+        })),
+
+        dctMostBelow20k = range(1, 20000).reduce(function (a, x) {
+            var lng = properDivisors(x).length;
+
+            return lng > a.divisorCount ? {
+                n: x,
+                divisorCount: lng
+            } : a;
+        }, {
+            n: 0,
+            divisorCount: 0
+        });
+
+
+    // [[a]] -> bool -> s -> s
+    function wikiTable(lstRows, blnHeaderRow, strStyle) {
+        return '{| class="wikitable" ' + (
+            strStyle ? 'style="' + strStyle + '"' : ''
+        ) + lstRows.map(function (lstRow, iRow) {
+            var strDelim = ((blnHeaderRow && !iRow) ? '!' : '|');
+
+            return '\n|-\n' + strDelim + ' ' + lstRow.map(function (v) {
+                return typeof v === 'undefined' ? ' ' : v;
+            }).join(' ' + strDelim + strDelim + ' ');
+        }).join('') + '\n|}';
+    }
+
+    return wikiTable(
+        tblOneToTen,
+        true
+    ) + '\n\nMost proper divisors below 20,000:\n\n  ' + JSON.stringify(
+        dctMostBelow20k
+    );
+
+})();

Task/Proper-divisors/JavaScript/proper-divisors-2.js

@@ -0,0 +1,110 @@
+(() => {
+    'use strict';
+
+    // properDivisors :: Int -> [Int]
+    const properDivisors = n => {
+        // The integer divisors of n, excluding n itself.
+        const
+            rRoot = Math.sqrt(n),
+            intRoot = Math.floor(rRoot),
+            blnPerfectSquare = rRoot === intRoot,
+            lows = enumFromTo(1)(intRoot)
+            .filter(x => 0 === (n % x));
+
+        // For perfect squares, we can drop
+        // the head of the 'highs' list
+        return lows.concat(lows
+                .map(x => n / x)
+                .reverse()
+                .slice(blnPerfectSquare | 0)
+            )
+            .slice(0, -1); // except n itself
+    };
+
+
+    // ------------------------TESTS-----------------------
+    // main :: IO ()
+    const main = () =>
+        console.log([
+            fTable('Proper divisors of [1..10]:')(str)(
+                JSON.stringify
+            )(properDivisors)(enumFromTo(1)(10)),
+            '',
+            'Example of maximum divisor count in the range [1..20000]:',
+            '    ' + maximumBy(comparing(snd))(
+                enumFromTo(1)(20000).map(
+                    n => [n, properDivisors(n).length]
+                )
+            ).join(' has ') + ' proper divisors.'
+        ].join('\n'));
+
+
+    // -----------------GENERIC FUNCTIONS------------------
+
+    // comparing :: (a -> b) -> (a -> a -> Ordering)
+    const comparing = f =>
+        x => y => {
+            const
+                a = f(x),
+                b = f(y);
+            return a < b ? -1 : (a > b ? 1 : 0);
+        };
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = m => n =>
+        Array.from({
+            length: 1 + n - m
+        }, (_, i) => m + i);
+
+    // fTable :: String -> (a -> String) -> (b -> String)
+    //                      -> (a -> b) -> [a] -> String
+    const fTable = s => xShow => fxShow => f => xs => {
+        // Heading -> x display function ->
+        //           fx display function ->
+        //    f -> values -> tabular string
+        const
+            ys = xs.map(xShow),
+            w = Math.max(...ys.map(x => x.length));
+        return s + '\n' + zipWith(
+            a => b => a.padStart(w, ' ') + ' -> ' + b
+        )(ys)(
+            xs.map(x => fxShow(f(x)))
+        ).join('\n');
+    };
+
+    // maximumBy :: (a -> a -> Ordering) -> [a] -> a
+    const maximumBy = f => xs =>
+        0 < xs.length ? (
+            xs.slice(1)
+            .reduce((a, x) => 0 < f(x)(a) ? x : a, xs[0])
+        ) : undefined;
+
+    // snd :: (a, b) -> b
+    const snd = tpl => tpl[1];
+
+    // str :: a -> String
+    const str = x => x.toString();
+
+    // until :: (a -> Bool) -> (a -> a) -> a -> a
+    const until = p => f => x => {
+        let v = x;
+        while (!p(v)) v = f(v);
+        return v;
+    };
+
+    // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+    const zipWith = f => xs => ys => {
+        const
+            lng = Math.min(xs.length, xs.length),
+            as = xs.slice(0, lng),
+            bs = ys.slice(0, lng);
+        return Array.from({
+            length: lng
+        }, (_, i) => f(as[i])(
+            bs[i]
+        ));
+    };
+
+    // MAIN ---
+    return main();
+})();

Task/Proper-divisors/Jq/proper-divisors-1.jq

@@ -0,0 +1,21 @@
+def count(stream): reduce stream as $i (0; . + 1);
+
+# unordered
+def proper_divisors:
+  . as $n
+  | if $n > 1 then 1,
+      ( range(2; 1 + (sqrt|floor)) as $i
+        | if ($n % $i) == 0 then $i,
+            (($n / $i) | if . == $i then empty else . end)
+         else empty
+	 end)
+    else empty
+    end;
+
+# The first integer in 1 .. n inclusive
+# with the maximal number of proper divisors in that range:
+def most_proper_divisors(n):
+  reduce range(1; n+1) as $i
+    ( [null, 0];
+      count( $i | proper_divisors ) as $count
+      | if $count > .[1] then [$i, $count] else . end);

Task/Proper-divisors/Jq/proper-divisors-2.jq

@@ -0,0 +1,7 @@
+"The proper divisors of the numbers 1 to 10 inclusive are:",
+(range(1;11) as $i | "\($i): \( [ $i | proper_divisors] )"),
+"",
+"The pair consisting of the least number in the range 1 to 20,000 with",
+"the maximal number proper divisors together with the corresponding",
+"count of proper divisors is:",
+most_proper_divisors(20000)

Task/Proper-divisors/Jq/proper-divisors-3.jq

@@ -0,0 +1,17 @@
+$ jq -n -c -r -f /Users/peter/jq/proper_divisors.jq
+The proper divisors of the numbers 1 to 10 inclusive 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 pair consisting of the least number in the range 1 to 20,000 with
+the maximal number proper divisors together with the corresponding
+count of proper divisors is:
+[15120,79]

Task/Proper-divisors/Julia/proper-divisors.julia

@@ -0,0 +1,40 @@
+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)]
+    for (k, v) in f
+        c = T[k^i for i in 0:v]
+        d = d*c'
+        d = reshape(d, length(d))
+    end
+    sort!(d)
+    return d[1:end-1]
+end
+
+lo = 1
+hi = 10
+println("List the proper divisors for ", lo, " through ", hi, ".")
+for i in lo:hi
+    println(@sprintf("%4d", i), " ", properdivisors(i))
+end
+
+hi = 2*10^4
+println("\nFind the numbers within [", lo, ",", hi, "] having the most divisors.")
+
+maxdiv = 0
+nlst = Int[]
+
+for i in lo:hi
+    ndiv = length(properdivisors(i))
+    if ndiv > maxdiv
+        maxdiv = ndiv
+        nlst = [i]
+    elseif ndiv == maxdiv
+        push!(nlst, i)
+    end
+end
+
+println(nlst, " have the maximum proper divisor count of ", maxdiv, ".")

Task/Proper-divisors/Kotlin/proper-divisors.kotlin

@@ -0,0 +1,40 @@
+// version 1.0.5-2
+
+fun listProperDivisors(limit: Int) {
+    if (limit < 1) return
+    for(i in 1..limit) {
+        print(i.toString().padStart(2) + " -> ")
+        if (i == 1) {
+            println("(None)")
+            continue
+        }
+        (1..i/2).filter{ i % it == 0 }.forEach { print(" $it") }
+        println()
+    }
+}
+
+fun countProperDivisors(n: Int): Int {
+    if (n < 2) return 0
+    return (1..n/2).count { (n % it) == 0 }
+}
+
+fun main(args: Array<String>) {
+    println("The proper divisors of the following numbers are :\n")
+    listProperDivisors(10)
+    println()
+    var count: Int
+    var maxCount = 0
+    val most: MutableList<Int> = mutableListOf(1)
+    for (n in 2..20000) {
+        count = countProperDivisors(n)
+        if (count == maxCount)
+            most.add(n)
+        else if (count > maxCount) {
+            maxCount = count
+            most.clear()
+            most.add(n)
+        }
+    }
+    println("The following number(s) have the most proper divisors, namely " + maxCount + "\n")
+    for (n in most) println(n)
+}

Task/Proper-divisors/Langur/proper-divisors.langur

@@ -0,0 +1,27 @@
+val .getproper = f(.x) for[=[]] .i of .x \ 2 { if .x div .i: _for ~= [.i] }
+val .cntproper = f(.x) for[=0] .i of .x \ 2 { if .x div .i: _for += 1 }
+
+val .listproper = f(.x) {
+    if .x < 1: return null
+    for .i of .x {
+        writeln $"\.i:2; -> ", .getproper(.i)
+    }
+    writeln()
+}
+
+writeln "The proper divisors of the following numbers are :"
+.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

Task/Proper-divisors/Lua/proper-divisors.lua

@@ -0,0 +1,32 @@
+-- Return a table of the proper divisors of n
+function propDivs (n)
+    if n < 2 then return {} end
+    local divs, sqr = {1}, math.sqrt(n)
+    for d = 2, sqr do
+        if n % d == 0 then
+            table.insert(divs, d)
+            if d ~= sqr then table.insert(divs, n/d) end
+        end
+    end
+    table.sort(divs)
+    return divs
+end
+
+-- Show n followed by all values in t
+function show (n, t)
+    io.write(n .. ":\t")
+    for _, v in pairs(t) do io.write(v .. " ") end
+    print()
+end
+
+-- Main procedure
+local mostDivs, numDivs, answer = 0
+for i = 1, 10 do show(i, propDivs(i)) end
+for i = 1, 20000 do
+    numDivs = #propDivs(i)
+    if numDivs > mostDivs then
+        mostDivs = numDivs
+        answer = i
+    end
+end
+print(answer .. " has " .. mostDivs .. " proper divisors.")

Task/Proper-divisors/MATLAB/proper-divisors.m

@@ -0,0 +1,3 @@
+function D=pd(N)
+K=1:ceil(N/2);
+D=K(~(rem(N, K)));

Task/Proper-divisors/Mathematica/proper-divisors-1.math

@@ -0,0 +1 @@
+ProperDivisors[n_Integer /; n > 0] := Most@Divisors@n;

Task/Proper-divisors/Mathematica/proper-divisors-2.math

@@ -0,0 +1 @@
+Grid@Table[{n, ProperDivisors[n]}, {n, 1, 10}]

Task/Proper-divisors/Mathematica/proper-divisors-3.math

@@ -0,0 +1,4 @@
+Fold[
+ Last[SortBy[{#1, {#2, Length@ProperDivisors[#2]}}, Last]] &,
+ {0, 0},
+ Range[20000]]

Task/Proper-divisors/Mathematica/proper-divisors-4.math

@@ -0,0 +1,5 @@
+Last@SortBy[
+  Table[
+    {n, Length@ProperDivisors[n]},
+    {n, 1, 20000}],
+  Last]

Task/Proper-divisors/Modula-2/proper-divisors.mod2

@@ -0,0 +1,54 @@
+MODULE ProperDivisors;
+FROM FormatString IMPORT FormatString;
+FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
+
+PROCEDURE WriteInt(n : INTEGER);
+VAR buf : ARRAY[0..15] OF CHAR;
+BEGIN
+    FormatString("%i", buf, n);
+    WriteString(buf)
+END WriteInt;
+
+PROCEDURE proper_divisors(n : INTEGER; print_flag : BOOLEAN) : INTEGER;
+VAR count,i : INTEGER;
+BEGIN
+    count := 0;
+    FOR i:=1 TO n-1 DO
+        IF n MOD i = 0 THEN
+            INC(count);
+            IF print_flag THEN
+                WriteInt(i);
+                WriteString(" ")
+            END
+        END
+    END;
+    IF print_flag THEN WriteLn END;
+    RETURN count;
+END proper_divisors;
+
+VAR
+    buf : ARRAY[0..63] OF CHAR;
+    i,max,max_i,v : INTEGER;
+BEGIN
+    FOR i:=1 TO 10 DO
+        WriteInt(i);
+        WriteString(": ");
+        proper_divisors(i, TRUE)
+    END;
+
+    max := 0;
+    max_i := 1;
+
+    FOR i:=1 TO 20000 DO
+        v := proper_divisors(i, FALSE);
+        IF v>= max THEN
+            max := v;
+            max_i := i
+        END
+    END;
+
+    FormatString("%i with %i divisors\n", buf, max_i, max);
+    WriteString(buf);
+
+    ReadChar
+END ProperDivisors.

Task/Proper-divisors/Nim/proper-divisors.nim

@@ -0,0 +1,42 @@
+import strformat
+
+proc properDivisors(n: int) =
+  var count = 0
+  for i in 1..<n:
+    if n mod i == 0:
+      inc count
+      write(stdout, fmt"{i} ")
+  write(stdout, "\n")
+
+proc countProperDivisors(n: int): int =
+  var nn = n
+  var prod = 1
+  var count = 0
+  while nn mod 2 == 0:
+    inc count
+    nn = nn div 2
+  prod *= (1 + count)
+  for i in countup(3, n, 2):
+    count = 0
+    while nn mod i == 0:
+      inc count
+      nn = nn div i
+    prod *= (1 + count)
+  if nn > 2:
+    prod *= 2
+  prod - 1
+
+for i in 1..10:
+  write(stdout, fmt"{i:2}: ")
+  properDivisors(i)
+
+var max = 0
+var maxI = 1
+
+for i in 1..20000:
+  var v = countProperDivisors(i)
+  if v >= max:
+    max = v
+    maxI = i
+
+echo fmt"{maxI} with {max} divisors"

Task/Proper-divisors/Oberon-2/proper-divisors.oberon

@@ -0,0 +1,96 @@
+MODULE ProperDivisors;
+IMPORT
+  Out;
+
+CONST
+    initialSize = 128;
+TYPE
+  Result* = POINTER TO ResultDesc;
+  ResultDesc = RECORD
+    found-: LONGINT; (* number of slots in pd *)
+    pd-: POINTER TO ARRAY OF LONGINT;
+    cap: LONGINT;   (* Capacity *)
+  END;
+
+VAR
+  i,found,max,idxMx: LONGINT;
+  mx: ARRAY 32 OF LONGINT;
+  rs: Result;
+
+  PROCEDURE (r: Result) Init(size: LONGINT);
+  BEGIN
+    r.found := 0;
+    r.cap := size;
+    NEW(r.pd,r.cap);
+  END Init;
+
+  PROCEDURE (r: Result) Add(n: LONGINT);
+  BEGIN
+    (* Out.String("--->");Out.LongInt(n,0);Out.String(" At: ");Out.LongInt(r.found,0);Out.Ln; *)
+    IF (r.found < LEN(r.pd^) - 1) THEN
+      r.pd[r.found] := n;
+    ELSE
+      (* expand pd for more room *)
+    END;
+    INC(r.found);
+  END Add;
+
+  PROCEDURE (r:Result) Show();
+  VAR
+    i: LONGINT;
+  BEGIN
+      Out.String("(Result:");Out.LongInt(r.found + 1,0);(* Out.String("/");Out.LongInt(r.cap,0);*)
+      Out.String("-");
+      IF r.found > 0 THEN
+        FOR i:= 0 TO r.found - 1 DO
+          Out.LongInt(r.pd[i],0);
+          IF i = r.found - 1 THEN Out.Char(')') ELSE Out.Char(',') END
+        END
+      END;
+      Out.Ln
+  END Show;
+
+  PROCEDURE (r:Result) Reset();
+  BEGIN
+    r.found := 0;
+  END Reset;
+
+  PROCEDURE GetFor(n: LONGINT;VAR rs: Result);
+  VAR
+    i: LONGINT;
+  BEGIN
+    IF n > 1 THEN
+      rs.Add(1);i := 2;
+      WHILE (i < n) DO
+        IF (n MOD i) = 0 THEN rs.Add(i) END;
+        INC(i)
+      END
+    END;
+  END GetFor;
+
+BEGIN
+  NEW(rs);rs.Init(initialSize);
+  FOR i := 1 TO 10 DO
+    Out.LongInt(i,4);Out.Char(':');
+    GetFor(i,rs);
+    rs.Show();
+    rs.Reset();
+  END;
+  Out.LongInt(100,4);Out.Char(':');GetFor(100,rs);rs.Show();rs.Reset();
+  max := 0;idxMx := 0;found := 0;
+  FOR i := 1 TO 20000 DO
+    GetFor(i,rs);
+    IF rs.found > max THEN
+      idxMx:= 0;mx[idxMx] := i;max := rs.found
+    ELSIF rs.found = max THEN
+      INC(idxMx);mx[idxMx] := i
+    END;
+    rs.Reset()
+  END;
+  Out.String("Found: ");Out.LongInt(idxMx + 1,0);
+  Out.String(" Numbers with most proper divisors ");
+  Out.LongInt(max,0);Out.String(": ");Out.Ln;
+  FOR i := 0 TO idxMx DO
+    Out.LongInt(mx[i],0);Out.Ln
+  END
+END ProperDivisors.

Task/Proper-divisors/Objeck/proper-divisors.objeck

@@ -0,0 +1,43 @@
+use Collection;
+
+class Proper{
+  function : Main(args : String[]) ~ Nil {
+    for(x := 1; x <= 10; x++;) {
+      Print(x, ProperDivs(x));
+    };
+
+    x := 0;
+    count := 0;
+
+    for(n := 1; n <= 20000; n++;) {
+      if(ProperDivs(n)->Size() > count) {
+        x := n;
+        count := ProperDivs(n)->Size();
+      };
+    };
+    "{$x}: {$count}"->PrintLine();
+  }
+
+  function : ProperDivs(n : Int) ~ IntVector {
+    divs := IntVector->New();
+
+    if(n = 1) {
+      return divs;
+    };
+    divs->AddBack(1);
+
+    for(x := 2; x < n; x++;) {
+      if(n % x = 0) {
+        divs->AddBack(x);
+      };
+    };
+    divs->Sort();
+
+    return divs;
+  }
+
+  function : Print(x : Int, result : IntVector) ~ Nil {
+    "{$x}: "->Print();
+    result->ToArray()->ToString()->PrintLine();
+  }
+}

Task/Proper-divisors/Oforth/proper-divisors.fth

@@ -0,0 +1,4 @@
+Integer method: properDivs  self 2 / seq filter(#[ self swap mod 0 == ]) }
+
+10 seq apply(#[ dup print " : " print properDivs println ])
+20000 seq map(#[ dup properDivs size Pair new ]) reduce(#maxKey) println

Task/Proper-divisors/PARI-GP/proper-divisors.parigp

@@ -0,0 +1,3 @@
+proper(n)=if(n==1, [], my(d=divisors(n)); d[2..#d]);
+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]

Task/Proper-divisors/PHP/proper-divisors.php

@@ -0,0 +1,36 @@
+<?php
+function ProperDivisors($n) {
+  yield 1;
+  $large_divisors = [];
+  for ($i = 2; $i <= sqrt($n); $i++) {
+    if ($n % $i == 0) {
+      yield $i;
+      if ($i*$i != $n) {
+        $large_divisors[] = $n / $i;
+      }
+    }
+  }
+  foreach (array_reverse($large_divisors) as $i) {
+    yield $i;
+  }
+}
+
+assert([1, 2, 4, 5, 10, 20, 25, 50] ==
+        iterator_to_array(ProperDivisors(100)));
+
+foreach (range(1, 10) as $n) {
+  echo "$n =>";
+  foreach (ProperDivisors($n) as $divisor) {
+    echo " $divisor";
+  }
+  echo "\n";
+}
+
+$divisorsCount = [];
+for ($i = 1; $i < 20000; $i++) {
+  $divisorsCount[sizeof(iterator_to_array(ProperDivisors($i)))][] = $i;
+}
+ksort($divisorsCount);
+
+echo "Numbers with most divisors: ", implode(", ", end($divisorsCount)), ".\n";
+echo "They have ", key($divisorsCount), " divisors.\n";

Task/Proper-divisors/PL-I/proper-divisors.pli

@@ -0,0 +1,64 @@
+*process source xref;
+ (subrg):
+ cpd: Proc Options(main);
+ p9a=time();
+ Dcl (p9a,p9b) Pic'(9)9';
+ Dcl cnt(3) Bin Fixed(31) Init((3)0);
+ Dcl x Bin Fixed(31);
+ Dcl pd(300) Bin Fixed(31);
+ Dcl sumpd   Bin Fixed(31);
+ Dcl npd     Bin Fixed(31);
+ Dcl hi      Bin Fixed(31) Init(0);
+ Dcl (xl(10),xi) Bin Fixed(31);
+ Dcl i       Bin Fixed(31);
+ Do x=1 To 10;
+   Call proper_divisors(x,pd,npd);
+   Put Edit(x,' -> ',(pd(i) Do i=1 To npd))(Skip,f(2),a,10(f(2)));
+   End;
+ xi=0;
+ Do x=1 To 20000;
+   Call proper_divisors(x,pd,npd);
+   Select;
+     When(npd>hi) Do;
+       xi=1;
+       xl(1)=x;
+       hi=npd;
+       End;
+     When(npd=hi) Do;
+       xi+=1;
+       xl(xi)=x;
+       End;
+     Otherwise;
+     End;
+   End;
+ Put Edit(hi,' -> ',(xl(i) Do i=1 To xi))(Skip,f(3),a,10(f(6)));
+
+ x= 166320; Call proper_divisors(x,pd,npd);
+ Put Edit(x,' -> ',npd)(Skip,f(8),a,f(4));
+ x=1441440; Call proper_divisors(x,pd,npd);
+ Put Edit(x,' -> ',npd)(Skip,f(8),a,f(4));
+
+
+ p9b=time();
+ Put Edit((p9b-p9a)/1000,' seconds elapsed')(Skip,f(6,3),a);
+ Return;
+
+ proper_divisors: Proc(n,pd,npd);
+ Dcl (n,pd(300),npd) Bin Fixed(31);
+ Dcl (d,delta)       Bin Fixed(31);
+ npd=0;
+ If n>1 Then Do;
+   If mod(n,2)=1 Then  /* odd number  */
+     delta=2;
+   Else                /* even number */
+     delta=1;
+   Do d=1 To n/2 By delta;
+     If mod(n,d)=0 Then Do;
+       npd+=1;
+       pd(npd)=d;
+       End;
+     End;
+   End;
+ End;
+
+ End;

Task/Proper-divisors/Pascal/proper-divisors.pas

@@ -0,0 +1,220 @@
+{$IFDEF FPC}{$MODE DELPHI}{$ELSE}{$APPTYPE CONSOLE}{$ENDIF}
+uses
+  sysutils;
+const
+  MAXPROPERDIVS = 1920;
+type
+  tRes = array[0..MAXPROPERDIVS] of LongWord;
+  tPot = record
+           potPrim,
+           potMax :LongWord;
+         end;
+
+  tprimeFac = record
+                 pfPrims : array[1..10] of tPot;
+                 pfCnt,
+                 pfNum   : LongWord;
+               end;
+  tSmallPrimes = array[0..6541] of longWord;
+
+var
+  SmallPrimes: tSmallPrimes;
+
+procedure InitSmallPrimes;
+var
+  pr,testPr,j,maxprimidx: Longword;
+  isPrime : boolean;
+Begin
+  maxprimidx := 0;
+  SmallPrimes[0] := 2;
+  pr := 3;
+  repeat
+    isprime := true;
+    j := 0;
+    repeat
+      testPr := SmallPrimes[j];
+      IF testPr*testPr > pr then
+        break;
+      If pr mod testPr = 0 then
+      Begin
+        isprime := false;
+        break;
+      end;
+      inc(j);
+    until false;
+
+    if isprime then
+    Begin
+      inc(maxprimidx);
+      SmallPrimes[maxprimidx]:= pr;
+    end;
+    inc(pr,2);
+  until pr > 1 shl 16 -1;
+end;
+
+procedure PrimeFacOut(primeDecomp:tprimeFac);
+var
+  i : LongWord;
+begin
+  with primeDecomp do
+  Begin
+    write(pfNum,' = ');
+    For i := 1 to pfCnt-1 do
+      with pfPrims[i] do
+        If potMax = 1 then
+          write(potPrim,'*')
+        else
+          write(potPrim,'^',potMax,'*');
+    with pfPrims[pfCnt] do
+      If potMax = 1 then
+        write(potPrim)
+      else
+        write(potPrim,'^',potMax);
+  end;
+end;
+
+procedure PrimeDecomposition(n:LongWord;var res:tprimeFac);
+var
+  i,pr,cnt,quot{to minimize divisions} : LongWord;
+Begin
+  res.pfNum := n;
+  res.pfCnt:= 0;
+  i := 0;
+  cnt := 0;
+  repeat
+    pr := SmallPrimes[i];
+    IF pr*pr>n then
+      Break;
+
+    quot := n div pr;
+    IF pr*quot = n then
+      with res do
+      Begin
+        inc(pfCnt);
+        with pfPrims[pfCnt] do
+        Begin
+          potPrim := pr;
+          potMax := 0;
+          repeat
+            n := quot;
+            quot := quot div pr;
+            inc(potMax);
+          until pr*quot <> n;
+        end;
+      end;
+     inc(i);
+  until false;
+  //a big prime left over?
+  IF n <> 1 then
+    with res do
+    Begin
+      inc(pfCnt);
+      with pfPrims[pfCnt] do
+      Begin
+        potPrim := n;
+        potMax := 1;
+      end;
+    end;
+end;
+
+function CntProperDivs(const primeDecomp:tprimeFac):LongWord;
+//count of proper divisors
+var
+   i: LongWord;
+begin
+  result := 1;
+  with primeDecomp do
+    For i := 1 to pfCnt do
+      result := result*(pfPrims[i].potMax+1);
+  //remove
+  dec(result);
+end;
+
+function findProperdivs(n:LongWord;var res:TRes):LongWord;
+//simple trial division to get a sorted list of all proper divisors
+var
+  i,j: LongWord;
+Begin
+  result := 0;
+  i := 1;
+  j := n;
+  while j>i do
+  begin
+    j := n DIV i;
+    IF i*j = n then
+    Begin
+      //smaller factor part at the beginning upwards
+      res[result]:= i;
+      IF i <> j then
+        //bigger factor at the end downwards
+        res[MAXPROPERDIVS-result]:= j
+      else
+        //n is square number
+        res[MAXPROPERDIVS-result]:= 0;
+      inc(result);
+    end;
+    inc(i);
+  end;
+
+  If result>0 then
+  Begin
+    //move close together
+    i := result;
+    j := MAXPROPERDIVS-result+1;
+    result := 2*result-1;
+    repeat
+      res[i] := res[j];
+      inc(j);
+      inc(i);
+    until i > result;
+
+    if res[result-1] = 0 then
+      dec(result);
+  end;
+end;
+
+procedure AllFacsOut(n: Longword);
+var
+  res:TRes;
+  i,k,j:LongInt;
+Begin
+   j := findProperdivs(n,res);
+   write(n:5,' : ');
+   For k := 0 to j-2 do write(res[k],',');
+   IF j>=1 then
+     write(res[j-1]);
+   writeln;
+end;
+
+var
+  primeDecomp: tprimeFac;
+  rs : tRes;
+  i,j,max,maxcnt: LongWord;
+BEGIN
+  InitSmallPrimes;
+  For i := 1 to 10 do
+    AllFacsOut(i);
+  writeln;
+  max    := 0;
+  maxCnt := 0;
+  For i := 1 to 20*1000 do
+  Begin
+    PrimeDecomposition(i,primeDecomp);
+    j := CntProperDivs(primeDecomp);
+    IF j> maxCnt then
+    Begin
+      maxcnt := j;
+      max := i;
+    end;
+  end;
+  PrimeDecomposition(max,primeDecomp);
+  j := CntProperDivs(primeDecomp);
+
+  PrimeFacOut(primeDecomp);writeln('  ',j:10,' factors'); writeln;
+  //https://en.wikipedia.org/wiki/Highly_composite_number <= HCN
+  //http://wwwhomes.uni-bielefeld.de/achim/highly.txt the first 1200 HCN
+  max := 3491888400;
+  PrimeDecomposition(max,primeDecomp);
+  j := CntProperDivs(primeDecomp);
+  PrimeFacOut(primeDecomp);writeln('  ',j:10,' factors'); writeln;
+END.

Task/Proper-divisors/Perl/proper-divisors.pl

@@ -0,0 +1,23 @@
+use ntheory qw/divisors/;
+sub proper_divisors {
+  my $n = shift;
+  # Like Pari/GP, divisors(0) = (0,1) and divisors(1) = ()
+  return 1 if $n == 0;
+  my @d = divisors($n);
+  pop @d;  # divisors are in sorted order, so last entry is the input
+  @d;
+}
+say "$_: ", join " ", proper_divisors($_) for 1..10;
+# 1. For the max, we can do a traditional loop.
+my($max,$ind) = (0,0);
+for (1..20000) {
+  my $nd = scalar proper_divisors($_);
+ ($max,$ind) = ($nd,$_) if $nd > $max;
+}
+say "$max $ind";
+# 2. Or we can use List::Util's max with decoration (this exploits its implementation)
+{
+  use List::Util qw/max/;
+  no warnings 'numeric';
+  say max(map { scalar(proper_divisors($_)) . " $_" } 1..20000);
+}

Task/Proper-divisors/Phix/proper-divisors-1.phix

@@ -0,0 +1,33 @@
+-->
+ <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;">--
+ -- returns a list of all integer factors of n
+ --  if include1 is 0 (the default), result does not contain either 1 or n
+ --  if include1 is 1 the result contains 1 and n
+ --  if include1 is -1 the result contains 1 but not n
+ --  </span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #0000FF;">{}</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #000000;">check_limits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"factors"</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">lfactors</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000000;">hfactors</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+     <span style="color: #004080;">atom</span> <span style="color: #000000;">hfactor</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span>
+             <span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">))</span>
+
+     <span style="color: #008080;">if</span> <span style="color: #000000;">include1</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+         <span style="color: #000000;">lfactors</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">1</span> <span style="color: #008080;">and</span> <span style="color: #000000;">include1</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">hfactors</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">}</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">while</span> <span style="color: #000000;">p</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">lim</span> <span style="color: #008080;">do</span>
+         <span style="color: #008080;">if</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">lfactors</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lfactors</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
+             <span style="color: #000000;">hfactor</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">p</span>
+             <span style="color: #008080;">if</span> <span style="color: #000000;">hfactor</span><span style="color: #0000FF;">=</span><span style="color: #000000;">p</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+             <span style="color: #000000;">hfactors</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prepend</span><span style="color: #0000FF;">(</span><span style="color: #000000;">hfactors</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hfactor</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">p</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <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>
+<!--

Task/Proper-divisors/Phix/proper-divisors-2.phix

@@ -0,0 +1,20 @@
+(phixonline)-->
+ <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: #004080;">sequence</span> <span style="color: #000000;">candidates</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">maxd</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20000</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</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;">if</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">maxd</span> <span style="color: #008080;">then</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">maxd</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">candidates</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">i</span>
+         <span style="color: #008080;">else</span>
+             <span style="color: #000000;">candidates</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">}</span>
+             <span style="color: #000000;">maxd</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">k</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+ <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>
+<!--

Task/Proper-divisors/Picat/proper-divisors-1.picat

@@ -0,0 +1,40 @@
+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.

Task/Proper-divisors/Picat/proper-divisors-2.picat

@@ -0,0 +1,5 @@
+go2 =>
+  time(find_most_divisors(100_000)),
+  nl,
+  time(find_most_divisors(1_000_000)),
+  nl.

Task/Proper-divisors/PicoLisp/proper-divisors-1.l

@@ -0,0 +1,10 @@
+# Generate all proper divisors.
+(de propdiv (N)
+   (head -1 (filter
+      '((X) (=0 (% N X)))
+      (range 1 N) )) )
+
+# Obtaining the values from 1 to 10 inclusive.
+(mapcar propdiv (range 1 10))
+# Output:
+# (NIL (1) (1) (1 2) (1) (1 2 3) (1) (1 2 4) (1 3) (1 2 5))

Task/Proper-divisors/PicoLisp/proper-divisors-2.l

@@ -0,0 +1,21 @@
+(de propdiv (N)
+   (cdr
+      (rot
+         (make
+            (for I N
+               (and (=0 (% N I)) (link I)) ) ) ) ) )
+(de countdiv (N)
+   (let C -1
+      (for I N
+         (and (=0 (% N I)) (inc 'C)) )
+      C ) )
+(let F (-5 -8)
+   (tab F "N" "LIST")
+   (for I 10
+      (tab F
+         I
+         (glue " + " (propdiv I)) ) ) )
+(println
+   (maxi
+      countdiv
+      (range 1 20000) ) )

Task/Proper-divisors/PicoLisp/proper-divisors-3.l

@@ -0,0 +1,24 @@
+(de accu1 (Var Key)
+   (if (assoc Key (val Var))
+      (con @ (inc (cdr @)))
+      (push Var (cons Key 2)) )
+   Key )
+(de factor (N)
+   (let
+      (R NIL
+         D 2
+         L (1 2 2 . (4 2 4 2 4 6 2 6 .))
+         M (sqrt N) )
+      (while (>= M D)
+         (if (=0 (% N D))
+            (setq M
+               (sqrt (setq N (/ N (accu1 'R D)))) )
+            (inc 'D (pop 'L)) ) )
+      (accu1 'R N)
+      (dec (apply * (mapcar cdr R))) ) )
+(bench
+   (println
+      (maxi
+         factor
+         (range 1 20000) )
+      @@ ) )

Task/Proper-divisors/PowerShell/proper-divisors-1.psh

@@ -0,0 +1,17 @@
+function proper-divisor ($n) {
+    if($n -ge 2) {
+        $lim = [Math]::Floor([Math]::Sqrt($n))
+        $less, $greater = @(1), @()
+        for($i = 2; $i -lt $lim; $i++){
+            if($n%$i -eq 0) {
+                $less += @($i)
+                $greater = @($n/$i) + $greater
+            }
+        }
+        if(($lim -ne 1) -and ($n%$lim -eq 0)) {$less += @($lim)}
+        $($less + $greater)
+    } else {@()}
+}
+"$(proper-divisor 100)"
+"$(proper-divisor 496)"
+"$(proper-divisor 2048)"

Task/Proper-divisors/PowerShell/proper-divisors-2.psh

@@ -0,0 +1,15 @@
+function proper-divisor ($n) {
+    if($n -ge 2) {
+        $lim = [Math]::Floor($n/2)+1
+        $proper = @(1)
+        for($i = 2; $i -lt $lim; $i++){
+            if($n%$i -eq 0) {
+                $proper += @($i)
+            }
+        }
+        $proper
+    } else {@()}
+}
+"$(proper-divisor 100)"
+"$(proper-divisor 496)"
+"$(proper-divisor 2048)"

Task/Proper-divisors/PowerShell/proper-divisors-3.psh

@@ -0,0 +1,49 @@
+function eratosthenes ($n) {
+    if($n -gt 1){
+        $prime = @(0..$n| foreach{$true})
+        $m = [Math]::Floor([Math]::Sqrt($n))
+        function multiple($i) {
+            for($j = $i*$i; $j -le $n; $j += $i) {
+                $prime[$j] = $false
+            }
+        }
+        multiple 2
+        for($i = 3; $i -le $m; $i += 2) {
+            if($prime[$i]) {multiple $i}
+        }
+        2
+        for($i = 3; $i -le $n; $i += 2) {
+            if($prime[$i]) {$i}
+        }
+
+    } else {
+        Write-Error "$n is not greater than 1"
+    }
+}
+function prime-decomposition ($n) {
+    $array = eratosthenes $n
+    $prime = @()
+    foreach($p in $array) {
+        while($n%$p -eq 0) {
+            $n /= $p
+            $prime += @($p)
+        }
+    }
+    $prime
+}
+function proper-divisor ($n) {
+    if($n -ge 2) {
+        $array = prime-decomposition $n
+        $lim = $array.Count
+        function state($res, $i){
+            if($i -lt $lim) {
+                state ($res) ($i + 1)
+                state ($res*$array[$i]) ($i + 1)
+            } elseif($res -lt $n) {$res}
+        }
+        state 1 0 | sort -Unique
+    } else {@()}
+}
+"$(proper-divisor 100)"
+"$(proper-divisor 496)"
+"$(proper-divisor 2048)"

Task/Proper-divisors/Prolog/proper-divisors-1.pro

@@ -0,0 +1,48 @@
+divisor(N, Divisor) :-
+    UpperBound is round(sqrt(N)),
+    between(1, UpperBound, D),
+    0 is N mod D,
+    (
+        Divisor = D
+     ;
+        LargerDivisor is N/D,
+        LargerDivisor =\= D,
+        Divisor = LargerDivisor
+    ).
+
+proper_divisor(N, D) :-
+    divisor(N, D),
+    D =\= N.
+
+
+%% Task 1
+%
+
+proper_divisors(N, Ds) :-
+    setof(D, proper_divisor(N, D), Ds).
+
+
+%% Task 2
+%
+
+show_proper_divisors_of_range(Low, High) :-
+    findall( N:Ds,
+             ( between(Low, High, N),
+               proper_divisors(N, Ds) ),
+             Results ),
+    maplist(writeln, Results).
+
+
+%% Task 3
+%
+
+proper_divisor_count(N, Count) :-
+    proper_divisors(N, Ds),
+    length(Ds, Count).
+
+find_most_proper_divisors_in_range(Low, High, Result) :-
+    aggregate_all( max(Count, N),
+                   ( between(Low, High, N),
+                     proper_divisor_count(N, Count) ),
+                   max(MaxCount, Num) ),
+    Result = (num(Num)-divisor_count(MaxCount)).

Task/Proper-divisors/Prolog/proper-divisors-2.pro

@@ -0,0 +1,14 @@
+?- show_proper_divisors_of_range(1,10).
+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]
+true.
+
+?- find_most_proper_divisors_in_range(1,20000,Result).
+Result = num(15120)-divisor_count(79).

Task/Proper-divisors/PureBasic/proper-divisors.basic

@@ -0,0 +1,56 @@
+EnableExplicit
+
+Procedure ListProperDivisors(Number, List Lst())
+  If Number < 2 : ProcedureReturn : EndIf
+  Protected i
+  For i = 1 To Number / 2
+    If Number % i = 0
+      AddElement(Lst())
+      Lst() = i
+    EndIf
+  Next
+EndProcedure
+
+Procedure.i CountProperDivisors(Number)
+  If Number < 2 : ProcedureReturn 0 : EndIf
+  Protected i, count = 0
+  For i = 1 To Number / 2
+    If Number % i = 0
+      count + 1
+    EndIf
+  Next
+  ProcedureReturn count
+EndProcedure
+
+Define n, count, most = 1, maxCount = 0
+If OpenConsole()
+  PrintN("The proper divisors of the following numbers are : ")
+  PrintN("")
+  NewList lst()
+  For n = 1 To 10
+    ListProperDivisors(n, lst())
+    Print(RSet(Str(n), 3) + " -> ")
+    If ListSize(lst()) = 0
+      Print("(None)")
+    Else
+      ForEach lst()
+        Print(Str(lst()) + " ")
+      Next
+    EndIf
+    ClearList(lst())
+    PrintN("")
+  Next
+  For n = 2 To 20000
+    count = CountProperDivisors(n)
+    If count > maxCount
+      maxCount = count
+      most = n
+    EndIf
+  Next
+  PrintN("")
+  PrintN(Str(most) + " has the most proper divisors, namely " + Str(maxCount))
+  PrintN("")
+  PrintN("Press any key to close the console")
+  Repeat: Delay(10) : Until Inkey() <> ""
+  CloseConsole()
+EndIf

Task/Proper-divisors/Python/proper-divisors-1.py

@@ -0,0 +1,12 @@
+>>> def proper_divs2(n):
+...     return {x for x in range(1, (n + 1) // 2 + 1) if n % x == 0 and n != x}
+...
+>>> [proper_divs2(n) for n in range(1, 11)]
+[set(), {1}, {1}, {1, 2}, {1}, {1, 2, 3}, {1}, {1, 2, 4}, {1, 3}, {1, 2, 5}]
+>>>
+>>> n, length = max(((n, len(proper_divs2(n))) for n in range(1, 20001)), key=lambda pd: pd[1])
+>>> n
+15120
+>>> length
+79
+>>>

Task/Proper-divisors/Python/proper-divisors-2.py

@@ -0,0 +1,45 @@
+from math import sqrt
+from functools import lru_cache, reduce
+from collections import Counter
+from itertools import product
+
+
+MUL = int.__mul__
+
+
+def prime_factors(n):
+    'Map prime factors to their multiplicity for n'
+    d = _divs(n)
+    d = [] if d == [n] else (d[:-1] if d[-1] == d else d)
+    pf = Counter(d)
+    return dict(pf)
+
+@lru_cache(maxsize=None)
+def _divs(n):
+    'Memoized recursive function returning prime factors of n as a list'
+    for i in range(2, int(sqrt(n)+1)):
+        d, m  = divmod(n, i)
+        if not m:
+            return [i] + _divs(d)
+    return [n]
+
+
+def proper_divs(n):
+    '''Return the set of proper divisors of n.'''
+    pf = prime_factors(n)
+    pfactors, occurrences = pf.keys(), pf.values()
+    multiplicities = product(*(range(oc + 1) for oc in occurrences))
+    divs = {reduce(MUL, (pf**m for pf, m in zip(pfactors, multis)), 1)
+            for multis in multiplicities}
+    try:
+        divs.remove(n)
+    except KeyError:
+        pass
+    return divs or ({1} if n != 1 else set())
+
+
+if __name__ == '__main__':
+    rangemax = 20000
+
+    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]))