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>

1 2</pre>

 

 

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

base 12 factorions: 1 2

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

factorions for base 12: 1 2

</pre>

=={{header|Delphi}}==

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

In base 12 Factorians are: 1 2

</pre>

=={{header|Factor}}==

prettyprint sequences ;

IN: rosetta-code.factorions

curry each nl ;

 

{{out}}

<pre>

=={{header|Fōrmulæ}}==

 

 

 

 

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

FACTORIONS=: 9 0 +"1 index Q=: 9 10 11 12 factorion/ i. 1500000

 

(,. ".@:((Num_j_,26}.Alpha_j_) {~ #.inv/)"1) FACTORIONS

9 1 1

11 5

12 2

 

=={{header|Java}}==

public class Factorion {

public static void main(String [] args){

}

}

{{out}}

<pre>

Base 12:

1 2

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

Factorians for base 11: [1, 2, 26, 48, 40472]

Factorians for base 12: [1, 2]

</pre>

 

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

uses

sysutils;

tdigit = byte;

const

 

var

For i := 2 to Base-1 do

result := result AND (dgtCnt[i]=0);

end;

 

begin

cnt := 0;

begin

writeln('Base = ',base);

InitDgtPotDgt(base);

end;

writeln('Check Count ',cnt);

{{out}}

<pre>

Base = 2

1 1 1

2 2 2

12973363226 8B0DD409C 11489BCDD

</pre>

 

=={{header|Perl}}==

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use ntheory qw/factorial todigits/;

}

print "\n\n";

{{out}}

<pre>Factorions in base 9:

1 2</pre>

 

Alternatively, a more efficient approach:

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

=={{header|Phix}}==

{{trans|C}}

{{out}}

<pre>

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

my @result;

 

 

@result[$base] = "\nFactorions in base $base:\n1 2";

}

 

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

</pre>

 

<pre>

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

 

=={{header|Swift}}==

{{trans|C}}

 

fact[0] = 1

 

print("\n")

 

{{out}}

1 2</pre>

 

 

}

}

 

{{out}}

 

The factorions for base 12 are:

</pre>

 

=={{header|VBScript}}==

Dim fact()

nn1=9 : nn2=12

Next

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

{{out}}

<pre>

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