sfondo

In questa sfida, una rappresentazione baseb di un numero intero nè un'espressione di nuna somma di poteri di b, in cui ogni termine si verifica nella maggior parte dei b-1casi. Ad esempio, la 4rappresentazione base di 2015è

4^5 + 3*4^4 + 3*4^3 + 4^2 + 3*4 + 3

Ora, la rappresentazione ereditaria di base bdi nviene ottenuta convertendo gli esponenti nelle loro brappresentazioni di base , quindi convertendo i loro esponenti e così via ricorsivamente. Quindi la 4rappresentazione ereditaria di base di 2015è

4^(4 + 1) + 3*4^4 + 3*4^3 + 4^2 + 3*4 + 3

Come esempio più complesso, la 3rappresentazione ereditaria di base di

7981676788374679859068493351144698070458

è

2*3^(3^(3 + 1) + 2) + 3 + 1

Il cambiamento di base ereditario di nda bac , indicato H(b, c, n), è il numero ottenuto prendendo la brappresentazione di base ereditaria di n, sostituendo ogni bda ce valutando l'espressione risultante. Ad esempio, il valore di

H(3, 2, 7981676788374679859068493351144698070458)

è

2*2^(2^(2 + 1) + 2) + 2 + 1 = 2051

La sfida

Si sono dati come input tre interi b, c, n, per il quale si può assumere n >= 0e b, c > 1. Il tuo output è H(b, c, n). Vince il conteggio dei byte più breve e non sono consentite scappatoie standard. È possibile scrivere una funzione o un programma completo. Devi essere in grado di gestire input e output arbitrariamente grandi (bignum).

Casi test

4 2 3 -> 3
2 4 3 -> 5
2 4 10 -> 1028
4 4 40000 -> 40000
4 5 40000 -> 906375
5 4 40000 -> 3584
3 2 7981676788374679859068493351144698070458 -> 56761
2 3 2051 -> 35917545547686059365808220080151141317047

Fatto divertente

Per qualsiasi numero intero n, la sequenza ottenuta da

n1 = n
n2 = H(2, 3, n1) - 1
n3 = H(3, 4, n2) - 1
n4 = H(4, 5, n3) - 1
....

alla fine raggiunge 0. Questo è noto come teorema di Goodstein .

CJam, 60 58 45 43 41 38 36 byte

Grazie a Optimizer per il salvataggio di due byte.

l~:C;:B;{Bb)1$,,@f{1$~=C@)F#*+}~}:F~

Provalo qui.

Accetta l'input in ordine n b c.

Puoi usarlo per eseguire tutti i casi di test:

"3 4 2 
3 2 4 
10 2 4 
40000 4 4 
40000 4 5 
40000 5 4 
7981676788374679859068493351144698070458 3 2 
2051 2 3 "N/
{
~:C;:B;{Bb)1$,,@f{1$~=C@)F#*+}~}:F~
p}/

Spiegazione

Questa è un'implementazione abbastanza diretta del processo spiegato nella sfida, tranne per il fatto che interlocco l'espansione della base ricorsiva, la sostituzione della base e il calcolo del risultato finale:

l~:C;:B;{Bb)1$,,@f{1$~=C@)F#*+}~}:F~
l~:C;:B;                             "Read and evaluate input, store b and c in B and C.";
        {                       }:F  "Define a block F. This performs the required conversion.";
         Bb                          "Get digits of input number in base B.";
           )                         "Split off 0-power digit.";
            1$,                      "Copy remaining digits. Get their length n.";
               ,                     "Make array [0 1 ... n-1].";
                @                    "Pull up remaining digits.";
                 f{           }      "Map this block onto the range, passing in the digits
                                      as a second argument each time.";
                   1$~=              "Copy current i, bitwise complement, access digit array.
                                      This accesses the digits in reverse order.";
                       C             "Push the new base C.";
                        @)           "Pull up current i and increment to get power.";
                          F          "Apply F recursively.":
                           ~         "Raise C to the resulting power.";
                            *        "Multiply by digit.";
                             +       "Add to running total.";
                               ~     "The result will be in an array. Unwrap it.";
                                   ~ "Execute F on the input n.";

Python 2, 55

H=lambda b,c,n,s=0:n and n%b*c**H(b,c,s)+H(b,c,n/b,s+1)

Una soluzione ricorsiva. Come l'algoritmo ricorsivo per convertire tra basi, tranne che si ricorre anche sull'esponente.

Dividiamo nin due parti, la cifra corrente n%be tutte le altre cifre n/b. Il valore attuale del luogo è memorizzato nel parametro opzionale s. La cifra corrente viene convertita in base ccon c**e l'esponente sviene convertito in modo ricorsivo. Il resto viene quindi convertito allo stesso modo, +H(b,c,n/b,s+1)ma il valore del luogo sè uno superiore.

A differenza della conversione di base, la conversione di base ereditaria richiede di ricordare il valore del posto corrente nella ricorsione per la conversione.

Per facilità di lettura, ecco come appare quando be csono costanti globali fisse.

H=lambda n,s=0:n and n%b*c**H(s)+H(n/b,s+1)