Largest proper divisor of n: Difference between revisions

{{trans|Python}}

L(i) (n - 1 .< 0).step(-1)

I n % i == 0

L(i) 1..100

{{out}}

=={{header|Ada}}==

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

end if;

end loop;

{{out}}

<pre>

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

INT largest proper divisor := 1;

FOR j FROM ( n OVER 2 ) BY -1 TO 2 WHILE largest proper divisor = 1 DO

IF n MOD 10 = 0 THEN print( ( newline ) ) FI

OD

{{out}}

<pre>

=={{header|ALGOL W}}==

for j := n div 2 step -1 until 2 do begin

if n rem j = 0 then begin

foundLargestProperDivisor:

if n rem 10 = 0 then write()

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

end task

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

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

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

item 1 of ((ca's NSArray's arrayWithObject:nsValue) as list)

end if

{{Out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|Arturo}}==

print map to [:string] row 'r -> pad r 5

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f LARGEST_PROPER_DIVISOR_OF_N.AWK

# converted from C

}

}

{{out}}

<pre>

=={{header|BASIC}}==

20 FOR I=1 TO 100

30 IF I=1 THEN PRINT " 1";: GOTO 70

60 NEXT J

70 IF I MOD 10=0 THEN PRINT

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

print " 1 1 ";

for i = 3 to 100

if i % 10 = 0 then print

next i

=={{header|BCPL}}==

let lpd(n) = valof

$( writed(lpd(i), 3)

if i rem 10=0 then wrch('*N')

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|BQN}}==

{{out}}

<pre>┌─

=={{header|C}}==

unsigned int lpd(unsigned int n) {

}

return 0;

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

#include <iomanip>

#include <iostream>

<< (n % 10 == 0 ? '\n' : ' ');

}

{{out}}

=={{header|Cowgol}}==

sub print3(n: uint8) is

end if;

i := i + 1;

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|Draco}}==

word d;

if n=1 then

if n%10 = 0 then writeln() fi

od

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

math.ranges prettyprint sequences ;

: largest ( m -- n ) dup odd? [ odd ] [ 2/ ] if ;

{{out}}

<pre>

=={{header|Fermat}}==

if n = 1 then Return(1) fi;

for i = n\2 to 1 by -1 do

!(Lpd(m):4);

if m|10=0 then ! fi;

{{out}}<pre>

1 1 1 2 1 3 1 4 3 5

=={{header|FOCAL}}==

01.20 Q

03.20 S A=N/10

03.30 I (FITR(A)-A)3.4;T !

{{out}}

<pre>= 1= 1= 1= 2= 1= 3= 1= 4= 3= 5

=={{header|Forth}}==

{{works with|Gforth}}

n 1 and 0= if n 2/ exit then

3

main

{{out}}

=={{header|Fortran}}==

implicit none

integer i, lpd

20 lpd = i

end if

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|FreeBASIC}}==

Print " 1 1";

For i As Byte = 3 To 100

If i Mod 10 = 0 Then Print

Next i

{{out}}

<pre>El mayor divisor propio de n es:

Frink contains efficient routines for factoring numbers. It uses trial division, wheel factoring, and Pollard rho factoring.

=={{header|Go}}==

import "fmt"

}

}

{{out}}

=={{header|GW-BASIC}}==

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

=={{header|Haskell}}==

import Text.Printf (printf)

main =

(putStr . unlines . map concat . chunksOf 10) $

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

import Data.List.Split (chunksOf)

import Text.Printf (printf)

main =

(putStr . unlines . map concat . chunksOf 10) $

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|J}}==

{{out}}

<pre>

Naive version:

def largestpd:

if . == 1 then 1

else . as $n

| first( range( ($n - ($n % 2)) /2; 0; -1) | (select($n % . == 0) ))

Slightly less naive:

if . == 1 then 1

else . as $n

else first( range( ($n - ($n % 11)) /11; 0; -1) | (select($n % . == 0) ))

end

def lpad($len):

tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

### The task

[range(1; 101) | largestpd]

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

=={{header|MAD}}==

INTERNAL FUNCTION(N)

VECTOR VALUES TABLE = $10(I3)*$

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{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|Modula-2}}==

FROM InOut IMPORT WriteCard, WriteLn;

END;

END;

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|Nim}}==

func largestProperDivisor(n: Positive): int =

for n in 1..100:

{{out}}

=={{header|Pascal}}==

program LarPropDiv;

Writeln;

end;

{{out}}

<pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use ntheory 'divisors';

while( my @batch = $iter->() ) {

printf '%3d', $_ == 1 ? 1 : max proper_divisors($_) for @batch; print "\n";

{{out}}

<pre>GPD for 1 through 100:

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

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

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

foreach(I in 1..100)

printf("%2d%s",a(I), cond(I mod 10 == 0,"\n", " "))

N mod I == 0.

a(N,I,Div) :-

{{out}}

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

lpd: procedure(n) returns(fixed);

declare (n, i) fixed;

if mod(i,10)=0 then put skip;

end;

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

END;

CALL EXIT;

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|PureBasic}}==

For i=v/2 To 1 Step -1

If v%i=0 : ProcedureReturn i : EndIf

Next

Input()

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|Python}}==

for i in range(n-1,0,-1):

if n%i==0: return i

for i in range(1,101):

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

from math import isqrt

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre> 1 1 1 2 1 3 1 4 3 5

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

{{out}}

=={{header|R}}==

if(n == 1) return(1)

largest_proper_divisor(i)

}

{{out}}

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.

for 0, 2**67 - 1 -> $add {

say (now - $start).fmt("%0.3f seconds\n");

{{out}}

<pre>GPD for 1 through 100:

This addition made it about &nbsp; '''75%''' &nbsp; faster.

parse arg n cols . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 101 /*Not specified? Then use the default.*/

if x//k==0 then return k /*Remainder=0? Got largest proper div.*/

end /*k*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

limit = 100

? "Largest proper divisor up to " + limit + " are:"

if col++ % 10 = 0 ? "" ok

next

{{out}}

<pre>working...

=={{header|Ruby}}==

def a(n)

(1..100).map{|n| a(n).to_s.rjust(3)}.each_slice(10){|slice| puts slice.join}

{{out}}

<pre> 1 1 1 2 1 3 1 4 3 5

=={{header|Seed7}}==

const func integer: largestProperDivisor (in integer: number) is func

end if;

end for;

{{out}}

<pre>

=={{header|Swift}}==

func largestProperDivisor(_ n : Int) -> Int? {

print(String(format: "%2d", largestProperDivisor(n)!),

terminator: n % 10 == 0 ? "\n" : " ")

{{out}}

=={{header|True BASIC}}==

{{trans|FreeBASIC}}

PRINT

PRINT " 1 1";

IF remainder(i, 10) = 0 Then PRINT

NEXT i

{{out}}

<pre>

=={{header|Vlang}}==

{{trans|go}}

for i := 2; i*i <= n; i++ {

if n%i == 0 {

}

}

{{out}}

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

}

if (n % 10 == 0) System.print()

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

print " 1 1 ";

for i = 3 to 100

next i

print

{{out}}

<pre>

=={{header|X86 Assembly}}==

2 0000 .model tiny

3 0000 .code

52

53 end start

{{out}}

=={{header|XPL0}}==

[for N:= 1 to 100 do

[D:= if N=1 then 1 else N/2;

if rem(N/10) = 0 then CrLf(0) else ChOut(0, ^ );

];

{{out}}