Ti viene dato un numero intero non negativo ne un numero intero p >= 2. È necessario aggiungere un po 'di ppoteri ( p=2significa quadrati, p=3significa cubi) insieme per ottenere n. Questo è sempre per qualsiasi non negativo n, ma non conosci molti ppoteri (di qualsiasi numero intero positivo ) di cui avrai bisogno.

Questo è il tuo compito: trova il numero minimo di ppotenze che possono essere sommate n.

Esempi

>>> 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 articolo di Wikipedia su questo problema, il problema di Waring .

Regole

• Il tuo codice deve essere un programma o una funzione.

• L'input è di due numeri interi ne pin qualsiasi ordine. Puoi presumere che tutti gli input siano validi ( nè un numero intero positivo,p >= 2

• L'output è un numero intero che rappresenta il numero di potenze necessarie per sommare n.

• Questo è il golf del codice, quindi vince il programma più breve , non necessariamente il più efficiente.

• Sono consentiti tutti gli incorporamenti.

Come sempre, se il problema non è chiaro, per favore fatemi sapere. Buona fortuna e buon golf!

Pyth, 20 19 byte

Salvato 1 byte grazie a FryAmTheEggman.

L&bhSmhy-b^dQS@bQyE

Accetta input su due righe, pprima e poi n.

Provalo online. Suite di test.

Spiegazione

Il codice definisce una funzione ricorsiva y(b)che restituisce il risultato per 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 byte

Con 11 byte salvati da LegionMammal978.

Se limitato ai poteri di conteggio dei numeri, questo problema è semplice (in Mathematica). Se esteso per includere poteri di numeri interi, è un incubo.

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

Casi 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

7

9

PowersRepresentationsp[n,k,p]trova tutti i casi in cui npuò essere espresso come somma di knumeri interi positivi portati pall'ennesima potenza.

Per esempio,

PowersRepresentations[1729, 2, 3]

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

Controllo,

1^3 + 12^3

1729

9^3 + 10^3

1729

Java - 183 177 byte

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 byte

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;}

Ungolfed

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;
}

Risultato

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 byte

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

Prova in modo ricorsivo a sottrarre ogni ppotenza ottava che lascia il resto non negativo, calcolando il suo valore su ciascun resto e prendendo il minimo più 1. Su 0, genera 0.

Il brutto controllo if n/k**p(equivalente a if k**p<=n) è quello di impedire alla funzione di entrare nei negativi e cercare di prendere la minlista vuota. Se Python ha min([])=infinity, questo non sarebbe necessario.

C (gcc) , 122 byte

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;}

Provalo online!