Factors of an integer: Difference between revisions
m
syntax highlighting fixup automation
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
|||
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
Line 580:
DONE: WRITE ("GOODBYE");
END</
{{out}}
<pre>NUMBER TO FACTOR (OR 0 TO QUIT):
Line 599:
=={{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 702:
end script
end if
end mReturn</
{{Out}}
<
----
===Straightforward===
<
set output to {}
Line 728:
end factors
factors(123456789)</
{{output}}
<
=={{header|Arc}}==
<syntaxhighlight lang="arc">
(= divisor (fn (num)
(= dlist '())
Line 748:
(map [rev _] (map [divisor _] '(45 53 60 64)))
</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="arc">
'(
(1 3 5 9 15 45)
Line 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 949:
</syntaxhighlight>
=={{header|Arturo}}==
<
select 1..num [x][
(num%x)=0
Line 958:
]
print factors 36</
{{out}}
Line 965:
=={{header|Asymptote}}==
<
for(var j : n) {
Line 976:
}
write(" ", j);
}</
{{out}}
<pre>11 => 1 11
Line 986:
=={{header|AutoHotkey}}==
<
Factors(n)
Line 994:
Sort, v, N U D,
Return, v
}</
{{out}}
Line 1,003:
=={{header|AutoIt}}==
<
$num = 45
MsgBox (0,"Factors", "Factors of " & $num & " are: " & factors($num))
Line 1,015:
Next
Return $ls_factors&$intg
EndFunc</
{{out}}
Line 1,023:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f FACTORS_OF_AN_INTEGER.AWK
BEGIN {
Line 1,042:
printf("\n")
}
</syntaxhighlight>
{{out}}
Line 1,063:
Note that this will error out if you pass 32767 (or higher).
<
REDIM SHARED factors(0) AS INTEGER
Line 1,103:
END IF
NEXT
END SUB</
{{out}}
Line 1,123:
==={{header|ASIC}}===
{{trans|GW-BASIC}}
<
REM Factors of an integer
PRINT "Enter an integer";
Line 1,138:
NEXT I
PRINT NA
END</
{{out}}
<pre>
Line 1,148:
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">
subroutine printFactors(n)
print n; " => ";
Line 1,164:
call printFactors(96)
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,172:
==={{header|GW-BASIC}}===
<
10 INPUT "Enter an integer: ", N
20 IF N = 0 THEN GOTO 10
Line 1,179:
50 IF NA MOD I = 0 THEN PRINT I;
60 NEXT I
70 PRINT NA</
{{out}}
<pre>
Line 1,193:
==={{header|IS-BASIC}}===
<
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</
==={{header|Minimal BASIC}}===
Line 1,204:
{{works with|Commodore BASIC}}
{{works with|Nascom ROM BASIC|4.7}}
<
10 REM Factors of an integer
20 PRINT "Enter an integer";
Line 1,216:
100 PRINT N1
110 END
</syntaxhighlight>
==={{header|Nascom BASIC}}===
{{trans|GW-BASIC}}
{{works with|Nascom ROM BASIC|4.7}}
<
10 REM Factors of an integer
20 INPUT "Enter an integer"; N
Line 1,231:
80 PRINT NA
90 END
</syntaxhighlight>
{{out}}
<pre>
Line 1,241:
==={{header|Sinclair ZX81 BASIC}}===
{{works with|Applesoft BASIC}}
<
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,251:
==={{header|Tiny BASIC}}===
<
110 INPUT I
120 LET C=1
Line 1,258:
150 LET C=C+1
160 IF C<=I THEN GOTO 140
170 END</
{{out}}
<pre>Give me a number:
Line 1,280:
==={{header|True BASIC}}===
{{trans|FreeBASIC}}
<
sub printfactors(n)
if n < 1 then exit sub
Line 1,298:
print
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,306:
=={{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,314:
:fac
set /a test = %1 %% %2
if %test% equ 0 set res=%res% %2</
{{out}}
Line 1,333:
Interactive version:
<
set /p limit=Gimme a number:
set res=Factors of %limit%:
Line 1,342:
:fac
set /a test = %1 %% %2
if %test% equ 0 set res=%res% %2</
{{out}}
Line 1,355:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
sort% = FN_sortinit(0, 0)
Line 1,379:
L$ += STR$(L%(I%)) + ", "
NEXT
= LEFT$(LEFT$(L$))</
{{out}}
Line 1,386:
=={{header|bc}}==
<
* This function mutates the global array f[] which will
* contain all factors of n in ascending order after the call!
Line 1,429:
scale = o
return(l)
}</
=={{header|Befunge}}==
<
>:0:g:*`| > >0:g1+0:p
>:0:g:*-#v_0:g\>$>:!#@_.v
> ^ ^ ," "<</
=={{header|BQN}}==
Line 1,441:
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,524:
}
return 0;
}</
===Prime factoring===
<
#include <stdlib.h>
#include <string.h>
Line 1,613:
return 0;
}</
{{out}}
Line 1,623:
=={{header|C sharp|C#}}==
===C# 1.0===
<
do {
Console.WriteLine ("Number:");
Line 1,643:
Console.WriteLine ("Done.");
} while (true);
}</
===C# 3.0===
<
using System.Collections.Generic;
using System.Linq;
Line 1,660:
Console.WriteLine (String.Join (", ", 45. Factors ()));
}
}</
{{out}}
Line 1,671:
=={{header|C++}}==
<
#include <iomanip>
#include <vector>
Line 1,704:
return EXIT_SUCCESS;
}</
{{out}}
Line 1,713:
=={{header|Ceylon}}==
<
{Integer*} getFactors(Integer n) =>
(1..n).filter((Integer element) => element.divides(n));
Line 1,720:
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,731:
}
}
}</
=={{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,786:
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,796:
=={{header|COBOL}}==
<
IDENTIFICATION DIVISION.
PROGRAM-ID. FACTORS.
Line 1,837:
END PROGRAM FACTORS.
</syntaxhighlight>
=={{header|CoffeeScript}}==
<
# robust--we'll use it to verify the more complicated (but hopefully faster)
# algorithm.
Line 1,898:
console.log n, factors
if n < 1000000
verify_factors factors, n</
{{out}}
Line 1,925:
=={{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,934:
(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,952:
f.sort
end
end</
'''Tests:'''
<
[45, 53, 64].each {|n| puts "#{n} : #{n.factors}"}</
{{out}}
<pre>
Line 1,965:
=={{header|D}}==
===Procedural Style===
<
T[] factors(T)(in T n) pure nothrow {
Line 1,987:
void main() {
writefln("%(%s\n%)", [45, 53, 64, 1111111].map!factors);
}</
{{out}}
<pre>[1, 3, 5, 9, 15, 45]
Line 1,995:
===Functional Style===
<
auto factors(I)(I n) {
Line 2,003:
void main() {
36.factors.writeln;
}</
{{out}}
<pre>[1, 2, 3, 4, 6, 9, 12, 18, 36]</pre>
Line 2,032:
=={{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 2,047:
[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 2,053:
=={{header|Dyalect}}==
<
for x in this when pred(x) {
yield x
Line 2,065:
for x in 45.Factors() {
print(x)
}</
Output:
Line 2,078:
=={{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 2,084:
}
return xfactors
}</
=={{header|EasyLang}}==
<syntaxhighlight lang="text">n = 720
for i = 1 to n
if n mod i = 0
Line 2,093:
.
.
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,116:
(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,129:
(time ( length (factors huge)))
→ (394ms 7776)
</syntaxhighlight>
=={{header|EDSAC order code}}==
Line 2,136:
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,290:
E 4 Z [define entry point]
P F [acc = 0 on entry]
</syntaxhighlight>
{{out}}
<pre>
Line 2,317:
===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,351:
IO.puts "#{name}\t prime count : #{value},\t#{time/1000000} sec"
end)
</syntaxhighlight>
{{out}}
Line 2,367:
=={{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,391:
divisors(K,N,_Q) ->
[K, N div K] ++ divisors(K+1,N,math:sqrt(N)).
</syntaxhighlight>
{{out}}
<pre>
Line 2,407:
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM FACTORS
Line 2,451:
PRINT("The factors of 12345 are ";L$)
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
Line 2,467:
{{Works with|Office 365 Betas 2021}}
<
IF(1 < n,
LET(
Line 2,490:
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,552:
)
)
)</
The '''FACTORS''' function, applied to an integer, defines a column of integer values.
Line 2,742:
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,771:
=={{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,787:
=={{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,793:
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,824:
0 :noname swap . ; <with-factors> (.factors)
: .factors (.factors) drop ;
</syntaxhighlight>
{{Out}}
<pre>
Line 2,837:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
implicit none
integer :: i, number
Line 2,856:
end if
end program</
=={{header|FreeBASIC}}==
<
Sub printFactors(n As Integer)
Line 2,878:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 2,899:
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,920:
=={{header|FutureBasic}}==
<
clear local mode
Line 2,969:
print @"Factors of 32434243 are:"; fn IntegerFactors( 32434243 )
HandleEvents</
Output:
Line 2,986:
=={{header|GAP}}==
<
DivisorsInt(Factorial(5));
# [ 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 ]
Line 3,005:
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 3,060:
fmt.Println(fs)
fmt.Println("Number of factors =", len(fs))
}</
{{out}}
Line 3,092:
=={{header|Gosu}}==
<
numbers.each(\ number -> printFactors(number))
Line 3,100:
(1 .. n/2).each(\ i -> {result += n % i == 0 ? "${i} " : ""})
print("${result}${n}")
}</
{{out}}
Line 3,114:
=={{header|Groovy}}==
A straight brute force approach up to the square root of ''N'':
<
if (target == 1) return [1L]
Line 3,126:
[1] + lowfactors + (0..<nhalf).collect { target.intdiv(lowfactors[it]) }.reverse() + [target]
}</
Test:
<
{{out}}
<pre>[number:1, factors:[1]]
Line 3,165:
=={{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,172:
factors = map product .
mapM (\(p,m)-> [p^i | i<-[0..m]]) . primePowerFactors</
Returns list of factors out of order, e.g.:
<Lang haskell>~> factors 42
[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,188:
Or, deriving cofactors from factors up to the square root:
<
integerFactors n
| 1 > n = []
Line 3,202:
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,208:
=== 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,226:
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,243:
[ 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,253:
[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,262:
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,284:
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,296:
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:
<
factors 420
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,333:
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,348:
factorsOfNumber 40
1 2 4 5 8 10 20 40</
Another approach:
<
factors=: (*/@:^"1 odometer@:>:)/@q:~&__</
See http://www.jsoftware.com/jwiki/Essays/Odometer
Line 3,359:
=={{header|Java}}==
{{works with|Java|5+}}
<
{
TreeSet<Long> factors = new TreeSet<Long>();
Line 3,371:
}
return factors;
}</
=={{header|JavaScript}}==
Line 3,377:
===Imperative===
<
{
var
Line 3,396:
factors(45); // [1,3,5,9,15,45]
factors(53); // [1,53]
factors(64); // [1,2,4,8,16,32,64]</
===Functional===
Line 3,404:
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,422:
}
factors_naive(6)</
Output:
<
Translating the Haskell (lows and highs) example
<
(function (lstTest) {
Line 3,487:
})([25, 45, 53, 64, 100, 102, 120, 12345, 32766, 32767])
);</
Output:
<
25 --> 1 5 25
Line 3,503:
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,580:
) + '\n';
})([25, 45, 53, 64, 100, 102, 120, 12345, 32766, 32767]);</
{{Out}}
Line 3,600:
=={{header|jq}}==
{{Works with|jq|1.4}}
<
def factors:
. as $num
Line 3,615:
(45, 53, 64) | "\(.): \(factors)" ;
task</
{{Out}}
$ jq -n -M -r -c -f factors.jq
Line 3,623:
=={{header|Julia}}==
<
function factors(n)
Line 3,638:
@time println("The factors of $n are: $(factors(n))")
end
</syntaxhighlight>
{{out}}
<pre>
Line 3,668:
=={{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,686:
/ 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,701:
val numbers = intArrayOf(11, 21, 32, 45, 67, 96)
for (number in numbers) printFactors(number)
}</
{{out}}
Line 3,714:
=={{header|Lambdatalk}}==
<
{def factors
{def factors.r
Line 3,738:
-> 1 2 4 8 16 32 64
</syntaxhighlight>
=={{header|LFE}}==
Line 3,745:
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,768:
((n k acc)
(factors n (+ k 1) acc)))
</syntaxhighlight>
{{out}}
Line 3,777:
=={{header|Liberty BASIC}}==
<
maxnFactors = 1000
dim primeFactors(maxnFactors), nPrimeFactors(maxnFactors)
Line 3,849:
next i
end if
end function</
{{out}}
<
10677106534462215678539721403561279 = 29269^1 * 32579^1 * 98731^2 * 104729^3
1 1
Line 3,902:
47 364792324112959639158827476291
48 10677106534462215678539721403561279
done</
===A Simpler Approach===
This is a somewhat simpler approach for finding the factors of smaller numbers (less than one million).
<syntaxhighlight lang="lb">
print "ROSETTA CODE - Factors of an integer"
'A simpler approach for smaller numbers
Line 3,944:
next y
end function
</syntaxhighlight>
{{out}}
Line 3,971:
=={{header|Lingo}}==
<
res = [1]
repeat with i = 2 to n/2
Line 3,978:
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 4,005:
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 4,033:
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 4,056:
disp(F);
end;
</
{{out}}
Line 4,076:
=={{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,106:
factors 54
#(1, 2, 3, 6, 9, 18, 27, 54)
</syntaxhighlight>
=={{header|Mercury}}==
Line 4,123:
===fac.m===
<
:- interface.
Line 4,162:
factor(N) = Factors :- factor(N, Factors).
:- end_module fac.</
===Use and output===
Line 4,174:
=={{header|min}}==
{{works with|min|0.19.6}}
<
(() 0 shorten) :new
(new (over swons 'pred dip) pick times nip) :iota
Line 4,189:
24 factors puts!
9 factors puts!
11 factors puts!</
=={{header|MiniScript}}==
<
result = [1]
for i in range(2, n)
Line 4,204:
if n <= 0 then break
print factors(n)
end while</
{{out}}
<pre>Number to factor (0 to quit)? 42
Line 4,223:
=={{header|MUMPS}}==
<
If num<1 Quit "Too small a number"
If num["." Quit "Not an integer"
Line 4,233:
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,243:
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,281:
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,297:
=={{header|Nim}}==
<
proc factors(n: int): seq[int] =
Line 4,310:
result.sort()
echo factors(45)</
=={{header|Niue}}==
<
[ n not-factor [ , ] when ] else ] n times n ] 'factors ;
Line 4,323:
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,393:
Out.Int(v.len,6);Out.String(" factors");Out.Ln
END Factors.
</syntaxhighlight>
{{out}}
<pre>
Line 4,404:
=={{header|Objeck}}==
<
use Structure;
Line 4,441:
}
}
}</
=={{header|OCaml}}==
<
let factors n =
List.filter (fun v -> (n mod v) = 0) (range n)</
=={{header|Oforth}}==
<
120 factors println</
{{out}}
Line 4,461:
=={{header|Oz}}==
<
fun {Factors N}
Sqr = {Float.toInt {Sqrt {Int.toFloat N}}}
Line 4,480:
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,513:
write(i, number/i);
writeln;
end.</
{{out}}
<pre>
Line 4,529:
"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 5,007:
AllFacsOut(Divs,true);
AllFacsOut(Divs,false);
end.</
{{out}}
<pre>
Line 5,032:
=={{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 5,051:
@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>
Line 5,071:
=={{header|Phixmonti}}==
<
by Galileo, 05/2022 #/
Line 5,087:
96 factors
pstack</
{{out}}
<pre>
Line 5,095:
=={{header|PHP}}==
<
$factors = array(1, $n);
for($i = 2; $i * $i <= $n; $i++){
Line 5,106:
sort($factors);
return $factors;
}</
=={{header|Picat}}==
===List comprehension===
<
===Recursion===
{{trans|Prolog}}
<
integer(N),
N > 0,
Line 5,123:
between(1,L,X),
0 == N mod X,
( F = X ; F = N // X ).</
===Loop using set===
<
Set = new_set(),
Set.put(1),
Line 5,133:
Set.put(I),
Set.put(N//I)
end.</
===Comparison===
Let's compare with 18! (6402373705728000) which has 14688 factors. The recursive version is slightly faster than the loop + set version.
<
N = 6402373705728000, % factorial(18),
println("factors:"),
Line 5,145:
println("factors3:"),
time(Fs3=factors3(N)).len),
</syntaxhighlight>
{{out}}
Line 5,162:
=={{header|PicoLisp}}==
<
(filter
'((D) (=0 (% N D)))
(range 1 N) ) )</
=={{header|PILOT}}==
<
A :#n
C :factor = 1
Line 5,179:
J :*Loop
*Finished
END:</
=={{header|PL/I}}==
<
declare i binary( 15 )fixed;
declare n binary( 15 )fixed;
Line 5,192:
end;
end factors;
</syntaxhighlight>
{{out}}
Line 5,216:
=={{header|Plain English}}==
<
Start up.
Show the factors of 11.
Line 5,237:
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.</
{{out}}
<pre>
Line 5,254:
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,296:
CALL PRNL;
END;
EOF: end factors_100H;</
{{out}}
<pre>
Line 5,314:
=={{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,342:
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,358:
( 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,379:
between1(X1,Y,Z)
.
</syntaxhighlight>
{{out}}
Line 5,413:
=={{header|PureBasic}}==
<
Protected i, lim=Round(sqr(n),#PB_Round_Up)
NewList F.i()
Line 5,433:
PrintFactors(Val(Input()))
Print(#CRLF$+#CRLF$+"Press ENTER to quit."): Input()
EndIf</
{{out}}
Line 5,443:
=={{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)):
<
>>> def factor(n):
factors = set()
Line 5,467:
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,487:
for e in prime_powers(n):
r += [a*b for a in r for b in e]
return r</
<syntaxhighlight lang="qb64">
'Task
'Compute the factors of a positive integer.
Line 5,504:
Wend
End
</syntaxhighlight>
=={{header|Quackery}}==
Line 5,512:
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"> [ 1
[ 2dup < not while
2 << again ]
Line 5,544:
factors witheach
[ echo i if say ", " ]
cr ]</
{{out}}
Line 5,572:
=={{header|R}}==
===Array solution===
<
{
if(length(n) > 1)
Line 5,582:
one.to.n[(n %% one.to.n) == 0]
}
}</
{{out}}
<pre>
Line 5,597:
===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,633:
(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|REALbasic}}==
<
'This function accepts an unsigned 64 bit integer as input and returns an array of unsigned 64 bit integers
Dim result() As UInt64
Line 5,653:
result.Append(num) 'Since a given number is always a factor of itself
Return result
End Function</
=={{header|Red}}==
<
factors: function [n [integer!]] [
Line 5,679:
][
print mold/flat sort factors num
]</
=={{header|Relation}}==
<syntaxhighlight lang="relation">
program factors(num)
relation fact
Line 5,696:
print
end program
</syntaxhighlight>
=={{header|REXX}}==
Line 5,709:
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,737:
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,957:
===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,988:
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,196:
=={{header|Ring}}==
<
nArray = list(100)
n = 45
Line 6,208:
see "" + nArray[i] + " "
next
</syntaxhighlight>
=={{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,226:
end
end
[45, 53, 64].each {|n| puts "#{n} : #{n.factors}"}</
{{out}}
<pre>
Line 6,234:
===Using the prime library===
<
require 'prime'
Line 6,247:
[1, 7, 45, 100].each{|n| p factors n}
</syntaxhighlight>
Output:
<pre>
Line 6,257:
=={{header|Run BASIC}}==
<
PRINT "Factors of 12345 are "; factorlist$(12345)
END
Line 6,288:
factorlist$ = factorlist$ + STR$(L(i)) + ", "
NEXT
end function</
{{out}}
Line 6,296:
=={{header|Rust}}==
<
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,313:
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}}==
<
factors!(n :INT):INT is
Line 6,351:
end;
end;
</syntaxhighlight>
=={{header|Scala}}==
Brute force approach:
<
(1 to num).filter { divisor =>
num % divisor == 0
}
}</
Brute force until sqrt(num) is enough, the code above can be edited as follows (Scala 3 enabled)
<
val list = (1 to math.sqrt(num).floor.toInt).filter(num % _ == 0)
list ++ list.reverse.dropWhile(d => d*d == num).map(num / _)
}</
=={{header|Scheme}}==
This implementation uses a naive trial division algorithm.
<
(define (*factors d)
(cond ((> d n) (list))
Line 6,376:
(display (factors 1111111))
(newline)</
{{out}}
Line 6,384:
=={{header|Seed7}}==
<
const proc: writeFactors (in integer: number) is func
Line 6,413:
writeFactors(number);
end for;
end func;</
{{out}}
Line 6,426:
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,439:
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,458:
[53, 64, 32766].each {|n|
say "divisors(#{n}): #{divisors(n)}"
}</
{{out}}
<pre>
Line 6,467:
=={{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,488:
[div: next.
next: next + 2] "Just looks at the next odd integer."
].</
=={{header|Smalltalk}}==
Line 6,494:
Copied from the Python example, but code added to the Integer built in class:
<
| a |
a := OrderedCollection new.
Line 6,500:
((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,530:
factors'(n,1)
end;
</syntaxhighlight>
Call:
<
printIntList(factors 120)</
{{out}}
<pre>1 3 5 15 823 2469 4115 12345
Line 6,541:
=={{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,563:
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,581:
=={{header|Tailspin}}==
<
[1..351 -> \(when <?(351 mod $ <=0>)> do $! \)] -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 6,590:
=={{header|Tcl}}==
<
set factors {}
for {set i 1} {$i <= sqrt($n)} {incr i} {
Line 6,601:
puts [factors 64]
puts [factors 45]
puts [factors 53]</
{{out}}
Line 6,611:
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,622:
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,635:
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}}
Line 6,656:
=={{header|VBA}}==
<
Application.Volatile
Dim i As Integer
Line 6,669:
Next i
If x <> 1 Then Factors = Factors & ", " & corresponding_factors
End Function</
{{out}}
<pre>cell formula is "=Factors(840)"
Line 6,676:
=={{header|Verilog}}==
<syntaxhighlight lang="verilog">
module main;
integer i, n;
Line 6,689:
end
endmodule
</syntaxhighlight>
{{out}}
<pre>
Line 6,697:
=={{header|Wortel}}==
<
factors1 &n !-\%%n @to n
factors_tacit @(\\%% !- @to)
Line 6,705:
!factors1 720
]]
}</
Returns: <pre>[
[1 2 5 10]
Line 6,715:
{{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) System.print("%(Fmt.d(6, e)) => %(Int.divisors(e))")</
{{out}}
<pre>
Line 6,742:
=={{header|X86 Assembly}}==
{{works with|nasm}}
<
section .bss
factorArr resd 250 ;big buffer against seg fault
Line 6,775:
mov esp, ebp ;garbage collecting
ret
</syntaxhighlight>
=={{header|XPL0}}==
<
int N0, N, F;
[N0:= 1;
Line 6,794:
N0:= N0+1;
until KeyHit;
]</
{{out}}
Line 6,833:
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<
sub printFactors(n)
if n < 1 then return 0 : fi
Line 6,851:
print
end
</syntaxhighlight>
{{out}}
<pre>
Line 6,860:
=={{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,874:
=={{header|ZX Spectrum Basic}}==
{{trans|AWK}}
<
20 IF n=0 THEN STOP
30 PRINT "Factors of ";n;": ";
Line 6,880:
50 IF FN m(n,i)=0 THEN PRINT i;" ";
60 NEXT i
70 DEF FN m(a,b)=a-INT (a/b)*b</
|