Một thử thách đơn giản nhưng hy vọng không tầm thường:

Viết chương trình hoặc hàm cộng các klũy thừa chia một số n. Cụ thể hơn:

• Đầu vào: hai số nguyên dương nvà k(hoặc một cặp số nguyên có thứ tự, v.v.)
• Đầu ra: tổng của tất cả các ước số dương của số nđó là klũy thừa của số nguyên

Ví dụ: 11! = 39916800 có sáu ước là các hình khối, cụ thể là 1, 8, 27, 64, 216 và 1728. Do đó , các đầu vào đã cho 39916800và 3chương trình sẽ trả về tổng của chúng , 2044.

Các trường hợp thử nghiệm khác:

{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

Đây là mã golf, vì vậy mã của bạn càng ngắn thì càng tốt. Tôi hoan nghênh mã golf trong tất cả các loại ngôn ngữ khác nhau, ngay cả khi một số ngôn ngữ khác có thể thoát khỏi với ít byte hơn của bạn.

05AB1E , 9 byte

DLImDŠÖÏO

Hãy thử trực tuyến!

Giải trình

Ví dụ đầu và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

Toán học, 28 byte

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

Chức năng không tên nvàk làm đầu vào theo thứ tự đó.

Haskell , 37 35 34 byte

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

Hãy thử trực tuyến!Sử dụng:

Prelude> 40320 ! 1
159120

Mã này khá kém hiệu quả vì nó luôn tính toán 1^k, 2^k, ..., n^k.

Chỉnh sửa: Đã lưu một byte nhờ Zgarb.

Giải trình:

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 byte

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

Cảm ơn @Rod đã cắt 2 byte.

Ruby, 45 byte

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

Sẽ ngắn hơn khi sử dụng "tổng" trong Ruby 2.4. Thời gian nâng cấp?

MATL , 10 byte

t:i^\~5M*s

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ví dụ với 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

Thạch , 7 6 byte

-1 byte nhờ Dennis (đi qua một loạt ngầm)
Một hiệu quả thông minh tiết kiệm cũng bởi Dennis tại chi phí 0-byte
(Trước đây ÆDf*€Ssẽ lọc giữ những ước có một sức mạnh của k của bất kỳ số tự nhiên lên đến n . Nhưng lưu ý rằng n lon duy nhất từng có một ước của tôi ^k nếu nó có một ước của tôi anyway!)

ÆDf*¥S

Hãy thử trực tuyến!

Làm sao?

Æ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

Đưa nvà kcú pháp currying(n)(k) .

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

Các trường hợp thử nghiệm

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 byte

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

Làm thế nào nó hoạt động

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

Thử nó

Japt , 10 byte

Đã lưu rất nhiều byte nhờ @ETHproductions

òpV f!vU x

Giải trình

ò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

Kiểm tra nó trực tuyến!

Scala 63 byte

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

Python 2 , 50 byte

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

Hãy thử trực tuyến! Đầu vào lớn có thể vượt quá độ sâu đệ quy tùy thuộc vào hệ thống và việc triển khai của bạn.

JavaScript (ES7), 49 46 byte

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

PHP, 86 byte

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

Hãy thử nó ở đây!

Phá vỡ :

$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!)

Camam , 20 byte

Có lẽ không được đánh gôn một cách tối ưu, nhưng tôi không thấy bất kỳ thay đổi rõ ràng nào để thực hiện ...

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

Hãy thử trực tuyến!

Thạch , 8 byte

R*³%$ÐḟS

Hãy thử trực tuyến!

( Tín dụng không phải của tôi. )

Tiện ích Bash + Unix, 44 byte

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

Hãy thử trực tuyến!

Chạy thử:

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 byte

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

Hãy thử trực tuyến!

Khá đơn giản. Điều đáng chú ý duy nhất là j**k**-1%1luôn trả về một số float trong [0,1) trong khi n%jluôn trả về một số nguyên không âm, vì vậy chúng chỉ có thể bằng nhau nếu cả hai đều bằng 0 .

Mẻ, 138 byte

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

Vì Batch không có nhà điều hành điện, tôi đang lạm dụng set/anhư một hình thức eval. Rất chậm khi k=1. Số học số nguyên 32 bit giới hạn các giá trị được hỗ trợ của nvà 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 byte trực tiếp, 43 byte cho chức năng

nếu n, k trong bộ nhớ:

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

cho một chức năng:

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