斐波那契+ FizzBuzz =斐波那契！

您的挑战是创建Fibo Nacci程序！

Fibo Nacci程序输出前100个斐波那契数（从1开始）。
如果斐波那契数可被2 和 3整除（即它可被6整除），则输出FiboNacci而不是数字。
否则，如果斐波那契数可被2整除，则输出Fibo而不是该数。
否则，如果斐波那契数可被3整除，则输出Nacci而不是该数。

规则

该程序不应该输入。
程序应\n在每次输入后输出新行（）。
该程序不应将任何内容打印到STDERR。
程序必须输出前100个 Fibo Nacci条目（从1开始）。
不允许使用标准漏洞（默认情况下）。
这是代码高尔夫球，因此以字节为单位的最短代码胜出！

这是预期的输出：

1
1
Fibo
Nacci
5
Fibo
13
Nacci
Fibo
55
89
FiboNacci
233
377
Fibo
Nacci
1597
Fibo
4181
Nacci
Fibo
17711
28657
FiboNacci
75025
121393
Fibo
Nacci
514229
Fibo
1346269
Nacci
Fibo
5702887
9227465
FiboNacci
24157817
39088169
Fibo
Nacci
165580141
Fibo
433494437
Nacci
Fibo
1836311903
2971215073
FiboNacci
7778742049
12586269025
Fibo
Nacci
53316291173
Fibo
139583862445
Nacci
Fibo
591286729879
956722026041
FiboNacci
2504730781961
4052739537881
Fibo
Nacci
17167680177565
Fibo
44945570212853
Nacci
Fibo
190392490709135
308061521170129
FiboNacci
806515533049393
1304969544928657
Fibo
Nacci
5527939700884757
Fibo
14472334024676221
Nacci
Fibo
61305790721611591
99194853094755497
FiboNacci
259695496911122585
420196140727489673
Fibo
Nacci
1779979416004714189
Fibo
4660046610375530309
Nacci
Fibo
19740274219868223167
31940434634990099905
FiboNacci
83621143489848422977
135301852344706746049
Fibo
Nacci

/* Configuration */

var QUESTION_ID = 63442; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 41805; // 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 "http://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 "http://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}

#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="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<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>

展开摘要

— 克里蒂希·石印
source

6

那么只有64位的最大整数类型的语言呢？:( 90 fib。数字不够吗？

— Zereges

3

@Zereges在这件事上，我很抱歉。:(

— Kritixi Lithos 2015年

28

也许应该叫做“ Fizzo Nacci”

— LegionMammal978

4

@SztupY因为此问题的输出完全不变，所以您甚至根本不需要整数。只需将此问题视为kolmogorov复杂性问题（我什至添加了标签），然后从那里开始。

— 克里斯·杰斯特·杨

3

@ ChrisJester-Young仍然是一个不必要的限制，它可能会使有创造力的实现者避免执行此任务。而且大多数解决方案（包括第二个最受好评的解决方案）都已被打破

— SztupY

18

Pyth，37个字节

我循环遍历斐波那契数而不是事先生成它们，因为这确实很短。

K1V100|+*"Fibo"!%=+Z~KZ2*"Nacci"!%Z3Z

在线尝试。

— PurkkaKoodari
source

恭喜您赢得了挑战！我喜欢这个解决方案很快。

— Kritixi Lithos

45

Python 2，62个字节

a=b=1;exec"print~a%2*'Fibo'+~a%3/2*'Nacci'or a;a,b=b,a+b;"*100

确实，与标准FizzBuzz并没有太大区别。

— Sp3000
source

1

这真太了不起了。

— J Atkin

我需要记住下一个Ruby高尔夫的循环结构。这真太了不起了。

— 2015年

21

C ++ 11元编程，348字节

#include<iostream>
#define D static const unsigned long long v=
template<int L>struct F{D F<L-1>::v+F<L-2>::v;};template<>struct F<2>{D 1;};template<>struct F<1>{D 1;};template<int Z>struct S:S<Z-1>{S(){auto&s=std::cout;auto l=F<Z>::v;s<<(l%2?"":"Fibo")<<(l%3?"":"Nacci");(l%2&&l%3?s<<l:s)<<"\n";}};template<>struct S<0>{S(){}};int main(){S<100>s;}

因为，为什么不呢。它使用编译warning C4307: '+': integral constant overflow，运行正常，但是第93个以上的斐波那契数未正确显示（由于溢出），因此这是无效的条目（但是我无法用那么多的字节赢得它）

不打高尔夫球

#include <iostream>
#define D static const unsigned long long v = 
template<int L>struct F { D F<L - 1>::v + F<L - 2>::v; };
template<>struct F<2> { D 1; };
template<>struct F<1> { D 1; };

template<int Z>struct S : S<Z - 1>
{
    S()
    {
        auto&s = std::cout;
        auto l = F<Z>::v;
        s << (l % 2 ? "" : "Fibo")
          << (l % 3 ? "" : "Nacci");
        (l % 2 && l % 3 ? s << l : s) << "\n";
    }
};

template<>struct S<0>
{
    S() { }
};

int main()
{
    S<100>s;
}

— 泽雷格斯
source

您可以template <char H, char ...T>在模板中使用分解字符串（）（理论上）处理任意长度的值。然后，它只是在每个字符串检查的最后2个字符2和/或3确定整除的问题

— 美高

@Mego我不了解你。它如何帮助我处理不适合64位的值。另外，你需要所有的数字，以找出是否数目是被3整除

— Zereges

字符串可以任意长（直到内存用完）。你是对的，我搞砸了我的评论。不过，你可以计算的数字总和3.确定整除

— 美高

@Mego实施这些字符串的添加将需要更多的精力。

— Zereges，2015年

1

您可以使用gnu方言并使用__uint128_t，也许。

14

C＃，175171152145字节

class c{static void Main(){for(dynamic a=1m,b=a,c=0;c++<100;b=a+(a=b))System.Console.WriteLine(a%6>0?a%2>0?a%3>0?a:"Nacci":"Fibo":"FiboNacci");}}

未压缩：

class c {
    static void Main()
    {
        for (dynamic a = 1m, b = a, c = 0; c++ < 100; b = a + (a = b))
            System.Console.WriteLine(a%6>0?a%2>0?a%3>0?a:"Nacci":"Fibo":"FiboNacci");
    }
}

— 奥列格兹
source

即使使用DeflateStream压缩输出，我可以获得的最低字符为191个字符，因此这很可能与最佳c＃答案非常接近。需要一个可耻的BigInteger。

— Jodrell 2015年

“使用系统”；会再加上-1。

— olegz 2015年

1

尽管使用了：-S，但我仍然必须在System.Numerics前面加上System，因此我不确定使用是否可以。

— Jodrell 2015年

1

您可以通过用替换==0s >0并反转三元数来保存3个字符：

class c{static void Main(){for(System.Numerics.BigInteger a=1,b=1,c=0;c++<100;b=a+(a=b))System.Console.WriteLine(a%6>0?a%2>0?a%3>0?a:(object)"Nacci":"Fibo":"FiboNacci");}}

— Bob

3

您可以通过更改decimal a=1,b=1为来保存另外7个字符dynamic a=1m,b=a，然后可能会丢失(object):)

— Timwi

13

Oracle SQL，212字节

不是打高尔夫球的语言，但我不得不尝试...

将所有行与连接\n：

WITH F(R,P,C)AS(SELECT 1,0,1 FROM DUAL UNION ALL SELECT R+1,C,P+C FROM F WHERE R<100)SELECT LISTAGG(NVL(DECODE(MOD(C,2),0,'Fibo')||DECODE(MOD(C,3),0,'Nacci'),''||C),CHR(13))WITHIN GROUP(ORDER BY R)||CHR(13)FROM F

SQLFIDDLE

或每行序列中有一个条目（162字节）：

WITH F(R,P,C)AS(SELECT 1,0,1 FROM DUAL UNION ALL SELECT R+1,C,P+C FROM F WHERE R<100)SELECT NVL(DECODE(MOD(C,2),0,'Fibo')||DECODE(MOD(C,3),0,'Nacci'),''||C)FROM F

— MT0
source

2

太棒了，仅用于使用SQL

— Wayne Werner 2015年

只需使用最后一个，因为它与输出“每行”是“等效的”。这确实是一段不错的代码。做得好！

— Ismael Miguel，

@IsmaelMiguel如果它在SQL * Plus（或另一个命令行界面）中运行，则每行之后将有一个换行输出（作为它报告查询输出的一部分）。但是，这是CLI的功能，而不是SQL语言的功能-为了与规则兼容，The program should output a new line (\n) after every entry我将其保留为较长的代码，但是可以通过||CHR(13)在最后添加FROM用于171个字符。

— MT0

你不能用"\n"吗？似乎可以在MySQL上工作。（跑步select length("\n")返回1，跑步select "\n"不返回n，因为select "\p"返回p无效，因此返回）

— Ismael Miguel

SELECT LENGTH('\n') FROM DUAL2Oracle中的输出'\n'不会转换为CHR(13)。

— MT0

11

ShapeScript，83个字节

11'1?1?+'77*2**!""'"%r
"@+@0?2%1<"Fibo"*1?3%1<"Nacci"*+0?_0>"@"*!#%'52*0?**!"'"$""~

在线尝试！

— 丹尼斯
source

15

从字面上看，当我尝试打开粘滞键时，猫跳到了键盘上方。不错的工作。

— 阶段

2

@phase具有象征意义。要么那个，要么你看起来不太近。或者您有一只小猫或一个巨大的键盘。因为这只猫设法键入Fibo和Nacci，但否则要避免所有字母键都保存一个r。

— John Dvorak

3

@JanDvorak我认为该阶段已经为此设置了宏；）

— Wayne Werner

2

@phase 1.为什么你的猫在你的房间里？2.为什么要打开粘滞键？3？为什么您的桌子上没有猫陷阱盒，以免猫跳到键盘上？

— Nzall

7

Java中，407个 398 351 308字节

在@Geobits和@SamYonnou的帮助下打高尔夫球

传播这个词： Verbose == Java

import java.math.*;class A{public static void main(String[]w){BigInteger a=BigInteger.ZERO,b=a.flipBit(0),c,z=a,t=a.flipBit(1),h=t.flipBit(0),s=t.flipBit(2);for(int i=0;i<100;i++){System.out.println(b.mod(s).equals(z)?"FiboNacci":b.mod(t).equals(z)?"Fibo":b.mod(h).equals(z)?"Nacci":b);c=a;a=b;b=c.add(b);}}}

非高尔夫版本：

import java.math.*;

class A
{
  public static void main(String[]w)
  {
    BigInteger a=BigInteger.ZERO,b=a.flipBit(0),c,z=a,t=a.flipBit(1),h=t.flipBit(0),s=t.flipBit‌(2);
    for(int i=1;i<=100;i++) {
      System.out.println(b.mod(s).equals(z)?"FiboNacci":b.mod(t).equals‌(z)?"Fibo":b.mod(h).equals(z)?"Nacci":b);                
      c=a;a=b;b=c.add(b);
    }
  }
}

— 袜子
source

1

这可以打更多。导入java.math.*而不是整个。使用常量ONE和ZERO替代newBigIntegers。public从课程中删除。将除println语句之外的所有内容打包for在循环声明等内部的主体中。我建议通常查看Java高尔夫技巧。

— Geobits，2015年

@Geobits完成！遗憾的是我不熟悉BigInteger它的各种高尔夫技术。

— 袜子

使用flipBit（...）替代新BigInteger（...）以及其他一些小事情来存储BigInteger.ZERO，您可以将其降低到308：

import java.math.*;class A{public static void main(String[]w){BigInteger a=BigInteger.ZERO,b=a.flipBit(0),c,z=a,t=a.flipBit(1),h=t.flipBit(0),s=t.flipBit(2);for(int i=0;i<100;i++){System.out.println(b.mod(s).equals(z)?"FiboNacci":b.mod(t).equals(z)?"Fibo":b.mod(h).equals(z)?"Nacci":b);c=a;a=b;b=c.add(b);}}}

— SamYonnou 2015年

看起来BigInteger总会BigInteger.ZERO在某些操作的add(...)求值为零时返回，因此您可以使用==代替.equals(z)，也可以取消存储s=t.flipBit‌(2)（6）的工作，而改为执行一些巧妙的内部分配，例如：

import java.math.*;class A{public static void main(String[]w){BigInteger a=BigInteger.ZERO,b=a.flipBit(0),c,d,z=a,t=a.flipBit(1),h=t.flipBit(0);for(int i=0;i<100;i++){System.out.println((c=b.mod(t)).add(d=b.mod(h))==z?"FiboNacci":c==z?"Fibo":d==z?"Nacci":b);c=a;a=b;b=c.add(b);}}}

这些更改将其降至280

— SamYonnou

2

我想你的意思是Verbose.isEqualTo(Java)

— Cyoce '16

7

Mathematica，80个字节

a=b_/;#∣b&;Print/@(Fibonacci@Range@100/.{%@6->FiboNacci,%@2->Fibo,%@3->Nacci})

适应了我以前的FizzBuzz解决方案。

— 军团哺乳动物978
source

1

@JacobAkkerboom对不起，已修复。另外，对于低于10.3的版本，请替换Echo为Print。

— LegionMammal978

5

Ruby，71 66字节

a=b=1;100.times{puts [b,f='Fibo',n='Nacci',f,b,f+n][~b%6];a=b+b=a}

松散

a = b = 1 #starting values
100.times{
  # create an array, and selects a value depending on the current number
  puts([b, 'Fibo', 'Nacci', 'Fibo', b, 'FiboNacci'][~b%6])
  a=b+b=a # magic
}

— 超级汤姆
source

我从事此工作的时间超过了我想要管理的时间，并且找不到任何改进方法。f,n=%w[Fibo Nacci]，f,n='Fibbo','Nacci'并且f='Fibbo';n='Nacci'所有字符数都相同。+1

— Shelvacu 2015年

1

您可以使用来节省三个字节[b,f='Fibo',n='Nacci',f,b,f+n][~b%6]，而删除中的括号则可以节省另外两个字节a=b+b=a。

— 2015年

谢谢@primo。对于~操作员而言，这是一个巧妙的技巧。以前没看过。现在我知道为什么负指标是红宝石的一部分了：）

— MegaTom，2015年

真的需要puts [代替puts[吗？

— 暴民埃里克（Erik the Outgolfer）

1

玫瑰是红色，紫罗兰是蓝色，对于Haskell和Ruby，我一无所知。

— 暴民埃里克（Erik the Outgolfer）'16年

5

> <>，116字节

01:n1&61>.
ao:@+:v
vv?%2:<
">:3%?vv^16<
o>:3%?!v~v<&
bov"ci"< 6 ;
io"   n  6~?
Focv1&<   o=
"o">+:aa*!o^
>^>"aN"ooo^

在线尝试！

— hakr14
source

6

欢迎光临本站！:)

— DJMcMayhem

您可能会合并两个3%部分

— Jo King

@JoKing您会这样认为，但如果n％3！= 0，它们实际上会导致不同的结果。我敢肯定有是办法将它们结合起来，但这意味着重建整个程序，和我想象它实际上会更长。

— hakr14

4

珀斯39

Vtu+Gs>2G99U2|+*!%N2"Fibo"*!%N3"Nacci"N

与标准的fizzbuzz解决方案非常相似，只是带有一个斐波那契数字的生成器。

在这里尝试

— 弗莱姆·埃格曼
source

4

C＃，498个 392 320字节

我只是真的想用linq做到这一点，太糟糕了，我不得不为BigInteger编写自己的sum函数，这真的杀死了它:-(

using System.Linq;using System.Numerics;using System.Collections.Generic;static class a{static void Main(){var f=new List<BigInteger>(){1,1};while(f.Count<100)f.Add(f.Skip(f.Count-2).Take(2).Aggregate((a,b)=>b+a));f.ForEach(x=>{System.Console.WriteLine(x%6==0?"FiboNacci":x%2==0?"Fibo":x%3==0?"Nacci":x.ToString());});}}

取消高尔夫：

using System.Linq;
using System.Numerics;
using System.Collections.Generic;
static class a
{
    static void Main()
    {
        var f=new List<BigInteger>(){1,1};
        while(f.Count<100)
            f.Add(f.Skip(f.Count-2).Take(2).Aggregate((a,b)=>b+a));
        f.ForEach(x=>
        {
            System.Console.WriteLine(x%6==0?"FiboNacci":x%2==0?"Fibo":x%3==0?"Nacci":x.ToString());
        });
    }
}

编辑：少了320个字节，这要归功于LegionMammal978的总体建议，也感谢olegz的C＃回答了X％2 && x％3的x％6速记以及在单个WriteLine语句中使用三元运算符。

— Jakotheshadows
source

4

您听说过AggregateLINQ功能吗？

— LegionMammal978

将“ sum”替换为“ t”以剃除6个字节。

— Xantix

3

Python 2 171个 121字节

“暴力法”。

a=[1,1]
print 1
for _ in"q"*99:print[a[1],"Fibo","Nacci","FiboNacci"][a.append(a.pop(0)+a[0])or(1-a[0]%2)+(a[0]%3<1)*2]

— 汉尼斯·卡皮拉（Hannes Karppila）
source

3

Javascript，93 90 86字节

for(a=0,b=1,i=100;i--;a=[b,b=a+b][0])console.log((b%2?'':'Fibo')+(b%3?'':'Nacci')||b)

— 妮娜·斯科茨（Nina Scholz）
source

1

通过更改a=[b,b=a+b][0]为，您可以节省四个字节b=a+b,a=b-a。另外，在一个完全不相关的笔记中，我喜欢您的回答方式，就像在Stack Overflow中一样快，嘿，祝你有美好的一天

— Piyin

2

Python 2，100字节

x=[1,1]
exec"x+=[x[-1]+x[-2]];"*98
print"\n".join(["Fibo"*(i%2==0)+"Nacci"*(i%3==0)or`i`for i in x])

对于较大的数字，L在末尾添加a 表示它是一个长数字。

如果这是一个问题，这是一个104字节的解决方案

x=[1,1]
exec"x+=[x[-1]+x[-2]];"*98
print"\n".join(["Fibo"*(i%2==0)+"Nacci"*(i%3==0)or str(i)for i in x])

— 蓝色
source

您可以for使用以下提示缩短循环时间：codegolf.stackexchange.com/a/5047/42736。特别是exec尖端看起来不错。

— J Atkin

+1 exec <program_string>*n。真好！

— agtoever

2

使用Javascript（ES6），137个 134字节

g=x=>(a=[1,1],f=(x)=>(a[x]=y=a[x-1]+a[x-2],(y%2&&y%3?y:(!(y%2)?'Fibo':'')+(!(y%3)?'Nacci':''))+'\n'+((++x<99)?f(x):'')),'1\n1\n'+f(2))

计算fibonnacci的递归函数，将其放入数组中，然后输出Fibo，Nacci或数字，并调用自身进行下一个计算，直到100。

由于javascript Number的精度，它在73处中断。解决该问题的唯一方法是添加我自己的位计算。

— 纳瓦克
source

这是行不通的，5527939700884757 + 8944394323791464 = 14472334024676220在应有的情况下它会出错，14472334024676221因为JavaScript使用16位精度的浮点数，并且需要17位精度。您还应该打印1两次。

— 乔治·瑞斯

两次添加打印1。为了提高精度，我需要更改代码上的所有内容以使其正常工作（不使用Number而是使用Uint32Array并逐位进行计算）

— Naouak

2

QBasic中，144个 141字节

并不是特别小，但是它击败了C ++和C＃

r=1:FOR i=1 TO 046:a$="":q=p+r
IF q MOD 2=0 THEN a$="Fibo"
IF q MOD 3=0 THEN a$=a$+"Nacci"
IF a$="" THEN a$=STR$(q)
PRINT a$:r=p:p=q:NEXT

没有声明，请:尽可能使用它，因为它比便宜1个字节CRLF。在循环计数器前面加一个0：Basic将在第47个斐波那契字符上溢出，因此补偿了应该存在的额外字节。

编辑：尼尔救了我3个字节：141个字节。

— 施滕伯格
source

您可以删除第一个，a$+因为此时已知它是空字符串。

— 尼尔

2

Wolfram语言，84个字节

当然是因为内置的，所以有点作弊Fibonacci。

t=Fibonacci@Range@100;g=(t[[#;;;;#]]=#2)&;g[3,Fibo]g[4,Nacci]g[12,FiboNacci]Print/@t

运行脚本的示例命令

/Applications/Mathematica.app/Contents/MacOS/WolframKernel -script ~/Desktop/fibo.wl

— 雅各布·阿克博姆
source

2

Perl，74个字节

map{print+(Fibo)[$_%2].(Nacci)[$_%3]||$_ for$a+=$b||1,$b+=$a}1..50

需要以下命令行选项：-lMbigint，计数为8。

样品用量

$ perl -lMbigint fibo-nacci.pl

Perl，79个字节

use bigint;map{print+(Fibo)[$_%2].(Nacci)[$_%3]||$_,$/for$a+=$b||1,$b+=$a}1..50

与上面相同，不需要任何命令行选项。

— 原始
source

2

GolfScript，47个字节

100,{1.@{.@+}*;..2%!'Fibo'*\3%!'Nacci'*+\or}%n*

说明

100,            # push 0..99
{               # map
  1.@           # push 1 twice, rotate counting var to the top
  {             # apply that many times
    .@+         # copy the top, rotate and add
                # if the stack is [a b], this produces: [a b b] -> [b b a] -> [b b+a]
  }*
  ;..           # discard the top, duplicate twice
  2%!'Fibo'*\   # divisible by 2 ? 'Fibo' : ''
  3%!'Nacci'*   # divisible by 3 ? 'Nacci' : ''
  +\or          # concatenate, if empty use the numeric value instead
}%
n*              # join all with a newline

— 原始
source

2

PARI / GP，76 73字节

保存了三个字节，由Mitch Schwartz提供。

for(n=b=!a=1,99,b=a+a=b;print(if(b%2,"",Fibo)if(b%3,if(b%2,b,""),Nacci)))

样品用量

$ gp -qf < fibo-nacci.gp

— 原始
source

1

较短的是不使用内置的。我得到73分for(i=b=!a=1,99,b=a+a=b; ...

— 米奇·施瓦茨

1

@MitchSchwartz它曾经被称为fibo;）

— primo

2

> <>，128个 119字节

111&v       >:3%0=?v>  v
?;ao>:2%0=?v :3%0=?v :n>:}+&:1+&aa*=
            ^oooo < ^ooooo <
           >"obiF"^>"iccaN"^

我~~无耻地偷了~~借来的现有程序FizzBuzz程序，并对其进行了修改以使其适用于Fibo Nacci序列。~~它永远输出数字。~~现在已固定，即仅输出100个数字。在这里尝试。

— 丹·曼
source

2

您只能输出前100个Fibo Nacci数字，不能多于或少。

— Kritixi Lithos 2015年

@ΚριτικσιΛίθος我终于设法使它仅输出100个数字。

— DanTheMan

这会在TIO上输出101个数字，但在链接的站点上不起作用

— Jo King

1

Pyth，51个字节

V.Wn100lHaZ+@Z_1@Z_2[1 1)|+*"Fibo"}2JPN*"Nacci"}3JN

生成斐波那契数列，然后决定要打印的内容。

                    [1 1)                           - H = [1,1]
  Wn100lH                                           - While len(H)!=100 
         aZ+@Z_1@Z_2                                - H.append(H[-1]+H[-2])
V.                                                  - For N in H:
                                    JPN             - Set J to the prime factorization of H
                           *"Fibo"}2J               - If there is a 2 in the factorization, add "Fibo" to a string
                                       *"Nacci"}3J  - If there is a 3 in the factorization, add "Nacci" to a string
                          +                         - Join them together
                         |                        N - If the string isn't empty (If it isn't divisible by 2 or 3), print N
                                                    - Else print the string

要测试，请尝试此操作（仅前20个数字有效）

V.Wn20lHaZ+@Z_1@Z_2[1 1)|+*"Fibo"}2JPN*"Nacci"}3JN

— 蓝色
source

运行实际程序需要多长时间？

— Kritixi Lithos 2015年

我不知道，花了30秒钟才得出结论，计算出如此大的素因分解可能会大大降低它的速度。

— 2015年

1

Clojure，127个字节

(def f(lazy-cat[1 1](map +' f(rest f))))(doseq[x(take 100 f)](println(str(if(even? x)'Fibo)({0'Nacci}(mod x 3)(if(odd? x)x)))))

取消高尔夫：

(def fib (lazy-cat [1 1] (map +' fib (rest fib))))

(doseq [x (take 100 fib)]
  (println (str (if (even? x) 'Fibo)
                ({0 'Nacci}
                 (mod x 3)
                 (if (odd? x) x)))))

使用了一些技巧：

def给出斐波那契数列本身的很少的东西是从Konrad Garus偷偷偷走的。
str可以将符号作为输入。疯狂吧？
if在某些情况下，映射和默认值是最短的写方法。

— 山姆·埃斯特普（Sam Estep）
source

什么lazy-cat啊

— Kritixi Lithos

@ΚριτικσιΛίθος它懒散地连接多个序列。在这种情况下，它将Fibonacci序列（[1 1]）的前两个元素连接在一起，其结果是将Fibonacci序列中的每个元素与其后的元素相加。

— Sam Estep 2015年

我猜对了，这基本上是Clojure的版本fibs = 0 : 1 : zipWith (+) fibs (tail fibs)吗？

— Soham Chowdhury 2015年

@SohamChowdhury是的，据我所知。

— 山姆Estep 2015年

1

CJam，44个字节

XX{_2$+}98*]{_B4bf%:!"Fibo Nacci"S/.*s\e|N}/

在CJam解释器中在线尝试。

— 丹尼斯
source

1

dc，100 89 79字节

[sG[]]sx[dn]s01df[sbdlb+lbrdd2%d[Fibo]r0!=xnr3%d[Nacci]r0!=xn*0!=0APzZ3>o]dsox

受到http://c2.com/cgi/wiki的启发吗？

— 用户名
source

欢迎来到编程难题和代码高尔夫球！

— 丹尼斯

1

Javascript（ES2015），99个字节

f=n=>n<3?1:f(n-1)+f(n-2);for(i=0;i<100;)console.log((f(++i)%2?'':'Fibo')+(f(i)%3?'':'Nacci')||f(i))

取消高尔夫：

// fibonacci function
var fibonacci = (n) => n < 3 ? 1 : fibonacci(n-1) + fibonacci(n-2) // (implicit return)

for (var i = 0; i<100;) {
  var output = fibonacci(++i) % 2 !== 0 ? '' : 'Fibo';
  output += fibonacci(i) % 3 !== 0 ? '' : 'Nacci';
  console.log(output || fibonacci(i));
}

— 塞巴斯蒂安·桑德奎斯特（Sebastian Sandqvist）
source

使用alert代替console.log; 它减少了一些字节。

— Kritixi Lithos

1

F＃，202个163 149字节

Seq.unfold(fun(a,b)->printfn"%s"(a%6m|>function|0m->"FiboNacci"|2m|4m->"Fibo"|3m->"Nacci"|_->string a);Some(1,(b,a+b)))(1m,1m)|>Seq.take 100|>Seq.sum

这是一个FSX（F＃脚本）文件

— 奥列格兹
source

我对此工作感到惊讶

— -asibahi

1

PHP，75字节

<?for(;4e20>$b=bcadd($a,$a=$b)?:1;)echo[Fibo][++$i%3].[Nacci][$i%4]?:$b,~õ;

令人惊讶的竞争力。Requres PHP v5.5或更高版本。我采用默认设置，因为它们没有.ini（您可以使用该-n选项禁用本地.ini ）。

样品用量

$ php -n fibo-nacci.php

— 原始
source

用-n bcadd时甚至不工作bcmath装的。-n stderr上没有很多东西输出。

— Sylwester

在我的盒子上工作。

— primo

1

Prolog，182字节

f(A,B,X):-X<100,C is A+B,Z is X+1,(Y is B mod 6,Y=0->writeln('FiboNacci');(Y is B mod 2,Y=0->writeln('Fibo');(Y is B mod 3,Y=0->writeln('Nacci');writeln(B)))),f(B,C,Z).
p:-f(0,1,0).

在此处在线尝试
运行该程序，请使用查询：

p.

— 艾米尼亚
source

斐波那契+嘶嘶声=斐波那契！

您的挑战是创建Fibo Nacci程序！

规则

目录

Pyth，37个字节

Python 2，62个字节

C ++ 11元编程，348字节

C＃，175171152145字节

Oracle SQL，212字节

ShapeScript，83个字节

Java中，407个 398 351 308字节

Mathematica，80个字节

Ruby，71 66字节

松散

> <>，116字节

珀斯39

C＃，498个 392 320字节

Python 2 171个 121字节

Javascript，93 90 86字节

Python 2，100字节

使用Javascript（ES6），137个 134字节

QBasic中，144个 141字节

Wolfram语言，84个字节

Perl，74个字节

GolfScript，47个字节

PARI / GP，76 73字节

> <>，128个 119字节

Pyth，51个字节

Clojure，127个字节

CJam，44个字节

dc，100 89 79字节

Javascript（ES2015），99个字节

F＃，202个163 149字节

PHP，75字节

Prolog，182字节