Il existe une équation, en supposant net xsont positifs,

qui exprime la relation entre deux monômes, l'un étant une fausse représentation commune de l'autre. Beaucoup de gens font la simple erreur de les assimiler (ie 3x^2et (3x)^2).

Défi

Étant donné un entier positif i, déterminez et renvoyez la solution net xavec la plus petite somme sous forme de tableau [n, x]. En cas d'égalité, tout ensemble de solutions est acceptable.

Cas de test

62658722541234765
[15, 11]

202500
[4, 15]

524288
[8, 4]

33044255768277
[13, 9]

Brachylog , 35 octets

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

Essayez-le en ligne!

Explication

Nous construisons une liste [N, X], où N >= X, après lui avoir assigné des valeurs, nous essayons à la fois [N, X]et [X, N]comme sortie possible. Par exemple, si Nobtient attribué 3, nous testerons par retours en arrière [3, 1], [1, 3], [3, 2], [2, 3], [3, 3]et [3, 3]. Après cela, la prochaine étape de retour en arrière se produira sur la valeur de N, qui ira à 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 octets

Merci aux miles pour avoir sauvé 2 octets, plus tout un tas d'octets que j'ai comptés sans raison!

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

Calcule une table de paires {n, x}, où x = (i / n) ^ (1 / n), en utilisant toutes les valeurs possibles de n; ne conserve que ceux dont le x correspondant est un entier; renvoie ensuite la paire avec la plus grande valeur de n.

Ici, "toutes les valeurs possibles de n" vont de 1 à 2 * ln (i). Cela ignore la solution {n, x} = {i, 1}, mais ce n'est pas grave car la solution {n, x} = {1, i} suffira si c'est le meilleur choix. Ainsi, x n'a jamais besoin d'être inférieur à 2, ce qui signifie que n * 2 ^ n ≤ i, et tous ces n sont inférieurs à 2 * ln (i).

On peut montrer en utilisant le calcul que la paire {n, x} qui minimise leur somme dans ce contexte est la même que la paire {n, x} avec le plus grand n (sans compter {i, 1}). C'est pourquoi l'initiale Lastest assez bonne pour trouver la paire optimale.

MATL , 22 octets

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

Les sorties sont x, ndans cet ordre.

L'entrée est limitée par le doubletype de données par défaut de MATL , qui peut représenter avec précision des entiers jusqu'à 2^53seulement. Cela exclut le premier test (toujours, il donne le résultat correct, mais cela ne peut pas être garanti en général pour des entrées si grandes).

Essayez-le en ligne!

Explication

Le code utilise deux boucles imbriquées:

• La do...whileboucle extérieure passe par toutes les sommes possibles n+xdans l'ordre croissant. La boucle sera arrêtée dès qu'une solution sera trouvée. Cela garantit que nous sortons la solution avec une somme minimale.
• La for eachboucle intérieure teste tout net xavec cette somme. Lorsque la somme coïncide avec l'entrée, la boucle interne est quittée et la condition de boucle de la boucle externe est définie de falsesorte que l'une soit également quittée.

Code commenté:

`         % 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ée , 23 16 octets

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

Étant donné i, cela génère toutes les paires entières avec remplacement dans [1, i]. Il effectue ensuite le même filtrage et tri que dans la solution précédente illustrée ci-dessous. Puisqu'il n'y a pas de contrainte de temps, la force brute fonctionnera avec suffisamment de temps.

Essayez-le en ligne! , mais n'essayez pas de grandes valeurs en ligne.

Sur mon PC, il faut environ 6 minutes pour calculer le résultat de l' i = 2048utilisation de la version inefficace.

Version efficace

Il s'agit de la solution précédente pour 23 octets qui est capable de résoudre rapidement les grandes valeurs.

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

Étant donné i, calcule les diviseurs de ipour générer des paires de [n, x]où nest un diviseur et x = floor( (i/n)^(1/n) ). Ensuite, il le filtre pour les valeurs où n * x^n == i, trie les paires restantes par leur somme et renvoie la première paire.

Essayez-le en ligne! ou Vérifiez tous les cas de test.

Explication

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

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

Cela génère toutes les solutions possibles qui ne sont pas dans le format proposé 73 octets

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

Perl, 52 octets

Comprend +2 pour -ap

Donnez votre avis sur STDIN

mono.pl <<< 33044255768277

mono.pl:

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

A pris un effort pour le faire fonctionner 1aussi. Je n'ai aucune idée si les erreurs en virgule flottante peuvent faire de ce retour la mauvaise réponse pour certaines entrées.