text:
Draw a timeline
Given an input of a list of integers representing dates, output an ASCII art
timeline like the following:
<----------------------------->
  A     B  C           D    E

The above timeline is the output for input [1990, 1996, 1999, 2011, 2016].
Note several things about the timeline:

The first line of output is a less than sign (<), a number of dashes equal
to dateOfLastEvent - dateOfFirstEvent + 3 (because one must be added to
include the last date, and then two more for padding), and then a greater
than sign (>).
In the second line of output, each event is placed at position dateOfEvent -
dateOfFirstEvent + 2 (assuming zero-indexing). Hence, the first event is
placed at position 2, two characters to the right of the <, and the last
event is similarly two characters to the left of the >.
Each event is represented by a letter. Event 1 is A, event 2 is B, etc.
There will never be more than 26 events. You may use lowercase letters if you
would like.
There is no trailing whitespace. The only extra whitespace allowed is a
trailing newline at the end of the program.

Furthermore,

The events are not necessarily given in order. Dates are still labelled
according to their position in the array, though. For example, an input of
[2, 3, 1, 5, 4] must output
<------->
  CABED

You may be given one or more events as input. For example, an
input of [12345] must output
<--->
  A

You may assume that the input will never contain duplicate dates.

Input may be given as either an array/list of integers/strings or a single
string separated by any non-numerical character. The allowable range of dates that will be provided as input is 1 ≤ x ≤ 32767.
Since this is code-golf, the shortest code in bytes will win.
Test cases:
32767 32715 32716 32750 32730 32729 32722 32766 32740 32762
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA
2015 2014
<---->
  BA
1990 1996 1999 2011 2016
<----------------------------->
  A     B  C           D    E
2 3 1 5 4
<------->
  CABED
12345
<--->
  A

Pyth, 37 36 35 34 bytes
:*dlp++\<*\-+3-eJSQhJ">
"mhh-dhJQG

Explanation: (for this the newline will be replaced by \n for simplicity)
:*dlp++\<*\-+3-eJSQhJ">\n"mhh-dhJQG

                                    - autoassign Q = eval(input())
                                    - G = "abcdefghijklmnopqrstuvwxyz"

    p++\<*\-+3-eJSQhJ">\n"          -    print out the first line

            +3-eJSQhJ               -        Get the number of dashes
                 SQ                 -            sorted(Q)
                J                   -           autoassign J = ^
               e                    -          ^[-1]
              -                     -         ^-V
                   hJ               -          J[0]
            +3                      -        ^+3

         *\-                        -       ^*"-"
      +\<                           -      "<"+^
     +               ">\n"          -     ^+"-->\n"
    p                               -    print(^)

 *dl                                -  work out the number of spaces to print
   l                                -   len(^)
 *d                                 -  ^*" "
:                                 G - For i in V: ^[i] = G[i]
                          mhh-dhJQ  -  Work out the positions of the characters
                          m      Q  -  [V for d in Q]
                               hJ   -     J[0]
                             -d     -    d-^
                           hh       -   ^+2

Try it here!

PowerShell, 120 108 bytes
param($a)$n,$m=($a|sort)[0,-1];"<$('-'*($b=$m-$n+3))>";$o=,' '*$b;$i=97;$a|%{$o[$_-$n+2]=[char]$i++};-join$o

Takes input $a then sets $n and $m to the minimal and maximal values, respectively. We output the timeline with the next section, by executing a code block $(...) inside the string to generate the appropriate number of - characters. We then generate an array of the same length containing only spaces, and set our output character to $i.
Then, we loop through the input $a with |%{...}. Each loop we set the appropriate $o value. Finally, we -join $o together to form a string. Since that is left on the pipeline, output is implicit.
Edited to remove the .TrimEnd() command, as the last character of $o is always guaranteed to be a letter.
Example
PS C:\Tools\Scripts\golfing> .\draw-a-timeline.ps1 2015,2014,2000
<------------------>
  c             ba

C - 294 287 220 191 184 178 174 bytes
After staring out with a somewhat insane code I at least have gotten it down a bit ...
Note: First loop has the requirement that the execution of the binary gives 0 as result from atoi() on argv[0]. If not, this would result in the binary (name) being included as an event. Examples that invalidates:
$ 42/program 1 2 3
# 42/program gives 42 from argv[0], fail.

$ 1program 3 2 9
# 1program gives 1 from argv[0], fail.

$ 842 3 2 9
# 842 gives 842 from argv[0], fail.

Not sure if this is a valid requirement.
char y[32769];n,m;main(i,a)char**a;{for(;n=atoi(a[--i]);y[n>m?m=n:n]=64+i);for(;!y[++i];);printf("<");for(n=i;i<=m;i+=printf("-"))!y[i]?y[i]=' ':0;printf("-->\n  %s\n",y+n);}

Run:
./cabed 32767 32715 32716 32750 32730 32729 32722 32766 32740 32762
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA

./cabed 2 1 3 5 4
<------->
  BACED

./cabed 2016
<--->
  A

./cabed 130 155 133 142 139 149 148 121 124 127 136
<------------------------------------->
  H  I  J  A  C  K  E  D     GF     B

Ungolfed:
#include <stdio.h>
#include <stdlib.h>

char y[32769]; /* Zero filled as it is in global scope. */
int n, m;

int main(i, a)
    char**a;
{
    /* Loop argv and set y[argv[i] as int] = Letter, (Event name).
     * Set m = Max value and thus last data element in y. */
    for ( ; n = atoi(a[--i]); y[n > m ? m = n : n] = 64 + i)
        ;

    /* i = 0. Find first element in y that has a value. (Min value.) */
    for (; !y[++i]; )
        ;

    printf("<");

    /* Save min value / y-index where data starts to n.
     * Print dashes until y-index = max
     * Build rest of event string by filling in spaces where no letters.*/
    for (n = i; i <= m; i += printf("-"))
        !y[i] ? y[i] = ' ' : 0;

    printf("-->\n  %s\n", y + n);

    return 0;
}

MATL, 40 41 bytes
0lY2in:)GtX<-I+(t~32w(ctn45lbX"60hP62hcw

Try it online!
0          % array initiallized to 0
lY2        % string 'ABC...Z'
in:)       % input array. Take as many letters as its length
GtX<-I+    % push input again. Duplicate, subtract minimum and add 3
(          % assign selected letter to those positions. Rest entries are 0
t~32w(     % replace 0 by 32 (space)
c          % convert to char
tn45lbX"   % duplicate, get length. Generate array of 45 ('-') repeated that many times
60hP62h    % prepend 60 ('<'), postpend 62 ('>')
c          % convert to char
w          % swap. Implicit display

Ruby, 83 characters
->a{n,m=a.minmax
s=' '*(d=m-n+3)
l=?@
a.map{|i|s[i-n+2]=l.next!}
puts ?<+?-*d+?>,s}

Sample run:
irb(main):001:0> ->a{n,m=a.minmax;s=' '*(d=m-n+3);l=?@;a.map{|i|s[i-n+2]=l.next!};puts ?<+?-*d+?>,s}[[32767,32715,32716,32750,32730,32729,32722,32766,32740,32762]]
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA

JavaScript (ES6), 124
l=>(l.map(v=>r[v-Math.min(...l)]=(++i).toString(36),r=[],i=9),`<-${'-'.repeat(r.length)}->
  `+[...r].map(x=>x||' ').join``)

TEST

F=
l=>(l.map(v=>r[v-Math.min(...l)]=(++i).toString(36),r=[],i=9),`<-${'-'.repeat(r.length)}->
  `+[...r].map(x=>x||' ').join``)

console.log=x=>O.textContent+=x+'\n'

test= [[32767,32715,32716,32750,32730,32729,32722,32766,32740,32762],
[2015,2014],[1990,1996,1999,2011,2016],[2,3,1,5,4],[12345]]

test.forEach(x=>console.log(x+'\n'+F(x)+'\n'))

PHP, 129 126 125 121 117 115 bytes
Uses ISO 8859-1 encoding.
$l=min([$h=max($z=$argv)]+$z)-3;echo~str_pad(Ã,$h-$l,Ò).~ÒÁõ;for(;$l<$h;)echo chr((array_search(++$l,$z)-1^32)+65);

Run like this (-d added for aesthetics only):
php -r '$l=min([$h=max($z=$argv)]+$z)-3;echo~str_pad(Ã,$h-$l,Ò).~ÒÁõ;for(;$l<$h;)echo chr((array_search(++$l,$z)-1^32)+65);' 1990 1996 1999 2016 2011 2>/dev/null;echo

Ungolfed version:
// Get the highest input value.
$h = max($z = $argv);

// Get the lowest value, setting the first argument (script name) to the highest
// so it is ignored.
$l = min([$h] + $z);

// Output the first line.
echo "<".str_repeat("-",$h - $l + 3).">\n  ";

// Iterate from $l to $h.
for(;$l <= $h;)
    // Find the index of the current iteration. If found, convert the numeric
    // index to a char. If not found, print a space.
    echo ($s = array_search($l++, $z)) ? chr($s+64) : " ";

Saved 3 bytes by printing leading spaces from the loop and changing <= to <.
Saved a byte by using str_pad instead of str_repeat.
Saved 4 bytes by using bitwise logic to convert 0 (false) to 32, and everything above 0 to 97 onwards. Then convert that number to char.
Saved 4 bytes by using negated extended ASCII to yield <, -, > and newline
Saved 2 bytes by negating string after padding instead of before

Perl, 109 bytes
includes +1 for -p
$l=A;s/\d+/$h{$&}=$l++/ge;($a,$z)=(sort keys%h)[0,-1];$o.=$h{$_}//$"for$a..$z;$_='<'.'-'x($z-$a+3).">$/  $o"

Expects input on stdin: space separated numbers. Example:
$ echo 2016 2012 2013 | perl -p file.pl
<------->
  BC  A

Somewhat readable:
$l=A;                                   # Intialize $l with the letter A
s/\d+/$h{$&}=$l++/ge;                   # construct %h hash with number->letter
($a,$z) = (sort keys %h)[0,-1];         # grab min/max numbers
$o .= $h{$_} // $" for $a..$z;          # construct 2nd line: letter or space
$_= '<' . '-' x ($z-$a+3) . ">$/  $o"   # construct 1st line, merge both lines to $_ output

Python 2, 173 172 182 bytes
since Python is missing yet, here is my first post:
import sys
d=dict([(int(v),chr(65+i))for(i,v)in enumerate(sys.argv[1:])])
k=sorted(d.keys())
f=k[0]
s=k[-1]-f+3
o=list(" "*s)
for i in k:o[i-f+2]=d[i]
print "<"+"-"*s+">\n"+"".join(o)

the original looks following:
import sys

dates = dict([(int(v), chr(65+i)) for (i,v) in enumerate(sys.argv[1:])])
keys = sorted(dates.keys())
first = keys[0]
out_size = keys[-1] - first + 3
out = list(" " * out_size)
for date in keys: out[date - first + 2] = dates[date]
print "<" + "-" * out_size + ">\n" + "".join(out)

You need import sys in your golfed version.

ok, I will, but I have never seen any imports in the golfed versions, so I just left it out

Groovy, 106 99 characters
{n=it.min()
o=[l="A"]
it.each{o[it-n]=l++}
"<${"-"*(it.max()-n+3)}>\n  "+o.collect{it?:" "}.join()}

Sample run:
groovy:000> print(({n=it.min();o=[l="A"];it.each{o[it-n]=l++};"<${"-"*(it.max()-n+3)}>\n  "+o.collect{it?:" "}.join()})([32767,32715,32716,32750,32730,32729,32722,32766,32740,32762]))
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA


text:
The "Do While False" idiom
Do While False
At work today one of my colleagues was describing the use-case for do while(false). The person he was talking to thought that
this was silly and that simple if statements would be much better. We then proceeded to waste half of our day discussing the best
manner to write something equivalent to:
do
{
   //some code that should always execute...

   if ( condition )
   {
      //do some stuff
      break;
   }

   //some code that should execute if condition is not true

   if ( condition2 )
   {
       //do some more stuff
       break;
   }

   //further code that should not execute if condition or condition2 are true

}
while(false);

This is an idiom which is found in c quite often.
Your program should produce the same output as the below pseudo-code depending on the conditions.
do
{
   result += "A";

   if ( C1)
   {
      result += "B";
      break;
   }

   result += "C"

   if ( C2 )
   {
       result += "D";
       break;
   }

   result += "E";

}
while(false);

print(result);

Therefore the input could be:
1. C1 = true, C2 = true
2. C1 = true, C2 = false
3. C1 = false, C2 = true
4. C1 = false, C2 = false

and the output should be:
1. "AB"
2. "AB"
3. "ACD"
4. "ACE"

This is code-golf so answers will be judged on bytes.
Standard loopholes are banned.
Yes this is a simple one, but hopefully we will see some creative answers, I'm hoping the simplicity will encourage people to use languages they are less confident with.

Does the output have to be uppercase, or is lowercase also permitted?

Are the " marks required? Also, is a trailing space ok?

As an aside for the debate with your coworker, it seems to me you could accomplish the same thing using a method with return result in place of break. Then you get the bonuses of re-usability and simplifying the calling code, too. But perhaps I'm missing something.

I didn't know this was an idiom in C...

@Mehrdad some folks do this instead of goto because using goto is bad form :)

@Seth: Yeah I understood why when I saw it, I'd just never seen it. :P

The only time I have ever used do{}while(false) is inside macros. A simple if does not suffice, because it interacts badly with elses around that may be present. Without a macro you may as well remove the do and while.

@Seth This is a poor man's goto and if you think goto is bad form you sure as heck shouldn't be using this. @nwp hit the nail on the head for the major usecase of this idiom. +1

@Poke - break is more like the rich man's goto (it's safer than plain goto because it's constrained to jumping forwards and exiting scopes - no entering new scopes without initializing their variables, for example).

Python 3, 31
Saved 1 byte thanks to xnor.
Only one byte away from ES6. :/ Stupid Python and its long anonymous function syntax.
Hooray for one liners!
lambda x,y:x*"AB"or"AC"+"ED"[y]

Test cases:
assert f(1, 1) == "AB"
assert f(1, 0) == "AB"
assert f(0, 1) == "ACD"
assert f(0, 0) == "ACE"

If you re-order x*"AB", you can save the space after.

Sorry, your long, anonymous function syntax will be the death of python :P

@CᴏɴᴏʀO'Bʀɪᴇɴ I knew something had to be holding Python back. I'll submit a PEP ASAP.

You do that, and I'll order snake traps

@CᴏɴᴏʀO'Bʀɪᴇɴ heh.

I just want JavaSnakes.

A PEP to make λ a synonym of lambda would be great :)

@RobertGrant It's a shame it's 2 bytes, but yeah, λx,y: would be fantastic.

@MorganThrapp pretty sure Haskell can do λx y-> already. Behind a language extension, unfortunately, but \x y-> is just as fine.

@CᴏɴᴏʀO'Bʀɪᴇɴ and Morgan'Venti'Thrappuccino: See here.

@OldBunny2800 Fascinating! Thanks!

JavaScript ES6, 30 26 25 bytes
A simple anonymous function taking two inputs. Assign to a variable to call.
Update: Let's jump on the index bandwagon. It saves 4 bytes. I have secured my lead over Python. Saved a byte by currying the function; call like (...)(a)(b). Thanks Patrick Roberts!
a=>b=>a?"AB":"AC"+"ED"[b]

Old, original version, 30 bytes (included to not melt into the python answer (;):
(a,b)=>"A"+(a?"B":b?"CD":"CE")

This isn't that clever...

@theonlygusti This a code-golf, not a popularity contest. Also, why waste bytes being clever if there is a more concise solution?

I like your choice of nose :b?

@JAtkin Indeed!

I think varibles x and y need to be replaced with a and b

@ShaunH Ah, thanks. My mistake.

Grrrrrrr, stupid javascript.

You can save a byte with currying

@PatrickRoberts ahhh haven't committed that one to memory yet

C preprocessor macro, 34

1 byte saved thanks to @TobySpeight

#define f(a,b)a?"AB":b?"ACD":"ACE"

Try it online.

MATL, 15 17 bytes
?'AB'}'AC'69i-h

Inputs are 0 or 1 on separate lines. Alternatively, 0 can be replaced by F (MATL's false) and 1 by T (MATL's true).
Try it online!
?           % if C1 (implicit input)
  'AB'      %   push 'AB'
}           % else
  'AC'      %   push 'AC'
  69        %   push 69 ('E')
  i-        %   subtract input. If 1 gives 'D', if 0 leaves 'E'
  h         %   concatenate horizontally
            % end if (implicit)

Haskell, 28 bytes
x#y|x="AB"|y="ACD"|1<2="ACE"

Usage example: False # True -> "ACD".
Using the input values directly as guards.

Brainfuck, 65 bytes
This assumes that C1 and C2 are input as raw 0 or 1 bytes.  e.g.
echo -en '\x00\x01' | bf foo.bf

Golfed:
++++++++[>++++++++<-]>+.+>+>,[<-<.>>-]<[<+.+>>,[<-<.>>-]<[<+.>-]]

Ungolfed:
                                      Tape
                                      _0
++++++++[>++++++++<-]>+.+  print A    0 _B
>+>,                       read C1    0 B 1 _0  or  0 B 1 _1
[<-<.>>-]<                 print B    0 B _0 0  or  0 B _1 0
[<+.+>>                    print C    0 D 1 _0
    ,                      read C2    0 D 1 _0  or  0 D 1 _1
    [<-<.>>-]<             print D    0 D _0 0  or  0 D _1 0
    [<+.>-]                print E    0 D _0    or  0 E _0
]

I believe it worth noting that this solution is in fact based on breaking out of while loops.

GNU Sed, 21
/^1/cAB
/1$/cACD
cACE

Ideone.

NTFJ, 110 bytes
##~~~~~#@|########@|~#~~~~~#@*(~#~~~~#~@*########@^)~#~~~~##@*##~~~~~#@|########@|(~#~~~#~~@*):~||(~#~~~#~#@*)

More readable:
##~~~~~#@|########@|~#~~~~~#@*(~#~~~~#~@*########@^)~#~~~~##@*##~~~~~#@|########@|(~#~~~#~~@*
):~||(~#~~~#~#@*)

That was certainly entertaining. Try it out here, using two characters (0 or 1) as input.
Using ETHProduction's method for converting to 0, 1 (characters) to bits, this becomes simpler.
##~~~~~#@|########@|

This is the said method. Pushing 193 (##~~~~~#@), NANDing it (|) with the top input value (in this case, the first char code, a 48 or 49). This yields 254 for 1 and 255 for 0. NANDing it with 255 (########@) yields a 0 or 1 bit according to the input.
~#~~~~~#@*

This prints an A, since all input begins with A. * pops the A when printing, so the stack is unchanged from its previous state.
(~#~~~~#~@*########@^)

Case 1: the first bit is 1, and ( activates the code inside. ~#~~~~#~@* prints B, and ########@^ pushes 255 and jumps to that position in the code. This being the end of the program, it terminates.
Case 2: the first bit is 0. ( skips to ) and the code continues.
~#~~~~##@*

This prints a C, because that's the next character.
##~~~~~#@|########@|

This converts our second input to a bit.
(~#~~~#~~@*)

If our second bit is a 1, we proceed to print an E.
:~||

This is the NAND representation of the Boolean negation of our bit: A NAND (0 NAND A) = NOT A.
(~#~~~#~#@*)

This now activates if the bit was a 0, and prints E.

Pyth, 16 bytes
+\A?Q\B+\C?E\D\E

Test suite
Ternaries!
Explanation:
+\A              Start with an A
?Q\B             If the first variable is true, add a B and break.
+\C              Otherwise, add a C and
?E\D             If the second variable is true, add a D and break.
\E               Otherwise, add a E and finish.

Input on two consecutive lines.

Oh pythmaster, make known to us the ways of this program. ;)

Pyth, 13 chars, 19 bytes
.HC@"૎્««"iQ2

Takes input in form [a,b]
Explanation
               - autoassign Q = eval(input())
           iQ2 -    from_base(Q, 2) - convert to an int
   @"૎્««"    -   "૎્««"[^]
  C            -  ord(^)
.H             - hex(^)

Try it here
Or use a test suite

At least in UTF-8, this weighs 19 bytes.

bytesizematters uses a completely made up way of counting bytes, which does not (and cannot) correspond to an actual encoding. It counts the square thingies as 2 bytes each (3 bytes in UTF-8) and « as 1 byte each (2 bytes in UTF-8). Both wc and this agree that it's 19 bytes.

CJam, 15 16 17 bytes
'Ali'B'C'Eli-+?

Try it online!
One byte off thanks to @randomra, and one byte off thanks to @Dennis
Explanation:
'A                  e# push "A"
  li                e# read first input as an integer
    'B              e# push "B"
      'C            e# push "C"
        'E          e# push "E"
          li-       e# leave "E" or change to "D" according to second input
             +      e# concatenate "C" with "E" or "D"
              ?     e# select "B" or "C..." according to first input

Old version (16 bytes):
'Ali'B{'C'Eli-}?

Explanation:
'A                  e# push character "A"
               ?    e# if-then-else
  li                e# read first input as an integer. Condition for if
    'B              e# push character "B" if first input is true
      {       }     e# execute this if first input is false
       'C           e# push character "C"
         'E         e# push character "E"
           li       e# read second input as an integer
             -      e# subtract: transform "E" to "D" if second input is true
                    e# implicitly display stack contents

Our good friends Ali and Eli!

C, 76 bytes
I renamed c1 to c, c2 to C and result to r. C programmers go to extremes to avoid goto. If you ever have a problum with absurd syntax in C, it is most likely to be because you did not use goto.
char r[4]="A";if(c){r[1]=66;goto e;}r[1]=67;if(C){r[2]=68;goto e;}r[2]=69;e:

Ungolfed
char r[4] = "A";
if(c1){
    r[1] = 'B';
    goto end;
}
r[1] = 'C';
if(c2){
    r[2] = 'D';
    goto end;
}
r[2] = 'E';
end:

Can you start with char r[4]="A";? My C is rusty.

Isn't that a really ridiculous way of declaring a String literal?

@TamoghnaChowdhury Sort of.  String literals aren't writable.  It's an array which is then initialized by the string literal "A".  Since "A" only sets the first two bytes, the remainder is initialized per the rules for objects of static duration (so 0 in this case).  [C99 6.7.8/22]

You can save 22 bytes by changing the initialization list to "AC" and replacing everything from r[1]=67 to r[2]=69; with r[2]=c2?68:69;

C, 41 bytes
I'm not sure if the question requires a program, a function or a code snippet.
Here's a function:
f(a,b){a=a?16961:4473665|b<<16;puts(&a);}

It gets the input in two parameters, which must be 0 or 1 (well, b must), and prints to stdout.
Sets a to one of 0x4241, 0x454341 or 0x444341. When printed as a string, on a little-endian ASCII system, gives the required output.

R, 41 39 37 bytes
pryr::f(c("ACD","ACE","AB")[1+a+a^b])

Try it online!
In R, TRUE and FALSE are coerced to 1 and 0 respectively when you attempt to use them as numbers. We can convert these numbers to indices 1, 2, and 3 through the formula 1+a+a^b.
  a  |   b  | 1+a+a^b
TRUE | TRUE | 1+1+1^1 = 3
TRUE | FALSE| 1+1+1^0 = 3
FALSE| TRUE | 1+0+0^1 = 1
FALSE| FALSE| 1+0+0^0 = 2

These values are then used to index the list ACD, ACE, AB to yield the correct output.
Saved two bytes thanks to JayCe.
If instead you prefer a version with an if statement, there's the following for 41 bytes:
pryr::f(`if`(a,"AB",`if`(b,"ACD","ACE")))

Try it online!

you can save two bytes using ^

@JayCe Thanks, I've updated the answer!

Mathematica, 35 30 bytes
If[#,"AB",If[#2,"ACD","ACE"]]&

Very simple. Anonymous function.

JavaScript, 38 bytes
Use no-delimiter 0 or 1 instead of false/true
_=>"ACE ACD AB AB".split` `[+('0b'+_)]

You can use split\ ` instead ofsplit(" ")`

You can also use +('0b'+prompt()) instead of parseInt(prompt(),2)

Retina, 22 bytes
1.+
AB
.+1
ACD
.+0
ACE

Try it Online

http://retina.tryitonline.net/#code=MS4rCkFCCl4wIApBQwpUYGRgRUQ&input=MCAx.  Prefix the ^ with `m``, to make it work for multi-line input, which is not necessary for the question, but makes testing easier.

I think you can save 3 bytes by removing the space between the two inputs.

Caché ObjectScript, 27 bytes
"A"_$s(x:"B",y:"CD",1:"CE")

ArnoldC, 423 bytes
IT'S SHOWTIME
HEY CHRISTMAS TREE a
YOU SET US UP 0
HEY CHRISTMAS TREE b
YOU SET US UP 0
BECAUSE I'M GOING TO SAY PLEASE a
BECAUSE I'M GOING TO SAY PLEASE b
TALK TO THE HAND "ABD"
BULLSHIT
TALK TO THE HAND "ABE"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
BECAUSE I'M GOING TO SAY PLEASE b
TALK TO THE HAND "ACD"
BULLSHIT
TALK TO THE HAND "ACE"
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Since ArnoldC doesn't seem to have formal input, just change the first 2 YOU SET US UP values to either 0 or 1 instead.
Explanation
This is just a whole bunch of conditional statements which account for all the possible outputs. Why, you may ask? Well, ArnoldC doesn't really have string comprehension. It can't even concatenate strings! As a result, we have to resort to the more... inefficient... method.

Er, the output should be "AB" if a is true, not "ABD"/"ABE".  That should make your code shorter!

Java, 28 bytes
Same boilerplate as a lot of the answers. type is BiFunction<Boolean,Boolean, String>.
(c,d)->c?"AB":d?"ACD":"ACE"

I know it's been almost two years, but (c,d)-> can be golfed by 1 byte to c->d-> when you use a java.util.function.Function<Boolean, java.util.function.Function<Boolean, String>>.

Pyth, 21 bytes
@c"ACE ACD AB AB"diz2

Try it here!
Input is taken as 0 or 1 instead of true/false while C1 comes first.
Explanation
Just using the fact that there are only 4 possible results. Works by interpreting the input as binary, converting it to base 10 and using this to choose the right result from the lookup string.

@c"ACE ACD AB AB"diz2   # z= input

                  iz2   # Convert binary input to base 10
 c"ACE ACD AB AB"d      # Split string at spaces
@                       # Get the element at the index

Y, 20 bytes
In the event that the first input is one, only one input is taken. I assume that this behaviour is allowed. Try it here!
'B'AjhMr$'C'E@j-#rCp

Ungolfed:
'B'A jh M
   r$ 'C 'E@ j - # r
 C p

Explained:
'B'A

This pushes the characters B then A to the stack.
jh M

This takes one input, increments it, pops it and moves over that number of sections.
Case 1: j1 = 0. This is the more interesting one. r$ reverses the stack and pops a value, 'C'E pushes characters C and E. @ converts E to its numeric counterpart, subtracts the second input from it, and reconverts it to a character. r un-reverses the stack. Then, the program sees the C-link and moves to the next link p, and prints the stack.
Case 2: the program moves to the last link p, which merely prints the entire stack.

PowerShell, 40 bytes
param($x,$y)(("ACE","ACD")[$y],"AB")[$x]

Nested arrays indexed by input. In PowerShell, $true / 1 and $false / 0 are practically equivalent (thanks to very loose typecasting), so that indexes nicely into a two-element array. This is really as close to a ternary as PowerShell gets, and I've used it plenty of times in golfing.
Examples
PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 1 1
AB

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 1 0
AB

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 0 1
ACD

PS C:\Tools\Scripts\golfing> .\do-while-false.ps1 0 0
ACE

K, 37 bytes
{?"ABCDE"@0,x,(1*x),(2*~x),(~x)*3+~y}

Vitsy, 26 bytes
Expects inputs as 1s or 0s through STDIN with a newline separating.
W([1m;]'DCA'W(Zr1+rZ
'BA'Z
I actually discovered a serious problem with if statements during this challenge. D: This is posted with the broken version, but it works just fine. (I'll update this after I fix the problem) Please note that I have updated Vitsy with a fix of if/ifnot. This change does not grant me any advantage, only clarification.
Explanation:
W([1m;]'DCA'W(Zr1+rZ
W                      Get one line from STDIN (evaluate it, if possible)
 ([1m;]                If not zero, go to the first index of lines of code (next line)
                       and then end execution.
       'DCA'           Push character literals "ACD" to the stack.
            W          Get another (the second) line from STDIN.
             (         If not zero,
do the next instruction.
              Z        Output all of the stack.
               r1+r    Reverse the stack, add one (will error out on input 0, 1), reverse.
                   Z   Output everything in the stack.

'BA'Z
'BA'                   Push character literals "AB" to the stack.
    Z                  Output everything in the stack.
Try it Online!

Jelly, 14 bytes
Ḥoị“ACD“AB“ACE

This expects the Booleans (1 or 0) as separate command-line arguments. Try it online!
How it works
Ḥoị“ACD“AB“ACE  Main link. Left input: C1. Right input: C2.

Ḥ               Double C1. Yields 2 or 0.
 o              Logical OR with C2.
                2o1 and 2o0 yield 2. 0o1 and 0o0 yield 1 and 0, resp.
   “ACD“AB“ACE  Yield ['ACD', 'AB', 'ACE'].
  ị             Retrieve the string at the corresponding index.

beeswax, 26 bytes
Interpreting 0 as false, 1 as true.
E`<
D`d"`C`~<
_T~T~`A`"b`B

Output:
julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i1
i1
AB
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i1
i0
AB
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i0
i1
ACD
Program finished!

julia> beeswax("codegolfdowhile.bswx",0,0.0,Int(20000))
i0
i0
ACE
Program finished!

Clone my beeswax interpreter from my Github repository.

I'm pretty sure you don't need the quotes.

@undergroundmonorail: Okay, I’ll update my solution. Thanks.

C, 47 45 bytes
Since there are only 3 different outcomes, we can pick one of three strings like this:
char*f(c,d){return"AB\0 ACE\0ACD"+(!c<<d+2);}

Thanks to Herman L for 2 bytes
Demo
#include<stdio.h>
int main()
{
    printf("%s\n%s\n%s\n%s\n",
           f(1,1),
           f(1,0),
           f(0,1),
           f(0,0));
}

-2 bytes: char*f(c,d){return"AB\0 ACE\0ACD"+(!c<<d+2);}

link to TIO pls

Perl, 23 bytes
say<>>0?AB:<>>0?ACD:ACE

Requires the -E|-M5.010 flag and takes input as 1 and 0:
$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'0\n0'
ACE
$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'0\n1'
ACD
$ perl -E'say<>>0?AB:<>>0?ACD:ACE' <<< $'1\n0'
AB

Alternative solution that requires -p and is 22 + 1 = 23 bytes:
$_=/^1/?AB:/1/?ACD:ACE

perl -pe'$_=/^1/?AB:/1/?ACD:ACE' <<< '0 1'

say-<>?AB:-<>?ACD:ACE is two bytes shorter.

05AB1E, 23 20 bytes
Code:
Ii"AB"?q}"AC"?69I-ç?

Try it online!

This is probably an ancient version of 05AB1E, but it can be 14 bytes now: i„ABë„AC69I-çJ Try it online or verify all test cases.

@KevinCruijssen Nice! This is indeed an ancient version of 05AB1E. The language was about three months old here (it did not even have implicit input).

Yeah, I was indeed already confused about the leading I. ;p

Japt, 19 bytes
"A{U?'B:'C+(V?'D:'E

Test it online!
Fun fact: This would be 16 bytes if it weren't for a bug:
"A{U?"B:C{V?"D:E

Bugs are the worst :|

@CᴏɴᴏʀO'Bʀɪᴇɴ Lemme see if I can dig out an older version that didn't have this bug. Then the 16 bytes would be legit.

What's the bug?

@CalculatorFeline I believe nested strings like that don't transpile for some reason.

SMBF, 39 bytes
Each _ represents a null literal \x00 and is used for readability. I've successfully tested it for all test cases.
except the third, because I haven't found a way to test that input on my interpreter, since I'd need stdin to be \x00\x01. I know it works, though, because I used the exact same method for testing C2 as I did for testing C1.
<.<,[<]<<.[>]>[<<<]<<<<,[<]<<.DE__BC__A

Explanation:
<.          print A
<,          read C1
[<]         if true, move left one
<<.         move left 2 and print (C if false, B if true)
[>]>        move to C1
[<<<]       if true, our output is done, so move all the way left, so further code is NOP
<<<<,       move left 4 and read C2
[<]         if true, move left one
<<.         move left 2 and print (E if false, D if true)
DE_ BC_ A   data on the tape

I think this will do the same for the same byte count, reusing B and C by adding 2 to each:
<.<,[<]<<.[>]>[<<]<<++<++>>,[<]<<.BC__A

Now I look at this and think "what was I doing, I could just increment A"... it might not be shorter, but I should've tried that first...

Try decrementing the inputs. Then you can nullterminate correctly.

Kotlin, 50 bytes
It is interesting what one can do with string templates.
{a,b->"A${if(a)"B" else "C${if(b)"D" else "E"}"}"}

Try Here

Those quotations... shivers

Oh my god, the quotes actually match? ...

Mouse-2002, 23 bytes
??"A"["B"|"C"["D"|"E"]]

Switches on two inputs, which each should be either 0 for false or anything else for true.
Ungolfed, as a function:
#Y,?,?;

$Y 1% a: 2% b:
  "A"
  a [
    "B"
  |
    "C"
    b [
      "D"
    |
      "E"
    ]
  ]
$

Brackets just test if the top of the stack is true, and | is else.
This is a translation of @Cᴏɴᴏʀ O'Bʀɪᴇɴ's ES6 answer.

Feature-request: These mentions actual should show up in my inbox >-<

@CᴏɴᴏʀO'Bʀɪᴇɴ I know, right?

PHP 4.1, 19 bytes
I was expecting it to be harder, but well. It was really fun!
<?=A,$A?B:C.($B^t);

This expects 2 parameters/values, passed as strings over POST/GET/SESSION/COOKIE... The key A will have the first value, the key B will have the 2nd.
The result will be sent to STDOUT.

DUP, 29 bytes
['A,^['B,]['C,$['D,]['E,]?]?]

Try it here!
Anonymous lambda. Usage:
1 0['A,^['B,]['C,$['D,]['E,]?]?]!

Explanation
[                           ] {lambda}
 'A,                          {output A}
    ^                         {check if arg1 is truthy}
     [   ][               ]?  {conditional}
      'B,                     {if so, output B}
           'C,                {otherwise, output C...}
              $               {...and check if arg2 is truthy}
               [   ][   ]?    {conditional}
                'D,           {if so, output D}
                     'E,      {otherwise, output E}

, 18 chars / 23 bytes
`A⏜î?⍘B:`C⏜í?⍘D:⍘E

Try it here (Firefox only).
It's pretty much a fusion of conditional statements.
Note: ⏜ basically takes all code up to an optional ⏝, interprets the code, and replaces that block in the code with the result. This is the first time I've used this in a submission, but it works quite well. Self-modifying code FTW!

This might be the most ASCII I've seen in an ESMin program

><> (Fish), 30 bytes
"A"o$1+.
"<"DC"v"CE
o "B"|>oo;

This code uses the two variables (using the initial stack) to move the pointer to (C2, C1+1) You can try it here

Perl, 19 + 1 (-p switch) = 20 bytes
$ perl -pe '$_=l.$_^-su;s/B./B/'
00
ACE
01
ACD
10
AB
11
AB

Uses string XOR and a bareword with leading hyphen. Ungolfed:
$_ = ('l' . $_) ^ '-su';
s/B./B/;

QBIC, 39 34 bytes
EDIT: Found out that QBasic (and by extension QBIC) doesn't need an =1 to test if an input is true, so removed those.
_!_!~a_>?@AB._X]~b_>?@ACD._E?@ACE.

Original answer:
_!_!~a=1_>?@AB._X]~b=1_>?@ACD._X]?@ACE.

Takes two numerical inputs and tests these in straight-forward IF's. No fancy OR logic and array indexes here, unfortunately.

Interpreter link?

@tac http://gamegiver.blogspot.nl/2015/12/introducing-qbic-qbasics-belated-entry.html

C, 42 bytes (long version); 31 (short version)
The existing submissions seem inconsistent with regards to whether the variables must be named C1 and C2, and whether actually printing the results is required, so I've done a long and short version.
This approach takes advantage of the fact that most of the possibilities for each index differ by only one bit.
Long version:
char s[4]={65,67-C1,69*!C1&69-C2};puts(s);

Short version:
char s[4]={65,67-a,69*!a&69-b};

ForceLang,124 bytes
def f io.readnum()
set w io.write
set g goto
w "A"
if f
g L
w "C"
if f
g M
w "E"
g N
label L
w "B"
g N
label M
w "D"
label N

Go, 120 bytes
func w(b bool,d bool)(r string){
for i:=true;i;i=!i{
r+="A"
if b{r+="B"
break}
r+="C"
if d{r+="D"
break}
r+="E"}
return}

Go has only one loop structure, for, but you can simulate a do-while loop with for i := true; i; i = expr.
Edit: It also happens that Go's switch statement is flexible enough to replicate this.
switch {
case true:
    r += "A"
    if b {
        r += "B"
        break
    }
    r += "C"
    if d {
        r += "D"
        break
    }
    r += "E"
}

I miss my ternary operator :(

D, 35 bytes
(int a,int b)=>a?"AB":"AC"+"ED"[b];

Hey, look, D has lambdas.
Hey, look, D is JavaScript, but longer. :^(
Copied verbatim from Conor's ES6 answer. c:

@Cᴏɴᴏʀ O'Bʀɪᴇɴ here's your ping c:

25

FALSE, 16 bytes
$"A"'C+,~['E+,]?

Input values are on the stack (first C2 then C1), false is 0 and true is -1 (this is normal in FALSE)

Hexagony, 28 26 25 bytes
A;?.));?~..>);@</E"+;@}/>

-2 bytes by moving up the printing of AB
-1 byte by incrementing to C instead
Try it online!
Expanded:
   A ; ? .
  ) ) ; ? ~
 . . > . ; @
< / E " + ; @
 } / > . . .
  . . . . .
   . . . .

Uses the value of the second input to get the last char, removing the need for another costly branch:
"E" + (-1*C2)

Credit to @JoKing
Alternatively I could have also just subtracted the value which doesn't save any bytes though:
"E" - C2

Instead of negating, you could just change the + to a -. This doesn't actually save any bytes though

@JoKing i don't know how I didn't notice that

CJam, 25 bytes
'Aq~[{'C\['E'D]=}{;'B}]=~

Try it online
Not the best way to do it, but it works.

Jolf, 16 bytes
+'A?j'B+'C."DE"J

Simple. Try this one here!
Aother one, using that other Pyth answer's approach:
11 characters, 18 UTF-8 bytes. You can try this one here.
~T."૎્««"Ιj
          ^-- that's a capital Iota, converting input to binary

Brainbash, 43 bytes
----[>+<----]>++.>#{<+.>}-{<++.+>#-{<+>}<.}

Brainbash is BF with two tapes and more stuff. We're only using one this time. Let's take a look:
----[>+<----]>++.

This sets the first cell to A and outputs it.
>#

This move to the next cell and takes numeric input
{<+.>}

This is an if statement. If the numeric input is one, then we'll increment the previous cell and output it, outting B.
-

This transforms 1 to 0 (falsey) and 0 to 255. It's effectively a boolean NOT as far as the next if statement is concerned.
{<++.

If the current bit, output a C.
+>#

Change it do a D and take some input
-

"Negate it"
{<+>}

If it was a zero, output an increment and return to input cell.
<.}

Move to destination cell and out it.

I could use the "heat death of the universe" to save two bytes, using >+[+[<]>>+<+]>, but that didn't complete in the online interpreter, which can be found in the link in the header.

Why does the "heat death of the universe" take until the heat death of the universe?

@CatsAreFluffy Because the Brainbash interpreter does not optimize the code.

How does the "heat death of the universe" code work, anyway?

@CatsAreFluffy it uses one of the constant generators found on esolangs wiki page  "brainfuck constants"

The 15-long one doesn't work either? How sad.

@CatsAreFluffy yeah. It's not like it's going to win anyhow :P

MATLAB, 31 28 bytes
@(x,y)[65,67-x,~x*(69-y),'']

This anonymous function will match all the test cases. The first input is condition 1 and the second input is condition 2. The string will be returned.
The function also works with Octave. You can try it online here.
Simply create the anonymous function by running the command above, then call the function. Running this for example:
ans(0,1)

Will return:
ACD

C, 54 bytes
Since the story started with a loop, I decided to stick to that. Not the shortest of solutions; but certainly one of the more obscure ones.
Function f takes two integer parameters as input (1 = true, 0 = false), and outputs AB, ACD or ACE to stdout.
f(a,b){for(int x=64;~putchar(++x)<<a&4;x+=x&2?!b:!a);}

Nustack, 27 bytes
a"AB"*"AC"b{"E"}{"D"}if + |

Thanks to Morgan Thrapp and her Python answer for giving me the inspiration for this one.
Explanation:
a"AB"* /* Repeat "AB" 0 or 1 times, depending on if a is #t or #f. The result ("" or "AB") is put on the stack */
"AC" /* Put "AC" on the stack */
b{"E"}{"D"}if /* If b is true, push "E", else push "D" */
+ /* Concatenate the top two strings on the stack, push the result ("ACE" or "ACD") */
| /* Right now the stack looks like (x y). If x is truthy (not empty), keep x, else keep y */

Javascript, 43 Bytes
A different (more intuitive?) way to do it in JS. The name parseInt is not inductive of Code Golfing :P
"A"+["CE","CD","B","B"][parseInt(x+""+y,2)]

Test:

var cases = ["00","01","10","11"];

for (i=0;i<4;i++) {
   var x = cases[i][0];
   var y = cases[i][1];
   document.write("A"+["CE","CD","B","B"][parseInt(x+""+y,2)]+"<br>")
}

Try +\0b${x}${y}`instead ofparseInt`

Ruby, 31 bytes
Anonymous function; assign to a variable to test its output.
->x,y{?A+(x ??B:?C+(y ??D:?E))}

SmileBASIC, 32 bytes
INPUT A,B?"A"+"CB"[A]+"ED"[B]*!A

C++, 57 52 bytes
[](auto c,auto&s){s="AC";c[0]?--s[1],s:s+='E'-c[1];}

First argument should be an indexable collection (vector, array, etc) of conditions, and second argument is the string to write to.
Assumes that the runtime character set has B and C contiguous, and D and E also contiguous (both are true for common codings such as ASCII and EBCDIC).
Demo
auto const f = [](auto c,auto&s){s="AC";c[0]?--s[1],s:s+='E'-c[1];};

#include<array>
#include<iostream>
#include<string>
int main()
{
    std::string s;

    for (bool c1: {true, false})
        for (bool c2: {true, false})
            f(std::array{c1, c2}, s),std::cout << s << '\n';
}

Forth (gforth), 54 bytes
I had orignally planned on using emit for this, but realized that direct string output was shorter (61 vs 54 bytes)
: f if ." AB" else if ." ACD" else ." ACE" then then ;

Try it online!
Explanation
If C1 is true, it prints AB, otherwise it prints ACD if C2 is true, and ACE if C2 is false
Code Explanation
: f                \ start a new word definition
   if              \ if c1 is true
      ." AB"       \ print "AB"
   else            \ if c1 is false
      if           \ if c2 is true
         ." ACD"   \ print "ACD"
      else         \ if c2 is false
         ." ACE"   \ print "ACE"
      then         \ end the inner if
   then            \ end the outer if
;                  \ end the word defintion

source: Stack Exchange

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

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

sort: votes


text:
Shortest binary number in range
Given two arbitrarily precise decimal numbers 0 ≤ x < y ≤ 1, compute the shortest (in digits) binary number b such that x ≤ b < y.
Output the binary digits of b after the binary point as an array or a string of zeroes and ones. Note that the empty array means 0.0, by virtue of deleting trailing zeroes. This also makes sure that there is a unique correct answer for any range.
If you are unfamiliar with binary fractional numbers, they work just like decimal numbers:
Base 10   0.625 = 0.6 + 0.02 + 0.005 = 6 x 10^-1  +  2 x 10^-2  +  5 x 10^-3
Base  2   0.101 = 0.1 + 0.00 + 0.001 = 1 x  2^-1  +  0 x  2^-2  +  1 x  2^-3
                                          |             |             |
                                          v             v             v
Base 10                        0.625 =   0.5      +     0       +   0.125

Built-ins that trivialize this problem are disallowed.
Examples:
0.0, 1.0 -> ""
0.1, 1.0 -> "1"
0.5, 0.6 -> "1"
0.4, 0.5 -> "0111"

Shortest code wins.

Does "arbitrarily precise" mean "within the limits of your language's types," or do we have to support input of (0.98983459823945792125172638374187268447126843298479182647, 0.98983459823945792125172638374187268447126843298479182648)? Also, test cases would be helpful.

@Doorknob Arbitrarily precise means that your answer should work for any input, up to limits of the physical machine (memory). So yes, that input must be supported.

Sort of dupe?

@MartinBüttner Really close (wasn't aware of it), but this question requires arbitrary precision and output as bits.

Aaaah the top-half-open interval x ≤ b < y is hard to deal with, it would be so much easier with x < b ≤ y.

@xnor Indeed, if I could guarantee 0 ≤ x < b ≤ y < 1 then I could do it in JavaScript in 171 bytes without even golfing: (a,b)=>{a=a.slice(2);b=b.slice(2);r='0.';while(a[0]>4|b[0]<5){r+=+(a[0]>4);a=a.replace(/./g,(n,i)=>n*2%10+(a[i+1]>4));b=b.replace(/./g,(n,i)=>n*2%10+(b[i+1]>4))}return r+1}

CJam, 46
q'.-_,:M;S/{3a.+M'0e]~GM#*AM(#/(2b}/_@.=0#)<2>

Try it online
Explanation:
The general idea is: multiply both numbers by 10some big enough exponent to get integers, multiply again by 2another big enough exponent to "make room" for binary digits in integer form, integer-divide back by 10the first exponent, decrement the numbers (to get to the "x < b ≤ y" case) and convert the results to base 2. Find the first different digit (it will be 0 in the first number and 1 in the second number), and print all the digits from the second number up to and including that one.
Before starting with the multiplications, I'm adding 3 to the integer parts in order to ensure that the results have the same number of binary digits (with no leading zeros) after decrementing. At the end, I am skipping the first 2 binary digits to compensate.
q          read the input as a string
'.-        remove the dots
_,         duplicate and get the string length
:M;        store in M and pop; M-1 will be the first exponent
S/         split by space
{…}/       for each number (in string form)
  3a.+     add 3 to the first digit (vectorized-add [3] to the string)
  M'0e]    pad to the right with '0's up to length M
            this is like multiplying the decimal number with 10^(M-1)
            but done as a string operation
  ~        evaluate the result as an integer
  GM#*     multiply by 16^M (G=16) = 2^(4*M) -- 4*M is the second exponent
  AM(#/    divide by 10^(M-1) (A=10)
  (2b      decrement and convert to base 2 (array of digits)
_          duplicate the 2nd array
@          bring the first array to the top
.=         vectorized-compare the arrays (digit by digit)
0#         find the position of the first 0 (meaning digits are not equal)
)<         increment and slice the other copy of the 2nd array before that position
2>         discard the first 2 digits

Ruby, 138 132 bytes
->x,y{d,*a=->{a.map.with_index{|n,i|n/BigDecimal.new(2)**(i+1)}.inject(:+)||0};[a+=[1],a[-1]=d[]>=y ?0:1]while d[]<x;a}

13 bytes added for the  -rbigdecimal flag. Expects input as two BigDecimals.
Sample run:
irb(main):029:0> f=->x,y{d,*a=->{a.map.with_index{|n,i|n/BigDecimal.new(2)**(i+1)}.inject(:+)||0};[a+=[1],a[-1]=d[]>=y ?0:1]while d[]<x;a}
=> #<Proc:0x00000001053a10@(irb):29 (lambda)>
irb(main):030:0> f[BigDecimal.new('0.98983459823945792125172638374187268447126843298479182647'),BigDecimal.new('0.98983459823945792125172638374187268447126843298479182648')]
=> [1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1]

Explanation:
->x,y{
d,*a=   # sets d to the following, and a to [] with fancy splat operator
->{     # lambda...
 a.map.with_index{|n,i|       # map over a with indices
  n/BigDecimal.new(2)**(i+1)  # this will return:
                              #  - 0 [ /2**(i+1) ] if n is 0
                              #  - 1   /2**(i+1)   if n is 1
 }.inject(:+)                 # sum
 ||0                          # inject returns nil on empty array; replace with 0
};      # this lambda turns `[0, 1, 1]' into `BigDecimal(0b0.011)'
[       # `[...]while x' is a fancy/golfy way to say `while x;...;end'
 a+=[1],            # add a digit 1 to the array
 a[-1]=d[]>=y ?0:1  # replace it with 0 if we exceeded upper bound
]while d[]<x;       # do this while(below the lower bound)
a       # return the array of digits
}

Mathematica, 72 bytes
IntegerDigits[#2[[-1,-1]],2,Log2@#]&@@Reap[1//.a_/;Sow@⌈a#⌉>=a#2:>2a]&

Explanation
The method is to find the smallest multiplier of form 2^n that enlarges the gap between two input numbers so that it contains an integer.
For example, 16*{0.4,0.5} = {6.4,8.} contains 7, so the answer is 7/16.
Test case
%[0.4,0.5]
(* {0,1,1,1} *)

Nice Reap and Sow!

JavaScript (ES6), 144 bytes
f=(x,y,b='',d=s=>s.replace(/\d/g,(n,i)=>(i&&n*2%10)+(s[i+1+!i]>4)).replace(/[.0]+$/,''),n=d(x),m=d(y))=>n?n>'1'||(m||2)<='1'?f(n,m,b+n[0]):b+1:b

Assumes input in the form 0.<digits> (or 1.<zeros> is acceptable for y). d is a function which takes the decimal part of a number and doubles it, then trims trailing zeros. The leading digit must be present but it is ignored. Conveniently d("0.0") is empty, and this is therefore used as a test to see whether x is an exact binary fraction; in this case b already holds the result. Otherwise, there is a somewhat convoluted test to determine whether suffixing a 1 to b serves to distinguish between x and y; if so that is returned. Otherwise the MSB of x is suffixed to the result and the function calls itself recursively to process the next bit.
If instead we desire x < b ≤ y the function is much simpler, something like this (untested):
f=(x,y,b='',d=s=>s.replace(/\d/g,(n,i)=>(i&&n*2%10)+(s[i+1+!i]>4)),n=d(x),m=d(y))=>n>='1'||m<'1'?f(n,m,b+n[0]):b+1

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


text:
Singly lossy integers: Concatenated sequences missing a single element
I define the method of combining a sequence to mean that every number in the sequence is concatenated as a string, then that result is made an integer.
[1, 2, 3] -> 123

For every finite sequence of at least 3 consecutive integers, missing exactly one element in the sequence, and this missing element may not be the first or last element in the sequence, output the integer resulting from the combined sequence. I am referring to this as a "singly lossy integer".
[1, 2, 3] -> {1, 3} (missing an element) -> 13

This sequence of singly lossy integers is the union of the following subsequences (partitions?):
The first subsequence {n, n+2} is A032607.
{n, n+2}            -> 13, 24, 35, 46, 57, 68, 79, 810, 911, 1012, ...
{n, n+1, n+3}       -> 124, 235, 346, ...
{n, n+2, n+3}       -> 134, 245, 356, ...
{n, n+1, n+2, n+4}  -> 1235, 2346, 3457, ...
{n, n+1, n+3, n+4}  -> 1245, 2356, 3467, ...
{n, n+2, n+3, n+4}  -> 1345, 2456, 3567, ...
...
for n ∈ ℕ (integers >= 1)

These integers must be printed in ascending order. The first 25 singly lossy integers are below:
13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, ...

First 7597 Singly Lossy Integers
Ungolfed reference implementations. I made it to be faster, rather than smaller.

Ideone
TIO (fastest, higher limits)

Rules:

Shortest code wins
You may either (say which one):

Print the singly lossy integers forever
Given a positive integer n, print or return the first n elements as a list, or a comma- or whitespace- delimited string.

You should support arbitrarily large integers if your language allows it, especially if you're printing forever.

Inspired by / Related
Note: There is not yet an entry in the OEIS for this sequence.
Another note: I named them the "Singly Lossy Integers" so that there could in turn be "Doubly Lossy Integers", "N-ly Lossy Integers", "(N+1)-ly Lossy Integers", and the "Lossy Integers" (union of all of these).

I added a list of the first ~7600 elements, as well as a reference implementation I just completed in Python.

This would be a fun fastest-code challenge.

That it would. Is it acceptable to re-post a challenge but with a different winning criterion? If so, I'd wait a week or more first anyway.

As far as I know, it should be fine. Might want to pop into chat to ask a mod though, just in case/for tips.

APL (Dyalog Unicode), 62 bytesSBCS
Infinite printing full program, 63 bytes
s←⍎' '~⍨⍕
{⎕←s⊢a←⊃⍵⋄b←1+a⋄t←∪(b,⍨⊃a)(a,⊃⌽b)b,1↓⍵⋄t[⍋s¨t]}⍣≡⊂1 3

Try it online!
This one is pretty fast. Theoretically can be made faster using a min heap, but the challenge is code golf after all.
How it works: the concept
If we denote each item in the sequence as a list of integers ([1,3] for 13, [1,2,4] for 124, and so on), observe that subsequent items can be derived from an existing item x in three ways:

Add 1 to all numbers in x
Add 1 to all numbers in x, and then prepend the first element of x
Append 1 plus the last element of x to x

Therefore, the algorithm is to start with the single known value and infinitely run the following:

Extract the smallest item and print it
Derive three larger values from it and add them to the list of next candidate items

How it works: the code
s←⍎' '~⍨⍕  ⍝ Helper function: concat a list of numbers
        ⍕  ⍝   Stringify entire array, which will contain blanks between items
   ' '~⍨   ⍝   Remove blanks
  ⍎        ⍝   Eval
s←         ⍝   Store the function to s

⍝ Main program: print all items in the sequence infinitely
{⎕←s⊢a←⊃⍵⋄b←1+a⋄t←∪(b,⍨⊃a)(a,⊃⌽b)b,1↓⍵⋄t[⍋s¨t]}⍣≡,⊂1 3
{...}⍣≡⊂1 3  ⍝ Specify starting item and infinite loop
       ⊂1 3  ⍝   singleton array containing [1 3]
{...}⍣≡      ⍝   Pass it to the infinite looping function

⎕←s⊢a←⊃⍵⋄b←1+a⋄t←∪(b,⍨⊃a)(a,⊃⌽b)b,1↓⍵⋄t[⍋s¨t]  ⍝ Single iteration
       ⍵  ⍝ Sorted candidate items
    a←⊃⍵  ⍝ Take the first element and store to a
⎕←s⊢a     ⍝ Concat and print it

b←1+a  ⍝ Add 1 to all items of a and store to b

t←∪(b,⍨⊃a)(a,⊃⌽b)b,1↓⍵  ⍝ Add next candidates
                   1↓⍵  ⍝ Remove the first item (already printed)
   (b,⍨⊃a)(a,⊃⌽b)b,     ⍝ Prepend three candidates:
                 b      ⍝   1+a
          (a,⊃⌽b)       ⍝   append 1+last element of a to a
   (b,⍨⊃a)              ⍝   prepend first element of a to 1+a
t←∪                     ⍝ Uniquify and store to t

t[⍋s¨t]  ⍝ t sorted with the key function s (concat'ed value)

Function returning first n values, 62 bytes
⎕CY'dfns'
⊢↑∘{(⍋⊃¨⊂)⍵{a b c←⍵-1 0⍺⋄⍎dab⍕c↓a↓b~⍨⍳⍺}¨↓3cmat⍵}2+⊢

Try it online!
Slower, but still can handle 100 items in around 5 seconds.
How it works: the concept
This solution uses a systematic way to generate all possible singly lossy integers from the list 1..n. It is equivalent to selecting three members from 1..n:

Select three distinct integers a < b < c from 1..n.
Take the inclusive range a..c and discard b.

Original list: 1 2 3 4 5 6 7 8 9
Selection:       ^ ^       ^
                 a b       c
Take a..c:       2 3 4 5 6 7
Discard b:       2   4 5 6 7
Result: 24567

I use dfns.cmat to generate all 3-combinations, generate all singly lossy numbers, sort them and take first n elements. We need length n+2 for the combinations because lower numbers won't give enough number of items.
How it works: the code
⎕CY'dfns'  ⍝ Import dfns library, so that we can use cmat

⍝ Inner function: generate enough singly lossy integers
{(⍋⊃¨⊂)⍵{a b c←⍵-1 0⍺⋄⍎dab⍕c↓a↓b~⍨⍳⍺}¨↓3cmat⍵}  ⍝ Input: 2+n

⍵{...}¨↓3cmat⍵  ⍝ Generate all 3-combinations, and get singly lossy integers
        3cmat⍵  ⍝ 3-combinations of 1..2+n
⍵{   }¨↓        ⍝ Map the inner function to each row of above, with left arg 2+n

a b c←⍵-1 0⍺⋄⍎' '~⍨⍕c↓a↓b~⍨⍳⍺  ⍝ From 3-combination to a singly lossy integer
a b c←⍵-1 0⍺  ⍝ Setup the numbers so that
              ⍝ "remove b, drop first a and last c elements" gives desired value
⍎dab⍕c↓a↓b~⍨⍳⍺  ⍝ Compute the target number
     c↓a↓b~⍨⍳⍺  ⍝ Remove b, drop first a and last c elements from 1..2+n
⍎dab⍕           ⍝ Concat the numbers (dab stands for Delete All Blanks)

(⍋⊃¨⊂)  ⍝ APL idiom for sorting

⊢↑∘{...}2+⊢  ⍝ Outer function; input: n
  ∘{...}2+⊢  ⍝   Pass 2+n to the inner function
⊢↑           ⍝   Take first n elements from the result

APL (Dyalog Extended), 49 bytesSBCS
⊢↑∘{∧⍵{a b c←⍵-1 0⍺⋄⍎⌂dab⍕c↓a↓b~⍨⍳⍺}¨↓3⌂cmat⍵}2+⊢

Try it online!
Simply uses extra built-ins provided in Extended version (dfns library pre-loaded as ⌂ functions, ∧ for ascending sort).

Haskell, 131, 114, 106 bytes
iterate(\n->minimum[x|x<-[read(show=<<filter(/=k)[i..j])::Int|i<-[1..n],j<-[i+2..n],k<-[i+1..j-1]],x>n])13

This is limited by the size of Int, but it can be easily extended by replacing Int with Integer.
Less golfed:
concatInt x = read (concatMap show x) ::Int
allUpToN n = [concatInt $ filter (/=k) [i..j] | i <- [1..n], j <- [i+2..n], k <- [i+1..j-1]]
f n = minimum[x | x <- allUpToN, x > n ]
iterate f 13

8 bytes golfed by @nimi.

Is this infinite, or does it take n?

@mbomb007 With Integer, it will continue until you run out of memory (or patience). It'll continue with Int, but will start giving wrong answers once it overflows (> 2^29-1).

Can you link to an interpreter where I can run this? I pasted it into TryHaskell.org and it didn't work.

@mbomb007 Best I've found so far is this, though it needs main=print$ that GHCi does not. GHC.io runs out of memory and TryHaskell.org's feature set is too limited.

Wow, it doesn't get very far before timing out. :D

@mbomb007 Yeah, it took over an hour to get to the 14th entry on my laptop (compiled)

What's the big oh of your program?

@mbomb007 Quick calculation shows: if a(n) is the nth term in the series, calculating the n+1th term should take less than O(a(n)^4) time, because allUpToN takes up to O(n^4) time (n for i, for j, for k, and for filter/concatInt). I'm not sure how fast the series grows so I don't have a more explicit bound at the moment.

Mathematica, 101 bytes
Sort@Flatten@Table[FromDigits[""<>ToString/@(z~Range~x~Delete~y)],{x,3,#},{z,1,x-1},{y,2,x-z}][[1;;#]]&

Yay! For once I have the shortest answer! Party[Hard]

Is that an actual Mathematica built-in? I wouldn't be surprised. :D

No, but that can be corrected with Party[_]:=While[True,Print["PARTY!!!"]]. The argument is ignored because all partying is partying.

@CatsAreFluffy I disagree. Party[Where] should print Here!, and Party[When] should print Now!, etc. Do not think lightly of partying.

Party[x_]:=Switch[x,Where,"Here!",When,"Now!",How,Pause[1];"...Really?",_,While [True,Print["PARTY!!!"]]]

outgolfed[Hard] (by more than 50%)

Python 3, 136 127 126 122 bytes
brute force solution, I don't even try n=7000 (it already take 10s for n = 100)
r=range
f=lambda n:sorted(int(''.join(str(i+k)for i in r(1,j)if l-i))for k in r(n)for j in r(4,n)for l in r(2,j-1))[:n]

Explanation
# f=lambda n:sorted( int(''.join(str(i+k) for i in r(1,j)   if l-i)) for k in r(n) for j in r(4,n) for l in r(2,j-1))[:n]
#            ──┬──                        ───────┬───────    ───┬──  ──────┬──────  ──────┬──────  ────────┬──────── ─┬─
#              │                                 │              │          │              │                │          └── selection of the n first numbers
#              │                                 │              │          │              │                └── loop to remove missing element
#              │                                 │              │          │              └── loop for the dimension of the list n to be sure we miss nothing xD
#              │                                 │              │          └── loop on the n in op description
#              │                                 │              └── Test to remove missing element
#              │                                 └── loop on {n, n+1 ...} in the op description
#              └──── sort the list

Results
>>> f(25)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235]

>>> f(100)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, 1245, 1315, 1345, 1416, 1517, 1618, 1719, 1820, 1921, 2022, 2123, 2224, 2325, 2346, 2356, 2426, 2456, 2527, 2628, 2729, 2830, 2931, 3032, 3133, 3234, 3335, 3436, 3457, 3467, 3537, 3567, 3638, 3739, 3840, 3941, 4042, 4143, 4244, 4345, 4446, 4547, 4568, 4578, 4648, 4678, 4749, 4850, 4951, 5052, 5153, 5254, 5355, 5456, 5557, 5658, 5679, 5689, 5759, 5789, 5860, 5961, 6062, 6163, 6264, 6365, 6466, 6567, 6668, 6769, 6870, 6971, 7072, 7173, 7274, 7375]

Thanks to @mbomb007 and @FricativeMelon for their help

You don't need a space between a ) and the following character, and you can add t=range to the beginning of the program and replace all range function calls with t calls. That should reduce the byte count a lot.

@FricativeMelon right, i'll removed useless space

i!=l+k can also be replaced with l+k-i, which saves a byte.

@FricativeMelon i added a small description :)

str(i)for i in r(1+k,j+k)if l+k-i can be replaced with str(i+k)for i in r(1,j)if l-i, saving 4 bytes.

Python 3, 319, 270, 251 bytes
t,h,n,k,q*=range,input(),1,2,
while h>len(q)or n*k<=len(str(q[h])):
 q+=[int("".join([str(c+s)for c in t(k+1)if c-y]))for s in t(10**~-n,10**n)for y in t(1,k)]
 if~-n:n*=k;k+=1
 else:n,k=k+1,2
 while n//k*k-n:k+=1
 n//=k;q.sort()
print(q[:h])

Takes an h as input from STDIN and prints an array of the first h singly-lossy integers. It is very fast as well, taking only a few seconds for h=7000.
Explanation: Note that, if we had infinite time, we could simply iterate over all n,k and for each pair drop each of n+1,n+2,...,n+k-1 (k-1 possibilities), and get all (infinitely many) values from those, then just sort the sequence in ascending order and truncate to h elements. Of course, we cannot actually do that, but if we can reach a point where the first sorted h elements can no longer change by adding the values of any future n,k pairs, we can just truncate then and be done, in finite time. For any n,k pair, it has at least floor(log10(n)+1)*k digits, possibly more. So lets group these pairs by the value c(n,k)=floor(log10(n)+1)*k, where we guarantee that if c(a,b)<c(n,k), we process a,b before n,k. If we have the list sorted, and its last element has d digits, and d<c(n,k) for the next n,k we are going to process, we can stop, since we can no longer get a number with that many or fewer digits, since by our guarantee we should have already processed it then, and therefore no matter which numbers we would end up computing, the first h elements can not change, so we can just return them.
So now we just need the function that guarantees the stated order on c(n,k). For each y obtainable for c(n,k), we must process all (n,k) such that y=c(n,k). Let's say L=floor(log10(n)+1) for some n. Therefore y=L*k must hold. Start with k=2,L=y/2, then do k=3,L=y/3;k=4,L=y/4...k=y,L=1, skipping non-integer values of L. To generate the whole c(n,k) function, start with (1,2) with y=2, and increase y by 1 and start again whenever you get L==1. Now we have an enumeration of pairs (L,k), and it satisfies our condition. However, we need to retrieve all possible n from L, which we do by enumerating all integers with L digits. Then for each of those (n,k) pairs, for each of the k-1 possible dropped elements we must generate the lossy number we get as a result, and add it to our list, which starts empty. Then we sort the list and repeat on the next (L,k) pair, stopping when we have d<c(n,k) as stated before.
Code breakdown (a little outdated):
t=range                     #shortens code
def f(r,n,k):               #helper function
 for s in t(10**~-n,10**n): #for the (L,k) pair, add value of (s,k,y)
  for y in t(1,k):r+=[(int("".join(map(str,[c+s for c in t(k+1)if c!=y]))))]
 if n>1:                    #case where L!=1
  n*=k;k+=1                 #multiply n (which is n'/k from prev iter), inc k
 else:n,k=k+1,2             #reset n and k
 while n//k*k-n:k+=1        #find next proper divisor of n
 return(r,n//k,k)           #divide by that divisor and return
def g(h):                   #main function
 q,a,b=[],1,2               #initial values
 while h>=len(q)or a*b<=len(str(q[h])):(q,a,b)=f(q,a,b);q.sort()
 return q[:h]               #continues until at least h numbers and surpassed current max

I think len(`q[h]`) should be len(str(q[h])) to support arbitrary integers? Or just say if it only works up to a certain bound, since you're taking a parameter, not printing forever.

I thought `x`==repr(x)==str(x) for non-negative integers, and can't find any reference to this not being true. Why do you think this is not true?

I know this is not true, because I frequently golf in Python. Example. Anything larger than the integer max value (2**63-1) will have an L on the end if using repr. Note that this entry is probably very far along in the sequence.

05AB1E, 17 bytes
∞ʒ.œD0Å?_*€¥1cP2å

Try it online!
Prints the singly lossy integers forever.


text:
Implement branchless binary search
Challenge
Implement binary search on a list of length 256 with no branches.
Specification

Input an integer X and a strictly increasing list of integers
Output is the greatest element of the list that is less than or equal to X
The output will always exist
List will always have exactly 256 elements and be strictly increasing
The algorithm must be a binary search on the list

Example code (with branches)
Without branches, these examples would be valid entries.
First a functional example (actually valid Haskell code):
b value list = b' 0 7
  where
    b' pos bitpos | bitpos < 0                          = list !! pos
                  | (list !! (pos + 2^bitpos)) <  value = b' (pos + 2^bitpos) (bitpos - 1)
                  | (list !! (pos + 2^bitpos)) == value = list !! (pos + 2^bitpos)
                  | otherwise                           = b' pos (bitpos - 1)

Now a pseudocode iterative example:
b(value, list):
  pos = 0
  bitpos = 7
  while bitpos >= 0:
    if list[pos + 2^bitpos] < value
       pos    += 2^bitpos
    elseif list[pos + 2^bitpos] == value
      return list[pos + 2^bitpos]
    bitpos -= 1
  return list[pos]

Rules

Branches include: if/then, switch, case, for, while, ?:, guards, and all other branches
Instead of a list, you may use a list-like object, so space separated string, vector, etc.
Entry may be a function or full program
If your language has a function that solves this challenge, it is not allowed
Score is in bytes, lowest score wins!

Example Input/Output (abbreviated)
Input:  50, [..21,34,55,89,144..]
Output: 34

Input:  15, [..2,3,15,25,34,35..]
Output: 15

Input:  144, [..37,50,65,82,101,122,145..]
Output: 122

Maybe separating the specifications from the rules would make it clearer for those who closed it?

@user81655 Good suggestion. I also added examples and the algorithm in two forms. Do you think I should add a worked example?

Personally I think it's very clear as it is now. The test cases really help.

@user81655 Great, now I just have to wait

Might as well just leave this here for reference.

C, 75 bytes
Here's the code:
#define g p+=(x>=p[i/=2])*i
b(x,p,i)int*p;{i=256;g;g;g;g;g;g;g;g;return*p;}

Less golfed:
int bin_search(int x, int * p){
    int i = 256;
    i = i / 2;
    p += (p[i] <= x) * i;
    \\ above two lines repeated 8 times
    return *p;
}

Noncompeting why?

@CatsAreFluffy I'll edit, I just accepted my own answer because it didn't look like anyone else was going to answer. If you want to post an answer, I'll reopen.


text:
Sequential Multiplication
Your objective is to write a program that takes an input, and, when chained together N times, performs "sequential multiplication". What is sequential multiplication, you may ask? It's a sequence with a seed a defined as thus:
f(0) = a
f(n+1) = f(n)*(f(n)-1)

So, let a = 5. Thus, f(0) = 5, f(1) = f(0)*(f(0)-1) = 5*4 = 20, and f(2) = f(1)*(f(1)-1) = 20*19 = 380.
If your program was ABC, then ABC should take input a and output f(1). Program ABCABC should output f(2), etc. Your program series should only take input once and only output once.
This is a code-golf so the shortest program in bytes wins. Standard loopholes are banned.

Jelly, 3 bytes
×’$

Try it online!
How it works
×’$    Main link (or part thereof). Argument (initially input): n

 ’     Compute n - 1.
×      Multiply n by (n - 1).
  $    Combine the previous two atoms into a monadic quicklink.

Repeating the snippet n times will execute it n times, resulting in the desired output.

Seriously, 4 bytes
,;D*

Explanation:
,;D*
,     push input (NOP once input is exhausted)
 ;D   dupe and push n-1
   *  multiply
      (implicit output at EOF)

Just like in Dennis's Jelly answer, repeating this program n times will result in it running n times. That's one of the many advantages of imperative stack-based languages.
Try it online!

MATL, 3 bytes
tq*

You can try it online! Basically similar to the Seriously and Jelly answers. First, it duplicates the top of the stack (get's input first time when the stack is empty). Decrements the top of the stack and multiplies the two elements to give the next input, or result.

Python 3, 56 bytes
+1if 0else 0
try:n
except:n=int(input())
n*=n-1
print(n)

Just wanted a solution without output-overwriting trickery. The lack of a trailing newline is important.

is that first line all 1 number?

@Seadrus No, the syntax highlighter isn't matching the Python parser, which stops parsing the numbers when it hits the if and else.

This would be shorter in Python 2.

@mbomb007 That won't quite work, the print doesn't get handled propery and you get extra output when you concatenate at least once.

Ah, so that's what that extra output was.

CJam, 5 bytes
r~_(*

Try it online!
How it works
r     e# Read a whitespace-separated token from STDIN.
      e# This pushes the input (when called for the first time) or an empty string.
 ~    e# Evaluate.
      e# This turns the input into an integer or discards an empty string.
  _   e# Copy the top of the stack.
   (  e# Decrement.
    * e# Multiply.

pl, 5 bytes
_▼•=_

Try it online.
Would be 4 bytes if I hadn't been lazy and not implemented "assign to _"...
Explanation
_▼•=_

_       push _ (input var)
 ▼      decrement last used var (_)
  •     multiply, since it is off by one it auto-adds _ to the arg list
   =_   assign result to _

JavaScript REPL, 25 20 bytes
a=prompt();
a*=a-1//

Will work on eliminating a REPL

How does this produce output?

In the console. I need to fix that.

no the console is fine, i consider that valid output for js

Oh! Fantastic!!

@Seadrus The console is a REPL environment, which cannot be assumed for the purposes of this site. All submissions must be either full programs or functions. As it stands this is a snippet, which we don't allow by default.

can I allow repl environments? @alex

@Seadrus Apparently per the meta consensus (which I didn't realize was a thing), REPL-based environments are fine so long as it's specified that it's a REPL.

You could shave a few bytes off by using the comment trick in Mego's python answer: a=prompt()<newline>a*=a-1// and you can remove the need of a REPL by making the first line a=prompt(setTimeout`alert(a)`).

05AB1E, 3 bytes
Code:
D<*

Explanation:
D    # Duplicate top of the stack, or input when empty
 <   # Decrement on top item
  *  # Multiply

Try it online!

Lua, 35 18 Bytes
It's something that Lua can do pretty easily for once!
Edit: I've discovered a lot of things in Lua since I did this, so I'm updating it :)
print(...*(...-1))

... contains the command-line argument unpacked, inlining it will use it's first value in this case as it won't be allowed to expend, resulting in just printing n*(n-1).

GolfScript, 5 bytes
~.(*`

Try it online.
De-golfed and commented:
~    # Eval the input to turn it from a string into a number.
.    # Duplicate the number.
(    # Decrement one of the copies by one.
*    # Multiply the copies together.
`    # Un-eval the number, turning it back into a string.

The GolfScript interpreter automatically reads the input and places it on the stack, but as a string, not as a number.  Thus, we need to turn the input into a number with ~, and stringify it again afterwards with `.  At the end, the interpreter will automatically print out the stringified number on the stack.
(Now, if the challenge had been to iterate f(n+1) = f(n)*(-f(n)-1), I could've done that in 4 bytes with ~.~*.  Figuring out how and why that works is left as an exercise. :)

Y, 7 bytes
jzC:t*!

Try it here!
This is how it works: j takes numeric input. z activates implicit printing. C begins a new link. : duplicates the value on the stack, and t decrements it, leaving us with [a a-1]. Then, we get [a*a-a] from *. ! skips the next command; on EOF, it does nothing. When chained together, it skips the input command, and the process begins again.

Jolf, 6 bytes
Try it here!
oj*jwj

Explanation
oj*jwj
oj      set j to
  *jwj  j times j-1
        implicit output

, 5 chars / 7 bytes
ï×‡ï;

Try it here (Firefox only).
Must I truly explain this? Oh well, here goes...
Explanation
It basically evaluates to input*=--input; in JS.

Perl, 23 bytes
l;$_|=<>;$_*=~-$_;print

Alternate version, 10 bytes
$_*=~-$_;

This requires the -p switch. I'm not sure if it is fair game in a source-layout question.

Haskell, 14 11 bytes
(*)=<<pred$

Usage example
Prelude> (*)=<<pred$5
20
Prelude> (*)=<<pred$(*)=<<pred$5
380
Prelude> (*)=<<pred$(*)=<<pred$(*)=<<pred$5
144020

Maybe this isn't a proper function. If you're nitpicking you can go with (*)=<<pred$id (<-there's a space at the end) for 14 bytes.
Edit: @Zgarb rewrote the function using the function monad and saved 3 bytes. Thanks!

(*)=<<pred$ saves 3 bytes. Also, it should be noted that this is doesn't actually define a function, and the input value must be placed directly after it.

@Zgarb: Thanks! Adding id makes it a proper function. I've put a note in my answer.

Pure bash (no utilities), 40
((a=a?a:$1,a*=a-1))
trap 'echo $a' exit

TI-Basic, 6 5 bytes
Runs on TI-83/84 calculators
:Ans²-Ans

This program works due to the fact that an expression on the last line of a program is printed instead of the regular Done text.

5 bytes: :Ans²-Ans

Mathcad, 39 "bytes"

From user perspective, Mathcad is effectively a 2D whiteboard, with expressions evaluated from left-to-right,top-to-bottom. Mathcad does not support a conventional "text" input, but instead makes use of a combination of text and special keys / toolbar / menu items to insert an expression, text, plot or component. For example, type ":" to enter the definition operator (shown on screen as ":="), "[" to enter an array index, or "ctl-]" to enter a while loop operator (inclusive of placeholders for the controlling condition and one body expression). What you see in the image above is exactly what appears on the user interface and as "typed" in.
For golfing purposes, the "byte" count is the equivalent number of keyboard operations required to enter an expression.
One thing I'm even less sure about (from an "byte" equivalence point of view) is how to count creating a new region  (eg, a:=5 or k:=0..n-1).  I've equated each move to a new region as being equal to a newline, and hence 1 byte (in practice, I use the mouse to click where I want the region).
I've only included the active statements and not the comments, and I've included 2 bytes each for the a and n inputs but not the values themselves (5 and 7 in the example).

Haskell, 72 bytes
This challenge is not friendly to Haskell.. However, the following works if input is in unary and the code is executed in GHCI:
(\x->if odd x then let y=until((>x).(10^))(+1)0 in y*(y-1)else x*(x-1))$

Explanation:
Unary is always odd, so the first application will convert to decimal. x*(x-1) is always even, so otherwise it returns x*(x-1), where x is the input. Because Haskell is strongly typed and 'special' symbols cannot be called like &1, I believe that this is pretty much the only way to complete this in Haskell, unless one used global variables or an even odder input form.

C++ (gcc), 173 / 176 bytes
Both versions have a crucial newline at the end.
Macro version, 173 bytes
#ifndef M
#define M(a,b)a##b
#define W(z,x)M(z,x)
#define B int W(m,__LINE__)=x++
#include<iostream>
int x,n;int main(){for(std::cin>>n;x--;)n*=n-1;std::cout<<n;}
#endif
B;

Try it online!
Template version, 176 bytes
Somewhat more C++ish:
#ifndef B
#define B template
#include<iostream>
int x,n;B<int N>struct A{static int i;};int main(){for(std::cin>>n;x--;)n*=n-1;std::cout<<n;}
#endif
B<>int A<__LINE__>::i=x++;

Try it online!

Burlesque - 5 bytes
J?d?*

blsq ) 5 J?d?*
20
blsq ) 5 J?d?* J?d?*
380
blsq ) 5 J?d?* J?d?* J?d?*
144020


text:
ROT-128 oscillating quine (Mutual Quine)
ROT-128 is a variant of ROT-13, where instead of cycling through the 26 letters, you cycle through the 256 possible bytes.  Your task is to create a program that outputs the ROT-128 of its own source. The outputted program must also be a valid program and output the original program.
Scoring
This is code golf, so least number of bytes wins! Ties are broken by number of votes.

In the interest of searchability, I think these are usually called "mutual quines" (at least that term has been used for several challenges on the site, iirc).

GolfScript, 64 48 bytes
{ºî»`'.~'+.{128^}%\](}.~û:n;à§®þ§«®û±²¸Þý¥ÜÝ¨ý®þ

Thanks to @MartinBüttner for golfing off 16 bytes!
Try it online!
Output
û:n;à§®þ§«®û±²¸Þý¥ÜÝ¨ý®þ{ºî»`'.~'+.{128^}%\](}.~

Try it online!
Verification
$ LANG=en_US

$ cat quine.gs
{ºî»`'.~'+.{128^}%\](}.~û:n;à§®þ§«®û±²¸Þý¥ÜÝ¨ý®þ
$ golfscript quine.gs
û:n;à§®þ§«®û±²¸Þý¥ÜÝ¨ý®þ{ºî»`'.~'+.{128^}%\](}.~
$ golfscript quine.gs | golfscript
{ºî»`'.~'+.{128^}%\](}.~û:n;à§®þ§«®û±²¸Þý¥ÜÝ¨ý®þ
$ diff -s quine.gs <(golfscript quine.gs | golfscript)
Files quine.gs and /dev/fd/63 are identical

Self-Modifying Brainf*ck, 74 bytes
<[<]>[<++++[>++++<-]>[<++++++++>-].>]

(The second half of the program is the same as above, except in ROT-128)
Just thought I would post this as a) a kickstart for ideas, and b) showing that it is possible to do without an insanely large program.


text:
Word or near-word?
Write a program or function that given a string (or your language's equivalent), determine if the string is a word, or not, and output a truthy or falsy value.
(This is not a duplicate of Is this even a word? The incorrect words are generated in a very different way that I believe makes this a completely different challenge)
The words will all be lowercase, between 5 and 10 characters, and have no apostrophes.
The correct words are a randomly selected subset of the SCOWL English words list (size 50).
The incorrect words are generated via two methods: swapping and substitution.
The "swapping" words are generated using a modified Fisher-Yates shuffle on the letters of randomly selected (real) words. Instead of swapping the letters every time, a letter may or may not be swapped (the probability varies, so some words will be more realistic than others). If the new word matches an existing word, the result is discarded and it generates another word.
The "substitution" words are generated using a similar method, but instead of swapping the letter with another letter, each letter has a chance of being replaced with another random letter.
Each method is used to generate 50% of the fake words.
Scoring
Your function must be less than 150 bytes. The scoring is determined as follows:
percentage of answers correct + ((150 - length of program) / 10)

Rules
Since this deals with a large number of test cases (each wordlist is 1000 words), an automated testing program is fine. The automated tester does not count towards the length of the program; however, it should be posted so that others are able to test it.

No loopholes.
No spelling/dictionary related built-ins.

Resources
List of words: http://pastebin.com/Leb6rUvt
List of not words (updated): http://pastebin.com/rEyWdV7S
Other resources (SCOWL wordlist and the code used to generate the random words): https://www.dropbox.com/sh/46k13ekm0zvm19z/AAAFL25Z8ogLvXWTDmRwVdiGa?dl=0

I know having a word list available would defeat the point of the challenge, but how is a program supposed to know that grits (404 in not-word list) isn't a word, considering it really really is one?

Don't get me wrong; I don't like grits at all. Why anyone would eat them is beyond me. But even I wouldn't go so far as to reject the word itself :P

Fair warning: I haven't gone any farther than that on the list, so it's possible there are others.

Few more word non-words, some slightly obscure: quais, paves, colic, supermax. (Side note: I was delighted to find out that supermax is an actual word)

What's weird is even running the list through SCOWL's largest list didn't catch any of those, though they definitely are words. I generated another 1000 words (they are in the other resources link), and if a not-word is actually a word, it will be replaced by the word on the alternate list that's at the same line number. In the meantime, I updated the pastebin thing to use the alternate words for the word not-words.

króna seems to be in the list, with an accent. Ditto crèche, clichéd.

@Sp3000 Looks like it digged into French, as crèche and cliché are actual words ^^

@Katenkyo I'm not doubting they're words, I just thought that "lowercase" meant a-z without accents :P (or do we have to handle accents too? @DanielM)

@Sp3000 For the purpose of what is a real, lowercase word, lowercase letters with accents count. However, they are only a small percentage of the words, so they shouldn't have too big of an impact on the score.

@Katenkyo They are French words, but they are also English words.

@DanielM. Did they keep their accent even in English? I though they disappeared as in Theatre or Cafe.

@Katenkyo If I search google for "cliche definition" (without an accent), it pulls up the definition of "cliché" (with an accent). Same with crèche. Króna depends who you ask, though it's a bit more disputed. I'll leave it for now (it's not like half the words have accents).

PHP, 64.9 (50%, 1 byte)
Well, I'm not really sure if this is an acceptable answer, but here goes:
1

Run like this:
echo '1' | php -- word

Obviously, for an equally large list of correct and incorrect words, this results in 50% false positives and 0% false negatives, so 50% correct. As the program is 1 byte though, you're getting the maximum possible length bonus (zero-length answers notwithstanding).

Interestingly, this is fairly competing due to scoring balance. +1

CJam, 78.6 (78.5%, 149 bytes)
l2b0"(1»\]ÁûKëá*ßð%äp`Ï_5ÚY÷:Ä$î ëQXV)JKÆ¿-(ivHì?{'à\ßÐiCæz°P0ãª/îÏèÄ)WCÅH±Ø^2Ô¥?
î'jJ#OAõ~×cA$[8,ô#~¬#7>"255b2b+=

Matches 696 real words and doesn't match 874 non-words, giving 1570/2000 = 0.785. Tested on the online interpreter in Chrome - I'm not sure if the permalink will work in Firefox. In case it doesn't, the string, which contains unprintables, can be obtained by
[24 40 5 49 25 187 92 93 193 251 158 131 75 235 131 225 42 129 223 240 14 37 228 112 96 207 95 53 218 89 247 58 3 196 3 36 1 238 143 32 235 139 81 15 88 86 41 20 173 74 75 198 191 45 40 105 118 72 236 63 123 39 224 15 15 92 223 208 16 147 105 140 67 16 230 122 176 80 26 48 133 227 148 144 170 47 238 207 232 136 24 196 41 87 132 67 197 72 177 216 94 24 50 212 165 63 10 238 39 106 74 35 79 65 245 126 215 136 6 99 65 36 91 56 44 143 155 150 244 35 126 172 35 55 62]:c

The program merely hashes the input and performs a lookup based on 1077 possible buckets. I tried regex golfing this, but the non-words were too close to real words for it to be useful.
Try it online! | Test suite (paste full word list to count number of matches)

"I tried regex golfing this, but the non-words were too close to real words" -pretty much the goal

Mathematica, 69.35 (69.35%, 150 bytes)
StringContainsQ[" "|##&@@"seaeiislaanreuaooesrtnlneimdiuuosnlrlggtwtwnsdjexexavsvnuvtxsgokcmairlzlzeyatgpnlfiyhtcdxrvmuqtqtmsfohnk"~StringPartition~2]

Explanation
The function will check whether the word contains certain letter pairs that rarely occur in real words. If so, the function will return True, indicating that the word is probably not a real word. For example, pair "ii" occurs 21 times in the list of not words, while does not occur in the list of words.
Correct rate
Words:      85.4%
Not words:  53.3%

ES6, 76 (67.4%, 64 bytes)
A more serious answer this time. This is a pretty simple algorithm. It returns a truthy value when the second character of a word is one of aeinoru. It does not yield a significantly better success ratio than just 1, but it is still very short.
w=>/^[^qxy][aehil-prux]/.test(w)>/[^aeiouy]{3}|[fiopq]$/.test(w)

Test here.

+2.7 by adding a regex to find words with 3 or more consecutive consonants and rule them "non-word"
+0.1 by replacing &! with >
+1.95 by excluding the most uncommon first characters qxy, adding more valid (common) second characters to compensate for false negatives, getting rid of the redundant comma in regex
+0.05 by excluding words ending with the unlikely ending characters fiopq

CSharp,  69.85 (57.45%, 26 bytes)
"hoeiaunrt".Contains(s[1])

I check if second letter of the word is on the list most popular second letters in english (from this site).
Automated test:
static void Main(string[] args)
{
string[] good = System.IO.File.ReadAllLines( @"PATH_GOOD.txt");
string[] bad = System.IO.File.ReadAllLines(@"PATH_BAD.txt");

int counter_good = 0;
int counter_bad = 0;

foreach (string s in good)
{
    if ("hoeiaunrt".Contains(s[1])) counter_good++;
}

foreach (string s in bad)
{
    if (!("hoeiaunrt".Contains(s[1]))) counter_bad++;
}

Console.WriteLine(counter_good);
Console.WriteLine(counter_bad);

Console.ReadLine();
}

Result:
828
321

Calculation:
(828+321)/20 + 124/10 = 57.45 + 12.4 = 69.85


text:
Convert to ASCII Agrippa Numbers
Challenge
Given a natural number, output it in the ASCII form of Agrippa's number system.
Description
I like odd alphabets and numeral systems. My favorite numeral system is one given by Heinrich Cornelius Agrippa. It gives a succinct way to write numbers in the range [0,9999], where single digits are written as follows:

Larger numbers less than 10^4 are a combination of single digits, but rotated/horizontally-mirrored on a single central bar as follows:
[0° mirrored, 10's  ] | [0°,            1's  ]
[180°,        1000's] | [180° mirrored, 100's]

Here are a few examples:

The ASCII equivalents are:
Ones:
  0  1  2  3  4  5  6  7  8  9
  |  |- |_ |\ |/ |~ || |^ |v |]
  |  |  |  |  |  |  |  |  |  |

Tens:
  0  1  2  3  4  5  6  7  8  9
  | -| _| /| \| ~| || ^| v| [|
  |  |  |  |  |  |  |  |  |  |

Hundreds:
  0  1  2  3  4  5  6  7  8  9
  |  |  |  |  |  |  |  |  |  |
  |  |_ |- |/ |\ |~ || |v |^ |]

Thousands:
  0  1  2  3  4  5  6  7  8  9
  |  |  |  |  |  |  |  |  |  |
  | _| -| \| /| ~| || v| ^| [|

 1510:  1511:  1471:  1486:  3421:
 -|     -|-    ^|-    v||    _|-
 _|~    _|~    _|\    -|\    \|\

Numbers larger than 9999 are broken up into sections of 4 digits (with leading zeros added to get a multiple of four) and each is converted. For example:
314159: (0031 4159)
         /|-  ~|]
          |   /|_

Rules

Your answer may be a function or full program
The input is a positive integer
Entries must support inputs over 10^8
Each four digit section takes exactly six characters
Sections of four are separated by a single space
Trailing newline is optional
Up to two trailing spaces per line are allowed
I will not accept my own answer
Score is in bytes, lowest score wins!

Sorry, but I don't understand any of your examples; they're not even consistent with each other, let alone the graphics.

@Neil I found that the 6's weren't consistent, but I've fixed them. Is there anything else? Also, what do you mean by "the graphics"? The ASCII art is my interpretation of the graphics, not a direct translation of any kind.

I mean http://i.stack.imgur.com/2BUbM.gif clearly shows that the units is at the top right and the hundreds at the bottom right, but your examples have the hundreds at the top left and the units at the bottom right.

@Neil Thank you for catching this. Have I missed anything else?

Your 1486 looks like 2486 to me, but I now agree with the rest.

Haskell, 310 bytes

Defining reverse (as I did: r) is one byte shorter than importing Data.List and using it just once
Defining z=0:z and (!)=(!!).(++z) is the shortest way yet that I've found to return 0 for out of bounds
I've checked and quickChecked the take4s function, but it still feels like magic to me

Here's the code:
l=lines"    \n--__\n__--\n\\//\\\n/\\\\/\n~~~~\n||||\n^^vv\nvv^^\n][]["
d x|x<1=[]|1<2=mod x 10:d(div x 10)
(&)=(!!)
z=(0::Int):z
(!)=(&).(++z)
t a=[[a!q|q<-[p..p+3]]|p<-[0,4..length a-1]]
g[c,d,b,a]=[[l&b&1,'|',l&a&0,' '],[l&d&3,'|',l&c&2,' ']]
r[]=[]
r(x:y)=r y++[x]
f=unlines.foldl1(zipWith(++)).map g.r.t.d

Less golfed:
import Data.List (reverse)

dict = lines "    \n--__\n__--\n\\//\\\n/\\\\/\n~~~~\n||||\n^^vv\nvv^^\n][]["

-- Note that (digits x) returns the digits of x in little-endian order
digits x  | x < 1     = []
          | otherwise = mod x 10 : digits (div x 10)

-- Note: zeros needs the type signature, because otherwise it won't match [Int] (inferred from (!!))
zeros = (0::Int) : zeros

-- list ! position gives the element at the position, or 0 for out of bounds
(!) = (!!) . (++zeros)

-- This partitions the digits into groups of four, padded right
take4s a = [[a!q | q <-[p..p+3]] | p <- [0,4..length a - 1]]

convertOne[c,d,b,a] = [[dict !! b !! 1, '|', dict !! a !! 0, ' '], [dict !! d !! 3, '|', dict !! c !! 2, ' ']]

f = unlines . foldl1(zipWith (++)) . map convertOne . reverse . take4s . digits

Tests (escape characters removed):
mapM_ print $ lines $ f 1510
-|
_|~

mapM_ print $ lines $ f 1511
-|-
_|~

mapM_ print $ lines $ f 1471
^|-
_|\

mapM_ print $ lines $ f 1486
v||
_|\

mapM_ print $ lines $ f 3421
_|-
\|\

mapM_ print $ lines $ f 1234567891011121314
_|\ ||^ -|  -|_ -|/
 |_ /|~ ^|] _|_ _|/

mapM_ print $ lines $ f 1024628340621757567
 |_ _|v  || ^|~ ||^
 |_ /|| \|\ -|_ v|~

I wondered how anyone could answer a challenge this long within a minute of posting. Then I saw you were OP.

JavaScript (ES6), 180 159 bytes
s=>`000${s}`.slice(-s.length&-4).replace(/..../g,([t,h,d,u])=>(r+=' _-\\/~|v^['[t]+`|${'_-/\\~|v^]'[h]} `,' -_/\\~|^v['[d]+`|${' -_\\/~|^v]'[u]} `),r='')+`\n`+r

Where \n represents a literal newline character.
Edit: Updated for the switch from ,' to |. Saved 14 bytes by using a single replace to do all the work. Saved 3 bytes by using &-4 instead of <<2>>2. Saved 2 bytes by abusing destructuring assignment. Saved 2 bytes by abusing template strings.


text:
A Free Sample of Autocorrelation
Consider a 1-dimensional, real-valued vector x that represents observations of some process measured at equally spaced intervals over time. We call x a time series.
Let n denote the length of x and x̄ denote the arithmetic mean of x. The sample autocovariance function is defined as

for all -n < h < n. This measures the linear dependence between two points on the same series observed at different times.
The sample autocorrelation function, or ACF, is defined as

This measures the linear predictability of the series x at time t, which we denote xt, using only the value xt+h.
Note that these sample estimates do not match the naïve calculations based on the theoretical properties. That is, the sample autocorrelation function is not equal to the Pearson correlation coefficient of x with the h-step lag of x.
Task
Given an array x and a nonnegative integer h, print or return the first h+1 lag autocorrelations of x, beginning with lag 0. The lag autocorrelations are those corresponding to negative inputs in the above formulas.
You can assume that 0 < h < n, where n is the length of x, and that 2 < n < 256.
Output should be correct to within 1E-4. There are no restrictions on the use of built-in functions or running time.
Examples
h, x -> output
--------------
5, [2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2] -> [1.00000000,  0.07659298, -0.06007802, -0.51144343, -0.02912874, -0.10468140]
1, [2134, 1863, 1877, 1877, 1492, 1249] -> [1.0000000, 0.3343041]
2, [13067.3, 13130.5, 13198.4] -> [1.0000000000, -0.0002854906, -0.4997145094]

Jelly, 26 25 24 23 20 bytes
×L_SµḊ;0µƓÐ¡×¹S€µF÷Ḣ

Try it online!
How it works
×L_SµḊ;0µƓÐ¡×¹S€µF÷Ḣ  Main link. Input: x (list) STDIN: h (integer)

×L                    Multiply all items in x by the length of x.
  _S                  Subtract the sum of x from all products.
                      Let's call the result X.
    µ                 Begin a new monadic chain. Argument: t (list)
     Ḋ                Remove the first element of t.
      ;0              Append a 0 to the result.
        µ             Push the previous chain and begin a new one.
                      Argument: X
         Ɠ            Read h from STDIN.
          Ð¡          Repeat the Ḋ;0 chain h times, collecting the h+1 intermediate
                      results in a list A.
            ×¹        Multiply the vectors in A by X.
              S€      Compute the sum of each vectorized product.
                µ     Begin a new, monadic chain. Argument: S (sums)
                 F    Flatten S. This does nothing except creating a deep copy.
                   Ḣ  Pop the first element of S.
                  ÷   Divide all elements of the copy by the first element.

R, 3 31 25 bytes
# changes the builtin to only return the acf
body(acf)=body(acf)[1:18]

Usage (returns an array with the autocorrelations)
(acf(c(2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2),5))
# , , 1
#
#             [,1]
# [1,]  1.00000000
# [2,]  0.07659298
# [3,] -0.06007802
# [4,] -0.51144343
# [5,] -0.02912874
# [6,] -0.10468140

Background:
The 31 byte solution based on the original acf built in
function(n,h)c(acf(n,h,,F)$acf)

Note that the 3 byte option  acf is the originalbuilt in that will plot (and print to 3 digits) while returning the required autocorrelation as an element in a list.
usage
 acf(c(2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2),5)

output:
#    Autocorrelations of series ‘c(2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2)’, by lag
#
#     0      1      2      3      4      5
# 1.000  0.077 -0.060 -0.511 -0.029 -0.105

If we want the correlations to display to more than 3 decimal places then 28 bytes will do it (or 31, if we want to suppress the plot)
# will still plot (28 bytes)
function(n,h)c(acf(n,h)$acf)
# won't plot (31 bytes)
function(n,h)c(acf(n,h,,F)$acf)

This is probably the cleverest trick I have ever seen. I had no idea one could do that. We're trying to get R selected as Language of The Month - you can upvote this meta answer to make it happen.

Python 3, 147 130 126 120 bytes
def p(h,x):x=[t-sum(x)/len(x)for t in x];return[sum(s*t for s,t in zip(x[n:],x))/sum(b*b for b in x)for n in range(h+1)]

This solution is probably going to be golfed further, It's just a start.
You can call it with:
p(5,[2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2])

Octave, 47 37 bytes
@(h,x)xcov(x,'coeff')(numel(x)+(0:h))

@Rainer You can maybe save a few bytes using an anonymous function (and in that case I think you can skip disp, because you are returnig a function output)

@LuisMendo You're right. Saved 10 bytes, even without counting the disp.

Thanks! This is actually really helpful. I've been using Matlab's autocorr, but it's part of the Econometrics Toolbox which I don't have access to anymore, so I had to write my own. This is a nice and concise way of calculating it, and in-built xcorr is actually really efficient because it uses the fact that autocorrelation and Fourier transform are related (Wiener-Khinchin theorem).

MATL, 20 bytes
tYm-tPX+tX>/GnqiQ:+)

EDIT (May 20, 2016): as of version 18.0.0 of the language, use Y+ instead of X+. The link includes this change.
Try it online!
Correlation is closely related to convolution. We normalize by subtracting mean, then convolve, normalize again by dividing by maximum value, and then pick the desired lags.
tYm-       % implicit input. Duplicate and subtract mean
tPX+       % duplicate, flip, convolve
tX>/       % duplicate, divide by maximum value
Gnq        % length of array, n. Subtract 1
iQ:        % input number h. Generate vector [1,2,...,h+1]
+          % add to obtain vector [n,n+1,...,n+h]
)          % use that vector as an index. Implicitly display

Mathematica, 27 bytes
Thanks to LegionMammal978 for saving 1 byte.
We could beat Jelly if function names were not so long.
#2~CorrelationFunction~{#}&

Test case
%[5,{2.4,2.4,2.4,2.2,2.1,1.5,2.3,2.3,2.5,2}]
(* {1.,0.076593,-0.060078,-0.511443,-0.0291287,-0.104681} *)

I was about to post this before my Internet went down... You can save a byte with #2~CorrelationFunction~{#}&.