Existe una ecuación, suponiendo ny xson positivas,

eso expresa la relación entre dos monomios, uno de los cuales es una tergiversación común del otro. Muchas personas cometen el simple error de igualar estos (es decir, 3x^2y (3x)^2).

Desafío

Dado un entero positivo i, determine y devuelva la solución ny xcon la suma más pequeña como una matriz [n, x]. En caso de empate, cualquier conjunto de soluciones es aceptable.

Casos de prueba

62658722541234765
[15, 11]

202500
[4, 15]

524288
[8, 4]

33044255768277
[13, 9]

Brachylog , 35 bytes

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

Pruébalo en línea!

Explicación

Construimos una lista [N, X], donde N >= X, luego de asignarle valores, probamos ambos [N, X]y [X, N]como posible salida. Por ejemplo, si Nse asigna a 3, vamos a probar a través de dar marcha atrás [3, 1], [1, 3], [3, 2], [2, 3], [3, 3]y [3, 3]. Después de eso, el siguiente paso de retroceso ocurrirá en el valor de N, que irá a 4, etc.

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

¡Gracias a las millas por ahorrar 2 bytes, más un montón de bytes que conté sin ninguna razón!

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

Calcula una tabla de pares {n, x}, donde x = (i / n) ^ (1 / n), utilizando todos los valores posibles de n; mantiene solo aquellos para los cuales la x correspondiente es un número entero; luego devuelve el par con el mayor valor de n.

Aquí, "todos los valores posibles de n" van de 1 a 2 * ln (i). Esto ignora la solución {n, x} = {i, 1}, pero está bien ya que la solución {n, x} = {1, i} será suficiente si es la mejor opción. Por lo tanto, x nunca necesita ser menor que 2, lo que significa que n * 2 ^ n ≤ i, y todos esos n son menores que 2 * ln (i).

Con el cálculo se puede demostrar que el par {n, x} que minimiza su suma en este contexto es el mismo que el par {n, x} con el n más grande (sin contar {i, 1}). Es por eso que la inicial Lastes lo suficientemente buena como para encontrar el par óptimo.

MATL , 22 bytes

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

Las salidas son x, nen ese orden.

La entrada está limitada por el doubletipo de datos predeterminado de MATL , que puede representar con precisión enteros hasta 2^53solo. Esto excluye la primera prueba (aún así, da el resultado correcto, pero eso no se puede garantizar en general para entradas tan grandes).

Pruébalo en línea!

Explicación

El código usa dos bucles anidados:

• El do...whilebucle externo pasa por todas las sumas posibles n+xen orden creciente. El ciclo se detendrá tan pronto como se encuentre una solución. Esto garantiza que generemos la solución con una suma mínima.
• El for eachbucle interno prueba todo ny xcon esa suma. Cuando la suma coincide con la entrada, se sale del bucle interno y se establece la condición del bucle del bucle externo falsepara que también se salga uno.

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

Jalea , 23 16 bytes

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

Dado i, esto genera todos los pares de enteros con reemplazo en [1, i]. Luego realiza el mismo filtrado y clasificación que en la solución anterior que se muestra a continuación. Dado que no hay restricción de tiempo, la fuerza bruta funcionará con el tiempo suficiente.

Pruébalo en línea! , pero no intente valores grandes en línea.

En mi PC, toma alrededor de 6 minutos calcular el resultado para i = 2048usar la versión ineficiente.

Versión eficiente

Esta es la solución anterior para 23 bytes que puede resolver los valores grandes rápidamente.

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

Dado i, calcula los divisores de ipara generar pares de [n, x]donde nes un divisor y x = floor( (i/n)^(1/n) ). Luego lo filtra por valores donde n * x^n == i, ordena los pares restantes por su suma y devuelve el primer par.

Pruébalo en línea! o Verificar todos los casos de prueba.

Explicación

×*@¥/=³  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)];

Esto genera todas las soluciones posibles que no están en el formato propuesto 73 Bytes

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

Perl, 52 bytes

Incluye +2 para -ap

Dar entrada sobre STDIN

mono.pl <<< 33044255768277

mono.pl:

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

1También se hizo un esfuerzo para que funcione . No tengo idea si los errores de coma flotante pueden hacer que esto devuelva la respuesta incorrecta para algunas entradas.