Factors of an integer: Difference between revisions

 

=={{header|0815}}==

<:1:~>|~#:end:>~x}:str:/={^:wei:~%x<:a:x=$~

=}:wei:x<:1:+{>~>x=-#:fin:^:str:}:fin:{{~%

 

=={{header|11l}}==

{{trans|Python}}

 

V factors = Set[Int]()

L(x) 1..Int(sqrt(n))

 

L(i) (45, 53, 64)

 

{{out}}

=={{header|360 Assembly}}==

Very compact version.

FACTOR CSECT

USING FACTOR,R15 set base register

PG DC CL132' ' buffer

YREGS

{{out}}

<pre>

 

=={{header|68000 Assembly}}==

 

 

 

 

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program factorst64.s */

.include "../includeARM64.inc"

 

 

=={{header|ACL2}}==

(declare (xargs :measure (nfix (- n i))))

(cond ((zp (- n i))

 

(defun factors (n)

 

=={{header|Action!}}==

BYTE notFirst

CARD p

Test(6502)

Test(12345)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Factors_of_an_integer.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

{

var factors:Vector.<uint> = new Vector.<uint>();

if(n % i == 0)factors.push(i);

return factors;

 

=={{header|Ada}}==

with Ada.Command_Line;

procedure Factors is

end loop;

Ada.Text_IO.Put_Line (Positive'Image (Number) & ".");

 

=={{header|Aikido}}==

 

function factor (n:int) {

printvec (factor (45))

printvec (factor (25))

 

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

 

Note: The following implements generators, eliminating the need of declaring arbitrarily long '''int''' arrays for caching.

 

PROC gen factors = (INT n, YIELDINT yield)VOID: (

# OD # ));

print(new line)

{{out}}

<pre>

 

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

for i := 1 until 100 do testFactorsOf( i )

 

{{out}}

<pre>

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

 

DONE: WRITE ("GOODBYE");

 

{{out}}

<pre>NUMBER TO FACTOR (OR 0 TO QUIT):

 

=={{header|APL}}==

factors 12345

1 3 5 15 823 2469 4115 12345

factors 720

 

=={{header|AppleScript}}==

===Functional===

{{Trans|JavaScript}}

on integerFactors(n)

if n = 1 then

end script

end if

{{Out}}

----

 

===Straightforward===

 

set output to {}

end factors

 

 

{{output}}

 

 

=={{header|Arc}}==

(= divisor (fn (num)

(= dlist '())

 

(map [rev _] (map [divisor _] '(45 53 60 64)))

 

{{Out}}

'(

(1 3 5 9 15 45)

(1 2 4 8 16 32 64)

)

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program factorst.s */

 

 

 

=={{header|Arturo}}==

select 1..num [x][

(num%x)=0

]

 

{{out}}

 

<pre>1 2 3 4 6 9 12 18 36</pre>

 

=={{header|AutoHotkey}}==

 

Factors(n)

Sort, v, N U D,

Return, v

 

{{out}}

 

=={{header|AutoIt}}==

$num = 45

MsgBox (0,"Factors", "Factors of " & $num & " are: " & factors($num))

Next

Return $ls_factors&$intg

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f FACTORS_OF_AN_INTEGER.AWK

BEGIN {

printf("\n")

}

 

{{out}}

 

=={{header|BASIC}}==

 

==={{header|ASIC}}===

{{trans|GW-BASIC}}

PRINT "Enter an integer";

LOOP:

NEXT I

PRINT NA

{{out}}

 

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

subroutine printFactors(n)

print n; " => ";

call printFactors(67)

call printFactors(96)

{{out}}

<pre>

</pre>

 

 

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

10 INPUT "Enter an integer: ", N

20 IF N = 0 THEN GOTO 10

50 IF NA MOD I = 0 THEN PRINT I;

60 NEXT I

{{out}}

<pre>

 

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

 

==={{header|Minimal BASIC}}===

{{trans|GW-BASIC}}

{{works with|Commodore BASIC}}

{{works with|Nascom ROM BASIC|4.7}}

20 PRINT "Enter an integer";

30 INPUT N

90 NEXT I

100 PRINT N1

 

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

80 PRINT NA

90 END

{{out}}

See also [[#Minimal BASIC|Minimal BASIC]]

 

==={{header|Sinclair ZX81 BASIC}}===

20 FOR I=1 TO N

30 IF N/I=INT (N/I) THEN PRINT I;" ";

{{in}}

<pre>315</pre>

 

==={{header|Tiny BASIC}}===

110 INPUT I

120 LET C=1

150 LET C=C+1

160 IF C<=I THEN GOTO 140

{{out}}

<pre>Give me a number:

20

30

 

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

{{trans|FreeBASIC}}

for i = 1 to n / 2

next i

print n

 

print

 

=={{header|Batch File}}==

Command line version:

set res=Factors of %1:

for /L %%i in (1,1,%1) do call :fac %1 %%i

:fac

set /a test = %1 %% %2

 

{{out}}

 

Interactive version:

set /p limit=Gimme a number:

set res=Factors of %limit%:

:fac

set /a test = %1 %% %2

 

{{out}}

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!

scale = o

return(l)

 

=={{header|Befunge}}==

>:0:g:*`| > >0:g1+0:p

>:0:g:*-#v_0:g\>$>:!#@_.v

 

=={{header|BQN}}==

A bqncrate idiom.

 

 

•Show Factors 12345

 

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.

 

=={{header|Burlesque}}==

 

=={{header|C}}==

#include <stdlib.h>

 

}

return 0;

===Prime factoring===

#include <stdlib.h>

#include <string.h>

 

return 0;

 

{{out}}

=={{header|C sharp|C#}}==

===C# 1.0===

do {

Console.WriteLine ("Number:");

Console.WriteLine ("Done.");

} while (true);

 

===C# 3.0===

using System.Collections.Generic;

using System.Linq;

Console.WriteLine (String.Join (", ", 45. Factors ()));

}

 

{{out}}

 

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

#include <iomanip>

#include <vector>

 

return EXIT_SUCCESS;

 

{{out}}

 

=={{header|Ceylon}}==

{Integer*} getFactors(Integer n) =>

(1..n).filter((Integer element) => element.divides(n));

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 {

}

}

 

=={{header|Clojure}}==

(filter #(zero? (rem n %)) (range 1 (inc n))))

 

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

 

Same idea, using for comprehensions.

(into (sorted-set)

(reduce concat

(for [x (range 1 (inc (Math/sqrt n))) :when (zero? (rem n x))]

 

=={{header|CLU}}==

{{trans|Sather}}

x0: int := s/2

if x0=0 then return(s) end

stream$putl(po, "")

end

{{out}}

<pre>Factors of 3135: 1 3 1045 5 627 11 285 15 209 19 165 33 95 55 57 3135

 

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. FACTORS.

 

END PROGRAM FACTORS.

 

=={{header|CoffeeScript}}==

# robust--we'll use it to verify the more complicated (but hopefully faster)

# algorithm.

console.log n, factors

if n < 1000000

 

{{out}}

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

(when (zerop remainder)

(push factor lows)

 

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

 

Faster, by only checking values up to <math>\sqrt{n}</math>.

def factors

f = [] of Int32

f.sort

end

 

'''Tests:'''

{{out}}

<pre>

=={{header|D}}==

===Procedural Style===

 

T[] factors(T)(in T n) pure nothrow {

void main() {

writefln("%(%s\n%)", [45, 53, 64, 1111111].map!factors);

{{out}}

<pre>[1, 3, 5, 9, 15, 45]

 

===Functional Style===

 

auto factors(I)(I n) {

void main() {

36.factors.writeln;

{{out}}

<pre>[1, 2, 3, 4, 6, 9, 12, 18, 36]</pre>

=={{header|Dc}}==

=== Simple O(n) version ===

[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

{{out}}

Factors of 998877 are: 1 3 11 33 30269 90807 332959 998877

0m1.120s

=== Faster O(sqrt(n)) version ===

[Enter positive number: ]P ? sn

[Factors of ]P lnn [ are: ]P

[li lv <q ln li % 0=P li1+si lxx]dsxx

[lj 1>q lj1-sj Lbsi lpx lxx]dsxx AP

0m0.004s

=={{header|Delphi}}==

=={{header|Dyalect}}==

 

for x in this when pred(x) {

yield x

for x in 45.Factors() {

print(x)

 

Output:

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

}

return xfactors

 

=={{header|EasyLang}}==

for i = 1 to n

if n mod i = 0

.

.

 

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

(for/fold (divs'(1)) ((g (map ppows (group (prime-factors n)))))

(for*/list ((a divs) (b g)) (* a b))))))

{{out}}

(lib 'bigint)

(factors 666)

(time ( length (factors huge)))

→ (394ms 7776)

 

=={{header|EDSAC order code}}==

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

E 4 Z [define entry point]

P F [acc = 0 on entry]

{{out}}

<pre>

 

===Using higher-order function===

 

 

===Using comprehension===

 

=={{header|Elixir}}==

def factor(1), do: [1]

def factor(n) do

IO.puts "#{name}\t prime count : #{value},\t#{time/1000000} sec"

end)

 

{{out}}

factor prime count : 1229, 7.316 sec

divisor prime count : 1229, 0.265 sec

</pre>

 

=={{header|Erlang}}==

===with Built in fuctions===

 

===Recursive===

Another, less concise, but faster version

 

-module(divs).

divisors(K,N,_Q) ->

[K, N div K] ++ divisors(K+1,N,math:sqrt(N)).

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM FACTORS

 

PRINT("The factors of 12345 are ";L$)

END PROGRAM

{{out}}

<pre>

 

{{Works with|Office 365 Betas 2021}}

IF(1 < n,

LET(

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,

)

)

 

The '''FACTORS''' function, applied to an integer, defines a column of integer values.

 

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

 

{{out}}

 

=={{header|FALSE}}==

 

=={{header|Fish}}==

>i:0(?v'0'%+a*

>~a,:1:>r{% ?vr:nr','ov

^:&:;?(&:+1r:< <

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>

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

 

53 .factors

64 .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.

: sq s" dup *" evaluate ; immediate

 

0 :noname swap . ; <with-factors> (.factors)

: .factors (.factors) drop ;

{{Out}}

<pre>

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

integer :: i, number

end if

 

=={{header|Frink}}==

The following produces all factors of n, including 1 and n:

 

 

=={{header|FunL}}==

Function to compute set of factors:

 

Test:

{{out}}

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 ]

 

div2(Factorial(5));

 

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

fmt.Println(fs)

fmt.Println("Number of factors =", len(fs))

 

{{out}}

 

=={{header|Gosu}}==

numbers.each(\ number -> printFactors(number))

 

(1 .. n/2).each(\ i -> {result += n % i == 0 ? "${i} " : ""})

print("${result}${n}")

 

{{out}}

=={{header|Groovy}}==

A straight brute force approach up to the square root of ''N'':

 

if (target == 1) return [1L]

[1] + lowfactors + (0..<nhalf).collect { target.intdiv(lowfactors[it]) }.reverse() + [target]

 

Test:

{{out}}

<pre>[number:1, factors:[1]]

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

 

factors = map product .

 

Returns list of factors out of order, e.g.:

 

 

Or, [[Prime_decomposition#Haskell|prime decomposition task]] can be used (although, a trial division-only version will become very slow for large primes),

 

 

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".

Or, deriving cofactors from factors up to the square root:

 

integerFactors n

| 1 > n = []

where

part n

| otherwise = id

(square, lows) =

 

main :: IO ()

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

=== List comprehension ===

Naive, functional, no import, in increasing order:

[ i

| i <- [1 .. n]

 

Factor, ''cofactor''. Get the list of factor&ndash;cofactor pairs sorted, for a quadratic speedup:

 

factorsCo n =

i :

[ d

 

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

[ i

| i <- [1 .. r - 1]

Testing:

~> factorsO 120

[1,2,3,4,5,6,8,10,12,15,20,24,30,40,60,120]

[1,7,41,287,541,3787,22181,77551,155267,542857,3179591,22257137,41955091,2936856

37,1720158731,12041111117]

 

=={{header|HicEst}}==

 

DO i = 1, N^0.5

ENDDO

 

 

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

 

 

{{out}}

 

{{libheader|Icon Programming Library}} [http://www.cs.arizona.edu/icon/library/src/procs/factors.icn divisors]

 

=={{header|J}}==

The "brute force" approach is the most concise:

 

 

Example use:

 

 

Basically we test every non-negative integer up through the number itself to see if it divides evenly.

 

J has a primitive, q: which returns its argument's prime factors.

 

Alternatively, q: can produce provide a table of the exponents of the unique relevant prime factors

2 3 5 7

 

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

 

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:

 

 

A less efficient, but concise variation on this theme:

 

 

This computes 2^n intermediate values where n is the number of prime factors of the original number.

That said, note that we get a representation issue when dealing with large numbers:

 

 

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:

 

 

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

 

factorsOfNumber 40

 

Another approach:

 

 

 

=={{header|Java}}==

{{works with|Java|5+}}

{

TreeSet<Long> factors = new TreeSet<Long>();

}

return factors;

 

=={{header|JavaScript}}==

===Imperative===

 

{

var

factors(45); // [1,3,5,9,15,45]

factors(53); // [1,53]

 

===Functional===

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));

}

 

 

Output:

 

Translating the Haskell (lows and highs) example

 

(function (lstTest) {

 

 

})([25, 45, 53, 64, 100, 102, 120, 12345, 32766, 32767])

 

Output:

 

 

25 --> 1 5 25

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

 

 

====ES6====

 

'use strict';

 

) + '\n';

 

 

{{Out}}

=={{header|jq}}==

{{Works with|jq|1.4}}

def factors:

. as $num

(45, 53, 64) | "\(.): \(factors)" ;

 

{{Out}}

$ jq -n -M -r -c -f factors.jq

 

=={{header|Julia}}==

 

end

 

@time println("The factors of $n are: $(factors(n))")

end

{{out}}

<pre>

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)

 

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

/ Number of factors for 3491888400 .. 3491888409

#:'f' 3491888400+!10

 

=={{header|Kotlin}}==

if (n < 1) return

print("$n => ")

val numbers = intArrayOf(11, 21, 32, 45, 67, 96)

for (number in numbers) printFactors(number)

 

{{out}}

 

=={{header|Lambdatalk}}==

{def factors

{def factors.r

-> 1 2 4 8 16 32 64

 

 

=={{header|LFE}}==

 

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

 

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

((n k acc)

(factors n (+ k 1) acc)))

 

{{out}}

> (factors 10677106534462215678539721403561279)

(104729 104729 104729 98731 98731 32579 29269 1)

</pre>

 

=={{header|Lingo}}==

res = [1]

repeat with i = 2 to n/2

res.add(n)

return res

-- [1, 3, 5, 9, 15, 45]

put factors(53)

-- [1, 53]

put factors(64)

 

=={{header|Logo}}==

output filter [equal? 0 modulo :n ?] iseq 1 :n

end

 

 

=={{header|Lua}}==

local f = {}

return f

 

=={{header|M2000 Interpreter}}==

\\ Factors of an integer

\\ For act as BASIC's FOR (if N<1 no loop start)

CALL LikeM2000

 

 

=={{header|Maple}}==

 

numtheory:-divisors(n);

 

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

disp(F);

end;

 

{{out}}

=={{header|Maxima}}==

The builtin <code>divisors</code> function does this.

 

Such a function could be implemented like so:

apply( cartesian_product,

map( lambda([fac],

setify(makelist(fac[1]^i, i, 0, fac[2]))),

 

=={{header|MAXScript}}==

fn factors n =

(

return (for i = 1 to n+1 where mod n i == 0 collect i)

)

 

{{out}}

factors 3

#(1, 3)

factors 54

#(1, 2, 3, 6, 9, 18, 27, 54)

 

=={{header|Mercury}}==

 

===fac.m===

 

:- interface.

factor(N) = Factors :- factor(N, Factors).

 

 

===Use and output===

=={{header|min}}==

{{works with|min|0.19.6}}

(() 0 shorten) :new

(new (over swons 'pred dip) pick times nip) :iota

24 factors puts!

9 factors puts!

 

=={{header|MiniScript}}==

result = [1]

for i in range(2, n)

if n <= 0 then break

print factors(n)

{{out}}

<pre>Number to factor (0 to quit)? 42

 

=={{header|MUMPS}}==

If num<1 Quit "Too small a number"

If num["." Quit "Not an integer"

w $$factors(45) ; [1,3,5,9,15,45]

w $$factors(53) ; [1,53]

 

=={{header|Nanoquery}}==

 

for i in range(1, n / 2)

end

end

 

=={{header|NetRexx}}==

{{trans|REXX}}

* 21.04.2013 Walter Pachl

* 21.04.2013 add method main to accept argument(s)

If j*j=x Then /*for a square number as input */

lo=lo j /* add its square root */

 

{{out}}

 

=={{header|Nim}}==

proc factors(n: int): seq[int] =

result.sort()

 

=={{header|Niue}}==

[ n not-factor [ , ] when ] else ] n times n ] 'factors ;

 

53 factors .s .clr ( => 1 53 ) newline

64 factors .s .clr ( => 1 2 4 8 16 32 64 ) newline

 

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE Factors;

IMPORT Out,SYSTEM;

Out.Int(v.len,6);Out.String(" factors");Out.Ln

END Factors.

{{out}}

<pre>

 

=={{header|Objeck}}==

use Structure;

 

}

}

 

=={{header|OCaml}}==

 

let factors n =

 

=={{header|Oforth}}==

 

 

 

{{out}}

 

=={{header|Oz}}==

fun {Factors N}

Sqr = {Float.toInt {Sqrt {Int.toFloat N}}}

end

in

 

=={{header|Panda}}==

Panda has a factor function already, it's defined as:

f where n.mod(1..n=>f)==0

 

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

{{trans|Fortran}}

{{works with|Free Pascal|2.6.2}}

var

i, number: integer;

write(i, number/i);

writeln;

{{out}}

<pre>

"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

AllFacsOut(Divs,true);

AllFacsOut(Divs,false);

{{out}}

<pre>

 

=={{header|Perl}}==

{

my($n) = @_;

return grep { $n % $_ == 0 }(1 .. $n);

}

 

Or more intelligently:

 

my $n = shift;

$n = -$n if $n < 0;

@divisors, map { $_*$_ == $n ? () : int($n/$_) } reverse @divisors;

}

 

One could also use a module, e.g.:

{{libheader|ntheory}}

print join " ", divisors(12345678), "\n";

 

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

 

=={{header|Phixmonti}}==

by Galileo, 05/2022 #/

 

96 factors

 

{{out}}

<pre>

 

=={{header|PHP}}==

$factors = array(1, $n);

for($i = 2; $i * $i <= $n; $i++){

sort($factors);

return $factors;

 

=={{header|Picat}}==

===List comprehension===

 

===Recursion===

{{trans|Prolog}}

integer(N),

N > 0,

between(1,L,X),

0 == N mod X,

 

===Loop using set===

Set = new_set(),

Set.put(1),

Set.put(I),

Set.put(N//I)

 

===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:"),

println("factors3:"),

time(Fs3=factors3(N)).len),

 

{{out}}

 

=={{header|PicoLisp}}==

(filter

'((D) (=0 (% N D)))

 

=={{header|PILOT}}==

A :#n

C :factor = 1

J :*Loop

*Finished

 

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

declare i binary( 15 )fixed;

declare n binary( 15 )fixed;

end;

end factors;

 

{{out}}

 

=={{header|Plain English}}==

Start up.

Show the factors of 11.

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.

{{out}}

<pre>

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

CALL PRNL;

END;

{{out}}

<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

 

=={{header|Prolog}}==

 

'''Simple Brute Force Implementation'''

brute_force_factors( N , Fs ) :-

integer(N) ,

setof( F , ( between(1,N,F) , N mod F =:= 0 ) , Fs )

.

 

'''A Slightly Smarter Implementation'''

smart_factors(N,Fs) :-

integer(N) ,

( F = X ; F is N // X )

.

 

Not every Prolog has <code>between/3</code>: you might need this:

 

 

between(X,Y,Z) :-

between1(X1,Y,Z)

.

 

{{out}}

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):

 

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)

 

Much better (realize that factors come in pairs, the smaller of which is no bigger than sqrt(n)):

if n % x == 0:

 

45: factors: [1, 3, 5, 9, 15, 45]

53: factors: [1, 53]

 

More efficient when factoring many numbers:

 

def factors(n):

for e in prime_powers(n):

r += [a*b for a in r for b in e]

 

=={{header|Quackery}}==

 

 

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.

 

[ times

[ dup i^ 1+ /mod iff

rot join

i^ 1+ join swap ]

if [ -1 split drop ]

swap join ] is factors ( n --> [ )

factors witheach

[ echo i if say ", " ]

 

{{out}}

=={{header|R}}==

===Array solution===

{

if(length(n) > 1)

one.to.n[(n %% one.to.n) == 0]

}

{{out}}

<pre>

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

 

=={{header|Racket}}==

 

#lang racket

 

(time (length (divisors huge)))

;; And this one clocks at 17ms

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

 

=={{header|Red}}==

 

factors: function [n [integer!]] [

][

print mold/flat sort factors num

 

=={{header|Relation}}==

program factors(num)

relation fact

print

end program

 

=={{header|REXX}}==

 

This REXX version is about &nbsp; '''22%''' &nbsp; faster than the alternate REXX version &nbsp; (2^nd 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*/

end /*j*/ /* [↑] % ≡ integer division. ___*/

if sq.j==x then return a j b /*Was X a square? Then insert √ x */

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> -6 &nbsp; 200 </tt>}}

 

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

If j*j=x Then /*for a square number as input */

lo=lo j /* add its square root */

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

 

 

=={{header|Ring}}==

nArray = list(100)

n = 45

see "" + nArray[i] + " "

next

 

=={{header|Ruby}}==

def factors() (1..self).select { |n| (self % n).zero? } end

end

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

end

end

{{out}}

<pre>

 

===Using the prime library===

require 'prime'

 

 

[1, 7, 45, 100].each{|n| p factors n}

Output:

<pre>

[1, 2, 4, 5, 10, 20, 25, 50, 100]

</pre>

 

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

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()

}

 

=={{header|Sather}}==

 

factors!(n :INT):INT is

end;

end;

 

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

 

(display (factors 1111111))

 

{{out}}

 

=={{header|Seed7}}==

 

const proc: writeFactors (in integer: number) is func

writeFactors(number);

end for;

 

{{out}}

 

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

foreach i within 1 ... floor(sqrt(num));

in

 

=={{header|Sidef}}==

Built-in:

 

Trial-division (slow for large n):

 

gather {

{ |d|

[53, 64, 32766].each {|n|

say "divisors(#{n}): #{divisors(n)}"

{{out}}

<pre>

 

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

[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:

| a |

a := OrderedCollection new.

((self \\ i) = 0) ifTrue: [ a add: i ] ].

a add: self.

 

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)

 

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

factors'(n,1)

end;

Call:

{{out}}

<pre>1 3 5 15 823 2469 4115 12345

=={{header|Swift}}==

Simple implementation:

return filter(1...n) { n % $0 == 0 }

More efficient implementation:

 

func sqrt(x:Int) -> Int { return Int(sqrt(Double(x))) }

return sorted(result)

Call:

println(factors(1))

println(factors(25))

println(factors(63))

println(factors(19))

{{out}}

<pre>[1, 2, 4]

 

=={{header|Tailspin}}==

[1..351 -> \(when <?(351 mod $ <=0>)> do $! \)] -> !OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

set factors {}

for {set i 1} {$i <= sqrt($n)} {incr i} {

puts [factors 64]

puts [factors 45]

 

{{out}}

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

 

r=`echo "sqrt($1)" | bc` # or `echo $1 v p | dc`

i=1

done | sort -nu

}

 

=={{header|Ursa}}==

This program takes an integer from the command line and outputs its factors.

set n (int args<1>)

 

end if

end for

 

=={{header|Ursala}}==

The simple way:

#import nat

 

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.

 

 

{{out}}

<pre><1,2,4,5,10,20,25,50,100></pre>

 

=={{header|Verilog}}==

module main;

integer i, n;

end

endmodule

{{out}}

<pre>

45 => 1 3 5 9 15 45

</pre>

 

=={{header|Wortel}}==

factors1 &n !-\%%n @to n

factors_tacit @(\\%% !- @to)

!factors1 720

]]

Returns: <pre>[

[1 2 5 10]

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

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

 

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:")

{{out}}

<pre>

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

{{works with|nasm}}

section .bss

factorArr resd 250 ;big buffer against seg fault

mov esp, ebp ;garbage collecting

ret

 

=={{header|XPL0}}==

int N0, N, F;

[N0:= 1;

N0:= N0+1;

until KeyHit;

 

{{out}}

57097 = 57097

</pre>

 

=={{header|zkl}}==

{{trans|Chapel}}

'wrap(m){((n % m)==0) and T(m,n/m) or Void.Skip}) }

{{out}}

<pre>

L(L(1,45),L(3,15),L(5,9))

</pre>