Es gibt eine Gleichung, vorausgesetzt nund xsind positiv,

das drückt die Beziehung zwischen zwei Monomen aus, wobei eines eine häufige Falschdarstellung des anderen ist. Viele Menschen machen den einfachen Fehler, diese (dh 3x^2und (3x)^2) gleichzusetzen .

Herausforderung

Gegeben eine positive ganze Zahl i, bestimmt und gibt die Lösung nund xmit der kleinsten Summe als Array [n, x]. Im Falle eines Unentschieden ist jeder Lösungssatz akzeptabel.

Testfälle

62658722541234765
[15, 11]

202500
[4, 15]

524288
[8, 4]

33044255768277
[13, 9]

Brachylog , 35 Bytes

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

Probieren Sie es online aus!

Erläuterung

Wir erstellen eine Liste [N, X], in der N >= Xwir nach dem Zuweisen von Werten beide [N, X]und [X, N]als mögliche Ausgabe versuchen . Wenn beispielsweise Nzugewiesen wird 3, prüfen wir durch Rückzieher [3, 1], [1, 3], [3, 2], [2, 3], [3, 3]und [3, 3]. Danach wird der nächste Rückverfolgungsschritt für den Wert von ausgeführt N, zu dem 4usw.

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

Dank Meilen für das Speichern von 2 Bytes plus einer ganzen Reihe von Bytes habe ich ohne Grund gezählt!

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

Berechnet eine Tabelle von Paaren {n, x}, wobei x = (i / n) ^ (1 / n) unter Verwendung aller möglichen Werte von n; behält nur diejenigen bei, für die das entsprechende x eine ganze Zahl ist; gibt dann das Paar mit dem größten Wert von n zurück.

Hier liegen "alle möglichen Werte von n" im Bereich von 1 bis 2 * ln (i). Dies ignoriert die Lösung {n, x} = {i, 1}, aber das ist in Ordnung, da die Lösung {n, x} = {1, i} ausreicht, wenn es die beste Wahl ist. X muss also niemals kleiner als 2 werden, was bedeutet, dass n * 2 ^ n ≤ i ist und alle diese n kleiner als 2 * ln (i) sind.

Mit Hilfe von Kalkül kann man zeigen, dass das Paar {n, x}, das in diesem Zusammenhang ihre Summe minimiert, dasselbe ist wie das Paar {n, x} mit dem größten n (ohne {i, 1}). Deshalb die InitialeLast gut genug, um das optimale Paar zu finden.

MATL , 22 Bytes

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

Ausgänge sind x ,n in dieser Reihenfolge.

Die Eingabe wird durch den Standarddatentyp von MATL begrenzt double, der 2^53nur Ganzzahlen bis zu genau darstellen kann . Dies schließt den ersten Test aus (es liefert immer noch das richtige Ergebnis, aber das kann bei so großen Eingaben im Allgemeinen nicht garantiert werden).

Probieren Sie es online aus!

Erläuterung

Der Code verwendet zwei verschachtelte Schleifen:

• Die äußere do...whileSchleife durchläuft alle möglichen Summenn+x in aufsteigender Reihenfolge. Die Schleife wird gestoppt, sobald eine Lösung gefunden wurde. Dies garantiert, dass wir die Lösung mit minimaler Summe ausgeben.
• Die innere for eachSchleife testet alles nund xmit dieser Summe. Wenn die Summe mit der Eingabe übereinstimmt, wird die innere Schleife verlassen und die Schleifenbedingung der äußeren Schleife wird so eingestellt, falsedass auch eine beendet wird.

Kommentierter Code:

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

Gelee , 23 16 Bytes

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

Vorausgesetzt i, dies erzeugt alle ganzzahligen Paare mit Ersetzung in [1, i]. Anschließend wird die gleiche Filterung und Sortierung wie in der unten gezeigten vorherigen Lösung durchgeführt. Da es keine zeitliche Beschränkung gibt, funktioniert Brute Force bei ausreichender Zeit.

Probieren Sie es online aus!, aber versuchen Sie nicht große Werte online.

Auf meinem PC dauert es ungefähr 6 Minuten, um das Ergebnis für zu berechnen i = 2048 Verwendung der ineffizienten Version .

Effiziente Version

Dies ist die vorherige Lösung für 23 Bytes, mit der die großen Werte schnell gelöst werden können.

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

Gegeben i, berechnet die Teiler von i, um Paare von [n, x]wo nist ein Teiler und zu erzeugen x = floor( (i/n)^(1/n) ). Filtert es dann nach Werten, wobei n * x^n == idie verbleibenden Paare nach ihrer Summe sortiert werden und das erste Paar zurückgegeben wird.

Probieren Sie es online aus! oder Überprüfen Sie alle Testfälle.

Erläuterung

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

Dies gibt alle möglichen Lösungen aus, die nicht im vorgeschlagenen Format 73 Bytes vorliegen

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

Perl, 52 Bytes

Beinhaltet +2 für -ap

Geben Sie eine Eingabe auf STDIN

mono.pl <<< 33044255768277

mono.pl::

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

Hat einige Anstrengungen unternommen, damit es auch funktioniert 1. Ich habe keine Ahnung, ob Gleitkommafehler dazu führen können, dass dies für einige Eingaben die falsche Antwort zurückgibt.