text:
Is My Graph Planar?
Your task is to determine whether a graph is planar.
A graph is planar if it can embedded in the plane, or in other words if it can be drawn without any crossing edges.
Input: You will be given an undirected graph in your choice of the following formats:

Edge list, e.g. [(0, 1), (0, 2), (0, 3)]
Adjacency map, e.g. {0: [1, 2, 3], 1:[0], 2:[0], 3:[0]}
Adjacent matrix, e.g. [[0, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]]

Node names may be numbers, strings or similar, but your chosen format must be able to support an an arbitrary graph. No putting code in the node names. There will be no self loops.
Standard choice of input, including STDIN, command line arguments and function arguments.
Output: You should return a specific output for all planar graphs, and a different specific output for all nonplanar graphs.
Standard choice of output, including STDOUT, function return value.
Examples:
Planar:
[]
[(0,1), (0,2), (0,3), (0,4), (0,5), (0,6)]
[(0,1), (0,2), (0,3), (1,2), (1,3), (2,3)]
[(0,2), (0,3), (0,4), (0,5), (1,2), (1,3), (1,4), (1,5), (2,3),
 (2,5), (3,4), (4,5)]

Nonplanar:
[(0,1), (0,2), (0,3), (0,4), (1,2), (1,3), (1,4), (2,3), (2,4), (3,4)]
[(0,3), (0,4), (0,5), (1,3), (1,4), (1,5), (2,3), (2,4), (2,5)]
[(0,3), (0,4), (0,6), (1,3), (1,4), (1,5), (2,3), (2,4), (2,5), (5,6),
 (7,8), (8,9), (7,9)]

Any function which explicitly performs planarity testing or otherwise specifically references planar embeddings is disallowed.
This is code golf. May the shortest code win.

It's great that this is a classic problem and there are still several possible approaches, including ones not used in code for usual purposes.

Floating numbers are going to mess up some stuff here.

@RenaeLider Sorry, but I don't understand. The question has nothing to do with floating point numbers whatsoever - it doesn't even use numbers, really, just labels.

Mathematica, 201 bytes
f@g_:=EdgeCount@g<9||!(h=g~IsomorphicGraphQ~CompleteGraph@#&)@5&&!h@{3,3}&&And@@(f@EdgeDelete[g,#]&&f@EdgeContract[g,#]&/@EdgeList@g);And@@(f@Subgraph[g,#]&/@ConnectedComponents[g=Graph[#<->#2&@@@#]])&

This evaluates to an unnamed function, which takes an edge list like
{{0, 3}, {0, 4}, {0, 5}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, {2, 4}, {2, 5}}

This is a horribly inefficient recursive approach based on Wagner's theorem:

A finite graph is planar if and only if it does not have K5 or K3,3 as a minor.

Here, K5 is the complete graph with 5 vertices, and K3,3 is the complete bipartite graph with 3 vertices in each group.  A graph A is a minor of graph B if it can be obtained from B by a sequence of edge deletions and edge contractions.
So this code just checks if the graph is isomorphic to K5 or K3,3 and if not then it recursively calls itself once for every possible edge deletion or contraction.
The catch is that deleting or contracting edges in one component of an unconnected graph will never get rid of all the vertices there, so we'll never find the desired isomorphisms. Hence, we apply this search to each connected component of the input graph separately.
This works very fast for the given inputs, but if you add a few more edges it will quickly take catastrophically long (and take a lot of memory as well).
Here is an indented version of f (the unnamed function after it just generates a graph object from the input:
f@g_ :=
  EdgeCount@g < 9 ||
  ! (h = g~IsomorphicGraphQ~CompleteGraph@# &)@5 &&
  ! h@{3, 3} &&
  And @@ (f@EdgeDelete[g, #] && f@EdgeContract[g, #] & /@ EdgeList@g)

And this is the unnamed function which converts the input to a graph and calls f for each connected component:
And @@ (
  f @ Subgraph[g, #] & /@ ConnectedComponents[
    g=Graph[# <-> #2 & @@@ #]
  ]
)&

I can save a couple of bytes by changing the termination condition from EdgeCount@g<9 to g==Graph@{}, but that will blow up the runtime significantly. The second test case then takes 30 seconds, and the last one hasn't completed yet.

You could try and remove the named function using #0 which refers to the innermost pure function.

@LegionMammal978 I know, but it doesn't really save anything, because then I need parentheses and also need to assign # to a variable g manually.


text:
A Chrestomathy of Obscurity
You should complete four tasks in a language which:

must return no results* when searched for on this (codegolf.se) website, for example ToffeeScript;
must have a page listed at Esolang, Rosetta Code or Wikipedia;
be a distinct language, rather than a distinct version (e.g. python 2.1 would be valid iff python satisfied the first two criteria).

*The exception being this hit for ToffeeScript.
The four tasks you should complete are:
1) Write a tweetable (<140 characters) description/promotion of your chosen language.
2) Print "Hello World! This is written in <programming language name>."
3) Print all the odd numbers in a user specified range. (e.g. a stdin of 20 25 should return 21 23 25).
4) Write a program which you feel best demonstrates an interesting feature of your chosen language.
Scoring:

This is a popularity contest
Bonus of 10 points if listed in two of the above directories, 25 if in all three.
Score is the summation of votes received at midnight UTC on July 1 2015, plus the bonuses.

Clarifications:

Task 1) can be a tweetable program but plain text is also acceptable.
Many languages do not have an existing interpreter; solutions to these are fine, but will be taken in good faith.
The second criterion for language choice forbids pages whose creation dates after this post. If, for a given language, X, a solution to a problem exists on Rosetta Code but it does not have a distinct page of its own somewhere, it is still acceptable.

you're talking to programmers, you don't have to say and/or ;)

The “must return no results” should be taken literally? For example there is a result for “mond”, but certainly not the same Mond as in the answer. Does it count as result?

You should probably state that the pages on Esolangs, Rosetta Code or Wikipedia must have existed before this challenge.

@MartinBüttner In that case it would also need to be decided if it counts that the language existed on Rosetta Code before its page. I added a Mond solution to the QuickSort task back in September 2014, but the actual page for the language didn't exist until today.

Could you clarify whether task 1 requires a 140 character program that outputs a description, or just a 140 character description (which is not a program)?

There are a ridiculous amount of "languages" on esolangs that have no interpreter available, either because one was never written or it's now 404'd. Are these usable, assuming good faith in writing programs according to the spec on the language page?

I've clarified the points raised here (at least I hope I have!) above

Can I use a language which is a derivate of another, but the only difference is the character of the keywords? (E.g. Brainfuck derivates which have the same 8 instructions, just with different characters.)

BlooP
Bonus: 10
There are pages for BlooP on Esolangs and Wikipedia. A PPCG search for BlooP returns no results. If you're feeling particularly loopy, you can try it out on repl.it.

Task 1: The Tweet

BlooP: Nothing but bounded loops. ;) #programming #goodtimes

This uses standard Twitter styling including hashtags and emoticons. This would appeal to any Twitter user.*

Task 2: The Hello World
DEFINE PROCEDURE ''GREETING'' [N]:
BLOCK 0: BEGIN
  PRINT['Hello World! This is written in BlooP.']
BLOCK 0: END.

GREETING[0];

As you can see, this is a prime golfing language.*

Task 3: The Odd Numbers
DEFINE PROCEDURE ''IS-ODD'' [N]:
BLOCK 0: BEGIN
  OUTPUT <= 0;
  CELL(0) <= 2;
  LOOP AT MOST N+1 TIMES:
  BLOCK 1: BEGIN
    IF N+1 = CELL(0), THEN:
    BLOCK 2: BEGIN
      OUTPUT <= 1;
      ABORT LOOP 1;
    BLOCK 2: END;
    CELL(0) <= CELL(0) + 2
  BLOCK 1: END;
BLOCK 0: END.

DEFINE PROCEDURE ''ODDS-IN-RANGE'' [A,B]:
BLOCK 0: BEGIN
  CELL(0) = A;
  LOOP AT MOST B TIMES:
  BLOCK 1: BEGIN
    IF CELL(0) > B, THEN:
    ABORT LOOP 1;
    IF IS-ODD[CELL(0)] = 1, THEN:
    PRINT[CELL(0)];
    CELL(0) <= CELL(0) + 1;
  BLOCK 1: END;
BLOCK 0: END.

ODDS-IN-RANGE[20,25];

The only available operators in BlooP are assignment (<=), addition, multiplication, greater than, less than, and equals. Because of its painfully verbose syntax, it's actually pretty easy to tell what's going on even without a deep understanding of the language.

Task 4: The Interesting
Note: My snippet for this task is subject to change should I come up with something more interesting.
DEFINE PROCEDURE ''MINUS'' [M,N]:
BLOCK 0: BEGIN
  IF M < N, THEN:
  QUIT BLOCK 0;
  LOOP AT MOST M + 1 TIMES:
  BLOCK 1: BEGIN
    IF OUTPUT + N = M, THEN:
    ABORT LOOP 1;
    OUTPUT <= OUTPUT + 1;
  BLOCK 1: END;
BLOCK 0: END.

DEFINE PROCEDURE ''FIB''[N]:
BLOCK 0: BEGIN
  IF N < 1, THEN:
  QUIT BLOCK 0;
  OUTPUT <= 1;
  IF N < 3, THEN:
  QUIT BLOCK 0;
  OUTPUT <= FIB[MINUS[N,1]] + FIB[MINUS[N,2]];
BLOCK 0: END.

FIB[10];

Behold, the Fibonacci numbers.

*May not be true

Mond*

* Searching for 'Mond' gives one result (this answer notwithstanding), but it's a false positive and doesn't actually mention the language.
Rosetta Code page. This was actually created after the challenge was posted, however a solution to the QuickSort task has existed since September 2014.
Although mond looks very similar to JavaScript (indeed, it's quite easy to write Mond/JS polyglots), it is not a subset, superset, or re-implementation. It is its own distinct language.

Try it in your browser
Full disclosure: I'm involved with the development and design process of Mond to a degree and have personally implemented several major language features including user-defined operators which are demonstrated in tasks 3 & 4.
Task #1
The pipeline operator (|>) is syntax sugar that transforms the function call on the right-hand side to a function call with the value on the left-hand side inserted as the first argument. foo |> bar() is the same as bar( foo ).
"Simple, elegant scripting language implemented in C# for .NET/Mono" |> printLn();

Task #2
"Hello World! This is written in Mond." |> printLn();

Task #3
The code for this task assumes several things:

The range of numbers will be entered on a single line
The upper and lower bounds will be separated by a single space
The numbers given are integers in base-10 and contain only the chars 0-9

Try it here
// parse a string to a number
fun toNumber( str ) {
    var n = 0, pow = str.length();

    for( var i = 0; i < str.length(); ++i )
        n += ( str.charCodeAt( i ) - 48 ) * ( 10 ** --pow );

    return n;
}

fun map( arr, fn ) {
    var ret = [ ];

    foreach( var item in arr )
        fn( item ) |> ret.add();

    return ret;
}

// user-defined operator to create an upper-bound inclusive range a-la Ruby
// (i.e. 1 .. 5 produces [ 1, 2, 3, 4, 5 ])
seq( .. )( start, end ) {
    for( var i = start; i <= end; ++i )
        yield i;
}

// read a line from STDIN, trim leading and trailing whitespace,
// split the string to an array, map the array to parse all strings to numbers.
var nums = readLn().trim().split( " " ) |> map( toNumber );

// nums[0] .. nums[1] makes use of the user-defined operator declared on line 22.
// nums[0] is the lower bound, nums[0] is the upper bound.
foreach( var n in nums[0] .. nums[1] ) {
    if( n % 2 != 0 ) printLn( n );
}

Task #4
This task demonstrates user-defined operators, which allow the programmer to define any arbitrary operator (so long as it doesn't already exist) just like a function, and use it as they would any other operator. They come in unary and binary flavours.
Try it here.
// forward function compositing user-defined operator.
// the function on the right-hand side is called with
// the result of the function on the left-hand side.
fun( >>> )( fn1, fn2 ) {
    return fun( ...args ) {
        return fn1( ...args ) |> fn2();
    };
}

// the mythical "goes down to" operator of legend.
// a lazy sequence that returns all numbers starting from 'hi'
// down to (and including) 'lo'
seq( --> )( hi, lo ) {
    for( var i = hi; i >= lo; --i )
        yield i;
}

seq map( iterable, callback ) {
    foreach( var item in iterable )
        yield item |> callback();
}

// doubles the value of n
fun double( n ) -> n *  2;

// squares the value of n (** is the power operator, a-la Python or Ruby)
fun square( n ) -> n ** 2;

// gets the sequence for 10 down to 0, passes it into
// map, which maps it through the composited function of
// double and square, which first doubles the given value
// then squares it.
var nums = ( 10 --> 0 ) |> map( double >>> square );

foreach( var n in nums )
    printLn( n );

It's only listed on Rosetta Code, how does it get a 25-pt bonus?

@Scimonster My interpretation of the scoring bonuses is that the language needs to have 0 search results, be listed on one of: Rosetta Code, Esolang, or Wikipedia, and be a distinct language to qualify for the 25 points. If I'm wrong and the only criteria is that it must have pages on Rosetta Code, Esolang, and Wikipedia, I'll edit accordingly.

No, the 3 things you listed are criteria for being allowed in the challenge at all. It qualifies for the 10 point bonus if, say, Wikipedia and Rosetta Code both list it. The 25 point bonus is if it's on Rosetta, Esolang, and Wikipedia.

@Scimonster I see, my mistake. I've updated my answer.

jq
None of the 14 results on codegolf.se is about the language. (jq (and uppercase variants) seems to be frequent statement in Pyth.)
There is jq category on Rosetta Code.
You can try it online but some of examples below need latest version 1.5.
Task 1: The Tweet

jq is like sed for JSON; you can use it to process structured data with the same ease that sed, awk, grep and friends let you play with text

(Shamelessly twittified the first paragraph from its site.)
Task 2: The Hello World
bash-4.3$ jq -n -r '"Hello World! This is written in jq."'
Hello World! This is written in jq.

Task 3: The Odd Numbers
bash-4.3$ jq -R 'split(" ") | range(.[0] | tonumber; .[1] | tonumber + 1) | select(. % 2 == 1)' <<< '20 25'
21
23
25

Task 4: The Interesting
The ~/.mozilla/firefox/*.default/extensions.json file containing information about the installed Firefox extensions has 0 newlines in 171 Kb on JSON data, which makes it somehow difficult to read.
Pretty print the JSON data:
bash-4.3$ jq '' ~/.mozilla/firefox/*.default/extensions.json

Doh. 8000++ lines are too long, so pass it to pager, but keep the highlighting:
bash-4.3$ jq -C '' ~/.mozilla/firefox/*.default/extensions.json | less -r

Ouch. How many extensions are there anyway?
bash-4.3$ jq '.addons | length' ~/.mozilla/firefox/*.default/extensions.json
58

Ok, but some of them are disabled. How many exactly?
bash-4.3$ jq '[.addons[] | select(.active | not)] | length' ~/.mozilla/firefox/*.default/extensions.json
7

Some of them are quite abandoned and not work with current Firefox anymore:
bash-4.3$ jq -r '.addons[] | [.defaultLocale.name, (.targetApplications[] | select(.id == "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}"))] | select(.[1].maxVersion | gsub("[^\\d.]"; "") | tonumber < 38.0) | .[0]' ~/.mozilla/firefox/*.default/extensions.json
Unity Desktop Integration
Unity Websites integration
Ubuntu Firefox Modifications

(This later is not true. For some reason extensions.json contains other version ranges than the extensions' install.rdf. But that is not jq's fault anyway.)

ooc
Yeah, I'm about a month late. So what???

Searching for ooc currently gives no results.
Link to ooc at Rosetta Code.

Task 1

ooc is a programming language that compiles down to C99 that has an elegant syntax, and supports both high- and low-level development.

135 bytes! That was close!
Also, fake bonus points for ooc's insanely cool ASCII-art logo:
           +(NNhBBhss+'                  ~+'(sNBND=~.
           -(=NDhNN+=+=' .   .  .    . .+='+~DNND+=.
           .+-DBDDh+(D-<'      .....  -<+ (=~DNh+<(
            '+<NNNB=~=z-(<-<<(+('-'~<<=- .+'sBNh~+
             (~=NNND+=DB~(-.    . .    ...(=BNB+s--      ALL YOUR
             .=-=DBDz-'~. .   ..'. .... '  '~s<<szh<.
               <(~'. .  .  ..sD='-~'-'-DDs.. . .~sD(     CODEBASE
            . ~+'  '  .-(-..sBNB~(~~+=hNNNz'<<z='-z(
           . .=. -DDz<~s~  'BNNN=~+<shNNNND(sNNNh~(+    ARE BELONG
            .=<.(NNNNDDs. (hhs+=s=hNDNNBNBBs<BNND<<=.
            .'-'~sNNs((- .''. ' -~NNDz+((~---~sB<'''.     TO US!
                '=(++(-..  . ...-~+B~'....'.''-+(     .
                -=z<<'.. .'-...'-~hz~-'.''''-~-<=
                 .~+~s~  ~z<~'-'--hN=~((~'---(~~z~
                   (+<-.'+=''''~(+=Bz--~(((=+s+~(s
  IT'S OVER      . '+-..~<----~-+(sBNh+zBNNBNh+<z'
                   .<-'--''(<~=B=hDDD=<<<++=++<=.
  9000 BUGS!     .. s~..'h=++ss=D<<~+B(<(+<=Nz=+
                    +'.''+NNDN(+z(((sB<((s+hNh<+
                   .= -~(~(zDNz+z+zhNDz=szhhBz++.       MADNESS?
                   '+. ss<'~=NBNBBDzBzhshDD=+<<-
                   -= . +s~-(+==hhDBNBDDs==hz+<     THIS! IS! LLAMA!
                 '(<-  . '~~(<+<=+<sz=+sshzs(..
                .+<.    '('-~(((((<++(<<((= .
                 .--.. ....'.'.'.'..''..'-..

Task 2
"Hello, world!" println()

Task 3
import text/StringTokenizer
import structs/ArrayList
input := stdin readLine() split(' ', false)
(begin, end) := (input[0] toInt(), input[1] toInt())
for (i in begin..end+1) {
    if (i % 2 != 0) { "%d " printf(i) }
}
println()

Pretty straightforward implementation. Also, this showcases an interesting aspect of ooc: method calls use spaces as delimiters, not dots. For instance, notice stdin readLine() split(' ', false) above. In most languages, that would be written as stdin.readLine().split(' ', false), but ooc reserves that for call chaining (scroll down to the code example).
Task 3
This showcases my favorite ooc feature: type matching. It's like pattern matching. In an OO language. Awesome.
import structs/ArrayList
import math/Random

Animal: abstract class {
    makeNoise: abstract func
}

Sheep: class extends Animal {
    init: func
    makeNoise: func {
        "Baaaaaaa!" println()
    }
}

Wolf: class extends Animal {
    init: func
    makeNoise: func {
        "Hooooowl!" println()
    }
}

animals := [Sheep new(), Sheep new(), Sheep new()] as ArrayList<Animal>
badNumber := Random randRange(0, 3)
animals[badNumber] = Wolf new()
animal: Animal

"Enter a number between 0 (inclusive) and 3 (exclusive)" println()
inputNumberString := stdin readLine()
for (chr in inputNumberString) {
    if (!(chr.digit?())) {
        "NUMBER, not CHARACTER! Can't you read!?" println()
        exit(1)
    }
}
inputNumber := inputNumberString toInt()
try {
    animal = animals[inputNumber]
} catch (e: OutOfBoundsException) {
    "I said a number between one and three, you idiot!" println()
    exit(1)
}
"Animal noise:" println()
animal makeNoise()
match (animal) {
    case sheep: Sheep => { "It's a stupid, annoying sheep!" println() }
    case wolf: Wolf => { "AHH! A WOLF! You got eaten. :/ R.I.P." println() }
}

source: Stack Exchange

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

sort: votes


text:
Pushing items in the sequence
Aim
If you are given a sequence such as (A, G, M, _, _, C, D, _, G) your aim is to push all non empty elements to one side to get (A, G, M, C, D, G, _, _, _). You must preserve the order of the non-empty elements.
Rules

You are free to choose the sequence type. (strings, numbers, containers etc). You must also choose a Nil/None/Null character or element that will fit your sequence type. eg; spaces or underscores inside a string.
User should be able to input the push direction (left or right) and the sequence. Input values and format are up to you to choose. eg; Your code handles sequences that are numbers with 7 as the null character. You set R for right, L for left. So user inputs R, 1577462722727777. The result is 7777777715462222
Rearranged sequence should be displayed or written to a file.
Your code should not exceed 128 bytes.

Points

+(10 / bytes) golfing points
+1 for Moses-Mode. Push half the elements to the left, and half to the right. If odd number of items are present, you may choose the direction of the final element. eg; (A, G, M, _, _, _, C, D, G)

You may use use this calculator to round your points to the hundredth decimal place.

For Moses-Mode, does that have to be a choice along with right and left, or can we just implement it by itself?

Your scoring basically forces languages to go for the bonus to have a chance. The weird scoring also feels like a gimmick.  Given that the bonus requires you to do a modified task, it would be cleaner to have it be part of the challenge instead.

@Maltysen Yes, it should be one of the input choices along with right and left.

@xnor You're right, some times I am very very sinister and Evil... (cue evil laughter)

The 128 byte limit is a needless barrier that keeps wordy languages from participating.

How cheaty can we make the right/left options? Whats stopping us from putting the code in there?

@Maltysen You can cheat as long as right and left input produces two distinct results. You may even take no/zero input as Left and any input as right, much like a yes or no question (the question being "Do you want me push these to the Right?").

This is a poor title because the challenge has nothing to do with a stack (which "pushing" suggests) or a sequence.

Did you really link to a calculator that rounds numbers? I expected something where we put in byte count and an output or something, not "A guide to rounding to 2dp"

@AlecTeal     .......and?

@RenaeLider well .... I went to school.

R - 10 / 71 70 66 39 bytes = 0.26 points
Saved 27 bytes thanks to Mickey!
function(d,s)s[order(xor(!is.na(s),d))]

This creates an unnamed function which takes a direction d (logical with TRUE corresponding to right and FALSE to left (legit per OP's comment)) and a vector s (assumed to use NA for empty elements) as input and returns a vector. To call it, give it a name, e.g. f=function(d,s)....
This does not support "Moses Mode."
Ungolfed + explanation:
f <- function(d, s) {
    # Order the elements of s by non-missing exclusive or direction
    s[order(xor(!is.na(s), d))]
}

Examples:
> test <- c(1, 5, NA, NA, 4, 6, 2, NA, 2, 2, NA, 2, NA, NA, NA, NA)
> f(FALSE, test)
[1] NA NA NA NA NA NA NA NA  1  5  4  6  2  2  2  2
> f(TRUE, test)
[1]  1  5  4  6  2  2  2  2 NA NA NA NA NA NA NA NA

And an extra special example just for FryAmTheEggman:
> c(f(TRUE, test), "BATMAN")
[1] "1" "5" "4" "6" "2" "2" "2" "2" NA NA NA NA NA NA NA NA "BATMAN"

I can't believe I've never seen a post on this site of an R array containing NA NA NA NA NA NA NA NA BATMAN. ;)

@FryAmTheEggman: Until now!

You could save a few using the an order on the is.na rather than reconstructing the vector.  function(d,s){O=is.na(s);if(d)s[order(O)]else s[order(!O)]}

Actually taking it a step further and using an xor this is quite a bit shorter function(d,s)s[order(xor(!is.na(s),d))]

@MickyT: Wow, thanks so much for the suggestions! You saved me 27 bytes!!

Wish I could see these sort of things in my own answers :-)

Pyth, 10 / 15 14 bytes + 1 = 1.71 points
s@.pac2-zd@dzQ

This takes two lines of input. The first one is a string (spaces are the special characters) and the second one is 0 (push all spaces to the right), 1 (Moses-mode) or 4 (push all spaces to the left).
Try it online: Demonstration
Thanks to @isaacg for saving one byte
Explanation:
                 implicit: z = input string, Q = input number
       -zd       remove all spaces from z
     c2          split into 2 equal pieces
    a            append
          @dz    get all spaces in z
  .p             create all permutation of the 3 strings
 @           Q   choose the Qth permutation
s                and join the strings

Pyth, 10 / 7 bytes = 1.43 points
oqQqNdz

Input format: string on first line, and 0 (push spaces to the left) or 1 (push spaces to the right) on second line.
Try it online: Demonstration
This is worth less points, but it's a quite simple and elegant solution.
Explanation:
          implicit: z = input string, Q = input number
o     z   order the chars N of z by the key:
 qQqNd       Q == (N == " ")

When Q == 0 all spaces get the key 0 and all other chars get the key 1, otherwise it's exactly opposite. Then the string is sorted by their keys. Since sorting is stable in Pyth, it sorts all spaces either to the beginning or the end and keeps all other chars in the same order.

To get all of the spaces in z, use @dz. It's shorter than using J.

Haskell 10/24 bytes = 0.42 points
import Data.List
(.sort)

Sadly the sort function is in Data.List, so I have to import it.
The sequence type is boolean values, i.e. True or False. The empty value is False. Pushing non empty values to the right is indicated by id and to the left by reverse.
Example usage:
*Main> (.sort) id [True,False,False,True,False,True]
[False,False,False,True,True,True]
*Main> (.sort) reverse [True,False,False,True,False,True]
[True,True,True,False,False,False]

I honestly don't mind that the challenge has a byte limit. It is the OP's choice to impose that restriction to make things more interesting. However, just to represent how a "wordy" language would do, here's java:
Java
283 bytes = 0.04points + 1 = 1.04
enum E{;public static void main(String[]r){String s="",t=r[0].substring(1),d="_";char p=r[0].charAt(0);for(;t.indexOf(d)>=0;){r=t.split(d,2);t=r[0]+r[1];s+=d;}int x=(t.length()-1)/2;if(p=='L')t+=s;else if(p=='R')t=s+t;else t=t.substring(0,x)+s+t.substring(x+1);System.out.print(t);}}

Input is from the command line. The first character can be L for left, R for right, anything else for moses mode. Underscore is used for the null character.
If I remove the moses mode code, I get:
207 bytes = 0.05points
enum E{;public static void main(String[]r){String s="",t=r[0].substring(1),d="_";char p=r[0].charAt(0);for(;t.indexOf(d)>=0;){r=t.split(d,2);t=r[0]+r[1];s+=d;}if(p=='L')t+=s;else t=s+t;System.out.print(t);}}

Input is from the command line. L is left, anything else is right. Underscore is null.
I quite enjoyed the challenge of trying to fit Java code inside 128 bytes. Java just isn't a competitive language for codegolfs though.

k,10/12 = 0.83 points
{x((>:;<:)y)x}

It takes an array of booleans and a 0 or 1 to say to push to the right or the left.
k){x((>:;<:)y)x}[1011110101101b;0]
1111111110000b
k){x((>:;<:)y)x}[1011110101101b;1]
0000111111111b

k, 10/29 = 0.34 points
A more flexible version that should work for all input types and which allows you to choose the null character.
{x@,/$[~z;|:;](&~:;&:)@\:x=y}

.
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}[1 0 3 6 5 6 0 6 0;6;0]
6 6 6 1 0 3 5 0 0
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}[1 0 3 6 5 6 0 6 0;6;1]
1 0 3 5 0 0 6 6 6
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}[1 0 3 6 5 6 0 6 0;0;1]
1 3 6 5 6 6 0 0 0
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}["abc def ghi";" ";1]
"abcdefghi  "
k){x@,/$[~z;|:;](&~:;&:)@\:x=y}["abc def ghi";" ";0]
"  abcdefghi"

Pyth - 10 / 1 byte + 1 = 11
Really cheaty, but it seems allowed, basically puts all the code in the options. Doing bonus now.
It takes an array of ints, with 0 as falsey.
The left value is: Y.append(eval(input())) or [i for i in Y[0] if i] + [0]*Y[0].count(0)
The right value is: Y.append(eval(input())) or [0]*Y[0].count(0) + [i for i in Y[0] if i]
The Moses value is: Y.append(eval(input())) or Y.append(chop(2, [i for i in Y[0] if i])) or Y[1][0] + [0]*Y[0].count(0) + Y[1][1]
So here is the code:
Q

Because of security reasons it only works locally, not online.
Old, non-cheaty one - 0.83:
Not going for the bonus, takes array of ints, 0 is falsey, and 1 for right, -1 for left.
Ms%H,fTGf!TG

Explanation coming soon.
M           Two var lambda
 s          Join the two parts of the array
  %         String slice step, reverses if -1, unchanged if 1
   H        Second arg
   ,        Two element list
    fTG     Filter arg 1 for truthiness
    f!TG    Filter arg 1 for falsiness

Try it here online.

@AlexA. derp :)

This is why my "use any format you want" challenges specify "your format can contain delimiters but not operators"

@Sparr or more generally, any "sane" input format.

R 10 / 69 + 1 = 1.14
Not very pretty. An unnamed function where d is a either 0 (left), 1 (right) or .5 (Moses). s is a vector of integers where 0 as the null.
function(d,s)c(rep(0,(l=length(s[!s]))*(1-d)),s[!!s],rep(0,(l*d)+.5))

Test example
> g=function(d,s)c(rep(0,(l=length(s[!s]))*(1-d)),s[!!s],rep(0,(l*d)+.5))
> test=c(17,0,2,42,2,4,35,0,0,45,0,2,0,7,9)
> g(0,test)
 [1]  0  0  0  0  0 17  2 42  2  4 35 45  2  7  9
> g(1,test)
 [1] 17  2 42  2  4 35 45  2  7  9  0  0  0  0  0
> g(.5,test)
 [1]  0  0 17  2 42  2  4 35 45  2  7  9  0  0  0
> test=c(17,0,2,42,0,2,4,35,0,0,45,0,2,0,7,9)
> g(0,test)
 [1]  0  0  0  0  0  0 17  2 42  2  4 35 45  2  7  9
> g(1,test)
 [1] 17  2 42  2  4 35 45  2  7  9  0  0  0  0  0  0
> g(.5,test)
 [1]  0  0  0 17  2 42  2  4 35 45  2  7  9  0  0  0
>

CoffeeScript, 172 bytes = 1.06 points
x=(m,d)->c='concat';l='length';s=d.filter((el)->el);z=new Array(d[l]-s[l]).fill 0;(Array.prototype.splice.apply(s,[d[l]/4,0][c] z);return s)if!m--;return z[c] s if!m;s[c] z

First parameter is mode: 0 (or false) for Moses mode, 1 for push right (prepend), 2 for push left (append)
Second parameter is an array of integers where 0 is considered the empty token (though all falsy values are considered empty, but will be replaced with 0).
Version without Moses mode: 91 bytes = 0.11 points
x=(d,a)->o=a.filter((l)->''!=l);o[if d then'push'else'unshift'] ''while a.length-o.length;o

First parameter is a Boolean indicating whether to push right (true or any truthy value) or push left (false or any falsy value).
Second parameter is the array. Empty tokens include empty strings.

JavaScript (ES6) - 168 bytes, 1.06 points
x=(d,a)=>{c='concat',l='length',o=a.filter(l=>l),z=new Array(a[l]-o[l]).fill(0);if(!d)Array.prototype.splice.apply(o,[a[l]/4,0][c](z));return d?(d>1?z[c](o):o[c](z)):o}

Input:

0 (or any falsy value) for Moses mode, 1 for push left, 2 for push right
Array of integers in second parameter, 0 considered empty

Unminified code
x = (mode, data) => {
    var concat = 'concat',
        length = 'length',
        stripped = data.filter(el => {
            return !!el;
        }),
        zeroes = new Array(data[length] - stripped[length]).fill(0);

    if (!mode) {
        Array.prototype.splice.apply(stripped, [data[length] / 4, 0][concat](zeroes));
    }

    return mode ? (mode > 1 ? zeroes[concat](stripped) : stripped[concat](zeroes)) : stripped;
};

PHP - 176 bytes, 1.06 points
function x($m,$d){$c=count;$y=array_merge;$s=array_filter($d);$z=array_fill(0,$c($d)-$c($s),0);if(!$m)array_splice($s,$c($s)/4+1,0,$z);return!$m?$s:(--$m?$y($z,$s):$y($s,$z));}

Where $m is:

0: Moses mode
1: Append (push left)
2: Prepend (push right)

And $d is the an array of numeric where 0 or 0.0 is considered empty.
There are notices for undefined constants but they still work.

rs, 41 bytes
+(.)(\d+)_(\d+)/\1_\2\3
l(_+)(.+)/\2\1
r/

Takes input as a sequence of numbers, with l for left, r for right, and the underscore as the null character, e.g. r_3_12.
Live demo here.

k2, 28 bytes
{,/ :[y;|:](x@&~x=0;x@&x=0)}

I already have another answer, and there's another K answer (for k3), but I believe this one uses a vastly different approach, IMO. 0 is used as the null value. Two unfortunate issues:

k2 has no binary vectors.
#1 makes this one really long.

Usage:
{,/ :[y;|:](x@&~x=0;x@&x=0)}[1 1 0 1 2 3 0 1;1] / outputs 0 0 1 1 1 2 3 1
{,/ :[y;|:](x@&~x=0;x@&x=0)}[1 1 0 1 2 3 0 1;0] / outputs 1 1 1 2 3 1 0 0

Now, if I am allowed to use just 1 and 0 as my input, I can get much shorter, but then it ends up being almost the same thing as the other K answer. So...yeah. This sucks. :(

Some have mentioned above that wordy languages can't participate because of the restriction in byte count. I doubt it. Here's a python solution, and I think python is a wordy language, somewhat golfed.

Python 2.7
68 bytes, 0.15 points
62 bytes, 0.16 points (thanks to @Sp3000)
d,s=input();e=filter(None,s),[0]*s.count(0)
print e[d]+e[d+1]

input/ouput
0 for right, -1 for left, list of numbers as sequence. 0 is the null character
>>>0, [1, 0, 2, 3, 6, 0, 0, 0, 5]
[1, 2, 3, 6, 5, 0, 0, 0, 0]
>>>-1, [1, 0, 2, 3, 6, 0, 0, 0, 5]
[0, 0, 0, 0, 1, 2, 3, 6, 5]

You can save a few by not putting the surrounding parens for the tuple e, and also by not saving n as  a separate variable. i.e. e=filter(None,s),[0]*s.count(0)

@Sp3000 Thank you. Made the edit.

python is not a "wordy language" imo. something like java would be.

Perl - 103 bytes, 1.09 points
$_=<>;s/\n//;$b='_'x s/_//g;$x=length($_)/2;print(($b.$_,$_.$b,(substr($_,0,$x).$b.substr$_,$x))[<>+0])

The sequence is a string. The null element is an underscore character. It reads the string as a line from the standard input, then reads the direction as another line: 0 for right, 1 for left, 2 for Moses mode.
Version without Moses Mode - 49 bytes, 0.20 points
$_=<>;s/\n//;$b='_'x s/_//g;print<>+0?$_.$b:$b.$_

Same as the above except shorter and without Moses mode implemented.

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


text:
Draw a Spinning Pinwheel
Remember those fun pinwheels that you blow on and they spin round and round? Let's code one!
A pinwheel will have the set of characters \ | / _ drawing its center and arms. One possible pinwheel could look like this:
    |
    |
    |_ ___
 ___|_|
      |
      |
      |

But what's a pinwheel that doesn't spin? No fun! We can make it spin by rearranging the symbols:
      /
\    /
 \  /
  \/\
   \/\
   /  \
  /    \
 /

The challenge is to create a program that takes three integers and outputs a pinwheel as specified below. The first of these is the number of arms it has, the second is the length of the pinwheel's arms, and the third is the number of times it will spin one-eighth of a revolution clockwise.
You can assume the following:

The number of arms will always be 0, 1, 2, 4, or 8.
All the arms will be equally spaced apart from each other.
The initial position of the pinwheel will have its center like this:
 _
|_|

If the number of arms is 1, you may decide which direction the arm points.
If the number of arms is 2, you may decide to make the arms point vertically or horizontally.

You can write a full program that takes input through STDIN or command-line argument, or a function that takes input through function arguments. Your program must show a sequence of outputs that shows the pinwheel spinning, each separated by at least one empty line. The center of the pinwheel should not move by more than one space. You may output as many leading and trailing spaces as necessary.
Here are some examples:
0 2 1
 _
|_|

/\
\/

1 3 2
|
|
|_
|_|

   /
  /
 /
/\
\/

 _ ___
|_|

2 2 0
   _ __
__|_|

8 4 1
 \   |    /
  \  |   /
   \ |  /
    \|_/____
 ____|_|
     / |\
    /  | \
   /   |  \
  /    |   \

     |   /
 \   |  /
  \  | /
   \ |/
____\/\____
     \/\
     /| \
    / |  \
   /  |   \
  /   |

This is code golf, so shortest code wins. Good luck!

Can there be a trailing newline in the output?

Trailing newlines are permitted, without restriction concerning the amount.

Also for the last example, you have an extra space prepended to each line for the first output. Can we have prepended and trailing spaces in the output?

The number of leading spaces in the output has to do with the position of the center of the pinwheel, the position of which should not shift by more than one space. If the rotation of the pinwheel will cause an arm to end up left of the pinwheel's center later in the output (such as for input 1 3 5 and the arm initially pointing up), spaces will need to be prepended in earlier outputs to accommodate for this.

Python 2 535 517 473 468 bytes
Saved 5 bytes thanks to @Easterly Ink!
Input expected to be comma separated (i.e., numArms,armLength,numRots)
Golfed Version
n,l,t=input()
b=[7,3,1,5,0,4,2,6][:n]
w=5+2*l
h=w-3
X=w/2
Y=h/2-1
z=range
d=[0,1,1,1,0,-1,-1,-1]
for j in z(t+1):
 g=[[' 'for _ in[1]*w]for _ in[1]*h];a=j%2;b=[(k+1)%8for k in b];print''
 if a:g[Y][X:X+2]='/\\';g[Y+1][X:X+2]='\\/'
 else:g[Y][X+1]='_';g[Y+1][X:X+3]='|_|'
 for k in b:k=k+8*a;x=[0,2,3,3,2,0,-1,-1,0,1,2,2,1,0,-2,-1][k]+X;y=[0,0,0,2,2,2,1,0,-1,-1,0,1,2,2,0,0][k]+Y;exec"g[y][x]='|/_\\\\'[k%4];x+=d[k%8];y+=d[(k-2)%8];"*l
 for k in z(h):print''.join(g[k])

Ungolfed Version
numArms, armLength, rotAmount = input()

# Choose which arms to draw
arms = [0,4,2,6,1,5,3,7][:numArms]
for i in xrange(rotAmount+1):

    # Set up the grid spacing
    maxWidth = 5 + 2 * armLength
    maxHeight = 2 + 2 * armLength
    grid = [[' ' for x in xrange(maxWidth)] for y in xrange(maxHeight)]

    # Add the base square
    angle = i%2
    startX = len(grid[0])/2
    startY = len(grid)/2 - 1
    if angle:
        grid[startY][startX:startX+2] = '/\\'
        grid[startY+1][startX:startX+2] = '\\/'
    else:
        grid[startY][startX+1] = '_'
        grid[startY+1][startX:startX+3] = '|_|'

    for armNum in arms:
        # Determine where this arm starts
        armIdx = armNum + 8*angle;
        armX = [0,2,3,3,2,0,-1,-1,0,1,2,2,1,0,-2,-1][armIdx] + startX
        armY = [0,0,0,2,2,2,1,0,-1,-1,0,1,2,2,0,0][armIdx] + startY

        # Determine the direction it travels
        d = [0,1,1,1,0,-1,-1,-1]
        dirX = [0,1,1,1,0,-1,-1,-1][armIdx%8]
        dirY = [-1,-1,0,1,1,1,0,-1][(armIdx)%8]
        sym = '|/_\\'[armIdx%4]

        # Draw the arm
        for i in xrange(armLength):
            grid[armY][armX] = sym
            armX += dirX
            armY += dirY

    # Increment which arms to draw next
    arms = [(a+1)%8 for a in arms]
    for i in xrange(len(grid)):
        print ''.join(grid[i])
    print ''

Explanation
Pretty simple when it's broken down. First figure out how big of grid is required, then plot the base square or diamond.
Each arm's starting location, symbol and direction is hardcoded in for each of the 8 possible arms for the square and diamond base. Then, drawing them is easy enough.
To rotate everything, I simply switch between the square and diamond base, then increment each of the arms, rotating them clockwise once.

You can remove the spaces in places like ' ' for to ' 'for', ] for to ]for',8 for to 8for', print '' to print''.

Nice! I'm really happy to see an answer to this challenge.


text:
Visual Long Multiplication
There is a nice way to perform long multiplication for two integers without having to do anything but counting, which occasional gets shared around the internet. You write the digits of each number as a bunch of slanted lines, with the two numbers at a 90 degree angle. Then you can simply count the intersections in the separate columns that arise. A diagram will probably clarify this. Here is an example for calculating 21 * 32:

If you google for "visual/graphical long multiplication" you'll find a lot more examples.
In this challenge, you are to generate these diagrams using ASCII art. For the same example, the output would look like this:
   \ /
    X /
 \ / X /
\ X / X
 X X / \ /
/ X X   X /
 / X \ / X
  / \ X / \
     X X
    / X \
     / \

It's probably easiest to figure out the construction rules for these from some examples (see below), but here some details:

Intersecting segments are X, non-intersecting segments of the lines are / or \.
There should be exactly one segment after the outermost intersections.
There should be exactly one segment between intersections belonging to different digits. If there are zero-digits, these will result in consecutive / or \ segments.
You have to support any positive input (at least up to some reasonable limit like 216 or 232), and any digits from 0 to 9. However, you may assume that there neither leading nor trailing 0s.
You must not print extraneous leading whitespace or leading or trailing empty lines.
You may print trailing whitespace but it must not exceed the diagram's axis-aligned bounding box.
You may optionally print a single trailing newline.
You may choose in which order you take the two input numbers. However, it you must support arbitrary numbers for either orientation, so you can't choose something like "The larger number is given first".
If you're taking input as a string, you can use any non-digit separator between the two numbers.

You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter.
This is code golf, the shortest answer (in bytes) wins.
Examples
1*1
\ /
 X
/ \

2*61
 \ /
\ X /
 X X /
/ X X /
 / X X /
  / X X /
   / X X
    / X \ /
     / \ X
        X \
       / \

 45*1
         \ /
        \ X
       \ X \
      \ X \
     \ X \
      X \
   \ / \
  \ X
 \ X \
\ X \
 X \
/ \

21001*209
       \ /
        X /
       / X
      / / \
   \ / /   \ /
    X /     X /
 \ / X     / X /
\ X / \   / / X /
 X X   \ / / / X /
/ X \   X / / / X /
 / \ \ / X / / / X /
    \ X / X / / / X /
     X X / X / / / X /
    / X X / X / / / X
     / X X / X / / / \
      / X X / X / /
       / X X / X /
        / X X / X
         / X X / \
          / X X
           / X \
            / \

A function with 2 string parameters or just one single string and I have to split it in my code?

@edc65 Two strings or even two integer parameters are fine.

Pyth - 79 bytes
A translation of @AlexeyBurdin's answer. Can probably be golfed a lot more.
AzHmu++Gm1sH]Zd]Z,_zwK+lzlHJmm\ KK .e.eX@J+kY+-Yklz@" \/x"+byZHzjbmjk:d2_1:J1_2

Takes input as two numbers, newline separated. Explanation coming soon.
Try it online here.

python, 303
def f(s):
    a,b=s.split('*')
    a,b=map(lambda l:reduce(lambda x,y:x+[1]*int(y)+[0],l,[0]),[reversed(a),b])
    n=sum(map(len,[a,b]))
    l=[[' ']*n for i in xrange(n)]
    for i,x in enumerate(a):
        for j,y in enumerate(b):
            l[i+j][j-i+len(a)]=r' \/x'[x+2*y]
    return '\n'.join(''.join(x[2:-1]) for x in l[1:-2])

I think it's enough human-readable.
Verification:
print '---'
print '\n'.join('"%s"'%x for x in f('21001*209').split('\n'))
print '---'
---
"       \ /            "
"        x /           "
"       / x            "
"      / / \           "
"   \ / /   \ /        "
"    x /     x /       "
" \ / x     / x /      "
"\ x / \   / / x /     "
" x x   \ / / / x /    "
"/ x \   x / / / x /   "
" / \ \ / x / / / x /  "
"    \ x / x / / / x / "
"     x x / x / / / x /"
"    / x x / x / / / x "
"     / x x / x / / / \"
"      / x x / x / /   "
"       / x x / x /    "
"        / x x / x     "
"         / x x / \    "
"          / x x       "
"           / x \      "
"            / \       "
---

Just a few quick golfs: reversed is the same as [::-1], you can put the contents of the for loop into one line to save on indentation, len(a)+len(b) is shorter than sum(map(len,[a,b])), don't use xrange in golfing, the space in ) for can be removed, and since you are using python2, you can combine spaces and tabs in indentation.

Thanks much. These gives 22 bytes. But I don't think it would be the shortest. I don't code pyth but I've seen 31-byte programs... Btw, 303 is the count when every 4-spaces is replaced by a tab actually.

Here, I was able to get 276 from simple syntactic golfing: https://gist.github.com/Maltysen/e8231c0a9b585e2a4941

Also, do you mind if I translate your program to Pyth and post it as a separate answer?

This would be great since you actually can. I think reverse coordinate change of (x,y)=(i+j,j-i+len(a)): (i,j)=(smth of x and y) would be more efficient, but just a guess.

Well I got it, but its no 31 byte answer, :)

Put the first four lines after the function signature onto the same line with semicolons separating. Should save 3 bytes. Also, remove the space in return '\n' and the space in -1]) for to save 2 more.

You can set e=enumerate at the start to golf 4 chars

Python 3, 205 bytes
L=a,b=[eval("+[0]+[1]*".join("0%s0"%x)[2:])for x in input().split()]
A,B=map(len,L)
for c in range(2,A+B-1):print((" "*abs(c-A)+" ".join(" \/X"[a[i-c]+2*b[i]]for i in range(max(0,c-A),min(c,B))))[1:A+B-2])

The expressions are quite long so I think there's a fair amount of room for improvement, but anyway...
Takes input space-separated via STDIN, e.g.
21 32
   \ /
    X /
 \ / X /
\ X / X
 X X / \ /
/ X X   X /
 / X \ / X
  / \ X / \
     X X
    / X \
     / \

There's a possible trailing space on some lines, but the A+B-2 ensures that all of the trailing spaces are within the bounding box.

C#, 451 bytes
void d(string s){var S=s.Split('*');int X=S[1].Select(c=>c-47).Sum(),Y=S[0].Select(c=>c-47).Sum(),L=9*(X+Y),A=1,B=L/3,i,j;var a=Range(0,L).Select(_=>new int[L]).ToArray();foreach(var c in S[1]){for(i=48;i<c;++i){for(j=-1;j<Y;++j)a[B-j][A+j]=1;A++;B++;}A++;B++;}A=1;B=L/3;foreach(var c in S[0]){for(i=48;i<c;++i){for(j=-1;j<X;++j)a[B+j][A+j]|=2;A++;B--;}A++;B--;}Write(Join("\n",a.Select(r=>Concat(r.Select(n=>@" /\X"[n]))).Where(r=>r.Trim().Any())));}

Formatted for readability, the function in context:
using System.Linq;
using static System.Console;
using static System.Linq.Enumerable;
using static System.String;

class VisualMultiply
{
    static void Main(string[] args)
    {
        new VisualMultiply().d("21001*209");

        WriteLine();
    }

    void d(string s)
    {
        var S = s.Split('*');

        int X = S[1].Select(c => c - 47).Sum(),
            Y = S[0].Select(c => c - 47).Sum(),
            L = 9 * (X + Y),
            A = 1,
            B = L / 3,
            i,
            j;

        var a = Range(0, L).Select(_ => new int[L]).ToArray();

        foreach (var c in S[1])
        {
            for (i = 48; i < c; ++i)
            {
                for (j = -1; j < Y; ++j)
                    a[B - j][A + j] = 1;
                A++;
                B++;
            }
            A++;
            B++;
        }

        A = 1;
        B = L / 3;
        foreach (var c in S[0])
        {
            for (i = 48; i < c; ++i)
            {
                for (j = -1; j < X; ++j)
                    a[B + j][A + j] |= 2;
                A++;
                B--;
            }
            A++;
            B--;
        }

        Write(Join("\n", a.Select(r => Concat(r.Select(n => @" /\X"[n]))).Where(r => r.Trim().Any())));
    }
}

The bitwise OR was just for fun, but addition would work too.

JavaScript (ES6) 271
I'm sure that there is a solution that builds the output row by row, fiddling with math and x,y coordinates (x+y==k, x-y==k ...). But I still can't nail it.
So here is a solution that simply draws the lines one by one.
Run the snippet in Firefox to test.

F=(a,b)=>( // string parameters
  t=u=0,[for(v of a)t-=~v],[for(v of b)u-=~v],
  r=t+u,o=[...' '.repeat(r*r-r)],
  L=(x,y,n,z,m,c)=>{
    for(i=0;d=n[i++];)
      for(j=0;++x,y+=z,j++<d;)
        for(l=m+1,p=x+y*r-1-r;l--;p+=r-z,o[p-p%r-1]='\n')
          o[p]=o[p]>' '&&o[p]!=c?'X':c
  },
  L(u,0,a,1,u,'/'),
  L(0,u,b,-1,t,'\\'),
  o.join('')
)

// TEST

function test()
{
  O.innerHTML= F(A.value, B.value);
}

test();
<input id=A value=21001> * <input id=B value=209> <button onclick='test()'>-></button>

VC++ (289)280
t(char*a){int i,j,k,r,c=1,e,A=0,B=0,*C,G[99],f,u;for(C=&A;c+48|(k=(c=(*(a+=c<1))---48)>0);G[2**(C=!(c+6)?&(B+=A):&(++*C))]=k**C);for(i=0;i<B*B;printf("\n%c"+!!j,32+15*((k=(c<(f=G[(c=i/B)+(j=i%B)+A+2]))*(j<f)*(f>A))+4*(r=(!!e*B>c+(e=G[A+j-c]))*(!!e*c>A-e-2)*(e<A)))+13*k*r),i++);

Usage
#include  <stdio.h>
#include  <conio.h>

int t(char*);

int main(void)
{   char a[]="123*45";
    t((char*)a);
    getch();
    return 0;
}

int
//-------- padded code ------
t(char*a){int i,j,k,r,c=1,e,A=0,B=0,*C,G[99],f,u;memset(G,0,396);for(C=&A;c+48|(k=(c=(*(a+=c<1))---48)>0);G[2**(C=!(c+6)?&(B+=A):&(++*C))]=k**C);for(i=0;i<B*B;printf("\n%c"+!!j,32+15*((k=(c<(f=G[(c=i/B)+(j=i%B)+A+2]))*(j<f)*(f>A))+4*(r=(!!e*B>c+(e=G[A+j-c]))*(!!e*c>A-e-2)*(e<A)))+13*k*r),i++);

//---------------------------
return 0;}

Results
       \ /
      \ x /
     \ x x /
      x x x /
   \ / x x x
  \ x / x x \ /
   x x / x \ x /
\ / x x / \ x x /
 x / x x   x x x /
/ x / x \ / x x x /
 / x / \ x / x x x
  / x   x x / x x \
   / \ / x x / x \
      x / x x / \
     / x / x x
      / x / x \
       / x / \
        / x
         / \

the function iterates one single loop , and use some geometricks and ascii trifling.

What's the ---48 for?

@LegionMammal978 sometimes i write things then i forget even why did i put it there :D anyway im busy doing something else, when i finish , ill remember for you ; (does this code go well in your compilater) ?

@LegionMammal978 here ,array content at specific (actual) index is subtracted to 48 before it decrements , subtracting 48 in order to wait a coming nil character then decrement step by step forward in loop (or backwards as ascii pattern)

48 is the ascii representation of "0"

I see now, it works like ...)-- - 48)....

Canvas, 41 bytes
（Ａ┬｛［１｝０｝┐）
⁷Ｌ├Ｘ⁷ｌＹø；｛³×？³ｙ³－╵ｘ＼╋
⁸⤢↔╶╶⁸ｎ

Try it here!

C (329 b)
int f(char*a){int i,j,r,k,c,h,o,e=15,m=99,A=0,B=0,*C,L[m][m],G[m],*g=G;for(C=&A;(c=*a-48)+48;C=!(c+6)?&B:&(*C+=(*g++=c+1)),a++);for(i=B-1,j=0;j<(r=A+B-1);i--,j++)for(k=0,o=4*!!((*(g-=!*g))---1);k<=*(C=(h=i<0)?&B:&A);k++)L[abs(i)+k][j+k-2*k*h]+=o/(3*h+1)*e;for(i=0;i<r*r;i++)printf("\n%c"+!!(i%r),((h=L[i/r][i%r])>e*4)?120:h+32);}

TRY IT

It seems there are columns of spaces after every character, and the final non-intersecting segments at the bottom ends are missing. You're also using the digits in reverse order.

@MartinBüttner imagine someone is doing this on the moon and u watching it by telescope , that s the way you should perceive the diagram (-joking-i ll adjust that later)

Jelly, 58 bytes
ŒDṙLN‘ƊṚị“\/X ”K€
L‘0xż1xⱮ$F
DÇ€Ḥ2¦+þ/µZJUṖ;J’⁶xⱮżÑṖḊẎḊ$€Y

Try it online!
Explanation
A full program that takes the two numbers as a list of two integers and returns a string.
Helper link 1: rotate the matrix
ŒD                        | get the diagonals
  ṙ                       | rotate left by
   LN‘Ɗ                   | minus num columns +1
       Ṛ                  | reverse order
        ị“\/X ”           | index into \/X
               K€         | join each with spaces

Helper link 2: generate the row and column templates
L‘0x                      | 0 copied (num digits + 1) times
    ż                     | interleaved with
     1xⱮ$                 | 1 copied as specified by the digits
         F                | flattened

Main link
D                         | convert to decimal digits
 Ç€                       | call above link for each number
   Ḥ2¦                    | double the second one
      +þ/                 | outer product using +
         µ                | start a new monadic chain
          ZJUṖ;J’         | reversed range counting down
                          | the columns, followed by range
                            counting up the rows (without
                            duplicating 0 in the middle)
                   ⁶xⱮ    | that many spaces (to provide indents)
                      ż   | interleaved with
                       Ñ  | rotated matrix
                        ṖḊẎḊ$€ Y | remove blank rows and columns and join with newlines

R, 294 bytes
d=do.call;r=outer;m=d(r,c(Map(function(y,w)d(c,c(lapply(y%/%10^rev(0:log10(y))%%10,function(z)c(0,rep(w,z))),0)),scan(),1:2),`+`))+1;p=matrix(" ",u<-sum(dim(m)),u);p[d(r,c(lapply(dim(m),seq),function(a,b)nrow(m)-a+b+u*(a+b-2)))]=c(" ","\\","/","X")[m];cat(apply(p,1,paste,collapse=""),sep="\n")

Try it online!

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


text:
Burrows, Wheeler and Back
Background
The Burrows–Wheeler transform (BWT) is a reversible permutation of the characters of a string that results in large runs of similar characters for certain types of strings such as plain text. It is used, for example, in the bzip2 compression algorithm.
The BWT is defined as follows:
Given an input string such as codegolf, compute all possible rotations of it and sort them in lexicographical order:
codegolf
degolfco
egolfcod
fcodegol
golfcode
lfcodego
odegolfc
olfcodeg

The BWT of the string codegolf is the string consisting of the last character of each string in that order, i.e., the last column of the block above. For codegolf, this yields fodleocg.
By itself, this transformation isn't reversible, since the strings codegolf and golfcode result in the same string. However, if we know that the string ends with an f, there is only one possible preimage.
Task
Implement an involutive program or function that reads a single string from STDIN or as command-line or function argument and prints or returns either the BWT or its inverse of the input string.
If the input string contains no spaces, your submission should append a single space to the input and compute the BWT.
If the input string already contains a space, it should compute the preimage of the BWT that has a trailing space and strip that space.
Examples
INPUT:  ProgrammingPuzzles&CodeGolf
OUTPUT: fs&e grodllnomzomaiCrGgPePzu

INPUT:  fs&e grodllnomzomaiCrGgPePzu
OUTPUT: ProgrammingPuzzles&CodeGolf

INPUT:  bt4{2UK<({ZyJ>LqQQDL6!d,@:~L"#Da\6%EYp%y_{ed2GNmF"1<PkB3tFbyk@u0#^UZ<52-@bw@n%m5xge2w0HeoM#4zaT:OrI1I<|f#jy`V9tGZA5su*b7X:Xn%L|9MX@\2W_NwQ^)2Yc*1b7W<^iY2i2Kr[mB;,c>^}Z]>kT6_c(4}hIJAR~x^HW?l1+^5\VW'\)`h{6:TZ)^#lJyH|J2Jzn=V6cyp&eXo4]el1W`AQpHCCYpc;5Tu@$[P?)_a?-RV82[):[@94{*#!;m8k"LXT~5EYyD<z=n`Gfn/;%}did\fw+/AzVuz]7^N%vm1lJ)PK*-]H~I5ixZ1*Cn]k%dxiQ!UR48<U/fbT\P(!z5l<AefL=q"mx_%C:2=w3rrIL|nghm1i\;Ho7q+44D<74y/l/A)-R5zJx@(h8~KK1H6v/{N8nB)vPgI$\WI;%,DY<#fz>is"eB(/gvvP{7q*$M4@U,AhX=JmZ}L^%*uv=#L#S|4D#<
OUTPUT: <#Q6(LFksq*MD"=L0<f^*@I^;_6nknNp;pWPBc@<A^[JZ?\B{qKc1u%wq1dU%;2)?*nl+U(yvuwZl"KIl*mm5:dJi{\)8YewB+RM|4o7#9t(<~;^IzAmRL\{TVH<bb]{oV4mNh@|VCT6X)@I/Bc\!#YKZDl18WDIvXnzL2Jcz]PaWux[,4X-wk/Z`J<,/enkm%HC*44yQ,#%5mt2t`1p^0;y]gr~W1hrl|yI=zl2PKU~2~#Df"}>%Io$9^{G_:\[)v<viQqwAU--A#ka:b5X@<2!^=R`\zV7H\217hML:eiD2ECETxUG}{m2:$r'@aiT5$dzZ-4n)LQ+x7#<>xW)6yWny)_zD1*f @F_Yp,6!ei}%g"&{A]H|e/G\#Pxn/(}Ag`2x^1d>5#8]yP>/?e51#hv%;[NJ"X@fz8C=|XHeYyQY=77LOrK3i5b39s@T*V6u)v%gf2=bNJi~m5d4YJZ%jbc!<f5Au4J44hP/(_SLH<LZ^%4TH8:R

INPUT:  <#Q6(LFksq*MD"=L0<f^*@I^;_6nknNp;pWPBc@<A^[JZ?\B{qKc1u%wq1dU%;2)?*nl+U(yvuwZl"KIl*mm5:dJi{\)8YewB+RM|4o7#9t(<~;^IzAmRL\{TVH<bb]{oV4mNh@|VCT6X)@I/Bc\!#YKZDl18WDIvXnzL2Jcz]PaWux[,4X-wk/Z`J<,/enkm%HC*44yQ,#%5mt2t`1p^0;y]gr~W1hrl|yI=zl2PKU~2~#Df"}>%Io$9^{G_:\[)v<viQqwAU--A#ka:b5X@<2!^=R`\zV7H\217hML:eiD2ECETxUG}{m2:$r'@aiT5$dzZ-4n)LQ+x7#<>xW)6yWny)_zD1*f @F_Yp,6!ei}%g"&{A]H|e/G\#Pxn/(}Ag`2x^1d>5#8]yP>/?e51#hv%;[NJ"X@fz8C=|XHeYyQY=77LOrK3i5b39s@T*V6u)v%gf2=bNJi~m5d4YJZ%jbc!<f5Au4J44hP/(_SLH<LZ^%4TH8:R
OUTPUT: bt4{2UK<({ZyJ>LqQQDL6!d,@:~L"#Da\6%EYp%y_{ed2GNmF"1<PkB3tFbyk@u0#^UZ<52-@bw@n%m5xge2w0HeoM#4zaT:OrI1I<|f#jy`V9tGZA5su*b7X:Xn%L|9MX@\2W_NwQ^)2Yc*1b7W<^iY2i2Kr[mB;,c>^}Z]>kT6_c(4}hIJAR~x^HW?l1+^5\VW'\)`h{6:TZ)^#lJyH|J2Jzn=V6cyp&eXo4]el1W`AQpHCCYpc;5Tu@$[P?)_a?-RV82[):[@94{*#!;m8k"LXT~5EYyD<z=n`Gfn/;%}did\fw+/AzVuz]7^N%vm1lJ)PK*-]H~I5ixZ1*Cn]k%dxiQ!UR48<U/fbT\P(!z5l<AefL=q"mx_%C:2=w3rrIL|nghm1i\;Ho7q+44D<74y/l/A)-R5zJx@(h8~KK1H6v/{N8nB)vPgI$\WI;%,DY<#fz>is"eB(/gvvP{7q*$M4@U,AhX=JmZ}L^%*uv=#L#S|4D#<

INPUT:  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
OUTPUT: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

INPUT:  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
OUTPUT: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

Additional rules

You cannot use any built-in operators that compute the BWT (or its inverse) of a string.

You cannot use any built-in operators that invert functions.

Your code may print a trailing newline if you choose STDOUT for output, even if it doesn't support trailing newlines in the input.

Your code has to work for any input of 500 or less printable ASCII characters (0x20 to 0x7E), including at most one space.

For any of the possible inputs described above, your code must finish in under ten minutes on my machine (Intel Core i7-3770, 16 GiB RAM). The last test case should be the slowest, so make sure you time your code with that one.
For most languages and approaches, it should be easy to comply with the time limit. This rule is solely meant to prevent implementing either transform as a brute-force inverse of the other.

Standard code golf rules apply. The shortest submission in bytes wins.

"You cannot use any built-in operators that invert functions." I'd be very surprised if such a thing existed!

@HughAllen J has inv.

It might work for trivial or builtin functions, but how could it work for general user-defined functions? Is this "inv" documented somewhere?

@HughAllen: I don't really know J, but here is an example of inv working on a user-defined function. I'm not sure if inv would work for the BWT, but better safe than sorry.

Related, see http://codegolf.stackexchange.com/questions/4771/text-compression-and-decompression-nevermore/4779#4779 for a full bzip2.

@KeithRandall: bzip2 in under 300 bytes. Nice!

Pyth, 29 bytes
?tthu+VzSGzz}dzseMS.>L+z\ hlz

Demonstration. Test harness.
This straightforwardly divides into an encoding and decoding segment, with the code deciding which one to use with a ternary.
?tthu+VzSGzz}dzseMS.>L+z\ hlz
                                 Implicit:
                                 z = input()
                                 d = ' '

?           }dz                  If there is a space in the input,
    u     zz                     Update G to the result of the following,
                                 with G starting as z and repeating len(z) times:
     +V                          The vectorized sum of
       zSG                       z and sorted(G)
   h                             Take the first such result, which will consist of
                                 the first character of z followed by the
                                 first cyclic permuation of the pre-BWT string,
                                 which must start with ' '.
 tt                              Remove the first two characters and return.
                 L               Otherwise, left-map (map with the variable as the
                                 left parameter and a constant as the right)
               .>                cyclic right shift
                  +z\            of z + ' '
                      hlz        over range(len(z)+1)
              S                  Sort the shifted strings,
            eM                   take their last charactes,
           s                     combine into one string and return.

CJam, 41 36 35 bytes
q:XS&LX,{X\.+$}*0=1>XS+_,,\fm<$zW>?

Test it here.
Explanation
q:X   e# Read STDIN and store it in X.
S&    e# Take the set intersection with " ". We'll use this as a truthy/falsy value to
      e# select the correct output later.

# Compute the iBWT:
LX,   e# Push an empty array, compute the length of X.
{     e# Run the following block that many times:
  X\  e# Push X and pull the other array on top.
  .+  e# Add the characters of X to the corresponding line of the other array,
      e# i.e. prepend X as a new column.
  $   e# Sort the rows.
}*
0=    e# Since we just sorted the rows, the first permutation of the output will be
      e# one starting with a space, followed by the string we actually want. So just
      e# pick the first permutation.
1>    e# Remove the leading space.

# Compute the BWT:
XS+   e# Push X and append a space.
_,    e# Get that string's length N.
,\    e# Turn it into a range [0 .. N-1], swap it with the string.
fm<   e# Map each value in the range to the string shifted left by that many characters.
$     e# Sort the permutations.
zW>   e# Transpose the grid and discard all lines but the last.

?     e# Choose between the iBWT and the BWT based on whether the input had a space.

Perl 5, 179
Another not-so-good one from me. There are probably some gains to be had in this one, but it's not going to compete with the purpose-built golf languages.
$_=<>;@y=/./g;if(/ /){@x=sort@y;for(1..$#y){@x=sort map$y[$_].$x[$_],0..$#x}
say$x[0]=~/^ (.*)/}else{push@y," ";say map/(.)$/,sort map{$i=$_;join"",
map$y[($_+$i)%@y],0..$#y}0..$#y}

Un-golfed:
# Read input
$_ = <>;
# Get all the chars of the input
my @chars = /./g;

if (/ /) {
  # If there's a space, run the IBWT:
  # Make the first column of the table
  my @working = sort @chars;

  # For each remaining character
  for (1 .. $#chars) {
    # Add the input as a new column to the left of @working,
    # then sort @working again
    @working = sort map {
      $chars[$_] . $working[$_]
    } 0 .. $#working;
  }
  # Print the first element of @working (the one beginning with space), sans space
  say $working[0] =~ /^ (.*)/;
} else {
  # BWT
  # Add a space to the end of the string
  push @chars, " ";
  # Get all the rotations of the string and sort them
  @rows = sort map {
    my $offset = $_;
    join "", map {
      $chars[($_ + $offset) % @chars]
    } 0 .. $#chars
  } 0 .. $#chars;

  # Print all the last characters
  say map /(.)$/, @rows;
}

A few minor improvements: 1. If you use the -n switch (usually counted as 1 byte), you don't need $_=<>;. 2. for(1..$#y){...} can become ... for 1..$#y. 3. $" is initialized to " " and one byte shorter.

@Dennis good call. I had had multiple statements in the for at one point so the postfix form wasn't a win, but when I pared it down to one I didn't notice :)


text:
Each step of the Levenshtein distance
In this challenge you will write a program that takes two newline-separated strings, s1 (the first line) and s2 (the second line), as input (STDIN or closest). You can assume that the length of s1 will always be smaller than 30 and bigger than the length of s2. The program should then output each step in the levenshtein distance from s1 to s2.
To clarify what each step in the levenshtein distance means, the program will print n strings, where n is the levenshtein distance between s1 and s2, and the levenshtein distance between two adjacent strings will always be one. The order doesn't matter. The output should be newline-separated and not include s1, only the in-betweens and s2. The program should also run in under one minute on a modern computer.

Examples:
Input:
Programming
Codegolf

Output:
rogramming
Cogramming
Coramming
Coamming
Codmming
Codeming
Codeging
Codegong
Codegolg
Codegolf

Input:
Questions
Answers

Output:
uestions
Aestions
Anstions
Ansions
Answons
Answens
Answers

Input:
Offline
Online

Output:
Ofline
Online

Input:
Saturday
Sunday

Output:
Sturday
Surday
Sunday

Here is a link to a python script that prints out the distance and the steps.
Additional rules:

No use of the internet
Standard loopholes apply

This is code-golf so keep you code short; shortest code wins!

For my edit, I rather presumed that the input would be of the form s1(newline)s2, however, having looked over the question again, I am wondering if instead you intended for the program to select s1 and s2 based on the length of 2 inputed strings, coming in either order, would you mind clarifying this point? That is, do we assume the input is s1 followed by s2, or do we select s1 and s2 based on the length of the two inputs?

Does an answer have to run in a reasonable amount of time?

Camper - Ampere, distance 2, the python script runs forever ...

How strict is "take input from STDIN or closest"? Can I write a function that takes the input via function argument? The currently accepted answer does so.

Haskell, 201 194 bytes
l=length
g[]n u=map(\_->"")n
g(b:c)[]u=(u++c):g c[]u
g(b:c)n@(o:p)u|b==o=g c p(u++[o])|1<2=((u++o:c):g c p(u++[o]))!((u++c):g c n u)
a!b|l a<l b=a|1<2=b
p[a,n]=g a n""
f=interact$unlines.p.lines

Longer than expected. Maybe I can golf it down a little bit ...
Usage example:
*Main> f                     -- call via f
Questions                    -- User input
Answers                      -- no newline after second line!
uestions                     -- Output starts here
Aestions
Anstions
Ansions
Answons
Answens
Answers

It's a brute force that decides between changing and deleting if the initial characters differ.

How long does it take to run?

How can I test (maybe ideone)?

@Loovjo: shorter strings like your examples are calculated instantly, worst case is about 1:30min. I've interpreted the "should" in "should run in under one minute" not as a strict limit (should vs. must). If this is a must, I can add a "performance pack" for about 20 bytes.

@edc65: yes, ideone, but it expects the function to be executed to be called "main". Try: http://ideone.com/CUgU8W

APL (Dyalog 18.0), 66 bytes
{⍺<Ö≢⍵:⍺∇⎕←0~⍨0@(⊃(⍸~p)~⍳⊃⌽⍸p←⍵=⍺↑⍨≢⍵)⊢⍵⋄j←⊃⍸⍺≠⍵⋄⍺≢⍵:⍺∇⎕←⍺[j]@j⊢⍵}

Try it online!
Works correctly now.
A recursive function submission, done with a lot of input from Adám and Bubbler.
Input is taken as <s2> f <s1>.
Explanation
⍺<⍥≢⍵: if the strings have different lengths:
0@(...)⊢⍵ put a zero at the following index:
⊃ first element of:
(⍸~p) characters which do not match
~ without
⍳⊃⌽⍸p←⍵=⍺↑⍨≢⍵ all indices before last character match
0~⍨ remove the zero(thereby removing the element)
⍺∇⎕← display the result and recurse
⋄⍺≢⍵: Otherwise, till the strings match:
i←⊃⍸⍺≠⍵ find first non-matching element
⍺[i]@i⊢⍵ and replace the element at that index
⍺∇⎕← display the result, and recurse


text:
Calculate a probability exactly
This task is about writing code to compute a probability exactly. The output should be a precise probability written as a fraction in its most reduced form. That is it should never output 4/8 but rather 1/2.
For some positive integer n, consider a uniformly random string of 1s and -1s of length n and call it A. Now concatenate to A its first value. That is A[1] = A[n+1] if indexing from 1.  A now has length n+1. Now also consider a second random string of length n whose first n values are -1, 0, or 1 with probability 1/4,1/2, 1/4 each and call it B.
For example, consider n=3. Possible values for A and B could be A = [-1,1,1,-1] and B=[0,1,-1]. In this case the two inner products are 0 and 2.
Now consider the inner product of A[1,...,n] and B and the inner product of A[2,...,n+1] and B.
Your code must output the probability that both inner products are zero.
For n=1 this probability is clearly 1/2.
I don't mind how n is specified in the code but it should be very simple and obvious how to change it.
Languages and libraries
You can use any language and libraries you like. I would like to run your code so please include a full explanation for how to run/compile your code in linux if at all possible.

Test cases for the first few n would be helpful. Also maybe an explicit example of A, B and the two inner products might help.

If we choose to harcode the integer, does n=4 count as zero, two or three bytes? Does the output have to be exactly a/b or would [a b], e.g., be allowed?

@Dennis It has to be exact.  If you hardcode the integer will I only have to change it in one place to change n? Otherwise, I think that is not allowed.

Yes, my program only uses the integer once to compute a cartesian power. Everything else is derived from the resulting array.

Pyth, 48 47 46 44 bytes
K,smlf!|Fms*Vd.>Tk2^,1_1Q^+0tM3Q^8Qj\//RiFKK

Try it online: Demonstration
The online version probably doesn't compute n=6. On my laptop (offline version) it takes about 45 seconds.
Brute force approach.
Explanation:
smlf!|Fms*Vd.>Tk2^,1_1Q^+0tM3Q   implicit: Q = input number
                          tM3    the list [-1, 0, 1]
                        +0       add zero, results in [0, -1, 0, 1]
                       ^     Q   all possible lists of length Q using these elements
 m                               map each list d (B in Lembik's notation) to:
                  ,1_1              the list [1, -1]
                 ^    Q             all possible lists of length Q
   f                                filter for lists T (A in Lembik's notation),
                                    which satisfy:
       m        2                      map each k in [0, 1] to:
        s*Vd.>Tk                          scalar-product d*(shifted T by k)
    !|F                                not or (True if both scalar-products are 0)
  l                                 determine the length
s                                add all possibilities at the end

K,...^8QQj\//RiFKK
 ,...^8Q             the list [result of above, 8^Q]
K                    store it in K
              iFK    determine the gcd of the numbers in K
            /R   K   divide the numbers in K by the gcd
         j\/         join the two numbers by "/" and print

dang, forgot about gcd, knew there was something I missed

+0r1_2 is shorter than /R2r2_2.

I think to be fair it should be the 89/512 version that you count.

@Lembik O.k. Changed it.

I have to admit, it never occurred to me this could be done in 47 characters!

44 bytes is very impressive! Accepted as the winner.

Mathematica, 159 100 87 86 85 bytes
n=3;1-Mean@Sign[##&@@Norm/@({1,0,0,-1}~t~n.Partition[#,2,1,1])&/@{1,-1}~(t=Tuples)~n]

To change n just change the variable definition at the beginning.
Since it's brute force it's fairly slow, but here are the first eight results:
n   P(n)
1   1/2
2   3/8
3   7/32
4   89/512
5   269/2048
6   903/8192
7   3035/32768
8   169801/2097152

The last one already took 231 seconds and the runtime is horribly exponential.
Explanation
As I said it's brute force. Essentially, I'm just enumerating all possible A and B, compute the two dot products for every possible pair and then find the fraction of pairs that yielded {0, 0}. Mathematica's combinatorics and linear algebra functions were quite helpful in golfing this:
{1,-1}~(t=Tuples)~n

This generates all n-tuples containing 1 or -1, i.e. all possible A. For n = 3 that is:
{{1, 1, 1},
 {1, 1, -1},
 {1, -1, 1},
 {1, -1, -1},
 {-1, 1, 1},
 {-1, 1, -1},
 {-1, -1, 1},
 {-1, -1, -1}}

To compute B we do almost the same:
{1,0,0,-1}~t~n

By repeating 0, we duplicate each tuple for each 0 it contains, thereby making 0 twice as likely as 1 or -1. Again using n = 3 as an example:
{{-1, -1, -1},
 {-1, -1, 0}, {-1, -1, 0},
 {-1, -1, 1},
 {-1, 0, -1}, {-1, 0, -1},
 {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 {-1, 0, 1}, {-1, 0, 1},
 {-1, 1, -1},
 {-1, 1, 0}, {-1, 1, 0},
 {-1, 1, 1},
 {0, -1, -1}, {0, -1, -1},
 {0, -1, 0}, {0, -1, 0}, {0, -1, 0}, {0, -1, 0},
 {0, -1, 1}, {0, -1, 1},
 {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1},
 {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
 {0, 0, 1}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1},
 {0, 1, -1}, {0, 1, -1},
 {0, 1, 0}, {0, 1, 0}, {0, 1, 0}, {0, 1, 0},
 {0, 1, 1}, {0, 1, 1},
 {1, -1, -1},
 {1, -1, 0}, {1, -1, 0},
 {1, -1, 1},
 {1, 0, -1}, {1, 0, -1},
 {1, 0, 0}, {1, 0, 0}, {1, 0, 0}, {1, 0, 0},
 {1, 0, 1}, {1, 0, 1},
 {1, 1, -1},
 {1, 1, 0}, {1, 1, 0},
 {1, 1, 1}}

Now, for each possible A, we want the dot product of each of those possible B, both with A[1 .. n] and A[2 .. n+1]. E.g. if our current A is {1, 1, -1}, we want the dot product with both {1, 1, -1} and with {1, -1, 1}. Since all our B are already conveniently the rows of a matrix, we want the two sublists of A as columns of another matrix, so that we can compute a simple dot product between them. But transposing {{1, 1, -1}, {1, -1, 1}} simply gives {{1, 1}, {1, -1}, {-1, 1}} which is just a list of all 2-element cyclic sublists of A. That's what this does:
Partition[#,2,1,1]

So we compute that and take the dot product with our list of B. Since we now get a nested list (since each possible A yields a separate vector), we flatten those with ##&@@.
To find out if a pair {x, y} is {0, 0} we compute Sign[Norm[{x,y}]]  where Norm gives √(x²+y²). This gives 0 or 1.
Finally, since we now just want to know the fractions of 1s in a list of 0s and 1s all we need is the arithmetic mean of the list. However, this yields the probability of both at least one dot product being non-zero, so we subtract it from 1 to get the desired result.

Pyth - 65 55 bytes
Fixed bug with fraction reduction at cost of one byte.
Uses brute force approach, and can be golfed hugely, but just wanted to get something out there. Very slow
*F-KP/Jmms*Vked,thdPhd*makhk^,1_1Q^[1ZZ_1)Q,ZZ2/lJ^2/K2

It uses Cartesian products to generate both A and B, doing the variable probabilities by making 0 appear twice in the source list and then counts the ones that inner product to zero. The inner product is make easy by the Vectorization syntactic sugar. Simplifing the fraction was scaring me initially, but it was pretty easy with the Prime Factorization function and the realization that we only have to reduce by powers of 2.
Try it online here.

How do I change n?

@Lembik The Pyth program requests a user input, which is specified in the second textbox (If you use the online compiler).

@Jakube Oh thanks! And it actually seems to work too :)

CJam, 58 57 54 51 46 bytes
WX]m*Zm*_{~.+2,@fm<\f.*::+0-!},,__~)&:T/'/@,T/

To run it, insert the desired integer between WX] and m*.
Thanks to @jimmy23013 for the bit magic and for golfing off 5 bytes!
Try it online in the CJam interpreter.
Idea
Most parts of these answer are straightforward, but it uses two neat tricks:

Instead of pairing all vectors of {-1, 1}n with all vectors of {-1, 0, 1}n with the desired probabilities, it considers counts the number of triplets of vectors in {-1, 1}n that satisfy a certain condition.
If we add the last two vectors of a triplet, the result will be a vector of {-2, 0, 2}n.
Since (-1) + 1 = 0 = 1 + (-1), 0s will occur twice as often as -2s and 2s.
Dividing each component by 2 would yield a vector of {-1, 0, 1}n with the desired probabilities.
Since we are only interested if the scalar product is 0 or not, we can skip the division by 2.
After counting all triplets satisfying the condition of the question and the total number of triplets, we have to reduce the resulting fraction.
Instead of calculating the GCD of both numbers, since the denominator will always be a power of 2, it suffices to divide both numbers by the highest power of 2 that divides the numerator.
To obtain the highest power of 2 that divides x, we can take the bitwise AND of x and ~x + 1.
~x reverses all bits of x, so all trailing 0s become 1s. By adding 1 to ~x, those 1s will turn back into 0s and the last 1 in ~x + 1 will match the last 1 in x.
All other bits are either both 0 of distinct, so the bitwise AND return the integer consisting of the last 1 of x and all 0s that follow it. This is the highest power of 2 that divides x.

Code
WX]    e# Push the array [-1 1].
       e# Insert N here.
m*     e# Cartesian product: Push the array of all vectors of {-1,1}^N.
Zm*    e# Cartesian product: Push the array of all triplets of these vectors.
_      e# Copy the array.
{      e# Filter; for each triplet of vectors U, V and W in {-1,1}^N:
  ~    e#   Dump U, V and W on the stack.
  .+   e#   Compute X := V + W, a vector of {-2,0,2}^N, where each component is
       e#   zero with probability 1/2.
  2,@  e#   Push [0 1]. Rotate U on top of it.
  fm<  e#   Push [U U'], where U' is U rotated one dimension to the left.
  \f.* e#   Push [U*X and U'*X], where * denotes the vectorized product.
  ::+  e#   Add the components of both products.
  0-   e#   Remove zeroes.
       e#   Push the logical NOT of the array.
},     e#   If the array was empty, keep the triplet.
,      e# Push X, the length of the filtered array.
__~)&  e# Push X & ~X + 1.
:T     e# Save the result in T and divide X by T.
'/     e# Push a slash.
@,T/   e# Dividet he length of the unfiltered array by T.

WX]m*Zm*_{~.+2,@fm<\f.*::+0-!},,__W*&:T/'/@,T/.

@jimmy23013: That's some impressive bit magic. Thanks!


text:
The hourglass challenge
The Hourglass
This hourglass has 60 "sands of time", and it completely fills each chamber. The clock is 19 characters wide and 13 characters in height. Each chamber has 5 rows of sand and there is a row in the centre that can hold 1 sand. The top row can hold 17 sands, the next one 15 and so on (see below). Sands fall in to the bottom chamber at the rate of one sand per second.
       START                     3 SECONDS LATER               38 SECONDS LATER

███████████████████            ███████████████████            ███████████████████
█.................█   17       █..............   █   14       █                 █    0
██...............██   15       ██...............██   15       ██               ██    0
███.............███   13       ███.............███   13       ███.......      ███    7
█████.........█████   09       █████.........█████   09       █████.........█████   09
███████.....███████   05       ███████.....███████   05       ███████.....███████   05
█████████.█████████   01       █████████.█████████   01       █████████.█████████   01
███████     ███████            ███████  .  ███████            ███████  .  ███████
█████         █████            █████    .    █████            █████    .    █████
███             ███            ███      .      ███            ███....         ███
██               ██            ██               ██            ██...............██
█                 █            █                 █            █.................█
███████████████████            ███████████████████            ███████████████████

The Challenge
Display the hourglass (no numbers or headings are required) after a certain period of time (0 ≤ t ≤ 60).
Coding Rules

The hourglass should look exactly as shown here. You may replace the █ character and/or the . character with whatever you like to fit your language (Unicode, ASCII compatibility issues).
The input should be a number such as 45 or 7. Display the clock after these many seconds.
The output can either be displayed or saved to a file. No extra text or labels as shown above are required - just the hourglass is all we need.
If the user enters t > 60, you don't have to handle the error.

Points

Shortest code wins.

I don't know if it's just me, but the hourglasses looks completely different in the editor than in the post itself. That's probably because the █ character doesn't get displayed with the proper width.

Does a grain of sand touch the current layer, then align to the left one second later?

@xnor You are free to choose.

What should be the output for t==59?

Congrats on making the Stack Exchange Hot Network Questions list!

@AlexA. Oh that is great, I am humbled. hehe.. but I don't know what " Hot Network Questions" are. Where can I find that?

@RenaeLider: They appear along the right side of the page in the form of a site icon and a question title, visible from all Stack Exchange sites. You can also see the list on the Stack Exchange questions homepage.

Interesting. Just 7 answers. The slightly similar Code Golf: Hourglass on [SO] was more popular.

This is not really an answer, as it doesn't fit the specs, but take a look here for a submission in Desmos. (Press the play button and set the speed to 0.15x for ~1 unit/second)

JavaScript (ES6), 203  208 233 270 256 characters
Edit Revised using a loop instead of a sequence of calls.
Edit Added top and bottom row that were missing.
A function returning the output. Run the snippet in Firefox to test.

f=w=>[h='█'[R='repeat'](19),...[17,15,13,9,5,1,5,9,13,15,17].map((d,i)=>(t=i>5?-v:v,v-=i<5?d:1-d,e=' '[R](d/2),b='█'[R](10-d/2),b+('.'[R](t<d&&d-t)+e+' .'[i>4&w>i-6&t>=d|0]+e).slice(0,d)+b),v=w),h].join`
`

// Less golfed
F=
w=>[h='█'.repeat(19),
    ... [17, 15, 13, 9, 5, 1, 5, 9, 13, 15, 17].map(
     (d,i) => (
       t = i>5 ? -v : v,
       v -= i<5 ? d : 1-d,
       e = ' '.repeat(d / 2),
       b = '█'.repeat(10 - d / 2),
       b +
        ('.'.repeat(t < d && d - t)
         + e + ' .'[i > 4 & w > i-6 & t >= d | 0]
         + e).slice(0,d)
       + b
     ), v = w
    ),
    h].join('\n')

// TEST

O.innerHTML=f(+I.value)

function tick(d) {
  var i=+I.value+d
  I.value=i
  O.innerHTML=f(i)
}

var int=0;

function auto()
{
  function go()
  {
    var t = I.value;
    O.innerHTML=f(++t)
    if (t>70)t=0;
    I.value = t;
  }
  if (A.checked && !int)
  {
    int = setInterval(go, 200);
  }
  else if (!A.checked && int)
  {
    clearInterval(int);
    int = 0;
  }
}
input[type=text] { width: 3em }
<button onclick='tick(-1)'>-</button>
<input type=text id=I value=0 onchange='tick(0)' >
<button onclick='tick(1)'>+</button>
<input type=checkbox id=A onclick='auto()'>Fly time

For my curiosity, why was this downvoted twice? I can find no problem with it.

This answer is awesome! Open it in Firefox, people!

Good answer, but the top and base of the hourglass seems to be missing.

@manatwork not sure (of course) but there was a flaw indeed

Please make a setInterval(), javascript would be great for that: setTimeout( tick, 1000);

@Martijn done, just a little faster ...

Now it should be nice if downvoters could change their minds ...

Did template literals exist back in 2015? Because if so, you can swap the join('\n') for joinBacktickNewlineBacktick.

@user2428118 yes they did, FireFox 34, december 2014. Good hint, thanks

Python 2, 200
t=input()+1
s=' '*t+'.'*60+' '*70
n=0
d=sum((1<t<56,2<t<48,3<t<36,4<t<22))
for c in'ctrplhdhlprtc':i=ord(c)-99;print[s[n+i:n:-1],[s[180-n-i+d:][:i],'.'][5+d*3>i>0]][n>59].center(i).center(19,'#');n+=i

xnor has made a 197 byte version in the chat.
I would post an explanation, but I've lost track of how it actually works...
Also, here's an animated version with curses:

from curses import*
w=initscr()

for t in range(1,61):
    s=' '*t+'.'*60+' '*70
    n=0
    d=sum((1<t<56,2<t<48,3<t<36,4<t<22))
    for i in 0,17,15,13,9,5,1,5,9,13,15,17,0:w.addstr([s[n+i:n:-1],[s[180-n-i+d:][:i],'.'][5+d*3>i>0]][n>59].center(i).center(19,'#')+"\n");n+=i
    w.refresh()
    w.clear()
    napms(999)

endwin()

kudos, You made me discover that strings have a center() method !

Python 2.7, 362 356 347
e,c,x,a,b,n=' .#ab\n';R,r,s,l,T,m=range,str.replace,'',19,[1,2,3,5,7,9],-1
for t in[T,T[:m][::m]]:s+=''.join([n+x*y+c*(l-y*2)+x*y for y in t]);c=b
s=list(s)
for i in R(130,220,20):s[i]=a
for _ in R(input()):s[s.index('.')]=e;i=s.index(a)if a in s else 219-s[::m].index(b);s[i]='.'
for l in(x*l+r(r(''.join(s),a,e),b,e)+n+x*l).split(n):print l[::m]

Output at 38 seconds :
###################
#                 #
##               ##
###.......      ###
#####.........#####
#######.....#######
#########.#########
#######  .  #######
#####    .    #####
###...   .      ###
##...............##
#.................#
###################

What kind of Python code is that? I would love to learn to code like them. Please guide in right direction.

I am not sure if this is a valid answer. If you look at the example he made for 38seconds, you can see that the lowest dot which is still falling is not in the line where the dots align. (in the 4th line from bottom, at the center)

@RononDex : As explained in the question's comments, the filling order is not so strict - my implementation sticks the grains of sand to the left in a way that is slightly different from the question, but still valid

C 544
Here's what I have so far for a C solution.
#include <stdio.h>
int main(int z,char **a){int r,i,y=i=0,v,d,t,m,s=atoi(a[1]),n[13]={0,43,28,15,6,1,0,1,5,13,25,39,0};char H[13][20];while(y<13){int x,b=x=i=0;v=y-6;t=3+abs(v);m=2*abs(v);d=t<m?t:m;d=9-d;if(d==0)d=10;while (b<d){H[y][b]='#';H[y][18-b]='#';b++;}while(x<19-2*b){if(x<=s-n[y])H[y][x+b]=v>0?' ':'.';else H[y][x+b]=v>0?'.':' ';x++;}if(s>58)r=0;else if(s==58)r=1;else if(s==57)r=2;else if(s==56)r=3;else if(s>38)r=4;else if(s>24)r=3;else if(s>12)r=2;else if(s>4)r=1;while(i<r){H[7+i][9]='.';i++;}H[y][19]='\n';y++;}fputs(H,stdout);}

Compiled with the following command:
gcc -w -o hourglass hourglass.c  // I realize I should have cast H as a char *, but since it works this way, I just decided to suppress the error from the compiler instead to save space.

Admittedly, this language has a lot of bulk- that include statement was a bit of a handicap coming right out of the blocks, but I really was just looking for an excuse to practice using C.
I hope you like my solution, and let me know if you see ways to improve.

There's a lot a ways to improve, making it worse C but a lot shorter.

Hints: for instead of where,?: instead of if else, global int variables don't need int, include not needed. (I like your math)

317: r,i,y,x,b,d,n[]={0,43,28,15,6,1,0,1,5,13,25,39,0};char H[14][20];main(s,a)char**a;{for(s=atoi(a[1]);y<13;){b=x=i=0;d=abs(y-6);d+=3<d?3:d;d=9-d?9-d:10;r=s>55?59-s:s>38?4:s>24?3:s>12?2:s>4?1:r;for(;b<19;)H[y][b++]=35;for(;x<19-2*d;x++)H[y][x+d]=(x>s-n[y]?" .":". ")[y>6];for(;i<r;)H[7+i++][9]=46;H[y++][b]=10;}puts(H);} (beware, strange invisible chars are added to long comments like this)

Matlab, 252 bytes
The idea is constructing a matrix that looks like this:
0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
0  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0
0   0  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18   0   0
0   0   0  45  44  43  42  41  40  39  38  37  36  35  34  33   0   0   0
0   0   0   0   0  54  53  52  51  50  49  48  47  46   0   0   0   0   0
0   0   0   0   0   0   0  59  58  57  56  55   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0   0  60   0   0   0   0   0   0   0   0   0
0   0   0   0   0   0   0 116 117  61 118 119   0   0   0   0   0   0   0
0   0   0   0   0 108 109 110 111  62 112 113 114 115   0   0   0   0   0
0   0   0  96  97  98  99 100 101  63 102 103 104 105 106 107   0   0   0
0   0  82  83  84  85  86  87  88  64  89  90  91  92  93  94  95   0   0
0  66  67  68  69  70  71  72  73  65  74  75  76  77  78  79  80  81   0
0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0

From there it is easy to fill the entries with the strings dependent on n (filling all entries that are greater than n and smaller than n+60 with dots)
function c=f(n);
b=zeros(13,19);
z=[0,17,32,45,54,59];
y=-2:3;
for k=2:6;
    d=k+sum(k>4:5);
    b(k,d:20-d)=z(k):-1:z(k-1)+1;
    b(14-k,d:19-d)=68+(z(k-1):z(k)-2)-k;
end;
b(8:12,11:19)=b(8:12,10:18);
b(7:12,10)=60:65;c=[ones(13,19)*32,''];
c(~b)='¶';c(nn+60)=32

For n=38 we get this output:
¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶
¶                 ¶
¶¶               ¶¶
¶¶¶.......      ¶¶¶
¶¶¶¶¶.........¶¶¶¶¶
¶¶¶¶¶¶¶.....¶¶¶¶¶¶¶
¶¶¶¶¶¶¶¶¶.¶¶¶¶¶¶¶¶¶
¶¶¶¶¶¶¶  .  ¶¶¶¶¶¶¶
¶¶¶¶¶    .    ¶¶¶¶¶
¶¶¶...   .      ¶¶¶
¶¶...............¶¶
¶.................¶
¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶

Java, 712
Input  is taken from the command line. Handles both negative values for the time as well as larger than required.
enum H{;public static void main(String[]r){int x=0,y=0,z=0,l,t=Integer.parseInt(r[0]);String b="",d="█",e=" ",f=".",n="\n",j,k,a="███████████████████"+n;int[]w={17,15,13,9,5},v;int[][]h=new int[10][];for(;x<5;){l=w[x];v=(h[x++]=new int[l--]);l/=2;v[l]=++z;for(y=0;y++<l;){v[l-y]=++z;v[l+y]=++z;}}for(z=0;x>0;){l=w[--x];v=(h[9-x]=new int[l--]);v[l/2]=++z;}for(;x<5;){l=(w[x]-1)/2;v=h[9-x++];for(y=0;y++<l;){v[l-y]=++z;v[l+y]=++z;}}p(a);for(x=0;x<5;x++){l=w[x];j=b;for(y=0;y++*2<19-l;)j+=d;k=b;for(y=0;y<l;)k+=t<h[x][y++]?f:e;p(j+k+j+n);}j="█████████";p(j+f+j+n);for(;x>0;){l=w[--x];j=b;for(y=0;y++*2<19-l;)j+=d;k=b;for(y=0;y<l;)k+=t<h[9-x][y++]?e:f;p(j+k+j+n);}p(a);}static void p(String s){System.out.print(s);}}

output:
time: 0
███████████████████
█.................█
██...............██
███.............███
█████.........█████
███████.....███████
█████████.█████████
███████     ███████
█████         █████
███             ███
██               ██
█                 █
███████████████████

time: 1
███████████████████
█........ ........█
██...............██
███.............███
█████.........█████
███████.....███████
█████████.█████████
███████  .  ███████
█████         █████
███             ███
██               ██
█                 █
███████████████████

time: 9
███████████████████
█....         ....█
██...............██
███.............███
█████.........█████
███████.....███████
█████████.█████████
███████  .  ███████
█████    .    █████
███      .      ███
██       .       ██
█      .....      █
███████████████████

time: 41
███████████████████
█                 █
██               ██
███..         ..███
█████.........█████
███████.....███████
█████████.█████████
███████  .  ███████
█████    .    █████
███   .......   ███
██...............██
█.................█
███████████████████

It fills the sand from the center expanding outwards. I can probably golf it more if I get lazy with how it fills the bottom half and empties the top half. But for now I quite like it.

Haskell 512 Bytes
h=[17,15,13,9,5,1];b=drop 1$reverse h;n#s=[1..n]>>[s];s='.';n =' ';c q=(q#n)++(60-q)#s;f q|q<=5=q#s|3>2=g#s where{g=foldl i 5 (scanl (+) 0 h);i x y=if q>x+y then x-1 else x};e q=j#s++(59-length(k q)-(j))#n where{j=q-length(f q)};l q=c q++k q++(reverse$e q);p _ []=[];p x y=reverse(z++take q x++z):p (drop (head y) x) (tail y)where{q=head y;z=replicate(div (19-q) 2) '|'};k q= (concat.map(\x -> z x ++ "." ++ z x).take (length.f$q)$b)where{z x=(div x 2)#n};m n=mapM_ putStrLn $ t ++ p (l n) (h++b) ++ t;t=[19#'|']

Input m 55
Output
|||||||||||||||||||
|                 |
||               ||
|||             |||
|||||         |||||
|||||||.... |||||||
|||||||||.|||||||||
|||||||  .  |||||||
|||||.........|||||
|||.............|||
||...............||
|.................|
|||||||||||||||||||

Input m 48
Output
    |||||||||||||||||||
    |                 |
    ||               ||
    |||             |||
    |||||......   |||||
    |||||||.....|||||||
    |||||||||.|||||||||
    |||||||  .  |||||||
    |||||..       |||||
    |||.............|||
    ||...............||
    |.................|
    |||||||||||||||||||

Welcome to PPCG! I see you already golfed this quite a bit, but there is still a lot of unnecessary white space left, eg. surrounding ++. Also you may save some bytes by predefining length and reverse.

Ruby: 196 190 186 185 184 characters
u=[0,17,15,13,9,5].map{|i|(?.*i).center 19,?#}*$/
(?1..$*[0]).map{u[?.]=' '}
l=u.reverse
5.times{|i|l[p=i*20+9]==?.&&l[' ']&&(l[p]=?|)&&l[' ']=?.}
puts u,?#*9+?.+?#*9,l.tr('. | ',' .')

CW because not conforms exactly to the posted samples as this consumes sand starting from the left. Mostly just a demonstration of String.[]= method.
Sample run:
bash-4.3$ ruby hg.rb 38
###################
#                 #
##               ##
###      .......###
#####.........#####
#######.....#######
#########.#########
#######  .  #######
#####    .    #####
###      .   ...###
##...............##
#.................#
###################

Ruby: 215 characters
This is generates the exact required output:
u=[0,17,15,13,9,5].map{|i|(?.*i).center 19,?#}*$/
(?1..$*[0]).map{u[?.]=' '}
l=u.reverse
5.times{|i|l[p=i*20+9]==?.&&l[' ']&&(l[p]=?|)&&l[' ']=?.}
puts ([u,?#*9+?.+?#*9,l.tr('. | ',' .')]*$/).split($/).map &:reverse

Sample run:
bash-4.3$ ruby hg.rb 38
###################
#                 #
##               ##
###.......      ###
#####.........#####
#######.....#######
#########.#########
#######  .  #######
#####    .    #####
###...   .      ###
##...............##
#.................#
###################

C#, 382 410
it might still be possible to reduce it by a few bytes...
class Program{static void Main(){int u=60-22,d=u,i,j,k,l,m;var c=new char[260];var r=new int[]{0,17,15,13,9,5,1,5,9,13,15,17,0,54,45,32,17,0};for(i=0;i<13;){m=0;l=(19-r[i])/2-1;for(j=19;j>=0;){k=i*20+j--;var b=j>=l&&j<r[i]+l;if(i>6&b)c[k-r[i]+m++ +m]=r[i+6]<d&&d-->0||j==8&r[i+6]>d&&d-->0?'.':' ';else c[k]=i<7&b?u-->1?' ':'.':'█';}c[++i*20-1]='\n';}System.Console.WriteLine(c);}}

Fiddler - 38sec

Cool! How does it take input?

@isaacg, oops, i will fix that later today, i knew it was too short for a c# solution :-) for now change u=60-22 to something else

Why you use int u=60-22 and not just int u=38??


text:
Compact XML Parser
Goal:
The goal of this challenge is to take a simple 6 row by 6 column XML file (without the standard XML header) and parse it out so that the program can return the value of a cell given it's coordinates.
The entry with the shortest overall length by language and overall will be declared the winner.
Additional information:
The XML syntax will always be an HTML table with each inner level being indented by four single spaces. You may assume that every file put into the program will be exactly like the one given below.
If your program uses imports you do not need to include them in the golfed version of your code but you must submit a copy of the program in the explanation that shows all imports used. This explanation will not effect your entries byte count.
Rules:

The XML file cannot be hardcoded
XML libraries/functions cannot be used

Extra Credit:

Can pretty print the table if given the --all flag (20 bytes off of total)
Can print all entries of a column given the column number in --col=number (20 bytes off of total)
Can print all entries of a row given the row number in --row=number (20 bytes off of total)
Can parse any size file as long as #rows = #columns (40 bytes off of total)

XML File:

        Foo
        Bar
        Baz
        Cat
        Dog
        Grinch

        Something
        Something
        Darkside
        Star
        Wars
        Chicken

        Star
        Trek
        Xbox
        Words
        Too
        Many

        Columns
        Not
        Enough
        Words
        To
        Fill

        Them
        So
        I
        Will
        Do
        My

        Best
        To
        Fill
        Them
        All
        Up

Putting aside the ban on golfing languages (this is a golf site after all), I'm not sure any of those bonuses are worth it. Maybe the last one in some languages (esp golf langs, which are banned), but parsing flags and doing something with them will take more than 2 bytes any way I see it. Honestly, the rule setup looks like you're just outsourcing a useful program.

I agree with you on the bonuses so I upped their value x10. As for the flags I am going off an observation that most programs are written to where they can accept these so I feel like if they person wants they should be given some incentive to use them. As for outsourcing I don't want to allow golfing languages because I want to see a program in a language that isn't designed to be ridiculously compact.

You don't have to ban languages for that. I golf in Java personally, and others here use C#, python, etc... If you want a variety of languages, the easiest thing is to just pose an interesting challenge, with less emphasis on "full header/program", "must be able to accept arguments", "no golf langs", etc. Seemingly arbitrary rules (whether you feel them to be arbitrary or not) puts people off answering at all, regardless of language.

I see your point, I will be altering the rules to get rid of those restrictions. As for full headers I think those should stay as it means that every byte of your working program is exposed and can be tested. Though I could move that so that it is only required in an explanation and not within the code itself.

If the input file format is so constrained, a single regular expression can give you a given row and a given column inside that row. And for any number of rows and columns

Then that would be a valid answer.

This is several months old and you are the only one to reply. Does voting matter? If so I have upvoted your answer.

JavaScript (ES6), 158 bytes
A function, parameters:

xml
row number (1 to n)
col number (1 to n or 0 to get the whole row as an array)

It works with an xml string with any number of rows and columns (formatted as in the example, no extra tags inside rows or cells).
I don't claim any bonus as the input mode is not what requested (--row=, etc)
Using this same expression in any language that implements regexps (perl maybe) you can have a stand-alone program.
Test running the snipper below (ES6 so Firefox only)

F=(t,r,c)=>(
  m=t.match(RegExp(`(<tr>(\\s*<th>(.*?)</th>\\s*){${c}}[\\s\\S]*?</tr>\\s*){${r}}`,"i")),
  c?m[3] // single cell
  :m[1].split(/(.*?)<\/th>/g).filter((v,i)=>i&1) // clean row value
)

// test

function test()
{
  var r=+R.value, c=+C.value, t=T.value
  X.value=F(t,r,c)
}
#X { width: 440px; }
#T { width: 440px; height: 10em; }
#R,#C { width: 3em; }
Row: <input id=R value=1> (1 ... n)
Col: <input id=C value=1> (1...n, 0 for whole row)
<button onclick="test()">Get</button>

<input readonly id=X>

Xml:

<textarea id=T>

        Foo
        Bar
        Baz
        Cat
        Dog
        Grinch

        Something
        Something
        Darkside
        Star
        Wars
        Chicken

        Star
        Trek
        Xbox
        Words
        Too
        Many

        Columns
        Not
        Enough
        Words
        To
        Fill

        Them
        So
        I
        Will
        Do
        My

        Best
        To
        Fill
        Them
        All
        Up

</textarea>