一个简单但希望不是很琐碎的挑战：

编写一个程序或函数k求和数的乘积n。进一步来说：

• 输入：两个正整数n和k（或有序整数对等）
• 输出：所有的正除数的总和n是k整数次方

例如11！= 39916800有六个因数为立方的除数，即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，节省了一个字节。

说明：

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字节

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字节的成本
节省了一个聪明的效率 （以前，过滤器会将那些除以k的任意自然数的幂的n保留为n，但是请注意，n可以永远只能有一个除数我^ķ如果它有一个除数我反正！）
ÆDf*€S

Æ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和kcurrying语法(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)