text:
Tiling the unit square
Background
By expanding and cancelling terms, it is easy to show the following identity:

However, it is an open problem whether all 1/n-by-1/(n+1) rectangles can tile the unit square.
The Task
Your program should take a positive integer N as input in any convenient manner, and pack all 1/n-by-1/(n+1) open rectangles with n between 1 and N inclusive into the unit square, such that no two overlap.
For each rectangle you must generate the following integers in order:

1 if the horizontal edges are longer than the vertical edges, else 0
The numerator and denominator of the x-coordinate of the bottom-left corner
The numerator and the denominator of the y-coordinate of the bottom-left corner

Note that we take the unit square to be (0, 1) x (0, 1), with x-values running from left to right, and y-values running from bottom to top.
The final expected output is the concatenation of these integers for each rectangle in order of increasing n, in any convenient format (e.g. printed to stdout, or as a list returned from a function).
Example Input and Output
Input:
3

Output:
0 0 1 0 1 1 1 2 0 1 1 1 2 1 3

This parses as the following:
0 (0/1, 0/1)  1 (1/2, 0/1)  1 (1/2, 1/3)

Scoring
This is a code-golf challenge, so the answer with the fewest bytes wins. However, your algorithm should also be reasonably efficient; it should be able to run for all N<=100 in a total of around 10 minutes.
Your solution must give valid solutions for all N<=100, but provably complete algorithms are also welcome even if they aren't the shortest.

Seeing as this is an open problem, is there a cap on the largest value of $N$ for which our algorithm must be guaranteed to work?

@GregMartin you should successfully run your program for N from 1 to 20. Brownie points if your algorithm can be proven to either succeed or disprove the conjecture.

For N≤20 the output can just be hardcoded ... is it your intention to allow that? There is a simple published algorithm that allows at least N=1,000,000,000....

OK, I changed the threshold from 20 to 100.

Oh, Goodness. I have not yet learnt sum to infinity, thus I do not understand this at all.

@SIGSEGV This isn't really a Riemann sum (there's no x or Δx). It's just the infinite series (1/1)(1/2) + (1/2)(1/3) + (1/3)(1/4) + ... which equals 1/2 + 1/6 + 1/12 + .... See series, and integral. Looking at the Partial sum formula of the integral, you can see that as m => ∞ that the result is 1.

@user1502040 Can you perhaps add a graphical picture of your example? I think that'd help.

@mbomb007 Oh no. Calculus. I didn't learn that too.

Haskell, 263 262 bytes
import Data.Ratio;f m=let{(#)n z|n>m=[[]]|True=[a:y|(a,j)<-[((o,x,y),[c|c<-(u&w,h-v,x,g):(w-u,h&v,a,y):z,c/=b])|b@(w,h,x,y)<-z,(o,u,v)<-[(o,1%(n+1-o),1%(n+o))|o<-[0,1]],(a,g)<-[(x+u,y+v)|u<=w,v<=h],let(&)p q|w>h=p|True=q],y<-(n+1)#j]}in(1#[(1%1,1%1,0%1,0%1)])!!0

This follows the algorithm described in Paulhus 1997, An Algorithm for Packing Squares, doi:10.1006/jcta.1997.2836. The key observation in the paper, which is empirically if not theoretically verified, is that the region left over after placing a rectangle in a box can be split into two sub-boxes whose filling can then in turn be regarded as independent.
Rather than finding the smallest width sub-box to fit the next rectangle into, the code performs a search across all possible sub-boxes; in practice this does not make an appreciable slow down for n<100.
Output is in the form of a list of entries as tuples with the fraction marker % still included. The integers in the formatted output are in the desired order, but strictly speaking some post-processing would be required to produce the list of integers alone.
Sample run:
*Main> f 5
(0,0 % 1,0 % 1),(0,1 % 2,0 % 1),(0,1 % 2,1 % 2),(0,3 % 4,1 % 2),(1,1 % 2,5 % 6)
Edit: removed an errant space after a let.


text:
Two roads diverged in a yellow wood (part 1)
This is the first in a series, the second is Two roads diverged in a yellow wood (part 2)
This challenge is inspired by Robert Frost's famous poem, "The Road Not Taken":

Two roads diverged in a yellow wood,
  And sorry I could not travel both
  And be one traveler, long I stood
  And looked down one as far as I could
  To where it bent in the undergrowth;
Then took the other, as just as fair,
  And having perhaps the better claim,
  Because it was grassy and wanted wear;
  Though as for that the passing there
  Had worn them really about the same,
And both that morning equally lay
  In leaves no step had trodden black.
  Oh, I kept the first for another day!
  Yet knowing how way leads on to way,
  I doubted if I should ever come back.
I shall be telling this with a sigh
  Somewhere ages and ages hence:
  Two roads diverged in a wood, and I —
  I took the one less traveled by,
  And that has made all the difference.

Notice the second to last line, I took the one less traveled by,.
Your actual challenge
You will take input in the form like:
#     ##
 #   ##
  # ##
   #
   #
   #

and you have to find the thinner road.
The road starts at the bottom with a #. The other 2 roads, which always terminate on the top row, are the roads you have to examine. The road that is the thickest is most traveled by, and therefore it is not what you want. The other one is the least traveled by, and it is the one you want.
Output
Your program/function must output one of 2 distinct values (eg. 0 or 1, true or false), one for each possible position of the road not taken. For example, you could output 0 if the road not taken is on the left of the road taken, and 1 otherwise, or you could output the string "left" or "right", true, false, etc.
Test cases:
 ##    #
  ##  #
   ###
    #
    #
    #

Might output "right".
 ##  #
  ## #
   ###
    ##
     #
     #
     #

Might output "right".
 ##  #
  ## #
   ###
    ##
   #
  #
 #

Might output "right".
 ##   #
  ## #
   ###
    #
   #
  #
  #

Might output "right".
 #    ##
  #  ##
   ###
    #
   #
  #
  #

Might output "left"
 #    ##
  #  ##
   ###
    #
     #
     #
     #

Might output "left"
Notes

This is code-golf, so the shortest answer in bytes wins
Standard loopholes forbidden
You must specify your outputs for "left" and "right" and they must be distinct
Input will be one big string, and may have any amount of lines
You don't need to worry about valid input.
The road is always a Y shape, so you only have to look at the top.
Have any questions? Comment below:

Lowest byte count wins!

What defines the thickness of a road (I assume it is horizontal crosssection)? Will the roads always be one and two wide?

Yes, always # and ##, and horizontal crosssection.

Is the road always a Y shape and never upside down? In that case, isn't it sufficient to only look at the top row? That kinda trivializes the problem.

Is it valid to replace actual newlines with the characters `\n" in the input?

Yes, it is valid.

@programmer5000 Don't be strict on the input. Some languages have to take input that way. The challenge should not be about the input format, but rather about the challenge you've described.

Why does this question have 2 upvotes and 2 downvotes?

Wasn't me. I quite like it. Well defined, good back story and clear examples. It's fairly easily doable and I think the idea of inviting obscure languages only adds extra flavour and could encourage some interesting answers.

IBM/Lotus Notes Formula Language and Acc!! responses are proof of how inviting obscure languages to easy questions leads to interesting results.

I was just saying to myself: "You know a challenge is simple when you think, 'Hey, this will be easy in Acc!!'" ;)

@programmer5000: I'm one of the downvoters. I downvoted the challenge because it's something of a chameleon challenge (in that it looks like it's about parsing or otherwise measuring the roads, but actually it's just "split on spaces, take the first section"), with a lot of background that's only tangentially related and to obscure the challenge still more; and because it's extremely easy (something that normally makes me downvote challenges). It's also incompletely specified (e.g. can inputs have widths other than 1 and 2?)

@programmer5000 is this comment correct? Can I return ' ' or #?

Sorry for another question, but I'm new to code golf. is removing the a=> making it no longer a function, and expecting an already defined variable of a to be defined valid?

@DavidArchibald The default policy is that submissions must be a function or a full program. Expecting the input in a predefined variable makes the code a snippet, which isn't allowed unless the OP specifically permits it.

Thanks, @DLosc. I thought I remembered seeing a challenge with an answer like that. Must've been stated by the OP.

Will the input string be gruaranteed to begin in a #? It is the case in all of the test cases...

@Mistah No, my test cases aren't great.

CJam, 1 byte
r

r puts the first string of adjacent non-whitespace characters from STDIN on the stack, so this prints ## for left and # for right.
Try it online!

This looks like the source code for Pokemon Go.

JavaScript(ES6), 19 14 bytes
a=>a.trim()[1]

Returns # for right and a space for left.
Original:
a=>a.trim()[1]=='#'

Explanation
Ungolfed:
function(input) {
  return input.trim().charAt(1) === '#';
};

The first thing this function does is remove white space the beginning and end of the input. This means that the first character is always #. Then from there I check the second character(JavaScript starts at 0) and see if it is a # character.
This returns a boolean. If the path is right it will be true, if it is left it will return false.
How I golfed it
In ES6 there is an anonymous function shorthand called an arrow function. This means that I can take my wrapper function and turn it into:
input => ...;

Due to the rules of arrow functions it will return the rest of the code. From there I converted charAt(1) to [1] as it is a shorter way, though not recommended. Then I took === and turned it into ==. While they are different in this case it doesn't matter. Finally, I renamed input to a and removed all whitespace.
Output right and left
While the puzzle doesn't actually need the program to output right and left, here's an example of other outputs:
a=>a.trim()[1]=='#'?'right':'left'

The only added part is ?'right':'left'. This creates a ternary operator, a condensed if statement, this means that the(ungolfed) code is equal to*:
function(input) {
  let output = input.trim().charAt(1) === '#';
  if(output) {
    return 'right';
  } else {
    return 'left'
  }
};

Example

// Function assignment not counted in byte count
let f =
a=>a.trim()[1]=='#'
<textarea placeholder="Put path in here" id="path" rows="10" style="width:100%"></textarea>
<button onclick="document.getElementById('result').textContent = f(document.getElementById('path').value)">Submit</button>

Welcome to the site! Nice explanation and snippet, it's a very thorough first answer. :)

Thanks. I've been surfing code golf for a while and finally decided to make one. Suppose its StackOverflow rubbing off on me.

Wow, totally outgolfed!

Your regex was a nice idea, but they're pretty space consuming. I saw that only the first 2 non-whitespace characters mattered and worked off of that.

That's a really cool approach. Hadn't thought of that one.

Could take three bytes off my answer by copying your idea but not going to post it. Enjoy the upvotes :)

@ElPedro Go ahead. The more the merrier. You could credit me and put your original as a second answer if you want to.

I think you can leave off =='#' and have the function return   or # instead of true or false, right? (Welcome to PPCG, BTW!)

I'll edit it as soon as @programmer5000 responds. It's a great idea, thanks.

Yes, that is allowed.

Acc!!, 30 bytes
Because of the way Acc!! takes input, it will give the output after just one line of input is entered. But if you pipe the input in or redirect it from a file, you shouldn't notice the difference.
Count i while 35-N {
}
Write N

Takes input from stdin. Outputs  if the left-hand road is less traveled, or # if the right-hand road is less traveled. Try it online!
Explanation
N reads the ASCII value of a character from stdin every time it is referenced. We loop while 35-N is truthy; that is, while 35-N != 0 or N != 35. Therefore, when the loop exits, we have just read the first # character on the line. The next character is then read with N and written back to stdout with Write.

Wow! Yet another obscure language...

@programmer5000 If you want obscure programming languages, you've come to the right site. ;)

Where can I run Acc!!? Is there a GitHub link, Tio, or other?

@programmer5000 The Python 3 source code is in the post I linked in the header, but I'll see if I can cobble together a TIO link for you.

@programmer5000 Added TIO link to the answer.

Pyth, 2 bytes
hc

Outputs # for left and ## for right.
Try it online
Explanation
hc
 cQ     Split the (implicit) input on whitespace.
h       Get the first part.

Retina, 5 bytes
Outputs 1 if right, 0 if left.
^ *##

Try it online

If the values for a positive result didn't have to be distinct (5 bytes):
Outputs a positive integer if right, zero if left.
## +#

Try it online

Wow! How does it work? Care editing your answer to explain?

@programmer5000 It just tests the input against the regular expression for a match.

IBM/Lotus Notes Formula Language, 37 35 26 bytes
Edit I always forget that @Like with wildcards is 2 bytes cheaper than @Contains.
Edit 2 Actually doesn't need the @if as it just prints 1 or 0 depending on whether the formula results to @True or @False.
@Like(@Left(a;"##");"%#%")

Computed field formula. Simply take everything to the left of the first ## it finds in field a and if there is a # in it outputs 1 for left otherwise outputs 0 for right.

With thanks to @DavidArchibald, here is a solution for 22 bytes. Out of respect for Davids solution I won't post it as my main answer.
@Left(@Trim(a);2)="##"

This one outputs 1 for right and 0 for left.

Wow! Quite the obscure language! May be accepted if a better answer does not come soon...

Used to be not so obscure in the good old days when I was a young(er) programmer ;-)

C, 35 bytes
f(char*s){while(35^*s++);return*s;}

Same idea as PragmaticProgrammer's answer: find the first #, and output what comes after it -- # for "right", and <space> for "left".
C (loophole), 16 bytes
According to the test cases, it looks like the left road is always exactly one space from the left margin. So...
#define f(s)2[s]

The loophole was not intended, those test cases were incorrect. But your C answer is impressive!

Pip, 8 6 bytes
a~`#+`

Takes input as a command-line argument (which will need quoting and escaping of newlines when run from an actual command line). Outputs # if the left-hand road is less traveled, and ## if the right-hand road is less traveled. Try it online!
Explanation
This uses Pip's recently added regex first-match operator.
a         First cmdline arg
 ~        Regex match the first instance of...
  `#+`    ...one or more #s (i.e. a cross-section of the left-hand road)
          Print (implicit)

The straightforward regex solution (a port of mbomb007's Retina answer) is 9 bytes:
`^ +##`Na

Did you count the command-line argument in the byte count?

@programmer5000 Taking input via command-line argument is an input method that is permitted by default (and is the usual way Pip gets input). The byte penalty applies to non-standard command-line flags, which I'm not using in this submission. That said, in this particular case, one could change the a to a q and get the input from stdin instead.

Oh. I didn't understand.

Chip, 7 bytes
AZ~S
at

Try it online!
Outputs 0x0 for left, and 0x1 for right. (The TIO includes flag -v so you can see the binary values in stderr. To see the output in ASCII, e*f can be appended to the end of the first line.)
Chip operates on individual bits within a byte stream, which actually makes it quite good at this specific problem.
A is the least significant bit of the input byte, and '#' is the only character of input for which this bit is set. When this bit is first encountered, we have reached the first '#' of the first line.
Z delays that signal for one cycle, so that we are now looking at the next character.
t is now activated, which means to terminate execution after this cycle is completed. We don't need to look further than the width of the first road.
~S suppresses output for all cycles except the final one. If this wasn't here, we'd get an output on every cycle.
a puts the current value of its neighbors (only A in this case) to the least significant bit of the output byte.
All of this means that we get a 0x1 if the first '#' is immediately followed by another '#', and 0x0 otherwise.

Batch, 46 bytes
@set/ps=
@for %%a in (%s%)do @echo %%a&exit/b

Reads one line from STDIN, splits it on spaces, and prints out the first word, so outputs # for left and ## for right. If an array of quoted command-line parameters is acceptable, then for 36 bytes:
@for %%a in (%~1)do @echo %%a&exit/b

Unquotes the first argument so that it will be split on spaces and print its first word.

Python 2, 21 bytes
Try it online
lambda S:S.split()[0]

Output # for left and ## for right

Brainfuck, 32 bytes
+[>,>+++++[<------>-]<--[,.>>]<]

Ungolfed:
+[                       while 1
>,>+++++[<------>-]<--     3 if hash; 0 if space
[,.>>]                     print next char and break iff current char is hash
<]

Prints # for right and  for left.
Try it online!

Haskell, 21 bytes
f n=snd$span(==' ')n!!1

or in point-free style:
(!!1).snd.span(' '==)

"#" means right, and " " means left
The function just takes a string, drops the beginning spaces, and then, it takes the second character (space if the left is skinny and # if the left is thick)
EDIT: Saved three bytes thanks to Laikoni and nimi!

Anonymous functions are acceptable too, so (!!2).dropWhile(' '==) suffices as answer.

It's !!1 for the 2nd element. You can shorten the test to <'!'. In the pointfree version, you can replace dropWhile by snd.span.

C 54 bytes
char*strchr();char c(char*s){return*(strchr(s,35)+1);}

C++ 58 bytes
#include<cstring>
char c(char*s){return*(strchr(s,35)+1);}

Since OP specified it can be a "program/function" I elected to write a function to save characters. However, I still included the "#include" statement and accompanying line break in the character count as they are required to compile the function.
Output
Returns a space " " character to indicate left, or a hash "#" character to indicate right.
Explanation
The strchr() function walks a given string and returns a pointer to the first occurrence of a specified character. It has an overload which accepts an integer as the second argument as opposed to a char which saves me 1 character. E.g. '#' can be replaced with 35.
I then add one to the pointer returned from the function to get the character immediately following, and dereference it, then return the resulting char.
Note
I would also like to take this opportunity to formally express my annoyance at Visual Studio auto-formatting my code when I'm trying to golf (╯°□°）╯︵ ┻━┻.
Edit: Thanks to Ray for pointing out some differences in C and C++ and where I could save characters <3.

C/C++ isn't a language: there are expressions that mean different things in C and C++.  For instance, in C++, if a function has an empty parameter list, it means that it takes no arguments.  Whereas in C, it means that the parameters are unspecified.  So if you decide this is a C program, you can replace #include <string.h>\n with char*strchr(); and save 6 bytes while still being perfectly legal.  (And if you prefer C++ for whatever reason, you can replace #include <string.h> with #include <cstring> and save 1 byte.)

Interesting, I wasn't aware of that. Updated my answer, thanks.

Retina, 5 bytes
!1`#+

Try it online!
An alternative 5-byte solution. Prints # for left and ## for right. The idea is to match all the runs of #s (#+) and print (!) only the first one of them (1).

JavaScript (ES6), 37 bytes
p=s=>/^ *#( |$)/.test(s.split("\n")[0])

Explanation:
p is a function that returns true if the road less traveled by is on the left and false otherwise. This is my first answer on this site, so it probably could be golfed more (maybe the regex.)
It works by taking the top line of the input and seeing if it matches the regex /^ *#( |$)/ (start of string, any amount of spaces, a #, and a space or end of string.)
This is just to give people clarification about the format and generate ideas. I am sure it can be beat and golfed further. Happy golfing!

p=s=>/^ *#[^#]/.test(s.split("\n")[0])
<textarea rows = "8" cols = "8" oninput = "console.log(p(this.value))"></textarea>

I think you can have a space instead of [^#]

Fixed regex issue.

I made a shorter Javascript answer.

Excel, 17 bytes
=left(trim(A1),2)

Assumes input in cell A1.
Returns ## for right and # (# and space) for left.

Java 8, 166 66 63 52 43 21 bytes
s->s.trim().charAt(1)

Outputs 35 for right and 32 for left.
Based on @Clashsoft's Dyvil answer.
Try it online.
Explanation:
s->           // Method with String parameter and integer return-type
  s.trim()    //  Remove leading and trailing whitespaces
   .charAt(1) //  and return the second character (as int value)

Perl 5, 8 + 1 = 9 bytes
die$F[0]

Try it online!
Run with -a (1 byte penalty).
Output is # at filename line 1, <> line 1 (where filename is the filename of the script) if the left road is less travelled, or ## at filename line 1, <> line 1 if the right road is less travelled.
Explanation
The -a option automatically reads input and splits it into columns around whitespace, ignoring leading whitespace. As such, the first datum of input is what we need; that's $F[0]. It also puts the program in an implicit loop, which we don't want. However, the use of die allows us to output a string, and exit the implicit loop, at the same time (and with no more characters than say, the more usual way to print a string).

Nice creativity and low byte count! Unfortunately, there is already a 2-byte answer. Are you interested in trying the third challenge in this series?

@programmer5000: I don't think there's a 2-byte answer in Perl (and, in fact, this is currently the shortest answer in a non-golfing language). Typically, we aim to find the best solution in each language / via each approach, otherwise there'd be no point in using anything other than a golfing language.

Dyvil, 12 bytes
s=>s.trim[1]

Explanation:
s=>          // lambda expression
   s.trim    // removes leading (and trailing) whitespace
         [1] // gets the second character

Usage:
let f: String -> char = s=>s.trim[1]
print f('...')

Returns  (whitespace) for left and # for right.

Japt, 3 bytes
x

(2 bytes for -g1 flag) Outputs # for right and a space for left. Based on the JavaScript answer by David Archibald.
Try it online!

Befunge 98, 11 bytes
-!jv~'
@.~<

Try it Online!
Prints 32  for left, and 35  for right, both with a single trailing space.
Explanation
-!jv      This is a no-op the first time through, but used later

    ~'    Pushes the ASCII value of the next character, and pushes 32
-!        Subtracts the 2, and nots. If the character was a space, the top will be 1
  jv      Goes to the second line if the character was not a space

  ~<      Pushes the next characer's ASCII value
 .        Prints it (32 for " " and 35 for "#")
@         Ends the program

One trick I used was putting the -!jv first, even though it didn't do anything. This let me both get rid of the space after the ' and saved some padding. With this last, the code would be
~' -!jv
   @.~<

for 15 bytes.

Ruby, 20 bytes
->r{r.strip[1]==' '}

Returns true for left, false for right.

Batch 34 bytes
Checks input file %1 using Find with conditional execution (&&=Success ||=Fail) and returns L or R depending on the presence of ## , which is only present when the road most travelled by is to the left.
@Find "## " %1>nul&&echo(R||echo(L

source: Stack Exchange

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

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

sort: votes


text:
How much time is remaining?
The Program
You are given two strings, A and B. A is the current position at which your timer is at, and B is the position at which your timer will stop. Both strings are in the format m:ss. You must write a program that determines the amount of time left which should also be formatted as m:ss or mm:ss.
Example
0:00 0:01 -> 0:01
0:55 1:00 -> 0:05
1:45 3:15 -> 1:30

In dc the input is read incorrectly, since : is a command (data as code philosophy). Am I allowed to use spaces instead or do I need to find other language to answer this?

is 01:30 valid output? (leading zero)

Yes, I'll accept that as valid. I'll edit the description.

@seshoumara The input must contain a colon.

What is the maximum value expected for m?

Maximum expected is 9. @DigitalTrauma

@obarakon, it is in format of minutes:seconds, not hours:minutes:seconds, so your solution isn't valid unfortunately.

Is the result guaranteed to be positive. so "3:15" "1:45"  is not considered valid input?

The result will always be positive

Excel, 6 Bytes
=B1-A1

Assuming A is in cell A1 and B is in cell B1

No... NO... I WILL NOT LET EXCEL WIN. +1 you devious individual.

Cancel that, |vy':¡ bootstrapped in 05AB1E, nothing I can do... I think Excel may honestly win this, nothing else automatically parses that format that I know of.

HOW? HOW? How is Excel winning? My brain must now explo...

If m is greater than 23, then the formatting doesn't seem to work.  For example if I type 45:45 in A1 and 22:22 in B1, then the result is 23:23:00 Edit Nevermind - max expected value for m is 9.

Someone file a feature request in 05AB1E.

This only works if you've formatted the cell with the formula, right? If it's formatted as "General" then the result is numeric by default and displays as a fraction of a day like 0.0625.

@EngineerToast Whatever the default formatting is worked for me. I just typed in the input, moved to a different cell, typed the formula and hit enter.

Ah, that's because typing in something that looks like a time automatically changes the value. Typing 1:45 and exiting the cell changes the cell value to 1:45:00 AM. Therefore, you're not sending strings into the function, you're sending time values. Try either prefixing the input with a backtick to force it as a string or formatting the cell to Text. That's when the formula as written spits out a numeric solution.

@DigitalTrauma, if the cell is formatted as [m]:ss, then it would work up to 9999 minutes

Excel is winning? Riley?

Excel not wins -- See Rebol solution :-)

MATL, 17 7 bytes
YOd15XO

Input is a cell array of strings, in the form {'1:45' '3:15'} or {'1:45', '3:15'}.
Try it online!
Explanation
YO     % Input cell array of strings (implicit). Convert to serial date numbers
d      % Difference
15XO   % Convert to format 15, i.e. 'HH:MM'. Display (implicit)

Oh nice! Carry on!

Bash + coreutils, 44  39 bytes
tr : \ |dc -e?r60*+r-r60*-60~rn58PA~rnn

Try it online!
Explanation: using "1:45 3:15" as test case (last example). I show intermediary steps in quotes.
tr : \ |         # replace colons with spaces: "1 45 3 15"
dc -e?           # start dc script, push input to LIFO stack: "15 3 45 1"
     r60*+            # turn time B to total seconds: "195 45 1"
     r-r60*-          # turn time A to total seconds and get difference: "90"
     60~r             # turn difference (time left) to minutes and seconds: "1 30"
     n58P             # pop and print minutes, print colon (ASCII code 58): "30"
     A~rnn            # print seconds. Padding with zeroes is done by dividing by
                      #10 (A), and printing the quotient and the remainder.

Note that I don't check if the minute value needs zero padding, because the OP stated that the maximum value for m is 9.

Below is my original 44 bytes answer, that used the date command to turn the total time left in seconds to the m:ss format.
date -d@`tr : \ |dc -e?r60*+r-r60*-p` +%M:%S

@DigitalTrauma Thank you. But in the end, I managed to remove the date command and do the format printing in dc as well.

Crossed out 44 looks like regular 44.

@Riley I crossed out the spaces surrounding 44 as well, to get the effect that should have been there in the first place.

https://codegolf.meta.stackexchange.com/a/7427/57100

Python 2, 90 87 83 80 bytes
Takes input like "2:45","5:01".
a,b=[60*int(s[-5:-3])+int(s[-2:])for s in input()]
print'%d:%02d'%divmod(b-a,60)

Try it online

you can use map on input to save 3 bytes

you can use list comprehension to save several bytes: a,b=[60*int(s[-5:-3])+int(s[-2:])for s in input()]

If I'm not mistaken, you can save three additional characters replacing the two last lines by print'%d:%02d'%divmod(b-a,60) :)

C, 112 100 bytes
Thanks to @betseg for saving 11 bytes and thanks to @Johan du Toit for saving one byte!
i,j;f(char*a,char*b){i=atoi(b)-atoi(a);j=atoi(b+2)-atoi(a+2);j<0?i--,j+=60:0;printf("%d:%02d",i,j);}

Try it online!

You can change %s%d with %02d and remove the ?:. Try it online!

scanf() is your friend for reading multiple integers.

You can also save 1 byte by using: j<0?i++,j+=60:0;

@DigitalTrauma Nononono, It's usually shorter to use arguments which he did.

c, 86
f(a,b,c,d){scanf("%d:%d%d:%d",&a,&b,&c,&d);d+=(c-a)*60-b;printf("%d:%02d",d/60,d%60);}

Reads space-separated times from STDIN.
Try it online.

Batch, 74 bytes
@set t=%2-(%1)
@set/as=%t::=*60+1%,m=s/60,t=s/10%%6
@echo %m%:%t%%s:~-1%

Replacing the : in the time with *60+1 converts it into an expression that calculates the number of seconds. Batch interprets leading zeros as octal so I prepend a 1 to the seconds to ensure decimal conversion; fortunately the two 1s cancel out.

MySQL, 13 22 bytes
select right(timediff(B,A),5)

expects the times in A and B.

ECMAScript 6, 99 91 85 bytes
Single Line:
f=s=>s.split`:`.reduce((a,e,i)=>a+e*(!i?60:1),0);t=n=>~~(n/60)+":"+n%60;t(f(b)-f(a));

Slightly formatted:
f=s=>s.split`:`.reduce((a,e,i)=>a+e*(!i?60:1),0);
t=n=>~~(n/60)+":"+n%60;
t(f(b)-f(a));

I feel there could be some some savings in there.. but I am not seeing them at present.
Edit - excellent suggestions in the comments.

You can remove the parentheses around the s.

And instead of s.split(":"), you can use the newer syntax : s.split<backtick>:<backtick>.

Bash + GNU utilities, 43
date -d@`date -f- +%s|dc -e??r-60/p` +%M:%S

Try it online.
Explanation
         date -f- +%s                        # read in 2 line-delimited dates and output as number of seconds since the epoch
                     |dc -e                  # pipe to dc expression:
                           ??                # - read 2 input numbers
                             r-              # - reverse and subtract
                               60/           # - divide by 60
                                  p          # - output
        `                          `         # evaluate date|dc command
date -d@                             +%M:%S  # format seconds difference and output

Note the dc expression divides by 60, because date reads the input as H:MM instead of M:SS.

PHP, 55 53 bytes
<?=date('i:s',($s=strtotime)($argv[2])-$s($argv[1]));

takes input from command line arguments

53 bytes: <?=date('i:s',($x=strtotime)($argv[2])-$x($argv[1]));

Rebol, 5 bytes
b - a

Assuming I didn't miss any rules..
Rebol has arithmetic built-in for a number of literal data types.
This also applies to its descendants such as Red

I know little to nothing about this language.

@carusocomputing https://chat.stackoverflow.com/rooms/291/rebol

C#, 72 bytes
using System;a=>b=>((DateTime.Parse(b)-DateTime.Parse(a))+"").Remove(5);

Takes input as strings.
b="3:15" a="1:45".
Explanation:
Because DateTime.Parse() returns a Date in hh:mm:ss format, I am able to parse the result into a string using +"", then trim the trailing :00.
This works with hh:mm because there are both 60 seconds in a minute and 60 minutes in an hour.
0:01 0:00 returns 0:01
1:00 0:55 returns  0:05
3:15 1:45 returns  1:30

Unfortunately, the DateTime.Parse() is taking the input -- for example, 1:45 -- as hh:mm and not mm:ss, resulting in the follow output -- for A 1:45 and B 3:15 -- [01:30:00] ( hh:mm:ss ) ( even with CultureInfo.InvariantCulture specified ). You might have to add a "0:" + a/b when parsing.

@auhmaan Ah, nice catch. I ended up trimming the trailing :00.

I believe you need a ; on the end, you can use currying i.e. a=>b=>, you need to fully qualify DateTime or include using System;.

Haskell, 98 127 86 Bytes
r(m:_:s)=60*read[m]+read s
a#b|(d,m)<-divMod(r b-r a)60=show d++':':['0'|m<=9]++show m

Try it online!
But I wonder if there are some library functions for this
EDIT: Removed import, also fixed an error where it showed m:s instead of m:ss
Also, well-formatted version:
convert :: String -> Integer
convert (a:_:b) = (read [a])*60+(read b)

diffTime :: String -> String -> String
diffTime s1 s2 = let (d,m) = divMod (c b-c a) 60 in show d ++ ":" ++ pad2d m

pad2d :: Int -> String
pad2d n = ['0'|n<=9]++show n

EDIT2: Golfed off (30?) bytes thanks to Laikoni! Also golfed some other misc. bytes.

You should tell us what language this is and how many bytes it uses.

Yeah, I didn't mean to press post (who knew tab+enter from the text box posts your answer?)

Same approach, 86 bytes: Try it online!

I didn't think of using a list comprehension. Thanks :)

Pyth, 47 45 44 40 Bytes
J.U-Zbm+*60hdedmmvkcd\:.z%"%d:%02d".DJ60

Takes the input separated by newlines.
Pyth had no time built-ins useful for this. I tried some fancy eval() stuff but apparantly Pyth can't eval stuff with * or any leading zeroes whatsoever. This got much longer than i hoped. Quite some bytes are spent on adding a leading zero to the output. At least I'm shorter than bash. Will add explanation if asked.
Try this!
alternative solution, 48 Bytes
J.U-Zbm+*60hdh_dmmvkcd\:.z
K%J60
s[/J60\:*<KT\0K

T-SQL, 238 bytes
CREATE PROCEDURE d @a time,@b time AS BEGIN DECLARE @d int DECLARE @s varchar(2) SET @d=datediff(s,@a,@b);SET @s=CAST(@d%3600/60 AS VARCHAR(3)) SELECT CAST(@d/3600 AS VARCHAR(3))+':'+(SELECT CASE WHEN LEN(@s)=1 THEN '0'+@s ELSE @s END)END

Usage:
EXEC d '00:55','01:00'

Seeing the PostGres example earlier I realised I hadn't seen many golfing attempts in SQL so I had a go at it in T-SQL. Now I know why you don't see much golfing in SQL :D

CJam, 34 33 25 bytes
Saved 8 bytes thanks to Martin Ender!
{r':/60b}2*\m60mds2Te[':\

Try it online!
Explanation
{             e# Start of block
 r            e#  Read one time from input
 ':/          e#  Split on colons, gives [minutes seconds]
 60b          e#  Convert from base 60
}2*           e# Run this block 2 times
              e# At this point, we have the two times in seconds on the stack
\             e# Swap top elements
m             e# Subtract
60md          e# Divmod the result by 60, to convert back to minutes and seconds
s             e# Convert the seconds to a string
2Te[          e# Pad it to 2 characters by adding 0s to the left (T = 0)
':            e# Push a colon character
\             e# Swap top elements, bringing seconds back to the top

Python, 160 bytes
I am still new to code golf so if anyone has any suggestions, I would appreciate it.
a, b = input()
def z(x):
    x = x.split(":")
    return int(x[0])*60+int(x[1])
a, b = z(a),z(b)
s, m = b-a,0
while s >= 60:
    s -= 60
    m += 1
print(str(m)+":"+str(s))

Hello and welcome to our site.  It seems that you are taking input for your program from preinitialized variables.  However this is not permitted under out defaults for IO.  I would recommend for this specific case to take input via raw_input().

T-SQL, 82 Bytes
select left(cast(dateadd(minute, datediff(S,'0:00','0:01')/60,114) as time(0)), 5)

REXX, 79 bytes
arg t q
say right(time(,f(q)-f(t),s),5)
f:return time(s,'00:'right(arg(1),5,0))

Pyth, 28
%"%d:%02d".Dh.+misMcd\:60Q60

Try it.
Explanation
                   cd\:      # lambda to split c on ":"
                 sM          # map to convert string to int
               mi      60Q   # convert from base-60 list to give seconds
             .+              # delta of the two seconds values
            h                # single-item list to int
          .D              60 # divmod by 60
%"%d:%02d"                   # format output

TXR Lisp, 101 bytes
$ txr -e '(awk (:let (s "%M:%S"))
               ((mf (time-parse s))
                (prn (time-string-local (- [f 1].(time-utc) [f 0].(time-utc)) s))))'
13:49 14:49
01:00
0:13 1:47
01:34
5:01 5:59
00:58
6:00 6:00
00:00
6:00 5:00
59:00

Condensed: (awk(:let(s"%M:%S"))((mf(time-parse s))(prn(time-string-local(-[f 1].(time-utc)[f 0].(time-utc))s))))

You need a bytecount, and I don't think this is fully golfed.

Java 7, 164 bytes
String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))*60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);}

Explanation:
String c(String a, String b){       // Method with two String parameters and String return-type
  long s = x(b,1) - x(a,1)          //  Get difference in seconds from input times
           + (x(b,0) - x(a,0)*60,   //   plus the difference in minutes times 60 to get the seconds
    m = s%60;                       //  Temp variable of seconds after we've subtracted the minutes (used multiple times)
  return (s/60)                     //  Return minutes
    +":"                            //   plus ":"
    +(m>9?m:"0"+m);                 //   plus seconds (with a leading 0 if necessary)
}                                   // End of method

long x(String s,int i){             // Separate ethod with String and Integer parameters and long return-type
  return new Long(s.split(":")[i];  //  Return either minutes or seconds of String parameter based on the index
}                                   // End of method

Test code:
Try it here.
class M{
  String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))*60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c("0:00", "0:01"));
    System.out.println(m.c("0:55", "1:00"));
    System.out.println(m.c("1:45", "3:15"));
  }
}

Output:
0:01
0:05
1:30

Ruby, 91 bytes
require'time';t=Time;d=t.parse($*[1])-t.parse($*[0]);puts t.at(d.to_i).utc.strftime '%H:%M'

Try it online!
Takes input from command line arguments.
Invocation:
ruby outatime.rb $A $B

Example:
ruby outatime.rb 1:45 3:15

Output:

01:30

Welcome to the site!

PowerShell 47 Bytes
param($s,[timespan]$f)($f-$s).ToString("h\:mm")

Simple timespan math and coverting to hour and seconds string.

JavaScript, 88 bytes
a=>b=>{c=a.split`:`,d=b.split`:`;return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60}

Try it online!
Explanation:
Splits the inputs on the colon
c=a.split`:`,d=b.split`:`;

Converts string to int
+c[0]

Gets the minute value
+c[0]-d[0]-d[1]>c[1]?1:0

Gets the second value
(+c[1]+60-d[1])%60

Returns the string minutes:seconds
return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60

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


text:
Schläfli Convex Regular Polytope Interpreter
Background
The Schläfli Symbol is a notation of the form {p,q,r,...} that defines regular polytopes and tessellations.
The Schläfli symbol is a recursive description, starting with a p-sided regular polygon as {p}. For example, {3} is an equilateral triangle, {4} is a square and so on.
A regular polyhedron that has q regular p-sided polygon faces around each vertex is represented by {p,q}. For example, the cube has 3 squares around each vertex and is represented by {4,3}.
A regular 4-dimensional polytope, with r {p,q} regular polyhedral cells around each edge is represented by {p,q,r}. For example a tesseract, {4,3,3}, has 3 cubes, {4,3}, around an edge.
In general a regular polytope {p,q,r,...,y,z} has z {p,q,r,...,y} facets around every peak, where a peak is a vertex in a polyhedron, an edge in a 4-polytope, a face in a 5-polytope, a cell in a 6-polytope, and an (n-3)-face in an n-polytope.
A regular polytope has a regular vertex figure. The vertex figure of a regular polytope {p,q,r,...y,z} is {q,r,...y,z}.
Regular polytopes can have star polygon elements, like the pentagram, with symbol {5/2}, represented by the vertices of a pentagon but connected alternately.
The Schläfli symbol can represent a finite convex polyhedron, an infinite tessellation of Euclidean space, or an infinite tessellation of hyperbolic space, depending on the angle defect of the construction. A positive angle defect allows the vertex figure to fold into a higher dimension and loops back into itself as a polytope. A zero angle defect tessellates space of the same dimension as the facets. A negative angle defect cannot exist in ordinary space, but can be constructed in hyperbolic space.
Competition
Your goal is to create a program which when passed a Schläfli Symbol will return a complete description of a convex polytope. This is only a subset of the Schläfli Symbols, but it is the simplest one, I believe even without the other possibilities this will be a very difficult task, and polytopes are the starting point for tessellations. The rules of this question were designed with the idea of this result being an API, and I have not been able to locate any such program on the internet.
Your program must accomplish all of the following.

The program must be able to generate any finite dimensional regular
convex polytope. In 2 dimensions this includes n-gons. In 3 dimensions these are the platonic solids, in 4 dimensions this includes the tesseract, the orthoplex and a few others)
The program must either (a) place a point on the origin, or (b) ensure that the average of all points is the origin. Orientation does not matter. Overall size does not matter.
The program must provide a complete description meaning that for a 4-dimensional object, the program will return/print the vertices, edges, faces, and polyhedra. The order these are reported does not matter. For polyhedra, this is the information you would need in order to render the object.

You do not need to handle:

Tesselations
Hyperbolic Geometry
Fractional Schläfli symbols (non-convex)
Embedded Schläfli Symbols (non-uniform tilings)

If asked to do any of these things you can return an error.
Example: Cube
Input:
4 3

Output:
Vertices
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

Edges (These are the vertex pairs that make up the edges)
0 1
0 2
0 4
1 3
1 5
2 3
2 6
3 7
4 5
4 6
5 7
6 7

Faces (These are the squares which are the faces of the cube)
0 1 3 2
0 1 5 4
0 2 6 4
6 7 5 4
7 6 2 3
7 5 1 3

I had some ideas for how this algorithm could work and be very recursive, but thus far I've failed, but if you are looking for inspiration check out: https://en.wikipedia.org/wiki/Euler_characteristic
As an example of working out the number of vertices, edges and faces, Consider the cube which is {4,3}. If we look at the initial 4, then it has 4 edges and 4 vertices. Now if we look at the next 3, we know that 3 edges meet at each vertex, each edge connects to 2 vertices, 2 faces meet at each edge, each face connects to 4 edges(because of the square sides), and we have the Euler Characteristic formula.
E = 3/2 V
E = 4/2 F
V - E + F = 2
Which gives E=12, V=8, F=6.
Scoring
In order to keep the question on topic, this has been revised to Code Golf. Shortest code wins.
A github has been created for this question

Googling shows there's only 3 families of regular polytope extending beyond 4 dimensions: analogous to cube, octahedron and tetrahedron. It seems it would be simpler to write for these families and hardcode the rest (two 3d polytopes, three 4d polytopes, and the infinite family of 2d polytopes.) As far as I can see that meets the spec but wouldn't be generalizable. Would that be a valid answer? It might be feasible to write a recursive algorithm to generate topological graphs beyond the scope of the spec, but the killer with that approach even within the spec is calculating the coordinates.

How do we know the actual vertices, by only knowing they are equilateral?

@SIGSEGV the only requirement specified is that the origin should correspond to either the centre or one of the points. That gives plenty of scope to rotate the shape as you please. https://en.wikipedia.org/wiki/Simplex gives an algorithm for calculating coordinates of the hypertetrahedrons (which could perhaps be extended to the icosahedron and its 4d analogue but doing that is too much for me, hence my question.) The hypercubes and hyperoctahedrons have nice integer coordinates (and the hypertetrahedrons too actually, but often only in more dimensions than the shape itself, which is untidy.)

@LevelRiverSt, yes since the only regular polytopes which exist would be covered within your suggestions then yes you could hardcode them.

I've cast the closing vote on this question because it is a fastest-guns-in-the-west style challenge, where the first valid answer wins.  This is not generally considered to be a valid winning criterion.  I don't know how this has been open for so long, it should have been closed.

@HeebyJeebyMan Thanks for your comment. I have started a meta post on this specific question https://codegolf.meta.stackexchange.com/q/14766/15599 I would point out that if the issue is that the existing winning criterion discourages further entries, closing the question is not a great long term solution as it actually prevents further entries. In my meta question I have linked a previous question about fastest-guns-in-the-west that you may find interesting. Perhaps OP Tony Ruth could revise the winning criteria but he's not particularly active here.

@totallyhuman as the first close voter, I would suggest you might have wished to leave a comment explaining your reasons. Also, in the meta post I have started on this question you will find a link to a previous meta post on the subject of pure programming puzzles, which in my opinion leans somewhat towards challenges like this being on topic.

@TonyRuth I strongly disagree that there was any need to close this question to future answers. If you are in agreement, I suggest we revise the winning criterion to Code-Golf. See the meta post.

I'm casting a reopen vote because (a) I'm convinced by the arguments in the meta question that this kind of question is arguably on topic according to currently agreed policy, and (b) in my personal, purely subjective opinion, questions of this nature should be on topic, so I hope the issue gets resolved in their favour.

Following Peter Taylor's answer I've changed the winning criteria to Code Golf. If anyone has a better idea, it can be rolled back.

@LevelRiverSt I don't know what brought about closing this question, but I agree converting it to code-golf would be a good solution. Also, I can ask another question on this if you would like to see some of the excluded stuff like tesselations included.

@TonyRuth you may have already discovered this by now, but the given output format really isn't a very good one.  The reason is that there is no way to extract the structure of the elements.  E.g. given the output for the 120-cell {5,3,3}, how would you figure out which of the 1200 edges or 720 pentagonal faces are incident on a particular one of the 120 dodecahedral cells?  A better representation would be for each element of dimension k to be represented as a list of indices into the elements of dimension k-1.  From that, you can extract vertex indices easily, but not the other way around.

@DonHatch I see your point. When I posted this, the first thing to do with the output that came to mind was the draw the resulting figures. openGL has an option: GL_POLYGON for which it is useful to have the faces point to the vertices instead of the edges. It is actually not too hard to use if faces point to edges, but the edges would need to be ordered. However, I can see cases where it would be useful to have faces point to edges, hyperfaces point to faces, etc, and the reverse as well.

Python
Here's a recursive program without any special cases.
Ignoring blank lines and comments, it's less than 100 90 lines,
including a gratuitous check of Euler's formula at the end.
Excluding the definitions of ad-hoc math functions (which could probably be provided by a library) and i/o, the polytope generation is 50 lines of code.
And it even does the star polytopes!
The output polytope will have edge length 1 and will be in canonical
position and orientation, in the following sense:

the first vertex is the origin,
the first edge lies along the +x axis,
the first face is in the +y half-plane of the xy plane,
the first 3-cell is in the +z half-space of the xyz space, etc.

Other than that, the output lists are in no particular order.
(Well, actually, that's not entirely true--
they'll actually come out roughly in order starting from the first element and expanding outwards.)
There's no checking for invalid schlafli symbol; if you give it one, the program will probably go off the rails
(endless loop, stack overflow, or just garbage out).
If you ask for an infinite planar tiling such as {4,4} or {3,6} or {6,3}, the program will
actually start generating the tiling, but it will go forever until it runs out of space, never finishing
nor producing output.  This would not be too hard to fix (just put a limit on the number of elements to generate; the result should be a fairly coherent region of the infinite picture, since elements are generated in roughly breadth-first-search order).
The code
#!/usr/bin/python3
# (works with python2 or python3)

#
# schlafli_interpreter.py
# Author: Don Hatch
# For: https://codegolf.stackexchange.com/questions/114280/schl%C3%A4fli-convex-regular-polytope-interpreter
#
# Print the vertex coords and per-element (edges, faces, etc.) vertex index
# lists of a regular polytope, given by its schlafli symbol {p,q,r,...}.
# The output polytope will have edge length 1 and will be in canonical position
# and orientation, in the following sense:
#  - the first vertex is the origin,
#  - the first edge lies along the +x axis,
#  - the first face is in the +y half-plane of the xy plane,
#  - the first 3-cell is in the +z half-space of the xyz space, etc.
# Other than that, the output lists are in no particular order.
#

import sys
from math import *

# vector minus vector.
def vmv(a,b): return [x-y for x,y in zip(a,b)]
# matrix minus matrix.
def mmm(m0,m1): return [vmv(row0,row1) for row0,row1 in zip(m0,m1)]
# scalar times vector.
def sxv(s,v): return [s*x for x in v]
# scalar times matrix.
def sxm(s,m): return [sxv(s,row) for row in m]
# vector dot product.
def dot(a,b): return sum(x*y for x,y in zip(a,b))
# matrix outer product of two vectors; that is, if a,b are column vectors: a*b^T
def outer(a,b): return [sxv(x,b) for x in a]
# vector length squared.
def length2(v): return dot(v,v)
# distance between two vectors, squared.
def dist2(a,b): return length2(vmv(a,b))
# matrix times vector, homogeneous (i.e. input vector ends with an implicit 1).
def mxvhomo(m,v): return [dot(row,v+[1]) for row in m]
# Pad a square matrix (rotation/reflection) with an extra column of 0's on the
# right (translation).
def makehomo(m): return [row+[0] for row in m]
# Expand dimensionality of homogeneous transform matrix by 1.
def expandhomo(m): return ([row[:-1]+[0,row[-1]] for row in m]
                         + [[0]*len(m)+[1,0]])
# identity matrix
def identity(dim): return [[(1 if i==j else 0) for j in range(dim)]
                                               for i in range(dim)]
# https://en.wikipedia.org/wiki/Householder_transformation. v must be unit.
# Not homogeneous (makehomo the result if you want that).
def householderReflection(v): return mmm(identity(len(v)), sxm(2, outer(v,v)))

def sinAndCosHalfDihedralAngle(schlafli):
  # note, cos(pi/q)**2 generally has a nicer expression with no trig and often
  # no radicals, see http://www.maths.manchester.ac.uk/~cds/articles/trig.pdf
  ss = 0
  for q in schlafli: ss = cos(pi/q)**2 / (1 - ss)
  if abs(1-ss) < 1e-9: ss = 1  # prevent glitch in planar tiling cases
  return sqrt(ss), sqrt(1 - ss)

# Calculate a set of generators of the symmetry group of a {p,q,r,...} with
# edge length 1.
# Each generator is a dim x (dim+1) matrix where the square part is the initial
# orthogonal rotation/reflection and the final column is the final translation.
def calcSymmetryGenerators(schlafli):
  dim = len(schlafli) + 1
  if dim == 1: return [[[-1,1]]]  # one generator: reflect about x=.5
  facetGenerators = calcSymmetryGenerators(schlafli[:-1])
  # Start with facet generators, expanding each homogeneous matrix to full
  # dimensionality (i.e. from its previous size dim-1 x dim to dim x dim+1).
  generators = [expandhomo(gen) for gen in facetGenerators]
  # Final generator will reflect the first facet across the hyperplane
  # spanned by the first ridge and the entire polytope's center,
  # taking the first facet to a second facet also containing that ridge.
  # v = unit vector normal to that bisecting hyperplane
  #   = [0,...,0,-sin(dihedralAngle/2),cos(dihedralAngle/2)]
  s,c = sinAndCosHalfDihedralAngle(schlafli)
  v = [0]*(dim-2) + [-s,c]
  generators.append(makehomo(householderReflection(v)))
  return generators

# Key for comparing coords with roundoff error.  Makes sure the formatted
# numbers are not very close to 0, to avoid them coming out as "-0" or "1e-16".
# This isn't reliable in general, but it suffices for this application
# (except for very large {p}, no doubt).
def vert2key(vert): return ' '.join(['%.9g'%(x+.123) for x in vert])

# Returns a pair verts,edgesEtc where edgesEtc is [edges,faces,...]
def regular_polytope(schlafli):
  dim = len(schlafli) + 1
  if dim == 1: return [[0],[1]],[]

  gens = calcSymmetryGenerators(schlafli)

  facetVerts,facetEdgesEtc = regular_polytope(schlafli[:-1])

  # First get all the verts, and make a multiplication table.
  # Start with the verts of the first facet (padded to full dimensionality),
  # so indices will match up.
  verts = [facetVert+[0] for facetVert in facetVerts]
  vert2index = dict([[vert2key(vert),i] for i,vert in enumerate(verts)])
  multiplicationTable = []
  iVert = 0
  while iVert < len(verts):  # while verts is growing
    multiplicationTable.append([None] * len(gens))
    for iGen in range(len(gens)):
      newVert = mxvhomo(gens[iGen], verts[iVert])
      newVertKey = vert2key(newVert)
      if newVertKey not in vert2index:
        vert2index[newVertKey] = len(verts)
        verts.append(newVert)
      multiplicationTable[iVert][iGen] = vert2index[newVertKey]
    iVert += 1

  # The higher-level elements of each dimension are found by transforming
  # the facet's elements of that dimension.  Start by augmenting facetEdgesEtc
  # by adding one more list representing the entire facet.
  facetEdgesEtc.append([tuple(range(len(facetVerts)))])
  edgesEtc = []
  for facetElementsOfSomeDimension in facetEdgesEtc:
    elts = facetElementsOfSomeDimension[:]
    elt2index = dict([[elt,i] for i,elt in enumerate(elts)])
    iElt = 0
    while iElt < len(elts):  # while elts is growing
      for iGen in range(len(gens)):
        newElt = tuple(sorted([multiplicationTable[iVert][iGen]
                               for iVert in elts[iElt]]))
        if newElt not in elt2index:
          elt2index[newElt] = len(elts)
          elts.append(newElt)
      iElt += 1
    edgesEtc.append(elts)

  return verts,edgesEtc

# So input numbers can be like any of "8", "2.5", "7/3"
def parseNumberOrFraction(s):
  tokens = s.split('/')
  return float(tokens[0])/float(tokens[1]) if len(tokens)==2 else float(s)

if __name__ == '__main__':
  if sys.stdin.isatty():
    sys.stderr.write("Enter schlafli symbol (space-separated numbers or fractions): ")
    sys.stderr.flush()
  schlafli = [parseNumberOrFraction(token) for token in sys.stdin.readline().split()]
  verts,edgesEtc = regular_polytope(schlafli)

  # Hacky polishing of any integers or half-integers give or take rounding error.
  def fudge(x): return round(2*x)/2 if abs(2*x-round(2*x))<1e-9 else x

  print(repr(len(verts))+' Vertices:')
  for v in verts: print(' '.join([repr(fudge(x)) for x in v]))
  for eltDim in range(1,len(edgesEtc)+1):
    print("")
    elts = edgesEtc[eltDim-1]
    print(repr(len(elts))+' '+('Edges' if eltDim==1
                          else 'Faces' if eltDim==2
                          else repr(eltDim)+'-cells')+" ("+repr(len(elts[0]))+" vertices each):")
    for elt in elts: print(' '.join([repr(i) for i in elt]))

  # Assert the generalization of Euler's formula: N0-N1+N2-... = 1+(-1)**(dim-1).
  N = [len(elts) for elts in [verts]+edgesEtc]
  eulerCharacteristic = sum((-1)**i * N[i] for i in range(len(N)))
  print("Euler characteristic: "+repr(eulerCharacteristic))
  if 2.5 not in schlafli: assert eulerCharacteristic == 1 + (-1)**len(schlafli)

Trying it out on some cases
Input (cube):
4 3

Output:
8 Vertices:
0.0 0.0 0.0
1.0 0.0 0.0
0.0 1.0 0.0
1.0 1.0 0.0
0.0 0.0 1.0
1.0 0.0 1.0
0.0 1.0 1.0
1.0 1.0 1.0

12 Edges (2 vertices each):
0 1
0 2
1 3
2 3
0 4
1 5
4 5
2 6
4 6
3 7
5 7
6 7

6 Faces (4 vertices each):
0 1 2 3
0 1 4 5
0 2 4 6
1 3 5 7
2 3 6 7
4 5 6 7

Input from a unix command shell (120-cell polychoron):
$ echo "5 3 3" | ./schlafli_interpreter.py | grep ":"

Output:
600 Vertices:
1200 Edges (2 vertices each):
720 Faces (5 vertices each):
120 3-cells (20 vertices each):

Input (10-dimensional cross polytope):
$ echo "3 3 3 3 3 3 3 3 4" | ./schlafli_interpreter.py | grep ":"

Output:
20 Vertices:
180 Edges (2 vertices each):
960 Faces (3 vertices each):
3360 3-cells (4 vertices each):
8064 4-cells (5 vertices each):
13440 5-cells (6 vertices each):
15360 6-cells (7 vertices each):
11520 7-cells (8 vertices each):
5120 8-cells (9 vertices each):
1024 9-cells (10 vertices each):

Input (15-dimensional simplex):
$ echo "3 3 3 3 3 3 3 3 3 3 3 3 3 3" | ./schlafli_interpreter.py | grep ":"

16 Vertices:
120 Edges (2 vertices each):
560 Faces (3 vertices each):
1820 3-cells (4 vertices each):
4368 4-cells (5 vertices each):
8008 5-cells (6 vertices each):
11440 6-cells (7 vertices each):
12870 7-cells (8 vertices each):
11440 8-cells (9 vertices each):
8008 9-cells (10 vertices each):
4368 10-cells (11 vertices each):
1820 11-cells (12 vertices each):
560 12-cells (13 vertices each):
120 13-cells (14 vertices each):
16 14-cells (15 vertices each):

Star polytopes
Ha, and it just naturally does star polytopes too!  I didn't even need to try :-)
Except that the bit about Euler's formula at the end fails,
since that formula isn't valid for star polytopes.
Input (small stellated dodecahedron):
5/2 5

Output:
12 Vertices:
0.0 0.0 0.0
1.0 0.0 0.0
0.8090169943749473 0.5877852522924732 0.0
0.19098300562505266 0.5877852522924732 0.0
0.5 -0.36327126400268034 0.0
0.8090169943749473 -0.2628655560595667 0.5257311121191336
0.19098300562505266 -0.2628655560595667 0.5257311121191336
0.5 0.162459848116453 -0.3249196962329062
0.5 0.6881909602355867 0.5257311121191336
0.0 0.32491969623290623 0.5257311121191336
0.5 0.1624598481164533 0.8506508083520398
1.0 0.32491969623290623 0.5257311121191336

30 Edges (2 vertices each):
0 1
0 2
1 3
2 4
3 4
0 5
1 6
5 7
6 7
0 8
2 9
7 8
7 9
1 8
0 10
3 11
5 9
4 10
7 11
4 9
2 5
1 10
4 11
6 11
6 8
3 10
3 6
2 10
9 11
5 8

12 Faces (5 vertices each):
0 1 2 3 4
0 1 5 6 7
0 2 7 8 9
1 3 7 8 11
0 4 5 9 10
2 4 5 7 11
1 4 6 10 11
0 3 6 8 10
3 4 6 7 9
2 3 9 10 11
1 2 5 8 10
5 6 8 9 11
Traceback (most recent call last):
  File "./schlafli_interpreter.py", line 185, in <module>
    assert sum((-1)**i * N[i] for i in range(len(N))) == 1 + (-1)**len(schlafli)
AssertionError

Input (great stellated 120-cell):
$ echo "5/2 3 5" | ./schlafli_interpreter.py | grep ":"

Output:
120 Vertices:
720 Edges (2 vertices each):
720 Faces (5 vertices each):
120 3-cells (20 vertices each):

Thanks for reviving this question, and your answer looks pretty impressive. I like the recursive nature and the star figures. I connected your code to some opengl for drawing polytopes (see github link above).

Ruby
Background
There are three families of regular polytope extending into infinite dimensions:

the simplexes, of which the tetrahedron is a member (I will often refer to them here as hypertetrahedra, though the term simplex is more correct.) Their schlafi symbols are of the form {3,3,...,3,3}
the n-cubes, of which the cube is a member. Their schlafi symbols are of the form {4,3,...,3,3}
the orthoplexes, of which the octahedron is a member (I will often refer to them here as hyperoctahedra) Their schlafi symbols are of the form {3,3,...,3,4}

There is one further infinite family of regular polytopes, symbol {m}, that of the 2 dimensional polygons, which may have any number of edges m.
In addition to this, there are just five other special cases of regular polytope: the 3-dimensional icosahedron {3,5} and dodecahedron {5,3}; their 4-dimensional analogues the 600-cell {3,3,5} and 120-cell {5,3,3}; and one other 4 dimensional polytope, the 24-cell {3,4,3} (whose closest analogues in 3 dimensions are the cuboctahedron and its dual the rhombic dodecahedron.)
Main function
Below is the main polytope function that interprets the schlafi symbol. It expects an array of numbers, and returns an array containing a bunch of arrays as follows:

An array of all vertices, each expressed as an n-element array of coordinates (where n is the number of dimensions)
An array of all edges, each expressed as a 2-element of vertex indices
An array of all faces, each expressed as an m-element of vertex indices (where m is the number of vertices per face)

and so on as appropriate for the number of dimensions.
It calculates 2d polytopes itself, calls functions for the 3 infinite dimensional families, and uses lookup tables for the five special cases. It expects to find the functions and tables declared above it.
include Math

#code in subsequent sections of this answer should be inserted here

polytope=->schl{
  if schl.size==1                                #if a single digit calculate and return a polygon
    return [(1..schl[0]).map{|i|[sin(PI*2*i/schl[0]),cos(PI*2*i/schl[0])]},(1..schl[0]).map{|i|[i%schl[0],(i+1)%schl[0]]}]
  elsif  i=[[3,5],[5,3]].index(schl)             #if a 3d special, lookup from tables
    return [[vv,ee,ff],[uu,aa,bb]][i]
  elsif i=[[3,3,5],[5,3,3],[3,4,3]].index(schl)  #if a 4d special. lookup fromm tables
    return [[v,e,f,g],[u,x,y,z],[o,p,q,r]][i]
  elsif schl.size==schl.count(3)                 #if all threes, call tetr for a hypertetrahedron
    return tetr[schl.size+1]
  elsif schl.size-1==schl.count(3)               #if all except one number 3
    return cube[schl.size+1] if schl[0]==4       #and the 1st digit is 4, call cube for a hypercube
    return octa[schl.size+1] if schl[-1]==4      #and the last digit is 4, call octa for a hyperoctahedron
  end
  return "error"                                 #in any other case return an error
}

Functions for the tetrahedron, cube and octahedron families
https://en.wikipedia.org/wiki/Simplex
https://en.wikipedia.org/wiki/5-cell (4d simplex)
http://mathworld.wolfram.com/Simplex.html
Tetrahedron family explanation - coordinates
an n-dimensional simplex/hypertetrahedron has n+1 points. It is very easy to give the vertices of the n-dimensional simplex in n+1 dimensions.
Thus (1,0,0),(0,1,0),(0,0,1) describes a 2d triangle embedded in 3 dimensions and (1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1) describes a 3d tetrahedron embedded in 4 dimensions. This is easily verified by confirming that all distances between vertices are sqrt(2).
Various complicated algorithms are given on the internet for finding the vertices for the n-dimensional simplex in n-dimensional space. I found a remarkably simple one in Will Jagy's comments on this answer https://mathoverflow.net/a/38725 . The last point lies on the line p=q=...=x=y=z at a distance of sqrt(2) from the others. Thus the triangle above can be converted to a tetrahedron by addition of a point at either (-1/3,-1/3,-1/3) or (1,1,1). These 2 possible values of the coordinates for the last point are given by (1-(1+n)**0.5)/n and (1+(1+n)**0.5)/n
As the question says the size of the n-tope does not matter, I prefer to multiply through by n and use the coordinates (n,0,0..0) up to (0..0,0,n) with the final point at (t,t,..,t,t) where t = 1-(1+n)**0.5 for simplicity.
As the centre of this tetrahedron is not at the origin, a correction to all coordinates must be done by the line s.map!{|j|j-((1-(1+n)**0.5)+n)/(1+n)} which finds how far the centre is from the origin and subtracts it. I have kept this as a separate operation. However I have used s[i]+=n where s[i]=n would do, to allude to the fact that when the array is initialised by s=[0]*n we could put the correct offset in here instead and do the centring correction at the outset rather than the end.
Tetrahedron family explanation - graph topology
The graph of the simplex is the complete graph: every vertex is connected exactly once to every other vertex. If we have an n simplex, we can remove any vertex to give an n-1 simplex, down to the point where we have a triangle or even an edge.
Therefore we have a total of 2**(n+1) items to catalogue, each represented by a binary number. This ranges from all 0s for nothingness, through one 1 for a vertex and two 1s for an edge, up to all 1s for the complete polytope.
We set up an array of empty arrays to store the elements of each size. Then we loop from zero to (2**n+1) to generate each of the possible subsets of vertices, and store them in the array according to the size of each subset.
We are not interested in anything smaller than an edge (a vertex or a zero) nor in the complete polytope (as the complete cube is not given in the example in the question), so we return tg[2..n] to remove these unwanted elements. Before returning, we tack [tv] containing the vertex coordinates onto the beginning.
code
tetr=->n{

  #Tetrahedron Family Vertices
  tv=(0..n).map{|i|
    s=[0]*n
    if i==n
      s.map!{(1-(1+n)**0.5)}
    else
      s[i]+=n
    end
    s.map!{|j|j-((1-(1+n)**0.5)+n)/(1+n)}
  s}

  #Tetrahedron Family Graph
  tg=(0..n+1).map{[]}
  (2**(n+1)).times{|i|
    s=[]
    (n+1).times{|j|s<<j if i>>j&1==1}
    tg[s.size]<<s
  }

return [tv]+tg[2..n]}

cube=->n{

  #Cube Family Vertices
  cv=(0..2**n-1).map{|i|s=[];n.times{|j|s<<(i>>j&1)*2-1};s}

  #Cube Family Graph
  cg=(0..n+1).map{[]}
  (3**n).times{|i|                         #for each point
    s=[]
    cv.size.times{|j|                      #and each vertex
      t=true                               #assume vertex goes with point
      n.times{|k|                          #and each pair of opposite sides
        t&&= (i/(3**k)%3-1)*cv[j][k]!=-1   #if the vertex has kingsmove distance >1 from point it does not belong
      }
      s<<j if t                            #add the vertex if it belongs
    }
    cg[log2(s.size)+1]<<s if s.size > 0
  }

return [cv]+cg[2..n]}

octa=->n{

  #Octahedron Family Vertices
  ov=(0..n*2-1).map{|i|s=[0]*n;s[i/2]=(-1)**i;s}

  #Octahedron Family Graph
  og=(0..n).map{[]}
  (3**n).times{|i|                         #for each point
    s=[]
    ov.size.times{|j|                      #and each vertex
      n.times{|k|                          #and each pair of opposite sides
        s<<j if (i/(3**k)%3-1)*ov[j][k]==1 #if the vertex is located in the side corresponding to the point, add the vertex to the list
      }
    }
    og[s.size]<<s
  }

return [ov]+og[2..n]}

cube and octahedron families explanation - coordinates
The n-cube has 2**n vertices, each represented by an array of n 1s and -1s (all possibilities are allowed.) We iterate through indexes 0 to 2**n-1 of the list of all vertices, and build an array for each vertex by iterating through the bits of the index and adding -1or 1 to the array (least significant bit to most significant bit.) Thus Binary 1101 becomes the 4d point [1,-1,1,1].
The n-octahedron or n-orthoplex has 2n vertices, with all coordinates zero except one, which an be 1 or -1. The order of the vertices in the array generated is [[1,0,0..],[-1,0,0..],[0,1,0..],[0,-1,0..],[0,0,1..],[0,0,-1..]...]. Note that as the octahedron is the dual of the cube, the vertices of the octahedron are defined by the centres of the faces of the cube that surrounds it.
cube and octahedron families explanation - graph topology
Some inspiration was taken from Hypercube sides and the fact that the hyperoctahedron is the dual of the hypercube.
For the n-cube, there are 3**n items to catalogue. For example, the 3 cube has 3**3 = 27 elements. This can be seen by studying a rubik's cube, which has 1 centre, 6 faces, 12 edges and 8 vertices for a total of 27. We iterate through -1,0 and -1 in all dimensions defining an n-cube of sidelength 2x2x2.. and return all vertices that are NOT on the opposite side of the cube. Thus the centrepoint of the cube returns all 2**n vertices, and moving one unit away from the centre along any axis reduces the number of vertices by half.
As with the tetrahedron family, we start by generating an empty array of arrays and populate it according to the number of vertices per element. Note that because the number of vertices varies as 2**n as we go up through edges, faces, cubes, etc, we use log2(s.size)+1 instead of simply s.size. Again, we have to remove the hypercube itself and all elements with less than 2 vertices before returning from the function.
The octahedron/orthoplex family are the duals of the cube family, therefore again there are 3**n items to catalogue. Here we iterate through -1,0,1 for all the dimensions and if the nonzero coordinate of a vertex is equal to the corresponding coordinate of the point, the vertex is added to the list corresponding to that point. Thus an edge corresponds to a point with two nonzero coordinates, a triangle to a point with 3 nonzero coordinates and a tetrahedron to a point with 4 nonzero contacts (in 4d space.)
The resulting arrays of vertex for each point are stored in a large array as for the other cases, and we have to remove any elements with less than 2 vertices before returning. But in this case we do not have to remove the complete parent n-tope because the algorithm does not record it.
The implementations of the code for the cube were designed to be as similar as possible. While this has a certain elegance, it is likely that more efficient algorithms based on the same principles could be devised.
https://en.wikipedia.org/wiki/Hypercube
http://mathworld.wolfram.com/Hypercube.html
https://en.wikipedia.org/wiki/Cross-polytope
http://mathworld.wolfram.com/CrossPolytope.html
Code for generating tables for the 3d special cases
An orientation with the icosahedron / dodecahedron oriented with the fivefold symmetry axis parallel to the last dimension was used, as it made for the most consistent labelling of the parts. The numbering of vertices and faces for the icosahedron is per the diagram in the code comments, and reversed for the dodecahedron.
According to https://en.wikipedia.org/wiki/Regular_icosahedron the latitude of the 10 non-polar vertices of the icosahedron is +/-arctan(1/2) The coordinates of the first 10 vertices of the icosahedron are calculated from this, on two circles of radius 2 at distance +/-2 from the xy plane. This makes the overall radius of the circumsphere sqrt(5) so the last 2 vertices are at (0,0,+/-sqrt(2)).
The coordinates of the vertices of the dodecahedron are calculated by summing the coordinates of the three icosahedron vertices that surround them.
=begin
TABLE NAMES      vertices     edges      faces
icosahedron      vv           ee         ff
dodecahedron     uu           aa         bb

    10
    / \   / \   / \   / \   / \
   /10 \ /12 \ /14 \ /16 \ /18 \
   -----1-----3-----5-----7-----9
   \ 0 / \ 2 / \ 4 / \ 6 / \ 8 / \
    \ / 1 \ / 3 \ / 5 \ / 7 \ / 9 \
     0-----2-----4-----6-----8-----
      \11 / \13 / \15 / \17 / \19 /
       \ /   \ /   \ /   \ /   \ /
       11
=end

vv=[];ee=[];ff=[]
10.times{|i|
  vv[i]=[2*sin(PI/5*i),2*cos(PI/5*i),(-1)**i]
  ee[i]=[i,(i+1)%10];ee[i+10]=[i,(i+2)%10];ee[i+20]=[i,11-i%2]
  ff[i]=[(i-1)%10,i,(i+1)%10];ff[i+10]=[(i-1)%10,10+i%2,(i+1)%10]

}
vv+=[[0,0,-5**0.5],[0,0,5**0.5]]

uu=[];aa=[];bb=[]
10.times{|i|
  uu[i]=(0..2).map{|j|vv[ff[i][0]][j]+vv[ff[i][1]][j]+vv[ff[i][2]][j]}
  uu[i+10]=(0..2).map{|j|vv[ff[i+10][0]][j]+vv[ff[i+10][1]][j]+vv[ff[i+10][2]][j]}
  aa[i]=[i,(i+1)%10];aa[i+10]=[i,(i+10)%10];aa[i+20]=[(i-1)%10+10,(i+1)%10+10]
  bb[i]=[(i-1)%10+10,(i-1)%10,i,(i+1)%10,(i+1)%10+10]
}
bb+=[[10,12,14,16,18],[11,13,15,17,19]]

Code for generating the tables for the 4d special cases
This is a bit of a hack. This code takes a few seconds to run. It would be better to store the output in a file and load it in as required.
The list of 120 vertex coordinates for the 600cell is from http://mathworld.wolfram.com/600-Cell.html . The 24 vertex coordinates which do not feature a golden ratio form the vertices of a 24-cell. Wikipedia has the same scheme but has an error in the relative scale of these 24 coordinates and the other 96.
#TABLE NAMES                           vertices     edges      faces   cells
#600 cell (analogue of icosahedron)    v            e          f       g
#120 cell (analogue of dodecahedron)   u            x          y       z
#24 cell                               o            p          q       r

#600-CELL

# 120 vertices of 600cell. First 24 are also vertices of 24-cell

v=[[2,0,0,0],[0,2,0,0],[0,0,2,0],[0,0,0,2],[-2,0,0,0],[0,-2,0,0],[0,0,-2,0],[0,0,0,-2]]+

(0..15).map{|j|[(-1)**(j/8),(-1)**(j/4),(-1)**(j/2),(-1)**j]}+

(0..95).map{|i|j=i/12
   a,b,c,d=1.618*(-1)**(j/4),(-1)**(j/2),0.618*(-1)**j,0
   h=[[a,b,c,d],[b,a,d,c],[c,d,a,b],[d,c,b,a]][i%12/3]
   (i%3).times{h[0],h[1],h[2]=h[1],h[2],h[0]}
h}

#720 edges of 600cell. Identified by minimum distance of 2/phi between them

e=[]
120.times{|i|120.times{|j|
  e<<[i,j]  if i<j && ((v[i][0]-v[j][0])**2+(v[i][1]-v[j][1])**2+(v[i][2]-v[j][2])**2+(v[i][3]-v[j][3])**2)**0.5<1.3
}}

#1200 faces of 600cell.
#If 2 edges share a common vertex and the other 2 vertices form an edge in the list, it is a valid triangle.

f=[]
720.times{|i|720.times{|j|
  f<< [e[i][0],e[i][1],e[j][1]] if i<j && e[i][0]==e[j][0] && e.index([e[i][1],e[j][1]])
}}

#600 cells of 600cell.
#If 2 triangles share a common edge and the other 2 vertices form an edge in the list, it is a valid tetrahedron.

g=[]
1200.times{|i|1200.times{|j|
  g<< [f[i][0],f[i][1],f[i][2],f[j][2]] if i<j && f[i][0]==f[j][0] && f[i][1]==f[j][1] && e.index([f[i][2],f[j][2]])

}}

#120 CELL (dual of 600 cell)

#600 vertices of 120cell, correspond to the centres of the cells of the 600cell
u=g.map{|i|s=[0,0,0,0];i.each{|j|4.times{|k|s[k]+=v[j][k]/4.0}};s}

#1200 edges of 120cell at centres of faces of 600-cell. Search for pairs of tetrahedra with common face
x=f.map{|i|s=[];600.times{|j|s<<j if i==(i & g[j])};s}

#720 pentagonal faces, surrounding edges of 600-cell. Search for sets of 5 tetrahedra with common edge
y=e.map{|i|s=[];600.times{|j|s<<j if i==(i & g[j])};s}

#120 dodecahedral cells surrounding vertices of 600-cell. Search for sets of 20 tetrahedra with common vertex
z=(0..119).map{|i|s=[];600.times{|j|s<<j if [i]==([i] & g[j])};s}

#24-CELL
#24 vertices, a subset of the 600cell
o=v[0..23]

#96 edges, length 2, found by minimum distances between vertices
p=[]
24.times{|i|24.times{|j|
  p<<[i,j]  if i<j && ((v[i][0]-v[j][0])**2+(v[i][1]-v[j][1])**2+(v[i][2]-v[j][2])**2+(v[i][3]-v[j][3])**2)**0.5<2.1
}}

#96 triangles
#If 2 edges share a common vertex and the other 2 vertices form an edge in the list, it is a valid triangle.
q=[]
96.times{|i|96.times{|j|
  q<< [p[i][0],p[i][1],p[j][1]] if i<j && p[i][0]==p[j][0] && p.index([p[i][1],p[j][1]])
}}

#24 cells. Calculates the centre of the cell and the 6 vertices nearest it
r=(0..23).map{|i|a,b=(-1)**i,(-1)**(i/2)
    c=[[a,b,0,0],[a,0,b,0],[a,0,0,b],[0,a,b,0],[0,a,0,b],[0,0,a,b]][i/4]
    s=[]
    24.times{|j|t=v[j]
    s<<j if (c[0]-t[0])**2+(c[1]-t[1])**2+(c[2]-t[2])**2+(c[3]-t[3])**2<=2
    }
s}

https://en.wikipedia.org/wiki/600-cell
http://mathworld.wolfram.com/600-Cell.html
https://en.wikipedia.org/wiki/120-cell
http://mathworld.wolfram.com/120-Cell.html
https://en.wikipedia.org/wiki/24-cell
http://mathworld.wolfram.com/24-Cell.html
Example of use and output
cell24 = polytope[[3,4,3]]

puts "vertices"
cell24[0].each{|i|p i}
puts "edges"
cell24[1].each{|i|p i}
puts "faces"
cell24[2].each{|i|p i}
puts "cells"
cell24[3].each{|i|p i}

vertices
[2, 0, 0, 0]
[0, 2, 0, 0]
[0, 0, 2, 0]
[0, 0, 0, 2]
[-2, 0, 0, 0]
[0, -2, 0, 0]
[0, 0, -2, 0]
[0, 0, 0, -2]
[1, 1, 1, 1]
[1, 1, 1, -1]
[1, 1, -1, 1]
[1, 1, -1, -1]
[1, -1, 1, 1]
[1, -1, 1, -1]
[1, -1, -1, 1]
[1, -1, -1, -1]
[-1, 1, 1, 1]
[-1, 1, 1, -1]
[-1, 1, -1, 1]
[-1, 1, -1, -1]
[-1, -1, 1, 1]
[-1, -1, 1, -1]
[-1, -1, -1, 1]
[-1, -1, -1, -1]
edges
[0, 8]
[0, 9]
[0, 10]
[0, 11]
[0, 12]
[0, 13]
[0, 14]
[0, 15]
[1, 8]
[1, 9]
[1, 10]
[1, 11]
[1, 16]
[1, 17]
[1, 18]
[1, 19]
[2, 8]
[2, 9]
[2, 12]
[2, 13]
[2, 16]
[2, 17]
[2, 20]
[2, 21]
[3, 8]
[3, 10]
[3, 12]
[3, 14]
[3, 16]
[3, 18]
[3, 20]
[3, 22]
[4, 16]
[4, 17]
[4, 18]
[4, 19]
[4, 20]
[4, 21]
[4, 22]
[4, 23]
[5, 12]
[5, 13]
[5, 14]
[5, 15]
[5, 20]
[5, 21]
[5, 22]
[5, 23]
[6, 10]
[6, 11]
[6, 14]
[6, 15]
[6, 18]
[6, 19]
[6, 22]
[6, 23]
[7, 9]
[7, 11]
[7, 13]
[7, 15]
[7, 17]
[7, 19]
[7, 21]
[7, 23]
[8, 9]
[8, 10]
[8, 12]
[8, 16]
[9, 11]
[9, 13]
[9, 17]
[10, 11]
[10, 14]
[10, 18]
[11, 15]
[11, 19]
[12, 13]
[12, 14]
[12, 20]
[13, 15]
[13, 21]
[14, 15]
[14, 22]
[15, 23]
[16, 17]
[16, 18]
[16, 20]
[17, 19]
[17, 21]
[18, 19]
[18, 22]
[19, 23]
[20, 21]
[20, 22]
[21, 23]
[22, 23]
faces
[0, 8, 9]
[0, 8, 10]
[0, 8, 12]
[0, 9, 11]
[0, 9, 13]
[0, 10, 11]
[0, 10, 14]
[0, 11, 15]
[0, 12, 13]
[0, 12, 14]
[0, 13, 15]
[0, 14, 15]
[1, 8, 9]
[1, 8, 10]
[1, 8, 16]
[1, 9, 11]
[1, 9, 17]
[1, 10, 11]
[1, 10, 18]
[1, 11, 19]
[1, 16, 17]
[1, 16, 18]
[1, 17, 19]
[1, 18, 19]
[2, 8, 9]
[2, 8, 12]
[2, 8, 16]
[2, 9, 13]
[2, 9, 17]
[2, 12, 13]
[2, 12, 20]
[2, 13, 21]
[2, 16, 17]
[2, 16, 20]
[2, 17, 21]
[2, 20, 21]
[3, 8, 10]
[3, 8, 12]
[3, 8, 16]
[3, 10, 14]
[3, 10, 18]
[3, 12, 14]
[3, 12, 20]
[3, 14, 22]
[3, 16, 18]
[3, 16, 20]
[3, 18, 22]
[3, 20, 22]
[4, 16, 17]
[4, 16, 18]
[4, 16, 20]
[4, 17, 19]
[4, 17, 21]
[4, 18, 19]
[4, 18, 22]
[4, 19, 23]
[4, 20, 21]
[4, 20, 22]
[4, 21, 23]
[4, 22, 23]
[5, 12, 13]
[5, 12, 14]
[5, 12, 20]
[5, 13, 15]
[5, 13, 21]
[5, 14, 15]
[5, 14, 22]
[5, 15, 23]
[5, 20, 21]
[5, 20, 22]
[5, 21, 23]
[5, 22, 23]
[6, 10, 11]
[6, 10, 14]
[6, 10, 18]
[6, 11, 15]
[6, 11, 19]
[6, 14, 15]
[6, 14, 22]
[6, 15, 23]
[6, 18, 19]
[6, 18, 22]
[6, 19, 23]
[6, 22, 23]
[7, 9, 11]
[7, 9, 13]
[7, 9, 17]
[7, 11, 15]
[7, 11, 19]
[7, 13, 15]
[7, 13, 21]
[7, 15, 23]
[7, 17, 19]
[7, 17, 21]
[7, 19, 23]
[7, 21, 23]
cells
[0, 1, 8, 9, 10, 11]
[1, 4, 16, 17, 18, 19]
[0, 5, 12, 13, 14, 15]
[4, 5, 20, 21, 22, 23]
[0, 2, 8, 9, 12, 13]
[2, 4, 16, 17, 20, 21]
[0, 6, 10, 11, 14, 15]
[4, 6, 18, 19, 22, 23]
[0, 3, 8, 10, 12, 14]
[3, 4, 16, 18, 20, 22]
[0, 7, 9, 11, 13, 15]
[4, 7, 17, 19, 21, 23]
[1, 2, 8, 9, 16, 17]
[2, 5, 12, 13, 20, 21]
[1, 6, 10, 11, 18, 19]
[5, 6, 14, 15, 22, 23]
[1, 3, 8, 10, 16, 18]
[3, 5, 12, 14, 20, 22]
[1, 7, 9, 11, 17, 19]
[5, 7, 13, 15, 21, 23]
[2, 3, 8, 12, 16, 20]
[3, 6, 10, 14, 18, 22]
[2, 7, 9, 13, 17, 21]
[6, 7, 11, 15, 19, 23]

Wow this is an awesome answer!! I am very surprised you were able to do this in ~200 lines. I ran the cube, tetrahedron, 600-cell and a few others, and they looked good. It's hard to verify the output since there is so much of it; it is pretty easy for the output to be longer than the program, but I'll take your word for it. I'm going to try loading this into openGL and view the  platonic solids which should be straightforward since all the faces are listed. I think adding tesselations in flat space would be  easy, and I might try that as well.

@TonyRuth the key was finding the best algorithm. Less lines = less room for error. The first thing I did was check what existed besides the 3 infinite dimensional families and that's when I decided to answer. Will Jagy's comments were a godsend (I was thinking about that type of solution as wikipedia's method looked hard) so the non-integer coordinates are kept to a minimum. I wanted to get it done before the bounty expired so checking has not been massively thorough, and I haven't plotted them. Let me know of any errors - I corrected the 24cell a few hours ago.

@TonyRuth face vertices are in no particular order (they don't go round the face in a clockwise sense or anything). For higher dimensions, there is no standard order.  The hypercubes have faces listed in numerical order, so the 2nd and 3rd vertices are diagonally opposite (you will need to swap 1st & 2nd or 3rd and 4th vertex if you want them in a clockwise/anticlockwise sense.) The dodecahedron should have faces in clockwise/anticlockwise order but the 120cell will have the face vertices in any and all orders.

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


text:
Life: Created or Evolved?
Given the state of a square Game of Life grid, determine whether it could have evolved from any previous state, or could only have been created. That is, identify whether the state is a "Garden of Eden" state.
Input
A square grid of states, with 1 indicating "alive" and 0 indicating "dead". You may choose any two distinguishable symbols instead of 0 and 1 if you wish.
The side length of the grid will not be zero, but may be any natural number 1 <= N <= 20.
Any or all of the cells outside the input grid may be alive at this generation, and any or all of them may have been alive in the previous generation. The universe to be considered is infinite, so there are no boundary conditions. The edges of the input are not the edges of the universe. Specifically, the grid does not wrap.
The input may be in the form of a row delimited string, or a single string. If you wish, you may take the side length or the area of the grid as an additional input (before or after the grid).
Acceptable input formats:
010,101,010

010101010

010
101
010
3 010101010

Output
"Created" if there is no possible previous state (including states larger than the input grid) that would lead to the input state on the next generation.
"Evolved" if there exists at least one possible previous state (including states larger than the input grid) that would lead to the input state on the next generation.
You may use any two distinguishable strings or numbers instead of "Created" and "Evolved" if you wish.
Note that the possible previous state need not be distinct from the input. If a state has itself as the next generation, then it should be considered evolved.
Test cases
010
101
010 Evolved

0101110100
0010101001
1011100110
0101111101
1001001111
1111001001
1011111010
0110011101
1001010100
0010111010 Created

The created test case is taken from Achim Flammenkamp's Game of Life Page.
Note
Thanks to trichoplax for writing this challenge and I adopted it from here

Any complexity limitations? For an input of size m-by-n, if I test all possible 2^(m*n) initial states the program complexity will be large, but it solves the problem by just checking if the result matches the input

@Luis for the input? 20 by 20. For the program? no

I can't be arsed to golf it, but here is an efficient implementation using an off-the shelf integer programming solver bundled in SageMath.

I assume that it doesn't matter whether or not the previous state (if existent) is a Garden of Eden state?

@Hyper nope! Only what you get

This related Sandbox post has potentially helpful information.

Java- 1254 bytes- a very poor solution
import java.util.Arrays;
public class z{
static boolean u=1>0,v=0<1;
public static void main(String[] a){
int y=a.length,x=a[0].length();Boolean[][] l=new Boolean[x][y];for(int i=0;i<a.length;i++){l[i]=m(a[i]);}
Boolean[] n=new Boolean[x*y];for(int i=0;i<n.length;i++){n[i]=v;}
while(n.length==x*y){Boolean[][] o=new Boolean[x][y];for(int i=0; i<n.length;i++){o[i%x][i/x]=n[i];}
n=p(n);o=q(o,x,y);int r=0;for(int i=0;i<x*y;i++){if(o[i%x][i/x]&&l[i%x][i/x])r++;}
if(r==x*y){System.out.println("evolved");return;}}System.out.println("created");}
public static Boolean[][] q(Boolean[][] o,int bx,int by){Boolean[][] s=new Boolean[bx][by];for(int x=0; x<bx; x++){for(int y=0;y<by;y++){
int t=0;for(int tx=-1;tx<2;tx++){for(int ty=-1;ty<2;ty++){if(ty+y<0||ty+y>by-1||tx+x<0||tx+x>bx-1)continue;if(o[tx+x][ty+y]){t++;}}}
if(t>1&&t<4){s[x][y]=u;}else{s[x][y]=v;}}}return s;}
public static Boolean[] p(Boolean[] b){boolean w=u;Boolean[] x=new Boolean[b.length];for(int i=0;i<b.length;i++){if(w&&b[i]){x[i]=u;w=u;}else if(b[i]||w){x[i]=u;w=v;}else{x[i]=v;w=v;}
}if(w){x=Arrays.copyOf(x,x.length+1);x[x.length]=u;}return x;}
public static Boolean[] m(String s){Boolean[] x=new Boolean[s.length()];for(int i=0;i<s.length();i++){x[i]=s.charAt(i)=='1';}return x;}}

It takes input via command line.
What it does
No fancy tricks here, simply a brute force solution. It goes through every possible beginning board of size X,Y and iterates it once thru the Game of Life algorithm and checks it against the input board. This takes a VERY long time, as each board of size x by y has 2^(x*y) possible combinations. It took almost 10 minutes to run a 4x5 board. Stupidly silly for something that is simpler than it is.
If it is possible that it was an evolved board, it prints "evolved.", and if it couldn't have been evolved, it prints "created.".

Nice! I agree that it's very poor for time complexity but hey, it's the only (non-plagarized) one so far so it'll probably get the bounty! Assuming orlp doesn't post the optimized one :)

@HyperNeutrino "You won this round, but I have an ace up my hole." -
Phillip J. Fry

Congratulations, this solution takes the bounty! :)

@HyperNeutrino I know it isn't clever, and probably not what you're looking for, and I was hoping to inspire other solutions with this easily-beatable one, but I hope it was good enough.

Nobody seemed to take the offer even after I advertised it on TNB. I mean, it isn't a great solution but you do seem to have put a noticeable amount of work into it and I think it's deserving of the bounty even though its TC is bad :) Also I lose 100 rep anyway so might as well give you 100 rep rather than have the system give you 50 rep automatically :D

also -1 not golfed (haha just kidding you got a +1 but still, trivial golfs could be made) ;)

Is there not a lot of whitespace you could easily get rid off? (Boolean[] b -> Boolean[]b as an example.)


text:
Sort and Re-apply Deltas of an Array
It seems that any Simple Modification of deltas using a consistent function can almost always be done some other shorter way, Dennis.
Thus, the only solution I can imagine to make this harder, is to introduce some sort of inconsistent function.
Sorting.
Your task is to take an array of integers, sort their deltas, and recompile that to give the new array of integers.
EG.
For the input:
1  5 -3  2  9

Get the following Deltas:
  4 -8  5  7

Then, sort these Deltas, Yielding:
 -8  4  5  7

And reapply them, which gives:
1 -7 -3  2  9

Input/Output
You will be given a list/array/table/tuple/stack/etc. of signed integers as input through any standard input method.
You must output the modified data once again in any acceptable form, following the above delta sorting method.
You will receive N inputs where 0 < N < 10 where each number falls within the range -1000 < X < 1000
Test Cases
1 5 -3 2 9   -> 1 -7 -3 2 9
-5 -1 -6 5 8 -> -5 -10 -7 -3 8
-8 1 -7 1 1  -> -8 -16 -16 -8 1
8 -9 3 0 -2  -> 8 -9 -12 -14 -2
-5 -2 -5 5 0 -> -5 -10 -13 -10 0
-1 9 -1 -7 9 -> -1 -11 -17 -7 9

Notes

As stated in above, you will always receive at least 1 input, and no more than 9.
The first and last number of your output, will always match that of the input.
Only Standard Input Output is accepted
Standard loopholes apply
This is code-golf, so the lowest byte-count wins!
Have fun!

IMO you should remove the second header (the one in the body of the post itself). It's kinda ugly and just takes up space, and it's a copy of the title (which is like 20 px above it).

Jelly, 7 bytes
IṢ;@Ḣ+\

Try it online!
How it works
IṢ;@Ḣ+\  Main link. Argument: A (array)

I        Increments; compute the deltas.
 Ṣ       Sort them.
    Ḣ    Head; pop and yield the first element of A.
  ;@     Concatenate with swapped arguments.
     +\  Take the cumulative sum.

MATL, 8 bytes
1)GdShYs

Try it online!
1)   % Implicit input. Get its first entry
G    % Push input again
d    % Differences
S    % Sort
h    % Concatenate
Ys   % Cumulative sum. Implicit display

Mathematica, 40 bytes
FoldList[Plus,#&@@#,Sort@Differences@#]&

Pure function taking a list of (anythings) as input and returning a list. FoldList[Plus starts with a number (in this case, #&@@#, the first element of the input) and repeatedly adds elements of the self-explanatory list Sort@Differences@#. This mimics the behavior of the built-in Accumulate, but the first number would need to be prepended to the list of differences by hand, which makes the byte-count higher (as far as I can tell).

05AB1E, 9 bytes
-4 thanks to Emigna
¬=s¥{vy+=

Try it online!
¬         # Get the head
 =        # Print
  s¥{     # Get sorted Deltas
     vy   # For each
       += # Add to the previous value and print

You could save 4 bytes with ¬=s¥{vy+=

Haskell, 59 Bytes
import Data.List
f l@(a:b)=scanl1(+)$a:(sort$zipWith(-)b l)

Breakdown:
f l@(a:b) =           --we create a function f that takes as input a list l with head a and tail b
zipWith(-)b l        --we make a new list with the deltas
sort$                    --sort it
a:                          --prepend a to the list
scanl1(+)$          --create a new list starting with a and adding the deltas to it cumulatively

scanl(+)a$sort...

Python 2, 92 bytes
l=input();p=0;d=[]
r=l[0],
for e in l:d+=e-p,;p=e
for e in sorted(d[1:]):r+=r[-1]+e,
print r

Python 2,
90 bytes
x=input()
print[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

84 bytes
Saved 6 bytes on using lambda. Thanks to ovs!
lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

Try it online!
Breaking down the code,
>>> x
[1, 5, -3, 2, 9]
>>> map(int.__sub__,x[1:],x[:-1]) #delta
[4, -8, 5, 7]
>>> sorted(map(int.__sub__,x[1:],x[:-1])) #sorted result
[-8, 4, 5, 7]
>>> [sorted(map(int.__sub__,x[1:],x[:-1]))[:i]for i in range(len(x))]
[[], [-8], [-8, 4], [-8, 4, 5], [-8, 4, 5, 7]]
>>> [sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]
[1, -7, -3, 2, 9]

Happy Coding!

i was trying to find a way to do it like that!

You can save some bytes by converting this into a function: lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

JavaScript (ES6), 68 bytes
([p,...a])=>[s=p,...a.map(e=>p-(p=e)).sort((a,b)=>b-a).map(e=>s-=e)]

In JavaScript it turns out to be golfier to compute the Inverse Deltas of an Array. These are then sorted in descending order and cumulatively subtracted from the first element.

Husk, 7 bytes
∫:←¹OẊ-

Try it online!

Python 2, 97 bytes
p=input()
d=[p[i+1]-p[i] for i in range(len(p)-1)]
o=p[:1]
for n in sorted(d):o+=o[-1]+n,
print o

Try it online!

You can delete a space in the list comprehension for 96 bytes: [p[i+1]-p[i]for i in range(len(p)-1)]

JavaScript (ES6), 93 bytes
(p,M=[p[0]])=>p.map((a,b)=>p[b+1]-a).sort((a,b)=>a-b).map((a,b)=>M=[...M,M[b]+a])[p.length-2]

Pyth, 11 bytes
.u+NYS.+QhQ

This just does the obvious thing described in the statement.
Try It Online
      .+Q    Take the deltas of the input
     S       sort it
.u           Cumulative reduce
  +NY        using addition
         hQ  starting with the first element of the input

Suggestions for further golfing welcome.

Julia 0.5, 30 bytes
!x=[x[];x|>diff|>sort]|>cumsum

Try it online!

Python 2 with numpy, 67 56 bytes
from numpy import*
lambda l:cumsum(l[:1]+sorted(diff(l)))

Let numpy compute the deltas, sort them, prepend the first element, and let numpy compute the cumulative sums. Pretty cheap?

Save 3 bytes by changing the import to from numpy import* and n.cumsum to cumsum and n.diff to diff

Thanks. You can tell its been a while since I golfed python, forgetting all the standard tricks.

PHP, 89 bytes
for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],_;

Run like this:
php -nr 'for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],",";' 1  5 -3  2  9;echo
> 1_-7_-3_2_9_

Explanation
for(
  $a=$argv;          # Set input to $a.
  n | $i=$a[++$x+1]; # Iterate over input.
)
  $d[] = $i-$a[$x];  # Add an item to array $d, with the difference between
                       the current and previous item.

for(
  sort($d);          # Sort the delta array.
  $x-$y++;           # Loop as many times as the previous loop.
)
  echo
    $a[1]+=$d[$y-2], # Print the first input item with the delta applied
                     # cumulatively. First iteration takes $d[-1], which
                     # is unset, so results in 0.
    _;               # Print underscore as separator.

Pushy, 17 bytes
@ZL:&v+;Fg@Lt:K-#

Try it online!
@ZL:&v+;F           \ Calculate cumulative sum
         g          \ Sort
          @Lt:K-#   \ Calculate and print deltas

Perl 6, 31 bytes
{[\+] @_[0],|sort @_[1..*]Z-@_}

Try it
Expanded:
{
  [\+]            # triangle produce values using &infix<+>
    @_[0],        # starting with the first argument
    |             # slip the following into this list
      sort        # sort the following

         # generate the list of deltas

         @_[1..*] # the arguments starting with the second one
         Z[-]     # zipped using &infix:<->
         @_       # the arguments
}

Batch, 197 bytes
@set n=%1
@set s=
:l
@set/ad=5000+%2-%1
@set s=%s% %d%
@shift
@if not "%2"=="" goto l
@echo %n%
@for /f %%a in ('"(for %%b in (%s%)do @echo %%b)|sort"') do @set/an+=%%a-5000&call echo %%n%%

sort doesn't sort numerically, so I bias all the differences by 5000.

bash + sort, 102 bytes
echo $1
n=$1
shift
for e in $*
do
echo $((e-n))
n=$e
done|sort -n|while read e
do
echo $((n+=e))
done

sh + sort + expr, 106 bytes
echo $1
n=$1
shift
for e in $*
do
expr $e - $n
n=$e
done|sort -n|while read e
do
n="$n + $e"
expr $n
done

Clojure, 46 bytes
#(reductions +(first %)(sort(map -(rest %)%)))

One day I'm going to make Cljr language which has shorter function names than Clojure.