115

फाइबोनैचि अनुक्रम संख्या है, जहां अनुक्रम में हर संख्या यह पिछले दो संख्याओं का योग है का क्रम है। अनुक्रम में पहले दो नंबर दोनों 1 हैं।

यहां पहले कुछ शब्द दिए गए हैं

1 1 2 3 5 8 13 21 34 55 89 ...

सबसे छोटा कोड लिखें जो या तो:

बिना अंत के फाइबोनैचि अनुक्रम उत्पन्न करता है।
दिए गए अनुक्रम nके nवें पद की गणना करता है । (या तो 1 या शून्य अनुक्रमित)

आप इनपुट और आउटपुट के मानक रूपों का उपयोग कर सकते हैं।

(यदि आपकी चुनी हुई भाषा को दूसरे की तुलना में करना आसान हो तो मैं दोनों विकल्प देता हूं।)

उस फ़ंक्शन के लिए n, जो एक बहुत बड़ा रिटर्न मान लेता है (सबसे बड़ा फाइबोनैचि संख्या जो आपके कंप्यूटर के सामान्य शब्द आकार को कम से कम फिट करता है) का समर्थन करना होगा।

लीडरबोर्ड

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

/* Configuration */

var QUESTION_ID = 85; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 3; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Expand snippet

— क्रिस जस्टर-यंग
स्रोत

48

पर्ल 6, 10 चार्ट:

बेनामी अनंत रिटेल अनुक्रम सूची:

^2,*+*...*

के समान:

0, 1, -> $x, $y { $x + $y } ... Inf;

तो, आप इसे एक सरणी में असाइन कर सकते हैं:

my @short-fibs = ^2, * + * ... *;

या

my @fibs = 0, 1, -> $x, $y { $x + $y } ... Inf;

और पहले ग्यारह मान प्राप्त करें (0 से 10 तक):

say @short-fibs[^11];

या साथ:

say @fibs[^11];

प्रतीक्षा करें, आप अनाम सूची से भी पहले 50 नंबर प्राप्त कर सकते हैं:

say (^2,*+*...*)[^50]

वह रिटर्न:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169
63245986 102334155 165580141 267914296 433494437 701408733 1134903170 
1836311903 2971215073 4807526976 7778742049

और कुछ सरल बेंचमार्क:

real    0m0.966s
user    0m0.842s
sys     0m0.080s

साथ में:

$ time perl6 -e 'say (^2, *+* ... *)[^50]'

EOF

— मार्को औरेलियो दा सिल्वा
स्रोत

मैं भी के ^2रूप में प्रतिस्थापन के बारे में सोचना नहीं होगा 0,1। +1

— कोनराड बोरोस्की

2

यह अब मान्य नहीं है, आपको इसे लिखना होगा |^2,*+*...*, जो कि बाइट्स की समान संख्या है 0,1,*+*...*।

— ब्रैड गिल्बर्ट 20

5

पर्ल बहुत अजीब है।

— साइओस

पर्ल 6 के किस संस्करण में यह उत्तर लिखा गया था?

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

3

@CalculatorFeline जीएलआर (ग्रेट लिस्ट रिफ्लेक्टर) के रूप में जाना जाने वाला एक बड़ा बदलाव था जो कि पहली आधिकारिक रिलीज़ से कुछ समय पहले हुआ था जो 2015-12-25 को हुआ था। उस समय तक इस कोड ने सही काम किया होगा।

— ब्रैड गिल्बर्ट b 12gills

73

ब्रेनफक, 22 स्ट्रोक

+>++[-<<[->+>+<<]>>>+]

फाइबोनैचि अनुक्रम को धीरे-धीरे मेमोरी टेप में स्थानांतरित करता है।

— आर। मार्टिनो फर्नांडीस
स्रोत

5

सुंदर! बेहद खूबसूरत! या शायद नहीं ... वैसे भी इस के लिए +1 :)

— प्रति हॉर्न्ज-शियरबेक

2

संकुचित ब्रेनफक में यह 3.344 या 4 बाइट्स है। (6 ln (22)) / ln (256)

— विल शेरवुड

24

16 बाइट्स:+[[<+>->+>+<<]>]

— प्राइमो

3

14 बाइट्स:+[.[>+>+<<-]>]

— चार्लीम

2

@Stefnotch बेशक छोटा है, विनाशकारी है। ऊपर दिए गए समाधान से टेप पर फ़्रीक्वेंसी अनुक्रम समाप्त हो जाता है, जो कि 16 बाइट समाधान भी करता है।

— प्रिमो

51

हास्केल, 17 15 14 वर्ण

f=1:scanl(+)1f

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

— Anon।
स्रोत

4

क्यों नहीं दो स्थानों में कटौती f=0:scanl(+)1 f?

— आर। मार्टिनो फर्नांडीस

@Martinho: संपादित, धन्यवाद।

— आनन।

वाह, यह सामान्य से भी छोटा है f@(_:x)=0:1:zipWith(+)f x! इसे याद रखना है।

— फ़ूजएक्सएक्सएल

4

आप दूसरी जगह भी पट्टी कर सकते हैं f=0:scanl(+)1f:।

— फूजएक्सएक्सएल

37

सी # 4, 58 बाइट्स

स्ट्रीम (69; 65 यदि कमजोर रूप से टाइप किया गया है IEnumerable)

(के usingलिए एक निर्देश मानते हुए System.Collections.Generic।)

IEnumerable<int>F(){int c=0,n=1;for(;;){yield return c;n+=c;c=n-c;}}

एकल मान (58)

int F(uint n,int x=0,int y=1){return n<1?x:F(n-1,y,x+y);}

— जॉन स्कीट
स्रोत

6

यह देखते हुए कि nएक है uint, n==0को छोटा किया जा सकता है n<1। और धारा जेनेरिक प्रकार के बाद अंतरिक्ष को खोदकर और xआवश्यक से व्यापक दायरे में घोषित करके कुछ चार्ट को बचा सकती है। वास्तव में, xपूरी तरह से खाई :n+=c;c=n-c;

— पीटर टेलर

1

@ पेटर: धन्यवाद, कुछ समय मिलने पर संपादित करूंगा।

— जॉन स्कीट

आपका एकल मान संस्करण तब तक है जब तक मेरा पुनरावर्ती लंबोदर अभिव्यक्ति उत्तर ... अच्छा है!

— एंड्रयू ग्रे

1

@ wizzwizz4 अगर मैं गलत नहीं हूँ, अगर !nकाम करता है, तो बस nआपको सशर्त फ्लिप करना चाहिए ।

— साइयो

3

@JonSkeet Aw और यहाँ मैं सोच रहा था कि मैं जॉन स्कीट को C # पर

— हराऊंगा

32

GolfScript, 12

अब, सिर्फ 12 वर्ण!

1.{.@.p+.}do

— jtjacques
स्रोत

+1 अच्छा काम। यदि आप इसे 13 वर्णों से छोटा बनाते हैं, तो मैं तुरंत आपके उत्तर को स्वीकार कर लूंगा (जब तक कि कोई इससे छोटा उत्तर नहीं देता, निश्चित रूप से)। :

— क्रिस जस्टर-यंग

1

मुझे एक चुनौती पसंद है। किया हुआ! ;-)

— jtjacques

अच्छा है, तुम जीतो। कम से कम, जब तक कोई व्यक्ति कुछ भी छोटा नहीं करता है (यदि यह भी संभव है)। :-P

— क्रिस जस्टर-यंग

5

यह परिभाषा लगभग 'फिबोनाची' नाम से कम है! +1

— एजेंट-

23

> <> - 15 वर्ण

0:nao1v LF a+@:n:<o

— केविन ब्राउन
स्रोत

यद्यपि आप चाहें 0:nao1v LF a+@:n:<oतो इसे छोटा कर सकते हैं। 15 :) देता है, वास्तव में, यह आउटपुट को थोड़ा और पठनीय बनाता है ...

— tomsmeding

5

13 वर्ण:01r:nao$:@+$r

— यादृच्छिक

21

जे, 10 वर्ण

टेलर श्रृंखला गुणांक की अंतर्निहित गणना का उपयोग करते हुए शायद थोड़ा धोखा। इसे यहां सीखा ।

   (%-.-*:)t.

   (%-.-*:)t. 0 1 2 3 4 5 10 100
0 1 1 2 3 5 55 354224848179261915075

— randomra
स्रोत

2

@aditsu (q:^-^:p) 6है 64 729जहां पी भी है। J शायद पहेलियों के लिए अच्छा है । :)

— यादृच्छिक

2

इससे भी बेहतर: (<:^-^:>) 4है 81और <:^-^:> 4है53.5982 ।

— रैंडम

2

यहाँ प्रदर्शित इमोजी वही है जो सभी जे कोड के लिए प्रयास करना चाहिए। एक साइड नोट पर, दूसरा विकल्प +/@:!&i.-9 बाइट्स का उपयोग कर रहा है।

— मील

1

@ मीलों बहुत अच्छा! आपको इसे पोस्ट करना चाहिए क्योंकि यह खदान से पूरी तरह से अलग है।

— रैंडम

21

Hexagony ,18 14 12

6 बाइट्स के लिए धन्यवाद मार्टिन!

1="/}.!+/M8;

विस्तारित:

  1 = "
 / } . !
+ / M 8 ;
 . . . .
  . . .

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

पुराना, उत्तर। यह इसलिए छोड़ा जा रहा है क्योंकि चित्र और स्पष्टीकरण नए हेक्सागोनी उपयोगकर्ताओं के लिए सहायक हो सकते हैं।

!).={!/"*10;$.[+{]

विस्तारित:

  ! ) .
 = { ! /
" * 1 0 ;
 $ . [ +
  { ] .

यह फाइबोनैचि अनुक्रम को नए सिरे से अलग करता है।

इसे ऑनलाइन आज़माएं!हालांकि सावधान रहें, ऑनलाइन दुभाषिया वास्तव में अनंत आउटपुट को पसंद नहीं करता है।

व्याख्या

इस कार्यक्रम में दो "सबरूटीन्स" हैं, प्रत्येक को दो उपयोग किए गए आईपी में से एक द्वारा चलाया जाता है। पहला रूटीन नए सिरे से प्रिंट करता है, और दूसरा फाइबोनैचि गणना और आउटपुट करता है।

पहली सबरूटीन पहली पंक्ति पर शुरू होती है और पूरे समय दाएं से बाएं चलती है। यह पहले मेमोरी पॉइंटर पर वैल्यू प्रिंट करता है (शून्य से आरंभिक), और उसके बाद मेमोरी पॉइंटर पर मूल्य बढ़ाता है 1। नो-ऑप के बाद, आईपी तीसरी पंक्ति में कूदता है जो पहले किसी अन्य मेमोरी सेल पर स्विच करता है, फिर एक नई रेखा प्रिंट करता है। चूंकि एक नई पंक्ति का एक सकारात्मक मूल्य है (इसका मूल्य 10 है), कोड हमेशा अगली पंक्ति में कूद जाएगा। पांचवीं पंक्ति हमारे फाइबोनैचि संख्या में मेमोरी पॉइंटर लौटाती है और फिर अन्य सबरूटीन पर स्विच करती है। जब हम इस सबरूटीन से वापस आते हैं, तो IP बिना किसी सेशन के, तीसरी पंक्ति में वापस कूद जाएगा।

दूसरा सबरूटीन शीर्ष दाएं कोने से शुरू होता है और दक्षिण पूर्व की ओर बढ़ना शुरू करता है। नो-ऑप के बाद, हम पश्चिम को दूसरी पंक्ति के साथ यात्रा करने के लिए बाउंस कर रहे हैं। मेमोरी पॉइंटर को अगले स्थान पर ले जाने से पहले यह लाइन वर्तमान फाइबोनैचि संख्या को प्रिंट करती है। फिर आईपी चौथी पंक्ति में कूदता है, जहां यह पिछले दो का उपयोग करके अगले फाइबोनैचि संख्या की गणना करता है। यह फिर पहले सबरूटीन पर नियंत्रण वापस देता है, लेकिन जब यह कार्यक्रम का नियंत्रण प्राप्त करता है, तो यह तब तक जारी रहता है जब तक कि यह एक छलांग से नहीं मिलता है, जहां यह दर्पण पर उछलता है जो मूल रूप से पश्चिम को इंगित करने के लिए उपयोग किया जाता था, क्योंकि यह दूसरी पंक्ति में लौटता है।

प्रारंभिक सुंदर चित्र!

छवि के बाईं ओर कार्यक्रम है, दाहिने हाथ की ओर मेमोरी का प्रतिनिधित्व करता है। ब्लू बॉक्स पहला IP है, और दोनों IP निष्पादित होने के अगले निर्देश पर इशारा कर रहे हैं।

नोट: चित्र केवल उन लोगों को बहुत अच्छे लगते हैं जिनके पास छवि संपादन कार्यक्रमों के साथ समान रूप से सीमित कौशल है: पीआई कम से कम 2 और पुनरावृत्तियों को जोड़ देगा ताकि *ऑपरेटर का उपयोग अधिक स्पष्ट हो जाए।

नोट 2: मैंने केवल एलेफाल्फा के उत्तर को देखा था इस के अधिकांश लिखने के बाद, मुझे लगा कि यह अलगाव के कारण अभी भी मूल्यवान है, लेकिन हमारे कार्यक्रमों के वास्तविक फाइबोनैचि भाग बहुत समान हैं। इसके अलावा, यह सबसे छोटा हेक्सागोनी प्रोग्राम है जिसे मैंने एक से अधिक आईपी का उपयोग करते हुए देखा है, इसलिए मैंने सोचा कि वैसे भी रखना अच्छा हो सकता है: पी

— FryAmTheEggman
स्रोत

आपको सुंदर चित्रों को बनाने के लिए जो कुछ भी इस्तेमाल करना था, उससे लिंक करना चाहिए, फिर लिंक को esolangs.org/wiki/Hexagony पर डाल दें ।

— mbomb007

1

@ mbomb007 मैंने मैन्युअल रूप से प्रत्येक फ्रेम बनाने के लिए जिम्प का उपयोग किया, फिर छवियों को कुछ जिफ़ बनाने वाली वेबसाइट पर अपलोड किया। हालांकि, इस प्रक्रिया के दौरान कई बार मैंने इसे करने के लिए एक उपकरण बनाने पर विचार किया, यह देखते हुए कि यह कितना थकाऊ था।

— FryAmTheEggman

@FryAmTheEggman प्रभावशाली! इसे एक चुनौती बनाओ। मुझे यकीन है कि कोई एक उत्तर पोस्ट करेगा। : D और भी बेहतर अगर आप मछली के ऑनलाइन दुभाषिया के समान एक वेबसाइट बना सकते हैं।

— mbomb007

@ mbomb007 इस साइट पर एक चुनौती के लिए एक महत्वाकांक्षी हो सकता है, यह उल्लेख करने के लिए नहीं कि यह वास्तव में व्यापक होने से बहुत अधिक पीड़ित होगा। मुझे नहीं लगता कि मैं इसे पोस्ट करूंगा, लेकिन अगर आप सोचते हैं कि आपके पास इसे प्रस्तुत करने का एक अच्छा तरीका है, तो इसे स्वयं करने के लिए स्वतंत्र महसूस करें। इसके अलावा, मेरा मानना है कि टिमवी ने हेक्सागोनी के लिए एक सी # विचारधारा बनाई है, हालांकि मैंने इसका इस्तेमाल कभी नहीं किया है क्योंकि मैंने मोनो के साथ परेशान नहीं किया है।

— FryAmTheEggman

1

@ mbomb007 विचारधारा यहां रहती है , वैसे, पिछली बार इसे लिंक करना भूल गया था।

— फ्राईअमईएग्गमैन

18

गाय , १० COW

 MoO moO MoO mOo MOO OOM MMM moO moO
 MMM mOo mOo moO MMM mOo MMM moO moO
 MOO MOo mOo MoO moO moo mOo mOo moo

— Timtech
स्रोत

17

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

अजगर, पुनरावृत्ति का उपयोग कर ... यहाँ एक StackOverflow आता है!

def f(i,j):print i;f(j,i+j)
f(1,1)

— jtjacques
स्रोत

15

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

+¡1

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

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

+¡1    Niladic link. No implicit input.
       Since the link doesn't start with a nilad, the argument 0 is used.

  1    Yield 1.
+      Add the left and right argument.
 ¡     For reasons‡, read a number n from STDIN.
       Repeatedly call the dyadic link +, updating the right argument with
       the value of the left one, and the left one with the return value.

^‡ ¡ बाईं ओर दो लिंक पर peeks। चूंकि केवल एक ही है, यह लूप का शरीर होना है। इसलिए, इनपुट से एक संख्या पढ़ी जाती है। चूंकि कोई कमांड-लाइन तर्क नहीं हैं, इसलिए उस नंबर को STDIN से पढ़ा जाता है।

— डेनिस
स्रोत

12

गोल्फस्क्रिप्ट - एकल संख्या - 12/11/10

स्टड से इनपुट लेने के लिए 12 वर्ण:

~0 1@{.@+}*;

पहले से ही स्टैक पर इनपुट के लिए 11 चार्ट:

0 1@{.@+}*;

आगे 1 परिभाषित करने के लिए 10 चार्ट 0 वें फाइबोनैचि संख्या के रूप में:

1.@{.@+}*;

— aaaaaaaaaaaa
स्रोत

1

विकल्प "गणना, एन दिया, nth फाइबोनैचि संख्या" है। तो खाई ~और आपके पास 11 चार्ट हैं जो nस्टैक पर ले जाते हैं और स्टैक F_nपर छोड़ देते हैं ।

— पीटर टेलर

12

माणिक

२ ९ २ 29 २५ २४ चौ

p a=b=1;loop{b=a+a=p(b)}

संपादित करें: इसे एक अनंत लूप बनाया गया। ;)

— st0le
स्रोत

13

क्या किसी ने नोटिस किया है कि b=a+a=bवह एक पलिंड्रोम है? :)

— st0le

2

हां st0le ने किया :)

— gnibbler

मुझे पता है कि मुझे पार्टी में देरी हो रही है, लेकिन क्या कोई यह समझा सकता है कि b=a+a=bभाग कैसे काम करता है? मेरे सिर को इसके चारों ओर लपेटने के लिए प्रतीत नहीं हो सकता।

— श्री लामा

3

@ गीगावाट, इसे इस तरह से सोचें, निर्देशों को बाएं से दाएं निष्पादित किया जाता है ... इसलिएnewb=olda+(a=oldb)

— st0le

आप का उपयोग करके 2 वर्ण बचा सकते हैं loop:p 1,a=b=1;loop{p b=a+a=b}

— पैट्रिक ऑसिटी

11

गणितज्ञ, 9 वर्ण

Fibonacci

यदि अंतर्निहित कार्यों की अनुमति नहीं है, तो यहां एक स्पष्ट समाधान है:

गणितज्ञ, ३३ ३२ ३१ वर्ण

#&@@Nest[{+##,#}&@@#&,{0,1},#]&

— celtschk
स्रोत

#&@@Nest[{#+#2,#}&@@#&,{0,1},#]&32 चरस।

— च्यानोग

1

@chyanog 31:#&@@Nest[{+##,#}&@@#&,{0,1},#]&

— Mr.Wizard

1

@ Mr.Wizard 24 chars (26 बाइट्स):Round[GoldenRatio^#/√5]&

— JungHwan Min

1

या 23 वर्ण (27 बाइट):Round[((1+√5)/2)^#/√5]&

— जुंगह्वान मिन

10

डीसी (20 बाइट्स)

एक बोनस के रूप में, यह भी बाधित है;)

zzr[dsb+lbrplax]dsax

संपादित करें: मैं इंगित कर सकता हूं कि यदि आप लंबे समय तक प्रतीक्षा करते हैं, तो यह सभी संख्याओं को अनुक्रम में प्रिंट करता है।

— Hiato
स्रोत

13

मैं इसे obfuscated नहीं कहूंगा - obfuscated कोड को समझना मुश्किल माना जाता है, और जहाँ तक dc का कोड आता है, वह पूरी तरह से सीधा है।

— नायब

10

प्रस्तावना , 12 बाइट्स

कुछ चुनौतियों में से एक जहां प्रील्यूड वास्तव में काफी प्रतिस्पर्धी है:

1(v!v)
  ^+^

इसके लिए पायथन इंटरप्रिटर की आवश्यकता होती है जो वर्णों के बजाय दशमलव संख्या के रूप में मानों को प्रिंट करता है।

व्याख्या

प्रस्तावना में, सभी पंक्तियों को समानांतर में निष्पादित किया जाता है, कार्यक्रम के निर्देश सूचक ट्रैवर्सिंग कॉलम के साथ। प्रत्येक पंक्ति का अपना स्टैक होता है जिसे शून्य से आरंभ किया जाता है।

1(v!v)
  ^+^
| Push a 1 onto the first stack.
 | Start a loop from here to the closing ).
  | Copy the top value from the first stack to the second and vice-versa.
   | Print the value on the first stack, add the top two numbers on the second stack.
    | Copy the top value from the first stack to the second and vice-versa.

लूप हमेशा के लिए दोहराता है, क्योंकि पहले स्टैक में कभी भी 0शीर्ष नहीं होगा ।

ध्यान दें कि इससे फिबोनाची अनुक्रम शुरू होता है 0।

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

10

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

गैर-प्रतिस्पर्धात्मक क्योंकि भाषा प्रश्न की तुलना में नई है।

1.}=+!

Ungolfed:

  1 .
 } = +
  ! .

यह किसी भी विभाजक के बिना फाइबोनैचि अनुक्रम को प्रिंट करता है।

— alephalpha
स्रोत

2

यह मामूली समस्या है कि यह संख्याओं के बीच किसी विभाजक को प्रिंट नहीं करता है। हालांकि यह चुनौती में पूरी तरह से निर्दिष्ट नहीं है। (और मैं वास्तव में खुश हूं कि कोई हेक्सागोनी का उपयोग कर रहा है। :))

— मार्टिन

9

TI-BASIC, 11

इस साइट से महान TI-BASIC गोल्फर केनेथ हैमंड ("Weregoose") । O (1) समय में चलता है, और 0 को फिबोनाची अनुक्रम का 0 वां शब्द मानता है।

int(round(√(.8)cosh(Anssinh‾¹(.5

काम में लाना:

2:int(round(√(.8)cosh(Anssinh‾¹(.5
                                     1

12:int(round(√(.8)cosh(Anssinh‾¹(.5
                                     144

यह कैसे काम करता है? यदि आप गणित करते हैं, तो यह पता चला हैsinh‾¹(.5)ln φ , तो यह समान हो जाता है , इसलिए यह Binet के सूत्र का एक संशोधित संस्करण है जो (1/φ)^nसुधार शब्द का उपयोग करने के बजाय नीचे गोल होता है । round((9 दशमलव स्थानों के लिए गोल) राउंडिंग त्रुटियों को रोकने की जरूरत है।

— थॉमस कावा को दर्शाता है
स्रोत

8

के - १२

nऔर n-1फाइबोनैचि संख्या की गणना करता है ।

{x(|+\)/0 1}

बस nthफिबोनाची संख्या।

{*x(|+\)/0 1}

— isawdrones
स्रोत

+1 बुरा नहीं है! यदि आप इसे केवल एक चरित्र को सिकोड़ सकते हैं (और मुझे इसे जांचने का एक तरीका प्रदान कर सकते हैं), तो मैं आपके उत्तर को स्वीकार करूंगा। :-)

— क्रिस जस्टर-यंग

इसे सिकोड़ने का एकमात्र तरीका यह होगा कि फ़ंक्शन को एक ज्ञात संख्या में कॉल के साथ प्रतिस्थापित किया जाए: n (! + +) / 0 1 इस दुभाषिया का उपयोग करके परीक्षण करें ।

— isawdrones

7

जूलिया, 18 बाइट्स

n->([1 1;1 0]^n)[]

— Rɪᴋᴇʀ
स्रोत

7

जावा, ५५

मैं यहां अधिकांश भाषाओं की संगति का मुकाबला नहीं कर सकता, लेकिन मैं n-वें संख्या की गणना करने के लिए एक अलग और संभवतः बहुत तेज़ (निरंतर समय) तरीका प्रदान कर सकता हूं:

Math.floor(Math.pow((Math.sqrt(5)+1)/2,n)/Math.sqrt(5))

nn (1) से शुरू होने वाला इनपुट (int या लंबा) है। यह घटाव के बजाय बिनेट के सूत्र और राउंड का उपयोग करता है ।

— हंस-पीटर स्टॉर
स्रोत

मुझे यह समाधान बहुत पसंद है

— एंड्रियास

यह मेरे लिए काम नहीं करता है, लेकिन यह जल्दी है और मुझे कुछ याद आ रहा है! 0अनुक्रम में पहले नंबर को मानते हुए , यह 0, 0, 1, 1, 3, 4, 8, 12, 21, 33पहले 10 नंबर के लिए देता है

— झबरा

@ शगुन उफ़! क्षमा करें, मैंने अभी एक बग की शुरुआत की है।

— हंस-पीटर स्टॉर

6

रूबी, 25 चरस

st0le का उत्तर छोटा हो गया।

p 1,a=b=1;loop{p b=a+a=b}

— मातमा रेक्स
स्रोत

6

वास्तव में आप इसे आगे भी छोटा कर सकते हैंa=b=1;loop{p a;b=a+a=b}

— वेंटरो

6

तो आप उसके जवाब को टालते हैं? : P

— mbomb007

6

FAC: कार्यात्मक APL, 4 वर्ण (!!)

मेरा नहीं, इसलिए सामुदायिक विकि के रूप में पोस्ट किया गया। FAC, APL की एक बोली है, जिसे Hai-Chen Tu ने 1985 में अपने PhD शोध प्रबंध के रूप में स्पष्ट रूप से सुझाया था। उन्होंने बाद में एलन जे। पेर्लिस के साथ मिलकर एक लेख लिखा, जिसे " FAC: A Functional APL Language " कहा गया। एपीएल की यह बोली "आलसी सरणियों" का उपयोग करती है और अनंत लंबाई की सरणियों के लिए अनुमति देती है। यह एक ऑपरेटर "iter" ( ⌼) को कुछ पुनरावर्ती अनुक्रमों की कॉम्पैक्ट परिभाषा के लिए अनुमति देता है।

⌼मूल रूप से मोनैडिक ("अनरीरी") मामला हास्केल का है iterate, और इसे परिभाषित किया गया है (F⌼) A ≡ A, (F A), (F (F A)), …। डाइएडिक ("बाइनरी") मामले को दो चर के लिए कुछ हद तक परिभाषित किया गया है A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …:। यह क्यों उपयोगी है? ठीक है, जैसा कि यह पता चलता है कि यह ठीक उसी तरह की पुनरावृत्ति है जिस पर फिबोनाची अनुक्रम है। वास्तव में, इसका एक उदाहरण दिया गया है

1+⌼1

परिचित अनुक्रम का निर्माण 1 1 2 3 5 8 …।

इसलिए, आप वहां जाते हैं, संभवत: गैर-नवीनता प्रोग्रामिंग भाषा में सबसे कम संभव फाइबोनैचि कार्यान्वयन। : डी

— जुगनू
स्रोत

ओह, मैंने अकस्मात अन-कम्युनिटी को अपनी पोस्ट को मेरे (मैनुअल) बल्क-अनडिक्लिंग के हिस्से के रूप में घोषित कर दिया। ओह अच्छा। ;-)

— क्रिस जैस्टर-यंग

6

आर, 40 बाइट्स

आर समाधान नहीं देखा है, इसलिए:

f=function(n)ifelse(n<3,1,f(n-1)+f(n-2))

— plannapus
स्रोत

1

मुझे पता है कि यह एक पुराना जवाब है, लेकिन आप 14 बाइट पर

— रॉबर्ट

6

05AB1E, 7 बाइट्स

कोड:

1$<FDr+

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

— Vimlesh
स्रोत

3

नमस्ते, और PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— R

6

डोडोस , 26 बाइट्स

	dot F
F
	F dip
	F dip dip

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

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

समारोह एफ सभी भारी उठाने करता है; इसे पुनरावर्ती रूप से परिभाषित किया गया है।

F(n) = ( F(|n - 1|), F(||n - 1| - 1|) )

जब भी n> 1 , हमारे पास है | n - 1 | = n - 1 <n और || n - 1 || - 1 | = | एन - 1 - 1 | = n - 2 <n , इसलिए फ़ंक्शन लौटता है (एफ (एन - 1), एफ (एन - 2)) ।

अगर n = 0 , तो | n - 1 | = 1> 0 ; अगर n = 1 , तो || n - 1 | - 1 | = | 0 - 1 | = 1 = 1 । दोनों मामलों में, पुनरावर्ती कॉल एफ (1) एक आत्मसमर्पण अपवाद को बढ़ाता है, इसलिए एफ (0) रिटर्न 0 और एफ (1) रिटर्न 1 ।

उदाहरण के लिए, एफ (3) = (एफ (1), एफ (2)) = (1, एफ (0), एफ (1)) = (1, 0, 1) ।

अंत में, मुख्य कार्य के रूप में परिभाषित किया गया है

main(n) = sum(F(n))

इसलिए यह एफ द्वारा लौटे वेक्टर के सभी निर्देशांक को जोड़ता है ।

उदाहरण के लिए, मुख्य (3) = योग (एफ (3)) = योग (1, 0, 1) = 2 ।

— डेनिस
स्रोत

5

GolfScript, 13 वर्ण

2,~{..p@+.}do

( पिछले स्टैक ओवरफ्लो सवाल से मेरा जवाब ।)

— क्रिस जस्टर-यंग
स्रोत

5

डेसमोस , 61 बाइट्स

golfed

के लिए add sliderबटन पर क्लिक करें n।

p=.5+.5\sqrt{5}
n=0
f=5^{-.5}\left(p^n-\left(-p\right)^{-n}\right)

अंतिम पंक्ति आउटपुट है।

Ungolfed

एक समारोह है।

\phi =\frac{1+\sqrt{5}}{2}
f_{ibonacci}\left(n\right)=\frac{\phi ^n-\left(-\phi \right)^{-n}}{\sqrt{5}}

— कोनोर ओ ब्रायन
स्रोत

5

क्यूबिक्स , 10 बाइट्स

गैर-प्रतिस्पर्धात्मक उत्तर क्योंकि भाषा प्रश्न की तुलना में नई है।

क्यूबिक्स एक नई 2 आयामी भाषा है @ETHproductions द्वारा कोड को फिट करने के लिए क्यूब के आकार पर लपेटा गया था।

;.o.ON/+!)

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

यह निम्नलिखित तरीके से 2 x 2 घन पर लपेटता है

    ; .
    o .
O N / + ! ) . .
. . . . . . . .
    . .
    . .

O टीओएस के मूल्य का उत्पादन
N स्टैक पर newline धक्का
/ उत्तर को प्रतिबिंबित करें
o टीओएस के चरित्र का उत्पादन
; पॉप टीओएस
/ क्यूब के चारों ओर जाने के बाद पूर्व को प्रतिबिंबित करें
+ स्टैक के शीर्ष 2 मान जोड़ें
! अगला आदेश छोड़ें यदि टीओएस 0 है
) टीओएस द्वारा वेतन वृद्धि 1. यह अनिवार्य रूप से अनुक्रम को बंद कर देता है।

यह एक अंतहीन लूप है जो अनुक्रम को एक नईलाइन विभाजक के साथ प्रिंट करता है। यह इस तथ्य का लाभ उठाता है कि अधिकांश कमांड स्टैक से मूल्यों को पॉप नहीं करते हैं।
यदि विभाजक को अनदेखा किया जाता है तो यह 5 बाइट्स के साथ किया जा सकता है.O+!)

— MickyT
स्रोत

5

Brainfuck, 16,15, 14/13 वर्ण

+[[->+>+<<]>]

फाइबोनैचि अनुक्रम उत्पन्न करता है और कुछ भी प्रिंट नहीं करता है। इसके अलावा, ऊपर वाले से छोटा है।

+[.[->+>+<<]>]

इस एक में 14 अक्षर हैं लेकिन ASCII वर्णों को प्रिंट करता है जिसमें फाइबोनैचि अनुक्रम के मान हैं।

— Stefnotch
स्रोत

1

यह अच्छा है, लेकिन क्या यह कहना गलत होगा कि 14 बाइट संस्करण केवल 2 1 से आउटपुट है? "1 1 2 3 5 8" के बजाय "1 2 3 5 8" में?

— चार्लीम

1

@Charlim ओह, तुम सही हो। मुझे नहीं पता कि 2014 के मुझे क्या लगा। वैसे भी, मैंने अभी प्रिंट निर्देश को लूप के सामने ले जाकर इसे ठीक किया है।

— स्टीफनोट

फाइबोनैचि फ़ंक्शन या अनुक्रम

लीडरबोर्ड

पर्ल 6, 10 चार्ट:

ब्रेनफक, 22 स्ट्रोक

हास्केल, 17 15 14 वर्ण

सी # 4, 58 बाइट्स

GolfScript, 12

> <> - 15 वर्ण

जे, 10 वर्ण

Hexagony ,18 14 12

व्याख्या

गाय , १० COW

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

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

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

गोल्फस्क्रिप्ट - एकल संख्या - 12/11/10

माणिक

२ ९ २ 29 २५ २४ चौ

डीसी (20 बाइट्स)

प्रस्तावना , 12 बाइट्स

व्याख्या

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

TI-BASIC, 11

के - १२

जूलिया, 18 बाइट्स

जावा, ५५

रूबी, 25 चरस

FAC: कार्यात्मक APL, 4 वर्ण (!!)

आर, 40 बाइट्स

05AB1E, 7 बाइट्स

डोडोस , 26 बाइट्स

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

GolfScript, 13 वर्ण

डेसमोस , 61 बाइट्स

golfed

Ungolfed

क्यूबिक्स , 10 बाइट्स

Brainfuck, 16,15, 14/13 वर्ण