text:
Fibonacci + Fizz Buzz = Fibo Nacci!
Fibonacci + FizzBuzz = Fibo Nacci!

Your challenge is to create a Fibo Nacci program!

A Fibo Nacci program outputs the first 100 Fibonacci numbers (starting from 1).
If the Fibonacci number is divisible by both 2 and 3 (i.e. it is divisible by 6), then output FiboNacci instead of the number.
Otherwise, if the Fibonacci number is divisible by 2, then output Fibo instead of the number.
Otherwise, if the Fibonacci number is divisible by 3, then output Nacci instead of the number.

Rules

The program should take no input.
The program should output a new line (\n) after every entry.
The program should not print anything to STDERR.
The program must output the first 100 Fibo Nacci entries (starting from 1).
Standard loopholes are not allowed (by default).
This is code-golf so shortest code in bytes wins!

Here is the expected output:
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

The Catalogue
The Snack Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

/* 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 = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });

    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(''+lang+'').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;
}

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

What about languages with highest integer type of only 64 bits? :( Isn't 90 fib. numbers enough?

@Zereges In that matter, I am sorry. :(

Do you mean "at least 100"? Or is printing more than 100 not allowed?

Maybe it should be called "Fizzo Nacci"

@mbomb007 Where is the "at least"?

@ΚριτικσιΛίθος It never says "at least". I think the point of the question is if it would be allowed to print more than 100 Fibo Nacci numbers.

@DanTheMan The program should only output the first 100 Fibo Nacci numbers, no more, no less.

Would be a much better question if it only required native int support :(

@SztupY If I were to make a change now, everyone else's answers would have to change to just the first 80 or 90 numbers.

@SztupY Because the output in this question is completely invariant, you don't even need integers at all. Just treat this question as a [tag:kolmogorov-complexity] question (I even added the tag) and go from there.

@ChrisJester-Young it's still an unnecessarry limitation, that might make creative implementators steer clear of this task. And most of the solutions (including the 2nd most upvoted one) are breaking already

:( @ approx-66-bit int requirement

Fibo Nazi (lol)

Math comment: every third Fibonacci number is even, and every fourth Fibonacci number is a multiple of 3. This might lead to alternate coding strategies, which don't require testing divisibility.

Related

Pyth, 37 bytes
I loop through the Fibonacci numbers instead of generating them beforehand, since it's really short to do.
K1V100|+*"Fibo"!%=+Z~KZ2*"Nacci"!%Z3Z

Try it online.

Congratulations for winning this challenge! I liked that this solution was fast.

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

Not much different from the standard FizzBuzz, really.

This is amazing.

I need to remember this looping construct for my next Ruby golf. This is amazing.

C++11 metaprogramming, 348 bytes
#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;}

Because, why not. It compiles with warning C4307: '+': integral constant overflow, runs fine, but 93+ th Fibonacci numbers are not shown correctly (due to overflow), so this is invalid entry (but I could not win it with that much of bytes though)
Ungolfed
#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;
}

You could use exploded strings (template <char H, char ...T>) in your templates to (theoretically) handle arbitrary-length values. Then it would just be a matter of examining the last 2 characters in each string to determine divisibility by 2 and/or 3.

@Mego I do not understand you. How it would help me to handle values, which do not fit into 64 bits. Also, You need all digits to find out if the number is divisible by 3.

Strings can be arbitrarily long (until you run out of memory). And you're right, I messed up my comment. Still, you could compute the digital sum to determine divisibility by 3.

@Mego Implementing addition of those strings would require much more effort.

Perhaps, but at least it would be a valid entry.

You could use the gnu dialect and use __uint128_t, maybe.

C#, 175 171 152 145 bytes
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");}}

Uncompressed:
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");
    }
}

Even compressing the output with a DeflateStream the lowest I could get was 191 chars so this is likely very close to the best possible c# answer. A shame BigInteger is required.

"using System;" will give another -1 in size.

I still had to prefix System.Numerics with System despite the using :-S, so I'm not sure the using will work.

Yes, the same here (under Mono) :(

Another trick to make it 3 bytes shorter

You can save 3 characters by replacing the ==0s with >0 and inverting the ternaries: 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");}}

That's a great idea! Let me check

You can save another 7 characters by changing decimal a=1,b=1 to dynamic a=1m,b=a and then you can lose the (object) :)

Great, @Timwi! That gonna be final word.

Using dynamic is pretty clever

Oracle SQL, 212 bytes
Not a golfing language but I had to try...
Concatenating all the rows with \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
Or with one entry from the sequence per row (162 bytes):
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

Awesome, just for using SQL

Just use the last one, since it is the "equivalent" to outputting "per line". And it really is a fine piece of code. Well done!

@IsmaelMiguel If it's run in SQL*Plus (or another command line interface) then there will be a newline output after each row (as part of how it reports the query output). However, that is a function of the CLI and not the SQL language - to be compliant with the rule The program should output a new line (\n) after every entry I'll leave it as the longer code but the shorter one could be made compliant (without relying on a CLI) by adding ||CHR(13) before the final FROM for 171 chracters.

Couldn't you use "\n"? Seems to work on MySQL. (Running select length("\n") returns 1, and running select "\n" doesn't return n, as with select "\p" returns p due to being an invalid escape)

SELECT LENGTH('\n') FROM DUAL outputs 2 in Oracle as '\n' does not get converted to CHR(13).

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

Try it online!

Literally looks like my cat jumped on top of my keyboard while I tried to turn on sticky keys. Nice job.

@phase figuratively. Either that or you're not looking too closely. Or you have a tiny cat or a giant keyboard. Because this cat managed to type Fibo and Nacci but otherwise avoid all letter keys save for one r.

@JanDvorak I think phase has macros setup for that ;)

@phase 1. Why is your cat in your room?; 2. why would you want to turn on sticky keys? 3? Why do you not have a cat trap box on your desk to avoid your cat jumping on your keyboard?

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

Adaptation of my older FizzBuzz solution.

@JacobAkkerboom Sorry, fixed. Also, for versions less than 10.3, replace Echo with Print.

Java, 407 398 351 308 bytes
Golfed it with help from @Geobits and @SamYonnou
Spread the word: 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);}}}

Ungolfed version:
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);
    }
  }
}

This can be golfed more. Import java.math.* instead of the whole thing. Use the constants for ONE and ZERO instead of new BigIntegers. Remove the public from the class. Pack everything except the println statement in the for body inside the loop declaration, etc. I recommend looking over the Java golfing tips in general.

@Geobits Done! 'Twas a pity that I was unfamiliar with BigInteger and its various golfing techniques.

Storing BigInteger.ZERO, using flipBit(...) as an alternative to new BigInteger(...), and some other minor things you can get it down to 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);}}}

Looks like BigInteger always returns BigInteger.ZERO when some operation like add(...) evaluates to zero so you can use == instead of .equals(z), also you can do away with storing s=t.flipBit(2) (6) and instead do some clever inner assignment like so: 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);}}} these changes get it down to 280

Oh and for the same reason you can use == for comparing to zero you can use it for the inner assignment bit and replace (c=b.mod(t)).add(d=b.mod(h))==z with (c=b.mod(t))==(d=b.mod(h)) bringing the total length to 275

Take advantage of the Properties of the Fibonacci numbers and you can do it with 42 chars less:
Remove the variable z and change the println to
System.out.println(i%12==0?"FiboNacci":i%3==0?"Fibo":i%4==0?"Nacci":b);
https://en.wikipedia.org/wiki/Fibonacci_number#Primes_and_divisibility

@FabianTschachtli The % cannot be used on a BigInteger. That is why I use the .mod() function.

@Sock Notice that he is using % on i, not the BigInteger. For Fibonacci numbers the divisibility of the number is related to divisibility of the index in the sequence, see the WP link.

interface a{static void ....

I think you mean Verbose.isEqualTo(Java)

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

ungolfed:
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
}

I've worked on this for longer than I'd like to admin and can't find any way to improve it. f,n=%w[Fibo Nacci],f,n='Fibbo','Nacci' and f='Fibbo';n='Nacci' all have the same character count. +1

You can save three bytes by using [b,f='Fibo',n='Nacci',f,b,f+n][~b%6], and two more by removing the parentheses in a=b+b=a.

Thank you @primo. That is a neat trick with the ~ operator. Never seen it before. And now I know why negative indexes are part of ruby:)

Really need puts [ instead of puts[?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ yes. puts[...][...] groups as (puts[...])[...] rater than puts([...][...])

Roses are red, Violets are blue, for Haskell and Ruby, I have no clue.

I love the symmetry in a=b+b=a

><>, 116 bytes
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^

Try it online!

Welcome to the site! :)

You could probably combine both the 3% sections

@JoKing You'd think so, but they actually lead to different outcomes if n%3!=0. I'm sure there is a way to combine them, but it would mean restructuring the entire program, and I imagine it would actually be longer.

C#, 498 392 320 bytes
I just really wanted to do this with linq, too bad I had to write my own sum function for BigInteger that really killed it :-(
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());});}}

Ungolfed:
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());
        });
    }
}

Edit: Down to 320 bytes thanks to LegionMammal978 for the aggregate suggestion and thanks to olegz's C# answer for the x%6 shorthand for X%2 && x%3 as well as the use of ternary operators in a single WriteLine statement.

Have you heard of the Aggregate LINQ function?

Replace "sum" with "t" to shave 6 bytes.

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

Very similar to the standard fizzbuzz solution, just with a generator for the Fibonacci numbers.
Try it here

Python 2, 171 121 bytes
"Brute force approach."
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]

Python 2, 100 bytes
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])

For the large numbers, adds a L to the end showing it's a long number.
If that's a problem, here is a 104 byte solution
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])

You can shorten the for loop using this tip: http://codegolf.stackexchange.com/a/5047/42736. In particular the exec tip looks good.

+1 for the exec <program_string>*n trick. Nice!

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

You could save four bytes by changing a=[b,b=a+b][0] to b=a+b,a=b-a. Also, in a completely unrelated note, I like the way you answer like really fast in Stack Overflow hehe Have a nice day

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

I shamelessly stole borrowed an existing program FizzBuzz program and modified it to work for the Fibo Nacci sequence. It outputs numbers forever. Now it is fixed, i.e. it only outputs 100 numbers. Try it here.

You must only output the first 100 Fibo Nacci numbers, no more, no less.

@ΚριτικσιΛίθος I finally got around to making it only output 100 numbers.

This outputs 101 numbers on TIO but doesn't work at the linked site

Javascript(ES6), 137 134 bytes
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))

Recursive function that calculates fibonnacci, put it in an array then output Fibo,Nacci or the number and call itself to calculate next until 100.
It breaks at 73 because of javascript Number precision. Only way to get around that would be to add my own bit calculation.

This doesn't work, it goes wrong after 5527939700884757 + 8944394323791464 = 14472334024676220 when it should be 14472334024676221 because JavaScript uses 16 bit precision floats and that requires 17 bits of precision. You should also print 1 twice.

Added the print 1 twice. For the precision, I need to change everythin on the code to make it work (not using Number but Uint32Array and doing computation bits by bits)

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

Requires the following command line option: -lMbigint, counted as 8.

Sample Usage
$ perl -lMbigint fibo-nacci.pl

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

Same as above, without requiring any command line options.

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

Explanation
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

PARI/GP, 76 73 bytes
Saved three bytes courtesy of 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)))

Sample Usage
$ gp -qf < fibo-nacci.gp

It's shorter not to use built-in; I got 73 with for(i=b=!a=1,99,b=a+a=b; ...

@MitchSchwartz it used to be called fibo ;)

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

Inspired by http://c2.com/cgi/wiki?DeeCee

Welcome to Programming Puzzles & Code Golf!

Wolfram Language, 84 bytes
Kind of cheating of course, because of the built in Fibonacci.
t=Fibonacci@Range@100;g=(t[[#;;;;#]]=#2)&;g[3,Fibo]g[4,Nacci]g[12,FiboNacci]Print/@t

Example command to run the script
/Applications/Mathematica.app/Contents/MacOS/WolframKernel -script ~/Desktop/fibo.wl

05AB1E, 29 bytes
тENÅfDÑ23SÃvá.•iÑ+FÌ;•™#yèJ},

Inspired by @Grimmy's bottom answer of the 1, 2, Fizz, 4, Buzz challenge (doesn't work in the legacy version with S removed, because there is a bug in the compressed string .•iÑ+FÌ;•; the compiler probably thinks there is an open if/loop block due to the i/F..).
Try it online.
Explanation:
тE                # Loop `N` in the range [1,100]:
  NÅf             #  Get the N'th Fibonacci number
     D            #  Duplicate it
      Ñ           #  Pop this copy, and push a list of its divisors
       23SÃ       #  Only keep the divisors [2,3]
 v                #  Inner loop over those remaining divisors (or not if none are left):
  á               #   Only leave the letters of the current top of the stack
                  #   (to get rid of the Fibonacci number that was still on the stack)
   .•iÑ+FÌ;•      #   Push compressed string "fibo nacci"
            ™     #   Titlecase each: "Fibo Nacci"
             #    #   Split it on spaces: ["Fibo","Nacci"]
              yè  #   Index the current divisor `y` into it (0-based and with wraparound,
                  #   so 2 will index into "Fibo" and 3 into "Nacci")
                J #   Join everything on the stack together
 },               #  After the inner loop: pop and print the top with trailing newline

See this 05AB1E tip of mine (section How to compress strings not part of the dictionary?) to understand why .•iÑ+FÌ;• is "fibo nacci".

Vyxal j, 21 bytes
ÞF₁Ẏƛ₍₂₃«-∇j€₌p«⌈ǐ*∑∴

Try it Online!
Basically the same as the standard 11 byte FizzBuzz with a few changes
Explained
ÞF₁Ẏƛ₍₂₃«-∇j€₌p«⌈ǐ*∑∴
ÞF₁Ẏ                  # The first 100 fibonacci numbers
    ƛ                 # to each item n:
     ₍₂₃              #   push a list [n % 2 == 0, n % 3 == 0]
        «-∇j€₌p«      #   push the string "fibo nacci"
                ⌈ǐ    #   split on spaces and titlecase each
                  *∑  #   vectorised string multiply and sum - this is like writing way of writing ("Fibo" * (n % 2 == 0) + "Naci" * (n % 3 == 0))
                    ∴ #   choose the greatest of n and that string. A number will always be greater than an empty string, and a non-empty string will always be greater than a number
                      # Just like the standard fizzbuzz, the `j` flag joins on newlines

Haskell, 150 143 126 118 bytes
main=putStr.unlines.take 100$0!1
x!y=d 3"Nacci"(d 2"Fibo"id)(show y):y!(x+y) where d z a f b|mod y z>0=f b|1>0=f""++a

ungolfed:
    main =
      putStr . unlines . take 100 $ f 0 1
    f x y
      = d 3 "Nacci" (d 2 "Fibo" id) (show y) : f y (x+y)
      where
        d z a g b
          | mod y z > 0 = g b
          | otherwise   = g "" ++ a

Why ;  instead of ;?

Oups, missed that one byte @LeifWillerts :).

Well, seems like that "inspired" to improve much more :)

What does d do?

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

Generates the Fibonacci sequence then decides what to print.
                    [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

To test, try this (only does the first 20 numbers)
V.Wn20lHaZ+@Z_1@Z_2[1 1)|+*"Fibo"}2JPN*"Nacci"}3JN

How long does it take to run the actual program?

I have no idea, it didn't in the 30 seconds  it took to work out that working out such large prime factorizations would probably slow it down a lot.

QBasic, 144 141 bytes
Not particularly small, but it beats C++ and 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

No declarations, used the : wherever possible because it's 1 byte cheaper than CRLF. Prefixed a 0 to the loop counter: Basic will overflow on the 47th Fibonacci character, so compensated for the extra byte that should be there.
EDIT: Neil saved me 3 bytes: 141 bytes.

You can remove the first a$+ since it's known to be the empty string at this point.

Clojure, 127 bytes
(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)))))

Ungolfed:
(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)))))

Some tricks used:

That pretty little def that gives the Fibonacci sequence itself is stolen shamelessly from Konrad Garus.
str can take symbols as input. Crazy, right?
Maps and default values are the shortest way to write if in some cases.

What is lazy-cat?

@ΚριτικσιΛίθος It lazily concatenates multiple sequences. In this case, it concatenates the first two elements of the Fibonacci sequence ([1 1]) with the result of summing each element in the Fibonacci sequence with the element following it.

Am I right in guessing that this is basically the Clojure version of fibs = 0 : 1 : zipWith (+) fibs (tail fibs)?

@SohamChowdhury Yes, as far as I can tell.

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

Try it online in the CJam interpreter.

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

Surpisingly competitive. Requres PHP v5.5 or higher. I assume default settings, as they are without an .ini (you may disable your local .ini with the -n option).

Sample Usage
$ php -n fibo-nacci.php

WIth -n bcadd doesn't work even when bcmath is installed. Without -n  lots of stuff is output on stderr.

Works on my box(es).

Javascript (ES6), 117 108 bytes
let s=[1,1],i;for(i=1;i<101;s[++i]=s[i-1]+s[i-2]);s.map(n=>console.log((n%2?"":"Fibo")+(n%3?"":"Nacci")||n))

Try it online here.
Sadly this breaks after the 77th number, because Javascript doesn't support numbers that high.  I think this is still cool enough to warrant an answer, though.
It generates the entire range of numbers, then iterates with map to print out the appropriate string.
Takes advantage of the fact that console.log prints on a new line.  Could also use alert, but that's more annoying.

F#, 202 163 149 bytes
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

This is an FSX (F# script) file

I am surprised that this works

><>, 78 bytes
01:n0\oo~o'F0ibo'\
aa:+1<}[3rn?/!?%3\!?%2:::::+}:}oa;?=*
ooooo'Nacci'/
00$0o\.

Try it online!

Python 3, 100 94 88 bytes
a,b=0,1
exec("print(f\"{''if b%2else'Fibo'}{''if b%3else'Nacci'}\"or b);a,b=b,a+b;"*100)

Try it online!

JavaScript, 82 78 bytes
-4 bytes thanks to xigio
for(n=a=b=1;n++n<102;b=a+(a=b))alert((a%2n?'':'Fibo')+(a%3n?'':'Nacci')||a+'')

Uses JavaScript's BigInt (not supported in IE) to get to get all the way up to 100.

78 bytes: for(n=a=b=1n;++n<102;b=a+(a=b))alert((a%2n?'':'Fibo')+(a%3n?'':'Nacci')||a+'')

@xigoi Duh, I should've seen that... I had all the parts right there

Javascript ES6 112 bytes
var f=(a,b,c)=>{if(!(99<c)){var d=a%2?"":"Fibo",e=a%3?"":"Nacci";console.log(d||e?d+e:n);f(b,a+b,c+1)}};f(1,1,0)

As with other JS answers, fails after 73rd number because of js use of floats

Why var? You can save 8 bytes omitting it, making globals instead. There is no consensus saying that functions can't create globals. Also, you can omit f=, making an anonymous function, saving another -2 bytes. Final save: -10 bytes Final size: 102 bytes

Perl, 146 Bytes
use bigint;$a=$b=1;for$i(0..99){$l=($a%2==0?2:0)+($a%3==0?1:0);print$a if$l==0;print"Fibo"if$l&2;print"Nacci"if$l&1;print"\n";($a,$b)=($b,$a+$b);}

Uncompressed:
#!/usr/bin/perl
use bigint;
$a=$b=1;
for$i(0..99) {
    $l=($a%2==0?2:0)+($a%3==0?1:0);
    print $a if $l == 0;
    print "Fibo" if $l & 2;
    print "Nacci" if $l & 1;
    print "\n";
    ($a,$b)=($b,$a+$b);
}

old version with 156 bytes...
use bigint;$a=$b=1;for$i(0..99){if($a%2==0){print"Fibo";print($a%3==0?"Nacci\n":"\n");}elsif($a%3==0){print"Nacci\n";}else{print"$a\n";}($a,$b)=($b,$a+$b);}

Uncompressed:
#!/usr/bin/perl
use bigint;
$a=$b=1;
for $i (0..99) {
    if($a%2 == 0) {
        print "Fibo";
        print ($a%3 == 0 ? "Nacci\n" : "\n");
    } elsif($a%3 == 0) {
        print "Nacci\n";
    } else {
        print "$a\n";
    }
    ($a,$b)=($b,$a+$b);
}

C, 121 bytes
Had to go full __int128_t for this to work. printf doesn't know how to handle a 128bit integer, so the last four numeric values will be printed wrong. Still, it was fun to code, so here you go:
__int128_t a,b=1,c;i=100;main(){while(i--){c=b;b%=6;printf(b?b%2?b-3?"%lu\n":"Nacci\n":"Fibo\n":"FiboNacci\n",c);b=c+a;a=c;}}

compiled with gcc-4.8 fibo.c on x86_64.

while is always longer than or as long as for.

Prolog, 182 bytes
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).

Try it out online here
To run the program, use the query:
p.

Javascript, 157 155 bytes
Golfed:
function g(n){a=!n%2;b=!n%3;a&&b?return "FiboNacci":;b?return "Nacci";a?return "Fibo";return n==1||n==2?1:f(n-1)+f(n-2)}for(n=100;n++>0;)console.log(f(n))

Ungolfed:
function fibonacci(n){
  if(n==1||n==2) return 1;
  return(fibonacci(n-1)+fibonacci(n-2));
}
function fibonacci2(n){
  a=!(n%2);
  b=!(n%3);
  if(a&&b) return "FiboNacci";
  if(a) return "Fibo";
  if(b) return "Nacci";
  return fibonacci(n);
}
for(n=100;n++>0;) console.log(fibonacci2(n));

Saved 3 bytes thanks to Cows Quack's comment

Thanks! By the way, why is there a minimum comment length?

There is a minimum comment length to prevent comments like "Good Job!" or "+1" and stuff like that.

@ΚριτικσιΛίθος Why is there also a minimum amount of reputation to be able to post comments then?

Change your for-loop to for(n=100;n++>0;)console.log(f(n)) It saves 3 bytes

@ΚριτικσιΛίθος OK, thanks. Editing post.

I am unable to run this, I get a syntax error

Javascript (ES2015), 99 bytes
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))

Ungolfed:
// 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));
}

Use alert instead of console.log; it shaves off some bytes.

Python 3, 137 bytes
Fun question with lots of new things I learnt in doing it. Python3 isn't a golfing language, but I suppose this isn't too bad
f=lambda n:n if n<2 else f(n-2)+f(n-1)
for n in range(100):t=f(-~n);x="Fibo"*(t%2==0)+"Nacci"*(t%3==0);print(x if t%2==0 or t%3==0 else t)

Hardest part was just to get it to only print the number
First line calculates the nth fib number. Second line joins Fibo and Nacci if it fits the rules an then it prints that string if it should else print the nth fib number.

2else instead of 2 else for -1 byte, n+1 instead of -~n because -~n is unneeded, t%2<1 instead of t%2==0 for -1 byte, t%3<1 instead of t%3==0 for -1 byte, t%2<1or t%3<1else instead of t%2==0 or t%3==0 else for -4 bytes. Total save: -7 bytes.

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

Perl6, 59 58
say "Fibo"x$_%%2~"Nacci"x$_%%3||$_ for (1,1,*+*...*)[^100]

F#, 153 134 bytes
let rec L c n p=printfn"%s"(c%6m|>function|0m->"FiboNacci"|2m|4m->"Fibo"|3m->"Nacci"|_->string c);if n<100 then L(p+c)(n+1)c
L 1I 1 0I

Edit: Used decimal instead of bigint which allowed using pattern matching. Stole the internal logic from the other F# answer. My older filtering logic is in the below snippets.
One liner, same logic, 155 bytes:
let rec L c n p=printfn"%s"(if c%6I=0I then"FiboNacci"elif c%2I=0I then"Fibo"elif c%3I=0I then"Nacci"else string c);if n<100 then L(p+c)(n+1)c in L 1I 1 0I

Different logic, 168 bytes:
Seq.unfold(fun(p,c)->Some((if c%6I=0I then"FiboNacci"elif c%2I=0I then"Fibo"elif c%3I=0I then"Nacci"else string c),(c,c+p)))(0I,1I)|>Seq.take 100|>Seq.iter(printfn"%s")

Swift 5.9, 129 bytes
let f={$0<3 ?1:f($0-UInt64(1))+f($0-2)},m="Fibo",n="Nacci"
for i in 1...30{print(i%12<1 ?m+n:i%3<1 ?m:i%4<1 ?n:"\(f(.init(i)))")}

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Finding sum-free partitions
Executive summary
Given input k, find a partition of integers 1 to n into k sum-free subsets for the largest n you can within 10 minutes.
Background: Schur numbers
A set A is sum-free if its self-sum A + A = { x + y | x, y in A} has no elements in common with it.
For every positive integer k there is a largest integer S(k) such that the set {1, 2, ..., S(k)} can be partitioned into k sum-free subsets. This number is called the kth Schur number (OEIS A045652).
For example, S(2) = 4. We can partition {1, 2, 3, 4} as {1, 4}, {2, 3}, and that is the unique partition into two sum-free subsets, but we can't now add a 5 to either part.
Challenge
Write a deterministic program which does the following:

Take a positive integer k as input
Write the current Unix timestamp to stdout
Outputs a sequence of partitions of 1 to n into k sum-free subsets for increasing n, following each sequence with the current Unix timestamp.

The winner will be the program which prints a partition for the largest n within 10 minutes on my computer when given input 5. Ties will be broken by the quickest time to find a partition for the largest n, averaged over three runs: that's why the output should include timestamps.
Important details:

I have Ubuntu Precise, so if your language is not supported I will be unable to score it.
I have an Intel Core2 Quad CPU, so if you want to use multithreading there's no point using more than 4 threads.
If you want me to use any particular compiler flags or implementation, document that clearly in your answer.
You shall not special-case your code to handle the input 5.
You are not required to output every improvement you find. E.g. for input 2 you could output only the partition for n = 4. However, if you don't output anything in the first 10 minutes then I will score that as n = 0.

Python 3, sort by greatest number, n = 92 121
Thanks to Martin Büttner for a suggestion that unexpectedly improved the maximum n reached.
Last output:
[2, 3, 11, 12, 29, 30, 38, 39, 83, 84, 92, 93, 110, 111, 119, 120]
[1, 4, 10, 13, 28, 31, 37, 40, 82, 85, 91, 94, 109, 112, 118, 121]
[5, 6, 7, 8, 9, 32, 33, 34, 35, 36, 86, 87, 88, 89, 90, 113, 114, 115, 116, 117]
[14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108]
[41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81]

The algorithm is the same as my previous answer, quoted below:

There are k bins that have both the numbers in it so far and the numbers that can't go in it anymore. At each depth in the iteration (it's basically a depth-first search), the bin ordering is shuffled and the next number (nextN) is (sequentially) put into the bins that can take it and then goes one step deeper. If there are none, it returns, backing up one step.

...with one exception: the bin ordering is not shuffled. Instead, it is sorted in such a way that the bins with the greatest number come first. This reached n = 121 in 8 seconds!
Code:
from copy import deepcopy
from random import shuffle, seed
from time import clock, time
global maxN
maxN = 0
clock()

def search(k,nextN=1,sets=None):
    global maxN
    if clock() > 600: return

    if nextN == 1: #first iteration
        sets = []
        for i in range(k):
            sets.append([[],[]])

    sets.sort(key=lambda x:max(x[0]or[0]), reverse=True)
    for i in range(k):
        if clock() > 600: return
        if nextN not in sets[i][1]:
            sets2 = deepcopy(sets)
            sets2[i][0].append(nextN)
            sets2[i][1].extend([nextN+j for j in sets2[i][0]])
            nextN2 = nextN + 1

            if nextN > maxN:
                maxN = nextN
                print("New maximum!",maxN)
                for s in sets2: print(s[0])
                print(time())
                print()

            search(k, nextN2, sets2)

search(5)

Note: sorting by greatest number of allowed numbers within the range of disallowed numbers gives n=59, and sorting by greatest number of allowed numbers less than nextN gives n=64. Sorting by the length of the disallowed numbers list (which may have repeats) leads very quickly to an elegant n=30 pattern.

The output time format isn't correct (should be seconds since the epoch, but I'm seeing Tue Nov 10 00:44:25 2015), but I saw n=92 in less than 2 seconds.

Ah, I figured that the time format wasn't as important as showing exactly how long it took. I'll figure it out and change it though. EDIT: D'oh. I picked ctime over time because the output was prettier when time was exactly what I should've picked.

You know, you could also just sort by greatest number in the bin, because the greatest disallowed number will always be twice that.

@MartinBüttner: ......I...uh...I have no idea how or why, but that gets n=121. o.O

Python 3, 121, < 0.001s
Improved heuristic thanks to Martin Buttner means we don't even need randomness.
Output:
1447152500.9339304
[1, 4, 10, 13, 28, 31, 37, 40, 82, 85, 91, 94, 109, 112, 118, 121]
[2, 3, 11, 12, 29, 30, 38, 39, 83, 84, 92, 93, 110, 111, 119, 120]
[5, 6, 7, 8, 9, 32, 33, 34, 35, 36, 86, 87, 88, 89, 90, 113, 114, 115, 116, 117]
[14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108]
[41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81]
1447152500.934646 121

Code:
from copy import deepcopy
from random import seed, randrange
from time import clock, time
from cProfile import run

n = 5

seed(0)

def heuristic(bucket):
    return len(bucket[0]) and bucket[0][-1]

def search():
    best = 0
    next_add = 1
    old_add = 0
    lists = [[[],set()] for _ in range(n)]
    print(time())
    while clock() < 600 and next_add != old_add:
        old_add = next_add
        lists.sort(key=heuristic, reverse=True)
        for i in range(n):
            if next_add not in lists[i][1]:
                lists[i][0].append(next_add)
                lists[i][1].update([next_add + old for old in lists[i][0]])
                if next_add > best:
                    best = next_add
                next_add += 1
                break

    for l in lists:
        print(l[0])
    print(time(), next_add-1, end='\n\n')

search()

Python 3, 112
Sort by sum of first 2 elements + skew
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79]
[7, 8, 9, 10, 11, 12, 13, 27, 28, 29, 30, 31, 32, 33, 80, 81, 82, 83, 84, 85, 86, 100, 101, 102, 103, 104, 105, 106]
[3, 4, 14, 19, 21, 26, 36, 37, 87, 92, 94, 99, 109, 110]
[2, 5, 16, 17, 20, 23, 24, 35, 38, 89, 90, 96, 97, 108, 111]
[1, 6, 15, 18, 22, 25, 34, 39, 88, 91, 93, 95, 98, 107, 112]
1447137688.032085 138.917074 112

I copied El'endia Starman's data structure, which consists of a list of pairs, where the first element of the pair is the elements in that bucket, and the second is the sums of that bucket.
I start with the same "track what sums are availible" approach. My sorting heuristic is simply the sum of the smallest two elements in a given list. I also add a small random skew to try different possibilities.
Each iteration simply places each the new number in the first avalible bin, similar to random greedy. Once this fails, it simply restarts.
from copy import deepcopy
from random import seed, randrange
from time import clock, time

n = 5

seed(0)

def skew():
    return randrange(9)

best = 0
next_add = old_add = 1
while clock() < 600:
    if next_add == old_add:
        lists = [[[],[]] for _ in range(n)]
        next_add = old_add = 1
    old_add = next_add
    lists.sort(key=lambda x:sum(x[0][:2]) + skew(), reverse=True)
    for i in range(n):
        if next_add not in lists[i][1]:
            lists[i][0].append(next_add)
            lists[i][1].extend([next_add + old for old in lists[i][0]])
            if next_add > best:
                best = next_add
                for l in lists:
                    print(l[0])
                print(time(), clock(), next_add, end='\n\n')
            next_add += 1
            break

Wow, this looks extremely similar to my code. :P ;) (I don't mind at all.)

@El'endiaStarman Credit added. It's a nice basis.

Java 8, n = 142 144
Last output:
@ 0m 31s 0ms
n: 144
[9, 12, 17, 20, 22, 23, 28, 30, 33, 38, 41, 59, 62, 65, 67, 70, 72, 73, 75, 78, 80, 83, 86, 91, 107, 115, 117, 122, 123, 125, 128, 133, 136]
[3, 8, 15, 24, 25, 26, 31, 35, 45, 47, 54, 58, 64, 68, 81, 87, 98, 100, 110, 114, 119, 120, 121, 130, 137, 142]
[5, 13, 16, 19, 27, 36, 39, 42, 48, 50, 51, 94, 95, 97, 103, 106, 109, 112, 118, 126, 129, 132, 138, 140, 141]
[2, 6, 11, 14, 34, 37, 44, 53, 56, 61, 69, 76, 79, 84, 89, 92, 101, 104, 108, 111, 124, 131, 134, 139, 143, 144]
[1, 4, 7, 10, 18, 21, 29, 32, 40, 43, 46, 49, 52, 55, 57, 60, 63, 66, 71, 74, 77, 82, 85, 88, 90, 93, 96, 99, 102, 105, 113, 116, 127, 135]

Performs a seeded random search distributed over 4 threads. When it can't find a partition to fit n in it tries to free up space for n in one partition at a time by dumping as much as it can out of it into the other partitions.
edit: tweaked the algorithm for freeing up space for n, also added ability to go back to a previous choice and choose again.
note: the output is not strictly deterministic because there are multiple threads involved and they can end up updating the best n found so far in jumbled order; the eventual score of 144 is deterministic though and is reached fairly quickly: 30 seconds on my computer.
Code is:
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

public class SumFree {

    private static int best;

    public static void main(String[] args) {
        int k = 5; // Integer.valueOf(args[0]);
        int numThreadsPeterTaylorCanHandle = 4;

        long start = System.currentTimeMillis();
        long end = start + TimeUnit.MINUTES.toMillis(10);

        System.out.println(start);

        Random rand = new Random("Lucky".hashCode());
        for (int i = 0; i < numThreadsPeterTaylorCanHandle; i++) {
            new Thread(() -> search(k, new Random(rand.nextLong()), start, end)).start();
        }
    }

    private static void search(int k, Random rand, long start, long end) {
        long now = System.currentTimeMillis();
        int localBest = 0;

        do {
            // create k empty partitions
            List<Partition> partitions = new ArrayList<>();
            for (int i = 0; i < k; i++) {
                partitions.add(new Partition());
            }

            Deque<Choice> pastChoices = new ArrayDeque<>();
            int bestNThisRun = 0;

            // try to fill up the partitions as much as we can
            for (int n = 1;; n++) {
                // list of partitions that can fit n
                List<Partition> partitionsForN = new ArrayList<>(k);
                for (Partition partition : partitions) {
                    if (!partition.sums.contains(n)) {
                        partitionsForN.add(partition);
                    }
                }

                // if we can't fit n anywhere then try to free up some space
                // by rearranging partitions
                Set<Set<Set<Integer>>> rearrangeAttempts = new HashSet<>();
                rearrange: while (partitionsForN.size() == 0 && rearrangeAttempts
                        .add(partitions.stream().map(Partition::getElements).collect(Collectors.toSet()))) {

                    Collections.shuffle(partitions, rand);
                    for (int candidateIndex = 0; candidateIndex < k; candidateIndex++) {
                        // partition we will try to free up
                        Partition candidate = partitions.get(candidateIndex);
                        // try to dump stuff that adds up to n into the other
                        // partitions
                        List<Integer> badElements = new ArrayList<>(candidate.elements.size());
                        for (int candidateElement : candidate.elements) {
                            if (candidate.elements.contains(n - candidateElement)) {
                                badElements.add(candidateElement);
                            }
                        }
                        for (int i = 0; i < k && !badElements.isEmpty(); i++) {
                            if (i == candidateIndex) {
                                continue;
                            }

                            Partition other = partitions.get(i);

                            for (int j = 0; j < badElements.size(); j++) {
                                int candidateElement = badElements.get(j);
                                if (!other.sums.contains(candidateElement)
                                        && !other.elements.contains(candidateElement + candidateElement)) {
                                    boolean canFit = true;
                                    for (int otherElement : other.elements) {
                                        if (other.elements.contains(candidateElement + otherElement)) {
                                            canFit = false;
                                            break;
                                        }
                                    }

                                    if (canFit) {
                                        other.elements.add(candidateElement);
                                        for (int otherElement : other.elements) {
                                            other.sums.add(candidateElement + otherElement);
                                        }
                                        candidate.elements.remove((Integer) candidateElement);
                                        badElements.remove(j--);
                                    }
                                }
                            }
                        }

                        // recompute the sums
                        candidate.sums.clear();
                        List<Integer> elementList = new ArrayList<>(candidate.elements);
                        int elementListSize = elementList.size();
                        for (int i = 0; i < elementListSize; i++) {
                            int ithElement = elementList.get(i);
                            for (int j = i; j < elementListSize; j++) {
                                int jthElement = elementList.get(j);
                                candidate.sums.add(ithElement + jthElement);
                            }
                        }

                        // if candidate can now fit n then we can go on
                        if (!candidate.sums.contains(n)) {
                            partitionsForN.add(candidate);
                            break rearrange;
                        }
                    }
                }

                // if we still can't fit in n, then go back in time to our last
                // choice (if it's saved) and this time choose differently
                if (partitionsForN.size() == 0 && !pastChoices.isEmpty() && bestNThisRun > localBest - localBest / 3) {
                    Choice lastChoice = pastChoices.peek();
                    partitions = new ArrayList<>(lastChoice.partitions.size());
                    for (Partition partition : lastChoice.partitions) {
                        partitions.add(new Partition(partition));
                    }
                    n = lastChoice.n;
                    Partition partition = lastChoice.unchosenPartitions
                            .get(rand.nextInt(lastChoice.unchosenPartitions.size()));
                    lastChoice.unchosenPartitions.remove(partition);
                    partition = partitions.get(lastChoice.partitions.indexOf(partition));
                    partition.elements.add(n);
                    for (int element : partition.elements) {
                        partition.sums.add(element + n);
                    }
                    if (lastChoice.unchosenPartitions.size() == 0) {
                        pastChoices.pop();
                    }
                    continue;
                }

                if (partitionsForN.size() > 0) {
                    // if we can fit in n somewhere,
                    // pick that somewhere randomly
                    Partition chosenPartition = partitionsForN.get(rand.nextInt(partitionsForN.size()));
                    // if we're making a choice then record it so that we may
                    // return to it later if we get stuck
                    if (partitionsForN.size() > 1) {
                        Choice choice = new Choice();
                        choice.n = n;
                        for (Partition partition : partitions) {
                            choice.partitions.add(new Partition(partition));
                        }
                        for (Partition partition : partitionsForN) {
                            if (partition != chosenPartition) {
                                choice.unchosenPartitions.add(choice.partitions.get(partitions.indexOf(partition)));
                            }
                        }
                        pastChoices.push(choice);

                        // only keep 3 choices around
                        if (pastChoices.size() > 3) {
                            pastChoices.removeLast();
                        }
                    }

                    chosenPartition.elements.add(n);
                    for (int element : chosenPartition.elements) {
                        chosenPartition.sums.add(element + n);
                    }
                    bestNThisRun = Math.max(bestNThisRun, n);
                }

                if (bestNThisRun > localBest) {
                    localBest = Math.max(localBest, bestNThisRun);

                    synchronized (SumFree.class) {
                        now = System.currentTimeMillis();

                        if (bestNThisRun > best) {
                            // sanity check
                            Set<Integer> allElements = new HashSet<>();
                            for (Partition partition : partitions) {
                                for (int e1 : partition.elements) {
                                    if (!allElements.add(e1)) {
                                        throw new RuntimeException("Oops!");
                                    }
                                    for (int e2 : partition.elements) {
                                        if (partition.elements.contains(e1 + e2)) {
                                            throw new RuntimeException("Oops!");
                                        }
                                    }
                                }
                            }
                            if (allElements.size() != bestNThisRun) {
                                throw new RuntimeException("Oops!" + allElements.size() + "!=" + bestNThisRun);
                            }

                            best = bestNThisRun;
                            System.out.printf("@ %dm %ds %dms\n", TimeUnit.MILLISECONDS.toMinutes(now - start),
                                    TimeUnit.MILLISECONDS.toSeconds(now - start) % 60, (now - start) % 1000);
                            System.out.printf("n: %d\n", bestNThisRun);
                            for (Partition partition : partitions) {
                                // print in sorted order since everyone else
                                // seems to to that
                                List<Integer> partitionElementsList = new ArrayList<>(partition.elements);
                                Collections.sort(partitionElementsList);
                                System.out.println(partitionElementsList);
                            }
                            System.out.printf("timestamp: %d\n", now);
                            System.out.println("------------------------------");
                        }
                    }
                }

                if (partitionsForN.size() == 0) {
                    break;
                }
            }
        } while (now < end);
    }

    // class representing a partition
    private static final class Partition {

        // the elements of this partition
        Set<Integer> elements = new HashSet<>();

        // the sums of the elements of this partition
        Set<Integer> sums = new HashSet<>();

        Partition() {
        }

        Partition(Partition toCopy) {
            elements.addAll(toCopy.elements);
            sums.addAll(toCopy.sums);
        }

        Set<Integer> getElements() {
            return elements;
        }
    }

    private static final class Choice {
        int n;
        List<Partition> partitions = new ArrayList<>();
        List<Partition> unchosenPartitions = new ArrayList<>();
    }
}

C, Random Greedy, n = 91
Just to provide a baseline solution, this iterates over n, keeping track of the bins and their sums and adds n to a random bin where it doesn't appear as a sum yet. It terminates once n appears in all k sums, and if the resulting n was better than any previous attempt, prints it to STDOUT.
The input k is provided via a command-line argument. The maximum possible k is currently hardcoded to 10 because I was too lazy add dynamic memory allocation, but that could be fixed easily.
I guess I could go hunting for a better seed now, but this answer is probably not particularly competitive anyway, so meh.
Here is the partition for n = 91:
1 5 12 18 22 29 32 35 46 48 56 59 62 69 72 76 79 82 86 89
2 3 10 11 16 17 25 30 43 44 51 52 57 64 71 83 84 90 91
6 8 13 15 24 31 33 38 40 42 49 54 61 63 65 77 81 88
9 14 19 21 27 34 37 45 60 67 70 73 75 78 80 85
4 7 20 23 26 28 36 39 41 47 50 53 55 58 66 68 74 87

And finally, here is the code:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define MAX_K 10
#define MAX_N 1024

int main(int argc, char **argv) {
    if (argc < 2)
    {
        printf("Pass in k as a command-line argument");
        return 1;
    }

    printf("%u\n", (unsigned)time(NULL));

    int k = atoi(argv[1]);

    int sizes[MAX_K];
    int bins[MAX_K][MAX_N];
    int sums[MAX_K][2*MAX_N];
    int selection[MAX_K];
    int available_bins;

    int best = 0;

    srand(1447101176);

    while (1)
    {
        int i,j;
        for (i = 0; i < k; ++i)
            sizes[i] = 0;
        for (i = 0; i < k*MAX_N; ++i)
            bins[0][i] = 0;
        for (i = 0; i < k*MAX_N*2; ++i)
            sums[0][i] = 0;
        int n = 1;
        while (1)
        {
            available_bins = 0;
            for (i = 0; i < k; ++i)
                if (!sums[i][n])
                {
                    selection[available_bins] = i;
                    ++available_bins;
                }

            if (!available_bins) break;

            int bin = selection[rand() % available_bins];

            bins[bin][sizes[bin]] = n;
            ++sizes[bin];
            for (i = 0; i < sizes[bin]; ++i)
                sums[bin][bins[bin][i] + n] = 1;

            ++n;
        }

        if (n > best)
        {
            best = n;
            for (i = 0; i < k; ++i)
            {
                for (j = 0; j < sizes[i]; ++j)
                    printf("%d ", bins[i][j]);
                printf("\n");
            }
            printf("%u\n", (unsigned)time(NULL));
        }
    }

    return 0;
}

Confirmed n=91, found in 138 seconds. If necessary for tie-breaking I'll retime to avoid large errors due to different CPU load.

C++, 135
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <set>
#include <vector>
#include <algorithm>

using namespace std;

vector<vector<int> > subset;
vector<int> len, tmp;
set<int> sums;

bool is_sum_free_with(int elem, int subnr) {
    sums.clear();
    sums.insert(elem+elem);
    for(int i=0; i<len[subnr]; ++i) {
        sums.insert(subset[subnr][i]+elem);
        for(int j=i; j<len[subnr]; ++j) sums.insert(subset[subnr][i]+subset[subnr][j]);
    }
    if(sums.find(elem)!=sums.end()) return false;
    for(int i=0; i<len[subnr]; ++i) if(sums.find(subset[subnr][i])!=sums.end()) return false;
    return true;
}

int main()
{
    int k = 0; cin >> k;

    int start=time(0);
    cout << start << endl;

    int allmax=0, cnt=0;
    srand(0);

    do {
        len.clear();
        len.resize(k);
        subset.clear();
        subset.resize(k);
        for(int i=0; i<k; ++i) subset[i].resize((int)pow(3, k));

        int n=0, last=0, c, y, g, h, t, max=0;
        vector<int> p(k);

        do {
            ++n;
            c=-1;
            for(int i=0; i++<k; ) {
                y=(last+i)%k;
                if(is_sum_free_with(n, y)) p[++c]=y;
            }

            if(c<0) --n;

            t=n;

            while(c<0) {
                g=rand()%k;
                h=rand()%len[g];
                t=subset[g][h];
                for(int l=h; l<len[g]-1; ++l) subset[g][l]=subset[g][l+1];
                --len[g];
                for(int i=0; i++<k; ) {
                    y=(g+i)%k;
                    if(is_sum_free_with(t, y) && y!=g) p[++c]=y;
                }
                if(c<0) subset[g][len[g]++]=t;
            }

            c=p[rand()%(c+1)];
            subset[c][len[c]++]=t;

            last=c;

            if(n>max) {
                max=n;
                cnt=0;
                if(n>allmax) {
                    allmax=n;
                    for(int i=0; i<k; ++i) {
                        tmp.clear();
                        for(int j=0; j<len[i]; ++j) tmp.push_back(subset[i][j]);
                        sort(tmp.begin(), tmp.end());
                        for(int j=0; j<len[i]; ++j) cout << tmp[j] << " ";
                        cout << endl;
                    }
                    cout << time(0) << " " << time(0)-start << " " << allmax << endl;
                }

            }

        } while(++cnt<50*n && time(0)-start<600);

        cnt=0;

    } while(time(0)-start<600);

    return 0;
}

Appends the next n to a randomly chosen subset. If that's not possible it removes random numbers from subsets and appends them to others in the hope that that enables appending n somewhere.
I prototyped this in awk, and because it looked promising, I translated it into C++ to speed it up. Using a std::set should even speed it up more.
Output for n=135 (after around 230 seconds on my [old] machine)

2 6 9 10 13 17 24 28 31 35 39 42 43 46 50 57 61 68 75 79 90 94 97 101 105 108 119 123 126 127 130 131 134
38 41 45 48 51 52 55 56 58 59 62 64 65 66 67 69 70 71 72 74 78 80 81 84 85 87 88 91 95 98
5 12 15 16 19 22 23 25 26 29 33 36 73 83 93 100 103 107 110 111 113 114 117 120 121 124
1 4 11 14 21 27 34 37 40 47 53 60 76 86 89 96 99 102 109 112 115 122 125 132 135
3 7 8 18 20 30 32 44 49 54 63 77 82 92 104 106 116 118 128 129 133

I didn't recheck the validity, but it should be alright.

Python 3, random greedy, n = 61
Last output:
[5, 9, 13, 20, 24, 30, 32, 34, 42, 46, 49, 57, 61]
[8, 12, 14, 23, 25, 44, 45, 47, 54]
[2, 6, 7, 19, 22, 27, 35, 36, 39, 40, 52, 53, 56]
[3, 10, 15, 16, 17, 29, 37, 51, 55, 59, 60]
[1, 4, 11, 18, 21, 26, 28, 31, 33, 38, 41, 43, 48, 50, 58]

This uses effectively the same algorithm as Martin Büttner's, but I developed it independently.
There are k bins that have both the numbers in it so far and the numbers that can't go in it anymore. At each depth in the iteration (it's basically a depth-first search), the bin ordering is shuffled and the next number (nextN) is (sequentially) put into the bins that can take it and then goes one step deeper. If there are none, it returns, backing up one step.
from copy import deepcopy
from random import shuffle, seed
from time import clock, time
global maxN
maxN = 0
clock()
seed(0)

def search(k,nextN=1,sets=None):
    global maxN
    if clock() > 600: return

    if nextN == 1: #first iteration
        sets = []
        for i in range(k):
            sets.append([[],[]])

    R = list(range(k))
    shuffle(R)
    for i in R:
        if clock() > 600: return
        if nextN not in sets[i][1]:
            sets2 = deepcopy(sets)
            sets2[i][0].append(nextN)
            sets2[i][1].extend([nextN+j for j in sets2[i][0]])
            nextN2 = nextN + 1

            if nextN > maxN:
                maxN = nextN
                print("New maximum!",maxN)
                for s in sets2: print(s[0])
                print(time())
                print()

            search(k, nextN2, sets2)

search(5)

Python, n = 31
import sys
k = int(sys.argv[1])

for i in range(k):
    print ([2**i * (2*j + 1) for j in range(2**(k - i - 1))])

Ok, so it's obvisouly not a winner, but I felt it belonged here anyway.
I've taken the liberty not to include timestamps, since it terminates instantaneously, and since it's not a real contender.
First, note that the sum of any two odd numbers is even, so we can dump all the odd numbers in the first block.
Then, since all the remaining numbers are even, we can divide them by 2.
Once again, we can throw all the resulting odd numbers in the second block (after re-multiplying them by 2), divide the remaining numbers by 2 (i.e., by 4 overall), throw the odd ones in the third block (after re-multiplying them by 4), and so on...
Or, to put in words you guys understand, we put all the numbers whose least-significant set bit is the first bit in the first block, all the numbers whose least-significant set bit is the second bit in the second block, and so on...
For k blocks, we run into trouble once we reach n = 2k, since the least-significant set bit of n isthe (k + 1)-th bit, which doesn't correspond to any block.
In other words, this scheme works upto n = 2k - 1.
So, while for k = 5 we only get a meager n = 31, this number grows exponentially with k.
It also establishes that S(k) ≥ 2k - 1 (but we can actually find a better lower limit than that quite easily.)
For reference, here's the result for k = 5:
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31]
[2, 6, 10, 14, 18, 22, 26, 30]
[4, 12, 20, 28]
[8, 24]
[16]

There's an easy way to squeeze out an extra one: move the top half of the odd numbers to any other category (since their sum is bound to be larger than any number already in that category) and add 2^k to the bottom half of the odd numbers. The same idea can probably be extended to get another lg k numbers, or maybe even another k.

@PeterTaylor Yeah, I realised short after posting that this is actually pretty trivial.
It's equivalent to doing [1], [2,3], [4,5,6,7], ..., which is probably simpler, just with reverse bit and block order.
It's easy to see how this one can be extended.

source: Stack Exchange

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Print a Pentomino Rectangle
Write a program or function that takes no input but prints or returns a constant textual depiction of a rectangle made of the 12 distinct pentominoes:

The rectangle may have any dimensions and be in any orientation, but all 12 pentominoes must be used exactly once, so it will have area 60. Each different pentomino must be composed of a different printable ASCII character (you don't need to use the letters from above).
For example, if you chose to output this 20×3 pentomino rectangle solution:

Your program's output might look something like this:
00.@@@ccccF111//=---
0...@@c))FFF1//8===-
00.ttttt)))F1/8888=-

Alternatively, you might find it easier to golf this 6×10 solution:
000111
203331
203431
22 444
2   46
57 666
57769!
58779!
58899!
5889!!

Any rectangle solution will do, your program only needs to print one. (A trailing newline in the output is fine.)
This great website has loads of solutions for various rectangle dimensions and it's probably worth browsing them to make sure your solution is as short as possible. This is code-golf, the shortest answer in bytes wins.

Bonus if it's a "quine" in Piet.

@mbomb007 That's pretty much impossible with just 12 blocks to play  with :P

I don't think that spaces should be allowed on the borders. But since they are, can I omit trailing spaces? Do I get a bonus if I print a vertical 5x12 solution with an I out of spaces at the end?

@Sp3000 how about a Piet program composed entirely of pentomino rectangle solutions?

@JanDvorak You can't omit trailing spaces if you have them. They are characters just like the rest of printable ASCII.

I wasted too much time trying to solve this in JavaScript using btoa as my decompressor but it still took 10-14 more bytes than the trivial literal string version.

Pyth, 37 bytes
jc4.HC"&f3ªªwril3:[·)ÌDU[r)ÌDA»

Demonstration
Uses a very straightforward approach: Use hex bytes as numbers. Convert to a hex number, base 256 encode that. That gives the magic string above. To decode, use Pyth's base 256 decoder function, convert to hex, split into 4 chunks, and join on newlines.

Bash + common Linux utils, 50
xxd -s20 -p -c2 $0
#<30 bytes of binary data>

To recreate this from encoded base64:
base64 -d <<< eHhkIC1zMjAgLXAgLWMyICQwCiMiImaSaZlmkDAAMwSjRKNEqoGogYhRVVF7UXu7d3s= > pent.sh

Since there are 12 pentominoes, their colours are easily encoded in hex nybbles.
Output:
$ ./pent.sh
2222
6692
6999
6690
3000
3304
a344
a344
aa81
a881
8851
5551
7b51
7bbb
777b
$

CJam (44 bytes)
Given in xxd format because it contains control characters (including a raw tab, which plays really badly with MarkDown):
0000000: 2202 7e0d 8ef3 570d e085 e168 cf27 092c
0000010: a235 0c22 3235 3662 3562 332f 5f2c 2c2e
0000020: 7b32 2f27 412b 662b 7d7a 4e2a

which decodes to something along the lines of
"MAGIC STRING"256b5b3/_,,.{2/'A+f+}zN*

Slightly ungolfed online demo which doesn't contain control characters and so plays nicely with browser URI decoding library functions.
The basic principle is that since no piece spans more than 5 rows we can encode an offset from a linear function of the row number compactly (in base 5, in fact, although I haven't tried to determine whether this would always be the case).

J, 49 bytes
u:64++/\|:3#.inv 1377859090 1567813024 1337683230

You can choose the letters in a way that the maximal increments between vertically adjacent letters are 2. We use this fact to encode vertical increments in base3. After that we create the running sums and add an offset to get the ASCII codes of the letters.
Definitely golfable. (I yet to find a way to input extended precision base36 numbers but simple base36 should save 3 bytes alone.)
Output:
AAA
ABA
BBB
DBC
DCC
DCC
DEE
DFE
FFE
FGE
FGG
GGH
HHH
IIH
JII
JJI
JKK
JKL
KKL
LLL

Try it online here.

Very nice. With base-256 encoding applying this difference encoding in CJam gives 33 bytes (48 byte version without b256).

This is awesome! It would also work with the 4x15, which would work well for packing four numbers into a byte, if you store data widthways rather than lengthways.  You'd need a layout that has the U pentomino facing the right way. There are plenty in the link at the question.

@steveverrill You would need a starting offset for that because there will be more than 4 pieces starting on the first line, so you can't code those into base4. With this extra offset (e.g. 3#i.5 which is 0 0 0 1 1 1 ... 4 4 4) it can work but probably won't be shorter (at least the way I tried).

Microscript II, 66 bytes
Lets start with the simple answer.
"00.@@@ccccF111//=---\n0...@@c))FFF1//8===-\n00.ttttt)))F1/8888=-"

Hooray implicit printing.

Ruby
Rev 3, 55bytes
i=1
'S, OJ1*$HCH(#%0'.bytes{|e|puts "%x"%i+=e*130&9011}

As a further development on Randomra's idea, consider the output and difference table below. The difference table can be compressed as before, and expanded by multiplying by 65=binary 1000001 and applying a mask 11001100110011. However, Ruby does not work predictably with 8 bit characters (it tends to interpret them as Unicode.)
Surprisingly, the last column is entirely even. Because of this, in compression we can perform a rightshift on the data. This ensures all codes are 7 bit ASCII. In expansion we simply multiply by 65*2=130 instead of 65.
The first column is also entirely even. Therefore we can add 1 to each element (32 to each byte) where necessary, to avoid any control characters. The unwanted 1 is removed by using the mask 10001100110011=9011 instead 11001100110011.
Solution 59 of document linked in question

Start0001

Out  Diff
2223 2222
2433 0210
2433 0000
4445 2012
6555 2110
6577 0022
6687 0110
6887 0200
8897 2010
aa99 2202
caa9 2010
cab9 0010
cbbb 0102
cdbd 0202
cddd 0020

Although I use 15 bytes for the table, I only really use 6 bits of each byte, which is a total of 90 bits. There are in fact only 36 possible values for each byte, which is 2.21E23 possibities in total. That would fit in 77 bits of entropy.
Rev 2, 58 bytes, using Randomra's incremental approach
i=0
'UPEIP@bPHPBETTEPRADT'.bytes{|e|puts "%x"%i+=e*65&819}

Finally, something shorter than the naive solution. Randomra's incremental approach, with the bytepacking method of Rev 1.
Rev 1, 72 bytes, golfed version of rev 0
Some changes were made to the baseline to accomodate a reordering of the code for golfing reasons, but still came in longer than the naive solution.
i=0
'UPUIYD&!)$&V*).);c+*'.bytes{|e|i+=1;puts "%x"%(i/2*273+(e*65&819))}

The offsets are encoded into each character of the magic string in base 4 in format BAC, ie with the 1's representing the righthand symbol, the 16's representing the middle symbol, and the lefthand symbol shoehorned into the 4's position. In order to extract them, the ascii code is multiplied by 65 (binary 1000001) to give BACBAC, then it is anded with 819 (binary 1100110011) to give .A.B.C.
Some of the ascii codes have the 7th bit set, i.e. they are 64 higher than the required value, to avoid control characters. Because this bit is removed by the mask 819, this is inconsequential, except when the value of C is 3, which causes a carryover. This has to be corrected in one place only (instead of g we have to use c.)
Rev 0, ungolfed version
a= %w{000 010 000 201 100 100 011 021 110 120 011 112 111 221 211 221 122 123 112 222}
i=2
a.each{|e|puts "%x"%(i/2*273+e.to_i(16));i+=1}

Output
111
121
222
423
433
433
455
465
665
675
677
778
888
998
a99
aa9
abb
abc
bbc
ccc

Explanation
From the following solution, I subtract the baseline, giving the offset which I store as data. The baseline is regenerated as a hexadecimal number in the code by i/2*273 (273 decimal = 111 hex.)
solution   baseline   offset
AAA        AAA        000
ABA        AAA        010
BBB        BBB        000
DBC        BBB        201
DCC        CCC        100
DCC        CCC        100
DEE        DDD        011
DFE        DDD        021
FFE        EEE        110
FGE        EEE        120
FGG        FFF        011
GGH        FFF        112
HHH        GGG        111
IIH        GGG        221
JII        HHH        211
JJI        HHH        221
JKK        III        122
JKL        III        123
KKL        JJJ        112
LLL        JJJ        222

That looks like essentially the same approach as mine, but you've managed to avoid the single delta of 4 which forced me to encode in base 5. Looks like I chose the wrong labelling for the pieces.

I saw your answer after I posted mine. I can't follow Cjam, but from what you said in your answer it's a similar approach. I actually only have a single 3 in the whole table (right near the bottom) so I think by increasing the baseline by slightly more than 0.5 every line it may actually be possible to use base 3. Feel free to try that. (For golfing reasons it seems I'm going to have to change the baseline slightly, which gives me rather more 3's, and unfortunately its looking like its going to be 1 byte longer than the naive solution in Ruby.)

In case I wasn't clear earlier, my intention was to congratulate you on doing a better job than me, not to accuse you of copying. And I'm not going to try using a growth rate of 2.5 because I don't think it will beat randomra's difference encoding approach.

@PeterTaylor thanks, I did get that you were congratulating me. On the other hand, you got in first with basically the same idea and made it much shorter, so congratulations to you, too. With randomra's difference approach finally I can get shorter than the naive solution. It would work well at 4x15 too (given the right pentomino layout). That's the way I'd do it in C or any other language that works well with 8.bit strings.  As Ruby supports unicode, it tries to interpret 8 bit strings as unicode and can give some annoying error messages.

Foo, 66 Bytes
"00.@@@ccccF111//=---\n0...@@c))FFF1//8===-\n00.ttttt)))F1/8888=-"

This is character-for-character identical to the Microscript II solution above...  I assume these languages are related?

@DatrelHoffman not really, foo basically just prints everything in quotes


text:
Self-debugging code
Your Task
Write a program using ASCII characters. Five alphanumeric (0-9, A-Z, a-z) characters will be inserted at random into your program's source code. Your task is to detect and output these characters inserted into your program.
Conditions

Your code cannot use any form of backup file.
Your code may produce any unnecessary error messages, provided these are distinguishable from the actual output.
The output may be on the screen or into a file.
The output may also contain unnecessary characters, but no extra alphanumeric characters (excluding error messages).

Winning
The post with the largest vote count  wins.

I'm confused about why the folder is relevant. Is this challenge the same as "Write a string so that when any five character are added in arbitrary positions, and the result is run as code, it prints those characters"?

Hahaha. I hope this post doesn't get investigated for unintentional obscene language. I understand the word http://urbandictionary.com/define.php?term=bugger isn't used much in the USA. It was the line before "conditions" that made me LOL

@xnor Yes, it is the same. I just wanted to say that the file cannot access a backup of itself.

@steveverrill It was unintentional. I've edited.

@wizzwizz4, are you sure that your edit is not an other question?

@Qwertiy I've rewritten it completely, but I'm pretty sure it's the same question. The same answers would fit it. If you cross reference, you will find the same info (except the stuff about the program that does the code-modification!)

PHP, 0 bytes
PHP will simply echo the source until it sees an opening code tag <?.

Why the downvotes? Are you insulted because this is not a Pyth, CJam whatever answer? Feersum has used one of the right languages for the task in question. (+ it is heavily golfed) +1

I downvoted because this is a popularity contest and while you use a language feature appropriately, I would rather see smart code written by a user than just "hey it works as is with php".

lmoa i like this place !

@Aaron ah ok i see sorry. Thought it was code-golf.

@StephanSchinkel you don't have to be sorry, popularity-contest are by nature opinion-based and feersum's answer has its merits. They were just not up to my expectations !

@NoOneIsHere Five alphanumeric (0-9, A-Z, a-z) characters will be inserted ...


text:
Are these trees isomorphic?
Introduction
In this challenge, your task is to write a program that decides whether two given trees are isomorphic.
A tree means a directed acyclic graph where every node has exactly one outgoing edge, except the root, which has none.
Two trees are isomorphic if one can be transformed into the other by renaming the nodes.
For example, the two trees (where every edge points up)
  0       0
 /|\     /|\
1 3 4   1 2 5
|\       /|
2 5     3 4

are easily seen to be isomorphic.
We encode a tree as a list L of nonnegative integers in the following way.
The root of the tree has label 0, and it also has nodes 1,2,...,length(L).
Each node i > 0 has an outgoing edge to L[i] (using 1-based indexing).
For example, the list (with the indices given under the elements)
[0,0,1,3,2,2,5,0]
 1 2 3 4 5 6 7 8

encodes the tree
  0
 /|\
1 2 8
| |\
3 5 6
| |
4 7

Input
Your inputs are two lists of nonnegative integers, given in the native format or your language.
They encode two trees in the manner specified above.
You can assume the following conditions about them:

They are not empty.
They have the same length.
Each list L satisfies L[i] < i for all (1-based) indices i.

Output
Your output shall be a truthy value if the trees are isomorphic, and a falsy value if not.
Rules and scoring
You can write either a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.
There are no time restrictions, but built-ins that decide tree or graph isomorphism are disallowed.
Test cases
Truthy instances
[0] [0]
[0,1,2,1] [0,1,1,3]
[0,1,1,3,3] [0,1,2,2,1]
[0,1,0,1,2,3,3,0] [0,0,2,1,0,4,2,1]
[0,1,2,3,1,2,3,0,8] [0,1,0,3,3,4,4,7,7]

Falsy instances
[0,0] [0,1]
[0,1,2,0,3,3,4] [0,1,2,3,0,4,3]
[0,1,0,1,2,3,3,0] [0,0,2,1,0,5,2,1]
[0,1,1,0,1,3,2,1,5] [0,1,0,3,3,3,2,5,2]
[0,1,2,3,1,2,3,0,8] [0,1,0,1,4,4,5,6,6]
[0,1,0,2,0,3,0,4,0,5] [0,0,2,1,0,3,4,0,0,9]

Related: Mathematician claims breakthrough in complexity theory

@DigitalTrauma Dangit, you made the OP disallow builtins... I had a 60-byte Mma solution...

Mathematica, 48 bytes
SameQ@@(Sort//@(0(0//.PositionIndex@#))&/@{##})&

It's even shorter than the solution that uses IsomorphicGraphQ:
IsomorphicGraphQ@@(Graph@*MapIndexed[#->Tr@#2&]/@{##})&

Python, 83
The anonymous function on the 2nd line is my solution.
f=lambda l,i=0:sorted(f(l,j+1)for j,e in enumerate(l)if e==i)
lambda a,b:f(a)==f(b)

f returns a canonized form of a subtree which is a sorted list of its canonized children.  Then we must simply check if the canonized forms of each tree are equal.


text:
Make a math equation from the date
In my Economics class, my friends and I like to come up with ways to rearrange the digits in the date (in MM/DD/YY) format to create a valid mathematical equation. For the most part, we are allowed to use addition, subtraction, multiplication, division, parentheses, and exponentiation in addition to concatenation.
Your program should do something similar. The program should import the current date and insert operators to print an expression according to the following rules.

The digits MUST be used in order. Rearrangement of digits is not allowed.
The resulting expression must be mathematically accurate.
Addition, subtraction, multiplication, division, exponentiation, and use of parentheses is allowed. So is concatenation of digits. However, not all operations are necessary. You cannot use a subtraction sign to make a digit negative (like -1+1+11=10 on November 11, 2010).
The program must run in 60 seconds on a standard machine.

For example, this challenge was written on November 10, 2015. The program would interpret this as 11/10/15. A sample output would be (1+1)/10=1/5.

Bonuses
You may multiply the number of bytes in your code by 0.9 for each one of the following your program supports.

The program prints all possible expressions that can be formed, separated by newlines. Multiply by an additional 0.95 if the expressions are listed in increasing order of additional symbols.
The program also works for MM/DD/YYYY dates, printing a possibility with the first two digits of the year in addition to the possibility without. If this bonus is combined with the first bonus, all possibilities with the first two digits of the year must be printed.
The program also prints an equation for when there are multiple equalities (for example, on November 11, 2011, 1=1=1=1=1=1 would be printed, in addition to possibilities such as 1*1=1=1=1=1, 1*1*1=1=1=1, and 1*1*1*1=1=1. All such cases must be printed for the first bonus to be achieved.
The program supports conversion to bases between 2 and 16. Note that if the base is not 10, all numbers in the expression must be written in the same base, and  (Base b) must be written after the expression (with b replaced accordingly).

This is code golf, so standard rules apply. Shortest code in bytes wins.

What operations are allowed?

Related

@FryAmTheEggman Is there enough similarity to call this a duplicate? I didn't think so because this challenge doesn't use exclusively one digit and does not have a specific RHS in mind (only equality).

I would have said duplicate and voted to close if I thought they were dupes :P Some of the approach can be quite similar, so I pointed people trying to answer the question well to another similar question, is all.

Ok, thanks. I'll keep the question up.

DD/MM/YYYY > MM/DD/YYYY.

Is 05/01/2015 valid or do you want 5/1/2015?

@muddyfish MM/DD/YYYY would use 05/01/2015.

I think you want to use equation in your question where you wrote expression (an expression is just one side of the equation, and then your question doesn't really make sense).

Similar?

Can we use == in place of =?

Also, can we use multiple equals signs (e.g. 110110 => 1-1=0^1=1*0)

@ETHproductions Good idea, multiple equals signs in the expression seems like a good bonus. However, == isn't something that should occur.

Is this proven possible for any given date?

Where is the input from?

Python 3, 424 420 369 363 bytes
import time as t
r=range
x=len
d=list(t.strftime('%m%d%y'))
o=([[x,x+'(',x+')']for x in ['']+"+ - == * / **".split()])
n=[]
for l in o:
    n=l+n
o=n
for p in r(x(o)**(x(d)-1)):
    e=''
    for i in r(x(d)-1):
        e+=str(d[i])+o[(p//(x(o)**i))%x(o)]
    e+=str(d[-1])
    try:
        if eval(e)and e.find('=')!=-1:
            print(e.replace('==','=').replace('**','^'))
            break
    except:pass

Brute-forces all possible combinations of operations in the numbers and stops when it finds one.
EDIT: Saved 4 bytes thanks to @NoOneIsHere
EDIT 2: Saved 51(!) bytes thanks to @ValueInk

Hello, and welcome to PPCG! You can inline the except:pass, and remove the space in [ (p//(len(o)**i))%len(o)].

If you're importing division from __future__, would upgrading to Python 3 work better for your situation? Also, I don't understand why you reverse o when you're building that list of operators-with-parens you have.

@ValueInk Yeah, I could probably change it to python 3 and save quite a few bytes. When I started doing the challenge, I wasn't focused on golfing it at all, so it can definitely still be made shorter. Also, since the program is brute forcing all combinations until it finds one, speed is an issue, and I found that it tends to work faster if you use the reverse of o. I'll probably golf this down a bit more to make it a serious contender.

o=([[x,x+'(',x+')']for x in",+,-,==,*,/,**".split(',')]) for 2 bytes

I noticed something else: some dates might not be solvable. An example may be Jul 28th '79: 072879 - in this case the code blows up in memory (I have not looked but probably power-tower related), I added a random shuffle to n to see if I could find a solution for that specific date and got a result of "0=7/2^8^7*9", but that is only evaluated as true due to floating point rounding of 7/2**8**7 to 0.0.

Sorry, slightly confused: are you saying that date has no answer, or are you saying it does and my code doesn't find it?

Didn't see this very soon due to lack of "@" - If you run your code against that date (import datetime and d=list(t.strftime('%m%d%y', datetime.date(2079,7,28).timetuple()))  you will notice it spins and consumes memory. If you change the order of operations it tries you may find a "solution" which is not valid (like 0=7/2^8^79). I don't know if there is no solution to that date (but I can't think of an obvious one, can you?) - EDIT - if we remove the power operation it returns pretty quickly with what should have been an obvious "0/7+28=7+9"

oops it actually gives, with removal of power operation: "0/7+2*8-7=9", but same difference (forgot to remove the random shuffle)

@JonathanAllan Any suggestions for fixing that floating point bug?

Only thing I can think of straight away is to use the Fractionclass  and perform power operations on the integer numerators and denominators (or do the same manually). It may be worth moving all the entries of n containing power operations so they come last as most dates seem to have solutions without power operations (an example of one that does not would be 19-Jan-78 (011978) - which does, however have a solution using powers of 0+1=1^9^7^8.

Taking the power operation out I also noticed it does not solve 111116 but that should then solve as (1+1+1)*(1+1)=6

@JonathanAllan Huh. Thanks for pointing these out. Ill do a rework of the code when I have time (probably tomorrow)

You can also inline for l in o:n=l+n.

You can change except:pass to except:0