Factorions: Difference between revisions

{{trans|Python}}

L(n) 1..11

fact.append(fact[n-1] * n)

I fact_sum == i

print(i, end' ‘ ’)

{{out}}

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

FACTORIO CSECT

USING FACTORIO,R13 base register

XDEC DS CL12 temp fo xdeco

REGEQU

{{out}}

<pre>

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

{{trans|C}}

# cache factorials from 0 to 11 #

[ 0 : 11 ]INT fact;

print( ( newline ) )

OD

{{out}}

<pre>

=={{header|Applesoft BASIC}}==

110 FACT(0) = 1

120 FOR N = 1 TO 11

300 NEXT I

310 PRINT : PRINT

=={{header|Arturo}}==

factorion?: function [n, base][

loop 9..12 'base ->

print ["Base" base "factorions:" select 1..45000 'z -> factorion? z base]

{{out}}

=={{header|AutoHotkey}}==

{{trans|C}}

fact[0] := 1

while (A_Index < 12)

}

MsgBox % res

{{out}}

<pre>

=={{header|AWK}}==

# syntax: GAWK -f FACTORIONS.AWK

# converted from C

exit(0)

}

{{out}}

<pre>

=={{header|C}}==

{{trans|Go}}

int main() {

}

return 0;

{{out}}

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

{{trans|C}}

class factorion_t {

}

return 0;

{{out}}

<pre>factorions for base 9: 1 2 41282

</pre>

=={{header|Common Lisp}}==

(defparameter *limit* 1500000)

(if (/= base 10) (format t " (decimal ~a)" n))

(format t "~%"))

{{Out}}

{{libheader| System.SysUtils}}

{{Trans|C}}

program Factorions;

end;

readln;

=={{header|F_Sharp|F#}}==

// Factorians. Nigel Galloway: October 22nd., 2021

let N=[|let mutable n=1 in yield n; for g in 1..11 do n<-n*g; yield n|]

let fG n g=let rec fN g=function i when i<n->g+N.[i] |i->fN(g+N.[i%n])(i/n) in fN 0 g

{9..12}|>Seq.iter(fun n->printf $"In base %d{n} Factorians are:"; {1..1500000}|>Seq.iter(fun g->if g=fG n g then printf $" %d{g}"); printfn "")

{{out}}

<pre>In base 9 Factorians are: 1 2 41282

=={{header|Factor}}==

prettyprint sequences ;

IN: rosetta-code.factorions

curry each nl ;

{{out}}

<pre>

=={{header|FreeBASIC}}==

fact(0) = 1

For n As Integer = 1 To 11

Print : Print

Next b

{{out}}

<pre>

=={{header|Frink}}==

for base = 9 to 12

if n == factorion[n, base]

println["$base\t$n"]

{{out}}

=={{header|Go}}==

import (

fmt.Println("\n")

}

{{out}}

</pre>

=={{header|Haskell}}==

import Data.List (unfoldr)

import Control.Monad (guard)

where

factorions b = filter (factorion b) [1..]

{{out}}

<pre>

=={{header|J}}==

index=: $ #: I.@:,

factorion=: 10&$: :(] = [: +/ [: ! #.^:_1)&>

11 5

12 2

=={{header|Java}}==

public class Factorion {

public static void main(String [] args){

}

}

{{out}}

<pre>

=={{header|Julia}}==

printallfactorian(base) = println("Factorians for base $base: ", [n for n in 1:100000 if isfactorian(n, base)])

foreach(printallfactorian, 9:12)

<pre>

Factorians for base 9: [1, 2, 41282]

=={{header|Mathematica}} / {{header|Wolfram Language}}==

FactorionQ[n_,b_:10]:=Total[IntegerDigits[n,b]!]==n

Select[Range[1500000],FactorionQ[#,9]&]

Select[Range[1500000],FactorionQ[#,10]&]

Select[Range[1500000],FactorionQ[#,11]&]

{{out}}

<pre>{1, 2, 41282}

=={{header|Nim}}==

Note that the library has precomputed the values of factorial, so there is no need for caching.

from strutils import join

for base in 9..12:

echo "Factorions for base ", base, ':'

{{out}}

=={{header|OCaml}}==

{{trans|C}}

(* cache factorials from 0 to 11 *)

let fact = Array.make 12 0 in

done;

print_string "\n\n";

=={{header|Pascal}}==

modified [[munchhausen numbers#Pascal]].

output in base and 0! == 1!, so in Base 10 40585 has the same digits as 14558.

{$IFDEF FPC}{$MODE objFPC}{$Optimization,On,all}{$ELSE}{$APPTYPE CONSOLE}{$ENDIF}

uses

end;

writeln('Check Count ',cnt);

{{out}}

<pre>

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use ntheory qw/factorial todigits/;

}

print "\n\n";

{{out}}

<pre>Factorions in base 9:

{{trans|Sidef}}

{{libheader|ntheory}}

use ntheory qw(:all);

use experimental qw(signatures);

my @r = factorions($base);

say "Factorions in base $base are (@r)";

{{out}}

<pre>

{{trans|C}}

As per talk page (ok, ''and'' the task description), this is incorrectly using the base 10 limit for bases 9, 11, and 12.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">=</span><span style="color: #000000;">9</span> <span style="color: #008080;">to</span> <span style="color: #000000;">12</span> <span style="color: #008080;">do</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

{{trans|Sidef}}

Using the correct limits and much faster, or at least it was until I upped the bases to 14.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">max_power</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">base</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Base %2d factorions: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">base</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">factorions</span><span style="color: #0000FF;">(</span><span style="color: #000000;">base</span><span style="color: #0000FF;">))})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|PureBasic}}==

{{trans|C}}

If OpenConsole() : main() : Else : End 1 : EndIf

Print(~"\n\n")

Next

{{out}}

<pre>The factorions for base 9 are:

=={{header|Python}}==

{{trans|C}}

for n in range(1, 12):

fact.append(fact[n-1] * n)

print(i, end=" ")

print("\n")

{{out}}

=={{header|Quackery}}==

4 times

[ ' [ stack [ ] ]

[ say "Factorions for base "

i^ radix echo say ": "

{{out}}

{{trans|C}}

(define fact

[(positive? n) (loop (+ sum (fact (modulo n b))) (quotient n b))]

[(= sum i) (printf "~a " i)])))

{{out}}

{{works with|Rakudo|2019.07.1}}

constant $limit = 1500000;

}

{{out}}

<pre>Factorions in base 9:

=={{header|REXX}}==

{{trans|C}}

parse arg LOb HIb lim . /*obtain optional arguments from the CL*/

if LOb=='' | LOb=="," then LOb= 9 /*Not specified? Then use the default.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

=={{header|Ruby}}==

def factorion?(n, base)

n.digits(base).sum{|digit| (1..digit).inject(1, :*)} == n

puts "Base #{base} factorions: #{(1..1_500_000).select{|n| factorion?(n, base)}.join(" ")} "

end

{{out}}

<pre>Base 9 factorions: 1 2 41282

=={{header|Scala}}==

{{trans|C++}}

private def is_factorion(i: Int, b: Int): Boolean = {

var sum = 0L

println

})

=={{header|Sidef}}==

var m = 1

var f = (b-1)!

var r = factorions(b)

say "Base #{'%2d' % b} factorions: #{r}"

{{out}}

<pre>

{{trans|C}}

fact[0] = 1

print("\n")

{{out}}

=={{header|Vlang}}==

{{trans|Go}}

fn main() {

println("\n")

}

{{out}}

=={{header|Wren}}==

{{trans|C}}

var fact = List.filled(12, 0)

fact[0] = 1

}

System.print("\n")

{{out}}

=={{header|VBScript}}==

Dim fact()

nn1=9 : nn2=12

Next

Wscript.Echo "the factorions for base "& right(" "& base,2) &" are: "& list

{{out}}

<pre>

=={{header|zkl}}==

{{trans|C}}

fcn factorions(base){

fs:=List();

}

fs

println("The factorions for base %2d are: ".fmt(n),factorions(n).concat(" "));

{{out}}

<pre>