간단하지만 희망적이지는 않은 간단한 도전 :

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

수학, 28 바이트

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

이름 기능을 복용 n하고 k순서대로 입력으로.

하스켈 , 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))

2 바이트를 차단 해 주셔서 감사합니다.

루비, 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 바이트

Dennis 덕분에 -1 바이트 (암시 적 범위 통과) 0 바이트 비용 으로 Dennis 도
영리한 효율성을 절약 할 수 있습니다 (이전에는 자연수 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

자바 스크립트 (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

펄 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)

온라인으로 사용해보십시오! 시스템과 구현에 따라 큰 입력이 재귀 깊이를 초과 할 수 있습니다.

자바 스크립트 (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) 에서 float를 반환하는 반면 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)