Largest proper divisor of n: Difference between revisions
Not a robot (talk | contribs) (Add PL/I) |
|||
Line 1,114: | Line 1,114: | ||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
||
<!--</lang>--> |
<!--</lang>--> |
||
=={{header|PL/I}}== |
|||
<lang pli>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;</lang> |
|||
{{out}} |
|||
<pre> 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</pre> |
|||
=={{header|PL/M}}== |
=={{header|PL/M}}== |
Revision as of 13:26, 8 September 2021
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
- a(1) = 1; for n > 1, a(n) = largest proper divisor of n, where n < 101 .
ALGOL 68
<lang algol68>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 ) ) FI
OD </lang>
- 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
<lang algolw>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.</lang>
- 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
<lang apl>(⌈/1,(⍸0=¯1↓⍳|⊢))¨10 10⍴⍳100</lang>
- 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
<lang applescript>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 1
end 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 output
end task
task(100)</lang>
- Output:
<lang applescript>"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 "</lang>
Functional
Composing functionally, for rapid drafting and refactoring, with higher levels of code reuse:
<lang applescript>use framework "Foundation"
LARGEST PROPER DIVISOR OF N --------------
-- maxProperDivisors :: Int -> Int on 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 if
end 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 -> c
on compose(f, g)
script property mf : mReturn(f) property mg : mReturn(g) on |λ|(x) mf's |λ|(mg's |λ|(x)) end |λ| end script
end 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 if
end 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 tell
end find
-- justifyRight :: Int -> Char -> String -> String
on 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 script
end 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 tell
end map
-- maximum :: Ord a => [a] -> a
on 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 if
end 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 -> String
on 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 xs
end 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 if
end splitAt
-- sqrt :: Num -> (Num | missing value)
on sqrt(n)
if 0 ≤ n then n ^ (1 / 2) else missing value end if
end sqrt
-- str :: a -> String
on str(x)
x as string
end str
-- unlines :: [String] -> String
on 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 s
end unlines
-- until :: (a -> Bool) -> (a -> a) -> a -> a
on |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 v
end |until|
-- unwords :: [String] -> String
on 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 s
end unwords
-- unwrap :: NSValue -> a
on 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 if
end unwrap</lang>
- 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
<lang AWK>
- syntax: GAWK -f LARGEST_PROPER_DIVISOR_OF_N.AWK
- converted from C
BEGIN {
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) } }
} </lang>
- 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
<lang basic>10 DEFINT A-Z 20 FOR I=1 TO 100 30 IF I=1 THEN PRINT " 1";: GOTO 70 40 FOR J=I-1 TO 1 STEP -1 50 IF I MOD J=0 THEN PRINT USING "###";J;: GOTO 70 60 NEXT J 70 IF I MOD 10=0 THEN PRINT 80 NEXT I</lang>
- 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
<lang BASIC256>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 print next i end</lang>
BCPL
<lang 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') $)</lang>
- 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
<lang 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;
}</lang>
- 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++
<lang cpp>#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' : ' '); }
}</lang>
- 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
<lang 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;</lang>
- 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#
<lang fsharp> // Largest proper divisor of n: Nigel Galloway. June 2nd., 2021 let 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 "" </lang>
- 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
<lang factor>USING: grouping kernel math math.bitwise math.functions math.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.</lang>
- 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
<lang focal>01.10 F N=1,100;D 2;D 3 01.20 Q
02.10 S V=1 02.20 I (1-N)2.3;R 02.30 S V=N-1 02.40 S A=N/V 02.50 I (FITR(A)-A)2.6;R 02.60 S V=V-1 02.70 G 2.4
03.10 T %2,V 03.20 S A=N/10 03.30 I (FITR(A)-A)3.4;T ! 03.40 R</lang>
- 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
<lang forth>: 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 ;
main bye</lang>
- 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
<lang 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</lang>
- 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
<lang 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 Print
Next i Sleep</lang>
- 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
<lang 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() } }
}</lang>
- 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
Haskell
<lang haskell>import Data.List.Split (chunksOf) import Text.Printf (printf)
lpd :: Int -> Int lpd 1 = 1 lpd 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]</lang>
- 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).
<lang haskell>import Data.List (find) import Data.List.Split (chunksOf) import Text.Printf (printf)
maxProperDivisors :: Int -> Int maxProperDivisors 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]</lang>
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
<lang j> lpd =: (1 |.!.1 ])&.q:</lang>
- 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: <lang jq># (1|largestpd) is 1 as per the task definition def largestpd:
if . == 1 then 1 else . as $n | first( range( ($n - ($n % 2)) /2; 0; -1) | (select($n % . == 0) )) end;</lang>
Slightly less naive: <lang jq>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;</lang>
<lang jq># For neatness def 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(" ")</lang>
- 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
<lang 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)
</lang>
- 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
MAD
<lang MAD> 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.1
TEST WHENEVER N/D*D.E.N, FUNCTION RETURN D
END OF FUNCTION THROUGH SHOW, FOR I=1, 10, I.GE.100
SHOW 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 </lang>
- 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
<lang Mathematica>Last[Prepend[DeleteCases[Divisors[#], #], 1]] & /@ Range[100]</lang>
- 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
<lang 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: ' '</lang>
- 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
<lang 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..10 var
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.</lang>
- 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
<lang perl>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";
}</lang>
- 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
<lang pli>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;</lang>
- 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
<lang plm>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</lang>
- 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
<lang 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 )</lang>
- 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:
<lang python>Largest proper divisor of
from math import isqrt
- maxProperDivisors :: Int -> Int
def 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()</lang>
- 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.
<lang Quackery>' [ 1 ] 99 times
[ i^ 2 + factors -2 peek join ]
echo</lang>
- 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. <lang perl6>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");
}</lang>
- 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.
This addition made it about 75% faster. <lang rexx>/*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 < " n idx = 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.*/</lang>
- 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
<lang ring> see "working..." + nl see "Largest proper divisor of n are:" + nl see "1 " row = 1 limit = 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 ok
next
see "done..." + nl </lang>
- 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
<lang 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} </lang>
- 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
<lang 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;</lang>
- 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
<lang 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" : " ")
}</lang>
- 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
<lang qbasic>PRINT "El mayor divisor propio de n es:" PRINT PRINT " 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 PRINT
NEXT i END</lang>
- Output:
Igual que la entrada de FreeBASIC.
Wren
<lang ecmascript>import "/math" for Int import "/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()
}</lang>
- 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
<lang yabasic>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 : fi
next i print end</lang>
- Output:
Igual que la entrada de FreeBASIC.
X86 Assembly
<lang asm> 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
</lang>
- 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
<lang 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, ^ ); ];
]</lang>
- 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
- Programming Tasks
- Solutions by Programming Task
- ALGOL 68
- ALGOL W
- APL
- AppleScript
- AWK
- BASIC
- BASIC256
- BCPL
- C
- C++
- Cowgol
- F Sharp
- Factor
- FOCAL
- Forth
- Fortran
- FreeBASIC
- Go
- Haskell
- J
- Jq
- Julia
- MAD
- Mathematica
- Wolfram Language
- Nim
- Pascal
- Perl
- Ntheory
- Phix
- PL/I
- PL/M
- Python
- Quackery
- Raku
- REXX
- Ring
- Ruby
- Seed7
- Swift
- True BASIC
- Wren
- Wren-math
- Wren-fmt
- Yabasic
- X86 Assembly
- XPL0