Count in factors: Difference between revisions
Content added Content deleted
No edit summary |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 24:
=={{header|11l}}==
{{trans|C++}}<
I li == 1
R ‘1’
Line 43:
L(x) 1..17
print(‘#4: #.’.format(x, get_prime_factors(x)))
print(‘2144: ’get_prime_factors(2144))</
{{out}}
Line 68:
=={{header|360 Assembly}}==
<
COUNTFAC CSECT assist plig\COUNTFAC
USING COUNTFAC,R13 base register
Line 141:
PG DS CL80 buffer
YREGS
END COUNTFAC</
{{out}}
<pre style="height:20ex">
Line 187:
=={{header|Action!}}==
<
BYTE notFirst
CARD p
Line 220:
PutE()
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Count_in_factors.png Screenshot from Atari 8-bit computer]
Line 243:
;count.adb:
<
procedure Count is
Line 272:
exit when N > Max_N;
end loop;
end Count;</
{{out}}
Line 292:
=={{header|ALGOL 68}}==
{{trans|Euphoria}}<
BEGIN
[⌈a + 1] INT c;
Line 327:
OD;
print ((new line))
OD</
{{out}}
<pre>1 = 1
Line 353:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program countFactors.s */
Line 735:
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
<pre>
Number 2144 : 2 2 2 2 2 67
Line 741:
=={{header|Arturo}}==
<
fs: [1]
if x<>1 -> fs: factors.prime x
print [pad to :string x 3 "=" join.with:" x " to [:string] fs]
]</
{{out}}
Line 782:
=={{header|AutoHotkey}}==
{{trans|D}}
<
if n = 1
return 1
Line 798:
Loop 22
out .= A_Index ": " factorize(A_index) "`n"
MsgBox % out</
{{out}}
<pre>1: 1
Line 824:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f COUNT_IN_FACTORS.AWK
BEGIN {
Line 851:
return(substr(f,1,length(f)-1))
}
</syntaxhighlight>
<p>output:</p>
<pre>
Line 878:
==={{header|Applesoft BASIC}}===
<
110 GOSUB 200"FACTORIAL
120 PRINT I" = "FA$
Line 897:
300 NEXT F
310 FA$ = MID$ (FA$,O)
320 RETURN </
==={{header|BASIC256}}===
{{trans|Run BASIC}}
<
print i; " = "; factorial$(i)
next i
Line 920:
end while
return factor$
end function</
==={{header|True BASIC}}===
{{trans|Run BASIC}}
<
LET f$ = ""
LET x$ = ""
Line 944:
PRINT i; "= "; factorial$(i)
NEXT i
END</
==={{header|Yabasic}}===
{{trans|Run BASIC}}
<
print i, " = ", factorial$(i)
next i
Line 968:
wend
return f$
end sub</
=={{header|BBC BASIC}}==
<
PRINT i% " = " FNfactors(i%)
NEXT
Line 989:
ENDWHILE
= LEFT$(f$, LEN(f$) - 3)
</syntaxhighlight>
Output:
<pre> 1 = 1
Line 1,015:
Lists the first 100 entries in the sequence. If you wish to extend that, the upper limit is implementation dependent, but may be as low as 130 for an interpreter with signed 8 bit data cells (131 is the first prime outside that range).
<
$<<<^_@#-"e":+1,+55$2<<<
v4_^#-1:/.:g00_00g1+>>0v
>8*"x",,:00g%!^!%g00:p0<</
{{out}}
Line 1,041:
=={{header|C}}==
Code includes a dynamically extending prime number list. The program doesn't stop until you kill it, or it runs out of memory, or it overflows.
<
#include <stdlib.h>
Line 1,104:
}
return 0;
}</
{{out}}
<pre>1 = 1
Line 1,125:
=={{header|C sharp|C#}}==
<
using System.Collections.Generic;
Line 1,170:
}
}
}</
=={{header|C++}}==
<
#include <iomanip>
using namespace std;
Line 1,207:
cout << "\n\n";
return system( "pause" );
}</
{{out}}
<pre>
Line 1,240:
=={{header|Clojure}}==
<
(:gen-class))
Line 1,260:
(doseq [q (range 1 26)]
(println q " = " (clojure.string/join " x "(factors q))))
</syntaxhighlight>
{{Output}}
<pre>
Line 1,291:
=={{header|CoffeeScript}}==
<
# Count through the natural numbers and give their prime
# factorization. This algorithm uses no division.
Line 1,330:
num_primes = count_primes 10000
console.log num_primes</
=={{header|Common Lisp}}==
Auto extending prime list:
<
(make-array 10 :adjustable t :fill-pointer 0 :element-type 'integer))
Line 1,360:
(loop for n from 1 do
(format t "~a: ~{~a~^ × ~}~%" n (reverse (factors n))))</
{{out}}
<pre>1:
Line 1,378:
...</pre>
Without saving the primes, and not all that much slower (probably because above code was not well-written):
<
(loop with res for x from 2 to (isqrt n) do
(loop while (zerop (rem n x)) do
Line 1,386:
(loop for n from 1 do
(format t "~a: ~{~a~^ × ~}~%" n (reverse (factors n))))</
=={{header|D}}==
<
in {
assert(n > 0);
Line 1,410:
foreach (i; 1 .. 22)
writefln("%d: %(%d × %)", i, i.factorize());
}</
{{out}}
<pre>1: 1
Line 1,435:
===Alternative Version===
{{libheader|uiprimes}} Library ''uiprimes'' is a homebrew library to generate prime numbers upto the maximum 32bit unsigned integer range 2^32-1, by using a pre-generated bit array of [[Sieve of Eratosthenes]] (a dll in size of ~256M bytes :p ).
<
std.array, std.string, import xt.uiprimes;
Line 1,466:
foreach (i; 1 .. 21)
writefln("%2d = %s", i, productStr(factorize(i)));
}</
=={{header|DCL}}==
Assumes file primes.txt is a list of prime numbers;
<
$ on control_y then $ goto clean
$
Line 1,513:
$
$ clean:
$ close /nolog primes</
{{out}}
<pre>$ @count_in_factors
Line 1,528:
=={{header|DWScript}}==
<
begin
if n <= 1 then
Line 1,545:
var i : Integer;
for i := 1 to 22 do
PrintLn(IntToStr(i) + ': ' + Factorize(i));</
{{out}}
<pre>1: 1
Line 1,571:
=={{header|EchoLisp}}==
<
(define (task (nfrom 2) (range 20))
(for ((i (in-range nfrom (+ nfrom range))))
(writeln i "=" (string-join (prime-factors i) " x "))))
</syntaxhighlight>
{{out}}
<pre>
Line 1,604:
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
class
Line 1,671:
end
</syntaxhighlight>
Test Output:
Line 1,701:
=={{header|Elixir}}==
<
def factor(n), do: factor(n, 2, [])
Line 1,712:
Enum.each(1..20, fn n ->
IO.puts "#{n}: #{Enum.join(RC.factor(n)," x ")}" end)</
{{out}}
Line 1,739:
=={{header|Euphoria}}==
<
sequence result
integer k
Line 1,766:
end for
printf(1, "%d\n", factors[$])
end for</
{{out}}
<pre>1: 1
Line 1,793:
=={{header|F_Sharp|F#}}==
<
Seq.unfold (fun (f, n) ->
let rec genFactor (f, n) =
Line 1,803:
let showLines = Seq.concat (seq { yield seq{ yield(Seq.singleton 1)}; yield (Seq.skip 2 (Seq.initInfinite factorsOf))})
showLines |> Seq.iteri (fun i f -> printfn "%d = %s" (i+1) (String.Join(" * ", Seq.toArray f)))</
{{out}}
<pre>1 = 1
Line 1,828:
=={{header|Factor}}==
<
sequences ;
Line 1,835:
[ " × " write ] [ pprint ] interleave nl ;
"1: 1" print 2 20 [a,b] [ .factors ] each</
{{out}}
<pre>
Line 1,861:
=={{header|Forth}}==
<
2
begin 2dup dup * >=
Line 1,875:
1+ 2 ?do i . ." : " i .factors cr loop ;
15 main bye</
=={{header|Fortran}}==
Line 1,882:
This algorithm creates a sieve of Eratosthenes, storing the largest prime factor to mark composites. It then finds prime factors by repeatedly looking up the value in the sieve, then dividing by the factor found until the value is itself prime. Using the sieve table to store factors rather than as a plain bitmap was to me a novel idea.
<syntaxhighlight lang="fortran">
!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Thu Jun 6 23:29:06
Line 2,009:
call sieve(0) ! release memory
end program count_in_factors
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
Sub getPrimeFactors(factors() As UInteger, n As UInteger)
Line 2,049:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 2,077:
=={{header|Frink}}==
Frink's factoring routines work on arbitrarily-large integers.
<
while true
{
println[join[" x ", factorFlat[i]]]
i = i + 1
}</
=={{header|Fōrmulæ}}==
Line 2,093:
=={{header|Go}}==
<
import "fmt"
Line 2,111:
fmt.Println()
}
}</
{{out}}
<pre>
Line 2,128:
=={{header|Groovy}}==
<
if (number == 1) {
return [1]
Line 2,149:
((1..10) + (6351..6359)).each { number ->
println "$number = ${number.factors().join(' x ')}"
}</
{{out}}
<pre>1 = 1
Line 2,173:
=={{header|Haskell}}==
Using <code>factorize</code> function from the [[Prime_decomposition#Haskell|prime decomposition]] task,
<
showFactors n = show n ++ " = " ++ (intercalate " * " . map show . factorize) n
-- Pointfree form
showFactors = ((++) . show) <*> ((" = " ++) . intercalate " * " . map show . factorize)</
isPrime n = n > 1 && noDivsBy primeNums n
{{out}}
<small><
1
2 = 2
Line 2,221:
121231231232164 = 2 * 2 * 253811 * 119410931
121231231232165 = 5 * 137 * 176979899609
. . .</
The real solution seems to have to be some sort of a segmented offset sieve of Eratosthenes, storing factors in array's cells instead of just marks. That way the speed of production might not be diminishing as much.
=={{header|Icon}} and {{header|Unicon}}==
<
write("Press ^C to terminate")
every f := [i:= 1] | factors(i := seq(2)) do {
Line 2,233:
end
link factors</
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/src/procs/factors.icn factors.icn provides factors]
Line 2,256:
=={{header|IS-BASIC}}==
<
110 FOR I=1 TO 30
120 PRINT I;"= ";FACTORS$(I)
Line 2,276:
280 LET FACTORS$=F$(1:LEN(F$)-1)
290 END IF
300 END DEF</
{{out}}
<pre> 1 = 1
Line 2,310:
=={{header|J}}==
'''Solution''':Use J's factoring primitive, <syntaxhighlight lang
'''Example''' (including formatting):<
1 : 1
2 : 2
Line 2,322:
9 : 3 3
10: 2 5
11: 11</
=={{header|Java}}==
{{trans|Visual Basic .NET}}
<
public static void main(String[] args){
for(int i = 1; i<= 10; i++){
Line 2,366:
return n;
}
}</
{{out}}
<pre>1 = 1
Line 2,390:
=={{header|JavaScript}}==
<
console.log(i + " : " + factor(i).join(" x "));
Line 2,404:
}
return factors;
}</
{{out}}
<pre>
Line 2,430:
reliable for integers up to and including 9,007,199,254,740,992 (2^53). However, "factors"
could be easily modified to work with a "BigInt" library for jq, such as [https://gist.github.com/pkoppstein/d06a123f30c033195841 BigInt.jq].
<
def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);
Line 2,441:
if . == 1 then "1: 1" else empty end,
(range($m;$n) | "\(.): \([factors] | join("x"))");
</syntaxhighlight>
'''Examples'''
<syntaxhighlight lang="jq">
10 | count_in_factors,
"",
count_in_factors(2144; 2145),
"",
(2|power(100) | count_in_factors(.; .+ 2))</
{{out}}
The output shown here is based on a run of gojq.
Line 2,470:
=={{header|Julia}}==
<
function strfactor(n::Integer)
n > -2 || return "-1 × " * strfactor(-n)
Line 2,482:
for n in lo:hi
@printf("%5d = %s\n", n, strfactor(n))
end</
{{out}}
Line 2,533:
=={{header|Kotlin}}==
<
fun isPrime(n: Int) : Boolean {
Line 2,574:
for (i in list)
println("${"%4d".format(i)} = ${getPrimeFactors(i).joinToString(" * ")}")
}</
{{out}}
Line 2,605:
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
'see Run BASIC solution
for i = 1000 to 1016
Line 2,623:
end if
wend
end function </
{{out}}
<pre>
Line 2,646:
=={{header|Lua}}==
<
if n == 1 then return {1} end
Line 2,669:
end
print ""
end</
=={{header|M2000 Interpreter}}==
Decompose function now return array (in number decomposition task return an inventory list).
<syntaxhighlight lang="m2000 interpreter">
Module Count_in_factors {
Inventory Known1=2@, 3@
Line 2,730:
}
Count_in_factors
</syntaxhighlight>
=={{header|M4}}==
<
`ifelse($#,0,``$0'',
`ifelse(eval($2<=$3),1,
Line 2,749:
for(`y',1,25,1, `wby(y)
')</
{{out}}
Line 2,781:
=={{header|Maple}}==
<
local i, j, firstNum;
if n = 1 then
Line 2,804:
printf("%2a: ", i);
factorNum(i);
end do;</
{{out}}
<pre>
Line 2,820:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
While[n < 100,
Print[Row[Riffle[Flatten[Map[Apply[ConstantArray, #] &, FactorInteger[n]]],"*"]]];
n++]</
=={{header|NetRexx}}==
{{trans|Java}}
<
options replace format comments java crossref symbols nobinary
Line 2,879:
end
return
</syntaxhighlight>
{{out}}
<pre style="height: 30em;overflow: scroll; font-size: smaller;">
Line 2,957:
=={{header|Nim}}==
{{trans|C}}
<
proc getPrime(idx: int): int =
Line 2,995:
if first > 0: echo n
elif n > 1: echo " x ", n
else: echo ""</
<pre>1 = 1
2 = 2
Line 3,013:
=={{header|Objeck}}==
<
class CountingInFactors {
function : Main(args : String[]) ~ Nil {
Line 3,067:
}
}
</syntaxhighlight>
Output:
<pre>
Line 3,093:
=={{header|OCaml}}==
<
let prime_decomposition x =
Line 3,114:
aux (succ_big_int v)
in
aux unit_big_int</
{{out|Execution}}
<pre>$ ocamlopt -o count.opt nums.cmxa count.ml
Line 3,140:
=={{header|Octave}}==
Octave's factor function returns an array:
<
printf ("%i: ", n)
printf ("%i ", factor (n))
printf ("\n")
endfor</
{{out}}
<pre>1: 1
Line 3,168:
=={{header|PARI/GP}}==
<
my(f,s="",s1);
if (n < 2, return(n));
Line 3,181:
s
};
n=0;while(n++, print(fnice(n)))</
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<
{$IFDEF FPC}
Line 3,233:
writeln;
end;
end.</
{{out}}
<pre>
Line 3,262:
=={{header|Perl}}==
Typically one would use a module for this. Note that these modules all return an empty list for '1'. This should be efficient to 50+ digits:{{libheader|ntheory}}
<
print "$_ = ", join(" x ", factor($_)), "\n" for 1000000000000000000 .. 1000000000000000010;</
{{out}}
<pre>1000000000000000000 = 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5
Line 3,278:
Giving similar output and also good for large inputs:
<
sub factor {
my ($pn,$pc) = @{Math::Pari::factorint(shift)};
return map { ($pn->[$_]) x $pc->[$_] } 0 .. $#$pn;
}
print "$_ = ", join(" x ", factor($_)), "\n" for 1000000000000000000 .. 1000000000000000010;</
or, somewhat slower and limited to native 32-bit or 64-bit integers only:
<
print "$_ = ", join(" x ", prime_factors($_)), "\n" for 1000000000000000000 .. 1000000000000000010;</
If we want to implement it self-contained, we could use the prime decomposition routine from the [[Prime_decomposition]] task. This is reasonably fast and small, though much slower than the modules and certainly could have more optimization.
<
my($n, $p, @out) = (shift, 3);
return if $n < 1;
Line 3,306:
}
print "$_ = ", join(" x ", factors($_)), "\n" for 100000000000 .. 100000000100;</
We could use the second extensible sieve from [[Sieve_of_Eratosthenes#Extensible_sieves]] to only divide by primes.
<
sub factors {
Line 3,324:
}
print "$_ = ", join(" x ", factors($_)), "\n" for 100000000000 .. 100000000010;</
{{out}}
<pre>100000000000 = 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5 x 5
Line 3,339:
This next example isn't quite as fast and uses much more memory, but it is self-contained and shows a different approach. As written it must start at 1, but a range can be handled by using a <code>map</code> to prefill the <tt>p_and_sq</tt> array.
<
use utf8;
use strict;
Line 3,370:
}
die "Ran out of primes?!";
}</
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">factorise</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
Line 3,382:
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)&{</span><span style="color: #000000;">2144</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1000000000</span><span style="color: #0000FF;">},</span><span style="color: #000000;">factorise</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 3,401:
=={{header|PicoLisp}}==
This is the 'factor' function from [[Prime decomposition#PicoLisp]].
<
(make
(let (D 2 L (1 2 2 . (4 2 4 2 4 6 2 6 .)) M (sqrt N))
Line 3,411:
(for N 20
(prinl N ": " (glue " * " (factor N))) )</
{{out}}
<pre>1: 1
Line 3,435:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
cnt: procedure options (main);
declare (i, k, n) fixed binary;
Line 3,460:
end;
end cnt;
</syntaxhighlight>
Results:
<pre> 1 = 1
Line 3,505:
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function eratosthenes ($n) {
if($n -ge 1){
Line 3,538:
"$(prime-decomposition 100)"
"$(prime-decomposition 12)"
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 3,547:
=={{header|PureBasic}}==
<
Protected I = 3, Max
ClearList(Factors())
Line 3,584:
PrintN(text$)
Next a
EndIf</
{{out}}
<pre> 1= 1
Line 3,609:
=={{header|Python}}==
This uses the [http://docs.python.org/dev/library/functools.html#functools.lru_cache functools.lru_cache] standard library module to cache intermediate results.
<
primes = [2, 3, 5, 7, 11, 13, 17] # Will be extended
Line 3,643:
print('\nNumber of primes gathered up to', n, 'is', len(primes))
print(pfactor.cache_info())</
{{out}}
<pre> 1 1
Line 3,686:
Reusing the code from [http://rosettacode.org/wiki/Prime_decomposition#Quackery Prime Decomposition].
<
dup times
[ [ dup i^ 2 + /mod
Line 3,704:
cr again ] ] is countinfactors ( --> )
countinfactors</
{{out}}
Line 3,734:
=={{header|R}}==
<syntaxhighlight lang="r">
#initially I created a function which returns prime factors then I have created another function counts in the factors and #prints the values.
Line 3,761:
}
count_in_factors(72)
</syntaxhighlight>
{{out}}
Line 3,771:
See also [[#Scheme]]. This uses Racket’s <code>math/number-theory</code> package
<
(require math/number-theory)
Line 3,792:
(factor-count 1 22)
(factor-count 2140 2150)
; tb</
{{out}}
Line 3,833:
(formerly Perl 6)
{{works with|rakudo|2015-10-01}}
<syntaxhighlight lang="raku"
multi factors(1) { 1 }
Line 3,853:
}
say "$_: ", factors($_).join(" × ") for 1..*;</
The first twenty numbers:
<pre>1: 1
Line 3,881:
Here is a solution inspired from [[Almost_prime#C]]. It doesn't use &is-prime.
<syntaxhighlight lang="raku"
$n == 1 ?? 1 !!
gather {
Line 3,893:
}
say "$_ == ", join " \x00d7 ", factor $_ for 1 .. 20;</
Same output as above.
Line 3,900:
Alternately, use a module:
<syntaxhighlight lang="raku"
say "$_ = {(.&prime-factors || 1).join: ' x ' }" for flat 1 .. 10, 10**20 .. 10**20 + 10;</
{{out}}
<pre>1 = 1
Line 3,934:
<br>prime factors are listed, but the number of primes found is always shown. The showing of the count of
<br>primes was included to help verify the factoring (of composites).
<
@.=left('', 8); @.0="{unity} "; @.1='[prime] ' /*some tags and handy-dandy literals.*/
parse arg LO HI @ . /*get optional arguments from the C.L. */
Line 3,970:
end /*j*/
if z==1 then return substr($, 1+length(@) ) /*Is residual=1? Don't add 1*/
return substr($||@||z, 1+length(@) ) /*elide superfluous header. */</
{{out|output|text= when using the default inputs:}}
<pre>
Line 4,049:
Note that the '''integer square root''' section of code doesn't use any floating point numbers, just integers.
<
@.=left('', 8); @.0="{unity} "; @.1='[prime] ' /*some tags and handy-dandy literals.*/
parse arg LO HI @ . /*get optional arguments from the C.L. */
Line 4,099:
if z==1 then return substr($, 1+length(@) ) /*Is residual=1? Don't add 1*/
return substr($||@||z, 1+length(@) ) /*elide superfluous header. */</
{{out|output|text= when using the default inputs:}}
<pre>
Line 4,147:
=={{header|Ring}}==
<
for i = 1 to 20
see "" + i + " = " + factors(i) + nl
Line 4,163:
end
return left(f, len(f) - 3)
</syntaxhighlight>
Output:
<pre>
Line 4,190:
=={{header|Ruby}}==
Starting with Ruby 1.9, 'prime' is part of the standard library and provides Integer#prime_division.
<
require 'prime'
Line 4,212:
end.join " x "
puts "#{i} is #{f}"
end</
{{out|Example}}
<pre>$ ruby prime-count.rb -h
Line 4,240:
=={{header|Run BASIC}}==
<
print i;" = "; factorial$(i)
next
Line 4,256:
end if
wend
end function</
{{out}}
<pre>1000 = 2 x 2 x 2 x 5 x 5 x 5
Line 4,278:
=={{header|Rust}}==
You can run and experiment with this code at https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=b66c14d944ff0472d2460796513929e2
<
fn main() {
Line 4,318:
}
vec![n]
}</
{{out}}
<pre>1
Line 4,343:
=={{header|Sage}}==
<
if is_prime(n) or n == 1:
print(n,end="")
Line 4,358:
print(i,"=",end=" ")
count_in_factors(i)
print("")</
{{out}}
Line 4,422:
=={{header|Scala}}==
<
object CountInFactors extends App {
Line 4,450:
}
</syntaxhighlight>
{{out}}
<pre> 1 : 1
Line 4,468:
=={{header|Scheme}}==
<
(let facs ((l '()) (d 2) (x n))
(cond ((= x 1) (if (null? l) '(1) l))
Line 4,487:
(display i)
(display " = ")
(show (reverse (factors i))))</
{{out}}
<pre>1 = 1
Line 4,504:
=={{header|Seed7}}==
<
const proc: writePrimeFactors (in var integer: number) is func
Line 4,542:
writeln;
end for;
end func;</
{{out}}
<pre>
Line 4,564:
=={{header|Sidef}}==
<
method factors(n, p=2) {
var a = gather {
Line 4,592:
for i in (1..100) {
say "#{i} = #{Counter().factors(i).join(' × ')}"
}</
=={{header|Swift}}==
<
@inlinable
public func primeDecomposition() -> [Self] {
Line 4,624:
print("\(i) = \(i.primeDecomposition().map(String.init).joined(separator: " x "))")
}
}</
{{out}}
Line 4,651:
=={{header|Tcl}}==
This factorization code is based on the same engine that is used in the [[Parallel calculations#Tcl|parallel computation task]].
<
namespace eval prime {
Line 4,712:
return [join $v "*"]
}
}</
Demonstration code:
<
for {set i 1} {$i <= $max} {incr i} {
puts [format "%*d = %s" [string length $max] $i [prime::factors.rendered $i]]
}</
=={{header|VBScript}}==
Made minor modifications on the code I posted under Prime Decomposition.
<
If n = 1 Then
CountFactors = 1
Line 4,779:
WScript.StdOut.WriteLine
WScript.StdOut.Write "2144 = " & CountFactors(2144)
WScript.StdOut.WriteLine</
{{Out}}
Line 4,788:
=={{header|Visual Basic .NET}}==
<
Sub Main()
Line 4,829:
End Sub
End Module</
{{out}}
<pre>
Line 4,856:
=={{header|Vlang}}==
{{trans|go}}
<
println("1: 1")
for i := 2; ; i++ {
Line 4,870:
println('')
}
}</
{{out}}
<pre>
Line 4,887:
=={{header|XPL0}}==
<
int N0, N, F;
[N0:= 1;
Line 4,903:
N0:= N0+1;
until KeyHit;
]</
Example output:
Line 4,942:
=={{header|Wren}}==
{{libheader|Wren-math}}
<
for (r in [1..9, 2144..2154, 9987..9999]) {
Line 4,950:
}
System.print()
}</
{{out}}
Line 4,992:
=={{header|zkl}}==
<
Using the fixed size integer (64 bit) solution from [[Prime decomposition#zkl]]
<
acc:=fcn(n,k,acc,maxD){ // k is 2,3,5,7,9,... not optimum
if(n==1 or k>maxD) acc.close();
Line 5,006:
if(n!=m) acc.append(n/m); // opps, missed last factor
else acc;
}</
{{out}}
<pre>
Line 5,025:
=={{header|ZX Spectrum Basic}}==
{{trans|BBC_BASIC}}
<
20 PRINT i;" = ";
30 IF i=1 THEN PRINT 1: GO TO 90
Line 5,035:
90 NEXT i
100 STOP
110 DEF FN m(a,b)=a-INT (a/b)*b</
|