Un défi simple mais espérons-le, pas tout à fait trivial:

Ecrivez un programme ou une fonction qui additionne les kpuissances divisant un nombre n. Plus précisement:

• Entrée: deux entiers positifs net k(ou une paire ordonnée d’entiers, etc.)
• Sortie: la somme de tous les diviseurs positifs de nqui sont les kpuissances des nombres entiers

Par exemple, 11! = 39916800 a six diviseurs qui sont cubes, à savoir 1, 8, 27, 64, 216 et 1728. Par conséquent les entrées données 39916800et 3, le programme devrait retourner leur somme, 2044.

Autres cas de test:

{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

C'est du code golf, donc plus votre code est court, mieux c'est. Je souhaite la bienvenue au code golfé dans toutes sortes de langues, même si une autre langue peut s’en tirer avec moins d’octets que le vôtre.

05AB1E , 9 octets

DLImDŠÖÏO

Essayez-le en ligne!

Explication

Exemple d'entrée 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 octets

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

Fonction sans nom prenant net kcomme entrées dans cet ordre.

Haskell , 37 35 34 octets

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

Essayez-le en ligne! Usage:

Prelude> 40320 ! 1
159120

Le code est assez inefficace car il calcule toujours 1^k, 2^k, ..., n^k.

Edit: enregistré un octet grâce à Zgarb.

Explication:

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 octets

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

Merci @Rod d'avoir coupé 2 octets.

Ruby, 45 octets

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

Serait plus court en utilisant "somme" dans Ruby 2.4. Temps de mise à niveau?

MATL , 10 octets

t:i^\~5M*s

Essayez-le en ligne!

Comment ça marche

Exemple avec 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

Gelée , 7 à 6 octets

-1 octet grâce à Dennis (traversent une gamme implicite)
Une efficacité intelligente sauver aussi par Dennis à coût 0 octet
(Auparavant ÆDf*€Sfiltrerait garder ces diviseurs qui sont une puissance de k d'un nombre naturel jusqu'à n . Mais notez que n peut N'avoir un diviseur de i ^{k que} s'il a un diviseur de i !)

ÆDf*¥S

Essayez-le en ligne!

Comment?

Æ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 octets

Prend net ken currying syntaxe (n)(k).

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

Cas de test

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 octets

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

Comment ça marche

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

L'essayer

Japt , 10 octets

Économisez beaucoup d'octets grâce à @ETHproductions

òpV f!vU x

Explication

ò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

Testez-le en ligne!

Scala 63 octets

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

Python 2 , 50 octets

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

Essayez-le en ligne! Les entrées importantes peuvent dépasser la profondeur de récursivité en fonction de votre système et de son implémentation.

JavaScript (ES7), 49 46 octets

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

PHP, 86 octets

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

Essayez-le ici!

Panne :

$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 octets

Probablement pas au golf optimal, mais je ne vois pas de changements évidents à faire ...

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

Essayez-le en ligne!

Gelée , 8 octets

R*³%$ÐḟS

Essayez-le en ligne!

( Crédit pas le mien. )

Utilitaires Bash + Unix, 44 octets

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

Essayez-le en ligne!

Tests effectué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 octets

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

Essayez-le en ligne!

Assez simple. La seule chose à noter est que j**k**-1%1renvoie toujours un float dans [0,1) et n%jtoujours un entier non négatif, de sorte qu'ils ne peuvent être égaux que si les deux sont égaux à 0 .

Lot, 138 octets

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

Depuis lot ne dispose pas d' un opérateur de pouvoir, j'abuser set/acomme une forme de eval. Très lent quand k=1. L'arithmétique entière sur 32 bits limite les valeurs prises en charge de net 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 octets directs, 43 octets pour la fonction

si n, k en mémoire:

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

pour une fonction:

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