Esiste un'equazione, assumendo ne xsono positivi,

che esprime la relazione tra due monomi, l'uno essendo una falsa rappresentazione comune dell'altro. Molte persone fanno il semplice errore di equiparare questi (cioè 3x^2e (3x)^2).

Sfida

Dato un numero intero positivo i, determinare e restituire la soluzione ne xcon la somma più piccola come matrice [n, x]. In caso di pareggio, qualsiasi set di soluzioni è accettabile.

Casi test

62658722541234765
[15, 11]

202500
[4, 15]

524288
[8, 4]

33044255768277
[13, 9]

Brachylog , 35 byte

,[N:X]#>>==L(.rMtT;Lr.rMtT),M^:T*?,

Provalo online!

Spiegazione

Costruiamo una lista [N, X], in cui N >= X, poi, dopo l'assegnazione di valori ad esso, proviamo entrambi [N, X]e [X, N]possibile uscita. Per esempio, se Nviene assegnato a 3, ci metterà alla prova attraverso il backtracking [3, 1], [1, 3], [3, 2], [2, 3], [3, 3]e [3, 3]. Dopodiché si verificherà il prossimo passo indietro sul valore di N, che andrà a 4, ecc.

,[N:X]     The list [N, X]
#>         Both N and X are strictly positive
>=         N >= X
=L         Assign values to N and X, and L = [N, X]
(          Either...
    .          Output = L
    rM         M is the reverse of the Output
    tT         T is the second element of M
;          ...or...
    Lr.        Output is the reverse of L
    rM         M = L
    tT         T is the last element of M
),
M^         First element of M to the power of the second element of L (T)...
:T*?,      ... times T is equal to the Input

Mathematica, 61 byte

Grazie alle miglia per aver salvato 2 byte, oltre a un sacco di byte che ho contato senza motivo!

Last@Select[{n,(#/n)^(1/n)}~Table~{n,2Log@#},IntegerQ@*Last]&

Calcola una tabella di coppie {n, x}, dove x = (i / n) ^ (1 / n), utilizzando tutti i possibili valori di n; mantiene solo quelli per i quali la corrispondente x è un numero intero; quindi restituisce la coppia con il valore più grande di n.

Qui, "tutti i possibili valori di n" vanno da 1 a 2 * ln (i). Ciò ignora la soluzione {n, x} = {i, 1}, ma va bene poiché la soluzione {n, x} = {1, i} sarà sufficiente se è la scelta migliore. Quindi x non deve mai diventare più piccolo di 2, il che significa che n * 2 ^ n ≤ i, e tutti questi n sono inferiori a 2 * ln (i).

Si può dimostrare usando il calcolo che la coppia {n, x} che minimizza la loro somma in questo contesto è la stessa della coppia {n, x} con n più grande (senza contare {i, 1}). Ecco perché l'iniziale Lastè abbastanza buona per trovare la coppia ottimale.

MATL , 22 byte

`T@XK:"@K@-@^*G=?3Mb~.

Le uscite sono x, nin questo ordine.

L'input è limitato dal tipo di doubledati predefinito di MATL , che può rappresentare accuratamente 2^53solo numeri interi . Questo esclude il primo test (comunque, dà il risultato corretto, ma ciò non può essere garantito in generale per input così grandi).

Provalo online!

Spiegazione

Il codice utilizza due loop nidificati:

• L' do...whileanello esterno passa attraverso tutte le possibili somme n+xin ordine crescente. Il ciclo verrà interrotto non appena viene trovata una soluzione. Ciò garantisce che produciamo la soluzione con la somma minima.
• Il for eachciclo interno verifica tutto ne xcon quella somma. Quando la somma coincide con l'input, il loop interno viene chiuso e la condizione del loop del loop esterno viene impostata in falsemodo da uscire anche da uno.

Codice commentato:

`         % Do...while
  T       %   Push "true". Will be used as loop condition (possibly negated to exit loop)
  @       %   Push iteration index, say K, which represents n+x
  XK      %   Copy that into clipboard K
  :       %   Range [1 2 ... K]
  "       %   For each
    @     %     Push loop variable (1, 2, ... K), which represents n
    K@-   %     Compute x as K minus n
    @     %     Push n again
    ^*    %     Power, multiply. This gives n*x^n
    G=    %     Does this equal the input?
    ?     %     If so
      3M  %       Push the inputs of the third-last function, that is, x and n
      b   %       Bubble up the "true" that is at the bottom of the stack
      ~   %       Transform it into "false". This will exit the do...while loop
      .   %       Break the for loop
          %     Implicitly end if
          %   Implicitly end for
          % Implicitly end do...while
          % Implicitly display

Gelatina , 23 16 byte

×*@¥/=³
ṗ2ÇÐfSÞḢ

Dato i, questo genera tutte le coppie di numeri interi con la sostituzione in [1, i]. Esegue quindi gli stessi filtri e ordinamenti della soluzione precedente illustrata di seguito. Poiché non vi è alcun limite di tempo, la forza bruta funzionerà con un tempo sufficiente.

Provalo online! , ma non provare grandi valori online.

Sul mio PC, sono necessari circa 6 minuti per calcolare il risultato per l' i = 2048utilizzo della versione inefficiente.

Versione efficiente

Questa è la soluzione precedente per 23 byte che è in grado di risolvere rapidamente i valori di grandi dimensioni.

×*@¥/=³
ÆDµṚ*İ⁸żḞÇÐfSÞḢ

Dato i, calcola i divisori di iper generare coppie di [n, x]dove nè un divisore e x = floor( (i/n)^(1/n) ). Quindi lo filtra per valori in cui n * x^n == i, ordina le coppie rimanenti in base alla loro somma e restituisce la prima coppia.

Provalo online! oppure Verifica tutti i casi di test.

Spiegazione

×*@¥/=³  Helper link. Input: list [n, x]
    /    Reduce using
   ¥       A dyadic chain
 *@        Compute x^n
×          Multiply by n
      ³  The initial value i
     =   Test if n * x^n == i

ṗ2ÇÐfSÞḢ  Main link (16 byte version). Input: integer i
ṗ2        Generate all pairs of integers in [1, i]
  ÇÐf     Filter for where the helper link is true
     SÞ   Sort them by their sum
       Ḣ  Return the first result

ÆDµṚ*İ⁸żḞÇÐfSÞḢ  Main link (23 byte version). Input: integer i
ÆD               Compute the divisors of i
  µ              Begin a new monadic chain operating on the divisors
   Ṛ             Reverse the divisors
     İ           Reciprocal of each divisors
    *            Raise each in the reversed divisors to the reciprocal of a divisor
      ⁸          Get the divisors
       ż         Interleave the divisors with the previous powers
        Ḟ        Floor each
         ÇÐf     Filter for where the helper link is true
            SÞ   Sort them by their sum
              Ḣ  Return the first result

PHP, 104 byte

for(;1<$x=(($i=$argv[1])/++$n)**(1/$n);)!($x==ceil($x))?:$a[$x+$n]="[$x, $n]";ksort($a);echo$a[key($a)];

Ciò genera tutte le possibili soluzioni non nel formato proposto 73 byte

for(;1<=$x=(($i=$argv[1])/++$n)**(1/$n);)!($x==ceil($x))?:print"$x,$n\n";

Perl, 52 byte

Include +2 per -ap

Dare input su STDIN

mono.pl <<< 33044255768277

mono.pl:

#!/usr/bin/perl -ap
$_=("@F"/++$.)**(1/$.)while!/\./?$\="$. $_":$_>2}{

Ci sono voluti alcuni sforzi per farlo funzionare 1anche per . Non ho idea se errori in virgola mobile possano rendere questo ritorno la risposta sbagliata per alcuni input.