एक धनात्मक पूर्णांक इनपुट N को देखते हुए , दो गैर-ऋणात्मक संख्याओं, a और b , जहाँ <b , का न्यूनतम संभव औसत मान होता है, जिसके परिणामस्वरूप संख्या N आवर्ती संबंध अनुक्रम का हिस्सा होगा:

f(0) = a
f(1) = b
f(n) = f(n-2)+f(n-1)

मामले में एक से अधिक समाधान होते हैं जहां a और b का मतलब न्यूनतम होता है, तो आपको सबसे कम b के साथ आउटपुट देना चाहिए ।

आप मान सकते हैं कि एन आपकी भाषा / प्रणाली में पूर्णांकों की प्रतिनिधि सीमा के भीतर है।

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

N = 1
a = 0, b = 1

N = 15
a = 0, b = 3

N = 21
a = 0, b = 1

N = 27
a = 0, b = 9   <- Tricky test case. [3, 7] is not optimal and [4, 3] is not valid

N = 100
a = 4, b = 10

N = 101
a = 1, b = 12

N = 102
a = 0, b = 3

N = 1000
a = 2, b = 10

— स्टीवी ग्रिफिन
स्रोत

यदि a>=0और a<bक्या कभी कई समाधान हैं?

— जोनाथन एलन

मैं गारंटी नहीं दे सकता कि कई समाधान हैं या नहीं हैं। दोनों 1,4और 2,3देना होगा 5, और वे एक ही मतलब है। मुझे लगता है कि उन मामलों के समान खोजना संभव है, जहां ये सबसे कम औसत मूल्य हैं। यदि आप दिखा सकते हैं / साबित कर सकते हैं कि कई समाधान नहीं हैं तो आपको उस स्थिति की जाँच करने की आवश्यकता नहीं है।

— स्टीवी ग्रिफिन

2

पूरी तरह से codegolf.stackexchange.com/q/147200/67961

— J42161217

3

सबसे कम संभव माध्य A249783 के लिए इसी OEIS अनुक्रम में एक जंगली दिखने वाला ग्राफ है ।

— पीटर कैगी

1

@ TorjanJohansen मैंने अपने उत्तर के लिए एक प्रमाण जोड़ा कि कोई डुप्लिकेट समाधान नहीं हैं (क्योंकि मेरा उत्तर उस पर निर्भर था)।

— कार्डबोर्ड_बॉक्स

8

हस्क , 19 18 16 14 13 15 बाइट्स

1 बाइट बचाने के लिए धन्यवाद जर्ब।

ḟö£⁰ƒẊ++ÖΣṖ2Θḣ⁰

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

स्पष्टीकरण:

अस्वीकरण: मैं वास्तव ȯƒẊ++में कोड के अनुभाग को नहीं समझता ।

संपादित करें: यह हास्केल में अनुवाद करना प्रतीत होता है fix.(mapad2(+).).(++), जहां mapad2एक सूची में सभी आसन्न जोड़े के लिए फ़ंक्शन लागू होता है। (हालांकि, इस कार्यक्रम के संदर्भ में हस्क को जानते हुए, इसका मतलब कुछ और हो सकता है)

            Θḣ⁰    Create the list [0..input]
          Ṗ2       Generate all possible sublists of length 2
        ÖΣ         Sort them on their sums
ḟ                  Find the first element that satisfies the following predicate.
    ƒẊ++             Given [a,b], magically generate the infinite Fibonacci-like
                     sequence from [a,b] without [a,b] at the start.
 ö£⁰                 Is the input in that list (given that it is in sorted order)?

— H.PWiz
स्रोत

— Ö के

मुझे यकीन है कि मैंने कोशिश की ...

— H.PWiz

8

जावास्क्रिप्ट (Node.js) , 92 90 89 91 83 82 बाइट्स

~~-3 बाइट्स~~ -1 बाइट थैंपेटबाय का धन्यवाद

-8 -9 बाइट्स नील को धन्यवाद।

f=(n,a=1,b=0,c=(a,b)=>b<n?c(a+b,a):b>n)=>c(a,b)?b+2<a?f(n,a-1,b+1):f(n,b-~a):[b,a]

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

नोट: यह समाधान इस तथ्य पर निर्भर करता है कि कभी भी एकाधिक न्यूनतम समाधान नहीं होते हैं।

सबूत है कि वहाँ कभी नहीं कई समाधान हैं:

आज्ञा देना FIB(a,b,k)क्रम से शुरू होने वाले फाइबोनैचि-जैसा है a,b:

FIB(a,b,0) = a
FIB(a,b,1) = b
FIB(a,b,k) = FIB(a,b,k-1) + FIB(a,b,k-2)

लेम्मा 1

फाइबोनैचि-जैसे दृश्यों के बीच का अंतर स्वयं फाइबोनैचि-जैसा है, अर्थात FIB(a1,b1,k) - FIB(a0,b0,k) = FIB(a1-a0,b1-b0,k)। इसका प्रमाण पाठक पर छोड़ दिया जाता है।

लेम्मा २

के लिए n >= 5, एक समाधान a,bमौजूद है संतोषजनक a+b < n:

अगर nहै भी,FIB(0,n/2,3) = n

अगर nयह अजीब है,FIB(1,(n-1)/2,3) = n

प्रमाण

n < 5उन मामलों को जहां पूरी जांच की जा सकती है।

मान लीजिए कि हमारे लिए दो कम से कम समाधान है n >= 5, a0,b0और a1,b1साथ a0 + b0 = a1 + b1और a0 != a1।

फिर ऐसे मौजूद k0,k1हैं FIB(a0,b0,k0) = FIB(a1,b1,k1) = n।

मामला एक: k0 = k1

WLOG मान b0 < b1(और इसलिए a0 > a1)

आज्ञा DIFF(k)देना के बीच अंतर Fibonnaci तरह दृश्यों के साथ शुरू a1,b1और a0,b0:

DIFF(k) = FIB(a1,b1,k) - FIB(a0,b0,k) = FIB(a1-a0,b1-b0,k) (लेम्मा 1)

DIFF(0) = a1 - a0 < 0

DIFF(1) = b1 - b0 > 0

DIFF(2) = (a1+b1) - (a0+b0) = 0

DIFF(3) = DIFF(1) + DIFF(2) = DIFF(1) > 0

DIFF(4) = DIFF(2) + DIFF(3) = DIFF(3) > 0

एक बार फिबोनेसी जैसे अनुक्रम में 2 सकारात्मक शब्द हैं, बाद के सभी शब्द सकारात्मक हैं।

इस प्रकार, केवल समय DIFF(k) = 0कब है k = 2, इसलिए एकमात्र विकल्प k0 = k1है 2।

इसलिये n = FIB(a0,b0,2) = a0 + b0 = a1 + b1

इन समाधानों की न्यूनतमता लेम्मा 2 का विरोध करती है।
केस 2 k0 != k1::

डब्ल्यूएलओजी मान लेते हैं k0 < k1।

हमारे पास है FIB(a1,b1,k1) = n

चलो a2 = FIB(a1,b1,k1-k0)

चलो b2 = FIB(a1,b1,k1-k0+1)

तब FIB(a2,b2,k0) = FIB(a1,b1,k1) = FIB(a0,b0,k0)(पाठक के लिए व्यायाम)

चूंकि FIB(a1,b1,k)यह गैर-नकारात्मक है k >= 0, इसलिए यह गैर-घटती भी है।

यह हमें देता है a2 >= b1 > a0और b2 >= a1+b1 = a0+b0।

तो चलो DIFF(k) = FIB(a2,b2,k) - FIB(a0,b0,k) = FIB(a2-a0,b2-b0,k)(Lemma 1)

DIFF(0) = a2 - a0 > 0

DIFF(1) = b2 - b0 >= (a0 + b0) - b0 = a0 >= 0

DIFF(2) = DIFF(0) + DIFF(1) >= DIFF(0) > 0

DIFF(3) = DIFF(1) + DIFF(2) >= DIFF(2) > 0

एक बार फिर, DIFF2 सकारात्मक शब्द हैं और इसलिए बाद के सभी शब्द सकारात्मक हैं।

इस प्रकार, एकमात्र समय जब यह संभव DIFF(k) = 0है k = 1, इसलिए एकमात्र विकल्प k0है 1।

FIB(a0,b0,1) = n

b0 = n

यह लेम्मा 2 का विरोध करता है।

— गत्ते के डिब्बे का बक्सा
स्रोत

1

89 बाइट्स

1

77 बाइट्स

— नील

@ नील जो कि कम bसे कम करने के बजाय कम से कम होता है a+b, और इस प्रकार आपका समाधान देता है f(27) = [3,7]लेकिन इष्टतम समाधान है f(27)=[0,9]। ब्रेकिंग परिवर्तनों को वापस करने के बाद, हम 83 बाइट्स के नीचे हैं।

— कार्डबोर्ड_बॉक्स

1

मुझे लगता है कि आप b-~aइसके बजाय का उपयोग करके एक और बाइट बचा सकते हैं a+b+1।

— नील

1

आपके दूसरे मामले में एक छोटी सी त्रुटि है: a2 >= a1 + b1कब सही नहीं है k1-k0=1। इसके बजाय आप उपयोग कर सकते हैं a2 >= b1 > a0और b2 >= a1+b1 = a0+b0, और फिर बाकी का अनुसरण करता है।

— अर्जन जोहान्सन

8

हास्केल , 76 72 74 बाइट्स

संपादित करें:

-4 बाइट्स: @ H.PWiz ने /इसके बजाय का उपयोग करने का सुझाव दिया div, हालांकि इसके लिए एक भिन्नात्मक संख्या प्रकार का उपयोग करना आवश्यक है।
+2 बाइट्स: Enumजोड़कर श्रेणियों के साथ एक बग फिक्स्ड -1।

fमान Doubleया Rationalप्रकार लेता है और उसी का एक टपल लौटाता है। Doubleसभी मानों के लिए पर्याप्त होना चाहिए जो राउंडिंग त्रुटियों का कारण बनने के लिए पर्याप्त नहीं है, जबकि Rationalसैद्धांतिक रूप से असीमित है।

f n|let a?b=b==n||b<n&&b?(a+b)=[(a,s-a)|s<-[1..],a<-[0..s/2-1],a?(s-a)]!!0

इसे ऑनलाइन आज़माएं! ( Rationalपूर्णांक प्रारूप में इनपुट / आउटपुट s के लिए H.PWiz के हेडर समायोजन के साथ )

यह काम किस प्रकार करता है

?के दायरे में स्थानीय रूप से नेस्टेड ऑपरेटर है f। a?bफाइबोनैचि-जैसे अनुक्रम के साथ पुनरावर्ती चरण a,bतब तक शुरू होते हैं b>=n, जब तक कि Trueयह nठीक से हिट न हो ।
सूची की समझ में:
- s1ऊपर की ओर से सभी संख्याओं के माध्यम से पुनरावृत्ति करता है, के योग का प्रतिनिधित्व करता है aऔर b।
- aसे नंबर के माध्यम से iterates 0लिए s/2-1। (यदि sरेंज राउंड की समाप्ति विषम है तो)
- a?(s-a)अनुक्रम के साथ शुरू करता है, तो परीक्षण a,s-aहिट n। यदि हां, तो सूची समझ में टपल शामिल है (a,s-a)। (यह है, b=s-aहालांकि, नामकरण के लायक होना बहुत कम था।)
- !!0 समझ में पहला तत्व (हिट) चुनता है।

— अर्जन जोहान्सन
स्रोत

8

APL (Dyalog) , 75 71 64 59 53 48 44 43 बाइट्स

2 बाइट्स @ Adám की बदौलत बच गए

12 बाइट्स ने @ngn को धन्यवाद बचाया

⊃o/⍨k∊¨+\∘⌽⍣{k≤⊃⍺}¨o←a/⍨</¨a←,⍉|-\¨⍳2⍴1+k←⎕

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

उपयोग करता है ⎕IO←0।

कैसे? यह असली पागल हो गया था।

k←⎕ - इनपुट सौंपें k

⍳2⍴1+k←⎕- सीमा से कार्तीय उत्पाद 0के लिए kखुद के साथ

|-\¨ - प्रत्येक दाएं जोड़ी तत्व को बाईं ओर से प्रतिस्थापित करें, और पूर्ण मान प्राप्त करें

a←,⍉ - स्थानांतरित करें, समतल करें और असाइन करें a

o←a/⍨</¨a - केवल ऐसे जोड़े रखें जहां बाएं तत्व दाएं से छोटा है, और असाइन करें o

oअब सभी जोड़ों की सूची है a < b, जो उनके अर्थमेटिक माध्य द्वारा क्रमबद्ध हैं

+\∘⌽⍣{k≤⊃⍺}¨o- प्रत्येक जोड़ी के लिए o, जब तक kया उच्च पद तक नहीं पहुंच जाता है, तब तक रिट्रेसमेंट (जोड़ी और कम्सम को उल्टा) लागू करें

k∊¨- फिर तय करें कि kक्या यह अंतिम शब्द है (इसका अर्थ अनुक्रम में निहित है)

o/⍨- और oपिछले चेक को लागू करने के लिए जोड़े रखें

⊃ - पहला परिणाम लौटाएं।

— Uriel
स्रोत

5

पायथन 2 , 127 109 107 बाइट्स

-2 बाइट्स ओव्स के लिए धन्यवाद (बदलते andहुए *)

g=lambda x,a,b:a<=b<x and g(x,b,a+b)or b==x
f=lambda n,s=1,a=0:g(n,a,s-a)*(a,s-a)or f(n,s+(a==s),a%s+(a<s))

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

के लिए कोई बोनस अंक n,a,s-a?

स्पष्टीकरण:

पहली पंक्ति एक पुनरावर्ती लैम्ब्डा की घोषणा करती है g, जो सत्यापित करता है कि क्या a, bफाइबोनैचि अनुक्रम के रूप में विस्तारित किया जाएगा x। यह भी जाँचता है कि a <= b, प्रश्न के मापदंड में से एक। (यह उन मामलों की अनुमति देता है जहां a == b, लेकिन इस तरह के मामले 0, aमें पहले ही खोजा जा चुका है और वापस आ जाएगा)।
- जंजीर असमानता a<=b<xएक ही बार में दो काम करती है: सत्यापन a <= b, और वह b < x।
- यदि b < xपैदावार होती है True, तो फ़ंक्शन फ़ाइबोनैचि अनुक्रम में अगले दो नंबरों के साथ फिर से कॉल करता है b, a+b:। इसका मतलब यह है कि फ़ंक्शन नए शब्दों को तब तक काम करता रहेगा जब तक ...
- यदि b < xपैदावार होती है False, तो हम उस बिंदु पर पहुंच गए हैं जहां हमें जांच करने की आवश्यकता है b==x। यदि हां, तो यह Trueसंकेत देगा कि प्रारंभिक जोड़ी a, bअंततः पहुंच जाएगी x। अन्यथा, यदि b > x, जोड़ी अमान्य है।
दूसरी पंक्ति एक और पुनरावर्ती लैम्ब्डा घोषित करती है f, जो किसी दिए गए मूल्य के लिए समाधान ढूंढती है n। यह पुनरावर्ती रूप a, bसे g(n, a, b)पैदावार तक , नए प्रारंभिक जोड़े की कोशिश करता है True। यह समाधान तब वापस आ जाता है।
- फ़ंक्शन पुनरावर्ती रूप से दो चर का उपयोग करके प्रारंभिक फाइबोनैचि जोड़े को गिनता है, s(शुरुआत में 1) और a(शुरुआत में 0)। प्रत्येक पुनरावृत्ति पर, aबढ़ा हुआ है, और a, s-aपहली जोड़ी के रूप में उपयोग किया जाता है। हालांकि, जब aहिट होता है s, तो इसे 0 पर रीसेट किया जाता है, और sबढ़ा दिया जाता है। इसका मतलब है कि जोड़े निम्न पैटर्न में गिने जाते हैं:
```
s = 1 (0, 1) (1, 0)
s = 2 (0, 2) (1, 1) (2, 0)
s = 3 (0, 3) (1, 2), (2, 1), (3, 0)
```
  जाहिर है, इसमें कुछ अमान्य जोड़े शामिल हैं, हालांकि इन्हें पास होने पर तुरंत हटा दिया जाता है g(पहली बुलेट बिंदु देखें)।
- जब मान aऔर sऐसे पाए जाते हैं g(n, a, s-a) == True, तो यह मान वापस आ जाता है। जैसा कि संभव समाधान 'आकार' (क्रम से क्रमबद्ध, फिर न्यूनतम मूल्य) के क्रम में गिना जाता है, पहला समाधान हमेशा चुनौती के अनुरोध के रूप में सबसे छोटा होगा।

— FlipTack
स्रोत

3

आर , 183 बाइट्स 160 बाइट्स

n=scan();e=expand.grid(n:0,n:0);e=e[e[,2]>e[,1],];r=e[mapply(h<-function(n,a,b,r=a+b)switch(sign(n-r)+2,F,T,h(n,b,r)),n,e[,1],e[,2]),];r[which.min(rowSums(r)),]

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

23 बाइट बंद करने के लिए Giuseppe को धन्यवाद

कोड स्पष्टीकरण

n=scan()                        #STDIO input
e=expand.grid(n:0,n:0)          #full outer join of integer vector n to 0
e=e[e[,2]>e[,1],]               #filter so b > a
r=e[mapply(
  h<-function(n,a,b,r=a+b)switch(sign(n-r)+2,F,T,h(n,b,r)),
                                #create a named recursive function mid-call 
                                #(requires using <- vs = to denote local variable creation 
                                #rather than argument assignment
  n,e[,1],e[,2]),]              #map n, a and b to h() which returns a logical
                                #which is used to filter the possibilities
r[which.min(rowSums(r)),]       #calculate sum for each possibility, 
                                #get index of the minimum and return
                                #because each possibility has 2 values, the mean and 
                                #sum will sort identically.

— निशान
स्रोत

1

160 बाइट्स - सामान्य तौर पर, आपको जहाँ भी हो सके बाइट्स को बचाना चाहिए, इसलिए अच्छा नामकरण हटाकर 4 बाइट्स को सहेजना न केवल स्वीकार्य या प्रोत्साहित है बल्कि कुछ अर्थों में कोड-गोल्फ द्वारा आवश्यक है । फिर भी, अच्छा जवाब, +1।

— Giuseppe

1

मैथेमेटिका, 117 बाइट्स

If[#==1,{0,1},#&@@SortBy[(S=Select)[S[Range[0,s=#]~Tuples~2,Less@@#&],!FreeQ[LinearRecurrence[{1,1},#,s],s]&],Mean]]&

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

— J42161217
स्रोत

1

जेली , 19 बाइट्स

ṫ-Sṭµ¡³e
0rŒcÇÐfSÐṂ

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

कार्डबोर्ड_बॉक्स द्वारा प्रमाण के लिए -1 बाइट । यदि यह अस्वीकृत है, तो आप कुल 22 बाइट्स के लिए दूसरी पंक्ति के अंत में संलग्न कर सकते हैं ।UṂṚ

— आउटगोल्फर को एरिक करें
स्रोत

... एक प्रमुख वेतन वृद्धि @ StewieGriffin के अवलोकन को हल करना चाहिए।

— जोनाथन एलन

मुझे लग रहा है कि आपḢ

— जोनाथन एलन

1

हमें केवल उस बीज को खोजने की आवश्यकता है जो इनपुट बनाता है x, नवीनतम दिखाई देता है। यदि कई के लिए तीसरे सूचकांक x में पाया गया था तो यह काम करता है 0,xऔर इसलिए या तो 1,(x-1)/2( xविषम) या 2,x/2-1( xयहां तक कि) पर काम xकरेगा जहां बाद में परिणाम में दिखाई देगा, ताकि अभ्यस्त न हो। बाद की टक्कर के लिए माध्य केवल वही हो सकता है यदि तीसरा शब्द भी समान हो, लेकिन फिर प्रारंभिक शर्तों के बीच कम अंतर होना चाहिए (अन्यथा वे समान होंगे) और इसलिए xबाद के सूचकांक में पाया जाएगा । जैसे कि हम ṫ-Sṭµ¡i³¶ḶŒcÇÐṀचार बाइट बचा सकते हैं ।

— जोनाथन एलन

... उफ़, और वेतन वृद्धि:ṫ-Sṭµ¡i³¶‘ḶŒcÇÐṀ

— जोनाथन एलन

@StewieGriffin जब मैंने उत्तर दिया तो यह परीक्षण-केस अस्तित्व में नहीं था: पी

— एरिक आउटलेफ़र

1

GolfScript - 88 77 बाइट्स

~:N[,{1+:a,{[.;a]}/}/][{[.~{.N<}{.@+}while\;N=]}/]{)1=\;},{(\;~+}$(\;);~~' '\

मैंने कई समाधानों के लिए जांच नहीं की, कार्डबोर्ड_बॉक्स के लिए धन्यवाद!

व्याख्या

~:N                           # Reads input
[,{1+:a,{[.;a]}/}/]           # Creates an array of pairs [a b]
[{[.~{.N<}{.@+}while\;N=]}/]  # Compute solutions
{)1=\;},         # Pairs that are not solutions are discarded
{(\;~+}$         # Sorts by mean
(\;);~~' '\      # Formats output

— FedeWar
स्रोत

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

— अर्जन जोहान्सन

0

बैच, 160 158 बाइट्स

@set/aa=b=0
:g
@if %a% geq %b% set/ab-=~a,a=0
@set/ac=a,d=b
:l
@if %c% lss %1 set/ad+=c,c=d-c&goto l
@if %c% gtr %1 set/aa+=1,b-=1&goto g
@echo %a% %b%

— नील
स्रोत

यह (भी) 3 7इनपुट पर देता है 27। सही समाधान है 0 9।

— कार्डबोर्ड_बॉक्स

@cardboard_box अभी भी यह नहीं देख रहा है कि प्रश्न की आवश्यकता कहाँ है ...

— नील

पहले वाक्य में: "सबसे कम संभव औसत मूल्य के साथ"।

— कार्डबोर्ड_बॉक्स

@cardboard_box आह, क्षमा करें, यह अनदेखी करना बहुत आसान था।

— नील

1

@cardboard_box अब ठीक होना चाहिए।

— नील

फाइबोनैचि-जैसे अनुक्रम में सबसे कम प्रारंभिक संख्या

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

हस्क , 19 18 16 14 13 15 बाइट्स

स्पष्टीकरण:

जावास्क्रिप्ट (Node.js) , 92 90 89 91 83 82 बाइट्स

सबूत है कि वहाँ कभी नहीं कई समाधान हैं:

लेम्मा 1

लेम्मा २

प्रमाण

हास्केल , 76 72 74 बाइट्स

यह काम किस प्रकार करता है

APL (Dyalog) , 75 71 64 59 53 48 44 43 बाइट्स

पायथन 2 , 127 109 107 बाइट्स

स्पष्टीकरण:

आर , 183 बाइट्स 160 बाइट्स

मैथेमेटिका, 117 बाइट्स

जेली , 19 बाइट्स

GolfScript - 88 77 बाइट्स

व्याख्या

बैच, 160 158 बाइट्स