text:
Crafting Canonically Cöcher Crosswords
The Setup
Most of us are familiar with crossword numbering, which follows three basic rules:

in a character grid consisting of blacks and whites (see below), any maximal contiguous horizontal or vertical chain of whites with length ≥ 2 is considered a word
any white at the leftmost end of a horizontal word and/or at the topmost end of a vertical word is called a "starter"
starters are assigned numbers (sequential integers starting with 1) scanning through the grid in standard English reading order (starting at the top left of the grid, scanning right-fast, down-slow to the bottom right of the grid)

A "crossword" generally refers to any n-by-n square grid of blacks and whites, with n ≥ 2, containing at least one black and at least one word, and containing no whites that do not belong to at least one word.
Some additional properties that a crossword may or may not possess:

a crossword is called singly connected if every white in the grid can be connected to every other white in the grid by moving north, east, south, and west (not diagonally) along a path consisting entirely of whites
a crossword is called proper if every white belongs to exactly two words (one horizontal, one vertical)
a crossword is called symmetric if for all x = 1..n, y = 1..n, the grid cell at (x,y) is a white if and only if the grid cell at (n+1-x,n+1-y) is a white, given 1-based indexing

Most run-of-the-mill cryptic crosswords are singly-connected and symmetric, but not proper. Many newspaper crosswords are proper, singly-connected, and symmetric.
The figure below also shows a proper, singly-connected, symmetric crossword.
                 Crossword
       w/o #s              w/ #s (mod 10)
  ##################    12##################
    #   ######  ####    3 45#678######90####
        #       ####    1   2   #34567  ####
      ###     ######    8     ###9    ######
##       ####   ####    ##0   123####456####
#   #    ##       ##    #7  #8   ##90   12##
   ##    ##  #          3  ##4   ##5 #6   78
  ####   #####          9 ####0  #####1
#   ##     ####   ##    #234##5  67####8  ##
#      #   ##    ###    #9  01 #2  ##34  ###
###    ##   #      #    ###5   ##6 7#8   90#
##   ####     ##   #    ##1  ####2  3 ##4  #
      #####   ####      56   7#####8  ####90
      #  ##    ##       1     #23##4  5##6
##       ##    #   #    ##7   8  ##9   #0  #
####   ####       ##    ####1  ####2   3  ##
######     ###          ######45678###9   01
####       #            ####23     #45
####  ######   #        ####6 ######7  #8
##################      ##################9

The Problem
...other than finding a crossword puzzle challenge that hasn't already been done. :P
Recall the crossword numbering challenge from days of yore, which accepts a crossword as input and produces clue numbering as output. Here we consider its younger (and significantly harder) cousin by reversing input and output:
Given a series of across/down clue numbers, generate a crossword puzzle whose numbering (per the canonical rules) yields these clue numbers.
For example, consider the clue numbers as input:
Across 3,5,6,7,8,9    Down 1,2,3,4,5,A
Two crosswords with compliant numbering are:
          A                           B
         6x6                         7x7
 w/o #s       w/ #s          w/o #s        w/ #s
 ______       ______        _______       _______
|## # #|     |##1#2#|      |#######|     |#######|
|#     |     |#3   4|      |# ## ##|     |#1##2##|
|  ##  |     |5 ##6 |      |# #  # |     |# #3 #4|
|  ##  |     |7 ##8 |      |  #  # |     |5 #6 # |
|     #|     |9  A #|      | #  #  |     | #7 #8 |
|# # ##|     |# # ##|      |  ## ##|     |9 ##A##|
 ¯¯¯¯¯¯       ¯¯¯¯¯¯       |#### ##|     |#### ##|
                            ¯¯¯¯¯¯¯       ¯¯¯¯¯¯¯

Solution A is singly-connected and symmetric, while B is neither. Solution A is also notably more compact, having only 14 blacks, while solution B has 29 blacks.
Note that you do not need to worry about what letters could/would go into any whites. This challenge is purely geometric in nature.
There are of course many trivial ways of generating compliant crosswords, which takes us to the interesting matter of...
Scoring
This 600-textline file contains 300 sets of across/down clue numbers for crosswords in the format

[across clue numbers for set 1, separated by spaces]
[down   clue numbers for set 1, separated by spaces]
[across clue numbers for set 2, separated by spaces]
[down   clue numbers for set 2, separated by spaces]
...
[across clue numbers for set 300, separated by spaces]
[down   clue numbers for set 300, separated by spaces]

Your objective is to write a program that generates a valid crossword for each set of across/down clue numbers and computes the resulting number of blacks.
The program should produce all 300 crosswords in 30 minutes or less running on a modern computer.
By setting a constant in the program or passing a command line argument, the program should be able to output the crossword grid (solution) for the kth input set given k ∈ 1..300, and you should display representative output (the black/white grid) for at least k = 1 and k = 300 along with your answer. The output can be text- or graphics-based, with or without clue numbers shown (preferably with, mod 36 for text-based graphics), and with any embellishments you desire. (This is simply for validation and showmanship.)
The output should also indicate whether the crossword is proper, singly-connected, and/or symmetric.
Your program's score is the sum total number of blacks over all 300 solutions. The program that produces the lowest total number of blacks is the winner.
per-crossword Bonuses
For any of the 300 crosswords (solutions) generated by your program:

if a crossword is proper, multiply its black count by 0.6
if a crossword is singly connected, multiply its black count by 0.85
if a crossword is symmetric, multiply its black count by 0.75
if any two of the above conditions apply for a crossword, multiply its black count by 0.4
if all three of the above conditions apply for a crossword, multiply its black count by 0.25

You may only claim one bonus per crossword.
The score for each crossword should be rounded up to the nearest integer.
Note that all of the input sets in the problem correspond to randomly-generated small(ish) singly-connected, proper, symmetric crosswords, hence I guarantee the existence of at least one such a solution.
Feel free to raise any questions or concerns in the comments section.
Happy crosswording. :)

Note that this is more culturally specific than you believe. Certainly in Spain the numbering system is completely different, and although in the UK the numbering system is the same as the one you describe I strongly doubt that the assertion "Most newspaper crosswords are proper" holds.

@PeterTaylor: Spec updated. ;)

If it's singly connected and symmetric, the score is 0.4x. If it's also proper, it should be multiplied by 0.6, but that yields 0.24x which is better than the score for all three conditions. Is this intentional?

@Ypnypn: The bonuses don't stack. Basically, claim the single best bonus that applies out of the five options listed. I've clarified this in the spec.

Python, total score 127,634(!)
This was a good excercise in humility. The score claimed above is using a fairly naive construction algorithm. I also tried implementing a slightly optimized brute force search, but while this managed to solve a few of the smaller crosswords in the 1-100 range (13x13 or less) it struggled with most and had no chance with the larger ones.
Crossword class
Nothing fancy here...
import itertools
import math
import copy
import sys

def read_crosswords(filename):
  crosswords = []
  with open(filename, 'r') as f:
    for across, down in zip(f, f):
      alist = list(map(int, across.rstrip().split()))
      dlist = list(map(int, down.rstrip().split()))
      crosswords.append(XWord(alist, dlist))
  return crosswords

def solve_crosswords(filename, solver, display=()):
  crosswords = read_crosswords(filename)
  total_score = 0
  for x, i in zip(crosswords, itertools.count(1)):
    print("Crossword {0}... ".format(i), end="")
    sys.stdout.flush()
    assert(solver(x))
    score = x.score(); details = ["score = {0}".format(score)]
    if x.is_symmetric(): details.append("symmetric")
    if x.is_proper(): details.append("proper")
    if x.is_connected(): details.append("connected")
    print("done! ({0})".format(", ".join(details)))
    if i in display: x.print_grid()
    total_score += score
  print("Total score: {0}".format(total_score))
  return crosswords

def flood_fill(grid, x, y, colorA, colorB):
  if grid[x][y] != colorA: return
  grid[x][y] = colorB
  flood_fill(grid, x-1, y, colorA, colorB)
  flood_fill(grid, x+1, y, colorA, colorB)
  flood_fill(grid, x, y-1, colorA, colorB)
  flood_fill(grid, x, y+1, colorA, colorB)

class XWord:

  B,W,U = range(3)

  def __init__(self, across, down):
    self.grid = []                                 # grid (2D array with black border)
    self.n = 0                                     # grid size (excluding border)
    self.num_clues = max(across + down)            # number of clues
    self.across = [(i+1) in across for i in range(self.num_clues)] # acrossness bool array
    self.down = [(i+1) in down for i in range(self.num_clues)]     # downness bool array

  def print_grid(self, numbers=True):
    """Print the grid."""
    i = 1
    for y in range(1,self.n+1):
      for x in range(1,self.n+1):
        if self.grid[x][y] == XWord.B: print("#",end="")
        elif self.grid[x][y] == XWord.W:
          across = (self.grid[x-1][y] == XWord.B) and (self.grid[x+1][y] == XWord.W)
          down = (self.grid[x][y-1] == XWord.B) and (self.grid[x][y+1] == XWord.W)
          if numbers and (across or down):
            print("{0}".format(i % 10), end="")
            i += 1
          else: print(" ", end="")
        else: print("?", end="")
      print()

  def is_symmetric(self):
    """Whether the grid is symmetric."""
    for y in range(1,self.n+1):
      for x in range(1,self.n+1):
        if self.grid[self.n+1-x][self.n+1-y] != self.grid[x][y]:
          return False
    return True

  def is_proper(self):
    """Whether the grid is proper."""
    for y in range(1,self.n+1):
      for x in range(1,self.n+1):
        if self.grid[x][y] == XWord.W:
          if not ((self.grid[x-1][y] == XWord.W or self.grid[x-1][y] == XWord.W) or
                  (self.grid[x][y-1] == XWord.W or self.grid[x][y+1] == XWord.W)):
            return False
    return True

  def is_connected(self):
    """Whether the grid is connected."""
    grid = copy.deepcopy(self.grid); filled = False
    for y in range(1,self.n+1):
      for x in range(1,self.n+1):
        if grid[x][y] == XWord.W:
          if not filled:
            flood_fill(grid, x, y, XWord.W, XWord.B)
            filled = True
          else:
            return False
    return True

  def score(self):
    """The grid score."""
    blacks = 0
    for y in range(1,self.n+1):
      for x in range(1,self.n+1):
        if self.grid[x][y] == XWord.U:
          raise Exception("Incomplete grid!")
        elif self.grid[x][y] == XWord.B:
          blacks += 1

    symmetric = self.is_symmetric()
    proper = self.is_proper()
    connected = self.is_connected()

    if (symmetric and proper and connected): multiplier = 0.25
    elif (symmetric and (proper or connected) or proper and connected): multiplier = 0.4
    elif proper: multiplier = 0.6
    elif symmetric: multiplier = 0.75
    elif connected: multiplier = 0.85
    else: multiplier = 1.0

    return int(math.ceil(float(blacks) * multiplier))

Naive solver
This generates a height two sequence, splits it into sections and wraps it round to fill the smallest possible square. Across clues are extended as far as possible to minimize blacks, but other than that there's not much cleverness. The solutions are never connected or proper and in practice never symmetric.
class XWord:

  def simple_solver(self):
    """Naive solver. Converts to a height 2 sequence and wraps round."""

    # generate a string sequence that we'll expand later
    # a=start across, b=start both, c=continue across, d=start down, _=optional space,  =space
    seq = []
    for a,d in zip(self.across, self.down):
      if a:
        if len(seq) > 0:
          if seq[-1] in "ab": seq.append("c")
          seq.append(" ")
        seq.append("a" if not d else "b")
      else:
        if len(seq) > 0:
          if seq[-1] in "bd": seq.append("_")
        seq.append("d")
    if len(seq) > 0 and seq[-1] in "ab": seq.append("c")

    # fit sequence into a square with grid size 3n-1 for minimal n
    n = 0; rows = seq
    while len(rows) > n:
      n += 1; x = 0; rows = []
      while x < len(seq):
        if seq[x] in "_ ": x+=1
        y = min(x+3*n-1,len(seq))
        if seq[y-1] in "ab": y-= 1
        rows.append("".join(seq[x:y]).rstrip(" _"))
        x = y

    # generate grid
    self.n = 3*n-1
    self.grid = [[XWord.B for i in range(self.n+2)] for j in range(self.n+2)]
    y = 1
    for row in rows:
      x = 1; across = False
      for s in row:
        if s in "abcd" or across and s in "_": self.grid[x][y] = XWord.W
        if s in "bd": self.grid[x][y+1] = XWord.W
        if s in "ab": across = True
        x += 1
      for x in range(x,self.n+1):
        if across: self.grid[x][y] = XWord.W
      y += 3
    return True

This runs almost instantaneously and generates an amusingly high score.
>>> solve_crosswords('crossword.txt', XWord.simple_solver,[1,300])
Crossword 1... done! (score = 121)

1 2#3 4#5 6 7
 # # # # # # #
##############
8#9#01#2 #3
 # ## #### ###
##############
4 #56#7 #8 9 0
#### #### # #
##############
1#2#3 #4 #56
 # ######## ##
##############
7 8 9#0 #1 #2
 # # #########

Crossword 2... done! (score = 192)
Crossword 3... done! (score = 203)
...
Crossword 299... done! (score = 666)
Crossword 300... done! (score = 645)

1 2#3 4 5 6#7 8#90 1 2 3#45 6 7
 # # # # # # # ## # # # ## # # #
################################
8 9#0 1 2#34#5 #6 #7 #8 9#0 #1
 # # # # ## ########## # #### ##
################################
2 #34#56#7 #89 0 1#23#45#6 #7
#### ## ##### # # ## ## # ######
################################
89#0 #1 2#34#5 #6 #7 #8 9#0 #1 2
# #### # ## ########## # #### #
################################
3#4#56 7 8 9 0 1 2 3 4#56 7 8#9
 # ## # # # # # # # # ## # # ###
################################
0 #1 #2 #3 #4 #5 6#7 #8 9#0 1 2
############### # #### # # # # #
################################
3 4#5 6#78#90 1 2#3 #4 #5 #6 #7
 # # # ## ## # # ############# #
################################
8 9#0 1 2 3 4#5 #6 #78#9 0 1 2
 # # # # # # ######## # # # # ##
################################
3 #45#67#89#0 #12#34 5#6 #7 #8
 ### ## ## ##### ## # ##########
################################
9 #01 2 3 4#5 6#7 #8 #9 #0 #1 2
#### # # # # # #### ######## # #
################################
34 5#6 #7 #8
# # ############################

Total score: 127634

Slow solver
The brute force solver traverses the grid square by square and decides at each point whether to start new clues, continue existing clues or block clues. Before continuing, it confirms that this choice is compatible with the current view of the grid. There are a number of other optimizations applied whenever we know that the grid is symmetricm, proper or connected.

Symmetric: we apply all updates symmetrically and check halfway that half of the across clues and at least half of the overall clues have been processed.
Proper: we check for properness whenver we update the grid.
Connected: we disallow a completely black row.

Note that there's even a bit of overoptimisation: we currently disallow proper crosswords that begin with a black row, though strictly these are allowed (though I'm not sure they should be). Also, we allow the user to specify the maximum number of black squares to look for to speed up the search.
class XWord:

  def slow_solver(self, n, symmetric=False, proper=False, connected=False, max_blacks=None):
    """Brute force solver with some optimizations. Too slow for much more than 10x10."""

    def _slow_solve(x, y, alist, dlist, updates, all_black_row, max_blacks):
      found = True

      # Early exits
      if connected and x == 1:
        if all_black_row: return False
        else: all_black_row = True
      if symmetric and x == 1:
        if y == self.n // 2 + 1:
          self.across_halfway = self.across.count(True) - alist.count(True)
          if alist.count(True) < self.across_halfway: return False
        if y == (self.n + 1) // 2 + 1:
          if 2 * len(alist) > self.num_clues: return False
          if alist.count(True) != self.across_halfway: return False

      # Apply updates and detect more inconsistencies
      undo = []
      for (i,j,C) in updates:
        # update square
        if self.grid[i][j] == C:
          pass
        elif self.grid[i][j] == XWord.U:
          self.grid[i][j] = C
          if C == XWord.B: max_blacks -= 1
          undo.append((i,j))
        else:
          found = False # inconsistent
          break
        if proper and C == XWord.W:
          if self.grid[i-1][j] == XWord.B and self.grid[i+1][j] == XWord.B or \
             self.grid[i][j-1] == XWord.B and self.grid[i][j+1] == XWord.B:
             found = False
             break
        elif C == XWord.W:
          if self.grid[i-1][j] == XWord.B and self.grid[i+1][j] == XWord.B and \
             self.grid[i][j-1] == XWord.B and self.grid[i][j+1] == XWord.B:
             found = False # lone black square
             break
        # update mirror image
        if symmetric and (i != self.n+1-i or j != self.n+1-j):
          if self.grid[self.n+1-i][self.n+1-j] == C:
            pass
          elif self.grid[self.n+1-i][self.n+1-j] == XWord.U:
            self.grid[self.n+1-i][self.n+1-j] = C
            if C == XWord.B: max_blacks -= 1
            undo.append((self.n+1-i,self.n+1-j))
          else:
            found = False
            break

      # Are we finished?
      if found:
        if y > self.n and len(alist) == 0: return True
        elif y > self.n or max_blacks < 0: found = False

      # Select next square type and recurse
      if found:
        nextx = x + 1; nexty = y
        if nextx > self.n: nextx = 1; nexty += 1
        found = len(alist) > 0 and _slow_solve(nextx, nexty, alist[1:], dlist[1:], self._start_clue_updates(x, y, alist[0], dlist[0]), False, max_blacks)
        found |= _slow_solve(nextx, nexty, alist, dlist, self._continue_clue_updates(x, y), False, max_blacks)
        found |= _slow_solve(nextx, nexty, alist, dlist, self._block_clue_updates(x, y), all_black_row, max_blacks)

      # Undo updates on error
      if not found:
        for (i,j) in undo:
          self.grid[i][j] = XWord.U

      return found

    # in future, this should try a few values of n until we get one that works.
    self.n = n
    self.grid = [[XWord.U if (0<i<self.n+1) and (0<j<self.n+1) else XWord.B for j in range(self.n+2)] for i in range(self.n+2)]
    if max_blacks is None:
      max_blacks = self.n * self.n - 2 * max(self.across.count(True), self.down.count(True))
    found = _slow_solve(1, 1, self.across, self.down, [], False, max_blacks)
    return found

  def _start_clue_updates(self, x, y, across, down):
    updates=[(x, y, XWord.W)]
    if across:
      updates.insert(0,(x-1, y, XWord.B))
      updates.append((x+1, y, XWord.W))
    elif self.grid[x-1][y] == XWord.B:
      updates.insert(0,(x+1, y, XWord.B))
    if down:
      updates.insert(0,(x, y-1, XWord.B))
      updates.append((x, y+1, XWord.W))
    elif self.grid[x][y-1] == XWord.B:
      updates.insert(0,(x, y+1, XWord.B))
    return updates

  def _continue_clue_updates(self, x, y):
    updates=[(x, y, XWord.W)]
    if self.grid[x-1][y] == XWord.B:
      updates.insert(0,(x+1, y, XWord.B))
      updates.append((x, y-1, XWord.W))
    elif self.grid[x][y-1] == XWord.B:
      updates.insert(0,(x, y+1, XWord.B))
      updates.append((x-1, y, XWord.W))
    return updates

  def _block_clue_updates(self, x, y):
    updates=[(x, y, XWord.B)]
    return updates

Unfortunately this is too slow to solve all but a few of the smaller crosswords in the puzzle file.
>>> xs = read_crosswords('crossword.txt')
>>> xs[0].slow_solver(13,True,True,True)
True
>>> xs[0].print_grid()
#12##########
3  4#56789###
0   1     ###
##2      ####
#3    #4 ####
#5    6  ####
#####7  #####
####8   9012#
####3 #4    #
####5 6    ##
###7       89
###0    #1
##########2 #
>>> xs[0].score()
18

source: Stack Exchange

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

sort: votes


text:
Determine the Base where a Given Equation is True
Given 3 integers, determine the lowest possible base for the first two integers to multiply into the third. If you think of the Answer to the Ultimate Question of Life, The Universe, and Everything, 6 * 9 == 42, is true in Base 13.
The inputs can include any numbers whose digits use the characters 0-9, a-z, and A-Z, where a equals 10 in Base 10, and Z is 61 in Base 10.
The inputs should be inputted in any way you like (except for hard-coding), and you can write either an individual function or an entire program.
The maximum base that must be considered is Base 62, and the minimum base is Base 2.
You can assume that the first two values are smaller than the third. You can also conclude that the minimum base is one greater than the highest digit/character from the inputs (for example, if the inputs are 3 1a 55, the minimum base would be Base 11, because a is the highest digit).
If there is no such base, return a junk value of your choice.
This is code golf, so the shortest code wins.
Test Cases
6 9 42     -->   13
a a 64     -->   16
aA bB 36jk -->   41
2 3 20     -->   <junk value>
10 10 100  -->   2

I think STDIN would probably be better, and either would be fine.

@MartinBüttner So should I just allow input in either form?

@MartinBüttner - Let the OP add examples.

As a point of clarification what should be done if multiple bases are valid such as your last example (which has now been removed - it was 10*10=100) where it is also valid in base 10 and indeed any other base you care to mention...

There is no such thing as base 1.

@Kay If I define the positional system in base b in a general way like a_0 b^0 + a_1 b^1 + a_2 b^2 + ... (where a_0 is the least significant digit) than base 1 definitely makes sense. Furthermore, the OP's conclusion would also include base 1 in the search if the largest present digit is 0.

About base 1, unary is a number system. http://en.m.wikipedia.org/wiki/Unary_numeral_system

I made an edit so that you should return the lowest possible base.

Changed the rules to stay at base 2.

@MartinBüttner Correct. Junk value should be a number that is not in the range of 2-62 inclusive.

Going up to base 62 AND requiring error cases really puts a wrench in the system.

CJam, 52 51 48 bytes
63,{_ea{i32b~\([G-35-9]=-_Xe>:X;}f%fbW%~*=\X>*}#

Test it here. The online tester doesn't support input via ARGV. The closest alternative is to put put the input like 6 9 42 into STDIN and use:
lS/:E;
63,{_E{i32b~\([G-35-9]=-_Xe>:X;}f%fbW%~*=\X>*}#

This prints -1 if no valid base up to 62 can be found.
Many thanks to Peter for the digit parsing code!
I fixed a lot of problems which added 14 bytes to the count. The following explanation is still for my original submission, and I'll update it some time tomorrow.
63,{_ea{i32b~\([G-35-9]=-_Xe>:X;}f%fbW%~*=\X>*}#
63,                                              "Push the array [0 1 .. 62].";
   {                                          }# "Find the first index for which the block returns
                                                  a truthy value.";
    _                                            "Duplicate the current base.";
     ea                                          "Read ARGV into an array of strings.";
       {                        }f%              "Apply this block to each character.";
        i32b                                     "Convert to code point, and then to base-32. The
                                                  most significant digit now identifies the 'type'
                                                  of digit.";
            ~\(                                  "Unwrap the array. Swap the digits. Decrement.";
               [G-35-9]                          "Push array [16 -35 -9] of digit offsets.";
                       =-                        "Select the relevant offset and subtract it from
                                                  the least significant digit.";
                         _                       "Duplicate the current digit D.";
                          Xe>:X;                 "X := max(X,D). X is predefined as 1.";
                                   fb            "Convert all numbers to the current base.";
                                     W%          "Reverse the list of numbers.";
                                       ~         "Unwrap the array.";
                                        *=       "Multiply factors. Check equality with product.";
                                          \      "Swap result with current base.";
                                           X>    "Ensure base is greater than X.";
                                             *   "Multiply boolean results.";

The index is printed automatically at the end of the program.

In GS the digits can be parsed as 32base~\[-16.35 9]=+. I know CJam has shorter base conversion.

APL (Dyalog Unicode), 30 bytesSBCS
⊢{3⊃e=×/2↑e←⍵⊥⍺:⍵⋄⍺∇⍵+1}1+⌈/∘,

Try it online!
Thanks to Adám for the help.
Explanation:
⊢{3⊃e=×/2↑e←⍵⊥⍺:⍵⋄⍺∇⍵+1}1+⌈/∘, ⍝
⊢                              ⍝ left argument ⍺: the vector (do nothing)
                        1+⌈/∘, ⍝ right argument ⍵: our starting base.
                             , ⍝             start by flattening the matrix of arguments                               ⌈/   ⍝             reduce by max (find the highest number)
                            ∘  ⍝             compose both of these together
                        1+     ⍝             increment by one
 {         ⍵⊥⍺         }       ⍝ convert inputs to the current base
 {       e←            }       ⍝ store the converted values in 3
 {      2↑             }       ⍝ take the first 2 values
 {    ×/               }       ⍝ multiply them together (reduce-multiply)
 {  e=                 }       ⍝ compare with e (the converted inputs)
 {3⊃                   }       ⍝ only keep the result of the comparison with the 3rd element (expected result)
 {             :⍵      }       ⍝ if truthy, return the current base.
 {               ⋄     }       ⍝ otherwise...
 {                ⍺∇⍵+1}       ⍝ ...recurse with the base incremented

We use a helper function, In, to receive the input into a more palatable format. Otherwise the input is received a matrix of 3 columns.
'3 9 42' would give, for example (read top-down then left-to-right):
0 0 4
3 9 2

And for 'aA bB 36jk' (same here. a is 10, b is 11, A is 36, etc)
 0  0  3
 0  0  6
10 11 19
36 37 20

CJam, 53 bytes
lA,s'{,97>+'[,65>+f#_$W=1e>)63,>_@Wa/W%f{fb~*=}1#\0+=

Takes the three input from STDIN like
6 9 42

Prints 0 if product in any base is not possible
Will try to golf it further.
Try it here

Python 2 - 197 213
What a monster... (compared to CJam)
from string import*
I=raw_input()
x,y,z=I.split()
B=lambda s,b:sum(b**i*(digits+lowercase+uppercase).find(s[-i-1])for i in range(len(s)))
print([b for b in range(B(max(I),10)+1,62)if B(x,b)*B(y,b)==B(z,b)]+[0])[0]

Unfortunately int's base conversion can only handle bases up to 36. So I needed to implement it by myself. (See this wonderful solution.)

Does this make sure not to return a base less than or equal to the largest digits?

@MartinBüttner: I'm not sure. At least not explicitly. Do you have a test case where this is an issue? (Actually, generating test cases should be taken care of by the OP...)

Try 2*3=20 which has base 3 in an error case. 3 is not a digit in a ternary numeral system.

JavaScript (E6) 129 139
Recursively try all bases from 2 up to 62, returning -1 if no value is ok.
JavaScript parseInt function works with base up to 36, so a little help is needed for greater bases.
Beware, the parameters x,y,z are strings, not numbers.
It's more difficult than it seems. Thanks to Martin for pointing out a basic bug in the first version.
F=(x,y,z,b=2,N=n=>[for(d of(t=0,n))t=(v=parseInt(d,36)+(d>'@'&d<'a')*26)<b?t*b+v:NaN]&&t)=>b<63?N(x)*N(y)!=N(z)?F(x,y,z,b+1):b:-1

Less golfed
F=(x,y,z,b=2,
   D=d=>parseInt(d,36)+(d>'@'&d<'a')*26, // parse a single digit
   N=n=>[for(d of(t=0,n))t=(v=D(d))<b?t*b+v:NaN]&&t // parse a string
)=>b<63?N(x)*N(y)!=N(z)?F(x,y,z,b+1):b:-1

Test In FireFox/FireBug console.
The test tries 1000 numbers with different bases (up to 36, not 62). It's worth noting that the found base could be correct but less than the base that generated the test case.
for(i=0;i<1000;i++)
{
   x=Math.random()*100|0,y=Math.random()*100|0,z=x*y,b=Math.random()*35+2|0
   bx=x.toString(b),by=y.toString(b),bz=z.toString(b),
   nb=F(bx,by,bz)
   nx=parseInt(bx,nb),ny=parseInt(by,nb),nz=parseInt(bz,nb)
   // if (nx*ny != nz) // uncomment to se output for errors only
     console.log(x,y,z,'base '+b,bx,by,bz, 'found base '+nb,nx,ny,nz,nx*ny)
}

@MartinBüttner the parameters are strings (as possible values are something like aA bB 36jk ...). Clarified in the answer.

Oh right, that makes sense.

Prolog - 195 bytes
Basically the same idea as my Erlang answer:
:-use_module(library(main)).
main(A):-between(2,62,B),maplist(x(B),A,[F,G,P]),0is F*G-P,write(B).
c(I,B,Q,O):-Q=[H|T]->(H<65->D=48;H<97->D=29;D=87),H-D<B,c(I*B+H-D,B,T,O);O=I.
c(B)-->name,c(0,B).

In readable:
:- use_module(library(main)).

main(Args) :-
    between(2, 62, Base),
    maplist(convert(Base), Args, [Factor1, Factor2, Product]),
    0 is Factor1 * Factor2 - Product,
    write(Base).

convert(Accumulator, Base, List, Output) :-
    List = [Head|Tail] ->
        (   Head < 65 -> Offset = 48;
            Head < 97 -> Offset = 29;
                         Offset = 87),
        Head - Offset < Base,
        convert(Accumulator * Base + Head - Offset, Base, Tail, Output);
    Output = Accumulator.

convert(Base, Input, Output) :-
    name(Input, List),
    convert(0, Base, List, Output).

Invocation:
$ swipl -qg main x.pl 6 9 42
13
$ swipl -qg main x.pl aA bB 36jk
41
$ swipl -qg main x.pl 2 3 20
ERROR: Unknown message: goal_failed(main([2,3,20]))

Charcoal, 28 bytes
Ｉ⌊Φ…⊕⍘⌈⁺⁺θηζ⁶²¦⁶³⁼×⍘θι⍘ηι⍘ζι

Try it online! Link is to verbose version of code. Outputs None if no valid base can be found. Explanation:
         θ                      First input
        ⁺                       Concatenated with
          η                     Second input
       ⁺                        Concatenated with
           ζ                    Third input
      ⌈                         Maximum character (by ordinal)
     ⍘                          Converted from base
            ⁶²                  Literal 62
    ⊕                           Incremented
   …                            Range up to
               ⁶³               Literal 63
  Φ                             Filtered by
                    θ           First input
                   ⍘            Converted from base
                     ι          Current value
                  ×             Multiplied by
                       η        Second input
                      ⍘         Converted from base
                        ι       Current value
                 ⁼              Equals
                          ζ     Third input
                         ⍘      Converted from base
                           ι    Current value
 ⌊                              Minimum
Ｉ                               Cast to string
                                Implicitly print

Is it possible to have a TIO program that uses the actual code you posted?

@mbomb007 You can Try it online! but the AST generator seems to think ⍘ is Any for some reason...

Jelly, 16 bytes
62ḊḅṪ=PƊ¥@ƇeoḢ{ɗ

Try it online!
Takes input similar to the APL answer. For example, aA bB 36jk is input as [10, 36], [11, 37], [3, 6, 19, 20]. The Footer does this for you.
If this isn't acceptable, +10 bytes to convert from a list of strings.
Outputs 1 as the junk value.
How it works
I'll explain the preceding 10 bytes for the longer version first, as both share the same ending 16 bytes:
ØBŒsiⱮⱮ⁸’µ - Main link. Takes a list of strings on the left
ØB         - Yield '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
  Œs       - Swap-case
      Ɱ⁸   - Over each string in the left argument:
     Ɱ     -   Over each character:
    i      -     1-based index
        ’  - Decrement to 0-index
         µ - Use this list of numbers as the argument from now on

62ḊḅṪ=PƊ¥@ƇeoḢ{ɗ - Main link. Takes an list of lists of integers on the left
62               - Yield 62
  Ḋ              - Dequeue; [2, 3, 4, ..., 62]
          Ƈ      - Filter this array...
        ¥        -    ...on the following, ...
         @       -    ...with the list on the right:
   ḅ             -   Convert from base
       Ɗ         -   To this array of integers:
    Ṫ            -     Does the tail...
     =           -     equal...
      P          -     ...the product without the tail?
               ɗ - Using the input on the right and the filtered array on the left:
           e     -   Is the filtered array in the input?
             Ḣ{  -   Yield the first element of the filter
            o    -   If the filtered array is in the input, return 1, else the first element

Erlang (escript) - 200
main(X)->m(2,X).
m(63,_)->0;m(C,X)->try[F,G,I]=[c(0,C,Y)||Y<-X],I=F*G,io:fwrite("~p",[C])catch _:_->m(C+1,X)end.
c(A,B,[H|T])->D=H-if$A>H->$0;$a>H->29;0<1->87end,if D<B->c(A*B+D,B,T)end;c(A,_,_)->A.

Add two leading newlines which must be present.
In readable:
#!/usr/bin/env escript

main(Args) -> test(2, Args).

test(63, _) -> 0;
test(Base, Args) ->
    try
        [Factor1, Factor2, Product] = [convert(0, Base, Arg) || Arg <- Args],
        Product = Factor1 * Factor2,
        io:fwrite("~p", [Base])
    catch _:_ ->
        test(Base + 1, Args)
    end.

convert(Accumulator, Base, [Head|Tail]) ->
    Digit = Head - if Head < $A -> $0;
                      Head < $a -> $A - 10 - 26;
                      true      -> $a - 10
                   end,
    if Digit < Base ->
        convert(Accumulator * Base + Digit, Base, Tail)
    end;
convert(Accumulator, _, _) -> Accumulator.

Invocation:
$ escript x.erl 6 9 42
13
$ escript -i x.erl a a 64
16
$ escript -i x.erl aA bB 36jk
41
$ escript -i x.erl 2 3 20
(no output)
$ escript -i x.erl 10 10 100
2

Does this make sure not to return a base less than or equal to the largest digits?

Yes, the if Digit < Base -> … end part takes care of it. If an if block has no true branch, then an exception is thrown, which gets caught in try … catch _:_ -> … end.

Haskell 216 char (177?)
Tried to golf this as much as possible. If imports are counted, then this is my shortest code (216)
import Data.Char
import Data.List
m=maximum
j[]=0;j(x:_)=x
f=reverse.map(\x->ord x-48)
g[]_=0;g(m:n)x=m+x*g n x
main=do
l<-getLine
let k@[x,y,z]=words l
print$j[n|n<-[2..62],g(f x)n*g(f y)n==g(f z)n,n>(m.map(m.f)$k)]

However, were imports not counted, then this is my best version (177):
import Data.Char
import Data.List
import Control.Applicative
m=maximum
j[]=0;j(x:_)=x
f=reverse.map(\x->ord x-48)
g[]_=0;g(m:n)x=m+x*g n x
main=words<$>getLine>>= \k@[x,y,z]->print$j[n|n<-[2..62],g(f x)n*g(f y)n==g(f z)n,n>(m.map(m.f)$k)]

This treats each number as a polynomial P(x) where x is the base, on condition that no coefficient is larger than x; I then evaluate the polynomials over each possible base, stopping when I reach one that satisfies the equality P(x)*Q(x)=R(x). The 'base is bigger than largest digit' rule is enforced with the last guard in the pattern match, namely n>(m.map(m.f)$k). I know that different golfing challenges and different challenge-makers have different policies regarding imports vis-a-vis scoring, so take the second one with a grain of salt.

The solutions are actually 216 and 177 bytes/characters, respectively. But the second solution is invalid, because imports are counted unless the OP explicitly specifies otherwise, which is not the case here as far as I can tell.

Julia, 122 bytes (79 with bending rules)
Julia has an in-built up to base 62 integer parser, but the problem is uppercase characters come before lowercase
f(l,n=2)=try
L=[parse(Int,join(i+32(i>'9')-64(i>'Z') for i=j),base=n) for j=l]
L[1]L[2]==L[3]||$
n
catch
n<62&&f(l,n+1)end

$ isn't define and will raise an error when the equality isn't right
Try it online!
Julia, 79 bytes by swapping uppercase and lowercase
If I'm allowed to swap lowercase and uppercase, It would shave off a lot of bytes (or at least if there was a swapcase function)
f(l,n=2)=try
L=parse.(Int,l,base=n)
L[1]L[2]==L[3]||$
n
catch
n<62&&f(l,n+1)end

Try it online!

authors: Олександр Маевський

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

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


text:
Choose-Your-Own-Language Code
Let's take a grid of 16x16 printable ASCII characters (code points 0x20 to 0x7E). There are 30-choose-15 paths from the top left to the bottom right corner, making only orthogonal moves, like the following example:
##..............
.#..............
.######.........
......##........
.......##.......
........#.......
........#.......
........#.......
........###.....
..........###...
............#...
............####
...............#
...............#
...............#

Each such path consists of exactly 31 characters. Note that each of those characters is on a different of the 31 anti-diagonals:
0123456789ABCDEF
123456789ABCDEFG
23456789ABCDEFGH
3456789ABCDEFGHI
456789ABCDEFGHIJ
56789ABCDEFGHIJK
6789ABCDEFGHIJKL
789ABCDEFGHIJKLM
89ABCDEFGHIJKLMN
9ABCDEFGHIJKLMNO
ABCDEFGHIJKLMNOP
BCDEFGHIJKLMNOPQ
CDEFGHIJKLMNOPQR
DEFGHIJKLMNOPQRS
EFGHIJKLMNOPQRST
FGHIJKLMNOPQRSTU

This is not an example grid. This is a visualisation of the 31 anti-diagonals.
We'll call a grid diagonally unique if no anti-diagonal contains the same character twice. If the grid has this property, no two paths will contain the same string. (Just to clarify, the visualisation itself is basically the opposite of diagonally unique.)
The Challenge
Design a diagonally unique 16x16 grid, such that as many paths as possible are valid code which prints Jabberwocky to STDOUT (with optional trailing line break) in as many languages as possible. Each code may either be a full program, or the body of a parameterless function without return statement (this is in order not to discourage languages that need to have their code in some boilerplate function/class/namespace).
Note: For simplicity you can use some reserved character for unused cells like Ypnypn did.
For each valid path, please clearly state one programming language it is valid in.
The winner is the submission with the largest number of languages covered by the above list. (Alternatively, for each language you want to count, show one path which is valid in that language, but make sure not to count any path for two languages.)
In the event of a tie, count the grid cells which are not covered by any valid path. Fewer unused cells win. If there is still a tie, I'll accept the answer with the most (net) votes.
Validation Script
I just quickly put together a little CJam snippet you can use to validate that a grid is diagonally unique.

Go to the online CJam interpreter.
Paste the following code
l:A;
qN/W%A16**33/z{A-__|=}%:*"D""Not d"?"iagonally unique"

In the input field, put you reserved character on the first line (use an unused character if you don't make sue of a reserved character), and then your grid in line 2 to 17. E.g., for Ypnypn's answer:
~
 pr~~~~~~~~~~~~~
 tin~~~~~~~~~~~~
~ypt(~~~~~~~~~~~
~~ef(~~~~~~~~~~~
~~  "J~~~~~~~~~~
~~~~~ab~~~~~~~~~
~~~~~~be~~~~~~~~
~~~~~~~rwo~~~~~~
~~~~~~~~~ck~~~~~
~~~~~~~~~~y~~~~~
~~~~~~~~~~\n~~~~
~~~~~~~~~~~")) ~
~~~~~~~~~~~  ;
~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~

Run.

Let me know if you think it has a bug.

'Twas brillig, and the slithey toves did gyre and gimble in the wabe... (yes, I have that memorized) ;)

This sounds like one of Calvin's Hobbies' questions, which is a fantastic achievement. I still have not been able to understand how it's done.

30 33 35 Languages
Reserved character: ~
 println!~~~~~~~
 puts    (1,~~~~
    echo   '~~~~
"cWprintfn"Ja~~~
Eork~~~;'Jabbe~~
\ui)K00~~~~~br~~
]tteL~0~~~~~ew~~
]<~ln(0~~~~~ro~~
`<~~~ 0~~~~~wc~~
m"~~~ "~~~~~ok~~
rJ~~~'J~~~~~cy~~
j"<< "a~~~~~k'..
^~~~~~bberwoy");
f~~~~~~~~~~c'  ;
t~~~~~~~~~~ky"
XX"););  5f+');

Languages:
01. Rust        | println! (  "Jabberwocky") ;  |
02. Groovy      | println     "Jabberwocky"     |
03. E           | println  (  "Jabberwocky")    |
04. Swift       | println  (  "Jabberwocky") ;  |
05. Julia       | println  (  "Jabberwocky");;  |
06. Processing  | println  (  "Jabberwocky")  ; |
07. Falcon      | printl   (  "Jabberwocky")    |
08. ALGOL 68    | print    (  "Jabberwocky")    |
09. Vala        | print    (  "Jabberwocky") ;  |
10. Pawn        | print    (  "Jabberwocky");;  |
11. Batsh       | print    (  "Jabberwocky")  ; |
12. freeBASIC   | print       "Jabberwocky"     |
13. Rebol       | print       "Jabberwocky"  ;  |
14. Red         | print       "Jabberwocky"   ; |
15. AWK         | print       'Jabberwocky'     |
16. Perl        | print       'Jabberwocky'  ;  |
17. bc          | print       'Jabberwocky'   ; |
18. Euphoria    |  puts    (1,"Jabberwocky")    |
19. C           |  puts    (  "Jabberwocky") ;  |
20. Tcl         |  puts       "Jabberwocky"     |
21. Ruby        |  puts       'Jabberwocky'     |
22. Zsh         |      echo   "Jabberwocky"     |
23. Bash        |      echo   "Jabberwocky"  ;  |
24. tcsh        |      echo   "Jabberwocky"   ; |
25. PHP         |      echo   'Jabberwocky'     |
26. Fish        |      echo   'Jabberwocky'  ;  |
27. Dash        |      echo   'Jabberwocky'   ; |
28. F#          |      printfn"Jabberwocky"   ; |
29. C++         |    cout<<"J"<< "abberwocky" ; |
30. D           |     Writeln(  'Jabberwocky'); |
31. Pascal      |     WriteLn(  'Jabberwocky'); |
32. Delphi      |     Writeln(  "Jabberwocky"); |
33. GolfScript  |      print;'Jabberwocky'..;;  |
34. CJam        |   "E\]]`mrj^ftXX"););  5f+'); |
35. Pyth        |      pk)K00000"Jabberwocky"   |

(Pyth and CJam thanks to user23013)

Actually, the haskell code prints the string with quotation marks. To print it without them you would need putStr[ln].... Also, haskell doesn't have ;;. I believe you mixed it with Ocaml.

Even Ocaml doesn't have that. (The online interpreter gives error if I put ;;). Anyways, replaced Haskell with something else.

Pyth would be easy to add - |         p    b"Jabberwocky"     | works, for instance

@isaacg Thanks!  I was going to look into Pyth too. This saves me time :)

@isaacg BTW, where is such path ?

Use the P in coWprint, add spaces and a b down to the lower Jabberwocky.

Can't add space in that path before that existing "

Why not? It seems open to me.

unique characters in anti sub diagonals.

Added CJam and Pyth.

@user23013 I modified the CJam one and chose a bit different approach. Thanks for both of them!

The Swift solution is not valid anymore. It is now print(...). You can specify the version (i.e: Swift 1.0) which would be valid

17 languages
Here's the grid, with . as the reserved character:
 prin...........
 utstln!........
       (1,......
<?echo    ".....
.........'Jab...
............b...
............e...
............r...
............w...
............o...
............c...
............k...
............y"..
............' ).
.............  ;
..............

And here are the languages and their paths (ignore the vertical bars):
01. Rust        | println!(   "Jabberwocky" ) ; |
02. Swift       | println (   "Jabberwocky" ) ; |
03. Scala       | println (   "Jabberwocky" )   |
04. Falcon      | printl  (   "Jabberwocky" )   |
05. Vala        | print   (   "Jabberwocky" ) ; |
06. Lua         | print   (   'Jabberwocky' ) ; |
07. ALGOL 68    | print   (   "Jabberwocky" )   |
08. Dart        | print   (   'Jabberwocky' )   |
09. Rebol       | print       "Jabberwocky"   ; |
10. Perl        | print       'Jabberwocky'   ; |
11. AWK         | print       "Jabberwocky"     |
12. Euphoria    | puts    (1, "Jabberwocky" )   |
13. C           | puts    (   "Jabberwocky" ) ; |
14. Tcl         | puts        "Jabberwocky"     |
15. Ruby        | puts        'Jabberwocky'     |
16. Bash        |     echo    "Jabberwocky"     |
17. PHP         |     echo    "Jabberwocky"   ; |

I haven't been able to test all of them, so let me know if something doesn't work.

I think you cannot use the same path for more than one language and add it to your score.

@Optimizer I don't think there are any paths used twice. Admittedly, the differences are pretty small.

Ugh, you sneaky guy! :P

For PHP, after removing boilerplate,    echo   "foobar"    (more than 1 space each time) prints just fine. Without any white spaces. Try it here

@Optimizer The problem is the space before <?. But you can probably omit that altogether if you invoke the script with the PHP interpreter itself from the command line, but I'm not sure.

Its okay to remove boilerplate from the code, which is <? here

@Optimizer Lol right, forgot my own rules.

@Optimizer Thanks! I forgot <? counts as boilerplate.

Why do you have <?

@proudhaskeller it was originally for PHP and I haven't bothered to remove it.

18 languages and more
Reserved character: ~.
         "~~~~~~
12345678 "~~~~~~
12345678 "~~~~~~
12345678 "~~~~~~
1234567: ea~~~~~
1234567: c;~~~~~
1234567: hL~~~~~
1234567: o'~~~~~
1234567:  Jab~~~
1234567:?""""~~~
~~~~~~~~~Jabberw
~~~~~~~~~~~~~~~o
~~~~~~~~~~~~~~~c
~~~~~~~~~~~~~~~k
~~~~~~~~~~~~~~~y
~~~~~~~~~~~~~~~"

Languages:
CJam                             |             ea;L'J"abberwocky"|
GolfScript                       |              cho "Jabberwocky"|
Bc                               |                  "Jabberwocky"|
Bash                             |         """"echo J"abberwocky"|
Zsh                              |           ""echo J"abberwocky"|
Fish                             |             echo J"abberwocky"|
Tcsh                             |         """"echo Ja"bberwocky"|
Dash                             |           ""echo Ja"bberwocky"|
Ksh                              |             echo Ja"bberwocky"|
Mksh                             |         """"echo Jab"berwocky"|
Yash                             |           ""echo Jab"berwocky"|
Sash                             |             echo Jab"berwocky"|
Posh                             |         """"echo "Jabberwocky"|
Csh                              |           ""echo "Jabberwocky"|
PHP                              |             echo "Jabberwocky"|

and...
FreeBasic                        |                 ?"Jabberwocky"|
QBasic                           | 12345678        ?"Jabberwocky"|
QB64                             | 123456788       ?"Jabberwocky"|

There should be many more Basic dialects that works. But I don't have time to test all of them yet.

Remember that you cannot use the same path for more than 1 language. So not all BASIC dialects will fit in.

@Optimizer At least those dialects which have line numbers and doesn't check overflow (and have ? for print) should work... Just select a different line number.


text:
Can you hear me now?
Background
You are a rich executive of a software empire. Your time is worth a lot of money. As such, you must always travel in the most efficient route possible. However, as an executive, you spend a lot of time participating in important phone calls. It is paramount that you never drop calls, so you must never travel through areas which don't have cell service!
The Challenge
You'll be given a list of three-tuples, each of which represents the location and power of a cell tower. As an example, [50, 25, 16] would represent a cell tower located at <x,y> = <50, 25> with a circle of radius 16 representing its circle of influence. With this list in mind, you must travel from your starting position at <0, 0> to your destination at <511, 511>, in the shortest distance possible without losing cell service. This is code-golf, so shortest code wins!
Input / Output
You are free to manipulate the input into a form that makes it easy to read, such as in a file, or as a nested array through STDIN using eval, etc. You may hardcode the input, so long as your code works for other inputs as well. The exact characters used to hardcode the input will not be counted, but the variable name and assignment characters will. You should not assume that the input is in any specific order, or that every cell tower is relevant to the problem. If you have any questions please leave a comment and I will try to clarify it.
The output is to be a list of coordinates, marking points that when connected in order form a path to the exit. The accuracy need only be rounded to the nearest integer, and if you are 1-2 units off of what I have in me output example, that is fine. I have included images below to clarify this.
Best of luck!
Examples
input:
[ 32,  42,  64]
[112,  99,  59]
[141, 171,  34]
[157, 191,  28]
[177, 187,  35]
[244, 168,  57]
[289, 119,  20]
[299, 112,  27]
[354,  59,  58]
[402,  98,  23]
[429,  96,  29]
[424, 145,  34]
[435, 146,  20]
[455, 204,  57]
[430, 283,  37]
[432, 306,  48]
[445, 349,  52]
[424, 409,  59]
[507, 468,  64]

output:
0 0
154 139
169 152
189 153
325 110
381 110
400 120
511 511

input2
[ 32,  42,  64]
[112,  99,  59]
[141, 171,  34]
[157, 191,  28]
[177, 187,  35]
[244, 168,  57]
[289, 119,  20]
[299, 112,  27]
[354,  59,  58]
[402,  98,  23]
[429,  96,  29]
[424, 145,  34]
[435, 146,  20]
[455, 204,  57]
[430, 283,  37]
[432, 306,  48]
[445, 349,  52]
[424, 409,  59]
[507, 468,  64]
[180, 230,  39]
[162, 231,  39]
[157, 281,  23]
[189, 301,  53]
[216, 308,  27]
[213, 317,  35]
[219, 362,  61]
[242, 365,  42]
[288, 374,  64]
[314, 390,  53]
[378, 377,  30]
[393, 386,  34]

output2:
0 0
247 308
511 511

The previous path is highlighted in blue, but you can see the addition of more towers allows a more optimal route.

Is the finish suppose to be 511,511?

How accurate do the intermediate points have to be?  Must they be integers?

If I were really so rich, I'd build a tower at (127, 127) with radius 182 with a little tunnel to drive right through.

not consistent: is the destination 255,255 or 511,511?

I think after some preparation it should be possible to reduce this problem to this challenge. You might want to add an example that has several paths of towers though.

@KeithRandall integers is fine, and accurate enough to be 1-2 units within my answer. I've updated the post.

@edc65 I fixed the specs, the destination should be 511,511.

I will add some more examples later today/tonight.

Can we assume that a valid path exists and that the input isn’t otherwise malformed?

@Wrzlprmft Yes, input will always have a valid solution.

@MartinBüttner Added a second test case with mutiple routes.

The output to the first test-case is missing a point. See the point of intersection between the second and third circles where it looks like the line passes straight through it? It actually makes ~2° turn there; it should be part of the path.

Python, 1,291 1,271 1,225 bytes
As Martin noted, this problem can be largely reduced to his excellent rubber band challenge.
Using that challenge's terminology, we can take as the second set of nails the points of intersection between the circles on the boundary of the enclosed area:

As the rubber band we can take any path P between the two endpoints that runs inside the enclosed area.
We can then invoke a solution to the rubber-band problem to produce a (locally) minimal path.
The challenge is, of course, to find such a path P, or more precisely, to find enough paths so that at least one of them produces the globally minimal path (note that in the first test-case we need at least one path to cover all possibilities, and in the second test-case at least two.)
A naive approach would be to just try all possible paths:
For every sequence of adjacent (i.e. intersecting) circles that connects the two endpoints, take the path along their centers (when two circles intersect, the segment between their centers is always within their union.)
Though this approach is technically correct, it can lead to a ridiculously large number of paths.
While I was able to solve the first test-case using this approach within a few seconds, the second one took forever.
Still, we can take this method as a starting point and try to minimize the number of paths we have to test.
This is what follows.
We construct our paths by basically performing a depth-first search on the graph of circles.
We're looking for a way to eliminate potential search directions at each step of the search.
Suppose that at some point we're at a circle A, that has two adjacent circles B and C, which are also adjacent to each other.
We can get from A to C by visiting B (and vice versa,) so we might think that visiting both B and C directly from A is unnecessary.
Unfortunately, this is wrong, as this illustration shows:

If the points in the illustration are the two endpoints, we can see that by going from A to C through B we get a longer path.
How about this one: if we're testing both the moves A→B and A→C, then it's unnecessary to test A→B→C or A→C→B, since they can't result in shorter paths.
Wrong again:

The point is that using purely adjacency-based arguments is not going to cut it; we have to use the geometry of the problem as well.
What the two above examples have in common (as well as the second test-case on a larger scale,) is that there's a "hole" in the enclosed area.
It manifests itself in the fact that some of the points-of-intersection on the boundary—our "nails"—are within the triangle △ABC whose vertices are the circles' centers:

When this happens, there's a chance that going from A to B and from A to C will result in different paths.
More importantly, when it doesn't happen (i.e. if there wasn't a gap between A, B and C) then it's guaranteed that all paths starting with A→B→C and with A→C and which are otherwise equivalent will result in the same locally minimal path, hence if we visit B we don't need to also visit C directly from A.
This leads us to our elimination method:
When we're at a circle A, we keep a list H of the adjacent circles we've visited.
This list is initially empty.
We visit an adjacent circle B if there are any "nails" in all the triangles formed by the centers of A, B and any of the circles in H adjacent to B.
This method dramatically drops the number of paths we have to test to just 1 in the first test-case and 10 in the second one.
A few more notes:

It's possible to decrease the number of paths we test even further, but this method is good enough for the scale of this problem.
I used the algorithm from my solution to the rubber-band challenge.
Since this algorithm is incremental it can be pretty easily integrated into the path-finding process, so that we minimize the path as we go along.
Since many paths share a starting-segment, this can significantly improve performance when we have lots of paths.
It can also hurt performance if there are much more dead-ends than valid paths.
Either way, for the given test-cases performing the algorithm for each path separately is good enough.
There's one edge-case where this solution may fail:
If any of the points on the boundary is the point of intersection of two tangent circles then under some conditions the result can be wrong.
This is due to the way rubber-band algorithm works.
With some modifications it's possible to handle these cases as well, but, hell, it's already long enough.

# First test case
I={((32.,42.),64.),((112.,99.),59.),((141.,171.),34.),((157.,191.),28.),((177.,187.),35.),((244.,168.),57.),((289.,119.),20.),((299.,112.),27.),((354.,59.),58.),((402.,98.),23.),((429.,96.),29.),((424.,145.),34.),((435.,146.),20.),((455.,204.),57.),((430.,283.),37.),((432.,306.),48.),((445.,349.),52.),((424.,409.),59.),((507.,468.),64.)}
# Second test case
#I={((32.,42.),64.),((112.,99.),59.),((141.,171.),34.),((157.,191.),28.),((177.,187.),35.),((244.,168.),57.),((289.,119.),20.),((299.,112.),27.),((354.,59.),58.),((402.,98.),23.),((429.,96.),29.),((424.,145.),34.),((435.,146.),20.),((455.,204.),57.),((430.,283.),37.),((432.,306.),48.),((445.,349.),52.),((424.,409.),59.),((507.,468.),64.),((180.,230.),39.),((162.,231.),39.),((157.,281.),23.),((189.,301.),53.),((216.,308.),27.),((213.,317.),35.),((219.,362.),61.),((242.,365.),42.),((288.,374.),64.),((314.,390.),53.),((378.,377.),30.),((393.,386.),34.)}

from numpy import*
V=array;X=lambda u,v:u[0]*v[1]-u[1]*v[0];L=lambda v:dot(v,v)
e=V([511]*2)
N=set()
for c,r in I:
 for C,R in I:
  v=V(C)-c;d=L(v)
  if d:
    a=(r*r-R*R+d)/2/d;q=r*r/d-a*a
    if q>=0:w=V(c)+a*v;W=V([-v[1],v[0]])*q**.5;N|={tuple(t)for t in[w+W,w-W]if all([L(t-T)>=s**2-1e-9 for T,s in I])}
N=map(V,N)
def T(a,b,c,p):H=[X(p-a,b-a),X(p-b,c-b),X(p-c,a-c)];return min(H)*max(H)>=0
def E(a,c,b):
 try:d=max((X(n-a,b-a)**2,id(n),n)for n in N if T(a,b,c,n)*X(n-b,c-b)*X(n-c,a-c))[2];A=E(a,c,d);B=E(d,c,b);return[A[0]+[d]+B[0],A[1]+[sign(X(c-a,b-c))]+B[1]]
 except:return[[]]*2
def P(I,c,r,A):
 H=[];M=[""]
 if L(c-e)>r*r:
    for C,R in I:
     if L(C-c)<=L(r+R)and all([L(h-C)>L(R+s)or any([T(c,C,h,p)for p in N])for h,s in H]):v=V(C);H+=[(v,R)];M=min(M,P(I-{(C,R)},v,R,A+[v]))
    return M
 A+=[e]*2;W=[.5]*len(A)
 try:
  while 1:
    i=[w%1*2or w==0for w in W[2:-2]].index(1);u,a,c,b,v=A[i:i+5];A[i+2:i+3],W[i+2:i+3]=t,_=E(a,c,b);t=[a]+t+[b]
    for p,q,j,k in(u,a,1,i+1),(v,b,-2,i+len(t)):x=X(q-p,c-q);y=X(q-p,t[j]-q);z=X(c-q,t[j]-q);d=sign(j*z);W[k]+=(x*y<=0)*(x*z<0 or y*z>0)*(x!=0 or d*W[k]<=0)*(y!=0 or d*W[k]>=0)*d
 except:return[sum(L(A[i+1]-A[i])**.5for i in range(len(A)-1)),id(A),A]
print V(P(I,e*0,0,[e*0]*2)[2][1:-1])

Input is given through the variable I as a set of tuples ((x, y), r) where (x, y) is the center of the circle and r is its radius.
The values must be floats, not ints.
The result is printed to STDOUT.
Example
# First test case
I={((32.,42.),64.),((112.,99.),59.),((141.,171.),34.),((157.,191.),28.),((177.,187.),35.),((244.,168.),57.),((289.,119.),20.),((299.,112.),27.),((354.,59.),58.),((402.,98.),23.),((429.,96.),29.),((424.,145.),34.),((435.,146.),20.),((455.,204.),57.),((430.,283.),37.),((432.,306.),48.),((445.,349.),52.),((424.,409.),59.),((507.,468.),64.)}

[[   0.            0.        ]
 [ 154.58723733  139.8329183 ]
 [ 169.69950891  152.76985495]
 [ 188.7391093   154.02738541]
 [ 325.90536774  109.74141936]
 [ 382.19108518  109.68789517]
 [ 400.00362897  120.91319495]
 [ 511.          511.        ]]


text:
Invent your own Unicode 7.0.0 encoding (as efficient as possible)
As you may know, the Unicode standard has room for 1,114,111 code points, and each assigned code point represents a glyph (character, emoji, etc.).
Most code points are not yet assigned.
Current Unicode implementations take a lot of space to encode all possible code points (UTF-32 takes 4 bytes per code point, UTF-16: 2 to 4 bytes, UTF-8: 1 to 4 bytes, etc.)
Task
Today, your task is to implement your own Unicode implementation, with the following rules:

Write an encoder and a decoder in any language of your choice
The encoder's input is a list of code points (as integers) and it outputs a list of bytes (as integers) corresponding to your encoding.
The decoder does the opposite (bytes => code points)
Your implementation has to cover all Unicode 7.0.0 assigned code points
It has to stay backwards-compatible with ASCII, i.e. encode Basic latin characters (U+0000-U+007F) on one byte, with 0 as most significant bit.
Encode all the other assigned code points in any form and any number of bytes you want, as long as there is no ambiguity (i.e. two code points or group of code points can't have the same encoding and vice versa)
Your implementation doesn't have to cover UTF-16 surrogates (code points U+D800-U+DFFF) nor private use areas (U+E000-U+F8FF, U+F0000-U+10FFFF)
Your encoding must be context-independant (i.e. not rely on previously encoded characters) and does NOT require self-synchronization (i.e. each byte doesn't have to infer where it's located in the encoding of a code point, like in UTF-8).

To sum up, here are the blocks that you have to cover, in JSON:
(source: http://www.unicode.org/Public/UNIDATA/Blocks.txt)

[
  [0x0000,0x007F], // Basic Latin
  [0x0080,0x00FF], // Latin-1 Supplement
  [0x0100,0x017F], // Latin Extended-A
  [0x0180,0x024F], // Latin Extended-B
  [0x0250,0x02AF], // IPA Extensions
  [0x02B0,0x02FF], // Spacing Modifier Letters
  [0x0300,0x036F], // Combining Diacritical Marks
  [0x0370,0x03FF], // Greek and Coptic
  [0x0400,0x04FF], // Cyrillic
  [0x0500,0x052F], // Cyrillic Supplement
  [0x0530,0x058F], // Armenian
  [0x0590,0x05FF], // Hebrew
  [0x0600,0x06FF], // Arabic
  [0x0700,0x074F], // Syriac
  [0x0750,0x077F], // Arabic Supplement
  [0x0780,0x07BF], // Thaana
  [0x07C0,0x07FF], // NKo
  [0x0800,0x083F], // Samaritan
  [0x0840,0x085F], // Mandaic
  [0x08A0,0x08FF], // Arabic Extended-A
  [0x0900,0x097F], // Devanagari
  [0x0980,0x09FF], // Bengali
  [0x0A00,0x0A7F], // Gurmukhi
  [0x0A80,0x0AFF], // Gujarati
  [0x0B00,0x0B7F], // Oriya
  [0x0B80,0x0BFF], // Tamil
  [0x0C00,0x0C7F], // Telugu
  [0x0C80,0x0CFF], // Kannada
  [0x0D00,0x0D7F], // Malayalam
  [0x0D80,0x0DFF], // Sinhala
  [0x0E00,0x0E7F], // Thai
  [0x0E80,0x0EFF], // Lao
  [0x0F00,0x0FFF], // Tibetan
  [0x1000,0x109F], // Myanmar
  [0x10A0,0x10FF], // Georgian
  [0x1100,0x11FF], // Hangul Jamo
  [0x1200,0x137F], // Ethiopic
  [0x1380,0x139F], // Ethiopic Supplement
  [0x13A0,0x13FF], // Cherokee
  [0x1400,0x167F], // Unified Canadian Aboriginal Syllabics
  [0x1680,0x169F], // Ogham
  [0x16A0,0x16FF], // Runic
  [0x1700,0x171F], // Tagalog
  [0x1720,0x173F], // Hanunoo
  [0x1740,0x175F], // Buhid
  [0x1760,0x177F], // Tagbanwa
  [0x1780,0x17FF], // Khmer
  [0x1800,0x18AF], // Mongolian
  [0x18B0,0x18FF], // Unified Canadian Aboriginal Syllabics Extended
  [0x1900,0x194F], // Limbu
  [0x1950,0x197F], // Tai Le
  [0x1980,0x19DF], // New Tai Lue
  [0x19E0,0x19FF], // Khmer Symbols
  [0x1A00,0x1A1F], // Buginese
  [0x1A20,0x1AAF], // Tai Tham
  [0x1AB0,0x1AFF], // Combining Diacritical Marks Extended
  [0x1B00,0x1B7F], // Balinese
  [0x1B80,0x1BBF], // Sundanese
  [0x1BC0,0x1BFF], // Batak
  [0x1C00,0x1C4F], // Lepcha
  [0x1C50,0x1C7F], // Ol Chiki
  [0x1CC0,0x1CCF], // Sundanese Supplement
  [0x1CD0,0x1CFF], // Vedic Extensions
  [0x1D00,0x1D7F], // Phonetic Extensions
  [0x1D80,0x1DBF], // Phonetic Extensions Supplement
  [0x1DC0,0x1DFF], // Combining Diacritical Marks Supplement
  [0x1E00,0x1EFF], // Latin Extended Additional
  [0x1F00,0x1FFF], // Greek Extended
  [0x2000,0x206F], // General Punctuation
  [0x2070,0x209F], // Superscripts and Subscripts
  [0x20A0,0x20CF], // Currency Symbols
  [0x20D0,0x20FF], // Combining Diacritical Marks for Symbols
  [0x2100,0x214F], // Letterlike Symbols
  [0x2150,0x218F], // Number Forms
  [0x2190,0x21FF], // Arrows
  [0x2200,0x22FF], // Mathematical Operators
  [0x2300,0x23FF], // Miscellaneous Technical
  [0x2400,0x243F], // Control Pictures
  [0x2440,0x245F], // Optical Character Recognition
  [0x2460,0x24FF], // Enclosed Alphanumerics
  [0x2500,0x257F], // Box Drawing
  [0x2580,0x259F], // Block Elements
  [0x25A0,0x25FF], // Geometric Shapes
  [0x2600,0x26FF], // Miscellaneous Symbols
  [0x2700,0x27BF], // Dingbats
  [0x27C0,0x27EF], // Miscellaneous Mathematical Symbols-A
  [0x27F0,0x27FF], // Supplemental Arrows-A
  [0x2800,0x28FF], // Braille Patterns
  [0x2900,0x297F], // Supplemental Arrows-B
  [0x2980,0x29FF], // Miscellaneous Mathematical Symbols-B
  [0x2A00,0x2AFF], // Supplemental Mathematical Operators
  [0x2B00,0x2BFF], // Miscellaneous Symbols and Arrows
  [0x2C00,0x2C5F], // Glagolitic
  [0x2C60,0x2C7F], // Latin Extended-C
  [0x2C80,0x2CFF], // Coptic
  [0x2D00,0x2D2F], // Georgian Supplement
  [0x2D30,0x2D7F], // Tifinagh
  [0x2D80,0x2DDF], // Ethiopic Extended
  [0x2DE0,0x2DFF], // Cyrillic Extended-A
  [0x2E00,0x2E7F], // Supplemental Punctuation
  [0x2E80,0x2EFF], // CJK Radicals Supplement
  [0x2F00,0x2FDF], // Kangxi Radicals
  [0x2FF0,0x2FFF], // Ideographic Description Characters
  [0x3000,0x303F], // CJK Symbols and Punctuation
  [0x3040,0x309F], // Hiragana
  [0x30A0,0x30FF], // Katakana
  [0x3100,0x312F], // Bopomofo
  [0x3130,0x318F], // Hangul Compatibility Jamo
  [0x3190,0x319F], // Kanbun
  [0x31A0,0x31BF], // Bopomofo Extended
  [0x31C0,0x31EF], // CJK Strokes
  [0x31F0,0x31FF], // Katakana Phonetic Extensions
  [0x3200,0x32FF], // Enclosed CJK Letters and Months
  [0x3300,0x33FF], // CJK Compatibility
  [0x3400,0x4DBF], // CJK Unified Ideographs Extension A
  [0x4DC0,0x4DFF], // Yijing Hexagram Symbols
  [0x4E00,0x9FFF], // CJK Unified Ideographs
  [0xA000,0xA48F], // Yi Syllables
  [0xA490,0xA4CF], // Yi Radicals
  [0xA4D0,0xA4FF], // Lisu
  [0xA500,0xA63F], // Vai
  [0xA640,0xA69F], // Cyrillic Extended-B
  [0xA6A0,0xA6FF], // Bamum
  [0xA700,0xA71F], // Modifier Tone Letters
  [0xA720,0xA7FF], // Latin Extended-D
  [0xA800,0xA82F], // Syloti Nagri
  [0xA830,0xA83F], // Common Indic Number Forms
  [0xA840,0xA87F], // Phags-pa
  [0xA880,0xA8DF], // Saurashtra
  [0xA8E0,0xA8FF], // Devanagari Extended
  [0xA900,0xA92F], // Kayah Li
  [0xA930,0xA95F], // Rejang
  [0xA960,0xA97F], // Hangul Jamo Extended-A
  [0xA980,0xA9DF], // Javanese
  [0xA9E0,0xA9FF], // Myanmar Extended-B
  [0xAA00,0xAA5F], // Cham
  [0xAA60,0xAA7F], // Myanmar Extended-A
  [0xAA80,0xAADF], // Tai Viet
  [0xAAE0,0xAAFF], // Meetei Mayek Extensions
  [0xAB00,0xAB2F], // Ethiopic Extended-A
  [0xAB30,0xAB6F], // Latin Extended-E
  [0xABC0,0xABFF], // Meetei Mayek
  [0xAC00,0xD7AF], // Hangul Syllables
  [0xD7B0,0xD7FF], // Hangul Jamo Extended-B
  [0xF900,0xFAFF], // CJK Compatibility Ideographs
  [0xFB00,0xFB4F], // Alphabetic Presentation Forms
  [0xFB50,0xFDFF], // Arabic Presentation Forms-A
  [0xFE00,0xFE0F], // Variation Selectors
  [0xFE10,0xFE1F], // Vertical Forms
  [0xFE20,0xFE2F], // Combining Half Marks
  [0xFE30,0xFE4F], // CJK Compatibility Forms
  [0xFE50,0xFE6F], // Small Form Variants
  [0xFE70,0xFEFF], // Arabic Presentation Forms-B
  [0xFF00,0xFFEF], // Halfwidth and Fullwidth Forms
  [0xFFF0,0xFFFF], // Specials
  [0x10000,0x1007F], // Linear B Syllabary
  [0x10080,0x100FF], // Linear B Ideograms
  [0x10100,0x1013F], // Aegean Numbers
  [0x10140,0x1018F], // Ancient Greek Numbers
  [0x10190,0x101CF], // Ancient Symbols
  [0x101D0,0x101FF], // Phaistos Disc
  [0x10280,0x1029F], // Lycian
  [0x102A0,0x102DF], // Carian
  [0x102E0,0x102FF], // Coptic Epact Numbers
  [0x10300,0x1032F], // Old Italic
  [0x10330,0x1034F], // Gothic
  [0x10350,0x1037F], // Old Permic
  [0x10380,0x1039F], // Ugaritic
  [0x103A0,0x103DF], // Old Persian
  [0x10400,0x1044F], // Deseret
  [0x10450,0x1047F], // Shavian
  [0x10480,0x104AF], // Osmanya
  [0x10500,0x1052F], // Elbasan
  [0x10530,0x1056F], // Caucasian Albanian
  [0x10600,0x1077F], // Linear A
  [0x10800,0x1083F], // Cypriot Syllabary
  [0x10840,0x1085F], // Imperial Aramaic
  [0x10860,0x1087F], // Palmyrene
  [0x10880,0x108AF], // Nabataean
  [0x10900,0x1091F], // Phoenician
  [0x10920,0x1093F], // Lydian
  [0x10980,0x1099F], // Meroitic Hieroglyphs
  [0x109A0,0x109FF], // Meroitic Cursive
  [0x10A00,0x10A5F], // Kharoshthi
  [0x10A60,0x10A7F], // Old South Arabian
  [0x10A80,0x10A9F], // Old North Arabian
  [0x10AC0,0x10AFF], // Manichaean
  [0x10B00,0x10B3F], // Avestan
  [0x10B40,0x10B5F], // Inscriptional Parthian
  [0x10B60,0x10B7F], // Inscriptional Pahlavi
  [0x10B80,0x10BAF], // Psalter Pahlavi
  [0x10C00,0x10C4F], // Old Turkic
  [0x10E60,0x10E7F], // Rumi Numeral Symbols
  [0x11000,0x1107F], // Brahmi
  [0x11080,0x110CF], // Kaithi
  [0x110D0,0x110FF], // Sora Sompeng
  [0x11100,0x1114F], // Chakma
  [0x11150,0x1117F], // Mahajani
  [0x11180,0x111DF], // Sharada
  [0x111E0,0x111FF], // Sinhala Archaic Numbers
  [0x11200,0x1124F], // Khojki
  [0x112B0,0x112FF], // Khudawadi
  [0x11300,0x1137F], // Grantha
  [0x11480,0x114DF], // Tirhuta
  [0x11580,0x115FF], // Siddham
  [0x11600,0x1165F], // Modi
  [0x11680,0x116CF], // Takri
  [0x118A0,0x118FF], // Warang Citi
  [0x11AC0,0x11AFF], // Pau Cin Hau
  [0x12000,0x123FF], // Cuneiform
  [0x12400,0x1247F], // Cuneiform Numbers and Punctuation
  [0x13000,0x1342F], // Egyptian Hieroglyphs
  [0x16800,0x16A3F], // Bamum Supplement
  [0x16A40,0x16A6F], // Mro
  [0x16AD0,0x16AFF], // Bassa Vah
  [0x16B00,0x16B8F], // Pahawh Hmong
  [0x16F00,0x16F9F], // Miao
  [0x1B000,0x1B0FF], // Kana Supplement
  [0x1BC00,0x1BC9F], // Duployan
  [0x1BCA0,0x1BCAF], // Shorthand Format Controls
  [0x1D000,0x1D0FF], // Byzantine Musical Symbols
  [0x1D100,0x1D1FF], // Musical Symbols
  [0x1D200,0x1D24F], // Ancient Greek Musical Notation
  [0x1D300,0x1D35F], // Tai Xuan Jing Symbols
  [0x1D360,0x1D37F], // Counting Rod Numerals
  [0x1D400,0x1D7FF], // Mathematical Alphanumeric Symbols
  [0x1E800,0x1E8DF], // Mende Kikakui
  [0x1EE00,0x1EEFF], // Arabic Mathematical Alphabetic Symbols
  [0x1F000,0x1F02F], // Mahjong Tiles
  [0x1F030,0x1F09F], // Domino Tiles
  [0x1F0A0,0x1F0FF], // Playing Cards
  [0x1F100,0x1F1FF], // Enclosed Alphanumeric Supplement
  [0x1F200,0x1F2FF], // Enclosed Ideographic Supplement
  [0x1F300,0x1F5FF], // Miscellaneous Symbols and Pictographs
  [0x1F600,0x1F64F], // Emoticons
  [0x1F650,0x1F67F], // Ornamental Dingbats
  [0x1F680,0x1F6FF], // Transport and Map Symbols
  [0x1F700,0x1F77F], // Alchemical Symbols
  [0x1F780,0x1F7FF], // Geometric Shapes Extended
  [0x1F800,0x1F8FF], // Supplemental Arrows-C
  [0x20000,0x2A6DF], // CJK Unified Ideographs Extension B
  [0x2A700,0x2B73F], // CJK Unified Ideographs Extension C
  [0x2B740,0x2B81F], // CJK Unified Ideographs Extension D
  [0x2F800,0x2FA1F], // CJK Compatibility Ideographs Supplement
  [0xE0000,0xE007F], // Tags
  [0xE0100,0xE01EF]  // Variation Selectors Supplement
]

Total: 116,816 code points.
Scoring
Your score is not the size of your encoder/decoder, but the number of bytes that your encoder outputs when you feed it with all the 116,816 possible code points (in one time or separately).
Winner
The most efficient encoding will win and will be the subject of a future code-golf challenge ;)
Good luck!

log₂ 113706 = 16.79, so one could encode all these code points in 17 bits (3 bytes).

@KennyTM the ASCII compatibility requirement will throw that estimate off a little. By almost one bit, if my mental math is right.

What exactly is the ambiguity requirement? I assume it doesn't have to be self-synchronising, and you seem to assume that each byte in the output is part of the representation of precisely one code point (correct?), so are you asking for a prefix code? Or is it sufficient that the encoder implement an injective function, but allowing arithmetic encoding?

@hobbs log₂ (113706 - 128) is still 16.79, so it just requires exactly 1 more bit, and still 3 bytes are needed.

@PeterTaylor I'm not sure about what you mean by self-synchronizing, prefix, injective and algorithmic encoding (lol), but what I meant was: "two (groups of) code points can't have the same encoding, and N bytes can't be decoded in more than one way". Each byte of the output can but DOES NOT HAVE TO be identifiable as the Xth byte of the Y-bytes encoding of a character, (like UTF-8 does).

I got 116816 adding up the amount of possible values.

As others have pointed out, doesn't this just amount to assigning a unique 17-bit integer to each code point?

@COTO yeah almost. you can encode all code points on 1 to 3 bytes. the challenge is to do it efficiently

@feersum thanks, I also get 116816 after recounting. Let's use that. :)

@KennyTM right. Well, 0.9998375 bits really, but I was in bed without a proper calculator when I wrote my previous comment :)

Of possible interest: Reading the Wiki UTF-8 article made this challenge a great deal clearer. @xem, you might consider including this link in the OP somewhere.

Score: 318080 (~2.72 bytes/char)

I assume the encoding does not require self-synchronization (like UTF-8 / UTF-16).
Because there is no example text, I assume the encoding is context-independent (unlike e.g. SCSU), i.e. the encoder converts every code point to a unique bytes sequence.
log₂ 116816 = 16.83 > 16, so any encoding chosen must contain some code point that map to 3 bytes.

For simplicity, let's assume we need to encode exactly 217 = 131072 code points. We could first map every code point to an integer from 0 to 131071. Then remaining is the optimization problem (a mathematical problem) on choosing a code which minimize L(E) = ∑0≤i<131072 |E(i)|.
One possible encoding is prefix code. The specification already 0-prefixed sequence is for 0 ... 127 only. A simple, inefficient encoding is to use 1-prefixed sequence for the remaining code:
0xxxxxxx                   = x        (this encodes values < 128)
1xxxxxxx xxxxxxxx xxxxxxxx = x + 128  (this encodes values < 131072)

The value is (1 byte × 128 + 3 bytes × (131072 − 128)) = 392960 bytes.
We could also use 2-bit prefix, e.g.
0xxxxxxx                   = x       (< 128)
10xxxxxx                   = x + 128 (< 192)
11xxxxxx xxxxxxxx xxxxxxxx = x + 192 (< 131072)
    L(E) = 192×1 + 130880×3 = 392832

or
0xxxxxxx                   = x         (< 128)
10xxxxxx xxxxxxxx          = x + 128   (< 16512)
11xxxxxx xxxxxxxx xxxxxxxx = x + 16512 (< 131072)
    L(E) = 376576

etc. I think the most efficient coding is like this:
0xxxxxxx                   = x
10xxxxxx xxxxxxxx          = x + 128
110xxxxx xxxxxxxx          = x + 16512 \
1110xxxx xxxxxxxx          = x + 24704  | squeeze all possible values
11110xxx xxxxxxxx          = x + 28800  | encodable by 2 bytes
111110xx xxxxxxxx          = x + 30848  | until 17 bits remains.
1111110x xxxxxxxx          = x + 31872 /
1111111x xxxxxxxx xxxxxxxx = x + 32384 (up to 163456)
    L(E) = 360704

Since the encoding supports all numbers up to 163456, I have chosen to close some "narrow" gaps under 14000 code points to simply the code point → number conversion, so it will support the ranges:
 U+0000 .. U+17000
U+1b000 .. U+2b900
U+2f800 .. U+2fb00
U+e0000 .. U+e0200

Since the range of numbers are extended, the score will be a few bytes above optimal, but I would compromise that for simplicity of the encoder here.
So the encoder and decoders may be written as (Python 3):
def codepoint_to_number(codepoint):
    if 0 <= codepoint < 0x17000:
        return codepoint
    elif 0x1b000 <= codepoint < 0x2b900:
        return codepoint - 0x4000
    elif 0x2f800 <= codepoint < 0x2fb00:
        return codepoint - 0x7f00
    elif 0xe0000 <= codepoint < 0xe0200:
        return codepoint - 0xb8400
    else:
        raise UnicodeError('Cannot encode ' + hex(codepoint))

def number_to_bytes(number):
    if number < 0x80:
        return bytes([number])
    elif number < 0x7e80:
        number += 0x7f80
        return bytes([number >> 8, number & 0xff])
    else:
        number += 0xfd8180
        return bytes([number >> 16, (number >> 8) & 0xff, number & 0xff])

def bytes_to_number(bs):
    first_byte = bs[0]
    if first_byte < 0x80:
        return (first_byte, bs[1:])
    elif first_byte < 0xfe:
        return (0x80 + ((first_byte & 0x7f) << 8 | bs[1]), bs[2:])
    else:
        return (0x7e80 + ((first_byte & 1) << 16 | bs[1] << 8 | bs[2]), bs[3:])

def number_to_codepoint(number):
    if number < 0x17000:
        return number
    elif number < 0x27900:
        return number + 0x4000
    elif number < 0x27c00:
        return number + 0x7f00
    else:
        return number + 0xb8400

def encode(codepoints):
    result = bytearray()
    for codepoint in codepoints:
        result.extend(number_to_bytes(codepoint_to_number(codepoint)))
    return result

def decode(bytes_sequence):
    bs = memoryview(bytes_sequence)
    while bs:
        (number, bs) = bytes_to_number(bs)
        yield number_to_codepoint(number)

# Test case:
import itertools
import unittest

# {{{
CODEPOINT_RANGES = [
    [0x0000,0x007F], # Basic Latin
    [0x0080,0x00FF], # Latin-1 Supplement
    [0x0100,0x017F], # Latin Extended-A
    [0x0180,0x024F], # Latin Extended-B
    [0x0250,0x02AF], # IPA Extensions
    [0x02B0,0x02FF], # Spacing Modifier Letters
    [0x0300,0x036F], # Combining Diacritical Marks
    [0x0370,0x03FF], # Greek and Coptic
    [0x0400,0x04FF], # Cyrillic
    [0x0500,0x052F], # Cyrillic Supplement
    [0x0530,0x058F], # Armenian
    [0x0590,0x05FF], # Hebrew
    [0x0600,0x06FF], # Arabic
    [0x0700,0x074F], # Syriac
    [0x0750,0x077F], # Arabic Supplement
    [0x0780,0x07BF], # Thaana
    [0x07C0,0x07FF], # NKo
    [0x0800,0x083F], # Samaritan
    [0x0840,0x085F], # Mandaic
    [0x08A0,0x08FF], # Arabic Extended-A
    [0x0900,0x097F], # Devanagari
    [0x0980,0x09FF], # Bengali
    [0x0A00,0x0A7F], # Gurmukhi
    [0x0A80,0x0AFF], # Gujarati
    [0x0B00,0x0B7F], # Oriya
    [0x0B80,0x0BFF], # Tamil
    [0x0C00,0x0C7F], # Telugu
    [0x0C80,0x0CFF], # Kannada
    [0x0D00,0x0D7F], # Malayalam
    [0x0D80,0x0DFF], # Sinhala
    [0x0E00,0x0E7F], # Thai
    [0x0E80,0x0EFF], # Lao
    [0x0F00,0x0FFF], # Tibetan
    [0x1000,0x109F], # Myanmar
    [0x10A0,0x10FF], # Georgian
    [0x1100,0x11FF], # Hangul Jamo
    [0x1200,0x137F], # Ethiopic
    [0x1380,0x139F], # Ethiopic Supplement
    [0x13A0,0x13FF], # Cherokee
    [0x1400,0x167F], # Unified Canadian Aboriginal Syllabics
    [0x1680,0x169F], # Ogham
    [0x16A0,0x16FF], # Runic
    [0x1700,0x171F], # Tagalog
    [0x1720,0x173F], # Hanunoo
    [0x1740,0x175F], # Buhid
    [0x1760,0x177F], # Tagbanwa
    [0x1780,0x17FF], # Khmer
    [0x1800,0x18AF], # Mongolian
    [0x18B0,0x18FF], # Unified Canadian Aboriginal Syllabics Extended
    [0x1900,0x194F], # Limbu
    [0x1950,0x197F], # Tai Le
    [0x1980,0x19DF], # New Tai Lue
    [0x19E0,0x19FF], # Khmer Symbols
    [0x1A00,0x1A1F], # Buginese
    [0x1A20,0x1AAF], # Tai Tham
    [0x1AB0,0x1AFF], # Combining Diacritical Marks Extended
    [0x1B00,0x1B7F], # Balinese
    [0x1B80,0x1BBF], # Sundanese
    [0x1BC0,0x1BFF], # Batak
    [0x1C00,0x1C4F], # Lepcha
    [0x1C50,0x1C7F], # Ol Chiki
    [0x1CC0,0x1CCF], # Sundanese Supplement
    [0x1CD0,0x1CFF], # Vedic Extensions
    [0x1D00,0x1D7F], # Phonetic Extensions
    [0x1D80,0x1DBF], # Phonetic Extensions Supplement
    [0x1DC0,0x1DFF], # Combining Diacritical Marks Supplement
    [0x1E00,0x1EFF], # Latin Extended Additional
    [0x1F00,0x1FFF], # Greek Extended
    [0x2000,0x206F], # General Punctuation
    [0x2070,0x209F], # Superscripts and Subscripts
    [0x20A0,0x20CF], # Currency Symbols
    [0x20D0,0x20FF], # Combining Diacritical Marks for Symbols
    [0x2100,0x214F], # Letterlike Symbols
    [0x2150,0x218F], # Number Forms
    [0x2190,0x21FF], # Arrows
    [0x2200,0x22FF], # Mathematical Operators
    [0x2300,0x23FF], # Miscellaneous Technical
    [0x2400,0x243F], # Control Pictures
    [0x2440,0x245F], # Optical Character Recognition
    [0x2460,0x24FF], # Enclosed Alphanumerics
    [0x2500,0x257F], # Box Drawing
    [0x2580,0x259F], # Block Elements
    [0x25A0,0x25FF], # Geometric Shapes
    [0x2600,0x26FF], # Miscellaneous Symbols
    [0x2700,0x27BF], # Dingbats
    [0x27C0,0x27EF], # Miscellaneous Mathematical Symbols-A
    [0x27F0,0x27FF], # Supplemental Arrows-A
    [0x2800,0x28FF], # Braille Patterns
    [0x2900,0x297F], # Supplemental Arrows-B
    [0x2980,0x29FF], # Miscellaneous Mathematical Symbols-B
    [0x2A00,0x2AFF], # Supplemental Mathematical Operators
    [0x2B00,0x2BFF], # Miscellaneous Symbols and Arrows
    [0x2C00,0x2C5F], # Glagolitic
    [0x2C60,0x2C7F], # Latin Extended-C
    [0x2C80,0x2CFF], # Coptic
    [0x2D00,0x2D2F], # Georgian Supplement
    [0x2D30,0x2D7F], # Tifinagh
    [0x2D80,0x2DDF], # Ethiopic Extended
    [0x2DE0,0x2DFF], # Cyrillic Extended-A
    [0x2E00,0x2E7F], # Supplemental Punctuation
    [0x2E80,0x2EFF], # CJK Radicals Supplement
    [0x2F00,0x2FDF], # Kangxi Radicals
    [0x2FF0,0x2FFF], # Ideographic Description Characters
    [0x3000,0x303F], # CJK Symbols and Punctuation
    [0x3040,0x309F], # Hiragana
    [0x30A0,0x30FF], # Katakana
    [0x3100,0x312F], # Bopomofo
    [0x3130,0x318F], # Hangul Compatibility Jamo
    [0x3190,0x319F], # Kanbun
    [0x31A0,0x31BF], # Bopomofo Extended
    [0x31C0,0x31EF], # CJK Strokes
    [0x31F0,0x31FF], # Katakana Phonetic Extensions
    [0x3200,0x32FF], # Enclosed CJK Letters and Months
    [0x3300,0x33FF], # CJK Compatibility
    [0x3400,0x4DBF], # CJK Unified Ideographs Extension A
    [0x4DC0,0x4DFF], # Yijing Hexagram Symbols
    [0x4E00,0x9FFF], # CJK Unified Ideographs
    [0xA000,0xA48F], # Yi Syllables
    [0xA490,0xA4CF], # Yi Radicals
    [0xA4D0,0xA4FF], # Lisu
    [0xA500,0xA63F], # Vai
    [0xA640,0xA69F], # Cyrillic Extended-B
    [0xA6A0,0xA6FF], # Bamum
    [0xA700,0xA71F], # Modifier Tone Letters
    [0xA720,0xA7FF], # Latin Extended-D
    [0xA800,0xA82F], # Syloti Nagri
    [0xA830,0xA83F], # Common Indic Number Forms
    [0xA840,0xA87F], # Phags-pa
    [0xA880,0xA8DF], # Saurashtra
    [0xA8E0,0xA8FF], # Devanagari Extended
    [0xA900,0xA92F], # Kayah Li
    [0xA930,0xA95F], # Rejang
    [0xA960,0xA97F], # Hangul Jamo Extended-A
    [0xA980,0xA9DF], # Javanese
    [0xA9E0,0xA9FF], # Myanmar Extended-B
    [0xAA00,0xAA5F], # Cham
    [0xAA60,0xAA7F], # Myanmar Extended-A
    [0xAA80,0xAADF], # Tai Viet
    [0xAAE0,0xAAFF], # Meetei Mayek Extensions
    [0xAB00,0xAB2F], # Ethiopic Extended-A
    [0xAB30,0xAB6F], # Latin Extended-E
    [0xABC0,0xABFF], # Meetei Mayek
    [0xAC00,0xD7AF], # Hangul Syllables
    [0xD7B0,0xD7FF], # Hangul Jamo Extended-B
    [0xF900,0xFAFF], # CJK Compatibility Ideographs
    [0xFB00,0xFB4F], # Alphabetic Presentation Forms
    [0xFB50,0xFDFF], # Arabic Presentation Forms-A
    [0xFE00,0xFE0F], # Variation Selectors
    [0xFE10,0xFE1F], # Vertical Forms
    [0xFE20,0xFE2F], # Combining Half Marks
    [0xFE30,0xFE4F], # CJK Compatibility Forms
    [0xFE50,0xFE6F], # Small Form Variants
    [0xFE70,0xFEFF], # Arabic Presentation Forms-B
    [0xFF00,0xFFEF], # Halfwidth and Fullwidth Forms
    [0xFFF0,0xFFFF], # Specials
    [0x10000,0x1007F], # Linear B Syllabary
    [0x10080,0x100FF], # Linear B Ideograms
    [0x10100,0x1013F], # Aegean Numbers
    [0x10140,0x1018F], # Ancient Greek Numbers
    [0x10190,0x101CF], # Ancient Symbols
    [0x101D0,0x101FF], # Phaistos Disc
    [0x10280,0x1029F], # Lycian
    [0x102A0,0x102DF], # Carian
    [0x102E0,0x102FF], # Coptic Epact Numbers
    [0x10300,0x1032F], # Old Italic
    [0x10330,0x1034F], # Gothic
    [0x10350,0x1037F], # Old Permic
    [0x10380,0x1039F], # Ugaritic
    [0x103A0,0x103DF], # Old Persian
    [0x10400,0x1044F], # Deseret
    [0x10450,0x1047F], # Shavian
    [0x10480,0x104AF], # Osmanya
    [0x10500,0x1052F], # Elbasan
    [0x10530,0x1056F], # Caucasian Albanian
    [0x10600,0x1077F], # Linear A
    [0x10800,0x1083F], # Cypriot Syllabary
    [0x10840,0x1085F], # Imperial Aramaic
    [0x10860,0x1087F], # Palmyrene
    [0x10880,0x108AF], # Nabataean
    [0x10900,0x1091F], # Phoenician
    [0x10920,0x1093F], # Lydian
    [0x10980,0x1099F], # Meroitic Hieroglyphs
    [0x109A0,0x109FF], # Meroitic Cursive
    [0x10A00,0x10A5F], # Kharoshthi
    [0x10A60,0x10A7F], # Old South Arabian
    [0x10A80,0x10A9F], # Old North Arabian
    [0x10AC0,0x10AFF], # Manichaean
    [0x10B00,0x10B3F], # Avestan
    [0x10B40,0x10B5F], # Inscriptional Parthian
    [0x10B60,0x10B7F], # Inscriptional Pahlavi
    [0x10B80,0x10BAF], # Psalter Pahlavi
    [0x10C00,0x10C4F], # Old Turkic
    [0x10E60,0x10E7F], # Rumi Numeral Symbols
    [0x11000,0x1107F], # Brahmi
    [0x11080,0x110CF], # Kaithi
    [0x110D0,0x110FF], # Sora Sompeng
    [0x11100,0x1114F], # Chakma
    [0x11150,0x1117F], # Mahajani
    [0x11180,0x111DF], # Sharada
    [0x111E0,0x111FF], # Sinhala Archaic Numbers
    [0x11200,0x1124F], # Khojki
    [0x112B0,0x112FF], # Khudawadi
    [0x11300,0x1137F], # Grantha
    [0x11480,0x114DF], # Tirhuta
    [0x11580,0x115FF], # Siddham
    [0x11600,0x1165F], # Modi
    [0x11680,0x116CF], # Takri
    [0x118A0,0x118FF], # Warang Citi
    [0x11AC0,0x11AFF], # Pau Cin Hau
    [0x12000,0x123FF], # Cuneiform
    [0x12400,0x1247F], # Cuneiform Numbers and Punctuation
    [0x13000,0x1342F], # Egyptian Hieroglyphs
    [0x16800,0x16A3F], # Bamum Supplement
    [0x16A40,0x16A6F], # Mro
    [0x16AD0,0x16AFF], # Bassa Vah
    [0x16B00,0x16B8F], # Pahawh Hmong
    [0x16F00,0x16F9F], # Miao
    [0x1B000,0x1B0FF], # Kana Supplement
    [0x1BC00,0x1BC9F], # Duployan
    [0x1BCA0,0x1BCAF], # Shorthand Format Controls
    [0x1D000,0x1D0FF], # Byzantine Musical Symbols
    [0x1D100,0x1D1FF], # Musical Symbols
    [0x1D200,0x1D24F], # Ancient Greek Musical Notation
    [0x1D300,0x1D35F], # Tai Xuan Jing Symbols
    [0x1D360,0x1D37F], # Counting Rod Numerals
    [0x1D400,0x1D7FF], # Mathematical Alphanumeric Symbols
    [0x1E800,0x1E8DF], # Mende Kikakui
    [0x1EE00,0x1EEFF], # Arabic Mathematical Alphabetic Symbols
    [0x1F000,0x1F02F], # Mahjong Tiles
    [0x1F030,0x1F09F], # Domino Tiles
    [0x1F0A0,0x1F0FF], # Playing Cards
    [0x1F100,0x1F1FF], # Enclosed Alphanumeric Supplement
    [0x1F200,0x1F2FF], # Enclosed Ideographic Supplement
    [0x1F300,0x1F5FF], # Miscellaneous Symbols and Pictographs
    [0x1F600,0x1F64F], # Emoticons
    [0x1F650,0x1F67F], # Ornamental Dingbats
    [0x1F680,0x1F6FF], # Transport and Map Symbols
    [0x1F700,0x1F77F], # Alchemical Symbols
    [0x1F780,0x1F7FF], # Geometric Shapes Extended
    [0x1F800,0x1F8FF], # Supplemental Arrows-C
    [0x20000,0x2A6DF], # CJK Unified Ideographs Extension B
    [0x2A700,0x2B73F], # CJK Unified Ideographs Extension C
    [0x2B740,0x2B81F], # CJK Unified Ideographs Extension D
    [0x2F800,0x2FA1F], # CJK Compatibility Ideographs Supplement
    [0xE0000,0xE007F], # Tags
    [0xE0100,0xE01EF]  # Variation Selectors Supplement
]
#}}}

ALL_CODEPOINTS = list(itertools.chain.from_iterable(range(x, y+1) for x, y in CODEPOINT_RANGES))

ENCODE_RESULT = encode(ALL_CODEPOINTS)

print(len(ENCODE_RESULT), '/', len(ALL_CODEPOINTS))

DECODE_RESULT = list(decode(ENCODE_RESULT))

tc = unittest.TestCase()
tc.assertListEqual(ALL_CODEPOINTS, DECODE_RESULT)

Great entry! You're right, the challenge doesn't require self-sync, and it's context independant. My code point count was wrong indeed, it seems like the correct count is 116816. (warning, if I'm right, it's not 116570 as you say, and you may have to recount your score)

@grawity: UTF-16 is self-synchronizing if you view every 16-bit as a single word.

@xem: Thanks, updated the code to match the correct count.

authors: Илья Хоришко