Own digits power sum: Difference between revisions

 

; Description

 

Optionally, do the same for '''N''' = '''9''' which may take a while for interpreted languages.

<br><br>

 

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

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>

Considered 73359 digit combinations

</pre>

 

=={{header|C}}==

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

Same as before.

</pre>

 

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

9 digit are: 146511208 472335975 534494836 912985153

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

534494836

912985153</pre>

 

=={{header|Julia}}==

dig = digits(n, base=base)

exponent = length(dig)

isowndigitspowersum(i) && println(i)

end

<pre>

153

</pre>

 

 

var

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

 

=={{header|Perl}}==

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

534494836

912985153</pre>

 

=={{header|Python}}==

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

534494836

912985153</pre>

 

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

153

370

35641594208964132

35875699062250035

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

<pre>

Same as iterative version.

</pre>