Largest proper divisor of n: Difference between revisions
m
→{{header|Wren}}: Minor tidy
No edit summary |
m (→{{header|Wren}}: Minor tidy) |
||
(37 intermediate revisions by 18 users not shown) | |||
Line 7:
{{trans|Python}}
<
L(i) (n - 1 .< 0).step(-1)
I n % i == 0
Line 14:
L(i) 1..100
print(‘#3’.format(lpd(i)), end' I i % 10 == 0 {"\n"} E ‘’)</
{{out}}
Line 31:
=={{header|Ada}}==
<
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
Line 55:
end if;
end loop;
end Main;</
{{out}}
<pre>
Line 71:
=={{header|ALGOL 68}}==
<
INT largest proper divisor := 1;
FOR j FROM ( n OVER 2 ) BY -1 TO 2 WHILE largest proper divisor = 1 DO
Line 81:
IF n MOD 10 = 0 THEN print( ( newline ) ) FI
OD
</syntaxhighlight>
{{out}}
<pre>
Line 97:
=={{header|ALGOL W}}==
<
for j := n div 2 step -1 until 2 do begin
if n rem j = 0 then begin
Line 107:
foundLargestProperDivisor:
if n rem 10 = 0 then write()
end for_n.</
{{out}}
<pre>
Line 124:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 140:
Most of this code is just to prepare the output for display. :D
<
if (n mod 2 = 0) then return n div 2
if (n mod 3 = 0) then return n div 3
Line 179:
end task
task(100)</
{{output}}
<
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
Line 191:
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 "</
Line 198:
Composing functionally, for rapid drafting and refactoring, with higher levels of code reuse:
<
Line 446:
item 1 of ((ca's NSArray's arrayWithObject:nsValue) as list)
end if
end unwrap</
{{Out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 461:
=={{header|Arturo}}==
<
print map to [:string] row 'r -> pad r 5
]</
{{out}}
Line 479:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f LARGEST_PROPER_DIVISOR_OF_N.AWK
# converted from C
Line 501:
}
}
</syntaxhighlight>
{{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
Line 515 ⟶ 514:
13 46 31 47 19 48 1 49 33 50
Largest proper divisor of n 1-100</pre>
=={{header|BASIC}}==
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="basic">10 DEFINT A-Z
20 FOR I=1 TO 100
30 IF I=1 THEN PRINT " 1";: GOTO 70
Line 526:
60 NEXT J
70 IF I MOD 10=0 THEN PRINT
80 NEXT I</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 539:
13 46 31 47 19 48 1 49 33 50</pre>
==={{header|
{{trans|FreeBASIC}}
{{works with|Decimal BASIC}}
{{works with|IS-BASIC}}
<syntaxhighlight lang="basic">
100 REM Largest proper divisor of n
110 PRINT "The largest proper divisor of n is:"
120 PRINT
130 PRINT USING " ## ##": 1, 1;
140 FOR I = 3 TO 100
150 FOR J = I - 1 TO 1 STEP -1
160 IF MOD(I, J) = 0 THEN
170 PRINT USING "###": J;
180 EXIT FOR
190 END IF
200 NEXT J
210 IF MOD(I, 10) = 0 THEN PRINT
220 NEXT I
230 END
</syntaxhighlight>
{{out}}
<pre>
The largest proper divisor of n is:
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|Applesoft BASIC}}===
{{works with|Quite BASIC}}
Solution [[#Quite_BASIC|Quite BASIC]] work without changes.
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">print "El mayor divisor propio de n es:\n"
print " 1 1 ";
for i = 3 to 100
Line 552 ⟶ 592:
if i % 10 = 0 then print
next i
end</
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">10 print "El mayor divisor propio de n es:"
20 print chr$(10)+" 1 1";
30 for i = 3 to 100
40 for j = i-1 to 1 step -1
50 if i mod j = 0 then print using "###";j; : exit for
60 next j
70 if i mod 10 = 0 then print
80 next i
90 end</syntaxhighlight>
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">print "Largest proper divisor of n is:"
print tab, "1", tab, "1",
for i = 3 to 100
for j = i - 1 to 1 step -1
if i mod j = 0 then
print tab, j,
break j
endif
wait
next j
if i mod 10 = 0 then
print
endif
next i</syntaxhighlight>
{{out| Output}}<pre>
Largest proper divisor of n is:
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|FreeBASIC}}===
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>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</pre>
==={{header|FutureBasic}}===
<syntaxhighlight lang="futurebasic">NSUInteger i, j
print " 1 1";
for i = 3 to 100
for j = i - 1 to 1 step - 1
if i mod j = 0 then print using "###"; j; : exit for
next
if i mod 10 = 0 then print
next
HandleEvents</syntaxhighlight>
{{output}}
<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|GW-BASIC}}===
<syntaxhighlight lang="gwbasic">10 PRINT 1;
20 FOR I = 1 TO 101
30 FOR D = I\2 TO 1 STEP -1
40 IF I MOD D = 0 THEN PRINT D; : GOTO 60
50 NEXT D
60 NEXT I</syntaxhighlight>
==={{header|Gambas}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vbnet">Public Sub Main()
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 Format$(j, "###");
Break
End If
Next
If i Mod 10 = 0 Then Print
Next
End</syntaxhighlight>
==={{header|Minimal BASIC}}===
{{works with|BASICA}}
{{trans|FreeBASIC}}
{{works with|IS-BASIC}}
<syntaxhighlight lang="qbasic">100 PRINT "El mayor divisor propio de n es:"
110 PRINT
120 PRINT " 1 1 ";
130 FOR i = 3 TO 100
140 FOR j = i-1 TO 1 STEP -1
150 IF i-INT(i/j)*j = 0 THEN 200
160 NEXT j
170 IF i-INT(i/10)*10 = 0 THEN 220
180 NEXT i
190 GOTO 240
200 PRINT j;
210 GOTO 170
220 PRINT
230 GOTO 180
240 END</syntaxhighlight>
==={{header|MSX Basic}}===
{{works with|MSX BASIC|any}}
{{works with|GW-BASIC}}
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">10 PRINT "El mayor divisor propio de n es:"
20 PRINT CHR$(10) + " 1 1";
30 FOR I = 3 TO 100
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
90 END</syntaxhighlight>
==={{header|Palo Alto Tiny BASIC}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic">
10 REM LARGEST PROPER DIVISOR OF N
20 PRINT "THE LARGEST PROPER DIVISOR OF N IS:"
30 PRINT;PRINT #3,1,1,
40 FOR I=3 TO 100
50 FOR J=I-1 TO 1 STEP -1
60 IF I=(I/J)*J PRINT #3,J,;GOTO 80
70 NEXT J
80 IF I=(I/10)*10 PRINT
90 NEXT I
100 STOP
</syntaxhighlight>
{{out}}
<pre>
THE LARGEST PROPER DIVISOR OF N IS:
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|PureBasic}}===
<syntaxhighlight lang="purebasic">Procedure.i lpd(v.i)
For i=v/2 To 1 Step -1
If v%i=0 : ProcedureReturn i : EndIf
Next
ProcedureReturn 1
EndProcedure
If OpenConsole("")
For i=1 To 100
Print(RSet(Str(lpd(i)),3))
If i%10=0 : PrintN("") : EndIf
Next
Input()
EndIf</syntaxhighlight>
{{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|Quite BASIC}}===
{{works with|Applesoft BASIC}}
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">100 PRINT "El mayor divisor propio de n es:"
110 PRINT : PRINT " 1 1";
120 FOR i = 3 TO 100
130 FOR j = i-1 TO 1 STEP -1
140 LET a = i-INT(i/j)*j
150 IF a = 0 THEN GOTO 210
160 IF a = 0 THEN GOTO 180
170 NEXT j
180 IF i-INT(i/10)*10 = 0 THEN PRINT
190 NEXT i
200 END
210 IF j < 10 THEN PRINT " "; j;
220 IF j >= 10 THEN PRINT " "; j;
230 GOTO 160</syntaxhighlight>
==={{header|Run BASIC}}===
<syntaxhighlight lang="vbnet">print "Largest proper divisor of n is:"
print chr$(10)+" 1 1";
for i = 3 to 100
for j = i-1 to 1 step -1
if i mod j = 0 then print using("###",j); : goto [exit]
next j
[exit]
if i mod 10 = 0 then print
next i
end</syntaxhighlight>
==={{Header|Tiny BASIC}}===
<syntaxhighlight lang="qbasic">REM Rosetta Code problem: https://rosettacode.org/wiki/Largest_proper_divisor_of_n
REM by Jjuanhdez, 05/2023
REM Largest proper divisor of n
PRINT "El mayor divisor propio de n es:"
PRINT ""
PRINT "1"
PRINT "1"
LET I = 3
10 IF I = 101 THEN GOTO 40
LET J = I-1
20 IF J = 0 THEN GOTO 30
LET A = I-(I/J)*J
IF A = 0 THEN PRINT J
IF A = 0 THEN GOTO 30
LET J = J-1
GOTO 20
30 IF I-(I/10)*10 = 0 THEN PRINT ""
LET I = I+1
GOTO 10
40 END
</syntaxhighlight>
==={{header|True BASIC}}===
{{trans|FreeBASIC}}
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">PROGRAM "progname"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
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 MOD j = 0 THEN
PRINT FORMAT$("###", j);
EXIT FOR
END IF
NEXT j
IF i MOD 10 = 0 THEN PRINT
NEXT i
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
=={{header|BCPL}}==
<
let lpd(n) = valof
Line 566 ⟶ 934:
$( writed(lpd(i), 3)
if i rem 10=0 then wrch('*N')
$)</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 580 ⟶ 948:
=={{header|BQN}}==
<
{{out}}
<pre>┌─
Line 596 ⟶ 964:
=={{header|C}}==
<
unsigned int lpd(unsigned int n) {
Line 612 ⟶ 980:
}
return 0;
}</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 626 ⟶ 994:
=={{header|C++}}==
<
#include <iomanip>
#include <iostream>
Line 646 ⟶ 1,014:
<< (n % 10 == 0 ? '\n' : ' ');
}
}</
{{out}}
Line 663 ⟶ 1,031:
=={{header|Cowgol}}==
<
sub print3(n: uint8) is
Line 696 ⟶ 1,064:
end if;
i := i + 1;
end loop;</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 708 ⟶ 1,076:
27 41 1 42 17 43 29 44 1 45
13 46 31 47 19 48 1 49 33 50</pre>
=={{header|D}}==
{{trans|C}}
<syntaxhighlight lang="d">
import std.stdio;
import std.range;
import std.algorithm;
uint lpd(uint n) {
if (n <= 1) {
return 1;
}
auto divisors = array(iota(1, n).filter!(i => n % i == 0));
return divisors.empty ? 1 : divisors[$ - 1];
}
void main() {
foreach (i; 1 .. 101) {
writef("%3d", lpd(i));
if (i % 10 == 0) {
writeln();
}
}
}
</syntaxhighlight>
{{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|Dart}}==
<syntaxhighlight lang="dart">
import "dart:io";
num 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;
}
void main() {
print("El mayor divisor propio de n es:");
for (int n = 1; n < 101; ++n) {
stdout.write(largest_proper_divisor(n));
print(largest_proper_divisor(n) + n % 10 == 0 ? "\n" : " ");
}
}
</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
function FindProperDivisor(N: Integer): integer;
{Find the highest proper divisor}
{i.e. The highest number that evenly divides in N}
begin
if N=1 then Result:=1
else for Result:=N-1 downto 1 do
if (N mod Result)=0 then break;
end;
procedure AllProperDivisors(Memo: TMemo);
{Show all proper divisors for number 1..100}
var I: integer;
var S: string;
begin
S:='';
for I:=1 to 100 do
begin
S:=S+Format('%3d',[FindProperDivisor(I)]);
if (I mod 10)=0 then S:=S+#$0D#$0A;
end;
Memo.Text:=S;
end;
</syntaxhighlight>
{{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|Draco}}==
<
word d;
if n=1 then
Line 727 ⟶ 1,211:
if n%10 = 0 then writeln() fi
od
corp</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 739 ⟶ 1,223:
27 41 1 42 17 43 29 44 1 45
13 46 31 47 19 48 1 49 33 50</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
func lpdiv v .
r = 1
for i = 2 to v div 2
if v mod i = 0
r = i
.
.
return r
.
for i = 1 to 100
write lpdiv i & " "
.
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<
// 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 ""
</syntaxhighlight>
{{out}}
<pre>
Line 754 ⟶ 1,254:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<
math.ranges prettyprint sequences ;
Line 763 ⟶ 1,263:
: largest ( m -- n ) dup odd? [ odd ] [ 2/ ] if ;
100 [1,b] [ largest ] map 10 group simple-table.</
{{out}}
<pre>
Line 779 ⟶ 1,279:
=={{header|Fermat}}==
<
if n = 1 then Return(1) fi;
for i = n\2 to 1 by -1 do
Line 788 ⟶ 1,288:
!(Lpd(m):4);
if m|10=0 then ! fi;
od;</
{{out}}<pre>
1 1 1 2 1 3 1 4 3 5
Line 803 ⟶ 1,303:
=={{header|FOCAL}}==
<
01.20 Q
Line 817 ⟶ 1,317:
03.20 S A=N/10
03.30 I (FITR(A)-A)3.4;T !
03.40 R</
{{out}}
<pre>= 1= 1= 1= 2= 1= 3= 1= 4= 3= 5
Line 832 ⟶ 1,332:
=={{header|Forth}}==
{{works with|Gforth}}
<
n 1 and 0= if n 2/ exit then
3
Line 850 ⟶ 1,350:
main
bye</
{{out}}
Line 867 ⟶ 1,367:
=={{header|Fortran}}==
<
implicit none
integer i, lpd
Line 885 ⟶ 1,385:
20 lpd = i
end if
end function</
{{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
Line 926 ⟶ 1,401:
Frink contains efficient routines for factoring numbers. It uses trial division, wheel factoring, and Pollard rho factoring.
<
println[last[allFactors[n,true,false]]]</
=={{header|Go}}==
<
import "fmt"
Line 956 ⟶ 1,431:
}
}
}</
{{out}}
Line 972 ⟶ 1,447:
13 46 31 47 19 48 1 49 33 50
</pre>
=={{header|Haskell}}==
<
import Text.Printf (printf)
Line 992 ⟶ 1,459:
main =
(putStr . unlines . map concat . chunksOf 10) $
printf "%3d" . lpd <$> [1 .. 100]</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,011 ⟶ 1,478:
(Otherwise, the largest proper divisor will be 1 itself).
<
import Data.List.Split (chunksOf)
import Text.Printf (printf)
Line 1,026 ⟶ 1,493:
main =
(putStr . unlines . map concat . chunksOf 10) $
printf "%3d" . maxProperDivisors <$> [1 .. 100]</
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,040 ⟶ 1,507:
=={{header|J}}==
<syntaxhighlight lang
{{out}}
<pre>
lpd
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>
This works by prime factorization of n,
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.
=={{header|Java}}==
<syntaxhighlight lang="java">
public final class LargestProperDivisor {
public static void main(String[] aArgs) {
for ( int n = 1; n < 101; n++ ) {
System.out.print(String.format("%2d%s", largestProperDivisor(n), ( n % 10 == 0 ? "\n" : " " )));
}
}
private static int largestProperDivisor(int aNumber) {
if ( aNumber < 1 ) {
throw new IllegalArgumentException("Argument must be >= 1: " + aNumber);
}
if ( ( aNumber & 1 ) == 0 ) {
return aNumber >> 1;
}
for ( int p = 3; p * p <= aNumber; p += 2 ) {
if ( aNumber % p == 0 ) {
return aNumber / p;
}
}
return 1;
}
}
</syntaxhighlight>
{{ 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|jq}}==
Line 1,056 ⟶ 1,570:
Naive version:
<
def largestpd:
if . == 1 then 1
else . as $n
| first( range( ($n - ($n % 2)) /2; 0; -1) | (select($n % . == 0) ))
end;</
Slightly less naive:
<
if . == 1 then 1
else . as $n
Line 1,071 ⟶ 1,585:
else first( range( ($n - ($n % 11)) /11; 0; -1) | (select($n % . == 0) ))
end
end;</
<
def lpad($len):
tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
Line 1,082 ⟶ 1,596:
### The task
[range(1; 101) | largestpd]
| nwise(10) | map(lpad(2)) | join(" ")</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,096 ⟶ 1,610:
=={{header|Julia}}==
<
foreach(n -> print(rpad(largestpd(n), 3), n % 10 == 0 ? "\n" : ""), 1:100)
</
<pre>
1 1 1 2 1 3 1 4 3 5
Line 1,111 ⟶ 1,625:
27 41 1 42 17 43 29 44 1 45
13 46 31 47 19 48 1 49 33 50
</pre>
=={{header|Lua}}==
{{Trans|ALGOL 68}}
<syntaxhighlight lang="lua">
for n = 1, 100 do -- show the largest proper divisors for n = 1..100
local largestProperDivisor, j = 1, math.floor( n / 2 )
while j >= 2 and largestProperDivisor == 1 do
if n % j == 0 then
largestProperDivisor = j
end
j = j - 1
end
io.write( string.format( "%3d", largestProperDivisor ) )
if n % 10 == 0 then io.write( "\n" ) end
end
</syntaxhighlight>
{{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|MAD}}==
<
INTERNAL FUNCTION(N)
Line 1,130 ⟶ 1,673:
VECTOR VALUES TABLE = $10(I3)*$
END OF PROGRAM </
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,144 ⟶ 1,687:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
{{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|Maxima}}==
<syntaxhighlight lang="maxima">
lpd(n):=if n=1 then 1 else listify(divisors(n))[length(divisors(n))-1]$
makelist(lpd(i),i,100);
</syntaxhighlight>
{{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|Modula-2}}==
<
FROM InOut IMPORT WriteCard, WriteLn;
Line 1,175 ⟶ 1,729:
END;
END;
END LargestProperDivisor.</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,189 ⟶ 1,743:
=={{header|Nim}}==
<
func largestProperDivisor(n: Positive): int =
Line 1,197 ⟶ 1,751:
for n in 1..100:
stdout.write ($n.largestProperDivisor).align(2), if n mod 10 == 0: '\n' else: ' '</
{{out}}
Line 1,212 ⟶ 1,766:
=={{header|Pascal}}==
<
program LarPropDiv;
Line 1,241 ⟶ 1,795:
Writeln;
end;
end.</
{{out}}
<pre>
Line 1,254 ⟶ 1,808:
27 41 1 42 17 43 29 44 1 45
13 46 31 47 19 48 1 49 33 50</pre>
===Alternative (sieve)===
Most solutions use a function that returns the largest proper divisor of an individual integer. This console program, written in Free Pascal, applies a sieve to the integers 1..100 (or other limit).
<syntaxhighlight lang="pascal">
program LPD;
(*
Displays largest proper divisor for each integer in range 1..limit.
Command line:
LPD limit items_per_line
or LPD limit // items_per_line defaults to 10
or LPD // limit defaults to 100
*)
{$mode objfpc}{$H+}
uses SysUtils;
var
limit, items_per_line, nr_items, j, p : integer;
a : array of integer;
begin
// Set up defaults
limit := 100;
items_per_line := 10;
// Overwrite defaults with command-line parameters, if present
if ParamCount > 0 then
limit := SysUtils.StrToInt( ParamStr(1));
if ParamCount > 1 then
items_per_line := SysUtils.StrToInt( ParamStr(2));
WriteLn( 'Largest proper divisors 1..', limit);
// Dynamic arrays are 0-based. To keep it simple, we ignore a[0]
// and use a[j] for the integer j, 1 <= j <= limit
SetLength( a, limit + 1);
for j := 1 to limit do a[j] := 1; // stays at 1 if j is 1 or prime
// Sieve; if j is composite then a[j] := smallest prime factor of j
p := 2; // p = next prime
while p*p < limit do begin
j := 2*p;
while j <= limit do begin
if a[j] = 1 then a[j] := p;
inc( j, p);
end;
repeat
inc(p);
until (p > limit) or (a[p] = 1);
end;
// If j is composite, divide j by its smallest prime factor
for j := 1 to limit do
if a[j] > 1 then a[j] := j div a[j];
// Write the array to the console
nr_items := 0;
for j := 1 to limit do begin
Write( a[j]:5);
inc( nr_items);
if nr_items = items_per_line then begin
WriteLn;
nr_items := 0;
end;
end;
if nr_items > 0 then WriteLn;
end.
</syntaxhighlight>
{{out}}
<pre>
Largest proper divisors 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
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use ntheory 'divisors';
Line 1,275 ⟶ 1,905:
while( my @batch = $iter->() ) {
printf '%3d', $_ == 1 ? 1 : max proper_divisors($_) for @batch; print "\n";
}</
{{out}}
<pre>GPD for 1 through 100:
Line 1,290 ⟶ 1,920:
=={{header|Phix}}==
<!--<
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"%3d"</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">vslice</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">),-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}),</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)}),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">))</span>
<!--</
{{out}}
<pre>
Line 1,307 ⟶ 1,937:
</pre>
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.
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span>
Line 1,323 ⟶ 1,953:
<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;">10</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\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;">for</span>
<!--</
=={{header|Picat}}==
<syntaxhighlight lang="picat">main =>
foreach(I in 1..100)
printf("%2d%s",a(I), cond(I mod 10 == 0,"\n", " "))
end.
a(1) = 1.
a(N) = Div =>
a(N,N//2,Div).
a(N,I,I) :-
N mod I == 0.
a(N,I,Div) :-
a(N,I-1,Div).</syntaxhighlight>
{{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/I}}==
<
lpd: procedure(n) returns(fixed);
declare (n, i) fixed;
Line 1,340 ⟶ 1,997:
if mod(i,10)=0 then put skip;
end;
end largestProperDivisor;</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,354 ⟶ 2,011:
=={{header|PL/M}}==
<
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
Line 1,385 ⟶ 2,042:
END;
CALL EXIT;
EOF</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,426 ⟶ 2,056:
=={{header|Python}}==
<
for i in range(n-1,0,-1):
if n%i==0: return i
Line 1,432 ⟶ 2,062:
for i in range(1,101):
print("{:3}".format(lpd(i)), end=i%10==0 and '\n' or '')</
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,448 ⟶ 2,078:
Or, reducing the search space, formatting more flexibly (to allow for experiments with larger ranges) and composing functionally:
<
from math import isqrt
Line 1,519 ⟶ 2,149:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,535 ⟶ 2,165:
<code>factors</code> is defined at [http://rosettacode.org/wiki/Factors_of_an_integer#Quackery Factors of an integer].
<
[ i^ 2 + factors
-2 peek join ]
echo</
{{out}}
Line 1,545 ⟶ 2,175:
=={{header|R}}==
<
if(n == 1) return(1)
Line 1,563 ⟶ 2,193:
largest_proper_divisor(i)
}
</syntaxhighlight>
{{out}}
Line 1,591 ⟶ 2,221:
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.
<syntaxhighlight lang="raku"
for 0, 2**67 - 1 -> $add {
Line 1,604 ⟶ 2,234:
say (now - $start).fmt("%0.3f seconds\n");
}</
{{out}}
<pre>GPD for 1 through 100:
Line 1,636 ⟶ 2,266:
This addition made it about '''75%''' faster.
<
parse arg n cols . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n= 101 /*Not specified? Then use the default.*/
Line 1,662 ⟶ 2,292:
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.*/</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,681 ⟶ 2,311:
=={{header|Ring}}==
<
limit = 100
? "Largest proper divisor up to " + limit + " are:"
Line 1,695 ⟶ 2,325:
if col++ % 10 = 0 ? "" ok
next
? "done..."</
{{out}}
<pre>working...
Line 1,710 ⟶ 2,340:
13 46 31 47 19 48 1 49 33 50
done...</pre>
=={{header|RPL}}==
≪ '''IF''' DUP 1 ≠ '''THEN''' DUP '''DO''' 1 - '''UNTIL''' DUP2 MOD NOT '''END''' SWAP DROP '''END''' ≫ '<span style="color:blue">LPROPDIV</span>' STO
≪ { } 1 100 '''FOR''' j j <span style="color:blue">LPROPDIV</span> + '''NEXT''' ≫ EVAL
{{out}}
<pre>
1: { 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|Rust}}==
{{trans|Go}}
<syntaxhighlight lang="rust">
fn largest_proper_divisor(n: i32) -> i32 {
for i in 2..=(n as f64).sqrt() as i32 {
if n % i == 0 {
return n / i;
}
}
}
fn main() {
println!("The largest proper divisors for numbers in the interval [1, 100] are:");
print!(" 1 ");
for n in 2..=100 {
if n % 2 == 0 {
print!("{:2} ", n / 2);
} else {
print!("{:2} ", largest_proper_divisor(n));
}
if n % 10 == 0 {
println!();
}
}
}
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
{{trans|C}}
<syntaxhighlight lang="rust">
fn lpd(n: u32) -> u32 {
if n <= 1 {
1
} else {
(1..n).rev().find(|&i| n % i == 0).unwrap_or(1)
}
}
fn main() {
for i in 1..=100 {
print!("{:3}", lpd(i));
if i % 10 == 0 {
println!();
}
}
}
</syntaxhighlight>
{{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|Ruby}}==
<
def a(n)
Line 1,720 ⟶ 2,440:
(1..100).map{|n| a(n).to_s.rjust(3)}.each_slice(10){|slice| puts slice.join}
</syntaxhighlight>
{{out}}
<pre> 1 1 1 2 1 3 1 4 3 5
Line 1,735 ⟶ 2,455:
=={{header|Seed7}}==
<
const func integer: largestProperDivisor (in integer: number) is func
Line 1,766 ⟶ 2,486:
end if;
end for;
end func;</
{{out}}
<pre>
Line 1,779 ⟶ 2,499:
27 41 1 42 17 43 29 44 1 45
13 46 31 47 19 48 1 49 33 50
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">1..100 -> map {|n| proper_divisors(n).tail \\ 1 }.slices(10).each {|a|
a.map{ '%3s' % _ }.join(' ').say
}</syntaxhighlight>
{{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|Swift}}==
<
func largestProperDivisor(_ n : Int) -> Int? {
Line 1,804 ⟶ 2,542:
print(String(format: "%2d", largestProperDivisor(n)!),
terminator: n % 10 == 0 ? "\n" : " ")
}</
{{out}}
Line 1,821 ⟶ 2,559:
=={{header|
TI-57 calculators could display only one number at a time. The program below pauses almost a second to show the largest proper divisor of each integer between 1 and 100 - which would take 6 or 7 minutes on a genuine machine - then displays <code>0</code> and stops.
{| class="wikitable"
! Machine code
! Comment
|-
|
Lbl 0
1
STO 0
Lbl 1
RCL 0
SBR 9
Pause
1
SUM 0
100
x⮂t
RCL 0
INV x≥t
GTO 1
CLR
R/S
RST
Lbl 9
x⮂t
1
x⮂t
x=t
INV SBR
STO 1
STO 2
C.t
Lbl 8
1
INV SUM 2
RCL 1
/
RCL 2
-
CE
Int
=
INV x=t
GTO 8
RCL 2
INV SBR
|
program task()
r0 = 1
loop
get a(r0)
display a(r0)
r0 += 1
t = 100
while r0 < t
end loop
clear display
end program
subroutine a(x)
t = 1
if x = t
return x
r1 = x
r2 = x
t = 0
loop
r2 -= 1
get r1
get r1/r2
get int(r1/r2)
get mod(r1,r2)
while mod(r1,r2) <> 0
end loop
return r2
end subroutine
|}
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">fn largest_proper_divisor(n int) int {
for i := 2; i*i <= n; i++ {
if n%i == 0 {
Line 1,865 ⟶ 2,673:
}
}
}</
{{out}}
Line 1,881 ⟶ 2,689:
13 46 31 47 19 48 1 49 33 50
</pre>
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
System.print("The largest proper divisors for numbers in the interval [1, 100] are:")
Line 1,898 ⟶ 2,705:
}
if (n % 10 == 0) System.print()
}</
{{out}}
<pre>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
Line 1,912 ⟶ 2,718:
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|X86 Assembly}}==
<
2 0000 .model tiny
3 0000 .code
Line 1,988 ⟶ 2,774:
52
53 end start
</syntaxhighlight>
{{out}}
Line 2,005 ⟶ 2,791:
=={{header|XPL0}}==
<
[for N:= 1 to 100 do
[D:= if N=1 then 1 else N/2;
Line 2,013 ⟶ 2,799:
if rem(N/10) = 0 then CrLf(0) else ChOut(0, ^ );
];
]</
{{out}}
|