Factors of an integer: Difference between revisions

 

=={{header|Ada}}==

<lang Ada>with Ada.Text_IO;

with Ada.Command_Line;

 

=={{header|Aikido}}==

 

function factor (n:int) {

printvec (factor (45))

printvec (factor (25))

 

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

 

=={{header|AutoHotkey}}==

<lang AutoHotkey>msgbox, % factors(45) "`n" factors(53) "`n" factors(64)

 

Next

Return $ls_factors&$intg

<pre>

Output:

 

=={{header|BASIC}}==

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

<lang qbasic>DECLARE SUB factor (what AS INTEGER)

 

 

Interactive version:

<lang dos>@echo off

set /p limit=Gimme a number:

L$ += STR$(L%(I%)) + ", "

NEXT

Output:

<pre>The factors of 45 are 1, 3, 5, 9, 15, 45

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

}

 

C# 1.0

<lang csharp>static void Main(string[] args)

{

Console.WriteLine("Done.");

} while (true);

 

Example output:

 

=={{header|Clojure}}==

<lang lisp>(defn factors [n]

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

 

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.

<lang lisp>(defn factors [n]

(into (sorted-set)

 

Same idea, using for comprehensions.

<lang lisp>(defn factors [n]

(into (sorted-set)

 

=={{header|CoffeeScript}}==

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

# algorithm.

console.log n, factors

if n < 1000000

output

1 [ 1 ]

3 [ 1, 3 ]

11111111111,

33333333333,

 

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

<lang lisp>(defun factors (n &aux (lows '()) (highs '()))

(do ((limit (isqrt n)) (factor 1 (1+ factor)))

[1, 239, 4649, 1111111]</pre>

Functional style:

<lang d>import std.stdio, std.algorithm, std.range;

 

 

=={{header|E}}==

{{improve|E|Use a cleverer algorithm such as in the Common Lisp example.}}

<lang e>def factors(x :(int > 0)) {

var xfactors := []

return xfactors

}</lang>

 

=={{header|Ela}}==

 

===Using higher-order function===

<lang ela>open Core

 

 

===Using comprehension===

<lang ela>let factors m = [x \\ x <- [1..m] | m % x == 0]</lang>

 

64 .factors

100 .factors</lang>

 

=={{Header|Fortran}}==

end program</lang>

=={{header|GAP}}==

<lang gap># Built-in function

div2(Factorial(5));

# [ 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 ]</lang>

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

Test:

<lang groovy>((1..30) + [333333]).each { println ([number:it, factors:factorize(it)]) }</lang>

Output:

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

=={{Header|Haskell}}==

Using D. Amos module Primes [http://www.polyomino.f2s.com/david/haskell/codeindex.html] for finding prime factors

import Data.List

 

factors = map product.

 

=={{header|HicEst}}==

 

=={{header|J}}==

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

<lang J>q: 40

2 2 2 5</lang>

 

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

<lang J>__ q: 40

2 5

 

With this, we can form lists of each of the potential relevant powers of each of these prime factors

<lang J>((^ i.@>:)&.>/) __ q: 40</lang>

┌───────┬───┐

 

From here, it's a simple matter (<code>*/&>@{</code>) to compute all possible factors of the original number

<lang J>factors=: */&>@{@((^ i.@>:)&.>/)@q:~&__</lang>

 

 

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

Y=. y"_

/:~ ~. ( , Y%]) ( #~ 0=]|Y) 1+i.>.%:y

/ Number of factors for 3491888400 .. 3491888409

#:'f' 3491888400+!10

 

=={{header|Liberty BASIC}}==

maxnFactors = 1000

dim primeFactors(maxnFactors), nPrimeFactors(maxnFactors)

next i

end if

 

Outcome:

10677106534462215678539721403561279 = 29269^1 * 32579^1 * 98731^2 * 104729^3

1 1

47 364792324112959639158827476291

48 10677106534462215678539721403561279

 

=={{header|Logo}}==

 

show factors 28 ; [1 2 4 7 14 28]</lang>

=={{header|Lua}}==

<lang lua>function Factors( n )

=={{header|Mathematica}}==

<lang Mathematica>Factorize[n_Integer] := Divisors[n]</lang>

 

=={{header|MATLAB}} / {{header|Octave}}==

<lang Matlab> function fact(n);

f = factor(n); % prime decomposition

 

=={{header|Maxima}}==

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

<lang maxima>(%i96) divisors(100);

(%o96) {1,2,4,5,10,20,25,50,100}</lang>

 

Such a function could be implemented like so:

<lang maxima>divisors2(n) := map( lambda([l], lreduce("*", l)),

apply( cartesian_product,

 

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

use Structure;

 

}

}

 

=={{header|OCaml}}==

 

=={{header|Pascal}}==

<lang pascal>program Factors;

var

=={{header|Perl 6}}==

{{works with|Rakudo Star|2010-08}}

<lang perl6>sub factors (Int $n) {

sort +*, keys hash

 

=={{header|PHP}}==

$factors = array(1, $n);

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

 

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

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

 

=={{header|PowerShell}}==

;

sort(LC, L)

Output :

<pre> ?- factor(36, L).

64: factors: [1, 2, 4, 8, 16, 32, 64]</lang>

 

a, r = 1, [1]

while a * a < n:

 

=={{header|R}}==

{

if(length(n) > 1)

}

}

1 2 3 4 5 6 10 12 15 20 30 60

<pre>

[[1]]

 

=={{header|REXX}}==

parse arg low high .; if high=='' then high=low

 

else p.2=arg(k) p.2 /*build (descending) to "high" list.*/

end

Below is the output for the divisors for the first two hundred integers

when

1 200

is entred as arguments.

<pre style="height:30ex;overflow:scroll">

 

=={{header|Ruby}}==

<lang ruby>class Integer

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

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

 

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