30

हम सभी प्रसिद्ध फाइबोनैचि अनुक्रम से परिचित हैं , जो शुरू होता है 0और 1, और प्रत्येक तत्व पिछले दो का योग है। यहां पहले कुछ शब्द (OEIS A000045 ) हैं:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584

दिया गया सकारात्मक पूर्णांक , इन नियमों के तहत, फाइबोनैचि अनुक्रम की निकटतम संख्या लौटाएं:

निकटतम फिबोनैकी संख्या को देखते हुए पूर्णांक के साथ छोटी से छोटी पूर्ण अंतर के साथ फाइबोनैचि संख्या के रूप में परिभाषित किया गया है। उदाहरण के लिए, 34निकटतम फाइबोनैचि संख्या है 30, क्योंकि |34 - 30| = 4, जो दूसरे निकटतम की तुलना में छोटी है 21, जिसके लिए |21 - 30| = 9।
यदि दिया गया पूर्णांक फाइबोनैचि अनुक्रम का है, तो निकटतम फाइबोनैचि संख्या स्वयं ही है। उदाहरण के लिए, निकटतम फाइबोनैचि संख्या 13बिल्कुल है 13।
एक टाई के मामले में, आप दोनों में से किसी एक में फाइबोनैचि संख्याओं को आउटपुट करने के लिए चुन सकते हैं जो इनपुट के सबसे करीब हैं या केवल उन दोनों को आउटपुट करते हैं। उदाहरण के लिए, यदि इनपुट है 17, निम्न में से सभी मान्य हैं: 21, 13या21, 13 । यदि आप उन दोनों को वापस करते हैं, तो कृपया प्रारूप का उल्लेख करें।

डिफ़ॉल्ट ढीले लागू होते हैं। आप इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं । आपके प्रोग्राम / फ़ंक्शन को केवल 10 ⁸ तक के मानों को संभालना होगा ।

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

इनपुट -> आउटपुट

1 -> 1
3 -> 3
4 -> 3 या 5 या 3, 5
6 -> 5
7 -> 8
11 -> 13
17 -> 13 या 21 या 13, 21
63 -> 55
101 -> 89
377 -> 377
467 -> 377
500 -> 610
1399 -> 1597

स्कोरिंग

यह कोड-गोल्फ है , इसलिए हर भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf number fibonacci

— श्री Xcoder
स्रोत

सैंडबॉक्स ।

— श्री एक्सकोडर

Fwiw, यहाँ बड़े आदानों के लिए कुशलता से यह कर, एक स्क्रिप्ट है कि विभिन्न एल्गोरिदम समय के लिए इस्तेमाल किया जा सकता के साथ साथ के लिए इतने पर कुछ अजगर कोड है।

— शाम 2:56 बजे PM 2Ring

क्या 0 को एक पूर्णांक माना जाता है?

— एलिक्स ईसेनहार्ट

@AlixEisenhardt सं। सकारात्मक पूर्णांकn का तात्पर्य है n ≥ 1।

— श्री Xcoder

21

पायथन 2 , 43 बाइट्स

f=lambda n,a=0,b=1:a*(2*n<a+b)or f(n,b,a+b)

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

लगातार फाइबोनैचि संख्याओं के जोड़े के माध्यम से इरेट (a,b)करता है जब तक कि यह एक तक नहीं पहुंचता है जहां इनपुट nउनके मध्य बिंदु से कम है (a+b)/2, फिर लौटता है a।

एक कार्यक्रम के रूप में लिखा (47 बाइट्स):

n=input()
a=b=1
while 2*n>a+b:a,b=b,a+b
print a

एक ही लंबाई :

f=lambda n,a=0,b=1:b/2/n*(b-a)or f(n,b,a+b)

— XNOR
स्रोत

15

नीम , 5 बाइट्स

f𝐖𝕖S𝕔

स्पष्टीकरण:

f       Push infinite Fibonacci list
 𝐖                     93
  𝕖     Select the first ^ elements
        This is the maximum amount of elements we can get before the values overflow
        which means the largest value we support is 7,540,113,804,746,346,429
   S𝕔   Closest value to the input in the list

नीम के नवीनतम संस्करण में, इसे 3 बाइट्स में रखा जा सकता है:

fS𝕔

चूंकि अनंत सूचियों को केवल उनके अधिकतम मूल्य तक जाने के लिए फिर से काम किया गया है।

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

— Okx
स्रोत

जब यह 2 वर्ण हैं तो यह 5 बाइट्स कैसे हैं? और पहले और दूसरे समाधान के बीच क्या अंतर है?

— caird coinheringaahing

1

क्या आप बाइट्स या वर्णों की गिनती कर रहे हैं? ऐसा लगता है कि पहला 15 बाइट्स है, और दूसरा 7 बाइट्स।

— नटोमामी

यह शायद किसी प्रकार का अपना कोडपेज है जिसमें प्रत्येक वर्ण स्वयं बाइट है जिसका अर्थ है कि पहला 5 बाइट्स है और दूसरा 3 बाइट्स है। दोनों के बीच का अंतर यह है कि पहला 93 तत्वों के मैनुअल का चयन करता है जबकि एक नए संस्करण में दूसरा स्निपेट स्वचालित रूप से उच्चतम संभव मान का चयन करता है जो कि भाषाओं का अंतर आकार संभाल सकता है

— रोमन ग्रैफ

1

@cairdcoinheringaahing मैं अक्सर लोगों के साथ मेरे कार्यक्रम नहीं देख पा रहा हूं। स्क्रीनशॉट

— Okx

1

@ ओके ओके, दिलचस्प है, मैंने अनुमान नहीं लगाया होगा।

— नटोमामी

10

पायथन , 55 52 बाइट्स

f=lambda x,a=1,b=1:[a,b][b-x<x-a]*(b>x)or f(x,b,a+b)

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

— OVS
स्रोत

8

आर , 70 67 64 62 60 बाइट्स

-2 बाइट्स धन्यवाद djhurio के लिए!

Djhurio के लिए -2 और बाइट्स धन्यवाद (लड़का वह गोल्फ कर सकता है!)

F=1:0;while(F<1e8)F=c(F[1]+F[2],F);F[order((F-scan())^2)][1]

चूंकि हमें केवल मूल्यों को संभालना है 10^8, इसलिए यह काम करता है।

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

स्टड nसे पढ़ता है। whileपाश में फिबोनैकी संख्या उत्पन्न करता है F(घटते क्रम में); एक टाई होने की स्थिति में, बड़ा लौटा दिया जाता है। यह कई चेतावनियों को ट्रिगर करेगा क्योंकि while(F<1e8)केवल पहले तत्व के लिए स्टेटमेंट का मूल्यांकन करता हैF साथ

मूल रूप से मैंने उपयोग किया F[which.min(abs(F-n))], भोली दृष्टिकोण, लेकिन @djhurio ने सुझाव दिया (F-n)^2कि ऑर्डर करना समकक्ष होगा, और orderइसके बजाय which.min। orderहालांकि, इसके इनपुट को बढ़ते क्रम में रखने के लिए सूचकांकों का एक क्रमांकन लौटाता है, इसलिए हमें [1]केवल पहले मूल्य प्राप्त करने के लिए अंत में आवश्यकता है ।

तेज़ संस्करण:

F=1:0;n=scan();while(n>F)F=c(sum(F),F[1]);F[order((F-n)^2)][‌1]

केवल अंतिम दो रिट्रेसमेंट नंबर संग्रहीत करता है

— ग्यूसेप
स्रोत

1

अच्छा है। -2 बाइट्सF=1:0;n=scan();while(n>F)F=c(F[1]+F[2],F);F[order((F-n)^2)][1]

— djhurio

1

और फास्ट संस्करण बाइट्स की समान संख्या के साथF=1:0;n=scan();while(n>F)F=c(sum(F),F[1]);F[order((F-n)^2)][1]

— djhurio

1

@djhurio अच्छा! आपका बहुत बहुत धन्यवाद।

— ग्यूसेप

1

यह मुझे पंसद है। -2 बाइट्स फिर सेF=1:0;while(F<1e8)F=c(F[1]+F[2],F);F[order((F-scan())^2)][1]

— djhurio

फाइब्रन उत्पन्न करने के लिए एक बेसिन का उपयोग कम होता है:numbers::fibonacci(x<-scan(),T)

— JAD

6

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

f=(n,x=0,y=1)=>y<n?f(n,y,x+y):y-n>n-x?x:y

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

स्निपेट का विस्तार करें

वरीयता द्वारा सीमाएँ।

— नील
स्रोत

लगभग उस संस्करण के समान, जिस पर मैं काम कर रहा था। कम से कम आप एक ही चर नाम का उपयोग नहीं करते थे या मुझे बाहर निकाल दिया जाता था।

— ग्रैक्स 32

@ ग्रेक्स हू, अब आप इसका उल्लेख करते हैं, बिजनेस कैट ने मुझे इसे हराया ...

— नील

(खैर, लगभग ... मैंने अपना संस्करण 0 के साथ काम किया, क्योंकि क्यों नहीं?)

— नील

f=(n,x=0,y=1)=>x*(2*n<x+y)||f(n,y,x+y) चूँकि आपको 0 से काम नहीं करना है, आप थोड़ा और गोल्फ कर सकते हैं।

— एलिक्स आइजनहार्ट

6

Jelly, 9 7 bytes

-2 bytes thanks to @EriktheOutgolfer

‘RÆḞạÐṂ

Try it online!

Golfing tips welcome :). Takes an int for input and returns an int-list.

            ' input -> 4
‘           ' increment -> 5
 R          ' range -> [1,2,3,4,5]
  ÆḞ        ' fibonacci (vectorizes) -> [1,1,2,3,5,8]
     ÐṂ     ' filter and keep the minimum by:
    ạ       ' absolute difference -> [3,3,2,1,1,4]
            ' after filter -> [3,5]

— nmjcman101
स्रोत

You can remove µḢ.

— Erik the Outgolfer

@EriktheOutgolfer as in: "There is a way to do it if you think about it", or as in "If you literally just backspace them it still works"?

— nmjcman101

As in "it's allowed by the rules". :P

— Erik the Outgolfer

Ah. Thank you! (Filler text)

— nmjcman101

5

Mathematica, 30 bytes

Array[Fibonacci,2#]~Nearest~#&

Try it online!

— J42161217
स्रोत

5

x86-64 Machine Code, 24 bytes

31 C0 8D 50 01 92 01 C2 39 FA 7E F9 89 D1 29 FA 29 C7 39 D7 0F 4F C1 C3

The above bytes of code define a function in 64-bit x86 machine code that finds the closest Fibonacci number to the specified input value, n.

The function follows the System V AMD64 calling convention (standard on Gnu/Unix systems), such that the sole parameter (n) is passed in the EDI register, and the result is returned in the EAX register.

Ungolfed assembly mnemonics:

; unsigned int ClosestFibonacci(unsigned int n);
    xor    eax, eax        ; initialize EAX to 0
    lea    edx, [rax+1]    ; initialize EDX to 1

  CalcFib:
    xchg   eax, edx        ; swap EAX and EDX
    add    edx, eax        ; EDX += EAX
    cmp    edx, edi
    jle    CalcFib         ; keep looping until we find a Fibonacci number > n

    mov    ecx, edx        ; temporary copy of EDX, because we 'bout to clobber it
    sub    edx, edi
    sub    edi, eax
    cmp    edi, edx
    cmovg  eax, ecx        ; EAX = (n-EAX > EDX-n) ? EDX : EAX
    ret

Try it online!

The code basically divides up into three parts:

The first part is very simple: it just initializes our working registers. EAX is set to 0, and EDX is set to 1.
अगले भाग, एक पाश कि iteratively इनपुट मूल्य के दोनों तरफ फिबोनैकी संख्या की गणना करता है n। यह कोड घटाव के साथ फाइबोनैचि के मेरे पिछले कार्यान्वयन पर आधारित है , लेकिन ... um ... घटाव के साथ नहीं है। :-) विशेष रूप से, यह दो चरों का उपयोग करते हुए फाइबोनैचि संख्या की गणना करने की एक ही चाल का उपयोग करता है - यहाँ, ये EAXऔर EDXरजिस्टर हैं। यह दृष्टिकोण यहाँ अत्यंत सुविधाजनक है, क्योंकि यह हमें आसन्न फाइबोनैचि संख्या देता है। संभावित रूप से कम उम्मीदवार nमें आयोजित किया जाता है EAX, जबकि संभावित रूप से उम्मीदवार की तुलनाn में अधिक आयोजित किया जाता हैEDX। मुझे इस बात पर काफी गर्व है कि मैं इस लूप के अंदर कोड को बनाने में कितना सक्षम था (और इससे भी अधिक गुदगुदी हुई कि मैंने इसे स्वतंत्र रूप से खोजा, और बाद में एहसास हुआ कि यह उपर्युक्त उत्तर से जुड़ा हुआ था) के समान कैसे था।
एक बार जब हम उम्मीदवार है फाइबोनैचि में उपलब्ध महत्व देता है EAXऔर EDX, यह पता लगाना है जो एक के करीब (निरपेक्ष मूल्य के संदर्भ में) है की एक धारणात्मक सरल बात है n। वास्तव में एक निरपेक्ष मूल्य लेने से बहुत अधिक बाइट्स का खर्च होता है , इसलिए हम बस घटाव की एक श्रृंखला करते हैं। दंडात्मक सशर्त-चाल अनुदेश के दाईं ओर टिप्पणी उपयुक्त रूप से यहाँ तर्क की व्याख्या करती है। यह या तो अंदर चला जाता EDXहै EAX, या EAXअकेला छोड़ देता है, ताकि जब कार्य पूरा हो जाए, तो RETनिकटतम फाइबोनैचि संख्या वापस आ जाए EAX।

In the case of a tie, the smaller of the two candidate values is returned, since we've used CMOVG instead of CMOVGE to do the selection. It is a trivial change, if you'd prefer the other behavior. Returning both values is a non-starter, though; only one integer result, please!

— Cody Gray
स्रोत

NASM listings are nice for codegolf answers, since they mix the machine code bytes with the original commented source somewhat compactly. I used nasm foo.asm -l /dev/stdout | cut -b -28,$((28+12))- to trim some columns between the machine code and source in a recent answer.

— Peter Cordes

1

In 32-bit code, you can get eax=0 and edx=1 in only 4 bytes instead of 5, with xor eax,eax / cdq / inc edx. So you could make a 32-bit custom-calling-convention version that saved a byte.

— Peter Cordes

मैं उस @Peter को करता था, लेकिन यहाँ "विधानसभा" या "मशीन कोड" में प्रस्तुतियाँ होने को लेकर बहुत भ्रम है। जाहिरा तौर पर कुछ अनुभवी उपयोगकर्ता इस बात को बनाए रखते हैं कि असेंबली mnemonics का उपयोग करके प्रस्तुत किए गए उत्तर के लिए मशीन कोड के बाइट्स को गिनने के लिए मेरे मन में कोई अंतर है और आपत्ति है। स्वाभाविक रूप से, मुझे लगता है कि यह बेवकूफी है, क्योंकि "असेंबली" मशीन बाइट्स का एक मात्र प्रतिनिधित्व है, लेकिन मैं इससे बाहर निकल गया। मैंने पाया है कि अलग प्रस्तुति कम घर्षण पैदा करती है, भले ही मैं व्यक्तिगत रूप से इसे पसंद नहीं करता हूं।

— कॉडी ग्रे

दूसरी चाल अच्छी है- धन्यवाद। मुझे इसके बारे में सोचना चाहिए था, मैं cdqकोड-गोल्फ उत्तरों में बहुत उपयोग करता हूं । एक कस्टम कॉलिंग कन्वेंशन की आवश्यकता नहीं है। मैं आमतौर पर __fastcall32-बिट कोड के लिए Microsoft कॉलिंग कन्वेंशन का उपयोग करता हूं । इसके बारे में अच्छी बात यह है कि यह एक एनोटेशन के साथ जीसीसी द्वारा समर्थित है, इसलिए आप अभी भी टीआईओ सेवा का उपयोग कर सकते हैं जिसे हर कोई देखना चाहता है।

— कोड़ी ग्रे

Ah yes, any old register calling convention works for you . My most recent codegolf answer needed pointers in edi/esi for lodsb/stosb, and only x86-64 SysV does that (fun fact: on purpose for that reason, because some functions pass on their args to memset / memcpy, and I guess gcc at the time liked to inline string ops).

— Peter Cordes

4

PowerShell, 80 74 bytes

param($n)for($a,$b=1,0;$a-lt$n;$a,$b=$b,($a+$b)){}($b,$a)[($b-$n-gt$n-$a)]

(Try it online! temporarily unresponsive)

Iterative समाधान। इनपुट लेता है $n, सेट $a,$bकरता है 1,0, और फिर $aइनपुट से बड़ा होने तक फाइबोनैचि के साथ लूप करता है। उस समय, हम सूचकांक पर में ($b,$a)है कि क्या पहले तत्व के बीच का अंतर और की बूलियन के आधार पर $nके बीच से अधिक होता है $nऔर दूसरा तत्व। यह पाइपलाइन पर छोड़ दिया गया है, आउटपुट निहित है।

— AdmBorkBork
स्रोत

4

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

f=(n,k,y)=>(g=k=>x=k>1?g(--k)+g(--k):k)(k)>n?x+y>2*n?y:x:f(n,-~k,x)

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

कोड स्निपेट दिखाएं

f=(n,k,y)=>(g=k=>x=k>1?g(--k)+g(--k):k)(k)>n?x+y>2*n?y:x:f(n,-~k,x)

console.log(f(1   )) // -> 1
console.log(f(3   )) // -> 3
console.log(f(4   )) // -> 3 or 5 or 3, 5
console.log(f(6   )) // -> 5
console.log(f(7   )) // -> 8
console.log(f(11  )) // -> 13
console.log(f(17  )) // -> 13 or 21 or 13, 21
console.log(f(63  )) // -> 55
console.log(f(101 )) // -> 89
console.log(f(377 )) // -> 377
console.log(f(467 )) // -> 377
console.log(f(500 )) // -> 610
console.log(f(1399)) // -> 1597

स्निपेट का विस्तार करें

— Arnauld
स्रोत

4

जावास्क्रिप्ट (बैबेल नोड) , 41 बाइट्स

f=(n,i=1,j=1)=>j<n?f(n,j,j+i):j-n>n-i?i:j

ओव्स के भयानक पायथन जवाब के आधार पर

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

Ungolfed

f=(n,i=1,j=1)=> // Function f: n is the input, i and j are the most recent two Fibonacci numbers, initially 1, 1
 j<n?           // If j is still less than n
  f(n,j,j+i)    //  Try again with the next two Fibonacci numbers
 :              // Else:
  j-n>n-i?i:j   //  If n is closer to i, return i, else return j

— बिजनेस कैट
स्रोत

मेरे जवाब पर यह टिप्पणी की गई थी, लेकिन यह इसके लिए काम करना बंद कर देगा 0(ऐसा नहीं है कि मुझे इसकी आवश्यकता है; मुझे बस यह चाहिए):f=(n,i=1,j=1)=>n+n<i+j?i:f(n,j,j+i)

— नील

4

पायथन, 74 बाइट्स

import math
r=5**.5
p=r/2+.5
lambda n:round(p**int(math.log(n*2*r,p)-1)/r)

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

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

सभी के लिए कश्मीर ≥ 0, के बाद से | φ ^{- कश्मीर} / √5 | <1/2, एफ _{कश्मीर} = φ ^{कश्मीर} / √5 + φ ^{- कश्मीर} / √5 = दौर (φ ^{कश्मीर} / √5)। तो वापसी मान से स्विच एफ _{कश्मीर - 1} के लिए एफ _{कश्मीर} कहां कश्मीर = लोग इन _φ ( एन ⋅2√5) - 1, या n = φ ^{कश्मीर + 1} / (2√5), जिनमें से 1/4 के भीतर है एफ _{के + 1/2} = ( एफ _{के - 1} + एफ _के ) / 2।

— Anders Kaseorg
स्रोत

Damn, I knew something like this had to be possible. Well done! (+1)

— SteamyRoot

3

05AB1E, 6 bytes

nÅFs.x

Try it online!

— Okx
स्रोत

3

C (gcc), 86 85 83 76 bytes

f(n){n=n<2?:f(n-1)+f(n-2);}i,j,k;g(n){for(;k<n;j=k,k=f(i++));n=k-n<n-j?k:j;}

Try it online!

— cleblanc
स्रोत

3

जावा (ओपनजेडके 8) , 60 57 56 bytes

c->{int s=1,r=2;for(;c>r;s=r-s)r+=s;return c-s>r-c?r:s;}

Try it online!

-1 बाइट @ @ नील को धन्यवाद

— Nevay
स्रोत

3

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

import math
def f(n):d=5**.5;p=.5+d/2;l=p**int(math.log(d*n,p))/d;L=[l,p*l];return round(L[2*n>sum(L)])

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

अफसोस की बात यह है कि लंबोदर की जगह एक डीप का इस्तेमाल करना पड़ा ... यहां सुधार के लिए शायद बहुत जगह है।

मूल (गलत) उत्तर:

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

lambda n:r(p**r(math.log(d*n,p))/d)
import math
d=5**.5
p=.5+d/2
r=round

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

मेरा पहला PPCG सबमिशन। या तो फाइबोनैचि संख्याओं की गणना करने या उन्हें पूर्वनिर्धारित रखने के बजाय, यह कोड उपयोग करता है कि कैसे n-th फाइबोनैचि संख्या 5 के मूल द्वारा विभाजित स्वर्ण अनुपात की n-वें शक्ति के लिए निकटतम पूर्णांक है।

— SteamyRoot
स्रोत

अच्छी नौकरी! PPCG में आपका स्वागत है :)

— musicman523

अपने कोड की बाइट गणना की गणना करने के लिए मुझे लगता है कि आपको लैम्ब्डा को असाइन करने की आवश्यकता है, जैसा कि अन्य पायथन उत्तरों में दिखाया गया है। हालाँकि, यह एल्गोरिथ्म हमेशा n (1, 1 + 10 ** 8) के n के लिए सही ढंग से काम नहीं करता है। जैसे, n = 70 रिटर्न 89, लेकिन इसे 55 वापस करना चाहिए। यहाँ n मान <120 हैं जो इसके लिए गलत उत्तर देता है: (27, 44, 70, 71, 114, 115, 116)। परीक्षण प्रयोजनों के लिए, आप nearest_fib_PM2Rप्रश्न पर मेरी टिप्पणी में जुड़े फ़ंक्शन का उपयोग करना पसंद कर सकते हैं ।

— PM 2Ring

@ PM2Ring तुम सही हो, मैंने एक बेवकूफ गलती की ... मेरे पास अब एक सही समाधान है, लेकिन बहुत अधिक बाइट्स के साथ। मेमने के लिए, मेरा मानना है कि आप गलत हैं। मेरा मानना है कि लैम्ब्डा असाइन करने वाले उत्तर केवल इसलिए करते हैं क्योंकि वे पुनरावृत्ति का उपयोग करते हैं। अन्य पायथन 3 के उत्तर उदाहरण के लिए, पहले लैम्ब्डा को निर्दिष्ट नहीं करते हैं।

— स्टीमीयूट

3

टैक्सी, 2321 बाइट्स

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Trunkers.Go to Trunkers:n 1 l 1 l.0 is waiting at Starchild Numerology.1 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 2 l.Pickup a passenger going to Bird's Bench.Pickup a passenger going to Cyclone.Go to Cyclone:w 1 r 4 l.[a]Pickup a passenger going to Rob's Rest.Pickup a passenger going to Magic Eight.Go to Bird's Bench:n 1 r 2 r 1 l.Go to Rob's Rest:n.Go to Trunkers:s 1 l 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:w 2 r.Pickup a passenger going to Trunkers.Pickup a passenger going to Magic Eight.Go to Zoom Zoom:n.Go to Trunkers:w 3 l.Go to Magic Eight:e 1 r.Switch to plan "b" if no one is waiting.Pickup a passenger going to Firemouth Grill.Go to Firemouth Grill:w 1 r.Go to Rob's Rest:w 1 l 1 r 1 l 1 r 1 r.Pickup a passenger going to Cyclone.Go to Bird's Bench:s.Pickup a passenger going to Addition Alley.Go to Cyclone:n 1 r 1 l 2 l.Pickup a passenger going to Addition Alley.Pickup a passenger going to Bird's Bench.Go to Addition Alley:n 2 r 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l.Switch to plan "a".[b]Go to Trunkers:w 1 l.Pickup a passenger going to Cyclone.Go to Bird's Bench:w 1 l 1 r 1 l.Pickup a passenger going to Cyclone.Go to Rob's Rest:n.Pickup a passenger going to Cyclone.Go to Cyclone:s 1 l 1 l 2 l.Pickup a passenger going to Sunny Skies Park.Pickup a passenger going to What's The Difference.Pickup a passenger going to What's The Difference.Go to What's The Difference:n 1 l.Pickup a passenger going to Magic Eight.Go to Sunny Skies Park:e 1 r 1 l.Go to Cyclone:n 1 l.Pickup a passenger going to Sunny Skies Park.Pickup a passenger going to What's The Difference.Go to Sunny Skies Park:n 1 r.Pickup a passenger going to What's The Difference.Go to What's The Difference:n 1 r 1 l.Pickup a passenger going to Magic Eight.Go to Magic Eight:e 1 r 2 l 2 r.Switch to plan "c" if no one is waiting.Go to Sunny Skies Park:w 1 l 1 r.Pickup a passenger going to The Babelfishery.Go to Cyclone:n 1 l.Switch to plan "d".[c]Go to Cyclone:w 1 l 2 r.[d]Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 2 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.

इसे ऑनलाइन आज़माएं!
टिप्पणियों के साथ इसे ऑनलाइन आज़माएं!

टिप्पणियों के साथ गैर-गोल्फ:

[ Find the Fibonacci number closest to the input ]
[ Inspired by: https://codegolf.stackexchange.com/q/133365 ]


[ n = STDIN ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Trunkers.
Go to Trunkers: north 1st left 1st left.


[ Initialize with F0=0 and F1=1 ]
0 is waiting at Starchild Numerology.
1 is waiting at Starchild Numerology.
Go to Starchild Numerology: west 1st left 2nd left.
Pickup a passenger going to Bird's Bench.
Pickup a passenger going to Cyclone.
Go to Cyclone: west 1st right 4th left.


[ For (i = 1; n > F(i); i++) { Store F(i) at Rob's Rest and F(i-1) at Bird's Bench } ]
[a]
Pickup a passenger going to Rob's Rest.
Pickup a passenger going to Magic Eight.
Go to Bird's Bench: north 1st right 2nd right 1st left.
Go to Rob's Rest: north.
Go to Trunkers: south 1st left 1st left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: west 2nd right.
Pickup a passenger going to Trunkers.
Pickup a passenger going to Magic Eight.
Go to Zoom Zoom: north.
Go to Trunkers: west 3rd left.
Go to Magic Eight: east 1st right.
Switch to plan "b" if no one is waiting.

[ n >= F(i) so iterate i ]
Pickup a passenger going to Firemouth Grill.
Go to Firemouth Grill: west 1st right.
Go to Rob's Rest: west 1st left 1st right 1st left 1st right 1st right.
Pickup a passenger going to Cyclone.
Go to Bird's Bench: south.
Pickup a passenger going to Addition Alley.
Go to Cyclone: north 1st right 1st left 2nd left.
Pickup a passenger going to Addition Alley.
Pickup a passenger going to Bird's Bench.
Go to Addition Alley: north 2nd right 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left.
Switch to plan "a".


[b]
[ F(i) > n which means n >= F(i-1) and we need to figure out which is closer and print it]
Go to Trunkers: west 1st left.
Pickup a passenger going to Cyclone.
Go to Bird's Bench: west 1st left 1st right 1st left.
Pickup a passenger going to Cyclone.
Go to Rob's Rest: north.
Pickup a passenger going to Cyclone.
Go to Cyclone: south 1st left 1st left 2nd left.
Pickup a passenger going to Sunny Skies Park.
Pickup a passenger going to What's The Difference.
Pickup a passenger going to What's The Difference.
[ Passengers:n, n, F(i-1) ]
Go to What's The Difference: north 1st left.
Pickup a passenger going to Magic Eight.
[ Passengers:n, n-F(i-1) ]
Go to Sunny Skies Park: east 1st right 1st left.
Go to Cyclone: north 1st left.
Pickup a passenger going to Sunny Skies Park.
Pickup a passenger going to What's The Difference.
[ Passengers: n-F(i-1), F(i-1), F(i) ]
Go to Sunny Skies Park: north 1st right.
Pickup a passenger going to What's The Difference.
[ Passengers: n-F(i-1), F(i), n ]
Go to What's The Difference: north 1st right 1st left.
[ Passengers: n-F(i-1), F(i)-n ]
Pickup a passenger going to Magic Eight.
Go to Magic Eight: east 1st right 2nd left 2nd right.
Switch to plan "c" if no one is waiting.

[ If no one was waiting, then {n-F(i-1)} < {F(i)-n} so we return F(i-1) ]
Go to Sunny Skies Park: west 1st left 1st right.
Pickup a passenger going to The Babelfishery.
Go to Cyclone: north 1st left.
Switch to plan "d".

[c]
[ Otherwise {n-F(i-1)} >= {F(i)-n} so we return F(i) ]
[ Note: If we didn't switch to plan c, we still pickup F(i) but F(i-1) will be the *first* passenger and we only pickup one at The Babelfishery ]
[ Note: Because of how Magic Eight works, we will always return F(i) in the event of a tie ]
Go to Cyclone: west 1st left 2nd right.
[d]
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 2nd right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.

— इंजीनियर टोस्ट
स्रोत

2

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

lambda k:min(map(f,range(2*k)),key=lambda n:abs(n-k))
f=lambda i:i<3or f(i-1)+f(i-2)

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

यह काम कर सकता है, लेकिन यह निश्चित रूप से तेज़ नहीं है ...

के Trueबजाय आउटपुट 1, लेकिन पायथन में ये बराबर हैं।

— notjagan
स्रोत

2

डीसी, 52 बाइट्स

si1d[dsf+lfrdli>F]dsFxli-rlir-sdd[lild-pq]sDld<Dli+p

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

~~रन का उपयोग करके इनपुट लेता है ?~~

इनपुट मूल्य, -1 बाइट के रूप में स्टैक के शीर्ष मान लेने के लिए संपादित किया गया।

इनपुट रजिस्टर में संग्रहित है i। फिर हमने फिबोनाची अनुक्रम शुरू करने के लिए स्टैक पर 1 और 1 लगाया, और हम अनुक्रम उत्पन्न करते हैं जब तक कि हम एक मूल्य से अधिक नहीं मारते i। इस बिंदु पर हमारे पास स्टैक पर फाइबोनैचि अनुक्रम में दो नंबर हैं: एक जो कि से कम या इसके बराबर है i, और एक जो इससे अधिक है i। हम इन्हें अपने संबंधित मतभेदों में बदलते हैं iऔर फिर मतभेदों की तुलना करते हैं। अंत में हम अंतर को जोड़कर या घटाकर फिबोनाची संख्या को फिर से जोड़ते हैं i।

उफ़, मैं गलत क्रम में दो रजिस्टर लोड कर रहा था और फिर एक बाइट को बर्बाद करते हुए उन्हें स्वैप कर रहा था।

— brhfl
स्रोत

कार्य करने की अनुमति है।

— कैलक्यूलेटरफ्लीन

धन्यवाद, मैंने बार-बार याद किया कि चुनौती के पाठ में।

— ब्रफल

2

सी # (.NET कोर) , 63 56 बाइट्स

-1 बाइट @ @ नील को धन्यवाद

-6 बाइट्स धन्यवाद @ नवीन

n=>{int a=0,b=1;for(;b<n;a=b-a)b+=a;return n-a>b-n?b:a;}

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

— jkelm
स्रोत

क्या for(;b<n;a=b,b+=c)c=a;बाइट बचती है?

— नील

आप cका उपयोग करके निकाल सकते हैं b+=a,a=b-a(6 बाइट बचा जाना चाहिए)।

— नेवले

2

क्यू / केडीबी +, 51 बाइट्स

{w where l=min l:abs neg[x]+w:{x,sum -2#x}/[x;0 1]}

— aodNap
स्रोत

2

PPCG में आपका स्वागत है!

— मार्टिन एंडर

2

हेक्सागोनी , 37 बाइट्स

?\=-${&"*.2}+".|'=='.@.&}1.!_|._}$_}{

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

ungolfed:

   ? \ = - 
  $ { & " * 
 . 2 } + " .
| ' = = ' . @
 . & } 1 . !
  _ | . _ }
   $ _ } {

टूटा:

start:
? { 2 ' * //set up 2*target number
" ' 1     //initialize curr to 1

main loop:
} = +     //next + curr + last
" -       //test = next - (2*target)
branch: <= 0 -> continue; > 0 -> return

continue:
{ } = &   //last = curr
} = &     //curr = next


return:
{ } ! @   //print last

कुछ अन्य पोस्टरों की तरह, मैंने महसूस किया कि जब अंतिम और वक्र का मध्य बिंदु लक्ष्य से अधिक होता है, तो दोनों में से सबसे छोटा निकटतम या निकटतम के लिए बंधा होता है।

मध्यबिंदु (अंतिम + वक्र) / 2 पर है हम इसे छोटा कर सकते हैं क्योंकि अगला पहले से ही अंतिम + वक्र है, और यदि हम इसके बजाय अपने लक्ष्य पूर्णांक को 2 से गुणा करते हैं, तो हमें केवल (अगला - 2 * लक्ष्य)> 0 की जांच करने की आवश्यकता है, फिर अंतिम पर लौटें।

— Brigmor
स्रोत

2

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

;I≜-.∧{0;1⟨t≡+⟩ⁱhℕ↙.!}

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

वास्तव में मैंने यहां जो कुछ भी किया है वह है Fatalize के क्लासिक को एक साथ चिपकाएं निकटतम प्राइम नंबर समाधान और मेरे खुद के I I एक फाइबोनैचि नंबर? समाधान। सौभाग्य से, बाद वाला पहले से ही आउटपुट चर पर संचालित होता है; दुर्भाग्य से, इसमें एक आवश्यक कटौती भी शामिल है जिसे +2 बाइट्स के लिए अलग किया जाना है, इसलिए एकमात्र विकल्प जो इसे छोड़ देता है ⁱ, वह निष्क्रिय है ≜।

— असंबंधित स्ट्रिंग
स्रोत

2

जाप `-g` , 8 बाइट्स

ò!gM ñaU

कोशिश करो

— झबरा
स्रोत

1

जावा 7, 244 234 बाइट्स

 String c(int c){for(int i=1;;i++){int r=f(i);int s=f(i-1);if(r>c && s<c){if(c-s == r-c)return ""+r+","+s;else if(s-c > r-c)return ""+r;return ""+s;}}} int f(int i){if(i<1)return 0;else if(i==1)return 1;else return f(i-2)+f(i-1);}

— 0x45
स्रोत

आप Java 8 का उपयोग क्यों नहीं करते हैं और इसे लैम्ब्डा में बदलते हैं? staticयदि आप जावा 7.

— ओकेक्स

आपके कोड में दो त्रुटियां हैं ( r>c&&s<cहोनी चाहिए r>=c&&s<=c, s-cहोनी चाहिए c-s), आप आवश्यक व्हाट्सएप को हटा नहीं सकते, उपयोग कर सकते हैं int f(int i){return i<2?i:f(--i)+f(--i);}, c में ternary ऑपरेटर के साथ एक सिंगल रिटर्न स्टेटमेंट का उपयोग कर सकते हैं और विशेष हैंडलिंग को हटा सकते हैं c-s==r-cक्योंकि या तो मान वापस करने की अनुमति है।

— नेवले

@ नवीन मुझे त्रुटि नहीं दिख रही है, मैंने इसे बिना किसी असफलता के परीक्षण किया है

— 0x45

R> c && s <c स्थिति कभी भी संतुष्ट नहीं होती है यदि इनपुट एक

— रिटेनर

1

Pyke , 6 बाइट्स

}~F>R^

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

}      -    input*2
 ~F    -   infinite list of the fibonacci numbers
   >   -  ^[:input]
    R^ - closest_to(^, input)

— नीला
स्रोत

1

आम लिस्प, 69 बाइट्स

(lambda(n)(do((x 0 y)(y 1(+ x y)))((< n y)(if(<(- n x)(- y n))x y))))

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

— रेंज़ो
स्रोत

1

पर्ल 6 , 38 बाइट्स

{(0,1,*+*...*>$_).sort((*-$_).abs)[0]}

झसे आज़माओ

{   # bare block lambda with implicit parameter ｢$_｣

  ( # generate Fibonacci sequence

    0, 1,  # seed the sequence
    * + *  # WhateverCode lambda that generates the rest of the values
    ...    # keep generating until
    * > $_ # it generates one larger than the original input
           # (that larger value is included in the sequence)

  ).sort(           # sort it by
    ( * - $_ ).abs  # the absolute difference to the original input
  )[0]              # get the first value from the sorted list
}

संभावित गति-अप के लिए .tail(2)पहले जोड़ें .sort(…)।

एक टाई के मामले में, यह हमेशा दो मूल्यों में से छोटे को लौटाएगा, क्योंकि sortएक स्थिर प्रकार है। (दो मान जो क्रमबद्ध करेंगे वही उनका क्रम बनाए रखेगा)

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

पायथ, 19 बाइट्स

JU2VQ=+Js>2J)hoaNQJ

इसे यहाँ आज़माएँ

व्याख्या

JU2VQ=+Js>2J)hoaNQJ
JU2                  Set J = [0, 1].
   VQ=+Js>2J)        Add the next <input> Fibonacci numbers.
              oaNQJ  Sort them by distance to <input>.
             h       Take the first.

1

हास्केल, 48 बाइट्स

(%)a b x|abs(b-x)>abs(a-x)=a|1>0=b%(a+b)$x
(1%2)

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

— Angs
स्रोत

निकटतम फाइबोनैचि संख्या ज्ञात करें

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

स्कोरिंग

पायथन 2 , 43 बाइट्स

नीम , 5 बाइट्स

पायथन , 55 52 बाइट्स

आर , 70 67 64 62 60 बाइट्स

तेज़ संस्करण:

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

Jelly, 9 7 bytes

Mathematica, 30 bytes

x86-64 Machine Code, 24 bytes

PowerShell, 80 74 bytes

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

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

जावास्क्रिप्ट (बैबेल नोड) , 41 बाइट्स

Ungolfed

पायथन, 74 बाइट्स

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

05AB1E, 6 bytes

C (gcc), 86 85 83 76 bytes

जावा (ओपनजेडके 8) , 60 57 56 bytes

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

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

टैक्सी, 2321 बाइट्स

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

डीसी, 52 बाइट्स

सी # (.NET कोर) , 63 56 बाइट्स

क्यू / केडीबी +, 51 बाइट्स

हेक्सागोनी , 37 बाइट्स

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

जाप -g , 8 बाइट्स

जावा 7, 244 234 बाइट्स

Pyke , 6 बाइट्स

आम लिस्प, 69 बाइट्स

पर्ल 6 , 38 बाइट्स

पायथ, 19 बाइट्स

व्याख्या

हास्केल, 48 बाइट्स

जाप `-g` , 8 बाइट्स