Factors of an integer: Difference between revisions
PascalABC.NET
m (→{{header|PL/M}}: Fixed link) |
(PascalABC.NET) |
||
(59 intermediate revisions by 31 users not shown) | |||
Line 29:
=={{header|0815}}==
<
<:1:~>|~#:end:>~x}:str:/={^:wei:~%x<:a:x=$~
=}:wei:x<:1:+{>~>x=-#:fin:^:str:}:fin:{{~%
</syntaxhighlight>
=={{header|11l}}==
{{trans|Python}}
<
V factors = Set[Int]()
L(x) 1..Int(sqrt(n))
Line 46:
L(i) (45, 53, 64)
print(i‘: factors: ’String(factor(i)))</
{{out}}
Line 57:
=={{header|360 Assembly}}==
Very compact version.
<
FACTOR CSECT
USING FACTOR,R15 set base register
Line 79:
PG DC CL132' ' buffer
YREGS
END FACTOR</
{{out}}
<pre>
Line 86:
=={{header|68000 Assembly}}==
<
Line 113:
;end of program</
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program factorst64.s */
Line 291:
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|ACL2}}==
<
(declare (xargs :measure (nfix (- n i))))
(cond ((zp (- n i))
Line 303:
(defun factors (n)
(factors-r n 1))</
=={{header|Action!}}==
<
BYTE notFirst
CARD p
Line 338:
Test(6502)
Test(12345)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Factors_of_an_integer.png Screenshot from Atari 8-bit computer]
Line 352:
=={{header|ActionScript}}==
<
{
var factors:Vector.<uint> = new Vector.<uint>();
Line 358:
if(n % i == 0)factors.push(i);
return factors;
}</
=={{header|Ada}}==
<
with Ada.Command_Line;
procedure Factors is
Line 382:
end loop;
Ada.Text_IO.Put_Line (Positive'Image (Number) & ".");
end Factors;</
=={{header|Aikido}}==
<
function factor (n:int) {
Line 418:
printvec (factor (45))
printvec (factor (25))
printvec (factor (100))</
=={{header|ALGOL 68}}==
Line 428:
Note: The following implements generators, eliminating the need of declaring arbitrarily long '''int''' arrays for caching.
<
PROC gen factors = (INT n, YIELDINT yield)VOID: (
Line 452:
# OD # ));
print(new line)
OD</
{{out}}
<pre>
Line 461:
=={{header|ALGOL W}}==
<
% return the factors of n ( n should be >= 1 ) in the array factor %
% the bounds of factor should be 0 :: len (len must be at least 1) %
Line 512:
for i := 1 until 100 do testFactorsOf( i )
end.</
{{out}}
<pre>
Line 529:
=={{header|ALGOL-M}}==
Instead of displaying 1 and the number itself as factors, prime numbers are explicitly reported as such. To reduce the number of test divisions, only odd divisors are tested if an initial check shows the number to be factored is not even. The upper limit of divisors is set at N/2 or N/3, depending on whether N is even or odd, and is continuously reduced to N divided by the next potential divisor until the first factor is found. For a prime number the resulting limit will be the square root of N, which avoids the necessity of explicitly calculating that value. (ALGOL-M does not have a built-in square root function.)
<
BEGIN
COMMENT RETURN P MOD Q;
INTEGER FUNCTION MOD (P, Q);
INTEGER P, Q;
Line 544 ⟶ 539:
END;
INTEGER I, N, LIMIT, FOUND, START, DELTA;
WHILE
BEGIN
WRITE ("
READ (N);
IF N = 0 THEN GOTO DONE;
WRITE ("THE FACTORS ARE:");
COMMENT CHECK WHETHER NUMBER IS EVEN OR ODD;
Line 567 ⟶ 563:
FOUND := 0;
I := START;
LIMIT := N /
WHILE I <= LIMIT DO
BEGIN
IF MOD(N, I) = 0 THEN
BEGIN
FOUND := FOUND + 1;
END;
Line 578 ⟶ 574:
IF FOUND = 0 THEN LIMIT := N / I;
END;
IF FOUND = 0 THEN WRITEON (" NONE - THE NUMBER IS PRIME.");
END;
DONE: WRITE ("
END</syntaxhighlight>
{{out}}
<pre>NUMBER TO FACTOR (OR 0 TO QUIT):
-> 96
THE FACTORS ARE: 2 3 4 6 8 12 16 24 32 48
NUMBER TO FACTOR (OR 0 TO QUIT):
-> 97
THE FACTORS ARE: NONE - THE NUMBER IS PRIME.
NUMBER TO FACTOR (OR 0 TO QUIT):
-> 98
THE FACTORS ARE: 2 7 14 49
NUMBER TO FACTOR (OR 0 TO QUIT):
-> 0
GOODBYE</pre>
=={{header|APL}}==
<
factors 12345
1 3 5 15 823 2469 4115 12345
factors 720
1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 30 36 40 45 48 60 72 80 90 120 144 180 240 360 720</
=={{header|AppleScript}}==
===Functional===
{{Trans|JavaScript}}
<
on integerFactors(n)
if n = 1 then
Line 693 ⟶ 702:
end script
end if
end mReturn</
{{Out}}
<
----
===Straightforward===
<
set output to {}
Line 719 ⟶ 728:
end factors
factors(123456789)</
{{output}}
<
=={{header|Arc}}==
<syntaxhighlight lang="arc">
(= divisor (fn (num)
(= dlist '())
Line 739 ⟶ 748:
(map [rev _] (map [divisor _] '(45 53 60 64)))
</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="arc">
'(
(1 3 5 9 15 45)
Line 749 ⟶ 758:
(1 2 4 8 16 32 64)
)
</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program factorst.s */
Line 940 ⟶ 949:
</syntaxhighlight>
=={{header|Arturo}}==
<
select 1..num [x][
(num%x)=0
Line 949 ⟶ 958:
]
print factors 36</
{{out}}
<pre>1 2 3 4 6 9 12 18 36</pre>
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">int[] n = {11, 21, 32, 45, 67, 519};
for(var j : n) {
write(j, suffix=none);
write(" =>", suffix=none);
for(int i = 1; i < (j/2); ++i) {
if(j % i == 0) {
write(" ", i, suffix=none);
}
}
write(" ", j);
}</syntaxhighlight>
{{out}}
<pre>11 => 1 11
21 => 1 3 7 21
32 => 1 2 4 8 32
45 => 1 3 5 9 15 45
67 => 1 67
519 => 1 3 173 519</pre>
=={{header|AutoHotkey}}==
<
Factors(n)
Line 964 ⟶ 994:
Sort, v, N U D,
Return, v
}</
{{out}}
Line 973 ⟶ 1,003:
=={{header|AutoIt}}==
<
$num = 45
MsgBox (0,"Factors", "Factors of " & $num & " are: " & factors($num))
Line 985 ⟶ 1,015:
Next
Return $ls_factors&$intg
EndFunc</
{{out}}
Line 993 ⟶ 1,023:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f FACTORS_OF_AN_INTEGER.AWK
BEGIN {
Line 1,012 ⟶ 1,042:
printf("\n")
}
</syntaxhighlight>
{{out}}
Line 1,029 ⟶ 1,059:
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
The [[Factors_of_an_integer#Sinclair ZX81 BASIC]] code works the same in Applesoft BASIC.
==={{header|ASIC}}===
{{trans|GW-BASIC}}
<syntaxhighlight lang="basic">REM Factors of an integer
PRINT "Enter an integer";
LOOP:
INPUT N
IF N = 0 THEN LOOP:
NA = ABS(N)
NDIV2 = NA / 2
FOR I = 1 TO NDIV2
NMODI = NA MOD I
IF NMODI = 0 THEN
PRINT I;
ENDIF
NEXT I
PRINT NA
END</syntaxhighlight>
{{out}}
<pre>Enter an integer?60
1 2 3 4 5 6 10 12 15 20 30 60</pre>
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">
subroutine printFactors(n)
print n; " => ";
for i = 1 to n / 2
if n mod i = 0 then print i; " ";
next i
print n
end subroutine
call printFactors(11)
call printFactors(21)
call printFactors(32)
call printFactors(45)
call printFactors(67)
call printFactors(96)
end</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> INSTALL @lib$+"SORTLIB"
sort% = FN_sortinit(0, 0)
PRINT "The factors of 45 are " FNfactorlist(45)
PRINT "The factors of 12345 are " FNfactorlist(12345)
END
DEF FNfactorlist(N%)
LOCAL C%, I%, L%(), L$
DIM L%(32)
FOR I% = 1 TO SQR(N%)
IF (N% MOD I% = 0) THEN
L%(C%) = I%
C% += 1
IF (N% <> I%^2) THEN
L%(C%) = (N% DIV I%)
C% += 1
ENDIF
ENDIF
NEXT I%
CALL sort%, L%(0)
FOR I% = 0 TO C%-1
L$ += STR$(L%(I%)) + ", "
NEXT
= LEFT$(LEFT$(L$))</syntaxhighlight>
{{out}}
<pre>The factors of 45 are 1, 3, 5, 9, 15, 45
The factors of 12345 are 1, 3, 5, 15, 823, 2469, 4115, 12345</pre>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{trans|BASIC256}}
<syntaxhighlight lang="qbasic">10 cls
20 printfactors(11)
30 printfactors(21)
40 printfactors(32)
50 printfactors(45)
60 printfactors(67)
70 printfactors(96)
80 end
100 sub printfactors(n)
110 if n < 1 then printfactors = 0
120 print n "=> ";
130 for i = 1 to n/2
140 if n mod i = 0 then print i " ";
150 next i
160 print n
170 end sub</syntaxhighlight>
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">do
input "enter an integer", n
loop n = 0
let a = abs(n)
for i = 1 to int(a / 2)
if a = int(a / i) * i then
print i
endif
next i
print a</syntaxhighlight>
{{out| Output}}<pre>?60
1 2 3 4 5 6 10 12 15 20 30 60</pre>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
Sub printFactors(n As Integer)
If n < 1 Then Return
Print n; " =>";
For i As Integer = 1 To n / 2
If n Mod i = 0 Then Print i; " ";
Next i
Print n
End Sub
printFactors(11)
printFactors(21)
printFactors(32)
printFactors(45)
printFactors(67)
printFactors(96)
Print
Print "Press any key to quit"
Sleep</syntaxhighlight>
{{out}}
<pre>
11 => 1 11
21 => 1 3 7 21
32 => 1 2 4 8 16 32
45 => 1 3 5 9 15 45
67 => 1 67
96 => 1 2 3 4 6 8 12 16 24 32 48 96
</pre>
==={{header|FutureBasic}}===
<syntaxhighlight lang="futurebasic">window 1, @"Factors of an Integer", (0,0,1000,270)
clear local mode
local fn IntegerFactors( f as long ) as CFStringRef
long i, s, l(100), c = 0
CFStringRef factorStr = @""
for i = 1 to sqr(f)
if ( f mod i == 0 )
l(c) = i
c++
if ( f != i ^ 2 )
l(c) = ( f / i )
c++
end if
end if
next i
s = 1
while ( s = 1 )
s = 0
for i = 0 to c-1
if l(i) > l(i+1) and l(i+1) != 0
swap l(i), l(i+1)
s = 1
end if
next i
wend
for i = 0 to c - 1
if ( i < c - 1 )
factorStr = fn StringWithFormat( @"%@ %ld, ", factorStr, l(i) )
else
factorStr = fn StringWithFormat( @"%@ %ld", factorStr, l(i) )
end if
next
end fn = factorStr
print @"Factors of 25 are:"; fn IntegerFactors( 25 )
print @"Factors of 45 are:"; fn IntegerFactors( 45 )
print @"Factors of 103 are:"; fn IntegerFactors( 103 )
print @"Factors of 760 are:"; fn IntegerFactors( 760 )
print @"Factors of 12345 are:"; fn IntegerFactors( 12345 )
print @"Factors of 32766 are:"; fn IntegerFactors( 32766 )
print @"Factors of 32767 are:"; fn IntegerFactors( 32767 )
print @"Factors of 57097 are:"; fn IntegerFactors( 57097 )
print @"Factors of 12345678 are:"; fn IntegerFactors( 12345678 )
print @"Factors of 32434243 are:"; fn IntegerFactors( 32434243 )
HandleEvents</syntaxhighlight>
{{out}}
<pre>Factors of 25 are: 1, 5, 25
Factors of 45 are: 1, 3, 5, 9, 15, 45
Factors of 103 are: 1, 103
Factors of 760 are: 1, 2, 4, 5, 8, 10, 19, 20, 38, 40, 76, 95, 152, 190, 380, 760
Factors of 12345 are: 1, 3, 5, 15, 823, 2469, 4115, 12345
Factors of 32766 are: 1, 2, 3, 6, 43, 86, 127, 129, 254, 258, 381, 762, 5461, 10922, 16383, 32766
Factors of 32767 are: 1, 7, 31, 151, 217, 1057, 4681, 32767
Factors of 57097 are: 1, 57097
Factors of 12345678 are: 1, 2, 3, 6, 9, 18, 47, 94, 141, 282, 423, 846, 14593, 29186, 43779, 87558, 131337, 262674, 685871, 1371742, 2057613, 4115226, 6172839, 12345678
Factors of 32434243 are: 1, 307, 105649, 32434243</pre>
==={{header|Gambas}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vbnet">Public Sub Main()
printFactors(11)
printFactors(21)
printFactors(32)
printFactors(45)
printFactors(67)
printFactors(96)
End
Sub printFactors(n As Integer)
If n < 1 Then Return
Print n; " =>";
For i As Integer = 1 To n / 2
If n Mod i = 0 Then Print i; " ";
Next
Print n
End Sub</syntaxhighlight>
==={{header|GW-BASIC}}===
<syntaxhighlight lang="qbasic">
10 INPUT "Enter an integer: ", N
20 IF N = 0 THEN GOTO 10
30 NA = ABS(N)
40 FOR I = 1 TO NA/2
50 IF NA MOD I = 0 THEN PRINT I;
60 NEXT I
70 PRINT NA</syntaxhighlight>
{{out}}
<pre>
Enter an integer: 1
1
Enter an integer: 12
1 2 3 4 6 12
Enter an integer: 13
1 13
Enter an integer: -22222
1 2 41 82 271 542 11111 22222
</pre>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="qbasic">100 PROGRAM "Factors.bas"
110 INPUT PROMPT "Number: ":N
120 FOR I=1 TO INT(N/2)
130 IF MOD(N,I)=0 THEN PRINT I;
140 NEXT
150 PRINT N</syntaxhighlight>
==={{header|Liberty BASIC}}===
<syntaxhighlight lang="lb">num = 10677106534462215678539721403561279
maxnFactors = 1000
dim primeFactors(maxnFactors), nPrimeFactors(maxnFactors)
global nDifferentPrimeNumbersFound, nFactors, iFactor
print "Start finding all factors of ";num; ":"
nDifferentPrimeNumbersFound=0
dummy = factorize(num,2)
nFactors = showPrimeFactors(num)
dim factors(nFactors)
dummy = generateFactors(1,1)
sort factors(), 0, nFactors-1
for i=1 to nFactors
print i;" ";factors(i-1)
next i
print "done"
wait
function factorize(iNum,offset)
factorFound=0
i = offset
do
if (iNum MOD i)=0 _
then
if primeFactors(nDifferentPrimeNumbersFound) = i _
then
nPrimeFactors(nDifferentPrimeNumbersFound) = nPrimeFactors(nDifferentPrimeNumbersFound) + 1
else
nDifferentPrimeNumbersFound = nDifferentPrimeNumbersFound + 1
primeFactors(nDifferentPrimeNumbersFound) = i
nPrimeFactors(nDifferentPrimeNumbersFound) = 1
end if
if iNum/i<>1 then dummy = factorize(iNum/i,i)
factorFound=1
end if
i=i+1
loop while factorFound=0 and i<=sqr(iNum)
if factorFound=0 _
then
nDifferentPrimeNumbersFound = nDifferentPrimeNumbersFound + 1
primeFactors(nDifferentPrimeNumbersFound) = iNum
nPrimeFactors(nDifferentPrimeNumbersFound) = 1
end if
end function
function showPrimeFactors(iNum)
showPrimeFactors=1
print iNum;" = ";
for i=1 to nDifferentPrimeNumbersFound
print primeFactors(i);"^";nPrimeFactors(i);
if i<nDifferentPrimeNumbersFound then print " * "; else print ""
showPrimeFactors = showPrimeFactors*(nPrimeFactors(i)+1)
next i
end function
function generateFactors(product,pIndex)
if pIndex>nDifferentPrimeNumbersFound _
then
factors(iFactor) = product
iFactor=iFactor+1
else
for i=0 to nPrimeFactors(pIndex)
dummy = generateFactors(product*primeFactors(pIndex)^i,pIndex+1)
next i
end if
end function</syntaxhighlight>
{{out}}
<syntaxhighlight lang="lb">Start finding all factors of 10677106534462215678539721403561279:
10677106534462215678539721403561279 = 29269^1 * 32579^1 * 98731^2 * 104729^3
1 1
2 29269
3 32579
4 98731
5 104729
6 953554751
7 2889757639
8 3065313101
9 3216557249
10 3411966091
11 9747810361
12 10339998899
13 10968163441
14 94145414120981
15 99864835517479
16 285308661456109
17 302641427774831
18 317573913751019
19 321027175754629
20 336866824130521
21 357331796744339
22 1020878431297169
23 1082897744693371
24 1148684789012489
25 9295070881578575111
26 9859755075476219149
27 10458744358910058191
28 29880090805636839461
29 31695334089430275799
30 33259198413230468851
31 33620855089606540541
32 35279725624365333809
33 37423001741237879131
34 106915577231321212201
35 113410797903992051459
36 973463478356842592799919
37 1032602289299548955255621
38 1095333837964291484285239
39 3129312029983540559911069
40 3319420643851943354153471
41 3483202590619213772296379
42 3694810384914157044482761
43 11197161487859039232598529
44 101949856624833767901342716951
45 108143405156052462534965931709
46 327729719588146219298926345301
47 364792324112959639158827476291
48 10677106534462215678539721403561279
done</syntaxhighlight>
====A Simpler Approach====
This is a somewhat simpler approach for finding the factors of smaller numbers (less than one million).
{{works with|Just BASIC}}
<syntaxhighlight lang="lb">
print "ROSETTA CODE - Factors of an integer"
'A simpler approach for smaller numbers
[Start]
print
input "Enter an integer (< 1,000,000): "; n
n=abs(int(n)): if n=0 then goto [Quit]
if n>999999 then goto [Start]
FactorCount=FactorCount(n)
select case FactorCount
case 1: print "The factor of 1 is: 1"
case else
print "The "; FactorCount; " factors of "; n; " are: ";
for x=1 to FactorCount
print " "; Factor(x);
next x
if FactorCount=2 then print " (Prime)" else print
end select
goto [Start]
[Quit]
print "Program complete."
end
function FactorCount(n)
dim Factor(100)
for y=1 to n
if y>sqr(n) and FactorCount=1 then
'If no second factor is found by the square root of n, then n is prime.
FactorCount=2: Factor(FactorCount)=n: exit function
end if
if (n mod y)=0 then
FactorCount=FactorCount+1
Factor(FactorCount)=y
end if
next y
end function
</syntaxhighlight>
{{out}}
<pre>
ROSETTA CODE - Factors of an integer
Enter an integer (< 1,000,000): 1
The factor of 1 is: 1
Enter an integer (< 1,000,000): 2
The 2 factors of 2 are: 1 2 (Prime)
Enter an integer (< 1,000,000): 4
The 3 factors of 4 are: 1 2 4
Enter an integer (< 1,000,000): 6
The 4 factors of 6 are: 1 2 3 6
Enter an integer (< 1,000,000): 999999
The 64 factors of 999999 are: 1 3 7 9 11 13 21 27 33 37 39 63 77 91 99 111 117 143 189 231 259 273 297 333 351 407 429 481 693 777 819 999 1001 1221 1287 1443 2079 2331 2457 2849 3003 3367 3663 3861 4329 5291 6993 8547 9009 10101 10989 12987 15873 25641 27027 30303 37037 47619 76923 90909 111111 142857 333333 999999
Enter an integer (< 1,000,000):
Program complete.
</pre>
==={{header|Minimal BASIC}}===
{{trans|GW-BASIC}}
{{works with|Commodore BASIC}}
{{works with|IS-BASIC}}
{{works with|MSX BASIC|any}}
{{works with|Nascom ROM BASIC|4.7}}
<syntaxhighlight lang="qbasic">10 REM Factors of an integer
20 PRINT "Enter an integer";
30 INPUT N
40 IF N = 0 THEN 30
50 N1 = ABS(N)
60 FOR I = 1 TO N1/2
70 IF INT(N1/I)*I <> N1 THEN 90
80 PRINT I;
90 NEXT I
100 PRINT N1
110 END</syntaxhighlight>
==={{header|MSX Basic}}===
{{trans|GW-BASIC}}
<syntaxhighlight lang="qbasic">10 INPUT "Enter an integer: "; N
20 IF N = 0 THEN GOTO 10
30 N1 = ABS(N)
40 FOR I = 1 TO N1/2
50 IF N1 MOD I = 0 THEN PRINT I;
60 NEXT I
70 PRINT N1</syntaxhighlight>
==={{header|Nascom BASIC}}===
{{trans|GW-BASIC}}
{{works with|Nascom ROM BASIC|4.7}}
<syntaxhighlight lang="basic">
10 REM Factors of an integer
20 INPUT "Enter an integer"; N
30 IF N=0 THEN 20
40 NA=ABS(N)
50 FOR I=1 TO INT(NA/2)
60 IF NA=INT(NA/I)*I THEN PRINT I;
70 NEXT I
80 PRINT NA
90 END
</syntaxhighlight>
{{out}}
<pre>Enter an integer? 60
1 2 3 4 5 6 10 12 15 20 30 60</pre>
See also [[#Minimal BASIC|Minimal BASIC]]
==={{header|Palo Alto Tiny BASIC}}===
{{trans|GW-BASIC}}
<syntaxhighlight lang="basic">
10 REM FACTORS OF AN INTEGER
20 INPUT "ENTER AN INTEGER"N
30 IF N=0 GOTO 20
40 LET A=ABS(N)
50 IF A=1 GOTO 90
60 FOR I=1 TO A/2
70 IF (A/I)*I=A PRINT I," ",
80 NEXT I
90 PRINT A
100 STOP
</syntaxhighlight>
{{out}}
3 runs.
<pre>ENTER AN INTEGER:1
1</pre>
<pre>ENTER AN INTEGER:60
1 2 3 4 5 6 10 12 15 20 30 60</pre>
<pre>ENTER AN INTEGER:-22222
1 2 41 82 271 542 11111 22222</pre>
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">Procedure PrintFactors(n)
Protected i, lim=Round(sqr(n),#PB_Round_Up)
NewList F.i()
For i=1 To lim
If n%i=0
AddElement(F()): F()=i
AddElement(F()): F()=n/i
EndIf
Next
;- Present the result
SortList(F(),#PB_Sort_Ascending)
ForEach F()
Print(str(F())+" ")
Next
EndProcedure
If OpenConsole()
Print("Enter integer to factorize: ")
PrintFactors(Val(Input()))
Print(#CRLF$+#CRLF$+"Press ENTER to quit."): Input()
EndIf</syntaxhighlight>
{{out}}
<pre> Enter integer to factorize: 96
1 2 3 4 6 8 12 16 24 32 48 96</pre>
==={{header|QB64}}===
<syntaxhighlight lang="qb64">'Task
'Compute the factors of a positive integer.
'These factors are the positive integers by which the number being factored can be divided to yield a positive integer result.
Dim Dividendum As Integer, Index As Integer
Randomize Timer
Dividendum = Int(Rnd * 1000) + 1
Print " Dividendum: "; Dividendum
Index = Int(Dividendum / 2)
print "Divisors: ";
While Index > 0
If Dividendum Mod Index = 0 Then Print Index; " ";
Index = Index - 1
Wend
End</syntaxhighlight>
==={{header|QBasic}}===
See [[#QuickBASIC|QuickBASIC]].
==={{header|QuickBASIC}}===
{{works with|QBasic}}
This example stores the factors in a shared array (with the original number as the last element) for later retrieval.
Note that this will error out if you pass 32767 (or higher).
<
REDIM SHARED factors(0) AS INTEGER
Line 1,066 ⟶ 1,665:
tmp(L1) = factors(L1)
NEXT
REDIM factors(UBOUND(factors) + 1) AS INTEGER
FOR L1 = 0 TO UBOUND(factors) - 1
factors(L1) = tmp(L1)
Line 1,073 ⟶ 1,672:
END IF
NEXT
END SUB</
{{out}}
<pre> Gimme a number? 17
1 , 17
Gimme a number? 12345
Line 1,085 ⟶ 1,682:
Gimme a number? 32766
1 , 2 , 3 , 6 , 43 , 86 , 127 , 129 , 254 , 258 , 381 , 762 , 5461 , 10922 ,
16383 , 32766</pre>
==={{header|Quite BASIC}}===
{{trans|GW-BASIC}}
<syntaxhighlight lang="qbasic">10 INPUT "Enter an integer: "; N
20 IF N = 0 THEN GOTO 15
30 N1 = ABS(N)
40 FOR I = 1 TO N1/2
50 IF N1 - INT(N1 / I) * I = 0 THEN PRINT I; " ";
60 NEXT I
70 PRINT N1</syntaxhighlight>
==={{header|
<syntaxhighlight lang="vb">Function factors(num As UInt64) As UInt64()
'This function accepts an unsigned 64 bit integer as input and returns an array of unsigned 64 bit integers
Dim result() As UInt64
Dim iFactor
While iFactor <= num/2 'Since a factor will never be larger than half of the number
If num Mod
result.Append(iFactor)
iFactor = iFactor + 1
Wend
result.Append(num) 'Since a given number is always a factor of itself
Return result
End Function</syntaxhighlight>
==={{header|Run BASIC}}===
<syntaxhighlight lang="basic">PRINT "Factors of 45 are ";factorlist$(45)
PRINT "Factors of 12345 are "; factorlist$(12345)
END
FUNCTION factorlist$(f)
DIM L(100)
FOR i = 1 TO SQR(f)
IF (f MOD i) = 0 THEN
L(c) = i
c = c + 1
IF (f <> i^2) THEN
L(c) = (f / i)
c = c + 1
END IF
END IF
NEXT i
s = 1
WHILE s = 1
s = 0
FOR i = 0 TO c-1
IF L(i) > L(i+1) AND L(i+1) <> 0 THEN
t = L(i)
L(i) = L(i+1)
L(i+1) = t
s = 1
END IF
NEXT i
WEND
FOR i = 0 TO c-1
factorlist$ = factorlist$ + STR$(L(i)) + ", "
NEXT
END FUNCTION</syntaxhighlight>
{{out}}
<pre>Factors of 45 are 1, 3, 5, 9, 15, 45,
Factors of 12345 are 1, 3, 5, 15, 823, 2469, 4115, 12345, </pre>
==={{header|Sinclair ZX81 BASIC}}===
{{works with|Applesoft BASIC}}
<syntaxhighlight lang="basic">10 INPUT N
20 FOR I=1 TO N
30 IF N/I=INT (N/I) THEN PRINT I;" ";
40 NEXT I</
{{in}}
<pre>315</pre>
Line 1,153 ⟶ 1,758:
==={{header|Tiny BASIC}}===
{{works with|TinyBasic}}
<syntaxhighlight lang="basic">100 PRINT "Give me a number:"
110 INPUT I
120 LET C=1
Line 1,160 ⟶ 1,766:
150 LET C=C+1
160 IF C<=I THEN GOTO 140
170 END</
{{out}}
<pre>Give me a number:
Line 1,176 ⟶ 1,782:
20
30
60</pre>
==={{header|True BASIC}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">SUB printfactors(n)
IF n < 1 THEN EXIT SUB
IF REMAINDER(n, i) = 0 THEN PRINT i;
NEXT i
PRINT n
END SUB
CALL printfactors(11)
CALL printfactors(21)
CALL printfactors(32)
CALL printfactors(45)
CALL printfactors(67)
CALL printfactors(96)
END</syntaxhighlight>
==={{header|VBA}}===
<syntaxhighlight lang="vb">Function Factors(x As Integer) As String
Application.Volatile
Dim i As Integer
Dim cooresponding_factors As String
Factors = 1
corresponding_factors = x
For i = 2 To Sqr(x)
If x Mod i = 0 Then
Factors = Factors & ", " & i
If i <> x / i Then corresponding_factors = x / i & ", " & corresponding_factors
End If
Next i
If x <> 1 Then Factors = Factors & ", " & corresponding_factors
End Function</syntaxhighlight>
{{out}}
<pre>cell formula is "=Factors(840)"
resultant value is "1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 15, 20, 21, 24, 28, 30, 35, 40, 42, 56, 60, 70, 84, 105, 120, 140, 168, 210, 280, 420, 840"</pre>
==={{header|XBasic}}===
{{trans|BASIC256}}
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "Factors of an integer"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
DECLARE FUNCTION printFactors (n)
FUNCTION Entry ()
printFactors(11)
printFactors(21)
printFactors(32)
printFactors(45)
printFactors(67)
printFactors(96)
END FUNCTION
FUNCTION printFactors (n)
PRINT n; " =>";
FOR i = 1 TO n / 2
IF n MOD i = 0 THEN PRINT i; " ";
NEXT i
PRINT n
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">sub printFactors(n)
if n < 1 return 0
print n, " =>";
for i = 1 to n / 2
if
next i
print n
end sub
printFactors(11)
printFactors(21)
printFactors(32)
printFactors(45)
printFactors(67)
printFactors(96)
print
end</syntaxhighlight>
==={{header|ZX Spectrum Basic}}===
{{trans|AWK}}
<syntaxhighlight lang="basic">10 INPUT "Enter a number or 0 to exit: ";n
20 IF n=0 THEN STOP
30 PRINT "Factors of ";n;": ";
40 FOR i=1 TO n
50 IF FN m(n,i)=0 THEN PRINT i;" ";
60 NEXT i
70 DEF FN m(a,b)=a-INT (a/b)*b</syntaxhighlight>
=={{header|Batch File}}==
Command line version:
<
set res=Factors of %1:
for /L %%i in (1,1,%1) do call :fac %1 %%i
Line 1,217 ⟶ 1,889:
:fac
set /a test = %1 %% %2
if %test% equ 0 set res=%res% %2</
{{out}}
Line 1,236 ⟶ 1,908:
Interactive version:
<
set /p limit=Gimme a number:
set res=Factors of %limit%:
Line 1,245 ⟶ 1,917:
:fac
set /a test = %1 %% %2
if %test% equ 0 set res=%res% %2</
{{out}}
Line 1,255 ⟶ 1,927:
Gimme a number:102
Factors of 102: 1 2 3 6 17 34 51 102</pre>
=={{header|bc}}==
<
* This function mutates the global array f[] which will
* contain all factors of n in ascending order after the call!
Line 1,332 ⟶ 1,972:
scale = o
return(l)
}</
=={{header|Befunge}}==
<
>:0:g:*`| > >0:g1+0:p
>:0:g:*-#v_0:g\>$>:!#@_.v
> ^ ^ ," "<</
=={{header|BQN}}==
Line 1,344 ⟶ 1,984:
A bqncrate idiom.
<
•Show Factors 12345
•Show Factors 729</
<syntaxhighlight lang="text">⟨ 1 3 5 15 823 2469 4115 12345 ⟩
⟨ 1 3 9 27 81 243 729 ⟩</
The [https://github.com/mlochbaum/bqn-libs/blob/master/primes.bqn primes] library from bqn-libs can be used for a solution that's more efficient for large inputs. <code>FactorExponents</code> returns each unique prime factor along with its exponent.
<
Factors ← { ∧⥊ 1 ×⌜´ ⋆⟜(↕1+⊢)¨˝ FactorExponents 𝕩 }</
=={{header|Burlesque}}==
<
{1 7 31 151 217 1057 4681 32767}</
=={{header|C}}==
<
#include <stdlib.h>
Line 1,427 ⟶ 2,067:
}
return 0;
}</
===Prime factoring===
<
#include <stdlib.h>
#include <string.h>
Line 1,516 ⟶ 2,156:
return 0;
}</
{{out}}
Line 1,526 ⟶ 2,166:
=={{header|C sharp|C#}}==
===C# 1.0===
<
do {
Console.WriteLine ("Number:");
Line 1,546 ⟶ 2,186:
Console.WriteLine ("Done.");
} while (true);
}</
{{out}}
<pre>Number:
32434243
For 1 through 5695
Found: 1. 32434243 / 1 = 32434243
Found: 307. 32434243 / 307 = 105649
Done.</pre>
===C# 3.0===
<
using System.Collections.Generic;
using System.Linq;
Line 1,563 ⟶ 2,210:
Console.WriteLine (String.Join (", ", 45. Factors ()));
}
}</
{{out}}
<pre>1, 3, 5, 9, 15, 45</pre>
=={{header|C++}}==
<
#include <iomanip>
#include <vector>
Line 1,607 ⟶ 2,249:
return EXIT_SUCCESS;
}</
{{out}}
Line 1,616 ⟶ 2,258:
=={{header|Ceylon}}==
<
{Integer*} getFactors(Integer n) =>
(1..n).filter((Integer element) => element.divides(n));
Line 1,623 ⟶ 2,265:
print("the factors of ``i`` are ``getFactors(i)``");
}
}</
=={{header|Chapel}}==
Inspired by the Clojure solution:
<
for i in 1..floor(sqrt(n)):int {
if n % i == 0 then {
Line 1,634 ⟶ 2,276:
}
}
}</
=={{header|Clojure}}==
<
(filter #(zero? (rem n %)) (range 1 (inc n))))
(print (factors 45))</
(1 3 5 9 15 45)
Improved version. Considers small factors from 1 up to (sqrt n) -- we increment it because range does not include the end point. Pair each small factor with its co-factor, flattening the results, and put them into a sorted set to get the factors in order.
<
(into (sorted-set)
(mapcat (fn [x] [x (/ n x)])
(filter #(zero? (rem n %)) (range 1 (inc (Math/sqrt n)))) )))</
Same idea, using for comprehensions.
<
(into (sorted-set)
(reduce concat
(for [x (range 1 (inc (Math/sqrt n))) :when (zero? (rem n x))]
[x (/ n x)]))))</
=={{header|CLU}}==
{{trans|Sather}}
<
x0: int := s/2
if x0=0 then return(s) end
Line 1,689 ⟶ 2,331:
stream$putl(po, "")
end
end start_up</
{{out}}
<pre>Factors of 3135: 1 3 1045 5 627 11 285 15 209 19 165 33 95 55 57 3135
Line 1,699 ⟶ 2,341:
=={{header|COBOL}}==
<
IDENTIFICATION DIVISION.
PROGRAM-ID. FACTORS.
Line 1,740 ⟶ 2,382:
END PROGRAM FACTORS.
</syntaxhighlight>
=={{header|CoffeeScript}}==
<
# robust--we'll use it to verify the more complicated (but hopefully faster)
# algorithm.
Line 1,801 ⟶ 2,443:
console.log n, factors
if n < 1000000
verify_factors factors, n</
{{out}}
Line 1,828 ⟶ 2,470:
=={{header|Common Lisp}}==
We iterate in the range <code>1..sqrt(n)</code> collecting ‘low’ factors and corresponding ‘high’ factors, and combine at the end to produce an ordered list of factors.
<
(do ((limit (1+ (isqrt n))) (factor 1 (1+ factor)))
((= factor limit)
Line 1,837 ⟶ 2,479:
(when (zerop remainder)
(push factor lows)
(push quotient highs)))))</
=={{header|Crystal}}==
{{trans|Ruby}}
Brute force and slow, by checking every value up to n.
<
def factors() (1..self).select { |n| (self % n).zero? } end
end</
Faster, by only checking values up to <math>\sqrt{n}</math>.
<
def factors
f = [] of Int32
Line 1,855 ⟶ 2,497:
f.sort
end
end</
'''Tests:'''
<
[45, 53, 64].each {|n| puts "#{n} : #{n.factors}"}</
{{out}}
<pre>
Line 1,868 ⟶ 2,510:
=={{header|D}}==
===Procedural Style===
<
T[] factors(T)(in T n) pure nothrow {
Line 1,890 ⟶ 2,532:
void main() {
writefln("%(%s\n%)", [45, 53, 64, 1111111].map!factors);
}</
{{out}}
<pre>[1, 3, 5, 9, 15, 45]
Line 1,898 ⟶ 2,540:
===Functional Style===
<
auto factors(I)(I n) {
Line 1,906 ⟶ 2,548:
void main() {
36.factors.writeln;
}</
{{out}}
<pre>[1, 2, 3, 4, 6, 9, 12, 18, 36]</pre>
Line 1,935 ⟶ 2,577:
=={{header|Dc}}==
=== Simple O(n) version ===
<syntaxhighlight lang="dc">
[Enter positive number: ]P ? sn
[Factors of ]P lnn [ are: ]P
[q]sq 1si [[ ]P lin]sp [ li ln <q ln li % 0=p li1+si lxx ]dsxx AP
</syntaxhighlight>
{{out}}
Factors of 998877 are: 1 3 11 33 30269 90807 332959 998877
0m1.120s
=== Faster O(sqrt(n)) version ===
<syntaxhighlight lang="dc">
[Enter positive number: ]P ? sn
[Factors of ]P lnn [ are: ]P
Line 1,950 ⟶ 2,592:
[li lv <q ln li % 0=P li1+si lxx]dsxx
[lj 1>q lj1-sj Lbsi lpx lxx]dsxx AP
</syntaxhighlight>
0m0.004s
=={{header|Delphi}}==
Line 1,956 ⟶ 2,598:
=={{header|Dyalect}}==
<
for x in this when pred(x) {
yield x
Line 1,962 ⟶ 2,604:
}
func Integer.
(1..this).
}
for x in 45.
print(x)
}</
Output:
Line 1,981 ⟶ 2,623:
=={{header|E}}==
{{improve|E|Use a cleverer algorithm such as in the Common Lisp example.}}
<
var xfactors := []
for f ? (x % f <=> 0) in 1..x {
Line 1,987 ⟶ 2,629:
}
return xfactors
}</
=={{header|EasyLang}}==
<syntaxhighlight lang="text">n = 720
for i = 1 to n
if n mod i = 0
Line 1,996 ⟶ 2,638:
.
.
print factors[]</
=={{header|EchoLisp}}==
'''prime-factors''' gives the list of n's prime-factors. We mix them to get all the factors.
<
;; ppows
;; input : a list g of grouped prime factors ( 3 3 3 ..)
Line 2,019 ⟶ 2,661:
(for/fold (divs'(1)) ((g (map ppows (group (prime-factors n)))))
(for*/list ((a divs) (b g)) (* a b))))))
</syntaxhighlight>
{{out}}
<
(lib 'bigint)
(factors 666)
Line 2,032 ⟶ 2,674:
(time ( length (factors huge)))
→ (394ms 7776)
</syntaxhighlight>
=={{header|EDSAC order code}}==
Line 2,039 ⟶ 2,681:
2021-10-10 Integers are now read from the tape in decimal format, instead of being defined by the awkward method of pseudo-orders. The factorization of 999,999,999 has been removed, as it took too long on the commonly-used EdsacPC simulator (14.6 million orders - over 6 hours on the original EDSAC).
<
[Factors of an integer, from Rosetta Code website.]
[EDSAC program, Initial Orders 2.]
Line 2,193 ⟶ 2,835:
E 4 Z [define entry point]
P F [acc = 0 on entry]
</syntaxhighlight>
{{out}}
<pre>
Line 2,220 ⟶ 2,862:
===Using higher-order function===
<
factors m = filter (\x -> m % x == 0) [1..m]</
===Using comprehension===
<
=={{header|Elixir}}==
<
def factor(1), do: [1]
def factor(n) do
Line 2,254 ⟶ 2,896:
IO.puts "#{name}\t prime count : #{value},\t#{time/1000000} sec"
end)
</syntaxhighlight>
{{out}}
Line 2,266 ⟶ 2,908:
factor prime count : 1229, 7.316 sec
divisor prime count : 1229, 0.265 sec
</pre>
=={{header|EMal}}==
<syntaxhighlight lang="emal">
fun factors = List by int n
List result = int[1]
for each int i in range(2, n)
if n % i == 0 do result.append(i) end
end
result.append(n)
return result
end
fun main = int by List args
int n = when(args.length == 0, ask(int, "Enter the number to factor please "), int!args[0])
writeLine(factors(n))
return 0
end
exit main(Runtime.args)
</syntaxhighlight>
{{out}}
<pre>
emal.exe Org\RosettaCode\FactorsOfAnInteger.emal 999997
[1,757,1321,999997]
</pre>
=={{header|Erlang}}==
===with Built in fuctions===
<
[I || I <- lists:seq(1,trunc(N/2)), N rem I == 0]++[N].</
===Recursive===
Another, less concise, but faster version
<
-module(divs).
Line 2,294 ⟶ 2,959:
divisors(K,N,_Q) ->
[K, N div K] ++ divisors(K+1,N,math:sqrt(N)).
</syntaxhighlight>
{{out}}
<pre>
Line 2,310 ⟶ 2,975:
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM FACTORS
Line 2,354 ⟶ 3,019:
PRINT("The factors of 12345 are ";L$)
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
Line 2,370 ⟶ 3,035:
{{Works with|Office 365 Betas 2021}}
<
IF(1 < n,
LET(
Line 2,393 ⟶ 3,058:
IF(1 = n, {1}, NA())
)
)</
and assuming that in the same worksheet, each of the following names is bound to the reusable generic lambda expression which follows it:
<
=LAMBDA(xs,
LAMBDA(ys,
Line 2,455 ⟶ 3,120:
)
)
)</
The '''FACTORS''' function, applied to an integer, defines a column of integer values.
Line 2,645 ⟶ 3,310:
Also, this is lazily evaluated.
<
for divisor in 1 .. (float >> sqrt >> int) number do
if number % divisor = 0 then
yield divisor
if number <> 1 then yield number / divisor //special case condition: when number=1 then divisor=(number/divisor), so don't repeat it
}</
===Prime factoring===
<
[6;120;2048;402642;1206432] |> Seq.iter(fun n->printf "%d :" n; [1..n]|>Seq.filter(fun g->n%g=0)|>Seq.iter(fun n->printf " %d" n); printfn "");;</
{{out}}
Line 2,674 ⟶ 3,339:
=={{header|FALSE}}==
<
45f;! 53f;! 64f;!</
=={{header|Fish}}==
<syntaxhighlight lang="fish">0v
>i:0(?v'0'%+a*
>~a,:1:>r{% ?vr:nr','ov
^:&:;?(&:+1r:< <
</syntaxhighlight>
Must be called with pre-polulated value (Positive Integer) in the input stack. Try at Fish Playground[https://fishlanguage.com/playground/onD7KN6YK3XMzLFdr].
For Input Number : <pre> 120</pre>
Line 2,690 ⟶ 3,355:
=={{header|Forth}}==
This is a slightly optimized algorithm, since it realizes there are no factors between n/2 and n. The values are saved on the stack and - in true Forth fashion - printed in descending order.
<
: .factors factors begin dup dup . 1 <> while drop repeat drop cr ;
Line 2,696 ⟶ 3,361:
53 .factors
64 .factors
100 .factors</
=== Alternative version with vectored execution ===
It's not really idiomatic FORTH to leave a variable number of items on the stack, so instead this version repeatedly calls an execution token for each factor, and it uses a defining word to create a fold over the factors of an integer. This version also only tests up to the square root, which means that items are generated in pairs, rather than in sorted order.
<syntaxhighlight lang="forth">
: sq s" dup *" evaluate ; immediate
Line 2,727 ⟶ 3,392:
0 :noname swap . ; <with-factors> (.factors)
: .factors (.factors) drop ;
</syntaxhighlight>
{{Out}}
<pre>
Line 2,740 ⟶ 3,405:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
implicit none
integer :: i, number
Line 2,759 ⟶ 3,424:
end if
end program</
=={{header|Frink}}==
Line 2,802 ⟶ 3,435:
The following produces all factors of n, including 1 and n:
<syntaxhighlight lang
=={{header|FunL}}==
Function to compute set of factors:
<
Test:
<
println( 'The set of factors of ' + x + ' is ' + factors(x) )</
{{out}}
Line 2,820 ⟶ 3,453:
The set of factors of 639 is {9, 639, 71, 213, 1, 3}
The set of factors of 760 is {8, 19, 4, 40, 152, 5, 10, 76, 1, 95, 190, 760, 20, 2, 38, 380}
</pre>
=={{header|GAP}}==
<
DivisorsInt(Factorial(5));
# [ 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 ]
Line 2,906 ⟶ 3,475:
div2(Factorial(5));
# [ 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 ]</
=={{header|Go}}==
Trial division, no prime number generator, but with some optimizations. It's good enough to factor any 64 bit integer, with large primes taking several seconds.
<
import "fmt"
Line 2,961 ⟶ 3,530:
fmt.Println(fs)
fmt.Println("Number of factors =", len(fs))
}</
{{out}}
Line 2,993 ⟶ 3,562:
=={{header|Gosu}}==
<
numbers.each(\ number -> printFactors(number))
Line 3,001 ⟶ 3,570:
(1 .. n/2).each(\ i -> {result += n % i == 0 ? "${i} " : ""})
print("${result}${n}")
}</
{{out}}
Line 3,015 ⟶ 3,584:
=={{header|Groovy}}==
A straight brute force approach up to the square root of ''N'':
<
if (target == 1) return [1L]
Line 3,027 ⟶ 3,596:
[1] + lowfactors + (0..<nhalf).collect { target.intdiv(lowfactors[it]) }.reverse() + [target]
}</
Test:
<
{{out}}
<pre>[number:1, factors:[1]]
Line 3,066 ⟶ 3,635:
=={{header|Haskell}}==
Using [https://web.archive.org/web/20121130222921/http://www.polyomino.f2s.com/david/haskell/codeindex.html D. Amos'es Primes module] for finding prime factors
<
import Control.Monad (mapM)
import Data.List (product)
Line 3,073 ⟶ 3,642:
factors = map product .
mapM (\(p,m)-> [p^i | i<-[0..m]]) . primePowerFactors</
Returns list of factors out of order, e.g.:
<
[1,7,3,21,2,14,6,42]</
Or, [[Prime_decomposition#Haskell|prime decomposition task]] can be used (although, a trial division-only version will become very slow for large primes),
<
primePowerFactors = map (\x-> (head x, length x)) . group . factorize</
The above function can also be found in the package [http://hackage.haskell.org/package/arithmoi <code>arithmoi</code>], as <code>Math.NumberTheory.Primes.factorise :: Integer -> [(Integer, Int)]</code>, [http://hackage.haskell.org/package/arithmoi-0.4.2.0/docs/Math-NumberTheory-Primes-Factorisation.html which performs] "factorisation of Integers by the elliptic curve algorithm after Montgomery" and "is best suited for numbers of up to 50-60 digits".
Line 3,089 ⟶ 3,658:
Or, deriving cofactors from factors up to the square root:
<
integerFactors n
| 1 > n = []
| otherwise = lows
where
part n
Line 3,098 ⟶ 3,667:
| otherwise = id
(square, lows) =
(,) . (^ 2)
$ floor (sqrt $ fromIntegral n)
main :: IO ()
main = print $ integerFactors 600</
{{Out}}
<pre>[1,2,3,4,5,6,8,10,12,15,20,24,25,30,40,50,60,75,100,120,150,200,300,600]</pre>
Line 3,108 ⟶ 3,678:
=== List comprehension ===
Naive, functional, no import, in increasing order:
<
[ i
| i <- [1 .. n]
, mod n i == 0 ]</
<
[1,5,25]</
Factor, ''cofactor''. Get the list of factor–cofactor pairs sorted, for a quadratic speedup:
<
factorsCo n =
Line 3,126 ⟶ 3,696:
i :
[ d
| d > i ] ]</
A version of the above without the need for sorting, making it to be ''online'' (i.e. productive immediately, which can be seen in GHCi); factors in increasing order:
<
ds ++
[ r
Line 3,143 ⟶ 3,713:
[ i
| i <- [1 .. r - 1]
, mod n i == 0 ]</
Testing:
<
~> factorsO 120
[1,2,3,4,5,6,8,10,12,15,20,24,30,40,60,120]
Line 3,153 ⟶ 3,723:
[1,7,41,287,541,3787,22181,77551,155267,542857,3179591,22257137,41955091,2936856
37,1720158731,12041111117]
(0.09 secs, 50758224 bytes)</
=={{header|HicEst}}==
<
DO i = 1, N^0.5
Line 3,162 ⟶ 3,732:
ENDDO
END</
=={{header|Icon}} and {{header|Unicon}}==
<
numbers := arglist ||| [ 32767, 45, 53, 64, 100] # combine command line provided and default set of values
every writes(lf,"factors of ",i := !numbers,"=") & writes(divisors(i)," ") do lf := "\n"
end
link factors</
{{out}}
Line 3,180 ⟶ 3,750:
{{libheader|Icon Programming Library}} [http://www.cs.arizona.edu/icon/library/src/procs/factors.icn divisors]
=={{Header|Insitux}}==
{{Trans|Clojure}}
<syntaxhighlight lang="insitux">
(function factors n
(filter (div? n) (range 1 (inc n))))
(factors 45)
</syntaxhighlight>
{{out}}
<pre>
[1 3 5 9 15 45]
</pre>
=={{header|J}}==
The "brute force" approach is the most concise:
<
Example use:
<
1 2 4 5 8 10 20 40</
Basically we test every non-negative integer up through the number itself to see if it divides evenly.
Line 3,196 ⟶ 3,783:
J has a primitive, q: which returns its argument's prime factors.
<
2 2 2 5</
Alternatively, q: can produce provide a table of the exponents of the unique relevant prime factors
<
2 3 5 7
2 1 1 1</
With this, we can form lists of each of the potential relevant powers of each of these prime factors
<
┌─────┬───┬───┬───┐
│1 2 4│1 3│1 5│1 7│
└─────┴───┴───┴───┘</
From here, it's a simple matter (<code>*/&>@{</code> or, find all possible combinations of one item from each list (<code>{</code> without a left argument) then unpack each list and multiply its elements) to compute all possible factors of the original number
<
factrs 40
1 5
2 10
4 20
8 40</
However, a data structure which is organized around the prime decomposition of the argument can be hard to read. So, for reader convenience, we should probably arrange them in a monotonically increasing list:
<
1 2 3 4 5 6 7 10 12 14 15 20 21 28 30 35 42 60 70 84 105 140 210 420</
A less efficient, but concise variation on this theme:
<
1 5 2 10 4 20 8 40</
This computes 2^n intermediate values where n is the number of prime factors of the original number.
Line 3,233 ⟶ 3,820:
That said, note that we get a representation issue when dealing with large numbers:
<
1 2 4 5 10 17 20 34 68 85 170 340 1.67198e6 3.34397e6 6.68793e6 8.35992e6 1.67198e7 2.84237e7 3.34397e7 5.68474e7 1.13695e8 1.42119e8 2.84237e8 5.68474e8</
One approach here (if we don't want to explicitly format the result) is to use an arbitrary precision (aka "extended") argument. This propagates through into the result:
<
1 2 4 5 10 17 20 34 68 85 170 340 1671983 3343966 6687932 8359915 16719830 28423711 33439660 56847422 113694844 142118555 284237110 568474220</
Another less efficient approach, in which remainders are examined up to the square root, larger factors obtained as fractions, and the combined list nubbed and sorted might be:
<
Y=. y"_
/:~ ~. ( , Y%]) ( #~ 0=]|Y) 1+i.>.%:y
Line 3,248 ⟶ 3,835:
factorsOfNumber 40
1 2 4 5 8 10 20 40</
Another approach:
<
factors=: (*/@:^"1 odometer@:>:)/@q:~&__</
See also the J essays [[j:Essays/Odometer|Odometer]] and [[j:Essays/Divisors|Divisors]].
=={{header|Java}}==
{{works with|Java|5+}}
<
{
TreeSet<Long> factors = new TreeSet<Long>();
Line 3,271 ⟶ 3,858:
}
return factors;
}</
=={{header|JavaScript}}==
Line 3,277 ⟶ 3,864:
===Imperative===
<
{
var
Line 3,296 ⟶ 3,883:
factors(45); // [1,3,5,9,15,45]
factors(53); // [1,53]
factors(64); // [1,2,4,8,16,32,64]</
===Functional===
Line 3,304 ⟶ 3,891:
Translating the naive list comprehension example from Haskell, using a list monad for the comprehension
<
function chain(xs, f) {
return [].concat.apply([], xs.map(f));
Line 3,322 ⟶ 3,909:
}
factors_naive(6)</
Output:
<
Translating the Haskell (lows and highs) example
<
(function (lstTest) {
Line 3,387 ⟶ 3,974:
})([25, 45, 53, 64, 100, 102, 120, 12345, 32766, 32767])
);</
Output:
<
25 --> 1 5 25
Line 3,403 ⟶ 3,990:
32766 --> 1 2 3 6 43 86 127 129 254 258 381 762 5461 10922 16383 32766
32767 --> 1 7 31 151 217 1057 4681 32767
</syntaxhighlight>
====ES6====
<
'use strict';
Line 3,480 ⟶ 4,067:
) + '\n';
})([25, 45, 53, 64, 100, 102, 120, 12345, 32766, 32767]);</
{{Out}}
Line 3,500 ⟶ 4,087:
=={{header|jq}}==
{{Works with|jq|1.4}}
<
def factors:
. as $num
Line 3,515 ⟶ 4,102:
(45, 53, 64) | "\(.): \(factors)" ;
task</
{{Out}}
$ jq -n -M -r -c -f factors.jq
Line 3,523 ⟶ 4,110:
=={{header|Julia}}==
<
""" Return the factors of n, including 1, n """
function factors(n::T)::Vector{T} where T <: Integer
sort(vec(map(prod, Iterators.product((p.^(0:m) for (p,
end
Line 3,538 ⟶ 4,122:
@time println("The factors of $n are: $(factors(n))")
end
</syntaxhighlight>
{{out}}
<pre>
Line 3,547 ⟶ 4,131:
The factors of 53 are: [1, 53]
0.000102 seconds (35 allocations: 1.516 KiB)
The factors of 64 are: [1, 2, 4, 8, 16, 32, 64]
0.000093 seconds (56 allocations: 3.172 KiB)
Line 3,568 ⟶ 4,154:
=={{header|K}}==
<
equivalent to:
q)f:{i:{y where x=y*x div y}[x ; 1+ til floor sqrt x]; distinct i,x div reverse i}
Line 3,586 ⟶ 4,172:
/ Number of factors for 3491888400 .. 3491888409
#:'f' 3491888400+!10
1920 16 4 4 12 16 32 16 8 24</
=={{header|Kotlin}}==
<
if (n < 1) return
print("$n => ")
Line 3,601 ⟶ 4,187:
val numbers = intArrayOf(11, 21, 32, 45, 67, 96)
for (number in numbers) printFactors(number)
}</
{{out}}
Line 3,614 ⟶ 4,200:
=={{header|Lambdatalk}}==
<
{def factors
{def factors.r
Line 3,638 ⟶ 4,224:
-> 1 2 4 8 16 32 64
</syntaxhighlight>
=={{header|LFE}}==
Line 3,645 ⟶ 4,231:
This following function is elegant looking and concise. However, it will not handle large numbers well: it will consume a great deal of memory (on one large number, the function consumed 4.3GB of memory on my desktop machine):
<
(defun factors (n)
(list-comp
((<- i (when (== 0 (rem n i))) (lists:seq 1 (trunc (/ n 2)))))
i))
</syntaxhighlight>
===Non-Stack-Consuming===
This version will not consume the stack (this function only used 18MB of memory on my machine with a ridiculously large number):
<
(defun factors (n)
"Tail-recursive prime factors function."
Line 3,668 ⟶ 4,254:
((n k acc)
(factors n (+ k 1) acc)))
</syntaxhighlight>
{{out}}
Line 3,674 ⟶ 4,260:
> (factors 10677106534462215678539721403561279)
(104729 104729 104729 98731 98731 32579 29269 1)
</pre>
=={{header|Lingo}}==
<
res = [1]
repeat with i = 2 to n/2
Line 3,878 ⟶ 4,270:
res.add(n)
return res
end</
<
-- [1, 3, 5, 9, 15, 45]
put factors(53)
-- [1, 53]
put factors(64)
-- [1, 2, 4, 8, 16, 32, 64]</
=={{header|Logo}}==
<
output filter [equal? 0 modulo :n ?] iseq 1 :n
end
show factors 28 ; [1 2 4 7 14 28]</
=={{header|Lua}}==
<
local f = {}
Line 3,905 ⟶ 4,297:
return f
end</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
\\ Factors of an integer
\\ For act as BASIC's FOR (if N<1 no loop start)
Line 3,933 ⟶ 4,325:
CALL LikeM2000
</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang="maple">
numtheory:-divisors(n);
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
=={{header|MATLAB}} / {{header|Octave}}==
<
f = factor(n); % prime decomposition
K = dec2bin(0:2^length(f)-1)-'0'; % generate all possible permutations
Line 3,956 ⟶ 4,348:
disp(F);
end;
</
{{out}}
Line 3,976 ⟶ 4,368:
=={{header|Maxima}}==
The builtin <code>divisors</code> function does this.
<
(%o96) {1,2,4,5,10,20,25,50,100}</
Such a function could be implemented like so:
<
apply( cartesian_product,
map( lambda([fac],
setify(makelist(fac[1]^i, i, 0, fac[2]))),
ifactors(n))));</
=={{header|MAXScript}}==
<syntaxhighlight lang="maxscript">
fn factors n =
(
return (for i = 1 to n+1 where mod n i == 0 collect i)
)
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="maxscript">
factors 3
#(1, 3)
Line 4,006 ⟶ 4,398:
factors 54
#(1, 2, 3, 6, 9, 18, 27, 54)
</syntaxhighlight>
=={{header|Mercury}}==
Line 4,023 ⟶ 4,415:
===fac.m===
<
:- interface.
Line 4,062 ⟶ 4,454:
factor(N) = Factors :- factor(N, Factors).
:- end_module fac.</
===Use and output===
Line 4,074 ⟶ 4,466:
=={{header|min}}==
{{works with|min|0.19.6}}
<
(() 0 shorten) :new
(new (over swons 'pred dip) pick times nip) :iota
Line 4,089 ⟶ 4,481:
24 factors puts!
9 factors puts!
11 factors puts!</
=={{header|MiniScript}}==
<
result = [1]
for i in range(2, n)
Line 4,104 ⟶ 4,496:
if n <= 0 then break
print factors(n)
end while</
{{out}}
<pre>Number to factor (0 to quit)? 42
Line 4,123 ⟶ 4,515:
=={{header|MUMPS}}==
<
If num<1 Quit "Too small a number"
If num["." Quit "Not an integer"
Line 4,133 ⟶ 4,525:
w $$factors(45) ; [1,3,5,9,15,45]
w $$factors(53) ; [1,53]
w $$factors(64) ; [1,2,4,8,16,32,64]</
=={{header|Nanoquery}}==
<
for i in range(1, n / 2)
Line 4,143 ⟶ 4,535:
end
end
println n</
=={{header|NetRexx}}==
{{trans|REXX}}
<
* 21.04.2013 Walter Pachl
* 21.04.2013 add method main to accept argument(s)
Line 4,181 ⟶ 4,573:
If j*j=x Then /*for a square number as input */
lo=lo j /* add its square root */
return lo hi /* return both lists */</
{{out}}
Line 4,197 ⟶ 4,589:
=={{header|Nim}}==
<
proc factors(n: int): seq[int] =
Line 4,210 ⟶ 4,602:
result.sort()
echo factors(45)</
=={{header|Niue}}==
<
[ n not-factor [ , ] when ] else ] n times n ] 'factors ;
Line 4,223 ⟶ 4,615:
53 factors .s .clr ( => 1 53 ) newline
64 factors .s .clr ( => 1 2 4 8 16 32 64 ) newline
12 factors .s .clr ( => 1 2 3 4 6 12 ) </
=={{header|Oberon-2}}==
Oxford Oberon-2
<
MODULE Factors;
IMPORT Out,SYSTEM;
Line 4,293 ⟶ 4,685:
Out.Int(v.len,6);Out.String(" factors");Out.Ln
END Factors.
</syntaxhighlight>
{{out}}
<pre>
Line 4,304 ⟶ 4,696:
=={{header|Objeck}}==
<
use Structure;
Line 4,341 ⟶ 4,733:
}
}
}</
=={{header|OCaml}}==
<
let factors n =
List.filter (fun v -> (n mod v) = 0) (range n)</
=={{header|Odin}}==
Uses built-in dynamic arrays, and only checks up to the square root
<syntaxhighlight lang="odin">
package main
import "core:fmt"
import "core:slice"
factors :: proc(n: int) -> [dynamic]int {
d := 1
factors := make([dynamic]int)
for {
q := n / d
r := n % d
if d >= q {
if d == q && r == 0 {
append(&factors, d)
}
slice.sort(factors[:])
return factors
}
if r == 0 {
append(&factors, d, q)
}
d += 1
}
}
main :: proc() {
for n in ([?]int{100, 108, 999, 255, 256, 257}) {
a := factors(n)
fmt.println("The factors of", n, "are", a)
delete(a)
}
}
</syntaxhighlight>
{{Out}}
<pre>
The factors of 100 are [1, 2, 4, 5, 10, 20, 25, 50, 100]
The factors of 108 are [1, 2, 3, 4, 6, 9, 12, 18, 27, 36, 54, 108]
The factors of 999 are [1, 3, 9, 27, 37, 111, 333, 999]
The factors of 255 are [1, 3, 5, 15, 17, 51, 85, 255]
The factors of 256 are [1, 2, 4, 8, 16, 32, 64, 128, 256]
The factors of 257 are [1, 257]
</pre>
=={{header|Oforth}}==
<
120 factors println</
{{out}}
Line 4,361 ⟶ 4,801:
=={{header|Oz}}==
<
fun {Factors N}
Sqr = {Float.toInt {Sqrt {Int.toFloat N}}}
Line 4,380 ⟶ 4,820:
end
in
{Show {Factors 53}}</
=={{header|Panda}}==
Panda has a factor function already, it's defined as:
<
f where n.mod(1..n=>f)==0
45.factor</
=={{header|PARI/GP}}==
<syntaxhighlight lang
=={{header|Pascal}}==
{{trans|Fortran}}
{{works with|Free Pascal|2.6.2}}
<
var
i, number: integer;
Line 4,413 ⟶ 4,853:
write(i, number/i);
writeln;
end.</
{{out}}
<pre>
Line 4,429 ⟶ 4,869:
"runtime overhead" +25% instead +100% for quicksort against no sort.<BR>
Especially fast for consecutive integers.
<
// gets factors of consecutive integers fast
// limited to 1.2e11
Line 4,907 ⟶ 5,347:
AllFacsOut(Divs,true);
AllFacsOut(Divs,false);
end.</
{{out}}
<pre>
Line 4,930 ⟶ 5,370:
Real time: 13.082 s CPU share: 99.16 %
</pre>
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
function Factors(n: integer): List<integer>;
begin
var res := HSet(1,n);
for var i:=2 to n.Sqrt.Trunc do
if n.Divs(i) then
begin
res.Add(i);
res.Add(n div i);
end;
Result := res.Order.ToList;
end;
begin
foreach var x in |45,53,64| do
Println(x,Factors(x));
end.
</syntaxhighlight>
{{out}}
<pre>
45 [1,3,5,9,15,45]
53 [1,53]
64 [1,2,4,8,16,32,64]
</pre>
=={{header|Perl}}==
<
{
my($n) = @_;
return grep { $n % $_ == 0 }(1 .. $n);
}
print join ' ',factors(64), "\n";</
Or more intelligently:
<
my $n = shift;
$n = -$n if $n < 0;
Line 4,951 ⟶ 5,418:
@divisors, map { $_*$_ == $n ? () : int($n/$_) } reverse @divisors;
}
print join " ", factors(64), "\n";</
One could also use a module, e.g.:
{{libheader|ntheory}}
<
print join " ", divisors(12345678), "\n";
# Alternately something like: fordivisors { say } 12345678; </
=={{header|Phix}}==
There is a builtin factors(n), which takes an optional second parameter to include 1 and n:
<!--<
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">12345</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
{1,3,5,15,823,2469,4115,12345}
</pre>
You can find the implementation of factors(), prime_factors(), and
and mpz_factors(), mpz_prime_factors(), and mpz_pollard_rho() in mpfr.e for larger numbers, for example:
<div style="font-size: 11px">
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- [p2js/integer() bugs]</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3491888400</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"factors"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- {2,3,4,5,"...",698377680,872972100,1163962800.0,1745944200.0," (1,918 factors)"}</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3491888400</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"factors"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- {2,3,4,5,"...",698377680,872972100,1163962800.0,1745944200.0," (1,918 factors)"}
-- If the include1 parameter is 1 or "BOTH", then you'll also get 1 and 3491888400</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3491888400</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- {2,3,5,7,11,13,17,19}</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">prime_powers</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3491888400</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- <nowiki>{{</nowiki>2,4},{3,3},{5,2},{7,1},{11,1},{13,1},{17,1},{19,1<nowiki>}}</nowiki></span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">vslice</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"3491888400"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10000</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- {2,3,5,7,11,13,17,19}</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">mpz_prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"3491888400"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10000</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- <nowiki>{{</nowiki>2,4},{3,3},{5,2},{7,1},{11,1},{13,1},{17,1},{19,1<nowiki>}}</nowiki>
-- Note that mpz_prime_factors() only accepts string or mpz, and not a raw native atom/integer.</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">108233175859200</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- 666</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">108233175859200</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- 666</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"10677106534462215678539721403561279"</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">mpz_prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">d</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10000</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- <nowiki>{{</nowiki>29269,1},{32579,1},{98731,2},{104729,3<nowiki>}}</nowiki></span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">d</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"factors"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- {1,29269,"...","364792324112959639158827476291","10677106534462215678539721403561279"," (48 factors)"}</span>
<!--</syntaxhighlight>-->
</div>
Note the value in (string) d exceeds the precision limit of an IEEE-754 float, and would trigger a suitable human readable run-time error if passed to any of the non-mpz routines. Sadly, 1200034005600070000008900000000000000000 exceeds the capabilities of my mpz_pollard_rho(), which I had hoped to showcase - perhaps you would like to improve it?
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">/# Rosetta Code problem: http://rosettacode.org/wiki/Factors_of_an_integer
by Galileo, 05/2022 #/
include ..\Utilitys.pmt
def Factors >ps
( ( 1 tps 2 / ) for tps over mod if drop endif endfor ps> )
enddef
11 Factors
21 Factors
32 factors
45 factors
67 factors
96 factors
pstack</syntaxhighlight>
{{out}}
<pre>
[[1, 11], [1, 3, 7, 21], [1, 2, 4, 8, 16, 32], [1, 3, 5, 9, 15, 45], [1, 67], [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 96]]
=== Press any key to exit ===</pre>
=={{header|PHP}}==
<
$factors = array(1, $n);
for($i = 2; $i * $i <= $n; $i++){
Line 4,982 ⟶ 5,494:
sort($factors);
return $factors;
}</
=={{header|Picat}}==
===List comprehension===
<syntaxhighlight lang="picat">factors(N) = [[D,N // D] : D in 1..N.sqrt.floor, N mod D == 0].flatten.sort_remove_dups.</syntaxhighlight>
===Recursion===
{{trans|Prolog}}
<syntaxhighlight lang="picat">factors2(N,Fs) :-
integer(N),
N > 0,
Fs = findall(F,factors2_(N,F)).sort_remove_dups.
factors2_(N,F) :-
L = floor(sqrt(N)),
between(1,L,X),
0 == N mod X,
( F = X ; F = N // X ).</syntaxhighlight>
===Loop using set===
<syntaxhighlight lang="picat">factors3(N) = Set.keys.sort =>
Set = new_set(),
Set.put(1),
Set.put(N),
foreach(I in 1..floor(sqrt(N)), N mod I == 0)
Set.put(I),
Set.put(N//I)
end.</syntaxhighlight>
===Comparison===
Let's compare with 18! (6402373705728000) which has 14688 factors. The recursive version is slightly faster than the loop + set version.
<syntaxhighlight lang="picat">go =>
N = 6402373705728000, % factorial(18),
println("factors:"),
time(_Fs1 = factors(N)) ,
println("factors2:"),
time(factors2(N,_Fs2)),
println("factors3:"),
time(Fs3=factors3(N)).len),
</syntaxhighlight>
{{out}}
<pre>factors:
CPU time 3.938 seconds.
factors2:
CPU time 3.108 seconds.
factors3:
CPU time 3.159 seconds.</pre>
=={{header|PicoLisp}}==
<
(filter
'((D) (=0 (% N D)))
(range 1 N) ) )</
=={{header|PILOT}}==
<
A :#n
C :factor = 1
Line 5,002 ⟶ 5,567:
J :*Loop
*Finished
END:</
=={{header|PL/0}}==
{{trans|GW-BASIC}}
PL/0 does not handle strings. So, no prompt. The program waits for entering a number, and then displays the factors.
<syntaxhighlight lang="pascal">
var n, absn, ndiv2, i;
begin
? n;
absn := n;
if n < 0 then absn := -n;
ndiv2 := absn / 2;
i := 1;
while i <= ndiv2 do
begin
if (absn / i) * i = absn then ! i;
i := i + 1
end;
! absn;
end.
</syntaxhighlight>
4 runs.
{{in}}
<pre>1</pre>
{{out}}
<pre>
1
</pre>
{{in}}
<pre>11</pre>
{{out}}
<pre>
1
2
3
4
6
12
</pre>
{{in}}
<pre>13</pre>
{{out}}
<pre>
1
13
</pre>
{{in}}
<pre>-22222</pre>
{{out}}
<pre>
1
2
41
82
271
542
11111
22222
</pre>
=={{header|PL/I}}==
<
declare i binary( 15 )fixed;
declare n binary( 15 )fixed;
Line 5,015 ⟶ 5,638:
end;
end factors;
</syntaxhighlight>
{{out}}
Line 5,032 ⟶ 5,655:
</pre>
See also [[#Polyglot
=={{header|PL/M}}==
See [[#Polyglot:PL/I and PL/M]]
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">To run:
Start up.
Show the factors of 11.
Show the factors of 21.
Show the factors of 519.
Wait for the escape key.
Shut down.
To show the factors of a number:
Write "The factors of " then the number then ":" on the console.
Find a square root of the number.
Loop.
If a counter is past the square root, write "" on the console; exit.
Divide the number by the counter giving a quotient and a remainder.
If the remainder is 0, show the counter and the quotient.
Repeat.
A factor is a number.
To show a factor and another factor:
If the factor is not the other factor, write "" then the factor then " " then the other factor then " " on the console without advancing; exit.
Write "" then the factor on the console without advancing.</syntaxhighlight>
{{out}}
<pre>
The factors of 11:
1 11
The factors of 21:
1 21 3 7
The factors of 519:
1 519 3 173
</pre>
=={{header|Polyglot:PL/I and PL/M}}==
Line 5,044 ⟶ 5,700:
The PL/I include file "pg.inc" can be found on the [[Polyglot:PL/I and PL/M]] page.
Note the use of text in column 81 onwards to hide the PL/I specifics from the PL/M compiler.
<
/* PL/I DEFINITIONS */
Line 5,086 ⟶ 5,742:
CALL PRNL;
END;
EOF: end factors_100H;</
{{out}}
<pre>
Line 5,100 ⟶ 5,756:
FACTORS OF: 99: 1 3 9 11 33 99
FACTORS OF: 100: 1 2 4 5 10 20 25 50 100
</pre>
=={{header|PowerShell}}==
===Straightforward but slow===
<
1..$a | Where-Object { $a % $_ -eq 0 }
}</
This one uses a range of integers up to the target number and just filters it using the <code>Where-Object</code> cmdlet. It's very slow though, so it is not very usable for larger numbers.
===A little more clever===
<
1..[Math]::Sqrt($a) `
| Where-Object { $a % $_ -eq 0 } `
| ForEach-Object { $_; $a / $_ } `
| Sort-Object -Unique
}</
Here the range of integers is only taken up to the square root of the number, the same filtering applies. Afterwards the corresponding larger factors are calculated and sent down the pipeline along with the small ones found earlier.
=={{header|ProDOS}}==
Uses the math module:
<
do /delimspaces %% -a- >b
printline Factors of -a-: -b- </
=={{header|Prolog}}==
'''Simple Brute Force Implementation'''
<syntaxhighlight lang="prolog">
brute_force_factors( N , Fs ) :-
integer(N) ,
Line 5,165 ⟶ 5,788:
setof( F , ( between(1,N,F) , N mod F =:= 0 ) , Fs )
.
</syntaxhighlight>
'''A Slightly Smarter Implementation'''
<syntaxhighlight lang="prolog">
smart_factors(N,Fs) :-
integer(N) ,
Line 5,181 ⟶ 5,804:
( F = X ; F is N // X )
.
</syntaxhighlight>
Not every Prolog has <code>between/3</code>: you might need this:
<syntaxhighlight lang="prolog">
between(X,Y,Z) :-
Line 5,202 ⟶ 5,825:
between1(X1,Y,Z)
.
</syntaxhighlight>
{{out}}
Line 5,233 ⟶ 5,856:
N = 32767, Factors = [1, 7, 31, 151, 217, 1057, 4681, 32767] ;
N = 32767, Factors = [1, 7, 31, 151, 217, 1057, 4681, 32767] .
</pre>
=={{header|Python}}==
Naive and slow but simplest (check all numbers from 1 to n):
<
return [i for i in range(1, n + 1) if not n%i]</
Slightly better (realize that there are no factors between n/2 and n):
<
return [i for i in range(1, n//2 + 1) if not n%i] + [n]
>>> factors(45)
[1, 3, 5, 9, 15, 45]</
Much better (realize that factors come in pairs, the smaller of which is no bigger than sqrt(n)):
<syntaxhighlight lang
factors1,
if n % x == 0:
x += 1
if x * x == n:
factors1.append(x)
factors1.extend(reversed(factors2))
return factors1
for i in 45, 53, 64:
print("%i: factors: %s" % (i, factor(i)))</syntaxhighlight><pre>
45: factors: [1, 3, 5, 9, 15, 45]
53: factors: [1, 53]
64: factors: [1, 2, 4, 8, 16, 32, 64]</
More efficient when factoring many numbers:
<
def factors(n):
Line 5,310 ⟶ 5,908:
for e in prime_powers(n):
r += [a*b for a in r for b in e]
return r</
=={{header|Quackery}}==
<code>
The nest editing at the end of the definition (i.e. the code after the <code>drop</code> on a line by itself) removes a duplicate factor if there is one, and arranges the factors in ascending numerical order at the same time.
<syntaxhighlight lang="text"> [
[ times
[ dup i^ 1+ /mod iff
Line 5,339 ⟶ 5,923:
rot join
i^ 1+ join swap ]
drop
dup size 2 / split ]
if [ -1 split drop ]
swap join ] is factors ( n --> [ )
Line 5,351 ⟶ 5,935:
factors witheach
[ echo i if say ", " ]
cr ]</
{{out}}
Line 5,379 ⟶ 5,963:
=={{header|R}}==
===Array solution===
<
{
if(length(n) > 1)
Line 5,389 ⟶ 5,973:
one.to.n[(n %% one.to.n) == 0]
}
}</
{{out}}
<pre>
Line 5,404 ⟶ 5,988:
===Filter solution===
With identical output, a more idiomatic way is to use R's Filter.
<
#Vectorize is an interesting alternative to the previous solution's lapply.
manyFactors <- function(vec) Vectorize(factors)(vec)</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 5,440 ⟶ 6,024:
(time (length (divisors huge)))
;; And this one clocks at 17ms
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku"
=={{header|Red}}==
<
factors: function [n [integer!]] [
Line 5,486 ⟶ 6,055:
][
print mold/flat sort factors num
]</
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout <Factors 120>>;
}
Factors {
s.N = <Factors (s.N 1)>;
(s.N s.D), <Compare s.N <* s.D s.D>>: '-' = ;
(s.N s.D), <Divmod s.N s.D>: {
(s.D) 0 = s.D;
(s.F) 0 = s.D <Factors (s.N <+ 1 s.D>)> s.F;
(s.X) s.Y = <Factors (s.N <+ 1 s.D>)>;
};
};</syntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 8 10 12 15 20 24 30 40 60 120</pre>
=={{header|Relation}}==
<syntaxhighlight lang="relation">
program factors(num)
relation fact
Line 5,503 ⟶ 6,089:
print
end program
</syntaxhighlight>
=={{header|REXX}}==
Line 5,516 ⟶ 6,102:
This REXX version is about '''22%''' faster than the alternate REXX version (2<sup>nd</sup> version).
<
parse arg LO HI inc . /*obtain the optional args*/
HI= word(HI LO 20, 1); LO= word(LO 1,1); inc= word(inc 1,1) /*define the range options*/
Line 5,544 ⟶ 6,130:
end /*j*/ /* [↑] % ≡ integer division. ___*/
if sq.j==x then return a j b /*Was X a square? Then insert √ x */
return a b /*return the divisors of both lists. */</
{{out|output|text= when using the input of: <tt> -6 200 </tt>}}
Line 5,764 ⟶ 6,350:
===Alternate Version===
{{trans|REXX optimized version}}
<
* Program to calculate and show divisors of positive integer(s).
* 03.08.2012 Walter Pachl simplified the above somewhat
Line 5,795 ⟶ 6,381:
If j*j=x Then /*for a square number as input */
lo=lo j /* add its square root */
return lo hi /* return both lists */</
{{out|output|text= when using the default input:}}
Line 6,003 ⟶ 6,589:
=={{header|Ring}}==
<
nArray = list(100)
n = 45
Line 6,015 ⟶ 6,601:
see "" + nArray[i] + " "
next
</syntaxhighlight>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
≪ → n
≪ { } DUP 1 n √ '''FOR''' d
'''IF''' n d MOD NOT
'''THEN'''
d + n d /
'''IF''' DUP d ≠ '''THEN''' ROT + SWAP '''ELSE''' DROP '''END'''
'''END'''
'''NEXT'''
SWAP +
≫ ≫
'FACTS' STO
45 FACTS
53 FACTS
64 FACTS
{{out}}
<pre>
3: { 1 3 5 9 15 45 }
2: { 1 53 }
1: { 1 2 4 8 16 32 64 }
</pre>
=={{header|Ruby}}==
<
def factors() (1..self).select { |n| (self % n).zero? } end
end
p 45.factors</
[1, 3, 5, 9, 15, 45]
As we only have to loop up to <math>\sqrt{n}</math>, we can write
<
def factors
1.upto(Integer.sqrt(self)).select {|i| (self % i).zero?}.inject([]) do |f, i|
Line 6,033 ⟶ 6,643:
end
end
[45, 53, 64].each {|n| puts "#{n} : #{n.factors}"}</
{{out}}
<pre>
Line 6,041 ⟶ 6,651:
===Using the prime library===
<
require 'prime'
Line 6,054 ⟶ 6,664:
[1, 7, 45, 100].each{|n| p factors n}
</syntaxhighlight>
Output:
<pre>
Line 6,062 ⟶ 6,672:
[1, 2, 4, 5, 10, 20, 25, 50, 100]
</pre>
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn main() {
assert_eq!(vec![1, 2, 4, 5, 10, 10, 20, 25, 50, 100], factor(100)); // asserts that two expressions are equal to each other
assert_eq!(vec![1, 101], factor(101));
Line 6,120 ⟶ 6,691:
factors.sort(); // sorts the factors into numerical order for viewing purposes
factors // returns the factors
}</
Alternative functional version:
<
fn factor(n: i32) -> Vec<i32> {
(1..=n).filter(|i| n % i == 0).collect()
}
</syntaxhighlight>
=={{header|Sather}}==
<syntaxhighlight lang="sather">class MAIN is
factors!(n :INT):INT is
Line 6,158 ⟶ 6,728:
end;
end;
</syntaxhighlight>
=={{header|Scala}}==
Brute force approach:
<
(1 to num).filter { divisor =>
num % divisor == 0
}
}</
<
val list = (1 to math.sqrt(num).floor.toInt).filter(num
list ++ list.reverse.dropWhile(d => d*d == num).map(num / _)
}</syntaxhighlight>
=={{header|Scheme}}==
This implementation uses a naive trial division algorithm.
<
(define (*factors d)
(cond ((> d n) (list))
Line 6,184 ⟶ 6,753:
(display (factors 1111111))
(newline)</
{{out}}
Line 6,192 ⟶ 6,761:
=={{header|Seed7}}==
<
const proc: writeFactors (in integer: number) is func
Line 6,221 ⟶ 6,790:
writeFactors(number);
end for;
end func;</
{{out}}
Line 6,234 ⟶ 6,803:
A simple brute force method using an indexed partial function as a filter.
<
'''Slightly More Efficient Method'''
A slightly more efficient method, only going up to the sqrt(n).
<
let
factorPairs[i] :=
Line 6,247 ⟶ 6,816:
foreach i within 1 ... floor(sqrt(num));
in
join(factorPairs);</
=={{header|Sidef}}==
Built-in:
<
say divisors(2695) #=> [1, 5, 7, 11, 35, 49, 55, 77, 245, 385, 539, 2695]</
Trial-division (slow for large n):
<
gather {
{ |d|
Line 6,266 ⟶ 6,835:
[53, 64, 32766].each {|n|
say "divisors(#{n}): #{divisors(n)}"
}</
{{out}}
<pre>
Line 6,275 ⟶ 6,844:
=={{header|Slate}}==
<
[
[| :result |
result nextPut: 1.
n primesDo: [| :prime | result nextPut: prime]] writingAs: {}
].</
where <tt>primesDo:</tt> is a part of the standard numerics library:
<
"Decomposes the Integer into primes, applying the block to each (in increasing
order)."
Line 6,296 ⟶ 6,865:
[div: next.
next: next + 2] "Just looks at the next odd integer."
].</
=={{header|Smalltalk}}==
Copied from the Python example, but code added to the Integer built in class:
<syntaxhighlight lang="smalltalk">Integer>>factors
| a |
a := OrderedCollection new.
Line 6,308 ⟶ 6,875:
((self \\ i) = 0) ifTrue: [ a add: i ] ].
a add: self.
^a</
Then use as follows:
<
59 factors -> an OrderedCollection(1 59)
120 factors -> an OrderedCollection(1 2 3 4 5 6 8 10 12 15 20 24 30 40 60 120)
</syntaxhighlight>
=={{header|Standard ML}}==
Need to print the list because Standard ML truncates the display of
longer returned lists.
<
(
List.app (fn n => print(Int.toString n ^ " ")) ls;
Line 6,338 ⟶ 6,905:
factors'(n,1)
end;
</syntaxhighlight>
Call:
<
printIntList(factors 120)</
{{out}}
<pre>1 3 5 15 823 2469 4115 12345
Line 6,349 ⟶ 6,916:
=={{header|Swift}}==
Simple implementation:
<
return filter(1...n) { n % $0 == 0 }
}</
More efficient implementation:
<
func sqrt(x:Int) -> Int { return Int(sqrt(Double(x))) }
Line 6,371 ⟶ 6,938:
return sorted(result)
}</
Call:
<
println(factors(1))
println(factors(25))
println(factors(63))
println(factors(19))
println(factors(768))</
{{out}}
<pre>[1, 2, 4]
Line 6,389 ⟶ 6,956:
=={{header|Tailspin}}==
<
[1..351 -> \(when <?(351 mod $ <=0>)> do $! \)] -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 6,398 ⟶ 6,965:
=={{header|Tcl}}==
<
set factors {}
for {set i 1} {$i <= sqrt($n)} {incr i} {
Line 6,409 ⟶ 6,976:
puts [factors 64]
puts [factors 45]
puts [factors 53]</
{{out}}
Line 6,415 ⟶ 6,982:
1 3 5 9 15 45
1 53</pre>
=={{header|Uiua}}==
<syntaxhighlight lang="uiua">
Factors ← ◴⊂⟜(⇌÷)⊸(▽:⟜≡(=0◿)⊙¤⊸(↘1⇡+1⌊√))
⍚Factors {45 53 64}
</syntaxhighlight>
{{out}}
<pre>
{[1 3 5 9 15 45] [1 53] [1 2 4 8 16 32 64]}
</pre>
=={{header|UNIX Shell}}==
This should work in all Bourne-compatible shells, assuming the system has both <tt>sort</tt> and at least one of <tt>bc</tt> or <tt>dc</tt>.
<syntaxhighlight lang="text">factor() {
r=`echo "sqrt($1)" | bc` # or `echo $1 v p | dc`
i=1
Line 6,430 ⟶ 7,008:
done | sort -nu
}
</syntaxhighlight>
=={{header|Ursa}}==
This program takes an integer from the command line and outputs its factors.
<
set n (int args<1>)
Line 6,443 ⟶ 7,021:
end if
end for
out n endl console</
=={{header|Ursala}}==
The simple way:
<
#import nat
factors "n" = (filter not remainder/"n") nrange(1,"n")</
The complicated way:
<
Another idea would be to approximate an upper bound for the square root of <code>"n"</code> with some bit twiddling such as <code>&!*K31 "n"</code>, which evaluates to a binary number of all 1's half the width of "n" rounded up, and another would be to use the <code>division</code> function to get the quotient and remainder at the same time. Combining these ideas, losing the dummy variable, and cleaning up some other cruft, we have
<
where <code>nleq-<&</code> isn't strictly necessary unless an ordered list is required.
<
example = factors 100</
{{out}}
<pre><1,2,4,5,10,20,25,50,100></pre>
=={{header|Verilog}}==
<syntaxhighlight lang="verilog">
module main;
integer i, n;
Line 6,497 ⟶ 7,055:
end
endmodule
</syntaxhighlight>
{{out}}
<pre>
45 => 1 3 5 9 15 45
</pre>
=={{header|Wortel}}==
<
factors1 &n !-\%%n @to n
factors_tacit @(\\%% !- @to)
Line 6,513 ⟶ 7,070:
!factors1 720
]]
}</
Returns: <pre>[
[1 2 5 10]
Line 6,519 ⟶ 7,076:
[1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 30 36 40 45 48 60 72 80 90 120 144 180 240 360 720]
]</pre>
=={{header|V (Vlang)}}==
{{trans|Ring}}
<syntaxhighlight lang="Zig">
fn main() {
mut arr := []int{len: 100}
mut n, mut j := 45, 0
for i in 1..n + 1 {
if n % i == 0 {
j++
arr[j] = i
}
}
print("Factors of ${n} = ")
for i in 1..j + 1 {print(" ${arr[i]} ")}
}
</syntaxhighlight>
{{out}}
<pre>
Factors of 45 = 1 3 5 9 15 45
</pre>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
{{libheader|Wren-math}}
<
import "./math" for Int
var a = [11, 21, 32, 45, 67, 96, 159, 723, 1024, 5673, 12345, 32767, 123459, 999997]
System.print("The factors of the following numbers are:")
for (e in a)
{{out}}
<pre>
Line 6,550 ⟶ 7,129:
=={{header|X86 Assembly}}==
{{works with|nasm}}
<
section .bss
factorArr resd 250 ;big buffer against seg fault
Line 6,583 ⟶ 7,162:
mov esp, ebp ;garbage collecting
ret
</syntaxhighlight>
=={{header|XPL0}}==
<
int N0, N, F;
[N0:= 1;
Line 6,602 ⟶ 7,181:
N0:= N0+1;
until KeyHit;
]</
{{out}}
Line 6,638 ⟶ 7,217:
57097 = 57097
</pre>
=={{header|zkl}}==
{{trans|Chapel}}
<
'wrap(m){((n % m)==0) and T(m,n/m) or Void.Skip}) }
fcn g(n){ [[(m); [1..n.toFloat().sqrt()],'{n%m==0}; '{T(m,n/m)} ]] } // list comprehension</
{{out}}
<pre>
Line 6,679 ⟶ 7,231:
L(L(1,45),L(3,15),L(5,9))
</pre>
|