Own digits power sum: Difference between revisions

{{trans|Python}}

V POWER_DIGIT = (0 .< MAX_BASE).map(_ -> (0 .< :MAX_BASE).map(_ -> 1))

V USED_DIGITS = (0 .< MAX_BASE).map(_ -> 0)

print(‘Own digits power sums for N = 3 to 9 inclusive:’)

L(n) NUMBERS

{{out}}

Non-recursive, generates the possible combinations ands the own digits power sums in reverse order, without duplication.<br>

Uses ideas from various solutions on this page, particularly the observation that the own digits power sum is independent of the order of the digits. Uses the minimum possible highest digit for the number of digits (width) and maximum number of zeros for the width to avoid some combinations. This trys 73 359 combinations.

# counts of used digits, check is a copy used to check the number is an own digit power sum #

[ 0 : 9 ]INT used, check; FOR i FROM 0 TO 9 DO check[ i ] := 0 OD;

OD;

print( ( "Considered ", whole( try count, 0 ), " digit combinations" ) )

{{out}}

<pre>

Takes about 1.9 seconds to run (GCC 9.3.0 -O3).

{{trans|Wren}}

#include <math.h>

}

return 0;

{{out}}

{{trans|Pascal}}

Down now to 14ms.

#include <string.h>

for (i = 0; i <= j; ++i) printf("%lld\n", numbers[i]);

return 0;

{{out}}

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

// Own digits power sum. Nigel Galloway: October 2th., 2021

let fN g=let N=[|for n in 0..9->pown n g|] in let rec fN g=function n when n<10->N.[n]+g |n->fN(N.[n%10]+g)(n/10) in (fun g->fN 0 g)

{3..9}|>Seq.iter(fun g->let fN=fN g in printf $"%d{g} digit are:"; {pown 10 (g-1)..(pown 10 g)-1}|>Seq.iter(fun g->if g=fN g then printf $" %d{g}"); printfn "")

{{out}}

<pre>

</pre>

=={{header|FreeBASIC}}==

dim as uinteger N, curr, temp, dig, sum

next curr

next N

{{out}}

<pre>

{{libheader|Go-rcu}}

Takes about 16.5 seconds to run including compilation time.

import (

}

}

{{out}}

Down to about 128 ms now including compilation time. Actual run time only 8 ms!

{{trans|Pascal}}

import "fmt"

fmt.Println(n)

}

{{out}}

=={{header|Haskell}}==

Using a function from the Combinations with Repetitions task:

------------------- OWN DIGITS POWER SUM -----------------

digits :: Show a => a -> [Int]

{{Out}}

<pre>N ∈ [3 .. 8]

(*) gojq requires significantly more time and memory to run this program.

# The global object:

"Own digits power sums for N = 3 to 9 inclusive:",

{{out}}

As for [[#Wren|Wren]].

=={{header|Julia}}==

dig = digits(n, base=base)

exponent = length(dig)

isowndigitspowersum(i) && println(i)

end

<pre>

153

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

digs = IntegerDigits[n];

len = Length[digs];

Total[digs^len] == n

], CompilationTarget -> "C"];

{{out}}

<pre>{153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084, 548834, 1741725, 4210818, 9800817, 9926315, 24678050, 24678051, 88593477}</pre>

===Brute Force===

Use <code>Parallel::ForkManager</code> to obtain concurrency, trading some code complexity for less-than-infinite run time. Still <b>very</b> slow.

use warnings;

use feature 'say';

$pm->wait_all_children;

{{out}}

<pre>153

===Combinatorics===

Leverage the fact that all combinations of digits give same DPS. Much faster than brute force, as only non-redundant values tested.

use warnings;

use List::Util 'sum';

}

{{out}}

<pre>153

=={{header|Phix}}==

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

<span style="color: #004080;">atom</span> <span style="color: #000000;">minps</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">maxps</span>

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

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

===Python :: Procedural===

==== slower ====

def isowndigitspowersum(integer):

if isowndigitspowersum(i):

print(i)

==== faster ====

{{trans|Wren}} Same output.

MAX_BASE = 10

print('Own digits power sums for N = 3 to 9 inclusive:')

for n in NUMBERS:

===Python :: Functional===

Using a function from the Combinations with Repetitions task:

from itertools import accumulate, chain, islice, repeat

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>N ∈ [3 .. 8]

=={{header|Raku}}==

my %pow = (^10).map: { $_ => $_ ** $p };

my $start = 10 ** ($p - 1);

}

.say for unique sort @temp;

{{out}}

<pre>153

=== Combinations with repetitions ===

Using code from [[Combinations with repetitions]] task, a version that runs relatively quickly, and scales well.

multi combs_with_rep (0, @ ) { () }

multi combs_with_rep ($, []) { () }

}

}

{{out}}

<pre>153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315 24678050 24678051 88593477 146511208 472335975 534494836 912985153</pre>

=={{header|Ring}}==

see "working..." + nl

see "Own digits power sum for N = 3 to 9 inclusive:" + nl

see "done..." + nl

{{out}}

<pre>

=={{header|Ruby}}==

Repeated combinations allow for N=18 in less than a minute.

range = (3..18)

end

{{out}}

<pre>Own digits power sums for 3..18

=={{header|Sidef}}==

var D = @(^base)

for n in (3..10) {

say ("For n = #{'%2d' % n}: ", armstrong_numbers(n))

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{Trans|ALGOL 68}}

Option Explicit On

{{out}}

<pre>

{{libheader|Wren-math}}

Includes some simple optimizations to try and quicken up the search. However, getting up to N = 9 still took a little over 4 minutes on my machine.

var powers = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

}

}

{{out}}

{{libheader|Wren-seq}}

Astonishing speed-up. Runtime now only 0.5 seconds!

var maxBase = 10

numbers.sort()

System.print("Own digits power sums for N = 3 to 9 inclusive:")

{{out}}

=={{header|XPL0}}==

Slow (14.4 second) recursive solution on a Pi4.

proc PowSum(Lev, Sum); \Display own digits power sum

int Lev, Sum, Dig;

NumLen:= 1;

PowSum(9-1, 0);

{{out}}