On vous donne un entier non négatif net un entier p >= 2. Vous devez ajouter quelques ppouvoirs ( p=2signifie carrés, p=3cubes) pour obtenir n. C'est toujours pour tout non négatif n, mais vous ne connaissez pas beaucoup de ppouvoirs -th (d'aucun entier positif ) dont vous aurez besoin.

C'est votre tâche: trouver le nombre minimum de p-th pouvoirs qui peuvent résumer n.

Exemples

>>> min_powers(7, 2)
4                       # you need at least four squares to add to 7
                        # Example: (2)^2 + (1)^2 + (1)^2 + (1)^2 = 4 + 1 + 1 + 1 = 7
>>> min_powers(4, 2)
1                       # you need at least one square to add to 4
                        # Example: (2)^2 = 4
>>> min_powers(7, 3)
7                       # you need at least seven cubes to add to 7
                        # Example: 7*(1)^3 = 7
>>> min_powers(23, 3)
9                       # you need at least nine cubes to add to 23
                        # Example: 2*(2)^3 + 7*(1)^2 = 2*8 + 7*1 = 23

Un article Wikipédia sur ce problème, le problème de Waring .

Règles

• Votre code doit être un programme ou une fonction.

• L'entrée est deux entiers netp dans n'importe quel ordre. Vous pouvez supposer que toutes les entrées sont valides ( nest tout entier positif,p >= 2

• La sortie est un entier représentant le nombre de puissances nécessaires pour additionner à n .

• C'est le golf de code, donc le programme le plus court gagne., Pas nécessairement le plus efficace.

• Tous les éléments intégrés sont autorisés.

Comme toujours, si le problème n'est pas clair, faites-le moi savoir. Bonne chance et bon golf!

Pyth, 20 19 octets

1 octet enregistré grâce à FryAmTheEggman.

L&bhSmhy-b^dQS@bQyE

Prend l'entrée sur deux lignes, d' pabord et ensuite n.

Essayez-le en ligne. Suite de tests.

Explication

Le code définit une fonction récursive y(b)qui renvoie le résultat pour min_powers(b, p).

L                      define a function y(b):
 &b                      return b if it's 0
             S           get a list of positive integers less than or equal to
              @bQ        the p:th root of b
     m                   map the integers to:
        -b                 subtract from b
          ^dQ              the p:th power of the current integer
       y                   recurse on the above
      h                    increment the result
    hS                   find the smallest result number and return it
                 yE    calculate y(n) and print

Mathematica 61 50 octets

Avec 11 octets enregistrés par LegionMammal978.

Lorsqu'il est limité aux pouvoirs de compter des nombres, ce problème est simple (dans Mathematica). Lorsqu'il est étendu pour inclure les pouvoirs des nombres entiers, c'est un cauchemar.

(k=0;While[PowersRepresentations[#,++k,#2]=={}];k)&

Cas de test

(k = 0; While[PowersRepresentations[#, ++k, #2] == {}]; k) &[7, 2]
(k = 0; While[PowersRepresentations[#, ++k, #2] == {}]; k) &[4, 2]
(k = 0; While[PowersRepresentations[#, ++k, #2] == {}]; k) &[7, 3]
(k = 0; While[PowersRepresentations[#, ++k, #2] == {}]; k) &[23, 3]

4

1

sept

9

PowersRepresentationsp[n,k,p]trouve tous les cas dans lesquels npeut être exprimé comme une somme d' kentiers positifs élevés à la ppuissance -th.

Par exemple,

PowersRepresentations[1729, 2, 3]

{{1, 12}, {9, 10}}

Vérification,

1^3 + 12^3

1729

9^3 + 10^3

1729

Java - 183 177 octets

int p(int a,int b){int P,c,t,l=P=t=a,f=0;double p;while(P>0){a=t=l;c=0;while(t>0){if(a-(p=Math.pow(t,b))>=0&&t<=P){while((a-=p)>=0)c++;a+=p;}t--;}f=c<f||f==0?c:f;P--;}return f;}

183 octets

int p(int a,int b){int P,c,t,l,f=0;P=t=l=a;double p;while(P>0){a=t=l;c=0;while(t>0){if(a-(p=Math.pow(t,b))>=0&&t<=P){while((a-=p)>=0){c++;}a+=p;}t--;}f=c<f||f==0?c:f;P--;}return f;}

Non golfé

int p(int a, int b){
    int P,c,t,l=P=t=a,f=0;
    double p;
    while (P>0){
        a=t=l;
        c=0;
        while (t>0){
            if (a-(p=Math.pow(t, b))>=0 && t<=P){
                while((a-=p)>=0)c++;
                a+=p;
            }
            t--;
        }
        f=c<f||f==0?c:f;
        P--;
    }
    return f;
}

Résultat

System.out.println(p(7, 2));    // 4
System.out.println(p(4,2));     // 1
System.out.println(p(7,3));     // 7
System.out.println(p(23,3));    // 9

Python 2, 66 octets

f=lambda n,p:n and-~min(f(n-k**p,p)for k in range(1,n+1)if n/k**p)

Essaie récursivement de soustraire chacun p puissance -th qui laisse le reste non négatif, de calculer sa valeur sur chaque reste et de prendre le minimum plus 1. Sur 0, sort 0.

Le vilain contrôle if n/k**p(équivalent à if k**p<=n) consiste à empêcher la fonction d'entrer dans les négatifs et d'essayer de prendre la minliste vide. Si Python l'a fait min([])=infinity, cela ne serait pas nécessaire.

C (gcc) , 122 octets

r(n,p,k,s,j,b){if(!k)return n!=s;for(b=j=1;j<n;b*=r(n,p,~-k,s+(int)pow(j++,p)));n=b;}f(n,p,k){for(k=0;r(n,p,++k,0););n=k;}

Essayez-le en ligne!