text:
Vandermonde Determinant
Given a vector of \$n\$ values \$(x_1,x_2,x_3,\ldots,x_n)\$ return the determinant of the corresponding Vandermonde matrix
\$V(x_1, x_2, \ldots, x_n) = \begin{bmatrix}1 & x_1 & x_1^2 & x_1^3 & \ldots &x_1^{n-1} \\1 & x_2 & x_2^2 & x_2^3 & \ldots &x_2^{n-1} \\ \vdots & & & \vdots & & \vdots \\ 1 & x_n & x_n^2 & x_n^3 & \ldots & x_n^{n-1}\end{bmatrix}\$.
This determinant can be written as:
\$\det V(x_1, x_2, \ldots x_n) = \prod_\limits{1 \leqslant i < j \leqslant n} (x_j - x_i)\$
Details
Your program/function has to accept a list of floating point numbers in any convenient format that allows for a variable length, and output the specified determinant.
You can assume that the input as well as the output is within the range of the values your language supports. If you language does not support floating point numbers, you may assume integers.
Some test cases
Note that whenever there are two equal entries, the determinant will be 0 as there are two equal rows in the corresponding Vandermonde matrix. Thanks to @randomra for pointing out this missing testcase.
[1,2,2,3]            0
[-13513]             1
[1,2]                1
[2,1]               -1
[1,2,3]              2
[3,2,1]             -2
[1,2,3,4]           12
[1,2,3,4,5]        288
[1,2,4]              6
[1,2,4,8]         1008
[1,2,4,8,16]  20321280
[0, .1, .2,...,1]   6.6586e-028
[1, .5, .25, .125]  0.00384521
[.25, .5, 1, 2, 4]  19.3798828

Can we assume the input is at least of length 2?

@Pietu1998 No, see the first test case.

Important test case: [1,2,2,3] => 0: two equal elements in the array, to test if the code checks self-difference (xi-xi) just by comparing to 0.

@randomra Thank you, I totally forgot to include one of those. Whenever two entries are equal, the determinant will be 0 as there are two times the same row.

@flawr The expected output was clear from your specs. I suggested the test case so answers not prepared for equal numbers could find their mistakes more easily.

Jelly, 5 bytes
œc2IP

œc2 gets all combinations without replacement of length 2. I computes the difference list of each of those pairs, yielding a list like [[1], [2], [3], ..., [1]]. We take the Product.
Try it here!

In modern Jelly, Œc works as a short form of œc2, so ŒcIP is a 4-byte solution.

Mathematica, 30 bytes
1##&@@(#2-#&@@@#~Subsets~{2})&

This is an anonymous function.
Expanded by Mathematica, it is equivalent to (1 ##1 & ) @@ Apply[#2 - #1 & , Subsets[#1, {2}], {1}] &. 1##& is an equivalent for Times (thanks tips page), which is applied to each distinct pair of elements from the input list, generated by Subsets[list, {2}]. Note that Subsets does not check for uniqueness of elements.

Ruby, 49 47 bytes
->x{eval(x.combination(2).map{|a,b|b-a}*?*)||1}

This is a lambda function that accepts a real valued, one-dimensional array and returns a float or an integer depending on the type of the input. To call it, assign it to a variable then do f.call(input).
We get all combinations of size 2 using .combination(2) and get the differences for each pair using .map {|a, b| b - a}. We join the resulting array into a string separated by *, then eval this, which returns the product. If the input has length 1, this will be nil, which is falsey in Ruby, so we can just ||1 at the end to return 1 in this situation. Note that this still works when the product is 0 because for whatever reason 0 is truthy in Ruby.
Verify all test cases online
Saved 2 bytes thanks to Doorknob!

MATL, 9
!G-qZRQpp

Try it online!
This computes a matrix of all differences and then keeps only the part below the main diagonal, making the other entries 1 so they won't affect the product. The lower triangular function makes the unwanted elements 0,  not 1. So we subtract 1, take the lower triangular part, and add 1 back. Then we can take the product of all entries.
t     % take input. Transpose
G     % push input again
-     % subtract with broadccast: matrix of all pairwise differences
q     % subtract 1
ZR    % make zero all values on the diagonal and above
Q     % add 1
p     % product of all columns
p     % product of all those products

It's unfortunate but 2Xn!dp only seems to work with single values when the value is greater than or equal to 2... I had written it myself trying to beat Jelly :P

@FryAmTheEggman Awww. You are right. Thanks for the heads-up!

Yeah, I figured that was the problem. I'd consider trying something like adding a wrapper when you get Xn to do a check like if size(arg) == [1,1] ... or something. I'm too lazy to look trough the source, but (hopefully) it shouldn't be that difficult.

@FryAmTheEggman In fact I'm not sure that's the problem (that's why I quickly edited my comment). If the first input is a number then the second input should be 1 or 0 and then it makes no difference if the first input is interpreted as array or as a number. The real problem is,  second input can't exceed the array size. "How many ways are there to choose 2 elements out of 1 element". In this case the array/number difference matters: if first input is an array return [](empty array), if it's a number return 0. I guess I'll return [], because then p forces the other interpretation

@FryAmTheEggman I think I'll split the function in two versions. Thanks again!

J, 13 bytes
-/ .*@(^/i.)#

This is a monadic function that takes in an array and returns a number.
Use it like this:
  f =: -/ .*@(^/i.)#
  f 1 2 4
6

Explanation
I explicitly construct the Vandermonde matrix associated with the input array, and then compute its determinant.
-/ .*@(^/i.)#   Denote input by y
            #   Length of y, say n
         i.     Range from 0 to n - 1
       ^/       Direct product of y with the above range using ^ (power)
                This gives the Vandermonde matrix
                 1 y0     y0^2     ... y0^(n-1)
                 1 y1     y1^2     ... y1^(n-1)
                   ...
                 1 y(n-1) y(n-1)^2 ... y(n-1)^(n-1)
-/ .*           Evaluate the determinant of this matrix

I thought whitespace was non-crucial in J...

@CᴏɴᴏʀO'Bʀɪᴇɴ The determinant is a special case that requires a separating space, since . is also a modifier character. Same for : on its own.

Oh! That's cool.

@CᴏɴᴏʀO'Bʀɪᴇɴ Actually, I think that is exactly what makes J uncool. J stands for Jot, i.e. a dot or little ring (APL's ∘), as in jotting with J... The incredibly overloaded . and : (which again is visually the same as two stacked .s) makes J hard to read (for me). How much more so when whitespace next to the dots determine meaning! J's . must be the most overloaded symbol in all of computing history: I count 53 distinct meanings of . and 43 (61 if you count all of _9: to 9:) distinct meanings of :. Yukk. ;-)

@Nᴮᶻ it may help to think of the . as its own token; thus, it could, without a white space, be mistaken for another operator. If J is not for you, however, that's understandable.

If someone were to make a cover for J's bi-graphs using single-char APL-like glyphs, on the other hand... like SAX...

Haskell, 34 bytes
f(h:t)=f t*product[x-h|x<-t]
f _=1

A recursive solution. When a new element h is prepended to the front, the expression is multiplied by the product of x-h for each element x of the list. Thanks to Zgarb for 1 byte.

Pyth, 15 13 12 11 bytes
*F+1-M.c_Q2

         Q    take input (in format [1,2,3,...])
        _     reverse the array: later we will be subtracting, and we want to
                subtract earlier elements from later elements
      .c  2   combinations of length 2: this gets the correct pairs
    -M        map a[0] - a[1] over each subarray
  +1          prepend a 1 to the array: this does not change the following
                result, but prevents an error on empty array
*F            fold over multiply (multiply all numbers in array)

Thanks to @FryAmTheEggman and @Pietu1998 for a byte each!

*F on an empty array should really be 1.

Mathematica, 32 bytes
Det@Table[#^j,{j,0,Length@#-1}]&

I was surprised not to find a builtin for Vandermonde stuff. Probably because it's so easy to do it oneself.
This one explicitly constructs the transpose of a VM and takes its determinant (which is of course the same as the original's). This method turned out to be significantly shorter than using any formula I know of.

Does not work if the list contains a zero element (giving 0^0 for j=0).

"I was surprised not to find a builtin for Vandermonde stuff." There is, but is somewhat hidden (and undocumented). Moreover, it does not make it shorter ;) : Det@*LinearAlgebra`Private`VandermondeMatrix.

APL (Dyalog Extended), 19 bytes
{×/-∊(⍳≢⍵)↓¨↓∘.-⍨⍵}

Dfn producing the pairs, then taking the product.
↓∘.-⍨⍵ all pairs (with repeats)
(⍳≢⍵) range from 1 to the length of the input
↓¨ drop 1 2 3 4... elements to avoid repeats
-∊ flatten and negate
×/ take the product
Try it online!

↓∘.-⍨⍵ -> ⍵-⊂⍵ and train: ×/∘∊⍳∘≢↓¨⊂-⊢

That's pretty clever, should I update my post?

thanks. sure, update and explain it if you want. i have no intention of posting separately.

Husk, 12 9 8 bytes
ΠṁhṠzM-ḣ

Try it online!
(Apparently the only one of the three which was correct)
-3 bytes by calculating difference instead of pairs.
-1 from Jo King
Explanation
ΠṁhṠzM-ḣ
   Ṡz    zip the input with
       ḣ prefixes
     M-  subtract the input from each
 ṁh      remove first element of each, join
Π        product

@Shaggy the longest one was the correct one :P

8 bytes through using prefixes instead

Perl, 38 41 bytes
Include +1 for -p
Give the numbers on a line on STDIN. So e.g. run as
perl -p vandermonde.pl <<< "1 2 4 8"

Use an evil regex to get the double loop:
vandermonde.pl:
$n=1;/(^| ).* (??{$n*=$'-$&;A})/;*_=n

Matlab, 26 bytes
(noncompeting)
Straightforward use of builtins. Note that (once again) Matlab's vander creates Vandermonde matrices but with the order of the rows flipped.
@(v)det(fliplr(vander(v)))

Why noncompeting?

Because I'm the one who made this challenge, I just wanted to provide this so people can try their own examples.

Isn't Det(flipped rows) = (-1)^n Det(original)?

I'm not quite sure, as the determinant switches sign whenever you switch two columns or rows.

@hYPotenuser - Replace n with n+1. All you're doing is multiplying by a matrix P which is all zeros except for the diagonal going from the bottom left to top right (so you want det(P * vander(v))= det(P) det(vander(v))). By expansion along the first column or whatever, you'll see det(P) = (-1)^(n+1).

Pari/GP, 35 bytes
a->matdet(matrix(#a,,i,j,a[i]^j--))

Try it online!

Haskell, 53 bytes
 f x=product[x!!j-x!!i|j<-[1..length x-1],i<-[0..j-1]]

Usage example: f [1,2,4,8,16] -> 20321280.
Go through the indices j and i in a nested loop and make a list of the differences of the elements at position j and i. Make the product of all elements in the list.
Other variants that turned out to be slightly longer:
f x=product[last l-i|l<-scanl1(++)$pure<$>x,i<-init l], 54 bytes
import Data.List;f i=product[y-x|[x,y]<-subsequences i], 55 bytes

CJam, 16 bytes
1l~{)1$f-@+:*\}h

In response to A Simmons' post, despite CJam's lack of a combinations operator, yes it is possible to do better :)
-1 byte thanks to @MartinBüttner.
Try it online | Test suite
1                   Push 1 to kick off product
 l~                 Read and evaluate input V
   {          }h    Do-while loop until V is empty
    )                 Pop last element of V
     1$               Copy the prefix
       f-             Element-wise subtract each from the popped element
         @+           Add the current product to the resulting array
           :*         Take product to produce new product
             \        Swap, putting V back on top

Rust, 86 bytes
|a:Vec<f32>|(0..a.len()).flat_map(|x|(x+1..a.len()).map(move|y|y-x)).fold(1,|a,b|a*b);

Rust, verbose as usual...
Explanation will come later (it's pretty straightforward, though).

JavaScript (ES6), 61 bytes
a=>a.reduce((p,x,i)=>a.slice(0,i).reduce((p,y)=>p*(x-y),p),1)

I tried an array comprehension (Firefox 30-57) and it was 5 bytes longer:
a=>[for(i of a.keys(p=1))for(j of Array(i).keys())p*=a[i]-a[j]]&&p

The boring nested loop is probably shorter though.

Japt v1.4.5, 8 bytes
à2 ®rnÃ×

Try it (includes all test cases)
à2 ®raÃ×     :Implicit input of array
à2           :Combinations of length 2 (using v1.4.5 avoids a bug here in later versions)
   ®         :Map
    r        :  Reduce by
     n       :  Inverse subtraction
      Ã      :End map
       ×     :Reduce by multiplication

[-13513] returns -13513.

I cobbled this together based on other solutions, @Razetime, 'cause I don't "speak" mathematical notation*; other than the fact that the a should be an n, though (which wouldn't affect this test case), I can't figure out what the fix should be. The insomnia probably isn't helping. (*I really wish people would stop relying on it as the sole means of defining their spec).

can relate very much to that.

Figured it out: Japt v1.4.6 introduced a bug whereby attempting to get the combinations of length n of an array with length less than n returns the original array instead of the empty array so I was able to "fix" it by downgrading to v1.4.5. Thanks, @Razetime

Nice work done!  +1

05AB1E, 6 bytes
η-€¨˜P

Try it online!
Commented:
η         # prefixes of the input
 -        # subtract those from the input
  €       # for each sublist:
   ¨      #   remove the last element (i=j)
    ˜     # flatten the list
     P    # take the product

There are a few alternatives at the same length, such as ηõš-˜P.

Desmos, 10+39=49 bytes
n=a.length
\prod_{i=1}^n\prod_{j=i+1}^n(a[j]-a[i])

View it in Desmos
There's not a lot to be golfed here other than "caching" a.length in an array, but I would like to point out that Desmos can handle the ... notation in arrays!

Python 3, 91 bytes (does NOT work yet)
lambda x:eval("*".join([str(b-a) for a,b in combinations(x,2)]))or 1
from itertools import*

Try it online!
Port of Alex A.'s answer.
Fixing currently.

you don't ned the brackets and you dont need the space between ) and for

Factor + math.matrices math.matrices.laplace, 45 bytes
[ dup length vandermonde-matrix determinant ]

Attempt This Online!

CJam, 32 bytes
1q~La\{1$f++}/{,2=},{~-}%~]La-:*

I'm sure someone can golf this better in CJam... The main issue is that I can't see a good way of getting the subsets so that uses up most of my bytes. This generates the power set (using an idea by Martin Büttner) and then selects the length-2 elements.

R, 41 bytes
function(v)det(outer(v,1:sum(v|1)-1,"^"))

Try it online!
I was surprised not to see an R answer here!

Perl 5 -pa, 36 bytes
$\=1;map$\*=$q-$_,@F while$q=pop@F}{

Try it online!

Arn, 27 bytes
ùW®š¡'‡ùHÓáâ§○iò;êñ⁺bì&B"$7

Try it!
Explained
Unpacked: *{*v{v-:{}\.{}\[_ _{.{}->--((:s)#
* ... \                  % Fold with multiplication after mapping
  {                      % Begin block
    * ... \
      v{                 % Block with key of `v`
          v              % Variable with identifier `v`
        -                % Minus
            _            % Variable intialized to STDIN; implied
          :{             % Head
      }                  % End block
              _          % Implied
            .{           % Beheaded
  }
        [                % Begin sequence
          _              % Entry equal to STDIN
          _{             % Block with key of `_` (needed otherwise the first `_` will be grabbed)
              _          % Last entry; implied
            .{           % Beheaded
          }
          ->             % Of length
            --           % Reduced by one
              (          % Begin expression
                  (
                      _  % Implied
                    :s   % Split on spaces
                  )      % End expression
                #        % Length
              )          % Implied
        ]                % End of sequence; implied

Had to fix a few major bugs I only found because of this challenge! Also made me consider adding a few quality of life features (including an upgrade to precedence and # automatically casting to a vector).
Speaking of bugs, I am 100% certain this works on the downloadable version, and it should be working on the online version very soon.

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


text:
Merging two strings
Introduction
Let's say that S1 = a...b and S2 = ..c... If we place them on top of each other, we get:
a...b
..c..

We merge both strings, with the . as the liquid character (which can overlapped). We get this:
a.c.b

If one of the string is longer than the other, we just apply the same algorithm:
a.....b
..c..

becomes:

a.c...b

and
a.....b
..c.......

becomes:

a.c...b...

If two characters collide, we just use the bottom character, e.g.
a..b
...c

becomes:

a..c

The Task
Given two non-empty strings, output the merged string. Note, you can assume that the input only contains periods and lowercase letters (or uppercase letters if that is more convenient).
Test cases
Input              Output
a....b ..c...      a.c..b
aaaaaa bbbbbb      bbbbbb
ab.ab. b.b.b.      bbbab.
a.......b c        c.......b

This is code-golf, so the submission with the least amount of bytes wins!

Is input a.....b ..c....... possible? What's the output then?

@DonMuesli That would become a.c...b....

Can we output a list of characters instead of a string?

@DenkerAffe No, sorry

Can the strings be taken in the opposite order?

Possible duplicate of Unslice a string

@Mego Yes, but that means that when two characters collide, the top character is used instead of the bottom.

Jelly, 5 bytes
Œu»Œl

Input via command-line arguments.
Try it online!
Explanation
This is a direct port of my CJam answer (see that for an explanation why this works):
Œu     # Convert first argument to upper case.
  »    # Element-wise maximum between both strings.
   Œl  # Convert result back to lower case.

NOOO! You can't adopt Jelly too! We will be left with all the mods as golfing masters.

@rikerw haha, why d'you think they're mods? cause they're good at golf :P

@RikerW I just had to preempt someone else beating me by porting my own solution to Jelly. ¯\(ツ)/¯

CJam, 9 bytes
leul.e>el

Test it here.
Explanation
Makes use of the fact that '.' < upper case letters < lower case letters. This way, when taking the element-wise maximum between two strings, any letter overrides a ., but we can make a letter from the second input override a letter from the first if we upper case the first. Confusing? Here's one of the test cases as an example:
ab.ab.
b.b.b.

Convert first to upper case:
AB.AB.
b.b.b.

Take the element-wise maximum:
bBbAb.

Convert back to lower case:
bbbab.

And here is how the code does that:
l    e# Read first line.
eu   e# Convert to upper case.
l    e# Read second line.
.e>  e# Take element-wise maximum. If the lengths are different, the additional elements
     e# from the longer list are just appended.
el   e# Convert back to lower case.

Nice eu / el trick!

Javascript ES6, 52 55 chars
(a,b)=>b.replace(/\./g,(m,i)=>a[i]||m)+a.slice(b.length)

Test
f=(a,b)=>b.replace(/\./g,(m,i)=>a[i]||m)+a.slice(b.length)
;`
a....b ..c...      a.c..b
aaaaaa bbbbbb      bbbbbb
ab.ab. b.b.b.      bbbab.
a.......b c        c.......b
c a....b           a....b
`.split('\n').filter(Boolean).map(s=>s.split(/\s+/)).every(a=>f(a[0],a[1])==a[2])

This will fail for input such as: f('c', 'a....b')

@dev-null, fixed

Pyth, 11
smenD\.d.TQ

Try it online or run the Test Suite

Seriously, 10 bytes
,û,Z`M`MΣù

Try it online!
Uses the same strategy as Martin's CJam answer
Explanation:
,û,Z`M`MΣù
,û          get first string, uppercase
  ,Z        get second string, zip with first string
    `M`M    map maximum
        Σù  join and uppercase

Octave, 50 bytes
function c=m(a,b)c=b;c(a>0)=a;i=b>46;c(i)=b(i);end

You can replace != by >

Python 2, 47 bytes
lambda s,t:`map(max,s.upper(),t)`[2::5].lower()

very golfy! I'm looking for a way to get rid of upper() and lower() but no luck so far...

@Max you sadly can't... this program uses the fact that '.'<uppercase<lowercase.

Haskell, 43 42 bytes
(a:b)#(c:d)|c<'a'=a:b#d|1<2=c:b#d
a#b=a++b

Usage example: "ab.ab." # "b.b.b." -> "bbbab.".
How it works:

if both list are non-empty, pick the the head of the 1st list if the head of the 2nd list is ".", else pick the head of the second list. Append a recursive call with the tails of the lists.
if at least one list is empty, append both lists.

Edit: @Lynn saved a byte. Thanks!

“you can assume that the input only contains periods and lowercase letters”, so you could check c<'a' to save a byte.

Julia, 101 bytes
f(s,t,r=i->rpad(i,max((n=endof)(s),n(t)),"."))=join([min(a,b)<90?max(a,b):b for(a,b)=zip(r(s),r(t))])

This is a function that accepts two strings and returns a string.
We compute m as the maximum length of the two inputs, then define a function r that right pads its input with .s to length m and store that as a function argument. We then zip the right padded inputs and check the minimum (as defined by the ASCII code) of each pair. If it's a ., we use whichever character has the bigger code, otherwise we use whichever came from the second input. The resulting array is joined into a string and returned.

C, 106 89 bytes
i,j,k;f(s,z)char*s,*z;{for(i=0,j=k=1;j|k;i++)putchar((k=k?z[i]:0)>46|!(j=j?s[i]:0)?k:j);}

Test live on ideone.

Retina, 55

$

+`(.?(\S* )(\w)|(\S)(\S* ).?)(\S* .*)
$2$5$6$3$4

Line 5 is a single space.  Line 6 is an empty line (with no trailing newline).
Try it online.
I started this one in GNU sed, (with the -r option).  Straightforward port to Retina once I got the regexes figured out.  The sed version is:
s/$/ /
:
s/(.?(\S* )(\w)|(\S)(\S* ).?)(\S* .*)/\2\5\6\3\4/
t
s/ *//

The Retina version fails with a..k.f....b c...f.g...g. => .c..kffg...g

Python 2, 70 bytes
lambda x,y:"".join([k if k!="."and k else j for j,k in map(None,x,y)])

Try it here!
First we create zip both strings into one list. If the second string is longer than the first, it is padded with None (map(None,x,y) does that).
Then we iterate over this list with j being the character from the first string and k the one from the second string. We choose k if it's not a dot and otherwise j.
This could be 61 bytes if I could output the result as list of characters instead of a string.

Perl, 48 + 3 = 51 bytes
s/\./substr($^I,$.=pos,1)||$&/ge;$_.=substr$^I,$.

Bah cannot find a shorter solution. (Same approach as @Qwertiy's JavaScript's answer).
Requires -pl and takes input from stdin and -i
$ perl -i'a...ce' -ple's/\./substr($^I,$.=pos,1)||$&/ge;$_.=substr$^I,$.' <<< '..b.d..f'
a.b.de..f

Pre-extend the target string (which looks very pretty too): $_^=$^I^$^I;s/\.|\0/substr$^I,pos,1or$&/ge

q/kdb+, 43 40 bytes
Solution:
lower{l:max(#:)each(x;y);upper[l$x]|l$y}

Example:
q)lower{l:max(#:)each(x;y);upper[l$x]|l$y}["a..b..";"...c"]
"a..c.."

Explanation:
(#:)                // k equivalent of count
max (#:) each(x;y)  // takes each string, count the length, return maximum
l$x                 // whites-space pad string x to length l
|                   // take the maximum (per Martin's strategy)
upper[...]          // convert padded string 1 to uppercase
lower{...}          // convert result of function to lowercase

Notes:
I'm taking taking advantage of "Given two non-empty strings" and assuming that inputs are strings. In kdb "c" is an atom, (),"c" is a string, otherwise need to add 6 bytes to the score, as we cannot use $ to pad an atom...

PHP>=7.1, 58 Bytes
for([,$x,$y]=$argv;~$c=$y[$i++];)$c<_?:$x[$i-1]=$c;echo$x;

Online Version

Undefined constant _

JavaScript (Node.js), 50 bytes
f=([a,...b],[c,...d])=>a+c?(c>'.'?c:a||c)+f(b,d):d

Try it online!

C (GCC), 86 76 bytes
-10 bytes thanks to @ceilingcat
f(x,y)char*x,*y;{for(;*x|*y;putchar(0[y=*y?y:x]-46?*y:*x),x++,y++)x=*x?x:y;}

Attempt This Online!

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:
Read an analog clock
You are given the positions of the minute and hour hands of an analog clock as an angle of clockwise rotation from the top (12). So a hand pointing at 9 is at an angle if 270, and a hand pointing exactly in between 12 and 1 is at an angle of 15.
Input will be two integer angles (in any order of your choice) between 0 and 359. Minute hand will be a multiple of 60, hour hand will be a multiple of 5. Output will be the time, given as two integers separated by a colon (and nothing more).
Sample data
(Hour hand first)
195 180 - 6:30
355 300 - 11:50
280 120 - 9:20
0 0 - 12:00
10 120 - 12:20

If I understand correctly, the second test cast gives 11:50, not 11:55. Also (hint): you could calculate the time from the hour hand only(!)

Yea... since the minute hand is constrained to 60 degree intervals, there shouldn't be any minutes that aren't a multiple of 10.

9:05 is not even valid for this challenge, neither is 280 30.

Surely the hour hand will be a multiple of 5 degrees?

What's the correct answer for an input of 0 0?

Most answers have 0:0 for 0 0. Strange... I even have a deleted answer because of that.

@edc65 Edited..

@zyabin Can I do anything about it?

May we return a leading 0, in accordance with ISO 8601?

JavaScript ES6, 22 bytes
a=>b=>(0|a/30)+":"+b/6

Try it online (all browsers work)

Pyth, 9 bytes
j\:.DyQ60

Explanation:
          - autoassign Q = eval_input()
     yQ   -   Q*2
   .D  60 -  divmod(^, 60)
j\:       - ":".join(^)

Try it here
Or try a test suite

Great approach!

Jelly, 13 7 bytes
Le code:
Ḥd60j“:

L'explanation:
         # Uses only the hour hand, (355)
Ḥ        # Double this, (355 × 2 = 710)
 d60     # Divmod 60, ([710 : 60, 710 % 60] = [11, 50])
    j“:  # Join by “:”, (11:50)

Try it online!

PHP, 50 bytes
function t($h,$m){echo floor($h/30)?:12.":".$m/6;}

Set $h and $m to whatever values you like, and off you go.

Where do you get $h and $m from?

Setting them immediately before the echo.  The thread starter never specified how input was handled.

By default all submissions have to be either full programs that read from STDIN and print to STDOUT or functions that read arguments and return values. Assuming that the variables exist makes this a snippet, which we don't allow.

Edited to add function call

Pyth, 11 bytes
++/E30\:/E6

Try it online or Test Suite
Alternative version but the same size:
j\:[/E30/E6

Explanation
Abuses the fact that Python does integer division by default
  /E30       Divide `\` input `E` by 30
 +    \:     Add literal `:`
+       /E6  Add input `E` divided by 6

Doesn't display the correct output for 10 120

Retina, 93 107 bytes
Byte count assumes ISO 8859-1 encoding
Had to fix a bug, code wasn't working for 0 in input and 0 minutes was shown as a single zero, not two. Fix for 0 in input didn't add any extra characters, but the minutes and new test case added some extra weight...
So...uh...integer division with regex?
(\d+) (\d+)
30$*' $1$*';¶6$*' $2$*';
m+`^('+) \1('*);('*)$
$1 $2;$3'
.+;

('*)¶('*)
$.1:$.2
:0$
:00
\`^0
12

Input is hours and minutes separated by space. Hours come first.
Try it online!

Python 2.7, 35 28 characters
Needs hour hand as a first input; ignores the minute hand input.
lambda i:`i/30`+":"+`i*2%60`

7 characters less thanks to @DenkerAffe by using lambda instead of input() and print.

28 bytes if you go with an anonymous lambda which is always allowed unless explicitly forbidden. lambda i:i/30+":"+i*2%60``

Perl 21 + 1 = 22 bytes
$_=($==$_/30).$".<>/6

Requires the -p flag and takes input on multiply lines. Requires -l for multiply inputs:
$ (echo $'195\n180';echo $'355\n300';echo $'280\n120') | perl -pl analclock.pl
6 30
11 50
9 20

Assigning to $= will always yield an integer print($= = 1.23) => 1

Pyke, 10 9 bytes
2*60.DRJ:

Explanation:
2*        - a = eval_input_or_not() * 2
  60.D    - a,b = divmod(a, 60)
      R   - a,b = rot_2(a,b)
       J: - ":".join([a,b])

05AB1E, 11 bytes
Code:
30/ï':I6/ïJ

Explanation:
30/          # Divide implicit input by 30
   ï         # Convert to int
    ':       # Add the ':'-character
      I6/ï   # Input divided by 6 and converted to int
          J  # Join the stack

Try it online
Uses CP-1252 encoding.

R, 29 bytes
cat(scan()%/%c(30,6),sep=':')

CJam, 11 bytes
ri30/':ri6/

Try it online!

MATL, 10 bytes
720/2$15XO

The hour in the output has a leading zero if less than 10.
Try it online!
720/      % take first input and divide by 720
2$15XO    % format as HH:MM

Perl 6, 54 bytes
{sprintf "%d:%02d",($^a div 30||12),$^b/6}

This accounts for 0 hours -> 12:00, as well as having two digits in the minutes place

DUP, 12 bytes
[2*60/.':,.]

Try it here.
Anonymous lambda that takes minutes then hours as arguments. Usage:
180 195[2*60/.':,.]!

Explanation
[          ] {lambda}
 2*          {double hours}
   60/       {divmod by 60}
      .      {output quotient}
       ':,   {output :}
          .  {output remainder}

Milky Way 1.6.5, 27 bytes
'2*60m":";+;?{_;+_^12;+0+}!

Explanation
'2*                          ` double the input (195) -> [390]
   60m                       ` divmod TOS by 60 -> [6, 30]
      ":";+;                 ` add a colon -> [":30", 6]
            ?{_;+_^12;+0+}   ` format HH:MM -> ["6:30"]
                          !  ` output TOS

Japt, 14 bytes
U/30|0 +':+V/6

Test it online!
I really need to implement a shorter way to floor...

CJam, 11 bytes
ri2*60md':\

An alternate approach using divmod.
Try it online!

Lua, 101 Bytes
A solution only using the hour argument. It is a full program taking the input via command-line argument lua readAnalogClock.lua 355. You could call it with 2 arguments, but the second one is never used.
i=arg[1]j=i%30i=(i-j)/30print(((i<1 and 12or i)..''):gsub("%..*","")..":"..(2*j..''):gsub("%..*",""))

Ungolfed
i=arg[1]                  -- initialise i with the hours angle
j=i%30                    -- initialise j with the minute part of i
i=(i-j)/30                -- round i to the previous hour
print(
  ((i<1 and 12or i)..'')  -- replace 0 by 12 and make it a string
    :gsub("%..*","")      -- remove decimal part of hour (which is .0)
  ..":"                   -- concatenate with the separator
  ..(2*j..'')             -- makes a string containing the minutes
    :gsub("%..*",""))     -- remove decimal part of minutes

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


text:
Is this number random?
I asked random.org for 128 random integers between 0 and 232 - 1. Since the random number generator was so eager to give the first 64 numbers first, they're obviously more random than the other 64.
Write a full program or function that returns a truthy result when one of the following 64 integers is input:
[1386551069, 1721125688, 871749537, 3410748801, 2935589455, 1885865030, 776296760, 614705581, 3841106923, 434616334, 1891651756, 1128215653, 256582433, 310780133, 3971028567, 2349690078, 489992769, 493183796, 3073937100, 3968540100, 777207799, 515453341, 487926468, 2597442171, 950819523, 1881247391, 3676486536, 3852572850, 3498953201, 2544525180, 297297258, 3783570310, 2485456860, 2866433205, 2638825384, 2405115019, 2734986756, 3237895121, 1560255677, 4228599165, 3106247743, 742719206, 2409129909, 3008020402, 328113612, 1081997633, 1583987616, 1029888552, 1375524867, 3913611859, 3488464791, 732377595, 431649729, 2105108903, 1454214821, 997975981, 1764756211, 2921737100, 754705833, 1823274447, 450215579, 976175934, 1991260870, 710069849]

And a falsey result for the other 64 numbers:
[28051484, 408224582, 1157838297, 3470985950, 1310525292, 2739928315, 3565721638, 3568607641, 3857889210, 682782262, 2845913801, 2625196544, 1036650602, 3890793110, 4276552453, 2017874229, 3935199786, 1136100076, 2406566087, 496970764, 2945538435, 2830207175, 4028712507, 2557754740, 572724662, 2854602512, 736902285, 3612716287, 2528051536, 3801506272, 164986382, 1757334153, 979200654, 1377646057, 1003603763, 4217274922, 3804763169, 2502416106, 698611315, 3586620445, 2343814657, 3220493083, 3505829324, 4268209107, 1798630324, 1932820146, 2356679271, 1883645842, 2495921085, 2912113431, 1519642783, 924263219, 3506109843, 2916121049, 4060307069, 1470129930, 4014068841, 1755190161, 311339709, 473039620, 2530217749, 1297591604, 3269125607, 2834128510]

Any input other than one of these 128 numbers is undefined behavior.
If your solution is found programmatically, please also share the code used to generate it!
This is code-golf, so the shortest solution in bytes wins.

Since the random number generator gave the first 64 numbers first, they must be more random ಠ___ಠ

You can distinguish the two sets modulo 834

Those numbers are not random.

"Maybe, not enough information."& 33 bytes, answers the question.

@CatsAreFluffy How aren't they random? I did use a program to generate them from bits from random.org; there may have been a bug.

Well, look at my answer. Normally, that doesn't seem to be possible.

@CatsAreFluffy Actually, as long as the input doesn't contain 0 or 1 and no two elements differ by 1, you can separate them by a modulo chain. e.g. separating [4 20 79] from [8 18 100] can be done by [99 79 20 17 7 4] (see if you can spot the pattern). Sure, the initial half of your answer might use a much smaller modulo than the input, but the back half consists of shifting one element at a time.

Oh. Makes sense.

Also my algorithm usually fails for other input sets (it chooses the smallest modulus that still allows for distinguishing the sets)

CJam, 53 52 47 bytes
l~"X    0'ò"2/Dfb+:%"gÇâì6Ô¡÷Ç8nèS¡a"312b2b=

There's unprintables, but the two strings can be obtained by
[88 9 48 5 39 5 29 1 242]:c
[8 103 199 226 236 54 212 15 161 247 199 56 110 232 83 161 97]:c

respectively. This also shows that the code points are below 256.
This is a modulo chain answer, where we apply the following modulos to the input integer, in order:
[1153 629 512 378 242 136]

Since this list contains integers greater than 255, the list is encoded using two chars each. The decoding is done by 2/Dfb, which splits the string into chunks of length two and converts each from a base 13 number (e.g. 88*13 + 9 = 1153). However, there are two exceptions to the decoding:

The last number (136) is not included (see below),
The second-last number is represented by a single char, since the number (242) is less than 256 and splitting an odd-length array into chunks of size 2 will leave a size 1 array at the end. Thanks to @MartinBüttner for this tip!

Once the modulos have reduced the input integer to a relatively small number, we perform a lookup from a table. This table is encoded via the second string, which is converted to a base 312 number then decoded to base 2, which we index. Since CJam's array indexing wraps, we can leave out the final modulo as mentioned earlier.
Try it online | Test suite

How do you people come up with the magic moduli?

@CatsAreFluffy Just a simple DFS with a limit on the number of modulos. My current implementation is quite slow, so if I feel like the program's stuck for a while I try a different initial starting point.

What's a DFS? (Wikipedia doesn't help.)

@CatsAreFluffy Depth-first search

Ah. I just used a greedy algorithm.

Retina, 117 bytes
([023]3|[067]0|[1289]1|5[5689]|67|96|88|77|65|05)$|^(8|4[358]|7[147]|51|37|30)|865|349|2.{5}5|761|74[348]|728|811|990

A regex golf answer, outputting a positive integer for truthy and zero for falsy.
Try it online! | Test suite - truthy | Test suite - falsy | Regex101

Jelly, 30 bytes
ȷ;€ȷḥ€⁸ḋ“¡`Ṿc-MrKṪZiṣ$Ṅ(ṀQ’B¤Ḃ

Try it online!
This answer was almost entirely automatically generated, using this automated encoder (which I wrote myself, and have previously used in another challenge); here's where the original algorithm (which I created myself) comes from. Because Jelly isn't so great at interprocess communication, the encoder generates a Sage program that generates a Jelly program that prints the final golfed program.
There were three manual tweaks to the automated result: two were golfing uses of base-generic builtins that dealt with base 2 into the (shorter) versions that are specific to binary, and one was to change the program from a full program into a function (so that I could easily test it on every test case – the byte count is the same either way, you just need to change the way it takes input from ⁸ (function argument) into, e.g., ³ (command-line argument)).
The generator has a couple of deficiencies that mean that it randomly fails sometimes; for a decision-problem (and therefore only two outputs), this chance is much higher than normal (hard to estimate exactly, but likely above 50%). Fortunately, it randomly happened to work first time
Explanation
ȷ;€ȷḥ€⁸ḋ“¡`Ṿc-MrKṪZiṣ$Ṅ(ṀQ’B¤Ḃ
 ;                              Form a pair of
  €                               each number from 1 to
ȷ                                   1000
   ȷ                              and 1000
     €                          and use each pair as
    ḥ                             a hash configuration, to hash
      ⁸                             this function's argument.
       ḋ                        Take the dot product {of the list of hashes}
                            ¤     and a constant determined by
                           B        taking the list of binary digits of
        “¡`Ṿc-MrKṪZiṣ$Ṅ(ṀQ’           [a magic constant]
                             Ḃ  {Output} its least significant bit.

As usual, the algorithm is to pass the inputs we're given through a list of hash functions to create a list of hashes (the list created this way is longer than it needs to be, to save bytes specifying how long it needs to be), then take the dot product of the list of hashes and a magic constant calculated by the program I linked above.
The reason this works is that each input/output pair that we need to set effectively corresponds to a requirement on the parity of the number of set bits in certain positions in the magic constant, e.g. the requirement that 1386551069 maps to 1 means that out of the bit positions in the magic constant that correspond to hash functions that hash 1386551069 to an odd number, an odd number of them need to be a 1 bit in order for the program to give the correct output in that case. This sort of requirement can be expressed as a linear equation in the finite field GF(2), making it possible to calculate what the magic constant should be simply via writing down all the equations (which is what the first stage of the generator program does) and solving them (which is what the Sage program that it outputs does). There might not be a solution, of course, but given an entirely randomly chosen set of simultaneous equations (i.e. each variable has a random coefficient in every equation), if the number of equations is no greater than the number of variables, the odds that they turn out to be solvable are actually pretty high, and they were here.
I did end up with a bit of luck converting the resulting equations to Jelly – the first bit of the list that needs to be encoded in the magic constant happens to be a 1, so it's possible to compress it by base-converting it into a number (which couldn't be done if it had a leading zero, as the leading zero would then be missing upon base-converting back). This is only a problem because Jelly base conversions are big-endian (extra trailing zeroes past the last useful hash function wouldn't have an effect), so wouldn't affect a golfing language that had this generic algorithm available as a builtin. Fortunately, this particular set of inputs and outputs managed to dodge the issue (and it's a deficiency with the decompressor that sits around the magic constant, rather than the technique for finding the magic constant itself).
As a side note, the magic constant is 17 bytes long (not 16, the theoretical minimum for 128 input → output pairs) because not all of the 256 bytes of the Jelly codepage are able to appear in a compressed literal – 6 of them are quotes (which can't appear unescaped because they'd be interpreted as ending the string, and there isn't an escape syntax), so only 250 of them are actually available, and that makes string literals a little longer than they would be in base 256.

JavaScript (ES6) 233
An anonymous function returning 0 as falsy and nonzero as truthy
x=>~"lnhp2wm8x6m9vbjmrqqew9v192jc3ynu4krpg9t3hhx930gu8u9n1w51ol509djycdyh077fd1fnrzv6008ipkh0704161jayscm0l6p4ymj9acbv5ozhjzxo3j1t20j9beam30yptco033c9s3a8jwnre63r29sfbvc5371ulvyrwyqx3kfokbu66mpy9eh" // newline added for readability
.search((x.toString(36)).slice(-3))

Checking the last 3 digits in the number representation in base 36.
The check string is built so:
a=[1386551069, 1721125688, ... ]
H=x=>(x.toString(36)).slice(-3)
Q=a.map(x=>H(x)).join('')

Test

f=x=>~"lnhp2wm8x6m9vbjmrqqew9v192jc3ynu4krpg9t3hhx930gu8u9n1w51ol509djycdyh077fd1fnrzv6008ipkh0704161jayscm0l6p4ymj9acbv5ozhjzxo3j1t20j9beam30yptco033c9s3a8jwnre63r29sfbvc5371ulvyrwyqx3kfokbu66mpy9eh"
.search((x.toString(36)).slice(-3))

a=[1386551069, 1721125688, 871749537, 3410748801, 2935589455, 1885865030, 776296760, 614705581, 3841106923, 434616334, 1891651756, 1128215653, 256582433, 310780133, 3971028567, 2349690078, 489992769, 493183796, 3073937100, 3968540100, 777207799, 515453341, 487926468, 2597442171, 950819523, 1881247391, 3676486536, 3852572850, 3498953201, 2544525180, 297297258, 3783570310, 2485456860, 2866433205, 2638825384, 2405115019, 2734986756, 3237895121, 1560255677, 4228599165, 3106247743, 742719206, 2409129909, 3008020402, 328113612, 1081997633, 1583987616, 1029888552, 1375524867, 3913611859, 3488464791, 732377595, 431649729, 2105108903, 1454214821, 997975981, 1764756211, 2921737100, 754705833, 1823274447, 450215579, 976175934, 1991260870, 710069849]
b=[28051484, 408224582, 1157838297, 3470985950, 1310525292, 2739928315, 3565721638, 3568607641, 3857889210, 682782262, 2845913801, 2625196544, 1036650602, 3890793110, 4276552453, 2017874229, 3935199786, 1136100076, 2406566087, 496970764, 2945538435, 2830207175, 4028712507, 2557754740, 572724662, 2854602512, 736902285, 3612716287, 2528051536, 3801506272, 164986382, 1757334153, 979200654, 1377646057, 1003603763, 4217274922, 3804763169, 2502416106, 698611315, 3586620445, 2343814657, 3220493083, 3505829324, 4268209107, 1798630324, 1932820146, 2356679271, 1883645842, 2495921085, 2912113431, 1519642783, 924263219, 3506109843, 2916121049, 4060307069, 1470129930, 4014068841, 1755190161, 311339709, 473039620, 2530217749, 1297591604, 3269125607, 2834128510]

A.textContent=a.map(x=>f(x))
B.textContent=b.map(x=>f(x))

first 64 - truthy

other 64 - falsy

Mathematica, 218 217 bytes
Fold[Mod,#,{834,551,418,266,228,216,215,209,205,199,198,195,178,171,166,162,154,151,146,144,139,137,122,120,117,114,110,106,101,98,95,88,84,67,63,61,60,57,55,51,45,44,43,41,40,35,34,30,27,26,25,23,20,14,13,11,10,9}]<1

For whatever reason, a set of moduli exists that allows us to distinguish two sets just by whether or not, after applying the moduli, the result is zero or not.
The long list of moduli was generated by this program:
Block[{data1, data2, n, mods},
 data1 = {1386551069, 1721125688, 871749537, 3410748801, 2935589455,
   1885865030, 776296760, 614705581, 3841106923, 434616334,
   1891651756, 1128215653, 256582433, 310780133, 3971028567,
   2349690078, 489992769, 493183796, 3073937100, 3968540100,
   777207799, 515453341, 487926468, 2597442171, 950819523, 1881247391,
    3676486536, 3852572850, 3498953201, 2544525180, 297297258,
   3783570310, 2485456860, 2866433205, 2638825384, 2405115019,
   2734986756, 3237895121, 1560255677, 4228599165, 3106247743,
   742719206, 2409129909, 3008020402, 328113612, 1081997633,
   1583987616, 1029888552, 1375524867, 3913611859, 3488464791,
   732377595, 431649729, 2105108903, 1454214821, 997975981,
   1764756211, 2921737100, 754705833, 1823274447, 450215579,
   976175934, 1991260870, 710069849};
 data2 = {28051484, 408224582, 1157838297, 3470985950, 1310525292,
   2739928315, 3565721638, 3568607641, 3857889210, 682782262,
   2845913801, 2625196544, 1036650602, 3890793110, 4276552453,
   2017874229, 3935199786, 1136100076, 2406566087, 496970764,
   2945538435, 2830207175, 4028712507, 2557754740, 572724662,
   2854602512, 736902285, 3612716287, 2528051536, 3801506272,
   164986382, 1757334153, 979200654, 1377646057, 1003603763,
   4217274922, 3804763169, 2502416106, 698611315, 3586620445,
   2343814657, 3220493083, 3505829324, 4268209107, 1798630324,
   1932820146, 2356679271, 1883645842, 2495921085, 2912113431,
   1519642783, 924263219, 3506109843, 2916121049, 4060307069,
   1470129930, 4014068841, 1755190161, 311339709, 473039620,
   2530217749, 1297591604, 3269125607, 2834128510};
 n = 1;
 mods = {};
 While[Intersection[Mod[data1, n], Mod[data2, n]] != {}, n++];
 FixedPoint[
  (mods = Append[mods, n]; data1 = Mod[data1, n];
    data2 = Mod[data2, n]; n = 1;
    While[Intersection[Mod[data1, n], Mod[data2, n]] != {}, n++];
    n) &
  , n];
 {mods, {Fold[Mod, data1, mods], Fold[Mod, data2, mods]}}
 ]

First output is the moduli, second and third outputs are the two lists, having applied the moduli.
The two long lists are the sets.

You can probably compress a part of the list into a string.

PowerShell, v3+ 194 bytes
$args[0]%834%653-in(40..45+4,8,12,51,60,64,69,76,84,86,93,97,103,117+137..149+160,162,178+195..209+215..227+255,263+300..329+354,361,386,398,417,443,444+469..506+516,519,535,565,581,586,606,618)

A little bit of a different approach, so I figured I would post it. It's not going to win shortest, but it may give someone else ideas to shorten their code.
We're still taking the input integer $args[0] and applying modulo operations to it, so nothing different there. In the above, we're using the -in operator (hence v3+ requirement) so this will output True for values that are in the truthy test case.
However, I'm attempting to find resultant arrays where we can leverage the .. range function to shorten the byte count, yet still have distinct arrays between the truthy and falsey values. We can do this since behavior other than the truthy/falsey input is undefined, so if the range catches values outside of the truthy/falsey input, it doesn't matter the output.
It's a pretty manual process so far, as the goal is to try and find the modulo where one of truthy or falsey arrays has large gap(s) between numbers and the other array has large amounts of numbers in that gap. I've mostly been going by intuition and gut feel so far, but I may eventually write a brute-forcer to solve this. The above is the shortest I've (mostly manually) found so far.


text:
Find the Words on the Grid!
Write a program or function that extracts a word from a wordsearch using its start and end coordinates.
The Input
Your program or function should accept three parameters: the start coordinate, the end coordinate, and a wordsearch from which to extract the word.

The start coordinate can be taken in any format.

It will always be an integer
The bottom left of the grid is (0, 0)
You will not be provided with coordinates that go outside the bounds of the grid
You will not be provided with coordinates that are not vertical, horizontal, or perfectly diagonal to each other, such as (7, 0) and (0, 6).

The end coordinate will be taken in the same format as the start coordinate
The wordsearch will be a string, or your language's closest equivalent

It will be a grid of characters separated by a single space, with each row on a newline. It can have any height or width - which can be different - but it will always be a rectangle. For example:
A G O A T C A T
E A T M E N O W
W O R D S E A R
A K L L K J H G
N P L F G H F D
A S P L K J H G
O P I L F G H J
T F A S E J K L

J H P B L D J L T
F J L N F N P W H
W P R D T F J R Q
J L L L L J H H W
N P L F H H F D S
J T P L L J H H K
P P J L F H H J N
L F J T F J L L O

The Output
You should output a string, or your language's closest equivalent. As no wordsearches in real life ever ask to find a single letter, you may output nothing if the coordinates are the same.
Examples and Test Cases

First Grid Above:
(0, 4) and (4, 0) --> "APPLE"

(4, 0) and (0, 4) --> "ELPPA"

(1, 7) and (4, 7) --> "GOAT"

(0, 5) and (7, 5) --> "WORDSEAR"

(0, 6) and (5, 6) --> "EATMEN"

(0, 6) and (0, 7) --> "EA"

(7, 0) and (0, 7) --> "LHJGLRAA"

----------

Second Grid Above:
(1, 0) and (8, 7) --> "FJLHJJWT"

(1, 4) and (4, 4) --> "LLLL"

(1, 4) and (1, 4) --> "L" or ""

Somewhat related.

You should format the test cases differently. This is way too much repeated text. Just split them into the two grids and go with something like (1,4),(4,4) -> "LLLL"

@DenkerAffe Done :)

Can I take the wordsearch as a listoflistofchars?

Test case 4 is incorrect. The correct output is "WORDSEAR"

@CatsAreFluffy Cheers! And hmm you can...makes it easier though ;)

I suggest to wait to accept an answer. Seeing the there is an accepted answer could discourage other players.

@edc65 Thanks for the tip ;)

JavaScript (ES6) 108
(x,y,t,u,g)=>eval("for(g=g.split`\n`.reverse(),r=g[y][2*x];x-t|y-u;)r+=g[y+=u<y?-1:u>y][2*(x+=t<x?-1:t>x)]")

Less golfed
(x,y,t,u,g)=>{
    g=g.split`\n`.reverse();
    for(r = g[y][2*x]; x-t | y-u; )
        r+=g[y += u<y ? -1 : u>y][2*( x += t<x ? -1 : t>x)];
    return r
}

Python 3.5 using Numpy, 251 bytes:
def r(t,y,z):import numpy;l=numpy.array([[*i.split()]for i in z.split('\n')]);A,B,C,D=t[0],y[0],t[1],y[1];p=[1,-1];a=p[A>B];b=p[C>D];n=range(A,B+a,a);m=range(C,D+b,b);w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])];return w

Takes input in the following format:
print(''.join(r((start1,start2),(end1,end2),'''grid''')))

Outputs in the format of a string (e.g. APPLE) as long as the function is called using the format above. Otherwise, a list
containing each letter (e.g. ['A','P','P','L','E']) is returned.

Will golf more over time where and when I can.
Try It Online! (Ideone) (Here, input is taken such that the grid is surrounded with double quotes ("") and input on one line, with \ns between each line of the grid. Then, the points are provided in a simple tuple form, with the starting on the second line, and the end on the third.)
Ungolfed code along with Explanation
def r(t,y,z):
    import numpy
    l=numpy.array([[*i.split()]for i in z.split('\n')])
    A,B,C,D=t[0],y[0],t[1],y[1]
    p=[1,-1]
    a=p[A>B]
    b=p[C>D]
    n=range(A,B+a,a)
    m=range(C,D+b,b)
    w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])]
    return w

For the purposes of this explanation, assume this program was run with the inputs ((0,4),(4,0)) and the first grid of the question. Here, I will go through the 2 main parts of the code:

l=numpy.array([[*i.split()]for i in z.split('\n')])
Here, l is a numpy array containing each line of the input in a separate "list". For instance, the first grid in the question, which is:
A G O A T C A T
E A T M E N O W
W O R D S E A R
A K L L K J H G
N P L F G H F D
A S P L K J H G
O P I L F G H J
T F A S E J K L

returns this numpy array:
[['A' 'G' 'O' 'A' 'T' 'C' 'A' 'T']
 ['E' 'A' 'T' 'M' 'E' 'N' 'O' 'W']
 ['W' 'O' 'R' 'D' 'S' 'E' 'A' 'R']
 ['A' 'K' 'L' 'L' 'K' 'J' 'H' 'G']
 ['N' 'P' 'L' 'F' 'G' 'H' 'F' 'D']
 ['A' 'S' 'P' 'L' 'K' 'J' 'H' 'G']
 ['O' 'P' 'I' 'L' 'F' 'G' 'H' 'J']
 ['T' 'F' 'A' 'S' 'E' 'J' 'K' 'L']]

w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])]
This is the main list of the function in which all of the letters corresponding to each point on the grid is found. Here, i corresponds to either each integer in n, which is a range object containing every number in the range start1=>end1+1 in increments of +1 if start1<end1 or -1 if the opposite is true. However, i only corresponds to this as long as start1 does not equal end1. Otherwise start1 is returned as many times as the length of m, where m is a range object containing each integer in the range start2=>end2+1 with the same conditions as n, and p corresponds to every integer in m. That being said, let us now walk through this step by step:

l[:,i] basically returns a row vector for each column, i, in the array, l. for instance, l[:,0] would return:
['A' 'E' 'W' 'A' 'N' 'A' 'O' 'T']

l[:,1] would return:
['G' 'A' 'O' 'K' 'P' 'S' 'P' 'F']

so on and so forth. You can read more about different ways of indexing in numpy, including this method, here.
Then, after that, the function reverses each array returned, using l[:,i][::-1], since each array is indexed from left to right, but since the point 0,0 on the grid in on the lower left hand corner of the grid, reversing each array would return the index values as if they were being looked for from right to left. For instance, l[:,0][::-1] would return:
['T' 'O' 'A' 'N' 'A' 'W' 'E' 'A']

After this, the function then indexes through that reversed array for the index value corresponding to p, which is your letter, and then adds that to the list being created. For instance, l[:,0][::-1][4], which corresponds to point (0,4), would return A.
This process keeps on repeating and adding new values to the list until  the range objects are exhausted.

After all that, the output, which is list w, is finally returned. In this case, that would be APPLE if called with print(''.join(r((0,4),(4,0),'''The Grid'''))) or ['A','P','P','L','E'] if it is called without ''.join(). Either way, it returns the correct answer, and we are done!


text:
Fluctuating ranges
Given a list with number, output the ranges like this:
Input: [0, 5, 0] would become [0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0].
This is mapping a range through the array, so we first have to create the range [0, 5], which is [0, 1, 2, 3, 4, 5]. After that, we use the 5 to create the range [5, 0]. Appended at our previous range, this gives us:
[0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0]

Let's observe a test case with two same digits next to each other:
[3, 5, 5, 3], ranges:

[3, 5] = 3, 4, 5
[5, 5] = 5 (actually [5, 5] due to overlapping)
[5, 3] = 5, 4, 3

So this would give us [3, 4, 5, 5, 4, 3].
Some other test cases:
[1, 9] > [1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, -10] > [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10]
[3, 0, 0, -3] > [3, 2, 1, 0, 0, -1, -2, -3]
[1, 3, 5, 7, 5, 3, 1, -1, -3] > [1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3]

Input will always have at least 2 integers.
Shortest answer wins!

Related. Related.

In what way are input and output related? What constitutes a valid input?

05AB1E, 1 byte
Ÿ

Try it online!
How it works
It's a built-in.

Do you have a dictionary of all built-ins in all esolangs in your head, or what? ;)

Well, thank you for using osabie :P

Why does it even have a built-in for this?

There should be a compilation of all 0byte and 1byte (maybe even 2byte) programs that do stuff.

@Neil It's basically an inclusive range function, it's really not that spectacular.

I challenge you with this question: https://codegolf.stackexchange.com/questions/240385/invent-new-programming-language-and-write-hello-world-in-it  :-)

Javascript, 99 95 93 bytes
4 6 bytes off thanks @Neil.
a=>a.reduce((x,y)=>x.concat(b.map?b=y:[...Array(yb+=yb)),b=[])

f=
a=>a.reduce(
    (x,y)=>
        x.concat(
            b.map?b=y
            :[...Array(yb+=yb)
        )
    ,b=[])

G.addEventListener('click',_=>O.innerHTML=f(JSON.parse(I.value)));
<input id=I value="[3,5,5,3]"><button id=G>Go</button>

Save 3 bytes by using yb||y-b&&-1.

@Neil. Good ones!! Thanks :)

Actually yb is better still.

JavaScript (SpiderMonkey 30+), 81 76 bytes
([n,...a])=>[n,...[for(i of a)for(j of Array(i<n?n-i:i-n||1))n+=i<n?-1:i>n]]

Tested in Firefox 44. Uses ES6's awesome argument destructuring capabilities and ES7's array comprehensions (which have sadly been removed from the ES7 spec).

Doesn't work on [3, 0, 0, -3]. I fixed the RangeError and saved 10 bytes but it still doesn't work: ([n,...a],z=[n])=>z.concat([for(i of a)for(j of[...Array((r=n[n].concat([for(i of a)for(j of[...Array((r=nl.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l

Test

f=l=>l.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l

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

;[[1,9],[10,-10],[3,0,0,-3],[1, 3, 5, 7, 5, 3, 1, -1, -3]]
.forEach(t=>console.log(t+' -> ' +f(t)))

Python 2, 77 bytes
lambda n:n[0:1]+sum([range(x,y,2*(y>x)-1)[1:]+[y]for(x,y)in zip(n,n[1:])],[])

Try it online
Thanks to Neil, DenkerAffe, and Erwan for pointing out improvements that I missed

Surely the +1 is unnecessary?

why not go with lambda n:n[0:1]+sum([range(x,y,[1,-1][y+1<x])[1:]+[y]for(x,y)in zip(n,n[1:])],[])? saves some bytes.

I was very tired while writing this :) Answer first, improve later.

i think you can replace [1,-1][y+1<x] by 2*(y>x)-1 (also i don't understand why you use y<=x and not simply y<x )

n[0:1] is equivalent to n[:1].

C, 120 + 12 = 132 bytes
i,j,k;f(a,n)int*a;{a[0]--;for(i=0;i<n-1;i++)for(k=0,j=a[i]-a[i+1]?a[i]:a[i]-1;j-a[i+1];)printf("%i ",j+=a[i+1]>j?1:-1);}

Example call:
f(a,sizeof(a)/4);        // I've added 12 bytes because of ",sizeof(a)/4"

Test live on ideone.

Perl, 47 bytes
Includes +3 for -p (code contains $' so space and - count too)
Give the list of numbers on STDIN:
fluctuating.pl <<< "3 5 5 3"

fluctuating.pl:
#!/usr/bin/perl -p
($n=$&+($'<=>$&))-$'&&s/\G/$n / while/\S+ /g

The temporary variable and all these parenthesis feel suboptimal...

It looks like you posted the wrong answer : it doesn't seem to be working and that $'  you mentioned isn't in the code...

@Dada: Yes, again pasted an old untested version of the code instead of the fixed one. Thanks and fixed

Haskell, 63 55 bytes
g(a:b:r)=[a|a==b]++[a..b-1]++[a,a-1..b+1]++g(b:r)
g x=x

Usage example: g [3,5,5,3] -> [3,4,5,5,4,3].
It's a modification of my answer  to a related challenge. Again, the main work is done by concatenating the list from a upwards to b-1 and from a downwards to b+1 (where one list will be empty) and a recursive call. To handle the a==b case where both lists are empty, we prepend [a|a==b] which evaluates to [a] if a==b and [] otherwise.

R, 86 82 75 bytes
function(x)rep((y<-rle(unlist(Map(seq,head(x,-1),x[-1]))))$v,pmax(1,y$l-1))

saved 4 bytes using rep not rep.int (code golf not performance!)
saved another 7 bytes by using built-in partial matching when using $ (and collapsing function definition to 1 line

I think (y=...) rather than (y<-...) is also valid, and one byte less.

Ruby, 116 82 bytes
->n{o,*m=n;o=[o];m.zip(n).map{|t,u|o+=[[u],[*u+1..t],[*t..u-1].reverse][t<=>u]};o}

My first ever golf.
Edit: Thanks manatwork for the awesome suggestions.

No need to assign to variable, anonymous proc is enough; no need to put parenthesis around formal parameter; taking out the array's first element is shorter with parallel assignment and splat; map's code block can take the array as multiple parameters: ->n{o,*m=n;o=[o];m.zip(n).map{|t,u|o+=u==t ?[u]:(u<t ?[*u+1..t]:[*t..u-1].reverse)};o}. Otherwise nice first golf.

Picking from a 3 element array by spaceship operator is shorter than 2 ternary operators: [[u],[*u+1..t],[*t..u-1].reverse][t<=>u].

Japt, 12 bytes
Saved 16 bytes thanks to @ETHproductions!
ä!õ ËsE©DÊ>1

Test it online

Perl 6, 94 bytes
I'm not super happy with this right now, I'll probably take another shot later
{reduce {|@^a[0..*-2],|@^b},map {@_[0]!= @_[1]??(@_[0]...@_[1])!!(@_[0],@_[1])},.rotor(2=>-1)}

PHP 5.4, 86 bytes
This is meant to be used as an included file, that returns the result.
The values are passed as commandline parameters.
<?for($i=1;$i<$argc-1;$R=array_merge($R?:[],range($argv[$i++],$argv[$i++])));return$R;

Not exactly pretty or anything, but does the job.

Python 3, 76 bytes
First attempt at a Python answer.
The basic idea is to repeatedly identify pairs in the sequence where the difference is larger than a step and insert one (and only one) additional element to complete the sequence in the right direction. Repeat until all differences between consecutive elements are between +1 and -1.
d=diff
while any(d(x)**2>1):i=argmax(d(x)**2);x[:i+1]+=[x[i]+sign(d(x)[i])]

Try it online!

Lua, 156 Bytes
A function that takes an array in parameter and return the extended array.
function f(t)r={}for i=2,#t
do x,y=t[i-1],t[i]r[#r+1]=x==y and x or nil
z=x>y and-1or 1
x=x==r[#r]and x+z or x
for j=x,y,z
do r[#r+1]=j end end
return r end

Ungolfed and explanations
function f(t)
  r={}                        -- Initialise an empty array
  for i=2,#t                  -- Iterate over the parameter array
  do
    x,y=t[i-1],t[i]           -- x and y are shorter names than t[i-1]
    r[#r+1]=                  -- when there's a range like [5,5]
      x==y and x or nil       -- put this number once in the array
    z=x>y and-1or 1         -- determine the step value
    x= x==r[#r]               -- prevent repeating the last value of r
          and x+z or x        -- by incrementing/decrementing x
    for j=x,y,z               -- iterate from t[i-1] to t[i] by step z (-1 or 1)
    do
      r[#r+1]=j               -- put j into the array r
    end
  end
  return r                    -- return the extended array
end

For ease of use, you can use the following function to print the array returned by f().
function printArray(t)
  print("["..table.concat(t,",").."]")
end

When testing this submission, you can call it like:
printArray(f( {0,5,0,3,4,4,7,3,-3} ))
> [0,1,2,3,4,5,4,3,2,1,0,1,2,3,4,4,5,6,7,6,5,4,3,2,1,0,-1,-2,-3]

Mathcad, 62 "bytes"

As Mathcad uses a 2D "whiteboard" and special operators (eg, summation operator, integral operator), and saves in an XML format, an actual worksheet may contain several hundred (or more) characters. For the purposes of Code Golf, I've taken a Mathcad "byte count" to be the number of characters or operators that the user must enter to create the worksheet.
Converting the function definition to a straight program, and replacing the variable lst with a single character name, gives a total of 62 "bytes".  With the function, using a single character rather than the full name, this increases to 65 "bytes" for the definition and a further 4 "bytes" for each call (assuming that creation of the list itself isn't included in the overall byte count (Using Mathcad's built-in tables is another way of inputting the list).

PHP, 144 bytes
function f($r){$m=[];for($i=0;++$i<count($r);){$d=array_pop($m);$n=$r[$i];$p=$r[$i-1];$m=array_merge($m,$p==$n?[$p,$n]:range($p,$n));}return$m;}

Exploded view
function f($r) {
  $m = [];
  for ($i=0; ++$i < count($r); ) {
    $d = array_pop($m);
    $n = $r[$i];
    $p = $r[$i-1];
    $m = array_merge($m, $p==$n ? [$p,$n]
                                : range($p,$n));
  }
  return $m;
}

Input / function call
f([ bound1, bound2, bound3, ... ]);

Output
[int, int, int, int, ...]

It's messy and chunky, and I'll try to optimize it later.  It creates a range() from each pair of adjacent value pairs, then stitches them together (after poping off the end of the previous cumulative Array).

Perl6, 21
.join is short for $_.join
say EVAL .join: "..."

Test (rakudo)
perl6 -MMONKEY-SEE-NO-EVAL -e'say EVAL @*ARGS.join: "..."' 1 3 5 7 5 3 1 -1 -3

Output
(1 2 3 4 5 6 7 6 5 4 3 2 1 0 -1 -2 -3)

Jelly, 10 bytes
,r⁼?2\Ṗ;¥/

Try it online!

R, 74 bytes
Another R solution
function(x){b=x[1];z=c();for(a in x[-1]){z=c(z,c(b:(a-sign(a-b))));b=a};z}

Try it online!

this doesn't quite work as the last value seems to be missing...


text:
Follow the dots
The Challenge
Given a rectangular grid of characters

A B C D E
F G H I J
K L M N O
P Q R S T

and a grid with the same dimensions of dots and spaces

. .     .
  .   . .
  .   .
  . . .

Output the string which is generated by following the dots through the grid starting in the upper left corner. This example would yield ABGLQRSNIJE
Notes

You may take the input grids as 2D-arrays or the closest alternative in your language instead of a multiline string.
You may use the NULL value of your language instead of spaces. But you have to use dots to mark the path.
You don't need to separate dots on the same line with spaces. I just added them for readability.
The smallest possible grid has the size 1x1.
The start and end dot will have only one neighbour. The dots between them will always have exact two vertical or horizontal neighbours. This guarantees that the path is unambiguously.
The path will not go diagonal.
The characters in the grid will be either all upper- or lowercase characters in the range [a-z] whatever is most convenient for you.
The path will always start in the upper left corner.

Rules

Function or full program allowed.
Default rules for input/output.
Standard loopholes apply.
This is code-golf, so lowest byte-count wins. Tiebreaker is earlier submission.

Test cases
Grid #1

A B C A B C W
D E F G H U Q
X L U S D Q Z
A S U K W X I
W U K O A I M
A I A I O U P

. .
  . . .
      .
. . . .
.
.
=> ABEFGSKUSAWA

. . . . . . .
            .
. . .       .
.   . .     .
.           .
. . . . . . .
=> ABCABCWQZIMPUOIAIAWAXLUUK

Grid #2
Note the triple spaces in the second lines of the first and second examples.

A B
C D

.

=> A

. .

=> AB

.
. .
=> ACD

Grid #3

A

.
=> A

Happy Coding!

Are you sure the second test case for Grid #1 is correct? I think the output should be ABCABCUQXIUOIAIAWAXLUUK.

@vaultah Thaks for the hint, corrected it. Had the dots in the grid one column to far on the left.

Do we need to accept input with every other character a space, as here, or can it be just letters and newlines (and no extra spaces in the dot matrix)?

@msh210 As said in the challenge, you may use some kind of NULL value instead of spaces, given of course you take the input as a 2D array.

I meant, with nothing at all, not even a null byte.

@msh210 You need some kind of seperator between the dots otherwise you can't follow the path that they are forming. Or do I understand you wrong? What specific input format do you have in mind?

The same as yours, but with the even-numbered bytes removed from each line.

@msh210 Ah, now I get it. Sure thats fine. I just added the extra spaces between the dots for readability.

APL, 63 bytes
{⍺[(⊂1 1){×≢⍵:⍺,(V/⍵)∇⍵/⍨~V←(+=⌊/)+/¨2*⍨⍺-⍵⋄⍺}1↓(,⍵='.')/,⍳⍴⍵]}

This is a function that takes two character matrices (they must be matrices), the character grid as its left argument and the dots grid as its right argument. The matrix of dots may be smaller than the matrix of characters.
Explanation:

(,⍵='.')/,⍳⍴⍵: get the positions of the dots, in row-column order
1↓: drop the first one (it is known to be at 1 1)
(⊂1 1){...}: starting from 1 1, run the following function, which follows the path (its left argument is its current position, its right argument are unvisited positions). It works by selecting the nearest unvisited dot each time. (If the assumptions from the question hold, this is correct.)

×≢⍵:: if there are still unvisited positions:

+/¨2*⍨⍺-⍵: find the Manhattan distance between each position and the current position
V←(+=⌊/): for each position, see if its distance is equal to the smallest distance, and store this in V.
⍵/⍨~: select all positions for which this is not the case, these are the fields to visit next
(V/⍵): find the position for which it is the case, this will be the next field
∇: run the function again with these new arguments
⍺,: the result is the current position, followed by the result of doing this for the rest of the list

⋄⍺: otherwise, just return the current position and stop (it's the last one)

⍺[...]: for each position, select the corresponding element in the character grid.

Test cases:
      f←{⍺[(⊂1 1){×≢⍵:⍺,(V/⍵)∇⍵/⍨~V←(+=⌊/)+/¨2*⍨⍺-⍵⋄⍺}1↓(,⍵='.')/,⍳⍴⍵]}
      ⍝ example
      g0  ← 4 5⍴'ABCDEFGHIJKLMNOPQRST'
      d0  ← 4 5⍴'..  . . .. . .  ... '
      ⍝ test case 1
      g1  ← 6 7⍴'ABCACBWDEFGHUQXLUSDQZASUKWXIWUKOAIMAIAIOUP'
      d1a ← 6 7⍴'..      ...      .   ....   .      .      '
      d1b ← 6 7⍴'.......      ....   .. ..  ..     ........'
      ⍝ test case 2
      g2  ← 2 2⍴'ABCD'
      d2a ← 1 1⍴'.'
      d2b ← 1 2⍴'..'
      d2c ← 2 2⍴'. ..'
      ⍝ test case 3
      g3  ← 1 1⍴'A'
      d3  ← 1 1⍴'.'

      g0 f d0
ABGLQRSNIJE
      (⊂g1) f¨ d1a d1b
┌────────────┬─────────────────────────┐
│ABEFGSKUSAWA│ABCACBWQZIMPUOIAIAWAXLUUK│
└────────────┴─────────────────────────┘
      (⊂g2) f¨ d2a d2b d2c
┌─┬──┬───┐
│A│AB│ACD│
└─┴──┴───┘
      g3 f d3
A

JavaScript (ES6), 122 bytes
c=>g=>c[l=~c.search`
`,i=p=0]+[...g].map(_=>i|!p?c[i=(d=n=>g[i-n-p?i-n:c]>" "&&(p=i)-n)(1)||d(-1)||d(l)||d(-l)]:"").join``

Explanation
Takes the grids as multiline strings.
Feels like a decent attempt but I ran out of time while golfing so it could probably be improved.

var solution =

c=>g=>
  c[                            // add the starting letter to the output
    l=~c.search`
`,                              // l = line length
    i=p=0                       // i = current index, p = previous index
  ]+
  [...g].map(_=>                // loop
    i|!p?                       // if we have not finished yet
      c[i=                      // find the next index and return it's letter
        (d=n=>                  // d = function to check for a dot at offset n
          g[
            i-n-p?i-n           // if i - n != p, get the character at index i - n
            :c                  // else get index "c" (will return undefined, not a dot)
          ]>" "                 // if the character is a dot
          &&(p=i)-n             // set p to i and return i - n
        )
        (1)||d(-1)||d(l)||d(-l) // search for the next adjacent dot
      ]
    :""                         // if we have finished, return no letter
  )
  .join``                       // output all the returned letters
<textarea id="Characters" rows="6" cols="30">ABCABCW
DEFGHUQ
XLUSDQZ
ASUKWXI
WUKOAIM
AIAIOUP</textarea>
<textarea id="Grid" rows="6" cols="30">.......
      .
...   .
. ..  .
.     .
.......</textarea>

<button onclick="result.textContent=solution(Characters.value)(Grid.value)">Go</button>

APL (Dyalog Classic), 43 bytes
{⍺[11 9∘○¨{⍵∪⍺∩∊⍵+⊂0j1*⍳4}⍣≡∘⊃⍨0j1⊥¨⍸⍵=⊃⍵]}

Try it online!


text:
Making a coin fair
You have a coin that produces 0 or 1. But you suspect the coin may be biased, meaning that the probability of 0 (or 1) is not necessarily 1/2.
A well known procedure to "transform" a biased coin into a fair coin (i.e. to obtain equally likely results), as proposed by von Neumann,  is as follows. Produce (non-overlapping) blocks of two coin tosses until the two values of a block differ; and output the first value in that block (the second value would also do, but for the purposes of this challenge we choose the first). Intuitively, 1 may be more likely than 0, but 01 and 10 will be equally likely.
For example, the input 1110... would discard the first block, then produce a 1 from the second block, ...
This procedure is expensive, because several coin tosses are consumed to generate a single result.
The challenge
Take a finite sequence of zeros and ones, representing tosses of the original coin, and produce the maximum number of results according to the above procedure, until all the input is consumed.
The last block may be incomplete, if the number of input values is odd. For example, the input sequence 11111 would produce no result (the first two blocks have equal values, and the third block is incomplete).
Rules
The input can have any non-negative number of values, not necessarily positive or even.
The input format may be:

an array of zeros and ones;
a string of zeros and ones with an optional separator.

Output format may be:

a string of zeros and ones, with or without separators;
an array of zeros and ones;
strings containing a single zero or one, separated by newlines;
any similar, reasonable format that suits your language.

Code golf. Fewest bytes wins.
Test cases
Input and output are here assumed to be strings.
Input         -->  Output

'1110'        -->  '1'
'11000110'    -->  '01'
'1100011'     -->  '0'
'00'          -->  ''
'1'           -->  ''
''            -->  ''
'1101001'     -->  '0'
'1011101010'  -->  '1111'

Shouldn't there be two possible outputs for each input (i.e. the bitwise not of the current output)?

@wizzwizz4 You can take one or the other, but not both (because then they wouldn't be statistically independent). In this challenge I arbitrarily chose the first

No, I mean in the question body you say we could take the first or second number, but your test-cases just take the first.

@wizzwizz4 I've edited to clarify: only the first. Thanks for the heads-up

You're too suspicious of the coin. Just flip the thing ;)

@IGoBest I'm not so sure :-D

@DonMuesli Man, the list of caveats in that paper is impressive :P

Jelly, 6 bytes
s2Q€Ṗ€

Try it online!
How it works
s2Q€Ṗ€  Main link. Argument: S (string)

s2      Split the string into pairs of characters.
  Q€    Deduplicate each pair.
        This removes the second character iff it is equal to the first.
    Ṗ€  Pop each; remove the last character of each pair/singleton.

Retina, 16 14 bytes
(.)\1|(.)?.
$2

Try it online!
Explanation
This is fairly simple. The code defines a single regex substitution replacing all (non-overlapping) matches of (.)\1|(.)?. with whatever the second group captured. This combines three different cases into one:
(.)\1 --> <empty>

If two repeated digits are equal, we remove them from the string (because group 2 is unused).
(.).  --> $2

Otherwise, if we can match two characters, remove the second one, by replacing both of them with the first. If that's not the case the ? will omit the group:
.     --> <empty>

This only happens if there is an unpaired trailing character, which is also removed.

This may be the shortest Retina answer I've seen :-)

@DonMuesli ummm...

Labyrinth, 21 12 bytes
"(. :
""*$,@

A rare example of a compact Labyrinth program that also has no no-ops. The | in the previous version was completely unnecessary, and removing it massively reduced the size of the program. In fact, Lab's beating Retina!
Try it online!
The bottom-left " can also be a space, but having it there greatly simplifies the explanation.
Explanation
This one's a little trickier, so it's accompanied by images. But first, a quick primer:

Labyrinth is a stack-based 2D language. Memory consists of a main stack and an auxiliary stack.
Labyrinth's stacks are bottomless and filled with zeroes, so performing operations on an empty stack is not an error.
At each junction, where there are two or more paths for the instruction pointer to go, the top of the main stack is checked to figure out where to go next. Negative is turn left, zero is straight ahead and positive is turn right. If a turn fails, the pointer tries to turn in the other direction.

Setup

The program starts at the top-left ", which is a no-op. Then we perform:
(        Decrement a bottom zero to -1. Since -1 is negative we try to turn
         left at this junction, fail, and turn right instead.
"        No-op junction, turn left
*        Multiply top of stack (-1) with a 0 at bottom of stack, giving 0.
         This makes us go straight ahead at this junction.
$        Bitwise xor (of 0 and 0)

This leaves the stack with a single 0 on it, which is as good as empty for the purposes of Labyrinth.
Reading input and termination

, reads a char from input, returning 48 or 49 for 0 or 1 respectively, and -1 on EOF. Since this is nonzero, either way we turn into the :, which duplicates the top of the stack.
The : is at a dead-end, so we turn around and execute , once more. Now if the last input was EOF, then we turn left and terminate with @, else we turn right, with the stack looking like [a a b] (where a, b are the two chars).
Interpreting the coin toss

If we didn't terminate, our next move is to execute $ (bitwise xor) again. This yields 0 if the input chars were the same, 1 otherwise. We then multiply a with this result, giving either 0 or a. Since the * is at a junction, this top stack value determines what happens next.
In the 0 case, we go straight ahead and execute three " no-ops, before perform a ( decrement. Like the setup, this makes us turn and execute "*$, leaving us ready to read more chars.

Otherwise, in the a case, we turn right at the junction since a is positive (48 or 49). . outputs the char, leaving the stack empty, and ( decrements the top of the stack, turning a 0 to -1. Once again, this makes us turn left, executing "*$ like in the setup, also leaving us ready to read more input.

...wow. Just, wow. Out of curiosity... what happens if you remove the leading quote from each line?

@ETHproductions The second column is no longer a junction, so the IP starts off executing ( then ., outputting char 255 (-1 modulo 256). So it's already wrong starting from there, unfortunately :P

CJam, 10 8 bytes
l2/{)-}%

Test it here.
Explanation
This is a very simple solution: in each pair, remove all instances of the last character. Repeated digits and unpaired trailing digits will be removed, as will be the second digit in any pair of unequal digits:
"0"  --> ""
"1"  --> ""
"00" --> ""
"01" --> "0"
"10" --> "1"
"11" --> ""

This leaves only the digits we're looking for. Here's how the code computes this:
l     e# Read input.
2/    e# Split into pairs. Odd inputs will yield a single-character string at the end.
{     e# Map this block over the pairs...
  )   e#   Pull the last character off the string.
  -   e#   Remove all occurrences of that character from the remainder (which is either
      e#   an empty string to begin with or a single-digit string).
}%

When the list is auto-printed at the end of the program, the empty strings are simply omitted.

You and @DonMuesli are the only people with any explanation in their answers other than the code itself.  Thanks.

Perl, 19 18 17 bytes
@Martin Büttner Retina solution inspired a 2 byte gain
Includes +1 for -p
Run with the input on STDIN, e.g. perl -p fair.pl <<< 11000110
fair.pl:
s/(.)\1|.?\K.//g

Not much to explain here since it is an (indirect) translation of the specification:

(.)\1 If the first 2 digits are the same, drop them
.\K.  Otherwise the first two digits are different. Keep (\K) the first one
.?\K. Except that the first . is optional. This allows for a single match at the end of the string which then gets discarded since the kept part is empty

Haskell, 71 44 29 bytes
p(a:b:r)=[a|a/=b]++p r
p _=[]

Extreme golfing by nimi.

Mathematica, 36  38  bytes
-2 after stealing @LegionMammal978's function for determining if a 2-element list is {0,1} or {1,0}
#&@@@Select[#~Partition~2,Tr@#==1&]&

Argument is expected to be a list of integers.

Oh no, three Mathematica answers on one question!

Hexagony, 23 21 bytes
,){,/;(_\/'%<\{)/>~$>

Unfolded:
    , ) { ,
   / ; ( _ \
  / ' % < \ {
 ) / > ~ $ > .
  . . . . . .
   . . . . .
    . . . .

This terminates with an error, but the error message goes to STDERR.
Try it online!
Judging by the number of mirrors it might be just about possible to fit it into side-length 3 but I've had no luck so far.
Explanation
Here's the usual diagram, generated with Timwi's HexagonyColorer:

The program uses only three memory edges, labelled A, B, and C here (diagram courtesy of Timwi's EsotericIDE):

Execution starts on blue path. The / are just mirrors that redirect the instruction pointer (IP), the actual code is:
,   Read character from STDIN into memory edge A.
)   Increment.
{   Move to memory edge B.
,   Read character from STDIN into memory edge B.
)   Increment.
'   Move to memory edge C.
%   Compute A mod B in memory edge C.

The , will set the edge to -1 instead of the character code if we've hit EOF. Since we're incrementing both inputs that doesn't change whether they are equal or not, but it turns EOF into 0.
We use modulo to check for equality, because it's either 1 or 49 (positive) for unequal characters and 0 for equal characters. It also serves as the end of the program, because when we have the 0 from EOF, the attempted division by zero will cause an error.
Now the < distinguishes zeroes from positive results. The simple one first: if the characters are equal, the IP takes the red path. _ is a mirror, \ is also a mirror but gets ignored, and > deflects the IP such that it wraps around the edges and starts from the top again. However, on this iteration, the roles of A, B and C are swapped cyclically (C now takes the role of A and so on).
If the characters are different, the green path is taken instead. This one's a bit messier. It first jumps over a no-op with $, then wraps around to the / on the left edge, then traverses the second-to-last row from right to left and finally re-enters the interesting part of the source code at the {. There's an essentially linear bit of code, that I'll explain in a second, before the $ makes the IP jump over the > to merge the two paths again.
Here is that linear piece of code:
{    Move to memory edge A.
(    Decrement to recover the actual character we read.
;    Print the character back to STDOUT.
'    Move to memory edge B.
~    Multiply the value there by -1, making it negative. This is
     necessary to ensure that the path correctly wraps back to the top.

Note that in this case, the roles of the edges for the next iteration are also swapped cyclically, but with B taking the role of A and so on.

><>, 11 bytes
i:i:0(?;-?o

><> is pretty well suited to read-a-char-at-a-time challenges like this :) Try it online!
i:            Read char and duplicate
i             Read char
:0(?;         Halt if last char was EOF
-             Subtract
?o            Output first char if the subtraction was non-zero (i.e. not equal)

This all happens in a loop since the instruction pointer wraps around once it reaches the end of a line.

-1 for a ><> program that contains no > or <

JavaScript (ES6), 33 bytes
s=>s.filter((c,i)=>++i%2&c!=s[i])

How it works
s=>s                // Take the input array.
.filter((c,i)=>   ) // Filter to only the chars that are both:
++i%2&              //  on an even index, and
c!=s[i]             //  not equal to the one after them.

You can save some bytes by requiring input to be an array. (Allowed by question.)

@MamaFunRoll Thanks for the tip!

Perl, 27 21 bytes
say grep$_-chop,/../g

Byte added for the -n flag.
                /../g  match groups of two chars
    grep       ,       select/filter on...
           chop        remove the last character, mutating the string
        $_-            is it different than the remaining char?
                         (subtract it, empty string is falsy)
say                    output if so

Test:
llama@llama:~$ perl -nE 'say grep$_-chop,/../g'
1110
1
11000110
01
1100011
0
00

1

1101001
0
1011101010
1111

Thanks to @TonHospel for 6 bytes!

You can gain some bytes by shortening the test: say grep$_-chop,/../g

@TonHospel Very nice, thanks!

Python, 42 bytes
f=lambda L:L[1:]and L[:L[0]^L[1]]+f(L[2:])

Fun with recursion and bitwise xor. Takes a list of 1s and 0s as input.

Prelude, 12 bytes
11(-(#!)?^?)

This assumes an interpreter that reads and prints characters. You can sort of try it online. But that interpreter prints integers, so for each 0 you'll get 48 and for each 1 you'll get 49 instead (and a linefeed).
Explanation
It's very rare that you can write a non-trivial program on a single line in Prelude (because Prelude needs more than one line to be Turing-complete).
11      Push two 1s. We need something non-zero on the stack to enter the loop, and by
        pushing the same value twice, we make sure that the loop doesn't print anything
        on the first iteration.
(       Main loop...
  -       Subtract the last two values. This will be zero for equal values, and non-zero
          otherwise...
  (       This "loop" is simply used as a conditional: if the last two values were
          were equal, skip the code inside...
    #       Discard the conditional.
    !       Print the value below.
  )       The loop is exited because the value below is always zero.
  ?       Read the first character of the next pair from STDIN.
  ^       Duplicate it, so the lower copy can be printed.
  ?       Read the second character of the pair. This returns 0 at EOF, which
          terminates the loop.
)

Befunge 93, 16 bytes
~:~:0`!#@_->#,_$

A one-liner for compactness. Tested using this online interpreter.
~:                     Read input char a and dup
  ~                    Read input char b (-1 on EOF)
   :0`!                Push 1 if b <= 0, 0 otherwise
       #@_             Halt if b <= 0 (i.e. EOF)
          -            Subtract to check whether a != b
           >#,_$       Output a if so

The last part makes use of the fact that popping from an empty Befunge-93 stack yields 0.
If a != b, we perform
>                      Move rightward
#                      Bridge: skip next
_                      Horizontal if - go right if 0, else left. But a != b, so we go left
,                      Output a
#                      Bridge: skip next
-                      Subtract (0 - 0 = 0)
_                      If: go right since 0 is popped
>#                     Go right and skip next
_                      If: go right since 0 is popped
$                      Pop top of stack, stack is now empty

Otherwise, if a == b, we perform:
>                      Move rightward
#                      Bridge: skip next
_                      If: go right since a == b (i.e. a-b is 0)
$                      Pop top of stack and discard, keeping stack empty

brainfuck, 33 bytes
,>,[<[->->+<<]>[[-]>.<]>[-]<<,>,]

Compared to Java, this is very compact, however, I'm afraid of brainfuck-golfer answerer. And feel free to mention if there's a bug. Assuming EOF is 0, input doesn't contain invalid input, the cell is initially zero, and the cell value range is finite and cyclic. No other assumption is present.
Explanation:
Memory Cell Map
+---------+---------+-----------------+
|1st input|2nd input|copy of 1st input|
+---------+---------+-----------------+

Instruction
,>,                               read two instruction at once | first to first cell |
                                  second to second cell
   [                              Until the input is EOF
    <                             look at first cell
     [->->+<<]                    move the first cell to additional cells while
                                  subtracting the second cell with this at same
                                  time
              >[                  if the second cell is nonzero (it means that first cell and
                                  the second cell is the same)
                [-]>.<            Print the copied first input
                      ]
                       >[-]       clear the first input to prevent it polluting next input
                           <<,>,  continue with next two input
                                ]

Very nice! I had been trying to write a BF answr myself. But I found it too BF-ing

Jelly, 4 bytes
ḟ2/ḟ

Try it online!
Full program, but the link still runs all test cases, since they still get the smash-print treatment.
 2/     Split the input into slices of length 2, then reduce each slice by
ḟ       remove elements of right from left.
        This produces a list of empty lists and singleton lists,
        except if the length of the input is odd the last element is entirely unaffected.
   ḟ    Remove elements of the input from that result.
        This removes the odd element if there is one, and nothing else,
        since it is necessarily an element of the input, and everything else is a list.

This should be the currently accepted answer, but if this answer uses language features introduced after the challenge I prefer to keep the other answer as accepted. Do you know if that's the case?

@LuisMendo I did some digging and it looks like Dennis added n-wise reduce to Jelly... 7 days after his answer. It should probably remain accepted

Thank you for taking the time to look into that!

MATL, 11 9 8 bytes
`-?6MD]T

Input and output are numbers separated by newlines. Ends with an error (allowed by default) when all inputs have been consumed.
Try it online!
`         % do...while loop
  -       %   take two inputs implicitly. Compute difference
  ?       %   if nonzero
    6M    %     push first of the two most recent inputs again
    D     %     display (and remove from stack)
  ]       %   end if
  T       %   true. Used as loop condition, so the loop is infinite
          % end loop implicitly

Old approach, 11 bytes
2YCd9L)Xz0<

Input is a string. Output is numbers separated by newlines.
Try it online!
2YC      % implicitly take input as a string. Generate 2D array of length-2
         % overlapping blocks as columns, padding with a zero if needed.
d        % difference of the two values in each column of that array
9L       % predefined literal [1 2 0]. This corresponds to "1:2:end" indexing
)        % keep only values at indices 1, 3, 5, ... This reduces the set of blocks
         % to non-overlapping, and discards the last (padded) block if the input had
         % odd length
Xz       % keep only nonzero entries, corresponding to blocks that had different values
0<       % 1 if negative, 0 if possitive. Implicitly display

Pyth, 10 9 bytes
jkPM{Mcz2

Algorithm shamelessly stolen from Dennis's Jelly answer.
       z    input
      c 2   chunks of 2
    {M      dedup each chunk
  PM        all-but-last element of each chunk
jk          join on empty string; can't use `s' because that gives `0' for []

Python 2, 48 bytes
lambda n:[s for s,t in zip(*[iter(n)]*2)if s!=t]

Try it online
Thanks to Dennis and vaultah for pointing out stuff that I missed

I think you could use the good old 'grouper' recipe: zip(*[iter(n)]*2)

Wouldn't a lambda work?

sed, 34 33 bytes
s/../& /g;s/00\|11//g;s/.\b\| //g

Test:
llama@llama:~$ sed 's/../& /g;s/00\|11//g;s/.\b\| //g'
1110
1
11000110
01
1100011
0
00

1

1101001
0
1011101010
1111

I tried using the fold(1) command to split into pairs. That also came out at 34! fold -s2|sed 's+01+0+p;s+10+1+p;d'

@joeytwiddle fold -s2 is equivalent to fold -2, making that 33 bytes... which is what I just golfed the pure sed solution down to, also. :P

I combined the second and third substitution to shave another 4 bytes: s/../& /g;s/00\|11\|.\b\| //g

Mathematica, 41 39 bytes
Select[#~Partition~2,Tr@#==1&][[1]]&

Less complicated and shorter than the other answer.
The box is a transpose character.

Labyrinth, 31 bytes
Not as short and neat as Sp3000's solution, but I thought I'd post this anyway as a different approach:
"" @
,, :{"
)  { $;
*"})";.
 ""

Explanation
The first loop is simply
""
,,

which reads in two characters at a time (the " are no-ops). After EOF, , will return -1, but only check for EOF at every second character. That means in any case the top of the stack will then be -1 and the value below is either -1 or some character code that we don't care about, because it's an unpaired coin toss.
Then )* turns the -1 and the value below into a single 0 which we need a) to get rid of those two values and b) to enter the next loop correctly. That next loop is simply
"}
""

Which shifts all the values over to the auxiliary stack. This is necessary because we want to start processing the pairs that we read first. Now the final loop:
:{"
{ $;
)";.

The ) just increments some dummy value to ensure that it's positive and the instruction pointer turns north. { pulls over the first digit of the next pair and : duplicates it. Now when we're done processing, this will have been a 0 from the bottom of the auxiliary stack. Otherwise it's either 48 or 49. In case of a zero, we exit the loop and terminate on @, otherwise, the IP turns east.
{ pulls over the other digit of the current pair. $ takes the XOR between them. If that is 0, i.e. the two are equal, the IP just continues moving south, ; discards the zero, and the IP turns west into the next iteration. If the XOR was 1, i.e. they were different, the IP turns west, discards the 1 with ; and prints the first digit with ..

JavaScript (ES6), 33 bytes
s=>s.replace(/(.)\1|(.)?./g,"$2")

Boring port of the Retina answer.

str, 11 bytes
gd0H=N~e>*x

Try it online!
Alternative 11 byte solution: dgdb=Nue>*x
If we didn't have to handle the edge case of an unpaired toss (i.e., the input was always even), then the solution would be 5 bytes: dg=Nx.
Explanation
str iterates implicitly over each character of the input. However, since it does not consume all the input at once, we can iterate over pairs of characters by manually taking the second character as input with g. Let c1 be the first character and c2 be the second.
gd0H=N~e>*x      stack: [c1]
g                stack: [c1, c2]
 d               stack: [c1, c2, c2] - duplicate
  0H             stack: [c1, c2, c2, c1] - get the first member of the stack
    =            stack: [c1, c2, (c2==c1)] - equality
     N           stack: [c1, c2, (c2!=c1)] - negate (inequality)
      ~          stack: [c1, (c2!=c1), c2] - swap top 2
       e         stack: [c1, (c2!=c1), c2, ``] - push empty string
        >        stack: [c1, (c2!=c1), c2>``] - test for end of input
         *       stack: [c1, Q] - Q is, if the two characters don't match
                                  AND we didn't read past the input
          x      stack: [c1 x Q] - c1 repeated once if Q, zero times if not

Hey, @Conor, it's been long!

Hey @LuisMendo :D it's certainly been a while. life's busy with college and all y'know :)

Mathematica, 41 bytes
Cases[#~Partition~2,a_/;Tr@a==1:>a[[1]]]&

Anonymous function that inputs and outputs lists of zeros and ones.

Wait, you can use Tr to sum a vector? Must go edit a bunch of answers...

#&@@a is 1 byte shorter than a[[1]].

@CatsAreFluffy I was thinking of that, but it breaks with RuleDelayed.

Doesn't work with my answer either because of Transpose :(

Pyth, 10 bytes
hMf!qFTcz2

Test suite

You can replace !q by n and then the filter fnFT by nF#. (hMnF#cz2; this was the thing I thought of when I saw the challenge, but yours is close enough for me to not post it separately)

@Pietu1998 I tried that. It fails on e.g. 1

C, 66 bytes
main(char*p,char**x){for(p=x[1];*p&p[1];p+=2)write(1,p,*p^p[1]);}

Assuming sizeof(int) == sizeof(char *)
"clever" solution - 84 81 bytes
main(int c,short**x){while(!((c=*x[1]++-12336)&~511))c>>8^c&1&&putchar(48|c&1);}

Works on little-endian machine assuming short is 2 bytes. Input is passed as argument. The program iterates over pairs of characters and prints 0 for 0x3130 and 1 for 0x3031. On big-endian the result will be reversed (replace 48|c&1 with 49^c&1 to fix this).

DOS/Windows Batch, 201 162 bytes
@echo off
set/pi=
:a
for /f "tokens=2" %%a in ("%i%") do goto l
exit/b
:l
for /f "tokens=1,2" %%a in ("%i:~0,4%") do if %%a neq %%b echo %%a
set "i=%i:~4%"
goto a

Input is a space seperated string, for example 1 0 0 1 1.
Start from cmd, otherwise the screen exits immediately

C, 57 bytes
f(char*p,char*r){for(;*p*p[1];)*r=*p++,r+=*r!=*p++;*r=0;}

We tentatively copy a character from input p to result r, but only advance the r pointer if it differs from the next character.  If not, then we'll overwrite it at the next unmatched pair, or with NUL at the end.
Test program:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv) {
    while (*++argv) {
        char *result = malloc(1+strlen(*argv));
        f(*argv, result);
        printf("%s => %s\n", *argv, result);
        free(result);
    }
    return EXIT_SUCCESS;
}

Test output:
$ ./74864 1110 11000110 1100011 00 1 "" 1101001 1011101010
1110 => 1
11000110 => 01
1100011 => 0
00 =>
1 =>
 =>
1101001 => 0
1011101010 => 1111

Befunge-93, 40 bytes
v  ,-1<
      | -<
>~1+:~1+:|
^     <  @

You can try it here. Paste code in the space under the "show" button, press "show", define input, press "run". Our use the "step" button to see how the program works.

My first Befunge answer!

Ruby, 46 bytes
This separates l[0], l[1] and l[2..{end}] as a, b and c. Then it creates a string with a if a!=b or '' otherwise and f[c] if c[0] exists or '' otherwise.
f=->l{a,b,*c=l;"#{a!=b ?a:''}#{c[0]?f[c]:''}"}

Ungolfed:
def f(l)
  a = l[0]
  b = l[1]
  c = l[2..l.length]
  s = ''
  if a!=b
    s += a.to_s
  end
  if c[0]       # equivalent to !c.empty?
    s += f[c]   # no .to_s because the output will be a string
  end
  puts s
end

beeswax, 45 35 bytes
I could golf it down by 10 bytes—not too bad.
pgy~1z;L?gAF1<<?V_
>&?@yg&?~@ KQd{b

I took the reading a full string of coin tosses approach, which makes the program pretty large. Just reading single integers one by one would make the program smaller—maybe around 22 bytes or so—but also very inconvenient to use.
Examples:
julia> beeswax("FairCoin.bswx")
s1110
1
Program finished!

julia> beeswax("FairCoin.bswx")
s11000110
01
Program finished!

julia> beeswax("FairCoin.bswx")
s1100011
0
Program finished!

julia> beeswax("FairCoin.bswx")
s00

Program finished!

julia> beeswax("FairCoin.bswx")
s10101001010111111100000010011001110100010110101110100001011
1110001010000111100
Program finished!

My beeswax GitHub repository.
My beeswax examples on Rosetta Code.

Thunno 2, 4 bytes
²ıUṫ

Try it online!
Port of Dennis's Jelly answer.
Explanation
²ıUṫ  # Implicit input
²     # Split into pairs
 ı    # Map over this list:
  U   #  Uniquify the pair
   ṫ  #  Remove the last character
      # Implicit output

Java 117 bytes
(or 10 if we consider numerical system with base 117)
String z(char[]s){String r="";for(int i=0,x=-1;++x<s.length/2;i+=2)r+=(s[i]==s[i+1]?"":s[i]=='0'?"0":"1");return r;}

GNU sed, 19 bytes
#!/bin/sed -rf
s/11|00|(.?)./\1/g

Simple and boring translation of Martin Büttner♦'s Retina solution.  Except that I used 11|00 in place of .(\1) (for the same score).  18 bytes of code, plus one for the -r.

C#, 83 bytes
int[]M(int[]x)=>x.Select((v,i)=>i%2>0&&x[i-1]!=v?x[i-1]:2).Where(v=>v<2).ToArray();

First, replace odd-numbered items which are not equal to their predecessors with the predecessor, while setting all the rest to 2, then drop all items equal to 2.

Ruby, 66 bytes
initial attempt; likely room for improvement. Run with "ruby -n" and then enter input followed by enter key.

$_.chomp!;i,s=0,'';(s<<$_[i] if $_[i]!=$_[i+1];i+=2)until !$_[i+1];p s

Python, 72 bytes
This definitely won't be the shortest, but hopefully it'll at least give someone a headache.
lambda s:hex(int('110'+s[::-1],4))[:3:-1].translate({48:'',53:'',52:48})