単純ですが、できればさほど簡単ではない挑戦：

k数値を分割する累乗を加算するプログラムまたは関数を作成しnます。すなわち：

• 入力：2つの正の整数nおよびk（または整数の順序ペアなど）
• 出力：の正の約数の総和nことがあるk整数の乗

たとえば、11！= 39916800には、キューブである6つの除数、つまり1、8、27、64、216、および1728があります。したがって、入力39916800およびが与えられると3、プログラムはそれらの合計を返し2044ます。

その他のテストケース：

{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

これはコードゴルフですので、コードが短いほど良いです。他の言語があなたのバイトよりも少ないバイトで逃げることができるとしても、私はあらゆる種類の異なる言語のゴルフコードを歓迎します。

05AB1E、9バイト

DLImDŠÖÏO

オンラインでお試しください！

説明

入力例 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バイト

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

無名関数は、服用nし、kその順序で入力として。

Haskell、37 35 34バイト

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

オンラインでお試しください！使用法：

Prelude> 40320 ! 1
159120

コードは常に計算するため、非常に非効率的1^k, 2^k, ..., n^kです。

編集： Zgarbのおかげで1バイト保存しました。

説明：

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

パイソン2、54の 52バイト

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

@ Rod、2バイトをカットしてくれてありがとう。

Ruby、45バイト

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

Ruby 2.4で「sum」を使用すると短くなります。アップグレードする時ですか？

MATL、10バイト

t:i^\~5M*s

オンラインでお試しください！

使い方

例の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

ゼリー、7 6 バイト

-1バイトデニスのおかげで（暗黙範囲を横切る）
巧妙な効率は保存もでデニスによって0バイトのコスト
（従来ÆDf*€Sの電源であるもの除数保つフィルタリングなるKの任意の自然数までのNを。しかし、なお、nは、CAN とにかくiの約数がある場合にのみi ^kの約数があります！）

ÆDf*¥S

オンラインでお試しください！

どうやって？

Æ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バイト

取りnやk構文をカリー化の中で(n)(k)。

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

テストケース

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バイト

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

使い方

->\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.

それを試してみてください

Japt、10バイト

@ETHproductionsのおかげで大量のバイトを節約

òpV f!vU x

説明

ò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

オンラインでテストしてください！

Scala 63バイト

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

Python 2、50バイト

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

オンラインでお試しください！システムと実装によっては、大きな入力が再帰の深さを超える場合があります。

JavaScript（ES7）、49 46バイト

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

PHP、86バイト

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

ここで試してみてください！

壊す ：

$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バイト

おそらく最適なゴルフではありませんが、明らかな変更はありません...

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

オンラインでお試しください！

ゼリー、8バイト

R*³%$ÐḟS

オンラインでお試しください！

（私のクレジットではありません。）

Bash + Unixユーティリティ、44バイト

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

オンラインでお試しください！

テスト実行：

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バイト

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

オンラインでお試しください！

かなり簡単です。唯一の注目すべきものは、ということであるj**k**-1%1常にフロートを返す）0,1 [ながらn%j両方がある場合、彼らだけ等しくすることができるので、常に負でない整数を戻す0。

バッチ、138バイト

@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%

Batchにはパワーオペレータがないためset/a、の形式として悪用していevalます。非常に遅いときk=1。サポートされる値の算術限界整数32ビットnと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バイト、機能用43バイト

メモリ内のn、kの場合：

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

関数の場合：

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