गलतफहमी मोनोमियल

Question

एक समीकरण मौजूद है, यह मानते हुए nऔर xसकारात्मक हैं,

यह दो मोनोमियल के बीच के रिश्ते को व्यक्त करता है, एक दूसरे का सामान्य गलत चित्रण है। कई लोग इन (यानी 3x^2और (3x)^2) को बराबर करने की सरल गलती करते हैं ।

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए i, समाधान को निर्धारित करें और वापस लौटें nऔर xएक सरणी के रूप में सबसे छोटी राशि के साथ [n, x]। एक टाई के मामले में, कोई भी समाधान सेट स्वीकार्य है।

परीक्षण के मामलों

62658722541234765
[15, 11]

202500
[4, 15]

524288
[8, 4]

33044255768277
[13, 9]

Comments

क्या हम [x, n]इसके बदले लौट सकते हैं [n, x]?

— घातक

इसके अलावा, क्या कोई समय की कमी है?

— घातक

nऔर xपूर्णांक, सही?

— लुइस मेंडो सेप

आउटपुट फॉर्म में है [n, x]और इसमें कोई समय की कमी नहीं है @Fatalize

— Zach Gates

हाँ, nऔर xपूर्णांक हैं @LuisMendo

— Zach Gates

Answer 1

ब्रेकीलॉग , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

हम एक सूची का निर्माण करते हैं [N, X], जहां N >= X, उसके बाद मूल्यों को निर्दिष्ट करने के बाद, हम दोनों [N, X]और [X, N]संभव आउटपुट के रूप में प्रयास करते हैं । उदाहरण के लिए, यदि Nको सौंप दिया जाता है 3, हम के माध्यम से उलटे पांव लौटने से परीक्षण किया जाएगा [3, 1], [1, 3], [3, 2], [2, 3], [3, 3]और [3, 3]। उसके बाद अगला backtracking स्टेप किस के वैल्यू पर Nआएगा 4, आदि।

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

Answer 2

गणितज्ञ, 61 बाइट्स

2 बाइट बचाने के लिए मीलों के लिए धन्यवाद, और बिना किसी कारण के गिने जाने वाले बाइट्स का एक पूरा गुच्छा!

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

N के सभी संभावित मूल्यों का उपयोग करके जोड़े की तालिका {n, x}, जहां x = (i / n) ^ (1 / n) की गणना करता है; केवल उन लोगों को रखता है जिनके लिए संबंधित x एक पूर्णांक है; फिर n के सबसे बड़े मान के साथ जोड़ी को वापस करता है।

यहाँ, "n के सभी संभावित मूल्य" 1 से 2 * ln (i) तक हैं। यह समाधान {n, x} = {i, 1} की उपेक्षा करता है, लेकिन समाधान के बाद से ठीक है {n, x} = {1, i} यदि यह सबसे अच्छा विकल्प है, तो पर्याप्त होगा। तो x को कभी भी 2 से छोटे होने की आवश्यकता नहीं है, जिसका अर्थ है कि n * 2 ^ n and i, और ऐसे सभी n 2 * ln (i) से कम हैं।

एक पथरी का उपयोग करके दिखा सकता है कि इस संदर्भ में उनकी राशि को कम करने वाली जोड़ी {n, x} सबसे बड़ी n (गिनती {i, 1}) के साथ जोड़ी {n, x} के समान है। यही कारण है कि प्रारंभिक Lastसबसे अच्छा है जो इष्टतम जोड़ी को ढूंढता है।

Comments

आप IntegerQ@*Last2 बाइट्स को बचाने के लिए परीक्षण स्थिति की रचना कर सकते हैं , लेकिन मैं इस वर्तमान संस्करण में 63 नॉट 86 बाइट्स भी गिनता हूं।

— मील

Answer 3

MATL , 22 बाइट्स

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

आउटपुट हैं x, nइसी क्रम में।

इनपुट MATL के डिफ़ॉल्ट doubleडेटा प्रकार द्वारा सीमित है , जो 2^53केवल पूर्णांकों तक पूर्णांक का प्रतिनिधित्व कर सकता है । यह पहले परीक्षण को बाहर करता है (फिर भी, यह सही परिणाम देता है, लेकिन इनपुट के लिए सामान्य रूप से इसकी गारंटी नहीं दी जा सकती है)।

इसे ऑनलाइन आज़माएं!

व्याख्या

कोड दो नेस्टेड छोरों का उपयोग करता है:

• बाहरी do...whileलूप n+xबढ़ते क्रम में सभी संभव रकम से गुजरता है । समाधान मिलते ही लूप बंद कर दिया जाएगा। यह गारंटी देता है कि हम न्यूनतम राशि के साथ समाधान का उत्पादन करते हैं।
• आंतरिक for eachपाश सभी का परीक्षण करता है nऔर xउस राशि के साथ। जब योग इनपुट के साथ मेल खाता है, तो आंतरिक लूप बाहर निकलता है और बाहरी लूप की लूप स्थिति सेट की जाती है falseताकि एक भी बाहर निकल जाए।

टिप्पणी कोड:

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

Answer 4

जेली , 23 16 बाइट्स

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

यह देखते हुए i, यह सभी पूर्णांक जोड़े को प्रतिस्थापन के साथ उत्पन्न करता है [1, i]। यह फिर वही फ़िल्टरिंग और सॉर्टिंग करता है जैसा कि नीचे दिखाए गए पिछले समाधान में किया गया है। चूंकि कोई समय की कमी नहीं है, इसलिए ब्रूट बल को पर्याप्त समय दिया जाएगा।

इसे ऑनलाइन आज़माएं! , लेकिन ऑनलाइन बड़े मूल्यों की कोशिश न करें।

मेरे पीसी पर, i = 2048अक्षम संस्करण का उपयोग करने के लिए परिणाम की गणना करने में लगभग 6 मिनट लगते हैं ।

कुशल संस्करण

यह 23 बाइट्स के लिए पिछले समाधान है जो बड़े मूल्यों को जल्दी से हल करने में सक्षम है।

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

यह देखते हुए i, जहां एक भाजक है और के iजोड़े उत्पन्न करने के लिए भाजक की गणना करता है । फिर इसे उन मानों के लिए फ़िल्टर करें जहां , शेष जोड़ियों को उनके योग द्वारा क्रमबद्ध करते हैं, और पहली जोड़ी को वापस करते हैं।[n, x]nx = floor( (i/n)^(1/n) )n * x^n == i

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें।

व्याख्या

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

Answer 5

PHP, 104 बाइट्स

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

यह प्रस्तावित प्रारूप 73 बाइट्स में नहीं सभी संभावित समाधानों को आउटपुट करता है

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

Answer 6

पर्ल, 52 बाइट्स

के लिए +2 शामिल है -ap

STDIN पर इनपुट दें

mono.pl <<< 33044255768277

mono.pl:

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

इसके लिए 1भी काम करने के लिए कुछ प्रयास किया । मुझे नहीं पता कि फ्लोटिंग पॉइंट एरर कुछ इनपुट के लिए गलत उत्तर दे सकता है।