Eine einfache, aber hoffentlich nicht ganz triviale Herausforderung:

Schreiben Sie ein Programm oder eine Funktion, die die kPotenzen einer Zahl aufaddiert n. Genauer:

• Eingabe: zwei positive ganze Zahlen nund k(oder ein geordnetes Paar von ganzen Zahlen usw.)
• Ausgang: die Summe aller positiven Teiler , ndass sind kten Potenzen von ganzen Zahlen

Zum Beispiel 11! = 39916800 hat sechs Divisoren , die Würfel sind, nämlich 1, 8, 27, 64, 216 und 1728. Daher gegebenen Eingänge 39916800und 3, sollte das Programm ihre Summe zurückkehren 2044.

Andere Testfälle:

{40320, 1} -> 159120
{40320, 2} -> 850
{40320, 3} -> 73
{40320, 4} -> 17
{40320, 5} -> 33
{40320, 6} -> 65
{40320, 7} -> 129
{40320, 8} -> 1
{46656, 1} -> 138811
{46656, 2} -> 69700
{46656, 3} -> 55261
{46656, 4} -> 1394
{46656, 5} -> 8052
{46656, 6} -> 47450
{46656, 7} -> 1
{1, [any positive integer]} -> 1

Dies ist Codegolf. Je kürzer Ihr Code, desto besser. Ich freue mich über Golfcode in allen möglichen Sprachen, auch wenn eine andere Sprache mit weniger Bytes auskommt als Ihre.

05AB1E , 9 Bytes

DLImDŠÖÏO

Probieren Sie es online!

Erläuterung

Beispiel Eingabe 46656, 3

D          # duplicate first input
           # STACK: 46656, 46656
 L         # range [1 ... first input]
           # STACK: 46656, [1 ... 46656]
  Im       # each to the power of second input
           # STACK: 46656, [1, 8, 27 ...]
    D      # duplicate
           # STACK: 46656, [1, 8, 27 ...], [1, 8, 27 ...]
     Š     # move down 2 spots on the stack
           # STACK: [1, 8, 27 ...], 46656, [1, 8, 27 ...]
      Ö    # a mod b == 0
           # STACK: [1, 8, 27 ...], [1,1,1,1,0 ...]
       Ï   # keep only items from first list which are true in second
           # STACK: [1, 8, 27, 64, 216, 729, 1728, 5832, 46656]
        O  # sum
           # OUTPUT: 55261

Mathematica, 28 Bytes

Tr[Divisors@#⋂Range@#^#2]&

Unbenannte Funktionen nehmen nund kals Eingaben in dieser Reihenfolge.

Haskell , 37 35 34 Bytes

n!k=sum[x^k|x<-[1..n],n`mod`x^k<1]

Probieren Sie es online! Verwendung:

Prelude> 40320 ! 1
159120

Der Code ist ziemlich ineffizient, da er immer berechnet 1^k, 2^k, ..., n^k.

Bearbeiten: Ein Byte dank Zgarb gespeichert.

Erläuterung:

n!k=             -- given n and k, the function ! returns
 sum[x^k|        -- the sum of the list of all x^k
   x<-[1..n],    -- where x is drawn from the range 1 to n
   n`mod`x^k<1]  -- and n modulus x^k is less than 1, that is x^k divides n

Python 2, 54 52 Bytes

lambda x,n:sum(i**n*(x%i**n<1)for i in range(1,-~x))

Vielen Dank an @Rod für das Abschneiden von 2 Bytes.

Ruby, 45 Bytes

->n,m{(1..n).reduce{|a,b|n%(c=b**m)<1?a+c:a}}

Wäre kürzer mit "sum" in Ruby 2.4. Zeit für ein Upgrade?

MATL , 10 Bytes

t:i^\~5M*s

Probieren Sie es online!

Wie es funktioniert

Beispiel mit 46656, 6.

t      % Implicitly input n. Duplicate
       % STACK: 46656, 46656
:      % Range
       % STACK: 46656, [1 2 ... 46656]
i      % Input k
       % STACK: 46656, [1 2 ... 46656], 6
^      % Power, element-wise
       % STACK: 46656, [1 64 ... 46656^6]
\      % Modulo
       % STACK: [0 0 0 1600 ...]
~      % Logically negate
       % STACK: [true true true false ...]
5M     % Push second input to function \ again
       % STACK: [true true true false ...], [1^6 2^6 ... 46656^6]
*      % Multiply, element-wise
       % STACK: [1 64 729 0 ...]
s      % Sum of array: 47450
       % Implicitly display

Gelee , 7 6 Bytes

-1 Byte dank Dennis (durchqueren eines impliziten Bereichs)
Eine clevere Effizienzersparnis auch von Dennis zu 0-Byte-Kosten
(Bisher ÆDf*€Swürden Filter jene Divisoren behalten, die eine Potenz von k einer beliebigen natürlichen Zahl bis n sind . Beachten Sie jedoch, dass n kann habe immer nur einen Teiler von i ^k, wenn es trotzdem einen Teiler von i hat!)

ÆDf*¥S

Probieren Sie es online!

Wie?

ÆDf*¥S - Main link: n, k
ÆD     - divisors of n  -> divisors = [1, d1, d2, ..., n]
    ¥  - last two links as a dyadic chain
  f    -     filter divisors keeping those that appear in:
   *   -     exponentiate k with base divisors (vectorises)
       - i.e. [v for v in [1, d1, d2, ..., n] if v in [1^k, d1^k, ..., n^k]]
     S - sum

JavaScript (ES7), 56 53 Byte

Takes nund kin currying Syntax (n)(k).

n=>k=>[...Array(n)].reduce(p=>n%(a=++i**k)?p:p+a,i=0)

Testfälle

let f =

n=>k=>[...Array(n)].reduce(p=>n%(a=++i**k)?p:p+a,i=0)

console.log(f(40320)(1)) // -> 159120
console.log(f(40320)(2)) // -> 850
console.log(f(40320)(3)) // -> 73
console.log(f(40320)(4)) // -> 17
console.log(f(40320)(5)) // -> 33
console.log(f(40320)(6)) // -> 65
console.log(f(40320)(7)) // -> 129
console.log(f(40320)(8)) // -> 1
console.log(f(46656)(1)) // -> 138811
console.log(f(46656)(2)) // -> 69700
console.log(f(46656)(3)) // -> 55261
console.log(f(46656)(4)) // -> 1394
console.log(f(46656)(5)) // -> 8052
console.log(f(46656)(6)) // -> 47450
console.log(f(46656)(7)) // -> 1

Perl 6 , 39 Bytes

->\n,\k{sum grep n%%*,({++$**k}...*>n)}

Wie es funktioniert

->\n,\k{                              }  # A lambda taking two arguments.
                        ++$              # Increment an anonymous counter
                           **k           # and raise it to the power k,
                       {      }...       # generate a list by repeatedly doing that,
                                  *>n    # until we reach a value greater than n.
            grep n%%*,(              )   # Filter factors of n from the list.
        sum                              # Return their sum.

Versuch es

Japt , 10 Bytes

Dank @ETHproductions wurden viele Bytes gespeichert

òpV f!vU x

Erläuterung

òpV f!vU x
ò           // Creates a range from 0 to U
 pV         // Raises each item to the power of V (Second input)
    f       // Selects all items Z where
     !vU    //   U is divisible by Z
            //   (fvU would mean Z is divisible by U; ! swaps the arguments)
         x  // Returns the sum of all remaining items

Online testen!

Scala 63 Bytes

(n:Int,k:Int)=>1 to n map{Math.pow(_,k).toInt}filter{n%_==0}sum

Python 2 , 50 Bytes

f=lambda n,k,i=1:n/i and(n%i**k<1)*i**k+f(n,k,i+1)

Probieren Sie es online! Große Eingaben können je nach System und Implementierung die Rekursionstiefe überschreiten.

JavaScript (ES7), 49 46 Bytes

n=>g=(k,t=i=0,p=++i**k)=>p>n?t:g(k,t+p*!(n%p))

PHP, 86 Bytes

$n=$argv[1];$k=$argv[2];for($i=1;$i<=$n**(1/$k);$i++)if($n%$i**$k<1)$s+=$i**$k;echo$s;

Probieren Sie es hier aus!

Nervenzusammenbruch :

$n=$argv[1];$k=$argv[2];       # Assign variables from input
for($i=1;$i<=$n**(1/$k);$i++)  # While i is between 1 AND kth root of n
    if($n%$i**$k<1)            #     if i^k is a divisor of n
        $s+=$i**$k;            #         then add to s
echo$s;                        # echo s (duh!)

CJam , 20 Bytes

Wahrscheinlich nicht optimal golfen, aber ich sehe keine offensichtlichen Änderungen, die vorgenommen werden müssten ...

ri:N,:)rif#{N\%!},:+

Probieren Sie es online!

Gelee , 8 Bytes

R*³%$ÐḟS

Probieren Sie es online!

( Gutschrift nicht meins. )

Bash + Unix-Dienstprogramme, 44 Bytes

bc<<<`seq "-fx=%.f^$2;s+=($1%%x==0)*x;" $1`s

Probieren Sie es online!

Testläufe:

for x in '40320 1' '40320 2' '40320 3' '40320 4' '40320 5' '40320 6' '40320 7' '40320 8' '46656 1' '46656 2' '46656 3' '46656 4' '46656 5' '46656 6' '46656 7' '1 1' '1 2' '1 3' '1 12' ; do echo -n "$x "; ./sumpowerdivisors $x; done

40320 1 159120
40320 2 850
40320 3 73
40320 4 17
40320 5 33
40320 6 65
40320 7 129
40320 8 1
46656 1 138811
46656 2 69700
46656 3 55261
46656 4 1394
46656 5 8052
46656 6 47450
46656 7 1
1 1 1
1 2 1
1 3 1
1 12 1

Python , 56 Bytes

lambda n,k:sum(j*(j**k**-1%1==n%j)for j in range(1,n+1))

Probieren Sie es online!

Ziemliech direkt. Das einzig Bemerkenswerte ist, dass j**k**-1%1immer ein Float in [0,1] zurückgegeben wird, während n%jimmer eine nicht negative ganze Zahl zurückgegeben wird. Sie können also nur gleich sein, wenn beide 0 sind .

Batch, 138 Bytes

@set s=n
@for /l %%i in (2,1,%2)do @call set s=%%s%%*n
@set/at=n=0
:l
@set/an+=1,p=%s%,t+=p*!(%1%%p)
@if %p% lss %1 goto l
@echo %t%

Da Batch keinen Netzbetreiber hat, missbrauche ich set/aals eine Form von eval. Sehr langsam wenn k=1. Die 32-Bit-Ganzzahlarithmetik begrenzt die unterstützten Werte von nund k:

           n   k
  (too slow)   1
 <1366041600   2
 <1833767424   3
 <2019963136   4
 <2073071593   5
 <1838265625   6
 <1801088541   7
 <1475789056   8
 <1000000000   9
 <1073741824  10
 <1977326743  11
  <244140625  12
 <1220703125  13
  <268435456  14
 <1073741824  15
   <43046721  16
  <129140163  17
  <387420489  18
 <1162261467  19
    <1048576  20
           ...
 <1073741824  30

R, 28 Bytes direkt, 43 Bytes für die Funktion

wenn n, k im Speicher:

sum((n%%(1:n)^k==0)*(1:n)^k)

für eine Funktion:

r=function(n,k)sum((n%%(1:n)^k==0)*(1:n)^k)