I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Largest proper divisor of n

Largest proper divisor of n
You are encouraged to solve this task according to the task description, using any language you may know.
a(1) = 1; for n > 1, a(n) = largest proper divisor of n, where n < 101 .

## ALGOL 68

`FOR n TO 100 DO # show the largest proper divisors for n = 1..100 #    INT largest proper divisor := 1;    FOR j FROM ( n OVER 2 ) BY -1 TO 2 WHILE largest proper divisor = 1 DO        IF n MOD j = 0 THEN            largest proper divisor := j        FI    OD;    print( ( whole( largest proper divisor, -3 ) ) );    IF n MOD 10 = 0 THEN print( ( newline ) ) FIOD `
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## ALGOL W

`for n := 1 until 100 do begin % show the largest proper divisors for n = 1..100 %    for j := n div 2 step -1 until 2 do begin        if n rem j = 0 then begin            writeon( i_w := 3, s_w := 0, j );            goto foundLargestProperDivisor        end if_n_rem_j_eq_0    end for_j;    writeon( i_w := 3, s_w := 0, 1 );foundLargestProperDivisor:    if n rem 10 = 0 then write()end for_n.`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## APL

Works with: Dyalog APL
`(⌈/1,(⍸0=¯1↓⍳|⊢))¨10 10⍴⍳100`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## AppleScript

Most of this code is just to prepare the output for display.  :D

`on largestProperDivisor(n)    if (n mod 2 = 0) then return n div 2    if (n mod 3 = 0) then return n div 3    if (n < 5) then return missing value    repeat with i from 5 to (n ^ 0.5 div 1) by 6        if (n mod i = 0) then return n div i        if (n mod (i + 2) = 0) then return n div (i + 2)    end repeat    return 1end largestProperDivisor on task(max)    script o        property LPDs : {}        property output : {}    end script     set w to (count (max as text)) * 2 + 3    set padding to text 1 thru (w - 2) of "          "    set end of o's LPDs to "1:1" & padding    set astid to AppleScript's text item delimiters    set AppleScript's text item delimiters to ""    set c to 1    repeat with n from 2 to max        set end of o's LPDs to text 1 thru w of ((n as text) & ":" & largestProperDivisor(n) & padding)        set c to c + 1        if (c mod 10 is 0) then            set end of o's output to o's LPDs as text            set o's LPDs to {}        end if    end repeat    if (c mod 10 > 0) then set end of o's output to o's LPDs as text    set AppleScript's text item delimiters to linefeed    set o's output to o's output as text    set AppleScript's text item delimiters to astid     return o's outputend task task(100)`
Output:
`"1:1      2:1      3:1      4:2      5:1      6:3      7:1      8:4      9:3      10:5     11:1     12:6     13:1     14:7     15:5     16:8     17:1     18:9     19:1     20:10    21:7     22:11    23:1     24:12    25:5     26:13    27:9     28:14    29:1     30:15    31:1     32:16    33:11    34:17    35:7     36:18    37:1     38:19    39:13    40:20    41:1     42:21    43:1     44:22    45:15    46:23    47:1     48:24    49:7     50:25    51:17    52:26    53:1     54:27    55:11    56:28    57:19    58:29    59:1     60:30    61:1     62:31    63:21    64:32    65:13    66:33    67:1     68:34    69:23    70:35    71:1     72:36    73:1     74:37    75:25    76:38    77:11    78:39    79:1     80:40    81:27    82:41    83:1     84:42    85:17    86:43    87:29    88:44    89:1     90:45    91:13    92:46    93:31    94:47    95:19    96:48    97:1     98:49    99:33    100:50   "`

### Functional

Composing functionally, for rapid drafting and refactoring, with higher levels of code reuse:

`use framework "Foundation"  --------------- LARGEST PROPER DIVISOR OF N -------------- -- maxProperDivisors :: Int -> Inton maxProperDivisors(n)    script p        on |λ|(x)            0 = n mod x        end |λ|    end script     set mb to find(p, enumFromTo(2, sqrt(n)))     if missing value is mb then        1    else        n div mb    end ifend maxProperDivisors  --------------------------- TEST -------------------------on run    set xs to map(maxProperDivisors, enumFromTo(1, 100))    set w to length of (maximum(xs) as string)     unlines(map(unwords, ¬        chunksOf(10, ¬            map(compose(justifyRight(w, space), str), xs))))end run  ------------------------- GENERIC ------------------------ -- chunksOf :: Int -> [a] -> [[a]]on chunksOf(k, xs)    script        on go(ys)            set ab to splitAt(k, ys)            set a to item 1 of ab            if {} ≠ a then                {a} & go(item 2 of ab)            else                a            end if        end go    end script    result's go(xs)end chunksOf  -- compose (<<<) :: (b -> c) -> (a -> b) -> a -> con compose(f, g)    script        property mf : mReturn(f)        property mg : mReturn(g)        on |λ|(x)            mf's |λ|(mg's |λ|(x))        end |λ|    end scriptend compose  -- enumFromTo :: Int -> Int -> [Int]on enumFromTo(m, n)    if m ≤ n then        set lst to {}        repeat with i from m to n            set end of lst to i        end repeat        lst    else        {}    end ifend enumFromTo  -- find :: (a -> Bool) -> [a] -> (a | missing value)on find(p, xs)    tell mReturn(p)        set lng to length of xs        repeat with i from 1 to lng            if |λ|(item i of xs) then return item i of xs        end repeat        missing value    end tellend find  -- justifyRight :: Int -> Char -> String -> Stringon justifyRight(n, cFiller)    script        on |λ|(strText)            if n > length of strText then                text -n thru -1 of ((replicate(n, cFiller) as text) & strText)            else                strText            end if        end |λ|    end scriptend justifyRight  -- map :: (a -> b) -> [a] -> [b]on map(f, xs)    -- The list obtained by applying f    -- to each element of 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 tellend map  -- maximum :: Ord a => [a] -> aon maximum(xs)    set ca to current application    unwrap((ca's NSArray's arrayWithArray:(xs))'s ¬        valueForKeyPath:"@max.self")end maximum  -- mReturn :: First-class m => (a -> b) -> m (a -> b)on mReturn(f)    -- 2nd class handler function lifted into 1st class script wrapper.     if script is class of f then        f    else        script            property |λ| : f        end script    end ifend mReturn  -- Egyptian multiplication - progressively doubling a list, appending-- stages of doubling to an accumulator where needed for binary -- assembly of a target length-- replicate :: Int -> String -> Stringon replicate(n, s)    -- Egyptian multiplication - progressively doubling a list,     -- appending stages of doubling to an accumulator where needed     -- for binary assembly of a target length    script p        on |λ|({n})            n ≤ 1        end |λ|    end script     script f        on |λ|({n, dbl, out})            if (n mod 2) > 0 then                set d to out & dbl            else                set d to out            end if            {n div 2, dbl & dbl, d}        end |λ|    end script     set xs to |until|(p, f, {n, s, ""})    item 2 of xs & item 3 of xsend replicate  -- splitAt :: Int -> [a] -> ([a], [a])on splitAt(n, xs)    if n > 0 and n < length of xs then        if class of xs is text then            {items 1 thru n of xs as text, ¬                items (n + 1) thru -1 of xs as text}        else            {items 1 thru n of xs, items (n + 1) thru -1 of xs}        end if    else        if n < 1 then            {{}, xs}        else            {xs, {}}        end if    end ifend splitAt  -- sqrt :: Num -> (Num | missing value)on sqrt(n)    if 0 ≤ n then        n ^ (1 / 2)    else        missing value    end ifend sqrt  -- str :: a -> Stringon str(x)    x as stringend str  -- unlines :: [String] -> Stringon unlines(xs)    -- A single string formed by the intercalation    -- of a list of strings with the newline character.    set {dlm, my text item delimiters} to ¬        {my text item delimiters, linefeed}    set s to xs as text    set my text item delimiters to dlm    send unlines  -- until :: (a -> Bool) -> (a -> a) -> a -> aon |until|(p, f, x)    set v to x    set mp to mReturn(p)    set mf to mReturn(f)    repeat until mp's |λ|(v)        set v to mf's |λ|(v)    end repeat    vend |until|  -- unwords :: [String] -> Stringon unwords(xs)    set {dlm, my text item delimiters} to ¬        {my text item delimiters, space}    set s to xs as text    set my text item delimiters to dlm    return send unwords  -- unwrap :: NSValue -> aon unwrap(nsValue)    if nsValue is missing value then        missing value    else        set ca to current application        item 1 of ((ca's NSArray's arrayWithObject:nsValue) as list)    end ifend unwrap`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## AWK

` # syntax: GAWK -f LARGEST_PROPER_DIVISOR_OF_N.AWK# converted from CBEGIN {    start = 1    stop = 100    for (i=start; i<=stop; i++) {      printf("%3d%1s",largest_proper_divisor(i),++count%10?"":"\n")    }    printf("\nLargest proper divisor of n %d-%d\n",start,stop)    exit(0)}function largest_proper_divisor(n,  i) {    if (n <= 1) {      return(1)    }    for (i=n-1; i>0; i--) {      if (n % i == 0) {        return(i)      }    }} `
Output:
```  1   1   1   2   1   3   1   4   3   5
1   6   1   7   5   8   1   9   1  10
7  11   1  12   5  13   9  14   1  15
1  16  11  17   7  18   1  19  13  20
1  21   1  22  15  23   1  24   7  25
17  26   1  27  11  28  19  29   1  30
1  31  21  32  13  33   1  34  23  35
1  36   1  37  25  38  11  39   1  40
27  41   1  42  17  43  29  44   1  45
13  46  31  47  19  48   1  49  33  50

Largest proper divisor of n 1-100
```

## BASIC

`10 DEFINT A-Z20 FOR I=1 TO 10030 IF I=1 THEN PRINT "  1";: GOTO 7040 FOR J=I-1 TO 1 STEP -150 IF I MOD J=0 THEN PRINT USING "###";J;: GOTO 7060 NEXT J70 IF I MOD 10=0 THEN PRINT80 NEXT I`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## BASIC256

Translation of: FreeBASIC
`print "El mayor divisor propio de n es:\n"print " 1  1 ";for i = 3 to 100	for j = i-1 to 1 step -1		If i % j = 0 then			print " "; j; " ";			exit for		end if	next  j	if i % 10 = 0 then printnext iend`

## BCPL

`get "libhdr" let lpd(n) = valof    for i = n<=1 -> 1, n-1 to 1 by -1        if n rem i=0 resultis i let start() be    for i=1 to 100    \$(  writed(lpd(i), 3)        if i rem 10=0 then wrch('*N')    \$)`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## BQN

`(1⌈´↕×0=↕|⊢)¨ ∘‿10⥊1+↕100`
Output:
```┌─
╵  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
┘```

## C

`#include <stdio.h> unsigned int lpd(unsigned int n) {    if (n<=1) return 1;    int i;    for (i=n-1; i>0; i--)        if (n%i == 0) return i;   } int main() {    int i;    for (i=1; i<=100; i++) {        printf("%3d", lpd(i));        if (i % 10 == 0) printf("\n");    }    return 0;}`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## C++

`#include <cassert>#include <iomanip>#include <iostream> int largest_proper_divisor(int n) {    assert(n > 0);    if ((n & 1) == 0)        return n >> 1;    for (int p = 3; p * p <= n; p += 2) {        if (n % p == 0)            return n / p;    }    return 1;} int main() {    for (int n = 1; n < 101; ++n) {        std::cout << std::setw(2) << largest_proper_divisor(n)            << (n % 10 == 0 ? '\n' : ' ');    }}`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## Cowgol

`include "cowgol.coh"; sub print3(n: uint8) is    print_char(' ');    if n>9 then        print_char('0' + n/10);    else        print_char(' ');    end if;    print_char('0' + n%10);end sub; sub lpd(n: uint8): (r: uint8) is    if n <= 1 then        r := 1;    else        r := n - 1;        while r > 0 loop            if n % r == 0 then                 break;            end if;            r := r - 1;        end loop;    end if;end sub; var i: uint8 := 1;while i <= 100 loop    print3(lpd(i));    if i%10 == 0 then        print_nl();    end if;    i := i + 1;end loop;`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## F#

` // Largest proper divisor of n: Nigel Galloway. June 2nd., 2021let fN g=let rec fN n=let i=Seq.head n in match(g/i,g%i) with (1,_)->1 |(n,0)->n |_->fN(Seq.tail n) in fN(Seq.initInfinite((+)2))seq{yield 1; yield! seq{2..100}|>Seq.map fN}|>Seq.iter(printf "%d "); printfn "" `
Output:
```1 1 1 2 1 3 1 4 3 5 1 6 1 7 5 8 1 9 1 10 7 11 1 12 5 13 9 14 1 15 1 16 11 17 7 18 1 19 13 20 1 21 1 22 15 23 1 24 7 25 17 26 1 27 11 28 19 29 1 30 1 31 21 32 13 33 1 34 23 35 1 36 1 37 25 38 11 39 1 40 27 41 1 42 17 43 29 44 1 45 13 46 31 47 19 48 1 49 33 50
Real: 00:00:00.015
```

## Factor

Works with: Factor version 0.99 2021-02-05
`USING: grouping kernel math math.bitwise math.functionsmath.ranges prettyprint sequences ; : odd ( m -- n )    dup 3 /i 1 - next-odd 1 -2 <range>    [ divisor? ] with find nip ; : largest ( m -- n ) dup odd? [ odd ] [ 2/ ] if ; 100 [1,b] [ largest ] map 10 group simple-table.`
Output:
```1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1  10
7  11 1  12 5  13 9  14 1  15
1  16 11 17 7  18 1  19 13 20
1  21 1  22 15 23 1  24 7  25
17 26 1  27 11 28 19 29 1  30
1  31 21 32 13 33 1  34 23 35
1  36 1  37 25 38 11 39 1  40
27 41 1  42 17 43 29 44 1  45
13 46 31 47 19 48 1  49 33 50
```

## FOCAL

`01.10 F N=1,100;D 2;D 301.20 Q 02.10 S V=102.20 I (1-N)2.3;R02.30 S V=N-102.40 S A=N/V02.50 I (FITR(A)-A)2.6;R02.60 S V=V-102.70 G 2.4 03.10 T %2,V03.20 S A=N/1003.30 I (FITR(A)-A)3.4;T !03.40 R`
Output:
```=  1=  1=  1=  2=  1=  3=  1=  4=  3=  5
=  1=  6=  1=  7=  5=  8=  1=  9=  1= 10
=  7= 11=  1= 12=  5= 13=  9= 14=  1= 15
=  1= 16= 11= 17=  7= 18=  1= 19= 13= 20
=  1= 21=  1= 22= 15= 23=  1= 24=  7= 25
= 17= 26=  1= 27= 11= 28= 19= 29=  1= 30
=  1= 31= 21= 32= 13= 33=  1= 34= 23= 35
=  1= 36=  1= 37= 25= 38= 11= 39=  1= 40
= 27= 41=  1= 42= 17= 43= 29= 44=  1= 45
= 13= 46= 31= 47= 19= 48=  1= 49= 33= 50```

## Forth

Works with: Gforth
`: largest-proper-divisor { n -- n }  n 1 and 0= if n 2/ exit then   3  begin    dup dup * n <=  while    dup n swap /mod swap    0= if nip exit else drop then    2 +  repeat drop 1 ; : main  101 1 do    i largest-proper-divisor 2 .r    i 10 mod 0= if cr else space then  loop ; mainbye`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## Fortran

`       program LargestProperDivisors       implicit none       integer i, lpd       do 10 i=1, 100           write (*,'(I3)',advance='no') lpd(i) 10        if (i/10*10 .eq. i) write (*,*)              end program        integer function lpd(n)       implicit none       integer n, i       if (n .le. 1) then           lpd = 1       else           do 10 i=n-1, 1, -1 10            if (n/i*i .eq. n) goto 20 20        lpd = i       end if       end function`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## FreeBASIC

`Print !"El mayor divisor propio de n es:\n"Print "  1  1"; For i As Byte = 3 To 100    For j As Byte = i-1 To 1 Step -1        If i Mod j = 0 Then Print Using "###"; j; : Exit For    Next  j    If i Mod 10 = 0 Then PrintNext iSleep`
Output:
```El mayor divisor propio de n es:

1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## Go

`package main import "fmt" func largestProperDivisor(n int) int {    for i := 2; i*i <= n; i++ {        if n%i == 0 {            return n / i        }    }    return 1} func main() {    fmt.Println("The largest proper divisors for numbers in the interval [1, 100] are:")    fmt.Print(" 1  ")    for n := 2; n <= 100; n++ {        if n%2 == 0 {            fmt.Printf("%2d  ", n/2)        } else {            fmt.Printf("%2d  ", largestProperDivisor(n))        }        if n%10 == 0 {            fmt.Println()        }    }}`
Output:
```The largest proper divisors for numbers in the interval [1, 100] are:
1   1   1   2   1   3   1   4   3   5
1   6   1   7   5   8   1   9   1  10
7  11   1  12   5  13   9  14   1  15
1  16  11  17   7  18   1  19  13  20
1  21   1  22  15  23   1  24   7  25
17  26   1  27  11  28  19  29   1  30
1  31  21  32  13  33   1  34  23  35
1  36   1  37  25  38  11  39   1  40
27  41   1  42  17  43  29  44   1  45
13  46  31  47  19  48   1  49  33  50
```

`import Data.List.Split (chunksOf)import Text.Printf (printf) lpd :: Int -> Intlpd 1 = 1lpd n = head [x | x <- [n -1, n -2 .. 1], n `mod` x == 0] main :: IO ()main =  (putStr . unlines . map concat . chunksOf 10) \$     printf "%3d" . lpd <\$> [1 .. 100]`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

Or, considering the two smallest proper divisors:

(If there are two, then the largest proper divisor will be N divided by the first proper divisor that is not 1)

(Otherwise, the largest proper divisor will be 1 itself).

`import Data.List (find)import Data.List.Split (chunksOf)import Text.Printf (printf) maxProperDivisors :: Int -> IntmaxProperDivisors n =  case find ((0 ==) . rem n) [2 .. root] of    Nothing -> 1    Just x -> quot n x  where    root = (floor . sqrt) (fromIntegral n :: Double) main :: IO ()main =  (putStr . unlines . map concat . chunksOf 10) \$    printf "%3d" . maxProperDivisors <\$> [1 .. 100]`
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## J

`   lpd =:  (1 |.!.1 ])&.q:`
Output:
```   lpd 1+i.100
1 1 1 2 1 3 1 4 3 5 1 6 1 7 5 8 1 9 1 10 7 11 1 12 5 13 9 14 1 15 1 16 11 17 7 18 1 19 13 20 1 21 1 22 15 23 1 24 7 25 17 26 1 27 11 28 19 29 1 30 1 31 21 32 13 33 1 34 23 35 1 36 1 37 25 38 11 39 1 40 27 41 1 42 17 43 29 44 1 45 13 46 31 47 19 48 1 49 33 ...```

This works by prime factorization of n, replacing the largest prime factor with 1, and then taking the product of this new list of prime factors. In J terms, we work "under" factorization, in analogy to a medical operation where the patient is "under" anaethesia: (put patient to sleep) rearrange guts (wake patient up).

The core logic only concerns itself with a list of prime factors; it is never even aware of the original input integer, nor the final integer result. In fact, note that the final multiplication is implicit and never spelled out by the programmer; product is the inverse of factorization, and we requested to work "under" factorization, thus J's algebra knows to apply the inverse of factorization (i.e. taking the product) as the final step.

## jq

Works with jq

Works with gojq, the Go implementation of jq

Naive version:

`# (1|largestpd) is 1 as per the task definitiondef largestpd:  if . == 1 then 1  else . as \$n  | first( range( (\$n - (\$n % 2)) /2; 0; -1) | (select(\$n % . == 0) ))  end;`

Slightly less naive:

`def largestpd:  if . == 1 then 1  else . as \$n  | (first(2,3,5,7 | select(\$n % . == 0)) // null) as \$div  | if \$div then \$n/\$div    else first( range( (\$n - (\$n % 11)) /11; 0; -1) | (select(\$n % . == 0) ))    end  end;`
`# For neatnessdef lpad(\$len):  tostring | (\$len - length) as \$l | (" " * \$l)[:\$l] + .; def nwise(\$n):  def w: if length <= \$n then . else .[:\$n], (.[\$n:]|w) end;  w; ### The task[range(1; 101) | largestpd]| nwise(10) | map(lpad(2)) | join(" ")`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## Julia

`largestpd(n) = (for i in n÷2:-1:1 (n % i == 0) && return i; end; 1) foreach(n -> print(rpad(largestpd(n), 3), n % 10 == 0 ? "\n" : ""), 1:100) `
Output:
```1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1  10
7  11 1  12 5  13 9  14 1  15
1  16 11 17 7  18 1  19 13 20
1  21 1  22 15 23 1  24 7  25
17 26 1  27 11 28 19 29 1  30
1  31 21 32 13 33 1  34 23 35
1  36 1  37 25 38 11 39 1  40
27 41 1  42 17 43 29 44 1  45
13 46 31 47 19 48 1  49 33 50
```

`            NORMAL MODE IS INTEGER             INTERNAL FUNCTION(N)            ENTRY TO LPD.            WHENEVER N.LE.1, FUNCTION RETURN 1            THROUGH TEST, FOR D=N-1, -1, D.L.1TEST        WHENEVER N/D*D.E.N, FUNCTION RETURN D            END OF FUNCTION             THROUGH SHOW, FOR I=1, 10, I.GE.100SHOW        PRINT FORMAT TABLE,           0     LPD.(I), LPD.(I+1), LPD.(I+2), LPD.(I+3),          1     LPD.(I+4), LPD.(I+5), LPD.(I+6), LPD.(I+7),          2     LPD.(I+8), LPD.(I+9)             VECTOR VALUES TABLE = \$10(I3)*\$            END OF PROGRAM `
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## Mathematica / Wolfram Language

`Last[Prepend[DeleteCases[Divisors[#], #], 1]] & /@ Range[100]`
Output:
`{1,1,1,2,1,3,1,4,3,5,1,6,1,7,5,8,1,9,1,10,7,11,1,12,5,13,9,14,1,15,1,16,11,17,7,18,1,19,13,20,1,21,1,22,15,23,1,24,7,25,17,26,1,27,11,28,19,29,1,30,1,31,21,32,13,33,1,34,23,35,1,36,1,37,25,38,11,39,1,40,27,41,1,42,17,43,29,44,1,45,13,46,31,47,19,48,1,49,33,50}`

## Nim

`import math, strutils func largestProperDivisor(n: Positive): int =  for d in 2..sqrt(float(n)).int:    if n mod d == 0: return n div d  result = 1 for n in 1..100:  stdout.write (\$n.largestProperDivisor).align(2), if n mod 10 == 0: '\n' else: ' '`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## Pascal

` program LarPropDiv; function LargestProperDivisor(n:NativeInt):NativeInt;//searching upwards to save time for example 100//2..sqrt(n) aka 1..10 instead downwards n..sqrt(n) 100..10var  i,j: NativeInt;Begin  i := 2;  repeat    If n Mod i = 0 then    Begin      LargestProperDivisor := n DIV i;      EXIT;    end;    inc(i);  until i*i > n;  LargestProperDivisor := 1;end;var  n : Uint32;begin  for n := 1 to 100 do  Begin    write(LargestProperDivisor(n):4);    if n mod 10 = 0 then      Writeln;  end;end.`
Output:
```   1   1   1   2   1   3   1   4   3   5
1   6   1   7   5   8   1   9   1  10
7  11   1  12   5  13   9  14   1  15
1  16  11  17   7  18   1  19  13  20
1  21   1  22  15  23   1  24   7  25
17  26   1  27  11  28  19  29   1  30
1  31  21  32  13  33   1  34  23  35
1  36   1  37  25  38  11  39   1  40
27  41   1  42  17  43  29  44   1  45
13  46  31  47  19  48   1  49  33  50```

## Perl

Library: ntheory
`use strict;use warnings;use ntheory 'divisors';use List::AllUtils <max natatime>; sub proper_divisors {  my \$n = shift;  return 1 if \$n == 0;  my @d = divisors(\$n);  pop @d;  @d;} my @range = 1 .. 100;print "GPD for \$range[0] through \$range[-1]:\n";my \$iter = natatime 10, @range;while( my @batch = \$iter->() ) {    printf '%3d', \$_ == 1 ? 1 : max proper_divisors(\$_) for @batch; print "\n";}`
Output:
```GPD for 1 through 100:
1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## Phix

```puts(1,join_by(apply(true,sprintf,{{"%3d"},vslice(apply(apply(true,factors,{tagset(100),-1}),reverse),1)}),1,10,""))
```
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

Alternative, same output, optimised: obviously checking for a factor from 2 up is going to be significantly faster than n-1 down... or of course as above collecting all of them and extracting/discarding all but the last, at least on much larger numbers, that is, and I suppose you could (perhaps) improve even further on this by only checking primes.

```with javascript_semantics
for n=1 to 100 do
integer p = 2,
lim = floor(sqrt(n)),
hf = 1
while p<=lim do
if remainder(n,p)=0 then
hf = n/p
exit
end if
p += 1
end while
printf(1,"%3d",hf)
if remainder(n,10)=0 then puts(1,"\n") end if
end for
```

## PL/I

`largestProperDivisor: procedure options(main);    lpd: procedure(n) returns(fixed);        declare (n, i) fixed;        if n <= 1 then return(1);        do i=n-1 repeat(i-1) while(i>=1);            if mod(n,i)=0 then return(i);        end;    end lpd;     declare i fixed;    do i=1 to 100;        put edit(lpd(i)) (F(3));        if mod(i,10)=0 then put skip;    end;end largestProperDivisor;`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## PL/M

`100H:BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;PUT\$CHAR: PROCEDURE (CH); DECLARE CH BYTE; CALL BDOS(2,CH); END PUT\$CHAR;PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT; PRINT\$3: PROCEDURE (N);    DECLARE N BYTE;    CALL PUT\$CHAR(' ');    IF N>9        THEN CALL PUT\$CHAR('0' + N/10);        ELSE CALL PUT\$CHAR(' ');    CALL PUT\$CHAR('0' + N MOD 10);END PRINT\$3; LPD: PROCEDURE (N) BYTE;    DECLARE (N, I) BYTE;    IF N <= 1 THEN RETURN 1;    I = N-1;    DO WHILE I >= 1;        IF N MOD I = 0 THEN RETURN I;        I = I - 1;    END;END LPD; DECLARE I BYTE;DO I=1 TO 100;    CALL PRINT\$3(LPD(I));    IF I MOD 10 = 0 THEN CALL PRINT(.(13,10,'\$'));END;CALL EXIT;EOF`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## Python

`def lpd(n):    for i in range(n-1,0,-1):        if n%i==0: return i    return 1 for i in range(1,101):    print("{:3}".format(lpd(i)), end=i%10==0 and '\n' or '')`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

Or, reducing the search space, formatting more flexibly (to allow for experiments with larger ranges) and composing functionally:

`'''Largest proper divisor of''' from math import isqrt  # maxProperDivisors :: Int -> Intdef maxProperDivisors(n):    '''The largest proper divisor of n.    '''    secondDivisor = find(        lambda x: 0 == (n % x)    )(        range(2, 1 + isqrt(n))    )    return 1 if None is secondDivisor else (        n // secondDivisor    )  # ------------------------- TEST -------------------------# main :: IO ()def main():    '''Test for values of n in [1..100]'''     xs = [        maxProperDivisors(n) for n        in range(1, 1 + 100)    ]     colWidth = 1 + len(str(max(xs)))     print(        '\n'.join([            ''.join(row) for row in            chunksOf(10)([                str(x).rjust(colWidth, " ") for x in xs            ])        ])    )  # ----------------------- GENERIC ------------------------ # chunksOf :: Int -> [a] -> [[a]]def chunksOf(n):    '''A series of lists of length n, subdividing the       contents of xs. Where the length of xs is not evenly       divisible, the final list will be shorter than n.    '''    def go(xs):        return (            xs[i:n + i] for i in range(0, len(xs), n)        ) if 0 < n else None    return go  # find :: (a -> Bool) -> [a] -> (a | None)def find(p):    '''Just the first element in the list that matches p,       or None if no elements match.    '''    def go(xs):        try:            return next(x for x in xs if p(x))        except StopIteration:            return None    return go  # MAIN ---if __name__ == '__main__':    main()`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50```

## Quackery

`factors` is defined at Factors of an integer.

`' [ 1 ] 99 times  [ i^ 2 + factors    -2 peek join ]echo`
Output:
`[ 1 1 1 2 1 3 1 4 3 5 1 6 1 7 5 8 1 9 1 10 7 11 1 12 5 13 9 14 1 15 1 16 11 17 7 18 1 19 13 20 1 21 1 22 15 23 1 24 7 25 17 26 1 27 11 28 19 29 1 30 1 31 21 32 13 33 1 34 23 35 1 36 1 37 25 38 11 39 1 40 27 41 1 42 17 43 29 44 1 45 13 46 31 47 19 48 1 49 33 50 ]`

## Raku

A little odd to special case a(1) == 1 as technically, 1 doesn't have any proper divisors... but it matches OEIS A032742 so whatever.

Note: this example is ridiculously overpowered (and so, somewhat inefficient) for a range of 1 to 100, but will easily handle large numbers without modification.

`use Prime::Factor; for 0, 2**67 - 1 -> \$add {    my \$start = now;     my \$range = \$add + 1 .. \$add + 100;     say "GPD for {\$range.min} through {\$range.max}:";     say ( \$range.hyper(:14batch).map: {\$_ == 1 ?? 1 !! \$_ %% 2 ?? \$_ / 2 !! .&proper-divisors.max} )\        .batch(10)».fmt("%{\$add.chars + 1}d").join: "\n";     say (now - \$start).fmt("%0.3f seconds\n");}`
Output:
```GPD for 1 through 100:
1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
0.071 seconds

GPD for 147573952589676412928 through 147573952589676413027:
73786976294838206464   49191317529892137643   73786976294838206465                      1   73786976294838206466   21081993227096630419   73786976294838206467   49191317529892137645   73786976294838206468    8680820740569200761
73786976294838206469    5088756985850910791   73786976294838206470   49191317529892137647   73786976294838206471   13415813871788764813   73786976294838206472   29514790517935282589   73786976294838206473   49191317529892137649
73786976294838206474    6416258808246800563   73786976294838206475     977310944302492801   73786976294838206476   49191317529892137651   73786976294838206477   29514790517935282591   73786976294838206478      87167130885810049
73786976294838206479   49191317529892137653   73786976294838206480   21081993227096630423   73786976294838206481    7767050136298758577   73786976294838206482   49191317529892137655   73786976294838206483    2784414199805215339
73786976294838206484   11351842506898185613   73786976294838206485   49191317529892137657   73786976294838206486     939961481462907089   73786976294838206487   29514790517935282595   73786976294838206488   49191317529892137659
73786976294838206489      82581954443019817   73786976294838206490        147258377885867   73786976294838206491   49191317529892137661   73786976294838206492   29514790517935282597   73786976294838206493   13415813871788764817
73786976294838206494   49191317529892137663   73786976294838206495                      1   73786976294838206496    2202596307308603179   73786976294838206497   49191317529892137665   73786976294838206498    5088756985850910793
73786976294838206499                      1   73786976294838206500   49191317529892137667   73786976294838206501   21081993227096630429   73786976294838206502   29514790517935282601   73786976294838206503   49191317529892137669
73786976294838206504   13415813871788764819   73786976294838206505     103270785577100359   73786976294838206506   49191317529892137671   73786976294838206507   29514790517935282603   73786976294838206508   21081993227096630431
73786976294838206509   49191317529892137673   73786976294838206510   11351842506898185617   73786976294838206511                      1   73786976294838206512   49191317529892137675   73786976294838206513    1305964182209525779
0.440 seconds```

## REXX

Logic was added to the   LPDIV   function so that for   odd   numbers,   only odd divisors were used.

`/*REXX program finds the largest proper divisors of all numbers  (up to a given limit). */parse arg n cols .                               /*obtain optional argument from the CL.*/if    n=='' |    n==","  then    n= 101          /*Not specified?  Then use the default.*/if cols=='' | cols==","  then cols=  10          /* "      "         "   "   "     "    */w= length(n)  +  1                               /*W:  the length of any output column. */@LPD = "largest proper divisor of  N,  where  N  < "       nidx = 1                                          /*initialize the index (output counter)*/say ' index │'center(@LPD,  1 + cols*(w+1)     ) /*display the title for the output.    */say '───────┼'center(""  ,  1 + cols*(w+1), '─') /*   "     "   sep   "   "     "       */\$=                                               /*a list of largest proper divs so far.*/     do j=1  for n-1;  \$= \$ right(LPDIV(j), w)   /*add a largest proper divisor ──► list*/     if j//cols\==0  then iterate                /*have we populated a line of output?  */     say center(idx, 7)'│'  substr(\$, 2);   \$=   /*display what we have so far  (cols). */     idx= idx + cols                             /*bump the  index  count for the output*/     end   /*j*/ if \$\==''  then say center(idx, 7)"│"  substr(\$, 2)  /*possible display residual output.*/say '───────┴'center(""  ,  1 + cols*(w+1), '─') /*display the foot separator.          */exit 0                                           /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/LPDIV:  procedure; parse arg x;  if x<4  then return 1   /*obtain  X;  test if  X < 4.  */        odd= x // 2;    beg= x % 2                       /*use BEG as the first divisor.*/        if odd  then if beg//2==0  then beg= beg -  1    /*Is X odd?  Then make BEG odd.*/                   do k=beg  by -1-odd           /*begin at halfway point and decrease. */                   if x//k==0  then return k     /*Remainder=0?  Got largest proper div.*/                   end   /*k*/                                    return 1     /*If we get here,  then  X  is a prime.*/`
output   when using the default inputs:
``` index │  largest proper divisor of  N,  where  N  <  101
───────┼───────────────────────────────────────────────────
1   │    1    1    1    2    1    3    1    4    3    5
11   │    1    6    1    7    5    8    1    9    1   10
21   │    7   11    1   12    5   13    9   14    1   15
31   │    1   16   11   17    7   18    1   19   13   20
41   │    1   21    1   22   15   23    1   24    7   25
51   │   17   26    1   27   11   28   19   29    1   30
61   │    1   31   21   32   13   33    1   34   23   35
71   │    1   36    1   37   25   38   11   39    1   40
81   │   27   41    1   42   17   43   29   44    1   45
91   │   13   46   31   47   19   48    1   49   33   50
───────┴───────────────────────────────────────────────────
```

## Ring

` see "working..." + nlsee "Largest proper divisor of n are:" + nlsee "1 " row = 1limit = 100 for n = 2 to limit    for m = 1 to n-1         if n%m = 0           div = m        ok    next    row = row + 1    see "" + div + " "    if row%10 = 0       see nl    oknext see "done..." + nl `
Output:
```working...
Largest proper divisor of n are:
1 1 1 2 1 3 1 4 3 5
1 6 1 7 5 8 1 9 1 10
7 11 1 12 5 13 9 14 1 15
1 16 11 17 7 18 1 19 13 20
1 21 1 22 15 23 1 24 7 25
17 26 1 27 11 28 19 29 1 30
1 31 21 32 13 33 1 34 23 35
1 36 1 37 25 38 11 39 1 40
27 41 1 42 17 43 29 44 1 45
13 46 31 47 19 48 1 49 33 50
done...
```

## Ruby

`require 'prime' def a(n)  return 1 if n == 1 || n.prime?  (n/2).downto(1).detect{|d| n.remainder(d) == 0}end (1..100).map{|n| a(n).to_s.rjust(3)}.each_slice(10){|slice| puts slice.join} `
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## Seed7

`\$ include "seed7_05.s7i"; const func integer: largestProperDivisor (in integer: number) is func  result    var integer: divisor is 0;  begin    if not odd(number) then      divisor := number >> 1;    else      divisor := number div 3 - 1;      if odd(divisor) then        divisor +:= 2;      else        incr(divisor);      end if;      while number rem divisor <> 0 do        divisor -:= 2;      end while;    end if;  end func; const proc: main is func  local    var integer: n is 0;  begin    for n range 1 to 100 do      write(largestProperDivisor(n) lpad 3);      if n rem 10 = 0 then        writeln;      end if;    end for;  end func;`
Output:
```  1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## Swift

`import Foundation func largestProperDivisor(_ n : Int) -> Int? {    guard n > 0 else {        return nil    }    if (n & 1) == 0 {        return n >> 1    }    var p = 3    while p * p <= n {        if n % p == 0 {            return n / p        }        p += 2    }    return 1} for n in (1..<101) {    print(String(format: "%2d", largestProperDivisor(n)!),          terminator: n % 10 == 0 ? "\n" : " ")}`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## True BASIC

Translation of: FreeBASIC
`PRINT "El mayor divisor propio de n es:"PRINTPRINT "  1  1";FOR i = 3 TO 100    FOR j = i-1 TO 1 STEP -1        IF remainder(i, j) = 0 THEN           PRINT USING\$("###", j);           EXIT FOR        END IF    NEXT  j    IF remainder(i, 10) = 0 THEN PRINTNEXT iEND`
Output:
```Igual que la entrada de FreeBASIC.
```

## Wren

Library: Wren-math
Library: Wren-fmt
`import "/math" for Intimport "/fmt" for Fmt System.print("The largest proper divisors for numbers in the interval [1, 100] are:")System.write(" 1  ")for (n in 2..100) {    if (n % 2 == 0) {        Fmt.write("\$2d  ", n / 2)    } else {        Fmt.write("\$2d  ", Int.properDivisors(n)[-1])    }    if (n % 10 == 0) System.print()}`
Output:
```The largest proper divisors for numbers in the interval [1, 100] are:
1   1   1   2   1   3   1   4   3   5
1   6   1   7   5   8   1   9   1  10
7  11   1  12   5  13   9  14   1  15
1  16  11  17   7  18   1  19  13  20
1  21   1  22  15  23   1  24   7  25
17  26   1  27  11  28  19  29   1  30
1  31  21  32  13  33   1  34  23  35
1  36   1  37  25  38  11  39   1  40
27  41   1  42  17  43  29  44   1  45
13  46  31  47  19  48   1  49  33  50
```

## Yabasic

Translation of: FreeBASIC
`print "El mayor divisor propio de n es:\n"print " 1  1 "; for i = 3 to 100	for j = i-1 to 1 step -1		If mod(i, j) = 0 then print j using "##"; : break : fi	next  j    if mod(i, 10) = 0 then print : finext iprintend`
Output:
```Igual que la entrada de FreeBASIC.
```

## X86 Assembly

`      1                              ;Assemble with: tasm, tlink /t      2 0000                                 .model  tiny      3 0000                                 .code      4                                      org     100h            ;.com program starts here      5      6                              ;bl = D = divisor      7                              ;bh = N      8      9 0100  B7 01                  start:  mov     bh, 1           ;for N:= 1 to 100 do     10 0102  8A DF                  d10:    mov     bl, bh          ;D:= if N=1 then 1 else N/2     11 0104  D0 EB                          shr     bl, 1     12 0106  75 02                          jne     d15     13 0108  FE C3                           inc    bl     14 010A                         d15:     15 010A  8A C7                  d20:    mov     al, bh          ;while rem(N/D) # 0 do     16 010C  98                             cbw                     ; ah:= 0 (extend sign of al into ah)     17 010D  F6 FB                          idiv    bl              ; al:= ax/bl; ah:= remainder     18 010F  84 E4                          test    ah, ah     19 0111  74 04                          je      d30     20 0113  FE CB                           dec    bl              ; D--     21 0115  EB F3                           jmp    d20     22 0117                         d30:     23 0117  8A C3                          mov     al, bl          ;output number in D     24 0119  D4 0A                          aam     10              ;ah:= al/10; al:= remainder     25 011B  50                             push    ax              ;save low digit in remainder     26 011C  8A C4                          mov     al, ah          ;get high digit     27 011E  04 20                          add     al, 20h         ;if zero make it a space char     28 0120  84 E4                          test    ah, ah     29 0122  74 02                          je      d50     30 0124  04 10                           add    al, 10h         ;else make it into ASCII digit     31 0126  CD 29                  d50:    int     29h             ;output high digit or space     32 0128  58                             pop     ax              ;get low digit     33 0129  04 30                          add     al, 30h         ;make it ASCII     34 012B  CD 29                          int     29h             ;output low digit     35     36 012D  B0 20                          mov     al, 20h         ;output space char     37 012F  CD 29                          int     29h     38     39 0131  8A C7                          mov     al, bh          ;if remainder(N/10) = 0 then CR LF     40 0133  D4 0A                          aam     10              ;ah:= al/10; al:= remainder     41 0135  3C 00                          cmp     al, 0     42 0137  75 08                          jne     next     43 0139  B0 0D                           mov    al, 0Dh         ;CR     44 013B  CD 29                           int    29h     45 013D  B0 0A                           mov    al, 0Ah         ;LF     46 013F  CD 29                           int    29h     47     48 0141  FE C7                  next:   inc     bh              ;next N     49 0143  80 FF 64                       cmp     bh, 100     50 0146  7E BA                          jle     d10     51 0148  C3                             ret     52     53                                      end     start `
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```

## XPL0

`int N, D;[for N:= 1 to 100 do    [D:= if N=1 then 1 else N/2;    while rem(N/D) do D:= D-1;    if D<10 then ChOut(0, ^ );    IntOut(0, D);    if rem(N/10) = 0 then CrLf(0) else ChOut(0, ^ );    ];]`
Output:
``` 1  1  1  2  1  3  1  4  3  5
1  6  1  7  5  8  1  9  1 10
7 11  1 12  5 13  9 14  1 15
1 16 11 17  7 18  1 19 13 20
1 21  1 22 15 23  1 24  7 25
17 26  1 27 11 28 19 29  1 30
1 31 21 32 13 33  1 34 23 35
1 36  1 37 25 38 11 39  1 40
27 41  1 42 17 43 29 44  1 45
13 46 31 47 19 48  1 49 33 50
```