text:
Generate and print the first 20 Fibonacci numbers with the least unique characters
As the title suggests, my task is fairly straightforward:
Write a program in your language of choice that will print out the first 20 Fibonacci numbers using the least unique characters.
For example in Python 2:
def fib(n):
  a,b = 1,1
  for i in range(n-1):
    a,b = b,a+b
  return a
for i in range(1,21):print fib(i)

This would have a score of 24, as it has 24 unique characters including whitespace.

Back in July 2014, http://codegolf.stackexchange.com/questions/34614/conways-game-of-life-with-smallest-set-of-source-characters was closed as a duplicate of http://codegolf.stackexchange.com/questions/11690/encode-a-program-with-the-fewest-distinct-characters-possible. In my opinion this should not be a duplicate—"fewest unique characters" seems to be a legitimate, if broken, scoring method.

Also note that there's a language called Lenguage in which every program contains only one unique non-end-of-file character.

Also, this is trivial in brainfuck. It would only need 3 characters "+", "-", and ".".

To keep this contest interesting, you'd need to exclude Unary/Lenguage. An easy way to achieve this would be to place an upper limit on the byte count (e.g., 1 million bytes). 2. There will be a tie, so you should choose a tie breaker. Byte count would probably be a good idea.

You can manually list the first 20 Fibonacci numbers with a delimiter in 11 characters. Just throwing that out there.

Possible duplicate of Encode a program with the fewest distinct characters possible,

CJam, 2 unique characters (1070 bytes)
S))))))))))))))))))SS))))))))))))))))))SS)))))))))))))))))))SS)))))))))))))))
)))))SS))))))))))))))))))))))SS)))))))))))))))))))))))))SS))))))))))))))))))S
))))))))))))))))))))SS)))))))))))))))))))S))))))))))))))))))SS)))))))))))))))
)))))S)))))))))))))))))))))SS))))))))))))))))))))))S))))))))))))))))))))))SS)
))))))))))))))))))))))))S))))))))))))))))))))))))))SS))))))))))))))))))S)))))
))))))))))))))))S)))))))))))))))))))))SS)))))))))))))))))))S)))))))))))))))))
)))S))))))))))))))))))))SS))))))))))))))))))))S))))))))))))))))))))))))S)))))
)))))))))))))))))))SS)))))))))))))))))))))))S))))))))))))))))))S)))))))))))))
))))SS))))))))))))))))))))))))))S)))))))))))))))))))))))))S))))))))))))))))))
))))))SS))))))))))))))))))S))))))))))))))))))))))S))))))))))))))))))))))))))S
))))))))))))))))))))))))SS)))))))))))))))))))S))))))))))))))))))))))S))))))))
)))))))))))))))))S)))))))))))))))))))))SS)))))))))))))))))))))S))))))))))))))
))))S)))))))))))))))))))))))))S))))))))))))))))))SS)))))))))))))))))))))))S))
))))))))))))))))))))))S)))))))))))))))))))))))S))))))))))))))))))))))

The linefeeds are included for "readability". Try it online in the CJam interpreter.
How it works
For starters, we don't actually calculate Fibonacci numbers, but build the string
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

byte by byte.
Keeping that in mind, we only need two characters to obtain the desired output:

S pushes the string " ".
) serves two purposes here:

When the topmost item on the stack is a string, ) pops its last character.
S) leaves an empty string and the space character on the stack.
When the topmost item on the stack is a character, ) increments its code point.
This way, S)))))))))))))))))) pushes the character 1.

After the program finishes, CJam automatically prints all items on the stack. Fortunately, the empty strings pushed by S) aren't visible in the output.

What

+1 This is so much more calm and aesthetically pleasing than your normal CJam code. Like an ocean with gentle waves. I still find it difficult to follow though..

Unary - 1 unique character
You all knew it was coming.
16552026807580920665211491750921730725235456808115643715721126181201732948544576109630429486831063241863270261670172778716193514984700165915528962410601287909151038925505538654870723736863226948250191139201776105749450716207585389147819928943248825902527229387923577427801786113554433618089574276607647435912941850901589122233248109334271085540771125628916636 0's

The equivalent brainfuck program:
-[----->+<]>--.>++++++++++.[->+++++<]>-.>++++++++++.[->+++++<]>.>++++++++++.[->+++++<]>+.>++++++++++.-[----->+<]>.>++++++++++.+[->+++++<]>+.>++++++++++.[->+++++<]>-.++.>++++++++++.[->+++++<]>.-.>++++++++++.[->+++++<]>+.+.>++++++++++.-[----->+<]>..>++++++++++.+[->+++++<]>+.+.>++++++++++.[->+++++<]>-.+++..>++++++++++.[->+++++<]>.+..>++++++++++.[->+++++<]>+.++++..>++++++++++.-[->++++++<]>.-----.-.>++++++++++.+[->+++++<]>++.-.-.>++++++++++.[->+++++<]>-.++++.++++.--.>++++++++++.[->+++++<]>.+++.+++.----.>++++++++++.-[----->+<]>-.---.+++++++.-------.>++++++++++.-[->++++++<]>.+.-.-.

It doesn't even  bother doing anything with Fibonacci's, just prints the literals.

Well, it's the answer the scoring system requires.

honestly this is what I was looking for, a language that could do it in a single character, 2 characters is somewhat obvious with brainfuck, so really beating that is what I was looking for

Whitespace, 3 unique characters
Dammit, CJam.
Space characters are replaced into S, and tabs are T, line feeds are L.
SSSLSSSTSTSTLTTSSSSLSSSTLLSSLSSSLTTTSSSTLTSSTSLSLTSTLSSSLSLTTTSSLSTLSTSSSTSTSLTLSSSLTSTSSTSLTSSSLSLLLSSTLLLL

or xxd.
$ xxd fib.ws
0000000: 2020 200a 2020 2009 2009 2009 0a09 0920     .   . . ....
0000010: 2020 200a 2020 2009 0a0a 2020 0a20 2020     .   ...  .
0000020: 0a09 0909 2020 2009 0a09 2020 0920 0a20  ....   ...  . .
0000030: 0a09 2009 0a20 2020 0a20 0a09 0909 2020  .. ..   . ....
0000040: 0a20 090a 2009 2020 2009 2009 200a 090a  . .. .   . . ...
0000050: 2020 200a 0920 0920 2009 200a 0920 2020     .. .  . ..
0000060: 0a20 0a0a 0a20 2009 0a0a 0a0a            . ...  .....

I made it from Whitelips by compiling assembly(?) code.
You can compile and run below at Whitelips.
;;;; store repeat count to heap
  push 0
  push 21
  store

;;;; initial setup
  push 0
  push 1

;;;; repeat
repeat:

;;;; check end of loop
  push 0
  retrieve
  push 1
  sub
  dup
  jz end
  push 0
  swap
  store

;;;; print
  dup
  printi
  push 10
  printc

;;;; add
  swap
  copy 2
  add
  jmp repeat

;;;; end
end:
  end

Python 2, 8 unique chars
Uses characters print+1,. 35444 chars total. Because of SE character limits, I post an abbreviated version below that only prints the first 14 Fibonacci numbers, but I think it should be clear how to extend it.
print+1,+1,+1+1,+1+1+1,+1+1+1+1+1,+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1

Here is code to generate the code string s:
def fib(n):
  a,b = 1,1
  for i in range(n-1):
    a,b = b,a+b
  return a

s="print"
for i in range(1,21):
    n=fib(i)
    s+="+1"*n+','

s=s[:-1]

In Python REPL, as well as in many languages, one could omit the print, reducing the score to 3.

You could shorten your code a lot by using 11, 111 and 1111.

Try BASIC, ? instead of PRINT

@Dennis shorter code isn't worth anything here, though, right?

@Sparr: Well, being able to fit the entire code in the answer would be a bonus, but no, it wouldn't improve the score.

Brainfuck, 2 unique characters
7801 characters

+++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++.++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++.+.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++..+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++.+++..++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++.+..+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++.++++..+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++.++++.++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++.+++.+++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++.+.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

Output: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
Ideone
Here is the code that wrote this program:
ans = "1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765"
x=[ord(c) for c in ans]
s=""
n=0
for q in x:
    if q > n:
        d = q - n
    elif q < n:
        d = 256 - n
        d += q
    else:
        d=0
    s+= "+"*d + "."
    n += d
    if n>255:
        n-=256
print s

Ruby, 6 unique characters, 183 118 bytes, actually does the calculation.
183 byte version with p+=1 space and \n
p p=1
p pp=1
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p
p p=p+pp
p pp=pp+p

It looks like some oddball esolang (like Brainfuck or Perl for example), but it's valid ruby.
We have 2 variables p and pp to accumulate the numbers in, and we print by means of the p command at the beginning of the line.
118 byte version, with comma instead of newline, and += instead of addition.
p p=1,pp=1,p+=pp,pp+=p,p+=pp,pp+=p,p+=pp,pp+=p,p+=pp,pp+=p,p+=pp,pp+=p,p+=pp,pp+=p,p+=pp,pp+=p,p+=pp,pp+=p,p+=pp,pp+=p

+1 for actually calculating the numbers. (Did you really just call Perl an oddball esolang? :P)

@Dennis Thanks. In the interests of proper attribution:  https://esolangs.org/wiki/Perl .

dc, 5 unique
Shortest "non-esoteric" answer so far.  Characters used are 2i10P
2i110001001000000011000100100000001100100010000000110011001000000011010100100000001110000010000000110001001100110010000000110010001100010010000000110011001101000010000000110101001101010010000000111000001110010010000000110001001101000011010000100000001100100011001100110011001000000011001100110111001101110010000000110110001100010011000000100000001110010011100000110111001000000011000100110101001110010011011100100000001100100011010100111000001101000010000000110100001100010011100000110001001000000011011000110111001101100011010100001010P

I guess its open to debate whether or not dc is esoteric.

Fish (><>), 3 unique, 3326 bytes
111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1-1-1--1p

Actually calculates the Fibonacci numbers using the program
01aa+v
@+&1->:?!;&:nao:

which is placed into the codebox using only -1p.

JavaScript, 6 unique
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[+!+[]]+[!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]]+[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

This has a total of 6547 characters and alerts the string "1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765".

dc, 2 unique, 6786 bytes
zzppzpzpzzpzzzpzzzzzpzzzzzzzzpzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzpzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzp

Try it online!
The only characters used are p and z.
Here's a run with output:
$ dc -f fibo
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765

SmileBASIC, 3 unique chars (409 bytes)
Characters used: ?, 1, -
(Line breaks inserted for readability)
?1
?1
?1--1
?1--1--1
?1--1--1--1--1
?11-1-1-1
?11--1--1
?11--11-1
?11--11--11--1
?11--11--11--11--11
?111-11-11
?111--11--11--11--11--11
?111--111--11
?111--111--111--11--11--11--11
?111--111--111--111--111--11--11--11--11--11
?1111-111-11-1-1
?1111--111--111--111--111--11--11--11--11-1-1
?1111--1111--111--111--111--11--11--11-1-1-1-1
?1111--1111--1111--1111-111-111-11-11-11-11--1--1--1
?11111-1111-1111-1111-1111--111-11-1-1

? is the same as PRINT
I used - instead of + to allow both addition and subtraction, which (probably) makes it shorter (not that it matters).
Probably works in other BASIC dialects, as long as they don't care about the lack of separation between lines.
Also works in my unfinished language. (Online interpreter: https://12me21.github.io/language/wasm/)

Golfscript, 4 unique characters
Uses 1 +p (literal space)
Only pasting the first 7....
1p 1p 1 1+p 1 1+1+p 1 1+1+1+1+p 1 1+1+1+1+1+1+1+p 1 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+p

It gets out of hand quickly.
Copy, paste, copy, paste, copy, paste the same sequence.

Jelly, 2 unique chars
‘ṄṄ‘Ṅ‘Ṅ‘‘Ṅ‘‘‘Ṅ‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘Ṅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘

Try it online!

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


text:
You call this optimized?
The task is simple, post 2 code snippets that perform the same task, where one seems very optimized at first glance, but actually is significantly slower than the other.
Only one rule:

Both snippets must finish with the exact same output (for the same given input, if any).

Without choosing a specific task, I think this is way too broad to be interesting. You should also specify if both snippets have to use the same language.

@Dennis yeah it might be too broad, I just wanted to see some creative approaches. Also there is no restriction on languages, so that one can get more creative freedom.

Creative freedom doesn't lead to creative answers. It requires a lot more creativity to solve a difficult task than an easy one.

Python 3
Seems fast...
 print(0 < 10**100 - 1 < 10**100)

Seems slow...
 print(10**100 - 1 in range(0, 10**100))

But the two run in very similar times! range has an efficient implementation of in

Question closed aside, isn't this doing the opposite of what the question's asking? You want something that looks fast but is actually slow, not something that looks slow but is actually fast...

@Sp3000 right but it was so broad that I decided to post an even broader answer.

source: Stack Exchange

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

sort: votes


text:
Print the Australian Flag!
Here we go again! This is my last flag for now!
I originally wanted to do my national flag but I thought the stars were too hard so I posted Print the British Flag! instead, which itself was inspired by Print the American Flag!. This challenge would be better for 3 September (Australian National Flag Day) or 26 January (Australia Day) but I couldn't wait that long! The Commonwealth Star is a bit messy but I'm pleased with the rest of the design. Once again you need to view it at 90 degrees.
Produce the following design in the fewest bytes!
 ________________________________________________
|XXXXXXXXXXXXXXXXXXXXXXXX\  \XXXX  0000  XXXX//0/|
|XXXXXXXXXXXXXXXXXXXXXXXX0\  \XXX  0000  XXX//0/ |
|XXXXXXXXXXXXXXXXXXXXXXXX\0\  \XX  0000  XX//0/  |
|XXXXXXXXXXXXXXXXXXXXXXXX\\0\  \X  0000  X//0/  /|
|XXXXXXXXXXXXXXXXXXXXXXXXX\\0\  \  0000  //0/  /X|
|XXXXXXXXXXXXXXXXXXXXXXXXXX\\0\    0000  /0/  /XX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXX\\0\   0000  0/  /XXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXX\\0\  0000  /  /XXXX|
|XXXXXXXX|\XXXXX-/XXXXXXXXXXXX\\0  0000    /XXXXX|
|XXXXX-XX| \XX- /XXXXXXXXXXXXXX\\  0000   /XXXXXX|
|XXXXX\ -|      --XXXXXXX          0000          |
|XXXXXXX\          -XXXXX000000000000000000000000|
|XXXXXXX/          -XXXXX000000000000000000000000|
|XXXXX/ -|      --XXXXXXX          0000          |
|XXXXX-XX| /XX- \XXXXXXXXXXXXXX/   0000  \\XXXXXX|
|XXXXXXXX|/XXXXX-\XXXXXXXXXXXX/    0000  0\\XXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXX/  /  0000  \0\\XXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXX/  /0  0000   \0\\XXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXX/  /0/  0000    \0\\XX|
|XXXXXXXXXXXXXXXXXXXXXXXXX/  /0//  0000  \  \0\\X|
|XXXXXXXXXXXXXXXXXXXXXXXX/  /0//X  0000  X\  \0\\|
|XXXXXXXXXXXXXXXXXXXXXXXX  /0//XX  0000  XX\  \0\|
|XXXXXXXXXXXXXXXXXXXXXXXX /0//XXX  0000  XXX\  \0|
|XXXXXXXXXXXXXXXXXXXXXXXX/0//XXXX  0000  XXXX\  \|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXX|\/|XXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXX>    >XXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXX|/\|XXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXX|\/|XXXXXXXXXXXXXXXXXXXXXXXXXXXX|\/|XXXXXX|
|XXXXX>    >XXXXXXXXXXXXXXXXXXXXXXXXXX>    >XXXXX|
|XXXXXX|/\|XXXXXXXXXXXXXXXXXXXXXXXXXXXX|/\|XXXXXX|
|XXXXXXXXXXXXXXXXXXXXX/|XXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXX>   >XXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXX\|XXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXX|\/|XXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXX>    >XXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXX|/\|XXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|

Things to watch out for: there is a space at the end of the first line. No other trailing spaces are allowed. The dimensions are 50 x 49 (48 x 48 plus borders on three sides).The fifth star (5-pointed) in the Southern Cross is slightly smaller and a different design from the others (7-pointed). A trailing newline is allowed but not required.
My code editor has a thumbnail view of the code at the side. This is what this design looks like:

Not bad!

At this rate, we are gonna need a flag tag!

@Fatalize There are only about 200 countries (not counting other flags)...

Someone will finally want to print the Libya flag from 1977 to 2011.

I know this is the third flag question in three days, but this flag is a lot more difficult to compress than the previous ones. The OP's ASCII art skills alone deserve an upvote.

Yay I started a trend!

Arguably a duplicate of Print the British Flag! since the premise is identical.

@AlexA. Wouldn't it be a dupe of the US one?

@DJMcMayhem I suppose so, but Australia is more similar to Britain, isn't it? :P

@AlexA. I'd say it's more like the British version of Texas. But with more terrifying animals. =D

We have Queens-land, Victoria and New South Wales and we speak English (as do Americans, arguably ;-P) but we haven't been British for a long time!

Python 2, 446 Bytes
Just decodes the Base64 and decompresses using zlib.
import zlib,base64
print zlib.decompress(base64.b64decode("eNrl1MFtwzAMBdCeMwUXEOgJPIcPBLqIhk8ofkq2QdFQb215iZDkgdSXZfpeLHrVY1JCJPpJtH2KSNfMG9c52WBORAUlRL7MDNJESsT6dGIiG8yNE4gjIzCdmMiJGyMQDwQGXUycSW2ncBS+GScQnZTPUhMtxPc+neAXJ0KlUqtS8Gfq5V2sxmAyvjS0TWoQXiW8PljbPuv25bp97kTkun1dWiJF7sKPEubhKLmdILrA5ETFOEqYlDCeRd++mYyYGIPBJARiXDGYhECcLrKZjJg4vy6ayQYzcXkpqXk4l6j+C6nCdY3s+ljti11Y6q9MbBJPEJ+TWTxBfKNLHE8Q32wvyZQx2bMpZ12k/jTkKMechDk+dQly/FMX+Q3ohQN5"))

dash, 261 bytes
0000000: 7a6361743c3c27270a1f8b0801010101010203e5d3c98d04  zcat<<''................
0000018: 410844d1fb58110ea4480bda0e0e48e308bef7fad5cc4a89  A.D..X...H....H.......J.
0000030: db2c717f0944a9f43a8c5ed2bf4948e1d748fb1ac9af31db  .,q..D..:.^..IH..H....1.
0000048: 96df938d8108a186040622444b3010210cd2198810de110c  .........."DK0.!........
0000060: 44889e6020889e602088b724c36f59f6c140847892e59e0a  D..` ..` ..$.oY..@.x....
0000078: f725441908a24868a5ee59cb1f118110be0be89907dadfa4  .%D...Hh..Y.............
0000090: 884d894d17e37c735f0a440d8744d4f924ed81cb20201bd3  .M.M..|s_.D..D..$...  ..
00000a8: 7c4a844114184823360403698541309056d4621848235c10  |J.A..H#6..i.A0.V.b.H#\.
00000c0: c734045104d31044114c431045309049fe0bc9b09c919324  .4.Q...D.LC.E0.I.......$
00000d8: 9d86532cf25736463dc7f541aa9ee3fa20554f5f5f7b8be5  ..S,.W6F=..A.... UO__{..
00000f0: f0fc135b8c1a8be3297d4f03424f13424f7ff847be        ...[....)}O.BO.BO..G.

It should be possible to beat this score with manual compression and a terse language, but if your going to use a widely available compressor (and don't think you can get away with calling zcat a non-Turing complete programming language), dash is probably the best option.
I chose zopfli as the compressor since it is compatible with the Coreutils program zcat and achieves better compression than gzip, bzip2 and xz.
Note that zcat will print a warning to STDERR, which is allowed by default per consensus on Meta.
Testing
This is how I created and tested the program:
$ echo "zcat<<''" > flag.sh
$ git clone https://github.com/google/zopfli.git
$ make -C zopfli
$ zopfli/zopfli -c --i100000 flag.txt >> flag.gz
$ head -c 252 flag.gz | tr \\000 \\001 >> flag.sh
$ dash flag.sh 2>&- | md5sum - flag.txt
168400d97bf59ebff194a6d13495cc26  -
168400d97bf59ebff194a6d13495cc26  flag.txt

Head strips the last 9 bytes from the gzip file, which aren't required for successful decompression.
Fortunately, the gzip file only contains NUL bytes in its header, which can be replaced with SOH bytes without affecting the output.

CJam, 250 246 231 bytes
S'_48*S"0H:+-86:0@6CEM00":i~'X*a*["3|\5-/2-2| \2- /3\ -| 0--4\00-"6,_s\'Xf*0S5*ter
sE/_W%{"\/"_W%er}:R%+"X|\/|X>  "_W%+6/___"XX/|X>   >XX\|"5/C,'X6*"//0/  /"+2*f>8f<
_2>\W%2>.{R" 00 ":_@}" 0 0"[A4A24].*+s_W%+24/]{..e&fm>m<}/{N'|@'|}/

The linefeeds are purely cosmetic and do not contribute to the byte count.
Try it online in the CJam interpreter.
Idea
We start by pushing the background of the flag, i.e., 48 strings of 48 X's each.
Now, we generate all 7 foreground images, i.e., the different types of stars and the miniature British flag.
"3|\5-/2-2| \2- /3\ -| 0--4\00-"

encodes the big star. After replacing each positive number with that many X's, each 0 with a string of 5 spaces and splitting the result into chunks of length 14, we obtain the following:
XXX|\XXXXX-/XX
-XX| \XX- /XXX
\ -|      --XX
XX\          -

If we repeat these strings, in reversed order, and swap the slashes, we obtain the desired big star:
XXX|\XXXXX-/XX
-XX| \XX- /XXX
\ -|      --XX
XX\          -
XX/          -
/ -|      --XX
-XX| /XX- \XXX
XXX|/XXXXX-\XX

For the middle star, we simply push the string "X|\/|X>  ", concatenate it with a reversed copy of itself and chop the result into strings of length 6:
X|\/|X
>    >
X|/\|X

Now, we push the small star as "XX/|X>   >XX\|" chopped into strings of length 5:
XX/|X
>   >
XX\|

(The missing X doesn't matter since the background already contains it.)
Finally, we push the small flag, using almost exactly the same approach as in Print the British Flag!
Now that we have all parts, we start to assemble them. By using twofold vectorized logical AND on the background and the big star, we can replace each truthy character of the background (and all are truthy) by the corresponding character of the big star.
We now rotate the array of strings, and the strings themselves as well, so that the first middle star should be in the upper left corner, then repeat the process from the last paragraph to incorporate this star.
In the same fashion, we paint the remaining stars and the small flag over the background.
After assembling all parts, we only have to add the vertical bars, linefeeds and underscores.
Code
S'_48*S  e# Push a space, a string of 48 underscores and another space.

"0H:+-86:0@6CEM00"

:i~      e# Cast each char to int and dump.
         e# This pushes 48 72 58 43 45 56 54 58 48 64 54 67 69 77 48 48.
         e# All but the last two integers are rotation amounts.
'X*      e# Push a string of 48 X's.
a*       e# Wrap 48 copies of that string in an array.
[        e#

  "3|\5-/2-2| \2- /3\ -| 0--4\00-"

  6,_s   e#   Push [0 1 2 3 4 5] and "012345".
  \'Xf*  e#   Replace the array with ["" "X" "XX" ... "XXXXX"].
  0S5*t  e#   Replace "" with "     ".
  er     e#   Perform transliteration.
  sE/    e#   Flatten and chop into chunks of length 14.
  _W%    e#   Copy and reverse the order of the chunks.
  {      e#   Define a function:
    "\/" e#     Push that string.
    _W%  e#     Push a reversed copy.
    er   e#     Perform transliteration.
  }:R%   e#   Save in R and map over the second array of chunks.
  +      e#   Concatenate.

  "X|\/|X>  "

  _W%    e#   Push a reversed copy.
  +6/    e#   Concatenate and chop into chunks of length 6.
  ___    e#   Copy the resulting array three more times.

  "XX/|X>   >XX\|"

  5/     e#   Split into chunks of length 5.

  C,'X6*"//0/  /"+2*f>8f<_2>\W%2>.{R" 00 ":_@}" 0 0"[A4A24].*+s_W%+24/

         e#   https://codegolf.stackexchange.com/a/52662
]

{        e# For each array of strings in the preceding array of arrays:
  ..e&   e#   Perform twofold vectorized logical AND.
  fm>    e#   Pop an integer from the stack and rotate each string that many
         e#   units to the right.
  m<     e#   Pop an integer from the stack and rotate the array of strings
         e#   that many units to the left/strings up.
}/       e#

{        e# For each string in the resulting array:
  N'|    e#   Push a linefeed and a vertical bar.
  @      e#   Rotate the string on top of them.
  '|     e#   Push an additional vertical bar.
}/       e#

Python 2 - 1258 bytes
import zlib
v=len
l=zlib.decompress("x\x9c\x95\x94I\x12\x83 \x10E\xaf\xc2\x05,F\xd1l<\x87\x0b\xaar\x11\x0f\x1f\t44\x9fv\xe1\"\xd5\x08y\xbfG\x08\xbb\xfaZ\xa5\xd4\xfd\xbb\\P\xe7m\x93+\xdf)(u\xe6\xf5mM\xb5\xf9[\xdfg\xc6\x16{1\xcep\xd6\x03\xebgV\x01\x9fP\xc3\x81\x86\x03\r\x07\x1aN\xd0\xb0\xa0ae\x8d\x9e\xcb*\xeb@\x1c\x12\x7f6\x8d8j\x84\xd1\xff\xc4:\xcen#\xebGv\xe0<\xe7\xf69n\xee\x93l`\xcc\xde\xd7i-\xeb\xe5\x1f\x9f\xebZ\xa4\x13*\xbf2\x9e\x18\x16\x7f\xeb[\xd5*\xf9\xd6\xde\x90\x96\xaf\xfbq\xd6J\x95\xc9\xec\x15K\xad\x97-\x9f\x99\xc2fK\xccFL\xd9[\xb2\xc6=\x07\x06\xce\xf5\xd3\xf9J\xe7/|>\xe4\xac!\xe7d\xcbLk?\xceM\x8ar\xfd5\xab\x7f\xca\xf5\xaf\xbd\x1az\xefz\x9fZ\xcfa\x8e\xf8\xff\xa9\x7f)\xc0|\xc1\xdc\x1a\xe8K\xe3<\xcc4r\xdcg\x00v\x98\xe9U\xf49\xc5\x8bq\x0fw*\xc8\x1a\xd2\xfd~\xd0\xe2\xef\x04\xc61\xbd3\xa8aA\xc3\x82\x86\xf4\xde\t\x1aC.\xc4J\xef,\xb0\x7f.\xec\xbd\x1eo\xd7\xb5\x07W\xd5+\xef\xddg\xaa\xefQ\xfbxX\x99\xd5-\x9e\xcf;\xffl\xee\x9b\x7f\xb7\xcf{\xc2\x9b\xd0b\xaa3\xd8\xbe\xf9]`\\\x8b\x91\xe9\xb7=\xae\xefl\xeb\x03\xcf\x91r;<\xf9\r\x13\x93\x90\x91r\xb1q\xbaw\xbd\xbe2\xdb\xeb\x1b\xdf\xd5\x97\xd6?\xd9\xaczF")
n=''.join([i[-1]*int(i[:v(i)-1].replace(' ',''))for i in[l[i:i+4]for i in range(0,v(l),4)]])
print''.join(n[i]if(i+2)%50 else n[i]+'\n'for i in range(v(n)))

I decided to encode the flag using run length encoding, then compressed it using zlib. In the program, it just decodes all of this and prints it to the console.

You have 232 occurrences of "\x"! That accounts for just under half of your data!

@CJDennis Haha that's just the printable version. That comes to over 1270 bytes

So why only 12 bytes difference?

@CJDennis No idea :/

Could the downvoter care to explain him/herself? :|

Downvoters rarely explain themselves. Don't worry about.

You need to specify an encoding (e.g., by putting # -*- coding: latin-1 -*- after the shebang) to use non-ASCII characters in your source code. Otherwise, roughly half of your characters in the compressed string will need escaping.

@Dennis Would # coding: utf-8 work here?

It should, but UTF-8 means 2 bytes per char for non-ASCII characters. Latin-1 encodes each char using 1 byte.

@Dennis Ooh good I'll add that when I have time

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


text:
Format microseconds as hours:minutes:seconds, etc
The following is inspired by a question that came up on Stack Overflow today.
Given a number of microseconds, 0 <= n <= 86400000000 (e.g. 12345678900), output a formatted string hh:mm:ss:000:000, e.g. 03:25:45:678:900.
          0 -> '00:00:00:000:000'
12345678900 -> '03:25:45:678:900'
86400000000 -> '24:00:00:000:000'

I have a solution in Python in 209 bytes, but can it go lower?

I realise now that this isn't really a standard format for writing times, and hh:mm:ss.000000 would probably have been better (and easier). Still, can't go changing it now.

Out of curiosity, what was the SO post?

@DigitalTrauma http://stackoverflow.com/questions/31251377 by a relatively new user. A correct answer had already been chosen, I was just playing around in IDLE and came up with a grotesque-looking dictionary comprehension that wasn't a particularly good answer to the question. Someone saw it and pointed out this site in a comment. I came here, wrote a question (slightly different to the SO post), and also wrote a much improved version of my answer (which I haven't posted, and which is now redundant to all the much more compact and imaginative answers below).

Is there a limit on the number of hours in the input?

Yes, arbitrarily I made it <= 86400000000 microsec, so <= 24 hours.

Sure would have saved me quite a few characters in my JavaScript answer if ISO format with the dot was allowed :/ Interesting challenge nonetheless :)

Welcome to PPCG! :)

Python 2, 82 79 bytes
n=input()
o=""
for k in[1000]*2+[60]*3:o=":%0*d"%(k%7/2,n%k)+o;n/=k
print o[1:]

Builds the string, iterating through a series of divmods. The only fancy bit is the %7/2, which maps 1000 -> 3 and 60 -> 2.

Pyth, 31 bytes
j\:_m>l`td+"00"%~/QddCM"ϨϨ<<<

Try it online: Demonstration
Explanation:
                                 implicit: Q = input number
                       "ϨϨ<<<   string "ϨϨ<<<" (5 chars but 7 bytes)
                     CM          convert each to number => [1000, 1000, 60, 60, 60]
    m                            map each number d to:
                 /Qd                divide Q by d
                ~                   and update Q with the new value
               %~ Q d               but use the old value to calculate Q mod d
          +"00"                     add the result to the string "00"
     >                              but only take the last
      l`td                          len(str(d-1)) chars
   _                             revert order
j\:                              join the strings with ":"s

Bash + coreutils, 61
Shortest "mainstream" language so far...
a=%02d:
printf $a$a$a%03d:%03d `dc -e$1\ A00~rA00~r60~r60~rf`

Test output:
$ for t in 0 12345678900 86400000000; do ./usec.sh $t; echo; done
00:00:00:000:000
03:25:45:678:900
24:00:00:000:000
$

CJam, 37 35 34 bytes
This is prettty long .. Golfing now..
ri[1e3_60__]{:ImdsIBb,0e[':@}%W%2>

UPDATE: 1 byte saved thanks to @Sp3000
Try it online here

q (34)
I'm sure it can be shorter
":"sv 0 8 11__[;8]15$2_($)16h$1e3*

e.g.
q)f:":"sv 0 8 11__[;8]15$2_($)16h$1e3*
q)f 12345678900
"03:25:45:678:900"

any online compilers ? in other words - How do I run it as a lazy person ?

32 bit version is available for free at http://www.kx.com

good spot. unfortunately the fix adds a few characters

you can cut more bytes here ":"sv 0 8 11__[;8]15$2_($)"n"$1e3*

C, 97 bytes
q=1000,s=60;
#define f(n)printf("%02d:%02d:%02d:%03d:%03d",n/s/s/q/q,n/s/q/q%s,n/q/q%s,n/q%q,n%q)

Test Code:
int main(int intc, char **argv)
{
    long long n = atoll(argv[1]);
    f(n);
}

Answers in C are supposed to be a complete, program; not a snippet.

It is not mentioned in the question. Is there some sort of global requirements?

Loopholes that are forbidden by default

No. If you read the answer, it is just using C as an example. The rule would have applied to every language. Also, the answer is hotly disputed - see the highest rated comment. The bottom line is the Question needs to state it clearly if a full program is required.

It has 41 upvotes and 9 downvotes, it's very much enforceable. That being said, you're defining a "function" which is an acceptable way to create an answer, so I would argue that this is fine.

Lots of answers on this site use functions instead of full programs - for example I don't think I have ever seen a Java answer that was a complete program...

I tried this on ideone, it returns 03:00:25:000:045 for 12345678900, which is incorrect.

I blame ideone. My code works fine with gcc on Linux and Mac. On ideone, even printf("%d:%d", n/q%q, n%q); ended up with 678:0. (it should be 678:900)

C#, 179 175 Bytes
When you have builtins at your disposal, why not use 'em?
static void Main(string[]a){var t=TimeSpan.FromTicks(long.Parse(Console.ReadLine())*10);Console.Write(t.ToString((t.Days<1?"hh":@"\2\4")+@"\:mm\:ss\:ffffff").Insert(12,":"));}

With better formatting:
static void Main(string[]a){
    var t = TimeSpan.FromTicks(long.Parse(Console.ReadLine())*10);
    Console.Write(t.ToString((t.Days<1?"hh":@"\2\4")+@"\:mm\:ss\:ffffff").Insert(12,":"));
    Console.Read();
}

Julia, 110 96 95 bytes
t->(o="";for i=int([36e8,6e7,1e6,1e3,1]) x,t=t÷i,t%i;o*=lpad(x,i>1e3?2:3,0)*":"end;o[1:end-1])

This creates an unnamed function that accepts an integer as input and returns a string. To call it, give it a name, e.g. f=t->....
Ungolfed + explanation:
function f(t)
    # Initialize an output string
    o = ""

    # Loop over an array consisting of the number of microseconds in
    # an hour, minute, second, millisecond, and microsecond
    for i = int([36e8, 6e7, 1e6, 1e3, 1])

        # Get the quotient and remainder for microseconds into t,
        # setting t to be the remainder
        x, t = t ÷ i, t % i

        # Left-pad x with zeroes and append it to the output
        o *= lpad(x, i > 1e3 ? 2 : 3, 0) * ":"
    end

    # o has a trailing :, so return everything but the last character
    o[1:end-1]
end

Examples:
julia> f(12345678900)
"03:25:45:678:900"

julia> f(0)
"00:00:00:000:000"

julia> f(86400000000)
"24:00:00:000:000"

Nice one. You get my vote because you inspired my Matlab answer :-)

Excel, 65 63 characters
Assuming your microseconds is in A1:
=TEXT(A1/50/1200^3,"[HH]:mm:ss:")&RIGHT(TEXT(A1,"000\:000"),7)

Output:
        A              B
1            0  00:00:00:000:000
2  12345678900  03:25:46:678:900
3  86400000000  24:00:00:000:000

Perl, 141 78 bytes
printf"%02d"x3.%03d:%03d",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_%1e3

77 bytes of code, +1 for the -n flag.
Run with:
echo 12345678900 | perl -ne'printf"%02d"x3.%03d:%03d",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_%1e3'

Thanks to Thomas Kwa and chilemagic for cutting my code size nearly in half.

I think 3600000000 can be 36e8.

Instead of chomp($n=<STDIN>); you can run it as a one-liner with the -n flag (which counts as 1 character). You also don't need the int(..) around each $_. Applying Thomas's tip too we can get it down to echo 12345678900 | perl -ne'printf"%02d:%02d:%02d:%03d:%03d\n",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_%1e3' and there might even be a shorter way too!

You don't need the \n in the output string either. You can also replace the string with "%02d:"x3 ."%03d:%03d"

@chilemagic Does using "echo" count as an increase in bytes?

@ASCIIThenANSI it doesn't because it isn't part of your program. The characters you would count are the ones between the single quotes, i.e. printf"%02d:%02d:%02d:%03d:%03d\n",$_/36e8,$_/6e7%60,$_/1e6%60,$_/1e3%1e3,$_%1e3 and then you add an additional byte for the -n flag. If you used -nle for example, that would count as an additional 2 (for the n and the l). You get the - and the e (or E if you need to use say) for free.

JavaScript (ES6), 128 118 116 111 bytes
There is probably some golfing potential in this.
f=t=>(t<864e8?new Date(t/1e3).toJSON().slice(11,-1):`24:00:00:000`).replace(`.`,`:`)+':'+('00'+t%1e3).slice(-3)

Demo
It is ES6 so Firefox only, for now anyways:

f=t=>(t<864e8?new Date(t/1e3).toJSON().slice(11,-1):`24:00:00:000`).replace(`.`,`:`)+':'+('00'+t%1e3).slice(-3)

// DEMO
document.body.innerHTML += '
' + f(0);
document.body.innerHTML += '
' + f(12345678020);
document.body.innerHTML += '
' + f(86400000000);

The first check is not needed, as the question is explicit: 0 <= n <= 86400000000

@edc65 Without the first check I can only get a range of 0 ≤ n < 86400000000, as 8.64e10 would roll over to the next day.

Oh right, I missed that. toJSON() instead of toISOString()?

CoffeeScript, 127 bytes
Took the approach in ASCIIThenANSI's answer. It's too bad that the JavaScript Console API doesn't have format placeholders for padding numbers.
p=(a,b)->('00'+~~a).slice -b||-2
f=(t)->console.log '%s:%s:%s:%s:%s',p(t/36e8),p(t/6e7%60),p(t/1e6%60),p(t/1e3%1e3,3),p t%1e3,3

Matlab - 88 89 bytes
Gained one byte with a solution without using the built in function:
n=[36e8,6e7,1e6,1e3];f=@(t)sprintf('%02d:%02d:%02d:%03d:%03d',fix([t mod(t,n)]./[n 1]))

Create an inline function which takes a numeric input argument t and return a string.
it uses a vectorized combination of fix and mod to separate the time elements, then display.
it's a bit frustrating that the formatting of the output string takes so much, more than the calculations themselves ...
Test:
for t=[0 12345678900 86400000000]
    f(t)
end

ans =
00:00:00:000:000
ans =
03:25:45:678:900
ans =
24:00:00:000:000

89 bytes version:
f=@(t)sprintf('%s:%03d:%03d',datestr(fix(t/1e6)/86400,13),fix(mod(t,1e6)/1e3),mod(t,1e3))

It splits the number, uses a built-in function for the hh:mm:ss part, which cannot deal with microseconds so the string is completed with combination of fix and mod operations

C, 113 103 105 bytes
EDIT: shoved off some more bytes
FIX: removed long type, thanks to some user
Not the shortest C answer, but I had some fun with carriage returns so I felt like someone might like this.
i,k,p=16;
#define f(n)for(;i<5;p-=i++<2?4:3)k=i<2?1000:60,printf("%0*d%c\r",p,n%k,i?58:13),n/=k;puts("");

Call it like:
int main() {
    long long n = 12345678900;
    f(n);

    return 0;
}

Depends on platform, "long" could be just 32-bits. (see https://en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models). I avoided the problem by declaring "f" as macro instead of function.

I noticed that. I assumed GCC on x64, fixing it tomorrow.

Powershell,153
$t=[timespan]::FromTicks(($a=$args[0]));"{0:D2}:{1:D2}:{2:D2}:{3:D3}:{4:000}"-f
[int]($t.TotalHours),$t.Minutes,$t.Seconds,$t.Milliseconds,(($a%1e4)/10)

Usage
powershell -nologo .\modprintsec.ps1 123456789000
03:25:45:678:900
powershell -nologo .\modprintsec.ps1 864000000000
24:00:00:000:000
powershell -nologo .\modprintsec.ps1 0
00:00:00:000:000

F#, 111 92 102 bytes
First iteration: Base idea.
Second iteration: Smaller constants
Third iteration: Correct formatting for single digit portions.
Note this function must be given an int64 to work.
let s,t=60L,1000L
let f n=sprintf"%02d:%02d:%02d:%03d:%03d"(n/s/s/t/t)(n/s/t/t%s)(n/t/t%s)(n/t%t)(n%t)

Example outputs:
f 0L           -> "00:00:00:000:000"
f 12345678900L -> "03:25:45:678:900"
f 86400000000L -> "24:00:00:000:000"

PHP - 115 102 bytes
A solution in 155 bytes (wrapped here on 3 lines for readability):
$a=$argv[1];
$h=($a-($m=($a=($a-($s=($a=($a-($t=($a=($a-($u=$a%1000))/1000)%1000))/1000)%60))/60)%60))/60;
printf("%02d:%02d:%02d:%03d:%03d",$h,$m,$s,$t,$u);

The second line computes (from inside to outside) the exact values of the components starting with the microseconds.
The shorter version (115 bytes, wrapped on two lines for readability):
$u=$argv[1];$h=($m=($s=($t=$u/1000)/1000)/60)/60;
printf("%02d:%02d:%02d:%03d:%03d",$h,$m%60,$s%60,$t%1000,$u%1000);

It also uses embedded assignments to compute the convert the input number of microseconds in milliseconds, seconds, minutes and hours using floating point numbers. The modulus operator (%) and the decimal number format (%d) of printf() is then used to force them to integer numbers (the fractional part is ignored).
Another solution that uses the date functions (102 bytes)
$u=$argv[1];
echo gmdate("H:i:s",strtotime("@".substr($u,0,-6))),":",substr($u,-6,3),":",substr($u,-3);

The hours:minutes:seconds part is handled by the PHP date functions gmdate() and strtotime(), the milli- and micro-seconds are extracted as strings from the input value.
Usage:
$ php -r '$u=$argv[1];echo gmdate("H:i:s",strtotime("@".substr($u,0,-6))),":",substr($u,-6,3),":",substr($u,-3);' 7198898787; echo
01:59:58:898:787

Java, 215 bytes
String f(long n){return p(n/3600000000l,2)+":"+p(n/60000000%60,2)+":"+p(n/1000000%60,2)+":"+p(n/1000%1000,3)+":"+p(n%1000,3);}String p(long n,int i){String s=String.valueOf(n);while(s.length()<i){s="0"+s;}return s;}

Method f does some calculations on n to work out the hours, minutes etc. and delegates to method p to format each value correctly.
Formatted:
String f(long n) {
    return p(n / 3600000000l, 2) + ":" + p(n / 60000000 % 60, 2) + ":"
            + p(n / 1000000 % 60, 2) + ":" + p(n / 1000 % 1000, 3) + ":" + p(n % 1000, 3);
}

String p(long n, int i) {
    String s = String.valueOf(n);
    while (s.length() < i) {
        s = "0" + s;
    }
    return s;
}

Usage:
public void demo() {
    long n = 12345678900l;
    System.out.println(f(n));
}

Ruby - 82 Bytes
puts (t=Time.at(0,gets.to_i)).strftime("%2H:%2M:%2S:%3L:#{(t.usec%1000).to_s.rjust(3,?0)}")

But I counted 91 bytes. It also only works in the UTC timezone.


text:
Print the Flag of the Arab Revolt!
It seems flags are a trend now, so what better place to start an account? I thought bars could use a twist to them, so I found this flag.
Produce the following in the console output the fewest possible bytes:
+----------------------------------+
|XXXXX                             |
|XXXXXXXX                          |
|XXXXXXXXX-------------------------+
|XXXXXXXXXXX                       |
|XXXXXXXXXXX                       |
|XXXXXXXXX-------------------------+
|XXXXXXXX                          |
|XXXXX                             |
+----------------------------------+

This crude rendition of the flag is 36 x 10 characters. A trailing newline on the last line is optional. You may use any language you choose. If it is an obscure language, please post a link to the language in your answer.

I am not a fan of the arbitrary "The answer must have fewer bytes than this flag..." as it discourages some really neat languages. They won't win anyway, so let them have their fun :)

You have a point. Editing!

Why did you accept an answer after 1 hour? That's way too short, IMHO. You should give people some time to submit answers before you pick a winner.

I guess. I'm new here, so I don't know what to expect.

It seems that every successive flag question has approximately half the votes of the previous one. If this keeps up, we should soon have a question with 1/1024 of a vote.

http://i.imgur.com/R7bK9rc.png

@steveverrill Actually, it has more than half, it's just that many votes are -1, rather than +1.

CJam, 44 bytes
8T5@9B]_W%+{I'|'+?'XI*34"-  "I=e]"+||"I=N}fI

(Thanks to @Dennis, @Jakube  and @Optimizer for -1 byte each)
8T5@9B]        Push [0 5 8 9 11]
_W%+           Add its reverse, to give [0 5 8 9 11 11 9 8 5 0]
{...}fI        For each I in the above array...
  I'|'+?         Push "+" if I == 0 else "|"
  'XI*             Push I "X"s
  34"-  "I=e]      Pad the "X"s to length 34 with "-" if I%3 == 0 else " "
  "+||"I=          Push "+" if I%3 == 0 else "|"
  N                Push a newline

"|+"I!= -> I'|'+? . And something similar for the "-  "I= and "+||"I= too

SQL (PostgreSQL flavour), 284 244 232 210 175 bytes
A HUGE Thank You to @manatwork for essentially the whole thing now.
A nice verbose language that still came in under the byte size of the flag, with a bit of a margin :)
Basically builds the half of the flag with using parameters.  This is cross joined with 1 and -1 giving us both halfs of the flag and a means to order it by negating the number of #'s in the row.
SELECT rpad(rpad(L,X,'X'),35,P)||R FROM(VALUES('|',12,' ','|'),('|',10,'-','+'),('|',9,' ','|'),('|',6,' ','|'),('+',1,'-','+'))F(L,X,P,R),(values(-1),(1))G(O)ORDER BY(12-X)*O

Formatted and commented
SELECT rpad(rpad(L,X,'X'),35,P)||R --Build each row from parameters
FROM(VALUES           -- Parameters for each row
    ('|',12,' ','|'), -- Start Char, Num of #, Pad Char, End Char
    ('|',10,'-','+'),
    ('|',9,' ','|'),
    ('|',6,' ','|'),
    ('+',1,'-','+')
    )F(L,X,P,R),
    (values(-1),(1))G(O) -- Cross join with order modifier
ORDER BY(12-X)*O -- Order by modified number of #

Change those '|XXXXX'||repeat(' ',29) into rpad('|XXXXX',35) to reduce it to 263 characters.

By the way, the sub-select is pointless, just the parenthesis does it: SELECT S FROM F UNION ALL(SELECT S FROM F ORDER BY I DESC) to reduce it to 250 characters. (At least in 9.4.4.)

@manatwork Thanks for the tips.  Worked out really nicely.

The I field is not necessary, as the strings that compose the flag are already in ascending order. Getting rid of that auxiliary field has the benefit of not needing the aliases anymore. And as asc is ``shorter than desc, you can squeeze one more characters by declaring the flag in reverse order, then reverse the top half using the shorter keyword: WITH F AS(SELECT*FROM(VALUES(rpad('|XXXXXXXXXXX',35)||'|'),(rpad('|XXXXXXXXX',35,'-')||'+'),(rpad('|XXXXXXXX',35)||'|'),(rpad('|XXXXX',35)||'|'),(rpad('+',35,'-')||'+'))F)(SELECT*FROM F ORDER BY 1ASC)UNION ALL SELECT*FROM F

@manatwork Unfortunately the row starting with '+' gets ordered into the wrong position.  Otherwise that would have worked a treat.  I could have also dropped the ASC.  But I have adapted your suggestion to get a few more bytes.

Sadly that may depend on the used collation. :( But given that “+” (code 43) occurs before “|” (code 124) in the ASCII table, it works for me. And on SQL Fiddle too. Anyway, in meantime I found another solution which involves your original order field but gets rid of CTE  and union: SELECT S FROM(VALUES(1,rpad('|XXXXXXXXXXX',35)||'|'),(2,rpad('|XXXXXXXXX',35,'-')||'+'),(3,rpad('|XXXXXXXX',35)||'|'),(4,rpad('|XXXXX',35)||'|'),(5,rpad('+',35,'-')||'+'))F(I,S),(values(-1),(1))G(P)ORDER BY I*P

@manatwork oh very nice

The 5 separate formatting is still too long. Better use a single formatting based on Left char, X count, Pad char and Right char. And while the X count will be an increasing integer, it can replace the I field in a modified order by formula: SELECT rpad(rpad(L,X,'X'),35,P)||R FROM(VALUES('|',12,' ','|'),('|',10,'-','+'),('|',9,' ','|'),('|',6,' ','|'),('+',1,'-','+'))F(L,X,P,R),(values(-1),(1))G(O)ORDER BY(12-X)*O

@manatwork  You should post that yourself.  It's way different to where I started and really quite impressive golfing.  Sub 200 with SQL.  I was happy with sub 300:)

Such answer would start anyway with a disclaimer “inspired by MickyT, if you like the base idea, please upvote his answer”. What I suggested is not much different than what you currently have. Feel free to use it.

CJam, 52 51 50 bytes
8U5@9B]34X$f-]z87Zb"X ||X-++X-+|"4/f=..*1fm>_W%+N*

Thanks to @Sp3000 for golfing off 1 byte!
Try it online in the CJam interpreter.
How it works
8U5@9B] e# Push [0 5 8 9 11] (`@` rotates on top).
34X$f-  e# Subtract each integer from 34.
]z      e# Wrap and zip. This pushes [[0 34] [5 29] [8 26] [9 25] [11 23]].
87Zb    e# Push [1 0 0 2 0] (87 in base 3).

"X ||X-++X-+|"4/

        e# Push ["X ||" "X-++" "X-+|"].

f=      e# Select for each. This pushes ["X-++" "X ||" "X ||" "X-+|" "X ||"].

..*     e# Twofold vectorized repetition.
        e# EXAMPLE: [9 25]"X-+|".* -> "XXXXXXXXX-------------------------+|"

1fm>    e# Rotate each string one character to the right.
_W%     e# Copy the resulting array and reverse the order of its lines.
+N*     e# Concatenate and join by linefeeds.

Python 2, 80
for n in 0,5,8,9,11,11,9,8,5,0:print'|+'[n<1]+'X'*n+'-  '[n%3]*(34-n)+'+||'[n%3]

Instead of iterating over the row numbers, iterate over the number of X-symbols directly. The stripes happen where n is 0 or 9, which are the only multiples of 3, and so can be checked by the value n%3 (thanks Sp3000).
This can surely be shortened in Python 3 by converting the list of numbers to a bytes object.

I was all proud of mine, and yours is just the same except better :P

JavaScript (ES6), 147 132  127  111 106 bytes
[0,5,8,9,11,11,9,8,5,0].map(v=>console.log('|+'[+!v]+'X'.repeat(v)+' -'[z=+!(v%3)].repeat(36-v)+'|+'[z]))

Demo
As it is ES6, it only works in Firefox at the moment.

// DEMO: redefine console.log to have output inside the snippet
// Taken from https://codegolf.stackexchange.com/a/52411/22867
console.log = (...x) => O.innerHTML += x + '\n';

// Actual program
[0,5,8,9,11,11,9,8,5,0].map(v=>console.log('|+'[+!v]+'X'.repeat(v)+' -'[z=+!(v%3)].repeat(36-v)+'|+'[z]))

<output id=O></output>

-6: [0,5,8,9,11,11,9,8,5,0].map(v=>console.log('|+'[+!v]+'X'.repeat(v)+' -'[z=+!(v%9)].repeat(36-v)+'|+'[z]))

C, 157 155 151 146 bytes
i;f(){for(char b[36];i<10;printf("%c%.34s%c\n",i++%9?124:43,b,i%3?124:43))memset(b,i%3?32:45,34),i%9?memset(b,120,35253>>((i<5?5-i:i)%4*4)&15):0;}

edit: I moved the string length inside of the format string and found two bytes.
edit: Added Cool Guy's recommendation and found four bytes.
edit: Removed the array and replaced it with a 4-bit packed short that's shifted to get the 'x' lengths

I'm having issues compiling this.

Let me know what error you're receiving and I will see if I can recreate it. I'm compiling using Cygwin GCC 4.8.3 using no compiler flags other than -o.

@CamelCaseCode This requires C99 or above. BTW, don't care about the warnings...

@openaddr for(;i<10;) --> for(char b[36];i<10;printf("%c%.34s%c\n",i++%9?124:43,b,i%3?124:43) saves two bytes. Also, you can remove the {...} of the loop and change ;i%9? to ,i%9?. +1 anyway. Nice solution!

@Cool Guy Thanks and good catch on the printf. I was going to put the buffer initializer in the for block, but the compiler complained that declarations within the for header is a C99 feature, so I left it out for maximum compatibility. If the reason CamelCaseCode couldn't compile is indeed because there is some other C99 feature that the compiler missed, then that won't matter anyways since it's already C99 specific.

Apparently, That does not matter. In code-golf, portability is not required. And (int[]){5,11,9,8} is a C99 feature.

CJam, 60 54 50 48 45 bytes
Compared to the previous version, I realized that one of the 5 entries in my descriptors was always the same, which was kind of pointless. Using a fixed value for it:
"++-0|| 5|| 8|+-9|| B"4/_W%+{1/~~'X*34@e]\N}/

Try it online
Thanks to @aditsu and @Sp3000 for some related help in chat this morning.
The basic approach here is that I have 4 character descriptors for the pattern of each line, where the characters in the descriptor are:

First character.
Last character.
Right fill character.
Repeat count for left fill character.

The left fill character, which was part of the descriptor in earlier versions of this solution, is always X, so it is now not part of the descriptor anymore.
These descriptors are specified for the top 5 lines, and repeated for the bottom 5 lines in reverse order.
Explanation:
"++-0|| 5|| 8|+-9|| B"
        Descriptors for top 5 lines, as described above.
4/      Split into 5 descriptors of 4 characters each.
_W%     Repeat the 5 descriptors in reverse order.
{       Loop over lines/descriptors.
    1/    Split descriptor string into array with 5 one-character strings.
    ~     Unwrap the array.
    ~     Evaluate last entry in descriptor, which is the count.
    'X    Left fill character.
    *     Repeat left fill character by given count.
    34@e] Pad to 34 characters using right fill character.
    \     Swap last character to top.
    N     Add a newline.
}/    End loop over lines/descriptors.

Python 3, 282 bytes/characters
f,l,h=lambda a:a in{0,35}and '+'or'-',lambda a:a%3 and'|'or'+',lambda a:a and(a<10 and 'X'or'-')or'|';print("\n".join("".join(x)for x in[[k in{0,9}and f(j)or j==35 and l(k)or k%3 and(j==0 and'|'or j<[0,6,9,0,12,12,0,9,6][k]and'X'or' ')or h(j)for j in range(36)]for k in range(10)]))

Output is, of course:
+----------------------------------+
|XXXXX                             |
|XXXXXXXX                          |
|XXXXXXXXX-------------------------+
|XXXXXXXXXXX                       |
|XXXXXXXXXXX                       |
|XXXXXXXXX-------------------------+
|XXXXXXXX                          |
|XXXXX                             |
+----------------------------------+

I'm sure there's a much shorter way to do this in Python.

You can use indexing to reduce a fair bit of the ... and ... or ..., e.g. "+||"[a%3]

Also, I'm not sure the lambdas are necessary... I don't think you call them enough times for it to be worth it

@Sp3000, you're probably right. If I remember to I'll refactor it later.

Ruby, 156 155 chars
h=[5,8,9,11];l=34;t=?++(?-*l)+?+;puts t;2.times{h.each{|c|if c==9 then j='-+' else j=' |';end;print(?|,((?X*c).ljust(l,j[0])),j[1],?\n)};h.reverse!};puts t

I used an array, h, with the values [5, 8, 9, 11], so I can use 2.times { h.each { code }; h.reverse } because the flag is symmetrical horizontally. I also use 34 many times in the code, so it is assigned to l. ?x is shorthand for "x".

Ruby, 78
"@EHIKKIHE@".each_byte{|i|puts"+|"[i/65]+?X*(i-64)+" -"[i%3]*(98-i)+"|+"[i%3]}

A copy of Rinkattendant's / Xnor's idea of iterating over the lengths of the strings of X's. Except instead of using an array, I have compressed them into a string.
Ruby, 96
Original plain vanilla approach
(0..9).each{|i|puts (i%9<1??+:?|)+(?X*("@EHIKKIHE@"[i].ord-64)).ljust(34,"-  "[i%3])+"+||"[i%3]}

Ungolfed
(0..9).each{|i|
   puts (i%9<1??+:?|)                                          #first character + or |
   +(?X*("@EHIKKIHE@"[i].ord-64)).ljust(34,"-  "[i%3])         #print quantity of X's according to string, then right justify with - or space
   +"+||"[i%3]}                                                #last character + or |

Swift 1.2, 157 bytes
Can be run in a playground, or from a file using swift file.swift in Terminal.
let z="-----",x="XXX",y="   ",g=y+y,w=z+z+z+z+"----+",e=g+g+g+y+"  |",c="|XX"+x,d=["+"+z+z+w,c+g+e,c+x+y+e,c+x+"X-"+w,c+x+x+e]
print("\n".join(d+reverse(d)))

PHP, 135 bytes
Lets play around with printf:
<?$A='|%-34s|
|%-34s|';$B="|%'--34s|";printf("+%'-34s+
$A
$B
$A
$B
$A
+%'-34s+",'',$a=XXXXX,$b=$a.XXX,$c=$b.X,$d=$b.XX,$d,$c,$b,$a,'');

Maybe there are some edges that I've left behind that can be cut.
But it was fun!

Vyxal j, 41 bytes
»'ꜝ»12τƛ\X*34↲n9=[ð\-V\+|\|]+\|p;\+17-mpm

Try it Online!
    12τ                                   # Base-12 digits of...
»'ꜝ»                                      # 9119 (so 5,8,9,11)
       ƛ                        ;         # Mapped to...
        \X*                               # That many Xs
           34↲                            # Padded to width of 34
              n9=[         ]              # If it's a 9...
                  ð\-V\+                  # Replace all spaces with -s and append a +
                        |\|               # Else append a |
                            +\|p          # Prepend a |
                                 \+       # '+'
                                   17-    # Append 17 -s
                                      m   # Mirror the result
                                       p  # Prepend that to the rest
                                        m # Mirror the lot.

Sed - 228
s/.*/eeeeee\neeeeee/
s/e/------/g
s/^-/+/
s/-$/+/
s/-\n-/+\n+/
s/\n/\nabcddcba/
s/\([a-d]\)/|XXXXX\1\1\1\1\1\1\n/g
s/\([a-d]\)/\1\1\1\1\1/g
s/Xbbb/XXXX/g
s/Xcccc/XXXXX/g
s/Xdddddd/XXXXXXX/g
y/abcd/  - /
s/ \n/|\n/g
s/-\n/+\n/g
q

Because of the way sed works, this requires a line of input to output the flag.

Haskell, 233 bytes
putStr$uncurry((.toEnum).replicate)=<<foldl1(++)(((++)=<<reverse)$zipWith zip[[1,11,23,1,1],[1,9,25,1,1],[1,8,26,1,1],[1,5,29,1,1],[1,34,1,1]][[124,88,32,124,10],[124,88,45,43,10],[124,88,32,124,10],[124,88,32,124,10],[43,45,43,10]])

Deadfish~, 558 bytes
{iiii}iiicii{ccc}ccccddc{ddd}c{{i}i}ic{ddd}ddddddccccc{dddddd}iiii{cc}ccccccccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddcccccccc{dddddd}iiii{cc}cccccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddccccccccc{dddd}ddd{cc}ccccc{{i}dd}dcd{{d}d}c{{i}i}ic{ddd}dddddd{c}c{dddddd}iiii{cc}ccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}dddddd{c}c{dddddd}iiii{cc}ccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddccccccccc{dddd}ddd{cc}ccccc{{i}dd}dcd{{d}d}c{{i}i}ic{ddd}ddddddcccccccc{dddddd}iiii{cc}cccccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddccccc{dddddd}iiii{cc}ccccccccc{{i}d}iicd{{d}d}c{iii}cii{ccc}ccccddc

Try it online!