text:
Fastest Mini-Flak Quine
Mini-Flak is a subset of the Brain-Flak language, where the <>, <...> and [] operations are disallowed.  Strictly speaking it must not match the following regex:
.*(<|>|\[])

Mini-Flak is the smallest known Turing complete subset of Brain-Flak.

A little while ago I was able to make a Quine in Mini-Flak, but it was too slow to run in the lifetime of the universe.
So my challenge to you is to make a faster Quine.

Scoring
To score your code put a @cy flag at the end of your code and run it in the Ruby interpreter (Try it online uses the ruby interpreter) using the -d flag. Your score should print to STDERR as follows:
@cy <score>

This is the number of cycles your program takes before terminating and is the same between runs.  Since each cycle takes about the same amount of time to be run your score should be directly correlated to the time it takes to run your program.
If your Quine is too long for you to reasonably run on your computer you can calculate the number of cycles by hand.
Calculating the number of cycles is not very difficult.  The number of cycles is equivalent to 2 times the number of monads run plus the number of nilads run.  This is the same as replacing every nilad with a single character and counting the number of characters run in total.
Example scoring

(()()()) scores 5 because it has 1 monad and 3 nilads.

(()()()){({}[()])} scores 29 because the first part is the same as before and scores 5 while the loop contains 6 monads and 2 nilads scoring 8.  The loop is run 3 times so we count its score 3 times.  1*5 + 3*8 = 29

Requirements
Your program must...

Be at least 2 bytes

Print its source code when executed in Brain-Flak using the -A flag

Not match the regex .*(<|>|\[])

Tips

The Crane-Flak interpreter is categorically faster than the ruby interpreter but lacks some of the features.  I would recommend testing your code using Crane-Flak first and then score it in the ruby interpreter when you know it works.  I would also highly recommend not running your program in TIO.  Not only is TIO slower than the desktop interpreter, but it will also timeout in about a minute.  It would be extremely impressive if someone managed to score low enough to run their program before TIO timed out.

[(...)]{} and (...)[{}] work the same as <...> but do not break the restricted source requirement

You can check out Brain-Flak and Mini-Flak Quines if you want an idea of how to approach this challenge.

"current best" -> "current only"

Mini-Flak, 6851113 cycles
The program (literally)
I know most people aren't likely expecting a Mini-Flak quine to be using unprintable characters and even multi-byte characters (making the encoding relevant). However, this quine does, and the unprintables, combined with the size of the quine (93919 characters encoded as 102646 bytes of UTF-8), make it fairly difficult to place the program into this post.
However, the program is very repetitive, and as such, compresses really well. So that the entire program is available literally from Stack Exchange, there's an xxd reversible hexdump of a gzip-compressed version of the full quine hidden behind the collapsible below:

00000000: 1f8b 0808 bea3 045c 0203 7175 696e 652e  .......\..quine.
00000010: 6d69 6e69 666c 616b 00ed d9db 6a13 4118  miniflak....j.A.
00000020: 0060 2f8b f808 0d64 a1c1 1dc8 4202 c973  .`/....d....B..s
00000030: 4829 4524 0409 22e2 5529 a194 1242 1129  H)E$..".U)...B.)
00000040: d2d7 ca93 f9cf 4c4c d45b 9536 e6db 6967  ......LL.[.6..ig
00000050: 770e 3bc9 ffed eca9 edb7 b1a4 9ad2 6a1d  w.;...........j.
00000060: bfab 75db c6c6 6c5f 3d4f a5a6 8da6 dcd8  ..u...l_=O......
00000070: 465b d4a5 5a28 4bd9 719d 727b aa79 f9c9  F[..Z(K.q.r{.y..
00000080: 43b6 b9d7 8b17 cd45 7f79 d3f4 fb65 7519  C......E.y...eu.
00000090: 59ac 9a65 bfdf 8f86 e6b2 69a2 bc5c 4675  Y..e......i..\Fu
000000a0: d4e4 bcd9 5637 17b9 7099 9b73 7dd3 fcb2  ....V7..p..s}...
000000b0: 4773 b9bc e9bd b9ba 3eed 9df7 aeaf 229d  Gs......>.....".
000000c0: e6ed 5eae 3aef 9d46 21b2 5e4d bd28 942e  ..^.:..F!.^M.(..
000000d0: 6917 d71f a6bf 348c 819f 6260 dfd9 77fe  i.....4...b`..w.
000000e0: df86 3e84 74e4 e19b b70e 9af0 111c fa0d  ..>.t...........
000000f0: d29c 75ab 21e3 71d7 77f6 9d8f f902 6db2  ..u.!.q.w.....m.
00000100: b8e1 0adf e9e0 9009 1f81 f011 18d8 1b33  ...............3
00000110: 72af 762e aac2 4760 6003 1bd8 698c c043  r.v...G``...i..C
00000120: 8879 6bde 9245 207c 04ae 5ce6 2d02 e1bb  .yk..E |..\.-...
00000130: 7291 4540 57f8 fe0d 6546 f89b a70b 8da9  r.E@W...eF......
00000140: f5e7 03ff 8b8f 3ad6 a367 d60b f980 679d  ......:..g....g.
00000150: d3d6 1c16 f2ff a767 e608 57c8 c27d c697  .......g..W..}..
00000160: 4207 c140 9e47 9d57 2e50 6e8e c215 b270  B..@.G.W.Pn....p
00000170: bdf6 9926 9e47 9d05 ce02 0ff0 5ea7 109a  ...&.G......^...
00000180: 8ba6 b5db 880b 970b 9749 2864 47d8 1b92  .........I(dG...
00000190: 39e7 9aec 8f0e 9e93 117a 6773 b710 ae53  9........zgs...S
000001a0: cd01 17ee b30e d9c1 15e6 6186 7a5c dc26  ..........a.z\.&
000001b0: 9750 1d51 610a d594 10ea f3be 4b7a 2c37  .P.Qa.......Kz,7
000001c0: 2f85 7a14 8fc4 a696 304d 4bdf c143 8db3  /.z.....0MK..C..
000001d0: d785 8a96 3085 2acc 274a a358 c635 8d37  ....0.*.'J.X.5.7
000001e0: 5f37 0f25 8ff5 6854 4a1f f6ad 1fc7 dbba  _7.%..hTJ.......
000001f0: 51ed 517b 8da2 4b34 8d77 e5b2 ec46 7a18  Q.Q{..K4.w...Fz.
00000200: ffe8 3ade 6fed b2f2 99a3 bae3 c949 9ab5  ..:.o........I..
00000210: ab75 d897 d53c b258 a555 1b07 63d6 a679  .u...<.X.U..c..y
00000220: 4a51 5ead a23a 6a72 9eb6 d569 960b f3dc  JQ^..:jr...i....
00000230: 9ceb 53fa 658f 345f ad07 6f6f efce 06ef  ..S.e.4_..oo....
00000240: 0677 b791 cef2 f620 57bd 1b9c 4521 b241  .w..... W...E!.A
00000250: 4d83 2894 2eaf a140 8102 050a 1428 50a0  M.(....@.....(P.
00000260: 4081 0205 0a14 2850 a040 8102 050a 1428  @.....(P.@.....(
00000270: 50a0 4081 0205 0a14 2850 a040 8102 050a  P.@.....(P.@....
00000280: 1428 50a0 4081 0205 0a14 2850 a040 8102  .(P.@.....(P.@..
00000290: 050a 1428 50a0 4081 0205 0a14 2850 a040  ...(P.@.....(P.@
000002a0: 8102 050a 1428 50a0 4081 0205 0a14 2850  .....(P.@.....(P
000002b0: a040 8102 050a 1428 50a0 4081 0205 0a14  .@.....(P.@.....
000002c0: 2850 a040 8102 050a 1428 50a0 4081 0205  (P.@.....(P.@...
000002d0: 0a14 2850 a040 8102 050a 1428 50a0 4081  ..(P.@.....(P.@.
000002e0: 0205 0a14 2850 a040 8102 050a 1428 50a0  ....(P.@.....(P.
000002f0: 4081 0205 0a14 2850 a040 8102 050a 1428  @.....(P.@.....(
00000300: 50a0 4081 0205 0a14 2850 a040 8102 050a  P.@.....(P.@....
00000310: 1428 50a0 4081 0205 0a14 2850 a040 8102  .(P.@.....(P.@..
00000320: 050a 1428 50a0 4081 0205 0a14 2850 a040  ...(P.@.....(P.@
00000330: 8102 050a 1428 50a0 4081 0205 0a14 2850  .....(P.@.....(P
00000340: a040 8102 050a 1428 50a0 4081 0205 0a14  .@.....(P.@.....
00000350: 2850 a040 8102 050a 1428 50a0 4081 0205  (P.@.....(P.@...
00000360: 0a14 2850 a040 8102 050a 1428 50a0 4081  ..(P.@.....(P.@.
00000370: 0205 0a14 2850 a01c 14ca 7012 cbb4 a6e9  ....(P....p.....
00000380: e6db e6b1 e4b1 9e4c 4ae9 d3be f5f3 745b  .......LJ.....t[
00000390: 37a9 3d6a af49 7489 a6e9 ae5c 96dd 488f  7.=j.It....\..H.
000003a0: d31f 5da7 fbad 5d56 3e73 5277 7cf5 aa7b  ..]...]V>sRw|..{
000003b0: 3fbc df7c e986 c3ba 5ee4 3c6f 74f7 c3e1  ?..|....^.<ot...
000003c0: 301a bb45 d795 9afb fbdc 1495 65d5 6d9b  0..E........e.m.
000003d0: baf7 a5b4 a87d 4a5b d7fd b667 b788 ec27  .....}J[...g...'
000003e0: c5d8 28bc b96a 9eda 7a50 524d 290a a5cb  ..(..j..zPRM)...
000003f0: cbef 38cb c3ad f690 0100                 ..8.......

(Yes, it's so repetitive that you can even see the repeats after it's been compressed).
The question says "I would also highly recommend not running your program in TIO. Not only is TIO slower than the desktop interpreter, but it will also timeout in about a minute. It would be extremely impressive if someone managed to score low enough to run their program before TIO timed out." I can do that! It takes about 20 seconds to run on TIO, using the Ruby interpreter: Try it online!
The program (readably)
Now I've given a version of the program that computers can read, let's try a version that humans can read. I've converted the bytes that make up the quine into codepage 437 (if they have the high bit set) or Unicode control pictures (if they're ASCII control codes), added whitespace (any pre-existing whitespace was converted to control pictures), run-length-encoded using the syntax «string×length», and some data-heavy bits elided:
␠
(((()()()()){}))
{{}
    (({})[(()()()())])
    (({})(
        {{}{}((()[()]))}{}
        (((((((({})){}){}{})){}{}){}){}())
        {
            ({}(
                (␀␀!S␠su! … many more comment characters … oq␝qoqoq)
                («()×35» («()×44» («()×44» («()×44» («()×44» («()×45»
                … much more data encoded the same way …
                («()×117»(«()×115»(«()×117»
                «000010101011┬â┬ … many more comment characters … ┬â0┬â┬à00␈␈
                )[({})(
                    ([({})]({}{}))
                    {
                        ((()[()]))
                    }{}
                    {
                        {
                            ({}(((({}())[()])))[{}()])
                        }{}
                        (({}))
                        ((()[()]))
                    }{}
                )]{}
                %Wwy$%Y%ywywy$wy$%%%WwyY%$$wy%$$%$%$%$%%wy%ywywy'×almost 241»
                ,444454545455┬ç┬ … many more comment characters … -a--┬ü␡┬ü-a␡┬ü
            )[{}()])
        }{}
        {}({}())
    )[{}])
    (({})(()()()()){})
}{}{}␊

(The "almost 241" is because the 241st copy is missing the trailing ', but is otherwise identical to the other 240.)
Explanation
About the comments
The first thing to explain is, what's up with the unprintable characters and other junk that isn't Mini-Flak commands? You may think that adding comments to the quine just makes things harder, but this is a speed competition (not a size competition), meaning that comments don't hurt the speed of the program. Meanwhile, Brain-Flak, and thus Mini-Flak, just dump the contents of the stack to standard output; if you had to ensure that the stack contained only the characters that made up the commands of your program, you'd have to spend cycles cleaning the stack. As it is, Brain-Flak ignores most characters, so as long as we ensure that junk stack elements aren't valid Brain-Flak commands (making this a Brain-Flak/Mini-Flak polyglot), and aren't negative or outside the Unicode range, we can just leave them on the stack, allow them to be output, and put the same character in our program at the same place to retain the quine property.
There's one particularly important way we can take advantage of this. The quine works by using a long data string, and basically all the output from the quine is produced by formatting the data string in various ways. There's only one data string, despite the fact that the program has multiple pieces; so we need to be able to use the same data string to print different parts of the program. The "junk data doesn't matter" trick lets us do this in a very simple way; we store the characters that make up the program in the data string by adding or subtracting a value to or from their ASCII code. Specifically, the characters making up the start of the program are stored as their ASCII code + 4, the characters making up the section that's repeated almost 241 times as their ASCII code − 4, and the characters making up the end of the program are stored as their ASCII code − 8. We can then print any of these three parts of the program via printing every character of the data string with an offset; if, for example, we print it with 4 added to every character code, we get one repeat of the repeated section, with some comments before and after. (Those comments are simply the other sections of the program, with character codes shifted so that they don't form any valid Brain-Flak commands, because the wrong offset was added. We have to dodge Brain-Flak commands, not just Mini-Flak commands, to avoid violating the restricted-source part of the question; the choice of offsets was designed to ensure this.)
Because of this comment trick, we actually only need to be able to output the data string formatted in two different ways: a) encoded the same way as in the source, b) as character codes with a specified offset added to every code. That's a huge simplification that makes the added length totally worth it.
Program structure
This program consists of four parts: the intro, the data string, the data string formatter, and the outro. The intro and outro are basically responsible for running the data string and its formatter in a loop, specifying the appropriate format each time (i.e. whether to encode or offset, and what offset to use). The data string is just data, and is the only part of the quine for which the characters that make it up are not specified literally in the data string (doing that would obviously be impossible, as it would have to be longer than itself); it's thus written in a way that's particularly easy to regenerate from itself. The data string formatter is made of 241 almost identical parts, each of which formats a specific datum out of the 241 in the data string.
Each part of the program can be produced via the data string and its formatter as follows:

To produce the outro, format the data string with offset +8
To produce the data string formatter, format the data string with offset +4, 241 times
To produce the data string, format the data string via encoding it into the source format
To produce the intro, format the data string with offset -4

So all we have to do is to look at how these parts of the program work.
The data string
(«()×35» («()×44» («()×44» («()×44» («()×44» («()×45» …

We need a simple encoding for the data string as we have to be able to reverse the encoding in Mini-Flak code. You can't get much simpler than this!
The key idea behind this quine (apart from the comment trick) is to note that there's basically only one place we can store large amounts of data: the "sums of command return values" within the various nesting levels of the program source. (This is commonly known as the third stack, although Mini-Flak doesn't have a second stack, so "working stack" is likely a better name in the Mini-Flak context.) The other possibilities for storing data would be the main/first stack (which doesn't work because that's where our output has to go, and we can't move the output past the storage in a remotely efficient way), and encoded into a bignum in a single stack element (which is unsuitable for this problem because it takes exponential time to extract data from it); when you eliminate those, the working stack is the only remaining location.
In order to "store" data on this stack, we use unbalanced commands (in this case, the first half of a (…) command), which will be balanced within the data string formatter later on. Each time we close one of these commands within the formatter, it'll push the sum of a datum taken from the data string, and the return values of all the commands at that nesting level within the formatter; we can ensure that the latter add to zero, so the formatter simply sees single values taken from the data string.
The format is very simple: (, followed by n copies of (), where n is the number we want to store. (Note that this means we can only store non-negative numbers, and the last element of the data string needs to be positive.)
One slightly unintuitive point about the data string is which order it's in. The "start" of the data string is the end nearer the start of the program, i.e. the outermost nesting level; this part gets formatted last (as the formatter runs from innermost to outermost nesting levels). However, despite being formatted last, it gets printed first, because values pushed onto the stack first are printed last by the Mini-Flak interpreter. The same principle applies to the program as a whole; we need to format the outro first, then the data string formatter, then the data string, then the intro, i.e. the reverse of the order in which they are stored in the program.
The data string formatter
)[({})(
    ([({})]({}{}))
    {
        ((()[()]))
    }{}
    {
        {
            ({}(((({}())[()])))[{}()])
        }{}
        (({}))
        ((()[()]))
    }{}
)]{}

The data string formatter is made out of 241 sections which each have identical code (one section has a marginally different comment), each of which formats one specific character of the data string. (We couldn't use a loop here: we need an unbalanced ) to read the data string via matching its unbalanced (, and we can't put one of those inside a {…} loop, the only form of loop that exists. So instead, we "unroll" the formatter, and simply get the intro/outro to output the data string with the formatter's offset 241 times.)
)[({})( … )]{}

The outermost part of a formatter element reads one element of the data string; the simplicity of the data string's encoding leads to a little complexity in reading it. We start by closing the unmatched (…) in the data string, then negate ([…]) two values: the datum we just read from the data string (({})) and the return value of the rest of the program. We copy the return value of the rest of the formatter element with (…) and add the copy to the negated version with {}. The end result is that the return value of the data string element and formatter element together is the datum minus the datum minus the return value plus the return value, or 0; this is necessary to make the next data string element out produce the correct value.
([({})]({}{}))

The formatter uses the top stack element to know which mode it's in (0 = format in data string formatting, any other value = the offset to output with). However, just having read the data string, the datum is on top of the format on the stack, and we want them the other way round. This code is a shorter variant of the Brain-Flak swap code, taking a above b to b above a + b; not only is it shorter, it's also (in this specific case) more useful, because the side effect of adding b to a is not problematic when b is 0, and when b is not 0, it does the offset calculation for us.
{
    ((()[()]))
}{}
{
    …
    ((()[()]))
}{}

Brain-Flak only has one control flow structure, so if we want anything other than a while loop, it'll take a bit of work. This is a "negate" structure; if there's a 0 on top of the stack, it removes it, otherwise it places a 0 on top of the stack. (It works pretty simply: as long as there isn't a 0 on top of the stack, push 1 − 1 to the stack twice; when you're done, pop the top stack element.)
It's possible to place code inside a negate structure, as seen here. The code will only run if the top of the stack was nonzero; so if we have two negate structures, assuming the top two stack elements aren't both zero, they'll cancel each other out, but any code inside the first structure will run only if the top stack element was nonzero, and the code inside the second structure will run only if the top stack element was zero. In other words, this is the equivalent of an if-then-else statement.
In the "then" clause, which runs if the format is nonzero, we actually have nothing to do; what we want is to push the data+offset to the main stack (so that it can be output at the end of the program), but it's there already. So we only have to deal with the case of encoding the data string element in source form.
{
    ({}(((({}())[()])))[{}()])
}{}
(({}))

Here's how we do that. The {({}( … )[{}()])}{} structure should be familiar as a loop with a specific number of iterations (which works by moving the loop counter to the working stack and holding it there; it'll be safe from any other code, because access to the working stack is tied to the nesting level of the program). The body of the loop is ((({}())[()])), which makes three copies of the top stack element and adds 1 to the lowest. In other words, it transforms a 40 on top of the stack into 40 above 40 above 41, or viewed as ASCII, ( into ((); running this repeatedly will make ( into (() into (()() into (()()() and so on, and thus is a simple way to generate our data string (assuming that there's a ( on top of the stack already).
Once we're done with the loop, (({})) duplicates the top of the stack (so that it now starts ((()… rather than (()…. The leading ( will be used by the next copy of the data string formatter to format the next character (it'll expand it into (()(()… then (()()(()…, and so on, so this generates the separating ( in the data string).
%Wwy$%Y%ywywy$wy$%%%WwyY%$$wy%$$%$%$%$%%wy%ywywy'

There's one last bit of interest in the data string formatter. OK, so mostly this is just the outro shifted 4 codepoints downwards; however, that apostrophe at the end may look out of place. ' (codepoint 39) would shift into + (codepoint 43), which isn't a Brain-Flak command, so you may have guessed that it's there for some other purpose.
The reason this is here is because the data string formatter expects there to be a ( on the stack already (it doesn't contain a literal 40 anywhere). The ' is actually at the start of the block that's repeated to make up the data string formatter, not the end, so after the characters of the data string formatter have been pushed onto the stack (and the code is about to move onto printing the data string itself), the outro adjusts the 39 on top of the stack into a 40, ready for the formatter (the running formatter itself this time, not its representation in the source) to make use of it. That's why we have "almost 241" copies of the formatter; the first copy is missing its first character. And that character, the apostrophe, is one of only three characters in the data string that don't correspond to Mini-Flak code somewhere in the program; it's there purely as a method of providing a constant.
The intro and outro
(((()()()()){}))
{{}
    (({})[(()()()())])
    (({})(
        {{}{}((()[()]))}{}
        (((((((({})){}){}{})){}{}){}){}())
        {
            ({}(
                (␀␀!S␠su! … many more comment characters … oq␝qoqoq)
                …
            )[{}()])
        }{}
        {}({}())
    )[{}])
    (({})(()()()()){})
}{}{}␊

The intro and outro are conceptually the same part of the program; the only reason we draw a distinction is that the outro needs to be output before the data string and its formatter are (so that it prints after them), whereas the intro needs to be output after them (printing before them).
(((()()()()){}))

We start by placing two copies of 8 on the stack. This is the offset for the first iteration. The second copy is because the main loop expects there to be a junk element on top of the stack above the offset, left behind from the test that decides whether to exist the main loop, and so we need to put a junk element there so that it doesn't throw away the element we actually want; a copy is the tersest (thus fastest to output) way to do that.
There are other representations of the number 8 that are no longer than this one. However, when going for fastest code, this is definitely the best option. For one thing, using ()()()() is faster than, say, (()()){}, because despite both being 8 characters long, the former is a cycle faster, because (…) is counted as 2 cycles, but () only as one. Saving one cycle is negligible compared to a much bigger consideration for a quine, though: ( and ) have much lower codepoints than { and }, so generating the data fragment for them will be much faster (and the data fragment will take up less space in the code, too).
{{} … }{}{}

The main loop. This doesn't count iterations (it's a while loop, not a for loop, and uses a test to break out). Once it exits, we discard the top two stack elements; the top element is a harmless 0, but the element below will be the "format to use on the next iteration", which (being a negative offset) is a negative number, and if there are any negative numbers on the stack when the Mini-Flak program exits, the interpreter crashes trying to output them.
Because this loop uses an explicit test to break out, the result of that test will be left on the stack, so we discard it as the first thing we do (its value isn't useful).
(({})[(()()()())])

This code pushes 4 and f − 4 above a stack element f, whilst leaving that element in place. We're calculating the format for the next iteration in advance (while we have the constant 4 handy), and simultaneously getting the stack into the correct order for the next few parts of the program: we'll be using f as the format for this iteration, and the 4 is needed before that.
(({})( … )[{}])

This saves a copy of f − 4 on the working stack, so that we can use it for the next iteration. (The value of f will still be present at that point, but it'll be in an awkward place on the stack, and even if we could manoeuvre it to the correct place, we'd have to spend cycles subtracting 4 from it, and cycles printing the code to do that subtraction. Far easier simply to store it now.)
{{}{}((()[()]))}{}

A test to see if the offset is 4 (i.e. f − 4 is 0). If it is, we're printing the data string formatter, so we need to run the data string and its formatter 241 times rather than just once at this offset. The code is fairly simple: if f − 4 is nonzero, replace the f − 4 and the 4 itself with a pair of zeros; then in either case, pop the top stack element. We now have a number above f on the stack, either 4 (if we want to print this iteration 241 times) or 0 (if we want to print it only once).
(
    ((((((({})){}){}{})){}{}){}){}
    ()
)

This is an interesting sort of Brain-Flak/Mini-Flak constant; the long line here represents the number 60. You may be confused at the lack of (), which are normally all over the place in Brain-Flak constants; this isn't a regular number, but a Church numeral, which interprets numbers as a duplication operation. For example, the Church numeral for 60, seen here, makes 60 copies of its input and combines them all together into a single value; in Brain-Flak, the only things we can combine are regular numbers, by addition, so we end up adding 60 copies of the top of the stack and thus multiplying the top of the stack by 60.
As a side note, you can use an Underload numeral finder, which generates Church numerals in Underload syntax, to find the appropriate number in Mini-Flak too. Underload numerals (other than zero) use the operations "duplicate top stack element" : and "combine top two stack elements" *; both those operations exist in Brain-Flak, so you just translate : to ), * to {}, prepend a {}, and add enough ( at the start to balance (this is using a weird mix of the main stack and working stack, but it works).
This particular code fragment uses the church numeral 60 (effectively a "multiply by 60" snippet), together with an increment, to generate the expression 60x + 1. So if we had a 4 from the previous step, this gives us a value of 241, or if we had a 0, we just get a value of 1, i.e. this correctly calculates the number of iterations we need.
The choice of 241 is not coincidental; it was a value chosen to be a) approximately the length at which the program would end up anyway and b) 1 more than 4 times a round number. Round numbers, 60 in this case, tend to have shorter representations as Church numerals because you have more flexibility in factors to copy. The program contains padding later on to bring the length up to 241 exactly.
{
    ({}(
        …
    )[{}()])
}{}

This is a for loop, like the one seen earlier, which simply runs the code inside it a number of times equal to the top of the main stack (which it consumes; the loop counter itself is stored on the working stack, but visibility of that is tied to the program's nesting level and thus it's impossible for anything but the for loop itself to interact with it). This actually runs the data string and its formatter 1 or 241 times, and as we've now popped all the values we were using for our control flow calculation from the main stack, we have the format to use on top of it, ready for the formatter to use.
(␀␀!S␠su! … many more comment characters … oq␝qoqoq)

The comment here isn't entirely without interest. For one thing, there are a couple of Brain-Flak commands; the ) at the end is naturally generated as a side effect of the way the transitions between the various segments of the program work, so the ( at the start was manually added to balance it (and despite the length of the comment inside, putting a comment inside a () command is still a () command, so all it does is add 1 to the return value of the data string and its formatter, something that the for loop entirely ignores).
More notably, those NUL characters at the start of the comment clearly aren't offsets from anything (even the difference between +8 and -4 isn't enough to turn a ( into a NUL). Those are pure padding to bring the 239-element data string up to 241 elements (which easily pay for themselves: it would take much more than two bytes to generate 1 vs. 239 rather than 1 vs. 241 when calculating the number of iterations required). NUL was used as the padding character because it has the lowest possible codepoint (making the source code for the data string shorter and thus faster to output).
{}({}())

Drop the top stack element (the format we're using), add 1 to the next (the last character to be output, i.e. the first character to be printed, of the program section we just formatted). We don't need the old format any more (the new format is hiding on the working stack); and the increment is harmless in most cases, and changes the ' at one end of the source representation of the data string formatter into a ( (which is required on the stack for next time we run the formatter, to format the data string itself). We need a transformation like that in the outro or intro, because forcing each data string formatter element to start with ( would make it somewhat more complex (as we'd need to close the ( and then undo its effect later), and we'd somehow need to generate an extra ( somewhere because we only have almost 241 copies of the formatter, not all 241 (so it's best that a harmless character like ' is the one that's missing).
(({})(()()()()){})

Finally, the loop exit test. The current top of the main stack is the format we need for the next iteration (which just came back off the working stack). This copies it and adds 8 to the copy; the resulting value will be discarded next time round the loop. However, if we just printed the intro, the offset was -4 so the offset for the "next iteration" will be -8; -8 + 8 is 0, so the loop will exit rather than continuing onto the iteration afterwards.

128,673,515 cycles
Try it online
Explanation
The reason that Miniflak quines are destined to be slow is Miniflak's lack of random access.  To get around this I create a block of code that takes in a number and returns a datum.  Each datum represents a single character like before and the main code simply queries this block for each one at a time.  This essentially works as a block of random access memory.

This block of code has two requirements.

It must take a number and output only the character code for that character

It must be easy to reproduce the lookup table bit by bit in Brain-Flak

To construct this block I actually reused a method from my proof that Miniflak is Turing complete.  For each datum there is a block of code that looks like this:
(({}[()])[(())]()){(([({}{})]{}))}{}{(([({}{}(%s))]{}))}{}

This subtracts one from the number on top of the stack and if zero pushes %s the datum beneath it.  Since each piece decrements the size by one if you start with n on the stack you will get back the nth datum.
This is nice and modular, so it can be written by a program easily.

Next we have to set up the machine that actually translates this memory into the source.  This consists of 3 parts as such:
(([()]())())
{({}[(
  -Look up table-
 )]{})
 1. (({}[()])[(())]()){(([({}{})]{}))}{}{([({}{}(([{}]))(()()()()()))]{})}{}

 2. (({}[()])[(())]()){(([({}{})]{}))}{}{([({}{}
      (({}[(
      ({}[()(((((()()()()()){}){}){}))]{}){({}[()(({}()))]{}){({}[()(({}((((()()()){}){}){}()){}))]{}){({}[()(({}()()))]{}){({}[()(({}(((()()()()())){}{}){}))]{}){([(({}{}()))]{})}}}}}{}
      (({}({}))[({}[{}])])
     )]{}({})[()]))
      ({[()]([({}({}[({})]))]{})}{}()()()()()[(({}({})))]{})
    )]{})}{}

 3. (({}[()])[(())]()){(([({}{})]{}))}{}{([({}{}
     (({}(({}({}))[({}[{}])][(
     ({}[()(
      ([()](((()()[(((((((()()()){})())){}{}){}){})]((((()()()()())){}{}){})([{}]([()()](({})(([{}](()()([()()](((((({}){}){}())){}){}{}))))))))))))
     )]{})
     {({}[()(((({})())[()]))]{})}{}
     (([(((((()()()()){}){}()))){}{}([({})]((({})){}{}))]()()([()()]({}(({})([()]([({}())](({})([({}[()])]()(({})(([()](([({}()())]()({}([()](([((((((()()()())()){}){}){}()){})]({}()(([(((((({})){}){}())){}{})]({}([((((({}())){}){}){}()){}()](([()()])(()()({}(((((({}())())){}{}){}){}([((((({}))){}()){}){}]([((({}[()])){}{}){}]([()()](((((({}())){}{}){}){})(([{}](()()([()()](()()(((((()()()()()){}){}){}()){}()(([((((((()()()())){}){}())){}{})]({}([((((({})()){}){}){}()){}()](([()()])(()()({}(((((({}){}){}())){}){}{}(({})))))))))))))))))))))))))))))))))))))))))))))))
     )]{})[()]))({()()()([({})]{})}{}())
    )]{})}{}

   ({}[()])
}{}{}{}
(([(((((()()()()){}){}())){}{})]((({}))([()]([({}())]({}()([()]((()([()]((()([({})((((()()()()){}){}()){})]()())([({})]({}([()()]({}({}((((()()()()()){}){}){}))))))))))))))))))

The machine consists of four parts that are run in order starting with 1 and ending with 3.  I have labeled them in the code above.  Each section also uses the same lookup table format I use for the encoding.  This is because the entire program is contained in a loop and we don't want to run every section every time we run through the loop so we put in the same RA structure and query the section we desire each time.
1
Section 1 is a simple set up section.
The program tells first queries section 1 and datum 0. Datum 0 does not exist so instead of returning that value it simply decrements the query once for each datum.  This is useful because we can use the result to determine the number of data, which will become important in future sections.  Section 1 records the number of data by negativizing the result and queries Section 2 and the last datum.  The only problem is we cannot query section 2 directly.  Since there is another decrement left we need to  query a non-existant section 5.  In fact this will be the case every time we query a section within another section.  I will ignore this in my explanation however if you are looking a the code just remember 5 means go back a section and 4 means run the same section again.
2
Section 2 decodes the data into the characters that make up the code after the data block.  Each time it expects the stack to appear as so:
Previous query
Result of query
Number of data
Junk we shouldn't touch...

It maps each possible result (a number from 1 to 6) to one of the six valid Miniflak characters ((){}[]) and places it below the number of data with the "Junk we shouldn't touch".  This gets us a stack like:
Previous query
Number of data
Junk we shouldn't touch...

From here we need to either query the next datum or if we have queried them all move to section 3.  Previous query is not actually the exact query sent out but rather the query minus the number of data in the block.  This is because each datum decrements the query by one so the query comes out quite mangled.  To generate the next query we add a copy of the number of data and subtract one.  Now our stack looks like:
Next query
Number of data
Junk we shouldn't touch...

If our next query is zero we have read all the memory needed in section 3 so we add the number of data to the query again and slap a 4 on top of the stack to move onto section 3.  If the next query is not zero we put a 5 on the stack to run section 2 again.
3
Section 3 makes the block of data by querying our RAM just as section 3 does.
For the sake of brevity I will omit most of the details of how section 3 works.  It is almost identical to section 2 except instead of translating each datum into one character it translates each into a lengthy chunk of code representing its entry in the RAM.  When section 3 is done it tells the program to exit the loop.

After the loop has been run the program just needs to push the first bit of the quine ([()]())(()()()()){({}[(.  I does this with the following code implementing standard Kolmogorov-complexity techniques.
(([(((((()()()()){}){}())){}{})]((({}))([()]([({}())]({}()([()]((()([()]((()([({})((((()()()()){}){}()){})]()())([({})]({}([()()]({}({}((((()()()()()){}){}){}))))))))))))))))))

I hope this was clear.  Please comment if you are confused about anything.

About how long does this take to run? It times on TIO.

@Pavel I don't run it on TIO because that would be incredibly slow, I do use the same interpreter that TIO uses (the ruby one). It takes about 20 minutes to run on an old rack server I have access to.  It takes about 15 minutes in Crain-Flak, but Crain-Flak doesn't have debug flags so I cannot score it without running it in the Ruby interpreter.

@Pavel I ran it again and timed it.  It took 30m45.284s to complete on a rather low end server (roughly the equivalent of a average modern desktop) using the ruby interpreter.


text:
Efficiently generate all vector partitions
A vector partition is splitting a vector up a series of vectors such that their sum is the original. Here are a couple partitions:
[3, 1, 2] = [3, 1, 2]
[3, 1, 2] = [0, 0, 1] + [0, 0, 1] + [0, 1, 0] + [1, 0, 0] + [2, 0, 0]
[3, 1, 2] = [1, 1, 2] + [2, 0, 0]

Here vector addition is done element-wise. A valid partition does not contain any vectors with negative integers, or the all-zero vector.
Now the challenge is to write a program or function that generates all possible vector partitions given a target vector. This may sound relatively easy...
...but there is a twist. If the input vector has size L, and the biggest partition it generates has M elements, you may not use more than O(L*M) memory.
You may assume that an integer uses O(1) memory.
This means that you must output the partitions as you generate them. On top of that, you must only output each partition exactly once. For example, these are the same partition:
[3, 1, 2] = [3, 0, 2] + [0, 1, 0]
[3, 1, 2] = [0, 1, 0] + [3, 0, 2]

If you were to output both your answer is invalid.

All partitions for [3, 2]:
[3, 2]
[0, 1] + [3, 1]
[0, 1] + [0, 1] + [3, 0]
[0, 1] + [0, 1] + [1, 0] + [2, 0]
[0, 1] + [0, 1] + [1, 0] + [1, 0] + [1, 0]
[0, 1] + [1, 0] + [2, 1]
[0, 1] + [1, 0] + [1, 0] + [1, 1]
[0, 1] + [1, 1] + [2, 0]
[0, 2] + [3, 0]
[0, 2] + [1, 0] + [2, 0]
[0, 2] + [1, 0] + [1, 0] + [1, 0]
[1, 0] + [2, 2]
[1, 0] + [1, 0] + [1, 2]
[1, 0] + [1, 1] + [1, 1]
[1, 1] + [2, 1]
[1, 2] + [2, 0]

To test your answer, run it on [3, 2, 5, 2]. It should generate 17939 partitions, all of which sum to [3, 2, 5, 2], and that are all unique (you can test for uniqueness by first sorting each partition lexicographically).

Shortest code in bytes wins.

Python 2, 289 bytes
Simple brute force algorithm. Treats entire list as a number in base max(input)+1 (b), and checks each "number" in the range [0, b**(L*M)) to see if it:

Sums to the correct amount
Is in alphabetical order (ensures uniqueness)

If the list matches these criteria, the program outputs it with all the all-zero vectors stripped.
Memory usage
The largest data structure I use in this program is a doubly-nested list, an list length M containing liss length L to give O(L*M) memory.
For my other data structures, I have 3 global ints O(3), 1 list length L (O(L)), 1 array length M (O(M)), and a copy of the largest array when outputting (O(L*M)).
In total, this gives me a memory usage of O(2*L*M + L + M + 3) which simplifies to O(L*M), fufilling the criteria.
Time complexity
Being a brute force algorithm, this algorithm is extremely slow. For the while loop to quit, the final int in the array needs to be b-1. The loop needs to run b**(L*M) times before that happens.
In addition, each time the list runs, it needs to check both conditions, and print the list in a worst case, using L*M+L+M iterations. This simplifies to give an overall O(L*M * b**(L*M)). I tried to test my program on [3, 2, 5, 2], but gave up after 45 minutes.
Golfed program
v=input()
L=len(v)
M=sum(v)
b=max(v)
R=range
t=[L*[0]for i in R(M)]
def A(l,i):
 if i<L*M-1and~-b<l[i/L][i%L]:A(l,i+1)
 l[i/L][i%L]=-~l[i/L][i%L]%-~b
while t[-1][-1]<b:
 if v==[sum(q[i]for q in t)for i in R(L)]and all(`t[i]`>=`t[i+1]`for i in R(M-1)):print[x for x in t if[0]*L!=x]
 A(t,0)

I might be able to golf this a bit more, especially the increment part. Ungolfed code coming.

Definitely not the efficiency I was hoping for when I posted this question, but I guess it technically solves the problem :)

source: Stack Exchange

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

sort: votes


text:
Let's Tessellate!
Introduction
From Wikipedia:

A tessellation of a flat surface is the tiling of a plane using one or more geometric shapes, called tiles, with no overlaps and no gaps.

A fairly well known tessellation is shown below:

The rhombi are tiled in a fashion that results in no overlaps or gaps, and simulates interchanging columns of cubes.
Task
Your task is to write a program that tessellates rhombi the same way the image does above. The input for the program will be dimensions of the tessellation: height x width, where width is the amount of columns and height is the amount of rows.
A single cube that is 1 x 1 (3 tiles of rhombi) is represented exactly as so:
    _____
  /\      \
 /  \      \
/    \ _____\
\    /      /
 \  /      /
  \/_____ /

So if the input/dimensions are 3 x 2, this should be the output:
    _____
  /\      \
 /  \      \
/    \ _____\ _____
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
  /\      \    /      /
 /  \      \  /      /
/    \ _____\/_____ /
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
  /\      \    /      /
 /  \      \  /      /
/    \ _____\/_____ /
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
          \    /      /
           \  /      /
            \/_____ /

As you can see, there are 3 rows (height), and 2 columns (width). The columns are interchanging up and down. Your program should do this too and start higher. For example, 3 x 3 would be:
    _____               _____
  /\      \           /\      \
 /  \      \         /  \      \
/    \ _____\ _____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
  /\      \    /      /\      \
 /  \      \  /      /  \      \
/    \ _____\/_____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
  /\      \    /      /\      \
 /  \      \  /      /  \      \
/    \ _____\/_____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
          \    /      /
           \  /      /
            \/_____ /

Rules

The result must be outputted, input may be taken in whatever way you like but must correspond to height and width
Trailing newlines are allowed
The tessellation columns always start from above then alternate up and down
Sides of tessellations must be shared and tessellations must be correctly placed in between the other columns with no gaps
Your submission may be a function or a full program
Your program must print exactly the output above given the same input; in other words the output must follow the same format for cubes/tessellations

Assumptions

You can assume that the input will always be greater than 1 x 1, so you don't need cases where a zero is inputted

Scoring
This is code-golf, so the shortest code in bytes wins. Standard loopholes are prohibited as well.

JavaScript (ES6), 243 bytes

f=
(h,w)=>[...Array(h*6+4)].map((_,i)=>[...Array(w*9+3)].map((_,j)=>i&&(i+j+3)%6==0&&j%9<(i>3?6:3)&&(i>3|j<w*9)&&(j>2|i<h*6)?'/':i&&(i-j+2)%6==0&&j%9<(i>h*6?j<w*9?3:0:6)?'\\':i%3==0&&j>2&&(i*3+j+14)%18%(!i|i>h*6?18:12)<4?'_':' ').join``).join`
`

<input id=h type=number min=1><input id=w type=number min=1>

Directly calculates all the desired characters. For /:
i&&                         Not on first row of output
(i+j+3)%6==0&&              Backward diagonals
j%9<                        Not on top (right) diamond of hexagons or
    (i>3?6:3)&&             empty spaces on top half row
(i>3|j<w*9)&&               Not on top right corner of output
(j>2|i<h*6)                 Not on bottom left corner of output

For \:
i&&                         Not on first row of output
(i-j+2)%6==0&&              Forward diagonals
j%9<                        Not on bottom (right) diamond of hexagons or
    (i>h*6?                 empty spaces on bottom half row or
        j<w*9?3:0:6)        bottom right corner of output

For _:
i%3==0&&                    Every third line
j>2&&                       Not on left two columns
(i*3+j+14)%18%              Every 18 characters
    (!i|i>h*6?18:12)<4      One or two groups

Befunge, 277 269 bytes
&6*4+00p&:55+*3+10p2%20pv@
6+5:g03%*54:::<<0+55p03:<<v%*54++55:\p04:**`+3g03g00`\g01+*3!g02\-*84g+3+!\%
48*+,1+:10g`!#^_$,1+:00g-|>30g:2+6%\3-!+3+g48*-\:2`\20g3*+10g\`*30g2`**40g!*+
  /\      \
 /  \      \
/    \ _____\
\    /      /
 \  /      /
  \/_____ /
    _____

Try it online!
This question looked deceptively easy, but the edge cases turned out to be more complicated than I had originally anticipated. The best approach I could come up with was to handle the odd and even columns as separate renderings, and then just merge the results.
So for each x,y coordinate that has to be output, we first need to determine what character should be rendered for an odd column, by mapping the x,y output coordinates to u,v coordinates in the cube diagram as follows:
u = x%20
v = (y+5)%6 + (y==0)

The addition of (y==0) is to handle the special case of the first line. But we also need to make sure we aren't rendering the last few lines at the bottom of the column, and the last few characters on the end of each row. This is achieved by multiplying output character with the expression:
(y > h-3) && (x > w-3*!(columns%2))

The !(columns%2) in the width calculation is because the amount we need to trim off the end is dependent on whether the total column count is even or odd.
We then do a second calculation to determine what character should be rendered for an even column, mapping the u,v coordinates as follows:
u = (x+10)%20
v = (y+2)%6 + (y==3)

This is the same basic calculation as used for the odd columns, but offset slightly. And as before, we need to make sure we don't render some of the characters on the boundaries - this time the first few lines at the top of the column, as well as some characters at the beginning and end of each row. The expression we multiply in this case is:
(y > 2) && (x > 2) && (x < w-3*(columns%2))

Having calculated these two potential output characters, the final value used is:
char1 + (char2 * !char1) + 32

In other words, if char1 is zero we need to output char2, otherwise we output char1. If both are non-zero, we're just going to output char1, but that's fine because they'd both be the same value anyway. Also note that these character values are offset by 32 (hence the addition of 32) so that zero will always end up as a space.

Python 2, 329 326 319 bytes
h,w=input()
a,R=[' '*10]*3,range
b='  /\      \  # /  \      \ #/    \ _____\#\    /      /# \  /      / #  \/_____ /  '.split('#')
c=['    _____    ']+b*h
e,o=c+a,a+c
k=len(e)
f=e[:]
o[3]=o[3][:10]
for x in R(1,w):
 for y in R(k):f[y]+=((e[y][3:],e[y])[y in R(4)],(o[y][3:],o[y])[y in R(k-3,k)])[x%2]
print'\n'.join(f)

Try it online!
Actually 21 24 31 bytes shorter than my previous incorrect post. Creates lists for the odd and even columns then concatenates them for each column in the width.

Batch, 590 bytes
@echo off
set c=call:c
set b=\      \
set f=%b:\=/%
set s=
set u=_____
set w=%2
%c%"   " " %u%" "%s%%s%"
%c%"  " "/%b%" "%s%    "
%c%" " "/  %b%" "%s%  "
%c%"" "/    \ %u%\" " %u% "
for /l %%i in (1,1,%1)do %c%"\" "    %f%" "%b%"&%c%" \" "  %f%" "  %b%"&%c%"  \" "/%u% /" "    \ %u%\"&if %%i lss %1 %c%"  /" "%b%" "    %f%"&%c%" /" "  %b%" "  %f%"&%c%"/" "    \ %u%\" "/%u% /"
%c%"   " "" "%s%\    %f%"
%c%"  " "" "  %s%\  %f%"
%c%" " "" "    %s%\/%u% /"
exit/b
:c
set o=%~1
for /l %%j in (%w%,-2,1)do call set o=%%o%%%~2&if %%j gtr 1 call set o=%%o%%%~3
echo(%o%

The :c subroutine takes three parameters; %3 is the difference between 1 and 2 columns, %2 is the difference between 2 and 3 columns, %1 is the extra prefix for the first column, so one column is %1%2, two columns is %1%2%3, three columns is %1%2%3%2, four columns is %1%2%3%2%3 etc.

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


text:
Sums of 24-hour time
Given an integer between 0 and 141 (inclusive), list all 24-hour times whose hour, minute, and second units add to that integer.
Rules of addition
Numbers are added by their time units, not by single digits.
For example, take 17:43:59
17+43+59=119
Remember, that is an example of digits being added. In reality, you would enter 119, and 17:43:59 would be one of the results. Output should be given as HH:MM:SS or H:MM:SS.
Also keep in mind the highest number possible is 141, being 23:59:59. This is code golf, so the lowest amount wins. Trial and error is permitted, but there may be a better way to go about this.
Edit: Please specify where in your code the input value is.

Welcome to Programming Puzzles & Code Golf! If by plugged in you mean made part of the source code, that's usually disallowed. In general, it's a good idea to stick to those defaults. Do we have to display the results as strings? If so, what formats are allowed?

Is the input number guaranteed to be positive? Will there be at least one solution?

I've edited the question a bit to clarify/answer some things. If your intent was different than my changes, feel free to edit it to match that.

Hours can be single digit but the rest must be padded to two? I'd rather these be consistent.

I only did that because it's the usual way I see times given (in the real world). Nobody ever says it's 13:4:7, but 5:10:30 is almost always acceptable. I don't have an issue with it being changed.

"Please specify where in your code the input value is." - The convention on PPCG for taking input is using arguments, as well as a few other options. See Default for Code Golf: Input/Output methods on Meta.

Jelly, 16 30 29 20 bytes
Now with the correct output format! Many thanks to Dennis for his help in debugging this answer. Golfing suggestions welcome. Try it online!
Edit: +14 bytes from using the correct output format. -1 byte from removing an extra space. -3 from changing from 24,60,60 to “ð<<‘. -6 bytes from changing +100DḊ€€ to d⁵.
“ð<<‘Œp’S=¥Ðfd⁵j€”:Y

Explanation
“ð<<‘Œp’S=¥Ðfd⁵j€”:Y  Main link. Argument: n

“ð<<‘                 Jelly ord() the string `ð<<` to get [24, 60, 60]. Call this list z.
     Œp               Cartesian product of z's items.
                        Since each item of z is a literal,
                        Jelly takes the range [1 ... item] for each item.
       ’              Decrements every number in the Cartesian product
                        to get lowered ranges [0 ... item-1].
        S=¥           Create a dyadic link of `sum is equal to (implicit n)`.
           Ðf         Filter the Cartesian product for items with sum equal to n.
             d⁵       By taking divmod 10 of every number in each item,
                        we get zero padding for single-digit numbers
                        and every double-digit number just turns into a list of its digits.
               j€”:   Join every number with a ':'.
                   Y  Join all of the times with linefeeds for easier reading.

Bash, 71

8 bytes saved thanks to @hvd

for t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}

Try it online.

printf is costly here. By getting t closer to the right format, and fixing it up to make ((t-$1)) work, you can get it down to 71: for t in {0..23}+{00..59}+{00..59};{((${t//+0/+}-$1))||echo ${t//+/:};}

@hvd Good golfing - thanks!

Perl 6, 62 56 bytes
{map *.fmt('%02d',':'),grep $_==*.sum,(^24 X ^60 X ^60)}

Just checks all possible combinations in the cross product of all hours, minutes, and seconds.

PowerShell, 87 77 bytes
Saved 10 bytes thanks to John L. Bevan
$d=date;0..86399|%{$d+=1e7l;"$d".Split()[1]}|?{("{0:H+m+s}"-f$d|iex)-in$args}

Try it online! (this will time out, it's very slow)
Explanation
Pretty simple, starting with the current [datetime], add 1 second 86,399 times, format as a string, then keep only the ones where sum adds up.

FYI: You can replace 10000000 with 1e7l to save 4 bytes... or even 1e7 for an extra byte (I think; I had to include the L for the benefit of the parameter; but suspect your approach avoids that need.

Also you can replace $d.Hour+$d.Minute+$d.Second with ("{0:H+m+s}"-f$d|iex) for another 6 bytes

@JohnLBevan thanks! I struggled with 1e7 for at least 30 minutes, and it was the L postfix I missed; I forgot about it and couldn't figure out a way to get it to int that was shorter than the constant. Who decided that that a [timespan] interprets an [int] as ticks and a [double] as days anyway?? The iex bit is pretty brilliant, though it makes this whole thing inordinately slower.

No worries; I had some help on that one too ;) : http://stackoverflow.com/q/41408902/361842

@JohnLBevan I literally just saw this question before the comment where you linked it! Nice.

Also the iex trick was adapted from a tip here: http://codegolf.stackexchange.com/a/746/6776

Python 3, 91 bytes
def f(n):
 for k in range(86400):t=k//3600,k//60%60,k%60;sum(t)==n!=print('%d:%02d:%02d'%t)

There are shorter solutions using exec (Python 2) or recursion (Python 3), but both require an unreasonable amount of memory.
Try it online!

Haskell, 77 bytes
f x=[tail$(':':).tail.show.(+100)=<<t|t<-mapM(\x->[0..x])[23,59,59],sum t==x]

Haskell, 90 bytes
p x=['0'|x<10]++show x
i=[0..59]
f x=[p h++':':p m++':':p s|h<-[0..23],m<-i,s<-i,h+m+s==x]

Returns a list of HH:MM:SS strings, e.g. f 140 -> ["22:59:59","23:58:59","23:59:58"].
It's three simple loops through the hours, minutes and seconds. Keep and format all values where the sum is the input number x.

Pyth - 30 bytes
Takes all possible times then filters.
mj\:%L"%02d"dfqsTQsM*U24*KU60K

Test Suite.

Julia 0.5, 69 bytes
!n=[h+m+s==n&&@printf("%d:%02d:%02d
",h,m,s)for s=0:59,m=0:59,h=0:23]

Try it online!

Batch, 168 bytes
@for /l %%t in (0,1,86399)do @call:c %1 %%t
@exit/b
:c
@set/ah=%2/3600,m=%2/60%%60,s=%2%%60,n=%1-h-m-s
@set m=0%m%
@set s=0%s%
@if %n%==0 echo %h%:%m:~-2%:%s:~-2%

Outputs single-digit hours.

Mathematica, 79 bytes
Cases[Tuples@{(r=Range)@24-1,x=r@60-1,x},t_/;Tr@t==#:>DateString@TimeObject@t]&

Octave, 83 , 87 bytes
@(a){[H,M,S]=ndgrid(0:23,s=0:59,s);printf("%d:%02d:%02d\n",[H(x=H+M+S==a),M(x),S(x)]')}

Try it Online!

QBIC, 82 72 bytes
:[0,23|[0,59|[0,59|~b+c+d=a|?!b$+@:`+right$(@0`+!c$,2)+A+right$(B+!d$,2)

This hits an unfortunate spot in QBasic, with casting to number, trimming and prepending a 0 when necessary is really costly.
Sample output:
Command line: 119
1:59:59
2:58:59
2:59:58
3:57:59
[... SNIP 270 lines ...]
23:58:38
23:59:37

Explanation I wrote a novel about it:
:           Get N, call it 'a'
[0,23|      Loop through the hours; this FOR loop is initialised with 2 parameters
            using a comma to separate FROM and TO, and a '|' to delimit the argument list
[0,59|      Same for the minutes
[0,59|      And the seconds
            QBIC automatically creates variables to use as loop-counters:
            b, c, d (a was already taken by ':')
~b+c+d=a    IF a == b+c+d
|           THEN
 ?          PRINT
  !         CAST
   b        'b'
    $       To String; casting num to str in QBasic adds a space, this is trimmed in QBIC
+@:`        Create string A$, containing ":"
+right$      This is a QBasic function, but since it's all lowercase (and '$' is
            not a function in QBIC) it remains unaltered in the resulting QBasic.
(@0`+!c$,2) Pad the minutes by prepending a 0, then taking the rightmost 2 characters.
+A          Remember that semicolon in A$? Add it again
+right$     Same for the seconds
(B+!d$,2)   Reusing the 0-string saves 2 bytes :-)

QBIC looks interesting. Did you create it just for #code-golf!? :)

@wasatchwizard Yup :-)

PowerShell, 67 79 Bytes (nasty version)
Since the rules say nothing about completing in a certain time (or at all), and nothing about no duplicates, here's a horrific solution:
for(){if(("{0:H+m+s}"-f($d=date)|iex)-in$args){"{0:H:mm:ss}"-f$d}}

I can't find the relevant meta post, but i'm pretty sure a submission have to halt to be valid, unless specified by the challenge

Thanks @Sefa... if that's the case I can't find a nice way to get my nasty version to work in less characters than Briantist's clean version...  Tempted to delete this answer, but I'm kind of proud of how bad it is ;)

PowerShell, 91 97 bytes (including input)
param($x)1..864e3|%{($d=date($_*1e7l))}|?{("{0:H+m+s}"-f$_|iex)-eq$x}|%{"{0:H:mm:ss}"-f$_}

 param($x)0..23|%{$h=$_;0..59|%{$m=$_;0..59|?{$h+$m+$_-eq$x}|%{"{0:0}:{1:00}:{2:00}"-f$h,$m,$_}}}
or
 param($x)0..23|%{$h=$_;0..59|?{($s=$x-$h-$_)-le59-and$s-ge0}|%{"{0:0}:{1:00}:{2:00}"-f$h,$_,$s}} <\s>
Expanded & commented
param($x)
#loop through the hours
0..23 | %{
    $h=$_
    #loop through the minutes
    0..59 | %{
        $m=$_
        #loop through the seconds
        0..59 | ?{ #filter for those where the sum matches the target
            $h + $m + $_ -eq $x
        } | %{
            #format the result
            "{0:#0}:{1:00}:{2:00}" -f $h, $m, $_
        }
    }
}

NB: Surpassed by @Briantist's version: https://codegolf.stackexchange.com/a/105163/6776

JavaScript, 122 120 bytes
Takes one additional empty string as input, which I presume doesn't count towards the size. Updated bytecount (including historical) to add two bytes for the string's initialization.

console.log((
//Submission starts at the next line
i=>o=>{for(h=24;h--;)for(m=60;m--;)for(s=60;s--;)if(h+m+s==i)o+=`${h}:0${m}:0${s} `;return o.replace(/0\d{2}/g,d=>+d)}
//End submission
)(prompt("Number:",""))(""))

If you need to initialize a string to empty, the initialization must be counted

@edc65 Done.···

Racket 39 bytes
(for*/sum((h 24)(m 60)(s 60))(+ h m s))

Ungolfed:
(for*/sum      ; loop for all combinations; return sum of values for each loop
   ((h 24)     ; h from 0 to 23
    (m 60)     ; m from 0 to 59
    (s 60))    ; s from 0 to 59
  (+ h m s))   ; sum of all 3 variables

MATL, 29 bytes
24:q60:qt&Z*t!si=Y)'%i:'8:)&V

Try it online!
Explanation
24:q     % Push [0 1 ... 23]
60:q     % Push [0 1 ... 59]
t        % Duplicate
&Z*      % Cartesian product of the three arrays. This gives a matrix with each
         % on a different row Cartesian tuple
t!       % Push a transposed copy
s        % Sum of each column
i=       % Logical mask of values that equal the input
Y)       % Select rows based on that mask
'%i:'    % Push this string
8:)      % Index (modularly) with [1 2 ... 8]: gives string '%i:%i:%i'
&V       % Convert to string with that format specification. Implicitly display

JavaScript (ES6), 110
v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

Less golfed
v=>{
  o=[];
  z=x=>':' + `0${x}`.slice(-2);
  for(m = 60; m--;)
    for(s = 60; s--; )
      h = v - m - s,
      h >= 0 & h < 24 && o.push(h + z(m) + z(s))
  return o
}

Test

F=
v=>eval("o=[];z=x=>':'+`0${x}`.slice(-2);for(m=60;m--;)for(s=60;s--;h>=0&h<24&&o.push(h+z(m)+z(s)))h=v-m-s;o")

function update() {
  O.textContent=F(+I.value).join`\n`
}

update()
<input id='I' value=119 type=number min=0 max=141 oninput='update()'>

JavaScript, 96 bytes
v=>{for (i=86399;i;[a,b,c]=[i/3600|0,i%3600/60|0,i--%60]){v-a-b-c?0:console.log(a+":"+b+":"+c)}}

Expanded view:
v => {
    for (i = 86399; i;
        [a, b, c] = [i / 3600 | 0, i % 3600 / 60 | 0, i-- % 60]) {
        v - a - b - c ? 0 : console.log(a + ":" + b + ":" + c)
    }
}

Loop through all possible times by looping 86399 to 1,

convert the integer to time by dividing by 3600 to get the first
digit
the 2nd digit by taking the integer mod 3600 and then dividing
by 60
and the last digit is the integer mod 60

Subtract all 3 numbers from the input value to return a falsey value if the three numbers add up to the input value.  If the value is falsey, output the value.

bash, 78 bytes (using a BSD utility) or 79 bytes (non-BSD also)
This is a little longer than @DigitalTrauma and @hvd's nice 71-byte bash solution, but I kind of liked the idea here of using numbers in base 60; I'm curious if anybody can golf this down a little more.
With the BSD-standard jot utility:
jot '-wx=`dc<<<60do3^%d+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 86400 0|sh

With the more universally available seq utility:
seq '-fx=`dc<<<60do3^%.f+n`;((`dc<<<$x++'$1'-n`))||tr \  :<<<${x:3}' 0 86399|sh

The idea is to generate the numbers from 0 to 83699 and use dc to convert them into base 60.  The "digits" in dc's base-60 output are 2-digit numbers from 00 to 59, with spaces separating the "digits", so this lists all the desired times from 00 00 00 to 23 59 59 in almost the format needed.
If you literally carry that out, though, numbers below 60^2 aren't 3-digit numbers in base 60, so the initial 00 or 00 00 is missing.  For that reason, I'm actually generating the numbers from 60^3 to 60^3+83699; this ensures that all the numbers generated are exactly 4 digits long in base 60.  This is OK as long as I eventually throw away the extra first digit (01) that isn't needed.
So, once the desired times are generated, I just take each quadruple from 01 00 00 00 to 01 23 59 59, add the last three numbers and subtract the argument $1. If that's 0, I then take everything in the quadruple from the 3rd character on (throwing away the "01 "), use tr to convert spaces to colons, and print the result.


text:
2017 is Almost Here!
Challenge
The challenge is simple:
Taking no inputs and output the following message:
 _     __    __
  |   |  | |   |
  |_  |__| |   |

A number of times equal to the number of hours before or after midnight UTC on 31st Dec  2016.
Examples
For example if it is 19:01 UTC dec 31st you should output:
 _     __    __
  |   |  | |   |
  |_  |__| |   |
 _     __    __
  |   |  | |   |
  |_  |__| |   |
 _     __    __
  |   |  | |   |
  |_  |__| |   |
 _     __    __
  |   |  | |   |
  |_  |__| |   |
 _     __    __
  |   |  | |   |
  |_  |__| |   |

if it is 23:24 UTC dec 31st you should output:
 _     __    __
  |   |  | |   |
  |_  |__| |   |

and if it is 1:42 UTC jan 1st you should output:
 _     __    __
  |   |  | |   |
  |_  |__| |   |
 _     __    __
  |   |  | |   |
  |_  |__| |   |

Clarification: if it is 10-11pm dec 31st you should output two, 11-12pm dec 31st output one, 00-01am jan 1st output one, 01-02am jan 1st output two etc...
Rules

No Inputs
Trailing lines or spaces are ok.
Your program should work any time or day I run it (albeit with a large output). For example on jan 2nd at 00:15am your code should output 25 times.

(This is my first Code Golf question so if I have left any thing important out please let me know.)
This is Code Golf so Shortest bits win

Is the number of hours rounded to the nearest integer? If it's within a half-hour of the New-Year-midnight, should there be no output?

@GregMartin See my edit for clarification.

What should happen if I run the program on 3 January?

@betseg ye I just thought about that to. See edit :). It should work the same even though the output will be large.

Nice first question. About rounding: the number of repetitions is the absolute value of the difference between current time UCT and 0:00:00 of Jan 1st UTC, rounded up. Correct?

@edc65 Yep so if you are 45mins from 0:00:00 you should output 1 times  if 43hours 15 mins you should output 44 times

@Quantumspaghettification What about on 0:00:00 of Jan, it should output nothing?

@GurupadMamadapur I will leave that open, but I very much doubt that any output at 0:00:00 will be seen since it is only that time for one second (at the most).

@Quantumspaghettification Ok great thanks. I'll output 2017 once because it saves bytes :)

I noticed bits are specified, not bytes. I sense an incoming solution in 7 with an argument in comments about scoring.

Hey, can you please update the correct answer?

JavaScript (ES6), 107
As an anonymous method with no parameters
Note 1483228800000 is Date.UTC(2017,0)
_=>` _     __    __
  |   |  | |   |
  |_  |__| |   |
`.repeat((Math.abs(new Date-14832288e5)+36e5-1)/36e5)

Test This keeps updating every 1 minute, but you'll need a lot of patience to see the output change.

F=_=>`_     __    __
 |   |  | |   |
 |_  |__| |   |
`.repeat((Math.abs(new Date-14832288e5)+36e5-1)/36e5)

update=_=>O.textContent=F()

setInterval(update,60000)

update()

Python 2 - 97 + 17 = 114 bytes
import time
print'_     __    __\n |   |  | |   |\n |_  |__| |   |\n'*int((abs(time.time()-1483228800)+3599)/3600)

Borrowed logic for ceiling from edc65's answer.
Python 3.5 - 116 bytes
import time,math
print('_     __    __\n |   |  | |   |\n |_  |__| |   |\n'*math.ceil(abs(time.time()/3600-412008)))

math.ceil returns an integer in 3.x whereas in 2.x it returns a float.
Thanks elpedro for saving 3 bytes.

@ElPedro Thanks. Was about to do that, in my previous solutions I was fiddling with datetime.now(pytz.utc).timestamp() which required python 3.5.

C compiled with Clang 3.8.1 327 317 145 Bytes
172 bytes saved thanks to @edc65
#include <time.h>
t;main(){time(&t);t=abs(difftime(t,1483228800)/3600);while(t--)puts(" _     __    __\n  |   |  | |   |\n  |_  |__| |   |\n");}

Ungolfed
#include <time.h>
t;
main()
{
time(&t);

t=difftime(t, 1483228800)/3600;

while(t--)
    puts(" _     __    __\n  |   |  | |   |\n  |_  |__| |   |\n");
}

317 bytes
10 bytes saved thanks to @LegionMammal978
#include <time.h>
t,y,w;main() {struct tm n;time(&t);n=*localtime(&t);n.tm_hour=n.tm_min=n.tm_sec=n.tm_mon=0;n.tm_mday=1;w=n.tm_year;if((w&3)==0&&((w % 25)!=0||(w & 15)==0))w=8784;else w=8760;t=(int)difftime(t, mktime(&n))/3600;t=t<w/2?t:w-t;for(;y++<t;)puts(" _     __    __\n  |   |  | |   |\n  |_  |__| |   |\n");

Ungolfed
#include <time.h>
t,y,w;
main()
{
    struct tm n;
    time(&t);

    n=*localtime(&t);

    n.tm_hour=n.tm_min=n.tm_sec=n.tm_mon=0;
    n.tm_mday=1;
    w=n.tm_year;

    if((w&3)==0&&((w % 25)!=0||(w & 15)==0))w=8784;else w=8760;

    t=(int)difftime(t, mktime(&n))/3600;
    t=t<w/2?t:w-t;

    for(;y++<t;)
        puts(" _     __    __\n  |   |  | |   |\n  |_  |__| |   |\n");
}

I will add some explanations when I'll be able to.

Aren't you able to do n.tm_hour=n.tm_min=...=n.tm_mon=0;?

@LegionMammal978 Oh yeah, I forgot. Thanks.

Pyth - 71 68 bytes
*"_     __    __
 |   |  | |   |
 |_  |__| |   |
".Ea412008c.d0 3600

Uses the same logic used in my python 3.5 answer.
Try it here!

@Quantumspaghettification Isn't this shorter?


text:
Negative Fibonacci Numbers
You probably all know the fibonacci sequence:
fibonacci(n)=fibonacci(n-1)+fibonacci(n-2)
fibonacci(0)=0
fibonacci(1)=1

Your task is as simple as it could be:

Given integer N compute fibonacci(n)

but here is the twist:

Also do negative N

Wait. What?
fibonacci(1)=fibonacci(0)+fibonacci(-1)

so
fibonacci(-1)=1

and
fibonacci(-2)=fibonacci(0)-fibonacci(1)=-1

and so on...

This is a code-golf so shortest programm in bytes win.
You may submit a function or a full programm
N is in [-100,100]

Testcase(s) in CSV:
-9;-8;-7;-6;-5;-4;-3;-2;-1;0;1;2;3;4;5;6;7;8
34;-21;13;-8;5;-3;2;-1;1;0;1;1;2;3;5;8;13;21

Hint:

 n<0 and n&1==0:
fibonacci(n)=fibonacci(abs(n))*-1

No. Mine wants you to support negative numbers too.

I think this is not a dupe. Of the answers on the first page of the existing Fibonacci challenge, only 1 can handle negatives, and all the rest would need to be significantly changed to go backwards too.

Added some. Feel free to add more. @Flip

Read this meta post about formatting test cases: try to avoid fancy tables

and by CSV you mean SSV (semicolon separated values)?

@NH. "European CSV" https://en.wikipedia.org/wiki/Comma-separated_values#Example

Mathematica, 9 bytes
Fibonacci

Yes, this built-in function supports negative numbers.

This is almost word-for-word the answer I was coming to post :D

Octave, 20 bytes
 @(n)([1,1;1,0]^n)(2)

Try it online!
Explanation
This makes use of the fact that the fibonacci sequence f(n) can be written as (this should be a matrix vector notation):
Recursively:
[f(n+1)]  = [1  1] * [f(n)  ]
[f(n)  ]    [1  0]   [f(n-1)]

Explicitly:
[f(n+1)]  = [1  1] ^n * [1]
[f(n)  ]    [1  0]      [0]

This means that the top right entry of this matrix to the power of n is the value f(n) we're looking for. Obviously we can also invert this matrix as it has full rank, and the relationship still describes the same recurrence relation. That means it also works for negative inputs.

(How) Does this also work for negative input?

yes, explanation coming...

is ans(-6) meant to be positive?

@FlipTack Sorry, it might have been because of the index shift. I used 1-based, while the question used 0-based, I fixed it now.

Maxima, 3 bytes
 fib

supports positive and negative numbers.
Try it (paste) on CESGA - Maxima on line

Can you add a link to the language?

Of course added a link to an online calculator!

Also works on WolframAlpha

Python, 43 bytes
g=5**.5/2+.5
lambda n:(g**n-(1-g)**n)/5**.5

A direct formula with the golden ratio g. With f the above function:
for n in range(-10,11):print f(n)

-55.0
34.0
-21.0
13.0
-8.0
5.0
-3.0
2.0
-1.0
1.0
0.0
1.0
1.0
2.0
3.0
5.0
8.0
13.0
21.0
34.0
55.0

Same length alt, only aliasing the square root of 5:
a=5**.5
lambda n:((a+1)**n-(1-a)**n)/a/2**n

I didn't see a way to make a recursive function that could compete with these. A mildly-golfed attempt for 57 bytes:
f=lambda n:n<0and(-1)**n*f(-n)or n>1and f(n-1)+f(n-2)or n

For comparison, an iterative method (60 bytes in Python 2):
n=input()
a,b=0,1;exec"a,b=b,a+b;"*n+"a,b=b-a,a;"*-n
print a

Or, for 58 bytes:
n=input()
a,b=0,1;exec"a,b=b,a+cmp(n,0)*b;"*abs(n)
print a

JavaScript (ES6), 42 bytes
f=n=>n<2?n<0?f(n+2)-f(n+1):n:f(n-2)+f(n-1)

Test

f=n=>n<2?n<0?f(n+2)-f(n+1):n:f(n-2)+f(n-1)

for(i = -9; i < 9; i++) {
  console.log(i, f(i))
}

I really like your function. I had a suggestion here, but I overlooked a -, so it wouldn't work...

JavaScript (ES7) 37 bytes
Uses Binet's Formula.
n=>((1+(a=5**.5))**n-(1-a)**n)/a/2**n

This outputs the nth Fibonacci number +- 0.0000000000000005.

** requires ES7.

Oh, thought it was part of ES6, but you're right. Changed it. I also used another version of Binet's Formula for a 1B save.

Now that I think about it, just using 1-p instead of -1/p should have worked for the same saving.

MATL, 11 9 bytes
I'm happy about the [3,2], which surely could be golfed, if anyone knows a way please let me know=) (It would also work with [1,3].) Thanks @LuisMendo for -2 bytes=)
IHhBiY^2)

This is using the same approach as the Octave annswer. But to generate the matrix
[1,1]
[1,0]

we just conver the number 3 and 2 from decimal to binary (i.e. 11 and 10).
Try it online!

Jolf, 2 bytes
mL

Try it here!
The fibonacci builtin, implemented using the phi formula.

Uncaught SyntaxError: Unexpected token |
at new Function ()
at p (math.min.js:27)
at Object (math.min.js:27)
at typed (eval at p (math.min.js:27), :36:14)
at Object.n [as factory] (math.min.js:45)
at t (math.min.js:27)
at f (math.min.js:27)
at Object.get [as median] (math.min.js:27)
at clone (rawgit.com/ConorOBrien-Foxx/Jolf/master/src/jolf.js:902)
at rawgit.com/ConorOBrien-Foxx/Jolf/master/src/jolf.js:2128 (Latest Google Chrome, version 55.0.2883.87m)

@IsmaelMiguel This should only work on firefox

I had no idea, it isn't anywhere

Haskell, 51 bytes
s=0:scanl(+)1s;f z|even z,z<0= -f(-z);f z=s!!abs z

Multiple tests within a guard can be combined with , instead of &&: even z,z<0.

Lithp, 88 bytes
#N::((if(< N 2)((if(< N 0)((-(f(+ N 2))(f(+ N 1))))((+ N))))((+(f(- N 2))(f(- N 1))))))

My look at all those parentheses.
Try it online!
Not very small really. There's currently a parsing bug that requires one to use (get N) or (+ N) instead of simply N. I chose the smaller one. However I don't think there's anything that can be done further to golf this.

PowerShell, 112 Bytes
function f($n){$o=('-','+')[$n-lt0];&(({$a,$b=(2,1|%{f("$n$o$_"|iex)});"$a- $o$b"|iex},{$n*$n})[$n-in(-1..1)])}

Demo Call:
-9..9 | %{"{0,2}`t=> {1,3}" -f $_,(f($_))}

Output of Demo:
-9  =>  34
-8  => -21
-7  =>  13
-6  =>  -8
-5  =>   5
-4  =>  -3
-3  =>   2
-2  =>  -1
-1  =>   1
 0  =>   0
 1  =>   1
 2  =>   1
 3  =>   2
 4  =>   3
 5  =>   5
 6  =>   8
 7  =>  13
 8  =>  21
 9  =>  34

Jelly, 2 bytes
ÆḞ

Try it online!
Boring builtin answer, Jelly’s Fibonacci builtin handles negative inputs just fine

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


text:
Fibonacci Exponents
For this challenge, you are to output the result of the sum of some numbers. What are these numbers? Well, you are given input, (a, b), which are integers (positive, negative, or zero) , a != b, and a < b , and each integer within a and b (including them) will have exponents according to the Fibonacci numbers. That's confusing so here's an example:
Input: (-2, 2)
Output: -2**1 + (-1**1) + 0**2 + 1**3 + 2**5 =
          -2  +    -1   +   0  +   1  +   32 = 30

Given that the first Fibonacci number is represented by f(0), the formula is:
a**f(0) + ... + b**f(b-a+1)

Input, Processing, Output
To clarify the above, here are some test cases, the processing of the input, and the expected outputs:
Input: (1, 2)
Processing: 1**1 + 2**1
Output: 3

Input: (4, 8)
Processing: 4**1 + 5**1 + 6**2 + 7**3 + 8**5
Output: 33156

Input: (-1, 2)
Processing: -1**1 + 0**1 + 1**2 + 2**3
Output: 8

Input: (-4, -1)
Processing: -4**1 + -3**1 + -2**2 + -1**3
Output: -4

Rules

No standard loopholes allowed
Exponents must be in order according to Fibonacci series
Code must work for above test cases
Only the output needs to be returned

Winning Criteria
Shortest code wins!

So 0 is not included in the fibonacci numbers here?

0 is not a Fibonacci number but is a valid choice for input

33165 or 33156?

@Neil I think you're right

This above "af(0) + ... + bf(b-a+1) " it is wrong, for example for a=1 and b=2 it would be 1f(0)+2f(2). I think would be af(0) + ... + bf(b-a); here f(0)=0 not 1

05AB1E, 9 bytes
ŸDg!ÅFsmO

Try it online!
Ÿ         # Push [a, ..., b].
 Dg!      # Calculate ([a..b].length())! because factorial grows faster than fibbonacci...
    ÅF    # Get Fibonacci numbers up to FACTORIAL([a..b].length()).
      s   # Swap the arguments because the fibb numbers will be longer.
       m  # Vectorized exponentiation, dropping extra numbers of Fibonacci sequence.
        O # Sum.

Doesn't work on TIO for large discrepancies between a and b (E.G. [a..b].length() > 25).
But it does seem to work for bigger numbers than the average answer here.
Inefficient, because it calculates the fibonacci sequence up to n!, which is more than is needed to compute the answer, where n is the length of the sequence of a..b.

I'm confused as to why this is the accepted answer, it doesn't output the correct result for any of the given testcases. The exponents should be the fibonacci numbers, not the integers in the range. I'm not sure what features were available back then, but ŸDgLÅfmO or just ŸāÅfmO would work instead.

I was wondering that too. I came up with a 9-byte answer that works, but your alternatives are much better.

Python, 49 bytes
A recursive lambda which takes a and b as separate arguments (you can also set the first two numbers of fibonacci, x and y, to whatever you want - not intentional, but a nice feature):
f=lambda a,b,x=1,y=1:a<=b and a**x+f(a+1,b,y,x+y)

Try it online! (includes test suite)
Golfing suggestions welcome.

Why -~a and not simply a+1? I think -~a is machine dependant.

Mathematica, 38 bytes 37 bytes 31 bytes
Sum[x^Fibonacci[x-#+1],{x,##}]&

This is just rahnema1's answer ported to Mathematica. Below is my original solution:
Tr[Range@##^Fibonacci@Range[#2-#+1]]&

Explanation:
## represents the sequence of all the arguments, # represents the first argument, #2 represents the second argument. When called with two arguments a and b, Range[##] will give the list {a, a+1, ..., b} and Range[#2-#+1] will give the list of the same length {1, 2, ..., b-a+1}. Since Fibonacci is Listable, Fibonacci@Range[#2-#+1] will give list of the first b-a+1 Fibonacci numbers. Since Power is Listable, calling it on two lists of equal length will thread it over the lists. Then Tr takes the sum.
Edit: Saved 1 byte thanks to Martin Ender.

You can use Range@##.

Not as relevant now, but the original approach can be improved 3 bytes to Tr[(r=Range@##)^Fibonacci[r-#+1]]&.

Using Range twice should have been a red flag. Thanks!

Perl 6, 32 30 bytes
{sum $^a..$^b Z**(1,&[+]...*)}

$^a and $^b are the two arguments to the function; $^a..$^b is the range of numbers from $^a to $^b, which is zipped with exponentiation by Z** with the Fibonacci sequence, 1, &[+] ... *.
Thanks to Brad Gilbert for shaving off two bytes.

(1,&[+]...*) is one byte shorter, and the space after Z** isn't needed.

@BradGilbertb2gills Cool, I had no idea the Fibonacci sequence could be expressed that way.

Actually it works because &infix:<+> can accept 0,1 or 2 arguments. (&[+] is a short way of writing &infix:<+>). The WhateverCode * + * accepts exactly 2 arguments. (&[0]() == 0 so you have to have the 1 there to start off the sequence)

Maxima , 32 bytes
f(a,b):=sum(x^fib(x-a+1),x,a,b);

Pyke, 11 bytes
h1:Foh.b^)s

Try it here!
h1:         -   range(low, high+1)
   F     )  -  for i in ^:
    oh      -     (o++)+1
      .b    -    nth_fib(^)
        ^   -   i ** ^
          s - sum(^)

Haskell, 35 bytes
f=scanl(+)1(0:f);(?)=sum.zipWith(^)

Usage:
$ ghc fibexps.hs -e '[4..8]?f'
33156

You can turn the function o into an infix operator, like a#b=sum....

Had considered infix like a…b but read the requirement to accept unary (ℤ,ℤ)→ℕ

Many other answers take two separate arguments, so I think it's fine.

Alrightie already, that brings us up to par with the ECMAscript7 lambda.  But if we are allowed to feed (a,b) as a?b then why aren't we allowed to prepare it as immediate [a..b]?f onto (?)=sum.zipWith(^)?

I think this goes too far. The input are two numbers (not necessarily as a pair, two separate arguments will do), but you're feeding a list of numbers and a function to your main function.

You mean: 2 lists of numbers.  I thought a#b went too far.

More precisely: 2 lists of numbers.  Substituting [a..b] for (a,b) and postfix ?f for prefix o seems as cognitively reasonable as substituting a#b or o a b for o(a,b) to me.

JavaScript (ES7), 42 bytes
f=(a,b,x=1,y=1)=>a<=b&&a**x+f(a+1,b,y,x+y)

Straightforward port of @FlipTack's excellent Python answer.

Nice, turned out even shorter in JavaScript! :)

MATL, 23 bytes
&:ll&Gw-XJq:"yy+]JQ$h^s

Try it online! Or verify all test cases.
&:      % Binary range between the two implicit inputs: [a a+1 ... b]
ll      % Push 1, 1. These are the first two Fibonacci numbers
&G      % Push a, b again
w-      % Swap, subtract: gives b-a
XJ      % Copy to cilipboard J
q:      % Array [1 2 ... b-a-1]
"       % For each (repeat b-a-1 times)
  yy    %    Duplicate the top two numbers in the stack
  +     %    Add
]       % End
J       % Push b-a
Q       % Add 1: gives b-a+1
$       % Specify that the next function takes b-a+1 inputs
h       % Concatenate that many elements (Fibonacci numbers) into a row vector
^       % Power, element-wise: each entry in [a a+1 ... b] is raised to the
        % corresponding Fibonacci number
s       % Sum of array. Implicitly display

Husk, 6 bytes
Σz^İf…

Try it online!
Explanation
Σz^İf…
     … rangify the input
 z^    zip using the power function
   İf  using the fibonacci numbers
Σ      sum the result

Vyxal s, 6 bytes
ṡ:ẏ∆fe

Try it online, or see a seven byte flagless solution. Takes input with b first, then a.
Explanation:
ṡ       # Range from a to b
 :      # Duplicate
  ẏ     # Range from 0 to length
   ∆f   # Nth Fibonacci number
     e  # To the power of
        # Sum with the s flag

R, 51 bytes
An anonymous function.
function(a,b)sum((a:b)^numbers::fibonacci(b-a+1,T))

Jelly, 13 bytes
ạµ1+⁸Ð¡0
r*çS

Try it online!

Nice, the only other answer I've found where an input of f(1,25) works ;). +1

Whispers v3, 87 bytes
> Input
> Input
> fₙ
>> 1…2
>> #4
>> 3ᶠ5
>> L*R
>> Each 7 4 6
>> ∑8
>> Output 9

Unfortunately, Whispers v3 isn't on TryItOnline!, so there isn't an online interpreter  to test this, aside from downloading the repository and running it locally.

Jelly, 9 8 bytes
rJÆḞ*@rS

Try it online!
-1 byte thanks to ZippyMagician
How it works
rJÆḞ*@rS - Main link. Takes a on the left and b on the right
r        - Range from a to b
 J       - Length range of that
  ÆḞ     - n'th Fibonacci number of each
      r  - Range from a to b
    *@   - Raise each to the power of the Fib numbers
       S - Sum

Arn -x, 11 8 bytes
gŸ▀<Çúì═

Try it!
Explained
Unpacked: .=z^[1 1{+
   .=       Rangify input (inclusive)
z^          Zipped with exponentiation to
   [1 1{+   The fibonacci sequence, closing }] implied
          Then take the sum

Ruby, 46 bytes
->a,b{n=s=0;m=1;a.upto(b){|x|s+=x**n=m+m=n};s}

Nothing particularly clever or original to see here. Sorry.

For me nonspeaker of Ruby, the ℤ.upto(ℤ) method is a nice reminder of Ruby's all-object behavior beauty.  Further golfing the code is left as an exercise to native Ruby speakers.  Have you scanned http://codegolf.stackexchange.com/questions/363/tips-for-golfing-in-ruby yet?

Java 7, 96 bytes
Golfed:
int n(int a, int b){int x=1,y=1,z=0,s=0;while(a<=b){s+=Math.pow(a++,x);z=x+y;x=y;y=z;}return s;}

Ungolfed:
int n(int a, int b)
{
    int x = 1, y = 1, z = 0, s = 0;
    while (a <= b)
    {
        s += Math.pow(a++, x);
        z = x + y;
        x = y;
        y = z;
    }

    return s;
}

R, 57 bytes
x=scan();sum((x[1]:x[2])^numbers::fibonacci(diff(x)+1,T))

Pretty straightforward. gmp::fibnum is a shorter built-in, but it doesn't support returning the entire sequence up to n, which numbers::fibonacci does by adding the argument T.
First I had a more tricky solution with gmp::fibnum which ended up 2 bytes longer than this solution.
x=scan();for(i in x[1]:x[2])F=F+i^gmp::fibnum((T<-T+1)-1);F

Using an anonymous function rather than scan() saves 6 bytes; see my posted solution.

ah yeah, silly of me.

dc, 56 bytes
?sf?sa0dsbsg1sc[lblcdlfrdsb^lg+sg+sclf1+dsfla!<d]dsdxlgp

Finishes for input [1,30] in 51 seconds. Takes the two inputs on two separate lines once executed and negative numbers with a leading underscore (_) instead of a dash (i.e -4 would be input as _4).

PHP, 77 75 bytes
for($b=$argv[$$x=1];$b<=$argv[2];${$x=!$x}=${""}+${1})$s+=$b++**$$x;echo$s;

takes boundaries from command line arguments. Run with -nr.
showcasing PHP´s variable variables again (and what I´ve found out about them.
breakdown
for($b=$argv[$$x=0}=1]; # $"" to 1st Fibonacci and base to 1st argument
    $b<=$argv[2];           # loop $b up to argument2 inclusive
    ${$x=!$x}                   # 5. toggle $x,             6. store to $1/$""
        =${""}+${1}             # 4. compute next Fibonacci number
)
    $s+=$b++**                  # 2. add exponential to sum,    3. post-increment base
        $$x;                    # 1. take current Fibonacci from $""/$1 as exponent
echo$s;                     # print result

FlipTack´s answer ported to PHP has 70 bytes:
function f($a,$b,$x=1,$y=1){return$a>$b?0:$a**$x+f($a+1,$b,$y,$x+$y);}

Axiom, 65 bytes
f(a,b)==reduce(+,[i^fibonacci(j)for i in a..b for j in 1..b-a+1])

test code and results
(74) -> f(1,2)
   (74)  3
                                                   Type: Fraction Integer
(75) -> f(4,8)
   (75)  33156
                                                   Type: Fraction Integer
(76) -> f(-1,2)
   (76)  8
                                                   Type: Fraction Integer
(77) -> f(-4,-1)
   (77)  - 4
                                                   Type: Fraction Integer
(78) -> f(3,1)
   >> Error detected within library code:
   reducing over an empty list needs the 3 argument form
    protected-symbol-warn called with (NIL)

PowerShell, 67 bytes
$e=1;$args[0]..$args[1]|%{$s+=("$_*"*$e+1|iex);$e,$f=($e+$f),$e};$s

Try it online!
Found a slightly better way to do the sequence, but powershell doesn't compare to other languages for this one :)

Japt -x, 9 bytes
òV ËpMgEÄ

Try it

05AB1E, 10 bytes
ŸvyN>Åfm}O

Try it online! Takes two lines of input, the first line being b and the second line being a.
 v          # for y in...
Ÿ           # [a, ..., b] (implicit input)
       m    # push...
  y         # current item in list
       m    # to the power of...
     Åf     # the...
   N>       # current index in list...
     Åf     # th Fibonacci number
        }   # end loop
         O  # push sum(stack)
            # implicit output