Existe uma equação, assumindo ne xé positiva,

que expressa a relação entre dois monômios, um sendo uma deturpação comum do outro. Muitas pessoas cometem o simples erro de equiparar esses valores (ie 3x^2e (3x)^2).

Desafio

Dado um número inteiro positivo i, determine e retorne a solução ne xcom a menor soma como uma matriz [n, x]. No caso de empate, qualquer conjunto de soluções é aceitável.

Casos de teste

62658722541234765
[15, 11]

202500
[4, 15]

524288
[8, 4]

33044255768277
[13, 9]

Braquilog , 35 bytes

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

Experimente online!

Explicação

Nós construímos uma lista [N, X], onde N >= X, em seguida, depois de atribuir valores a ele, nós tentamos tanto [N, X]e [X, N]possível saída. Por exemplo, se Né atribuído a 3, vamos testar através de retrocesso [3, 1], [1, 3], [3, 2], [2, 3], [3, 3]e [3, 3]. Depois disso, a próxima etapa de retrocesso ocorrerá no valor de N, que irá para 4etc.

,[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 bytes

Graças a milhas por economizar 2 bytes, mais um monte de bytes que contei sem motivo!

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

Calcula uma tabela de pares {n, x}, onde x = (i / n) ^ (1 / n), usando todos os valores possíveis de n; mantém apenas aqueles para os quais o x correspondente é um número inteiro; então retorna o par com o maior valor de n.

Aqui, "todos os valores possíveis de n" variam de 1 a 2 * ln (i). Isso ignora a solução {n, x} = {i, 1}, mas tudo bem, já que a solução {n, x} = {1, i} será suficiente se for a melhor escolha. Portanto, x nunca precisa ser menor que 2, o que significa que n * 2 ^ n ≤ i, e todos esses n são menores que 2 * ln (i).

Pode-se mostrar, usando cálculo, que o par {n, x} que minimiza sua soma nesse contexto é o mesmo que o par {n, x} com o maior n (sem contar {i, 1}). É por isso que a inicial Lasté boa o suficiente para encontrar o par ideal.

MATL , 22 bytes

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

As saídas são x, nnessa ordem.

A entrada é limitada pelo doubletipo de dados padrão do MATL , que pode representar com precisão números inteiros até 2^53apenas. Isso exclui o primeiro teste (ainda, fornece o resultado correto, mas isso não pode ser garantido em geral para entradas tão grandes).

Experimente online!

Explicação

O código usa dois loops aninhados:

• O do...whileloop externo percorre todas as somas possíveis n+xem ordem crescente. O loop será interrompido assim que uma solução for encontrada. Isso garante que produzimos a solução com soma mínima.
• O for eachloop interno testa tudo ne xcom essa soma. Quando a soma coincide com a entrada, o loop interno é encerrado e a condição do loop externo é definida para falseque um também seja encerrado.

Código comentado:

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

Geléia , 23 16 bytes

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

Dado i, isso gera todos os pares inteiros com substituição em [1, i]. Em seguida, ele executa a mesma filtragem e classificação da solução anterior mostrada abaixo. Como não há restrição de tempo, a força bruta funcionará com tempo suficiente.

Experimente online! , mas não tente grandes valores online.

No meu PC, leva cerca de 6 minutos para calcular o resultado do i = 2048uso da versão ineficiente.

Versão eficiente

Esta é a solução anterior para 23 bytes que é capaz de resolver grandes valores rapidamente.

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

Dado i, calcula os divisores de ipara gerar pares de [n, x]onde né um divisor e x = floor( (i/n)^(1/n) ). Em seguida, filtra-o para valores em que n * x^n == i, classifique os pares restantes por sua soma e retorne o primeiro par.

Experimente online! ou Verifique todos os casos de teste.

Explicação

×*@¥/=³  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 bytes

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

Isso gera todas as soluções possíveis que não estão no formato proposto 73 bytes

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

Perl, 52 bytes

Inclui +2 para -ap

Dê entrada no STDIN

mono.pl <<< 33044255768277

mono.pl:

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

1Também foi necessário algum esforço para fazê-lo funcionar . Não tenho idéia se erros de ponto flutuante podem fazer com que esse retorno seja a resposta errada para algumas entradas.