एक पूर्णांक का सुनहरापन

21

एक सकारात्मक पूर्णांक n को पूर्णांक पक्षों के साथ एक आयत के रूप में दर्शाया जा सकता है a , b ऐसा कि n = a * b । यही है, क्षेत्र संख्या का प्रतिनिधित्व करता है। सामान्य तौर पर, ए और बी किसी दिए गए एन के लिए अद्वितीय नहीं हैं ।

साथ ही जाना जाता है, एक आयत विशेष रूप से आंखों के लिए खुश है (या यह मस्तिष्क है?) जब इसके पक्ष में हैं सुनहरा अनुपात , φ = (sqrt (5) +1) / 2 ≈ १.६१८०३३९८८७ ...

इन दो तथ्यों को मिलाकर, इस चुनौती का उद्देश्य दो पूर्णांकों के उत्पाद में एक पूर्णांक n को विघटित करना है a , b जिसका अनुपात φ (सामान्य मेट्रिक पर। के साथ) जितना संभव हो उतना करीब है । तथ्य यह है कि φ तर्कहीन है तात्पर्य एक अनूठा समाधान जोड़ी (है कि वहाँ एक , ख )।

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए n , उत्पादन धनात्मक पूर्णांक एक , ख ऐसी है कि एक * ख = n और के बीच पूर्ण अंतर एक / ख और φ कम से कम है।

एक उदाहरण के रूप में, n = 12. पर विचार करें जो जोड़े ( a , b ) जो एक * b = n को संतुष्ट करते हैं: (1, 12), (2,6), (3,4), (4,3), ( 6,2), (12,1)। जोड़ी जिसका अनुपात φ (4,3) के सबसे करीब है , जो 4/3 = 1.333 देता है।

नियम

कार्य या कार्यक्रम स्वीकार्य हैं।

अंश ( एक ) दिखाई देनी चाहिए पहले उत्पादन में, और विभाजक ( ख ) दूसरा । इसके अलावा, इनपुट और आउटपुट प्रारूप हमेशा की तरह लचीले होते हैं। उदाहरण के लिए, दो नंबर किसी भी उचित विभाजक के साथ तार के रूप में या एक सरणी के रूप में आउटपुट हो सकते हैं।

कोड को मनमाने ढंग से बड़ी संख्या के लिए सिद्धांत रूप में काम करना चाहिए। व्यवहार में, यह स्मृति या डेटा-प्रकार के प्रतिबंधों तक सीमित हो सकता है।

यह की एक अनुमानित संस्करण पर विचार करने के लिए पर्याप्त है φ , जब तक यह करने के लिए सही निर्भर है तीसरे दशमलव या बेहतर। यही है, सही φ और अनुमानित मान के बीच का अंतर 0.0005 से अधिक नहीं होना चाहिए। उदाहरण के लिए, 1.618 स्वीकार्य है।

एक अनुमानित, तर्कसंगत संस्करण का उपयोग करते समय imate वहाँ एक छोटा सा मौका है कि समाधान अद्वितीय नहीं है। उस स्थिति में आप किसी भी युग्म a का उत्पादन कर सकते हैं , b जो न्यूनतम मानदंड को संतुष्ट करता है।

सबसे छोटा कोड जीतता है।

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

1        ->  1    1
2        ->  2    1 
4        ->  2    2
12       ->  4    3
42       ->  7    6
576      ->  32   18
1234     ->  2    617
10000    ->  125  80
199999   ->  1    199999
9699690  ->  3990 2431
code-golf  math  arithmetic 
— लुइस मेंडो
स्रोत
निश्चित रूप से अधिकांश उत्तर कुछ प्रकार के तर्कसंगत सन्निकटन का उपयोग कर रहे हैं be, जब तक कि आप स्वीकार नहीं करते हैं उदाहरण के लिए / bb / a के परिणाम के साथ उत्तर यथासंभव 1 के करीब है।
— नील
@ नहीं मुझे यकीन नहीं है कि मैं आपकी टिप्पणी को समझूंगा। कम से कम करने |a/b-b/a-1|का आपका विचार आशाजनक है, हालांकि एक प्रमाण क्रम में होगा
— लुइस मेंडू
यकीन नहीं है कि मैं एक टिप्पणी में एक पूरे सबूत रटना कर सकते हैं, लेकिन रूपरेखा इस प्रकार है: पूरे आयत का प्रतिनिधित्व करता है a/b। इकाई वर्ग को हटाने से दाईं ओर छोटी आयत निकलती है जो प्रतिनिधित्व करती है b/a। एक सुनहरा आयत इसलिए 1.11 के अंतर को प्राप्त करता है
— नील
यदि ए और बी Fibbonacci अनुक्रम में आसन्न संख्याएं नहीं हैं, तो क्या परीक्षण में उनके सहित कोई बिंदु है?
— स्ट्रॉबेरी
उस ने कहा, 1618 x 1000 एक अच्छे उम्मीदवार की तरह लगता है (या, संदर्भ के अनुसार, 809 x 500)
— स्ट्रॉबेरी

जवाबों:

6

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

@ मीलों के लिए 1 बाइट का धन्यवाद सहेजा गया।

÷/ạØp
ÆDżṚ$ÇÞḢ

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

व्याख्या

÷/ạØp         Helper link, calculates abs(a/b - phi). Argument: [a, b]
÷/            Reduce by division to calculate a/b.
  ạØp         Calculate abs(a/b - phi).

ÆDżṚ$ÇÞḢ      Main link. Argument: n
ÆD            Get divisors of n.
  żṚ$         Pair the items of the list with those of its reverse. The reversed
              divisors of a number is the same list as the number divided by each
              of the divisors.
     ÇÞ       Sort by the output of the helper link of each pair.
       Ḣ      Get the first element [a, b] and implicitly print.
— PurkkaKoodari
स्रोत
आप अपने साथ भाजक सूची के रिवर्स इंटरलेक्ट करके एक बाइट बचा सकते हैं। ÷/ạØp¶ÆDżṚ$ÇÞḢ14 बाइट्स के लिए उपयोग करना , यह एक तर्क के रूप में [a, b]दी nगई सूची देता है ।
— मील
@ मीलों कूल! मैं स्पष्ट रूप से पूरी तरह से याद किया /। (यह वही है जो मैंने अपने पाइथ सॉल्यूशन में किया था।) जब मैं अपने लैपटॉप पर मिलेगा तो एडिट करूंगा।
— पुरकाकूदरी
6

मतलाब, 96 81 बाइट्स

गोल्फ (-15 बाइट्स), लुइस मेंडो के लिए सहारा

function w(n);a=find(~(mod(n,1:n)));[~,c]=min(abs(a./(n./a)-1.618));[a(c) n/a(c)]

मूल:

function w(n)
a=find(not(mod(n,1:n)));b=abs(a./(n./a)-1.618);c=find(not(b-min(b)));[a(c) n/a(c)]

यह अब तक एक महान समाधान नहीं है, लेकिन कोड-गोल्फ में मेरा पहला प्रयास है। क्या मजाक है!

— ptev
स्रोत
2
सहमत थे कि यह मजेदार है! साइट पर आपका स्वागत है!
— DJMcMayhem
1
आप की जगह ले सकता notसे ~ कुछ बाइट्स को बचाने के लिए। इसके अलावा, minआप के दूसरे आउटपुट का उपयोग करके छुटकारा पा सकते हैं find:a=find(~(mod(n,1:n)));[~,c]=min(abs(a./(n./a)-1.618));[a(c) n/a(c)]
— लुइस मेंडो सेप
अच्छी तरह से देखा - जो काफी कुछ प्रतीकों को छोड़ देता है!
— 11:12 बजे ptev
1
आप इसे का उपयोग करके कम कर सकते हैं n=input('');के बजाय function w(n);तो आप के लिए एक अतिरिक्त जोड़ी है ()चारों ओर mod।
— 10
5

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

#&@@SortBy[{x=Divisors@#,#/x},Abs[#/#2-1.618]&]&

स्थानांतरण के लिए मेथेमेटिका के पोस्टफ़िक्स ऑपरेटर (एक सुपरस्क्रिप्ट के रूप में प्रदर्शित किया जाता है Tमेथेमेटिका में)।

Mathematica में एक अंतर्निहित है GoldenRatio, लेकिन 1.618 बहुत छोटा है, खासकर क्योंकि पूर्व की भी आवश्यकता होती है N@।

— मार्टिन एंडर
स्रोत
5

पायथ, 21 20 18 बाइट्स

hoacFN.n3C_Bf!%QTS

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

व्याख्या

  1. S1 से इनपुट तक inclu ive रेंज प्राप्त करें ।
  2. fइनपुट विभाजित करने के लिए संख्याओं के लिए ilter !%QT।
  3. मिलता है [that list, that list reversed] _B। किसी संख्या का उलटा भाजक एक ही सूची है जो प्रत्येक भाजक द्वारा विभाजित संख्या के समान है।
  4. की जोड़ी प्राप्त करने के लिए सूची स्थानांतरित करें [numerator, denominator]।
  5. S o, जोड़े aके अनुपात cFNऔर सुनहरे अनुपात के bsolute अंतर से जोड़े .n3।
  6. पहली (सबसे कम) जोड़ी प्राप्त करें hऔर प्रिंट करें।
— PurkkaKoodari
स्रोत
5

जावास्क्रिप्ट (ईएस 6), 73 बाइट्स

n=>{for(b=0,k=n/.809;n%++b||k>b*b*2&&(a=b););return[b=k-a*a>b*b?b:a,n/b]}

हम देख रहे हैं:

  • a = n का उच्चतम विभाजक जिसके लिए n / of > a
  • b = n का सबसे निचला भाजक जिसके लिए n / of < b of है

फिर, समाधान या तो [ए, एन / ए] या [बी, एन / बी] है । हम तुलना a² - n / φ साथ b² - n / φ पता लगाने के लिए जो अभिव्यक्ति शून्य के सबसे करीब है।

: वास्तविक कोड में इस्तेमाल सूत्र φ / 2 जो एक ही परिशुद्धता के साथ φ की तुलना में कम तरह से लिखा जा सकता है पर आधारित हैं .809बनाम 1.618।

इसलिए:

n / φ> a / ⇔ n / (2/2)> 2a²

तथा:

n / / - a /> b² - n / ² / 2n / ² - a²> b / φ n / ( ⇔ / 2) - a²> b²

जटिलता

पुनरावृत्तियों की संख्या एन के कारकों की संख्या पर बहुत अधिक निर्भर करती है। सबसे खराब स्थिति तब होती है जब n अभाज्य होता है, क्योंकि हमें इसके केवल 2 विभाजकों को खोजने के लिए 1 से n तक सभी पुनरावृत्तियों का प्रदर्शन करना होगा। 199999 के साथ यही होता है। दूसरी तरफ, 9699690 19-चिकनी है और हम जल्दी से ब्रेकिंग पॉइंट breaking (n / φ) breaking 2448 के दोनों ओर दो डिवाइडर पाते हैं।

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

let f =
n=>{for(b=0,k=n/.809;n%++b||k>b*b*2&&(a=b););return[b=k-a*a>b*b?b:a,n/b]}

console.log(JSON.stringify(f(12)));       // [ 3, 4 ]
console.log(JSON.stringify(f(42)));       // [ 6, 7 ]
console.log(JSON.stringify(f(576)));      // [ 18, 32 ]
console.log(JSON.stringify(f(1234)));     // [ 2, 617 ]
console.log(JSON.stringify(f(10000)));    // [ 80, 125 ]
console.log(JSON.stringify(f(199999)));   // [ 1, 199999 ]
console.log(JSON.stringify(f(9699690)));  // [ 2431, 3990 ]
स्निपेट का विस्तार करें

— Arnauld
स्रोत
4

जावास्क्रिप्ट (ईएस 6), 83 बाइट्स

f=
n=>{p=r=>Math.abs(r/n-n/r-1);for(r=i=n;--i;)r=n%i||p(i*i)>p(r*r)?r:i;return[r,n/r]}
;
<input type=number min=1 oninput=[a.value,b.value]=f(+this.value)><input readonly id=a><input readonly id=b>
स्निपेट का विस्तार करें

असल में (रिटर्न एक , ख ) जोड़ी जिनमें से निरपेक्ष मूल्य को कम करता है एक / ख - ख / एक , -1, लेकिन कम से कम सभी प्रकार के परीक्षण के लिए इस काम करता है, हालांकि मुझे लगता है मैं बजाय 1.618 परीक्षण का उपयोग करके 4 बाइट बचत हो सकती है ।

— नील
स्रोत
3

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

:1fL:2a:Lzoht
,A:B#>.*?!,.=
:3a/:$A-$|
//

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

व्याख्या

  • मुख्य विधेय:

    :1fL           L is the list of all couples [A:B] such that A*B = Input (see Pred. 1)
    :2a        Compute the distance between all As/Bs and φ (see Pred. 2)
       :Lz     Zip those distances to L
          o    Sort the zip on the distances
           ht  Take the couple [A:B] of the first element of the sorted list

  • Predicate 1: आउटपुट एक ऐसा युगल [A:B]हैA*B = Input

    ,A:B           The list [A:B]
    #>         Both A and B are strictly positive
      .        Output = [A:B]
       *?      A*B = Input
         !,    Discard other choice points
           .=  Assign a value to A and B that satisfy the constraints

  • 2 की भविष्यवाणी करें: A/Bऔर Comp के बीच की दूरी की गणना करें ।

    :3a            Convert A and B to floats
   /           Divide A by B
    :$A-       Subtract φ
        $|     Absolute value

  • Predicate 3: एक इंट्रेट को अपने इनवर्ट में बदलकर फ्लोट में कन्वर्ट करें

    /              1/Input
 /             Output = 1/(1/Input)
— Fatalize
स्रोत
जिज्ञासा से बाहर: φBrachylog में एक पूर्वनिर्धारित शाब्दिक है? या इसे कोड में कहां परिभाषित किया गया है?
— लुइस मेंडो सेप
1
ओह, मैंने अभी देखा:$A
— लुइस मेंडो सेप
2
@LuisMendo के Aलिए Au;)
— घातक
आआहह, बहुत अच्छा!
— लुइस मेंडो सेप
2

हास्केल (लैंबडॉट), 86 बाइट्स

f(x,y)=abs$(x/y)-1.618
q n=minimumBy((.f).compare.f)[(x,y)|x<-[1..n],y<-[1..n],x*y==n]
— BlackCap
स्रोत
2

php, 103 बाइट्स

<?php for($s=$a=$argv[1];++$i<$a;)if($a%$i==0&&$s>$t=abs($i*$i/$a-1.618)){$n=$i;$s=$t;}echo"$n ".$a/$n;

बिना सूचना $ के बारे में एक नोटिस (यह निष्पादन को बाधित नहीं करता है) का उत्पादन करता है इसलिए मुझे ऐसे वातावरण में चलना चाहिए जो नोटिस को चुप कर दें।

— user59178
स्रोत
जब कोड को php -r '…'(जहां -rमुफ्त में हो) चलाया जा सकता है, तब PHP ओपन टैग की गिनती की आवश्यकता नहीं होती है। और निश्चित रूप से लंबे फॉर्म की आवश्यकता नहीं है, जैसा short_open_tagकि डिफ़ॉल्ट रूप से है।
— मैनटवर्क
जहाँ तक मुझे पता है कि $ argv -r के साथ काम नहीं करता है, इसलिए इसे वैसे भी नहीं चलाया जा सकता है। अगर आपने खिड़कियों पर और टैग के बिना चल रहे हैं, तो इसे रीडलाइन () या फ़िज़ (एसटीडीआईएन) में बदलना संभवतया वैसे भी कम है।
— user59178
-rऔर $argvसाथ में अच्छा काम कर रहे हैं: pastebin.com/vcgb5pT2
— मैनटवर्क
हुह। वैसे यह मेरे लिए काम नहीं करता है, मुझे बस अपरिभाषित चर नोटिस मिलते हैं, मुझे आश्चर्य है कि अगर यह एक सेटिंग है या अगर यह सामान्य रूप से सिर्फ विंडोज़ है।
— user59178
तुम अब भी जगह ले सकता है <?phpके साथ <?करने के लिए बचाने तीन बाइट्स।
— पॉल शमित्ज़
1

पायथन 3, 96 बाइट्स

बहुत ही सरल उपाय। इस SO उत्तर का उपयोग करता है ।

lambda n:min([((i,n//i),abs(1.618-i/(n//i)))for i in range(1,n+1)if n%i<1],key=lambda x:x[1])[0]

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

पायथन 2 में एक ही समाधान लंबे समय तक एक बाइट है।

lambda n:min([((i,n/i),abs(1.618-1.*i/(n/i)))for i in range(1,n+1)if n%i<1],key=lambda x:x[1])[0]
— mbomb007
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.