Простий, але, сподіваємось, не зовсім тривіальний виклик:

Напишіть програму або функцію, що додає 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

Математика, 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

Пітон 2, 54 52 байти

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

Дякуємо @Rod, що вирізав 2 байти.

Рубін, 45 байт

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

Було б коротше, використовуючи "суму" в Ruby 2.4. Час оновлення?

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 можна у будь-якого разу ділиться i ^k, якщо він має дільник i все одно!)

Æ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

Перевірте це в Інтернеті!

Скала 63 байти

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

Пітон 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

Пітон , 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)