text:
How many characters are there on the icon of a Stack Exchange site?
Given the name of a Stack Exchange site which doesn't have their own design yet, decide how many ASCII characters (non-ASCII ones are counted separately) are there on their icons. Your code should distinguish these 4 cases:
1 character:
Astronomy
Beer
Freelancing
Health
History
Law
Music: Practice & Theory
Parenting
The Great Outdoors
Writers

2 characters:
3D Printing
Amateur Radio
Biblical Hermeneutics
Bitcoin
Board & Card Games
Buddhism
Chinese Language
Coffee
Community Building
Computational Science
Computer Graphics
Data Science
Earth Science
Ebooks
Economics
Emacs
Engineering
Expatriates
French Language
Gardening & Landscaping
Genealogy & Family History
German Language
Hardware Recommendations
Hinduism
Homebrewing
Islam
Italian Language
Japanese Language
Joomla
Lifehacks
Martial Arts
Mathematics Educators
Motor Vehicle Maintenance & Repair
Music Fans
Mythology
Open Data
Personal Productivity
Pets
Philosophy
Physical Fitness
Politics
Portuguese Language
Project Management
Puzzling
Quantitative Finance
Reverse Engineering
Robotics
Russian Language
Software Quality Assurance & Testing
Software Recommendations
Sound Design
Space Exploration
Spanish Language
Sports
Startups
Sustainable Living
Tridion
Vi and Vim
Video Production
Windows Phone
Woodworking
Worldbuilding

3 characters:
Cognitive Sciences
elementary OS
Ethereum
History of Science and Mathematics
Linguistics
Open Source
Programming Puzzles & Code Golf
Signal Processing
Tor

Non-ASCII:
Anime & Manga
Arduino
Aviation
Chess
CiviCRM
Poker

Excluded in this challenge for having non-ASCII characters in their names:
LEGO® Answers
Русский язык

Your code should output a consistent distinct value for each of the 4 sets. Each output (or its string representation for non-string values returned from a function) should be no more than 10 bytes, not counting the optional trailing newline.
You can create multiple pieces of code in the same language. The output of your submission is considered to be the output of each piece of code concatenated in a fixed order (so you can use Regex).
Shortest code wins.

This seams like regex golf

Or could be image analysis using the favicon, given that "Anime and Manga" has a Japanese character in that logo - hence being on the "Non-ASCII" list.

@ChrisJ You are not supposed to access Internet for the purpose of this challenge. That might be another question...

The character on Anime & Manga is obviously a 画. But it's not easy to argue whether the thing on Aviation is a ✈. So I decided to follow the easiest way.

So we input the name and output the amount of ascii characters?

@GamrCorps Basically yes. You can also output something else that has no more than 6 characters, as long as each identifies one group.

What defined as 6 characters in the return? For example, what if I return undefined (the value) or an [0,0,0] (array) in JavaScript?

The LEGO® Answers shouldn't be excluded, since all characters are present in the Extended ASCII supersets. One of them is the (currently, the most comon single-byte encoding) ISO-8859-1 which is also known as Latin-1 and is the default for MySQL. In that encoding, it is the character ® has the decimal code 174.

@Mwr247 I didn't think of that. I'm considering also allowing values stored with less than k bytes internally, and relax k to 8 or 10. But the problem is we don't know how a value exactly is stored internally in many languages. So I'm not sure it fixes the problem. The purpose was to not encourage printing a lot of temporary data.

That is a tough one to figure out... Perhaps relax it, but make the phrasing more like: "The output, when stringified, should be no longer than X characters."

I knew SQA had a long official name, but I didn't realize it was the longest name out there... wow...

CJam, 50 48 45 bytes
l22b391"þÁ "+{i%}/"Yª>Þÿ9cîÂcVáòe~"322b4b=

There's unprintable characters in the strings above, which can be obtained by the snippets
[254 193 160]:c
[89 170 62 222 30 255 20 57 99 238 194 99 86 225 242 101 126 20]:c

This also shows that the code points are all below 256. Output is 0 for 1 letter, 1 for 2 letters, 2 for 3 letters and 3 for non-ASCII.
The program simply converts the input string to a base 22 number, performs a series of modulos to reduce the number down, before performing a lookup from a base-4 encoded table.
Try it online | Test suite

You lie! Open Source has 3 letters! How could you do this to my site! I'm... I'm... I'm heartbroken!

@Zizouz212 The 0123 outputs don't correspond to the number of letters each. By "respectively" I was referring to the order listed in the OP, so 0 is 1 letter, 1 is 2 letters, 2 is 3 letters and 3 is non-ASCII. Confusing, yes, but it was the golfiest output choice.

Retina, 146 136 134 130 124 107 102 bytes
A\w*i|Che|CR|ke
4
my|Be|lan|^H.*y$|lt|aw|:|Pa|Ou|Wr
1
gn.|^e|Et|^H.*S|gui|rc|lf|To
2
.*(\d).*
$1
..+
3

Thanks @Sp3000 for golfing off 4 bytes!
Thanks @Mwr247 for golfing off 17 bytes by letting me use regexes from his answer!
Thanks @jimmy23013 for golfing off 5 bytes by reminding me that I can change output values!
The output is 1, 3, 2, and 4 for 1-char, 2-char, 3-char, and non-ASCII, respectively.
Version with all testcases has edits in few places to make it work with multiple lines.
Try it online!
Try it online with all testcases!

@Sp3000 Oh...yeah, thanks! Didn't notice that. That's what happens when you type too fast and don't check it properly afterwards, I guess. I can even i?(ni|vi) -> [nv]?i now.

I have some pretty compact regexes in my JS answer. Feel free to use them if they'll help ;)

@Mwr247 Thanks, I think I'll use them.

I think you can output 3 for 2-char to get rid of the (?!D).

@jimmy23013 That makes sense... I somehow forgot I can move the output values around.

@jimmy23013 Yeah, that's also true now. (EDIT: Not even all 5, first 3 seems enough EDIT2: now) Before it was a bit broken by that 3D Printing. Silly me doesn't remember rules of the challenge for too long.

You lie too! Open Source has 3 letters! I can feel my heart falling from the sky!

@Zizouz212 The output is 2 for 3-char and 3 for 2-char. It's confusing, I know, but it's shorter this way. Your heart needn't fall, for I'd never commit treason against Open Source.

Javscript ES6, 342 339 330 327 bytes
a=>{for(c of "9As4BebFr6He7Hi3LaoMu9PaiTh7Wrzb3DdAmlBi7BiiBo8BugCh6CoiColCohCocDadEa6Eb9Ec5EmbEnbExfFrnGaqGefGeoHa8HibHo5IsgIthJa6Jo9LicMalMayMoaMu9My9OplPe4PeaPhgPh8PojPoiPr8PukQujRe8RogRu10SooSocSohSpgSp6Sp8StiSu7TraVigVidWibWodWoziCodel8EtyHibLibOpvPrhSi3To".split`z`)if(~c.indexOf(a.length.toString(36)+a[0]+a[1]))return c}

Returns a long string starting with 9 for one character, a different long string starting with b for two, a third string starting withi for three, and simply undefined for non-ascii.

Is there anywhere to test it out? I've detected a series of acts of treason against Open Source...

@Zizouz212 here's a fiddle: https://jsfiddle.net/fpt60bpg/

Is it just me, or can I not make it work?

It seems to be working for me.

PowerShell, 212 181 bytes
$a=-join$args[0][0,2,-1];$b="Aty,Ber,Feg,Hah,Hsy,Lww,Msy,Prg,Tes,Wis,Cgs,eeS,Ehm,Hss,Lns,Oee,Pof,Sgg,Trr,Aia,Ado,Ain,Ces,CvM,Pkr".IndexOf($a);(((1,3)[$b-ge40],4)[$b-ge76],2)[$b-lt0]

I found that if you take the first, third, and last characters of each of the possible entries ([0,2,-1] when zero-indexed), we obtain a unique three-letter string for each entry. We then are simply using a string-based lookup to determine which one we have.
Takes input $args[0], and applies the above unique-ness function, saves as $a.
This is then sent through our lookup list via .IndexOf($a) and the result stored in $b. Then, we go through a pseudo-ternary that indexes based on the value of $b to output the appropriate value.
Outputs 1, 2, 3, and 4 for one-character, two-character, three-character, non-ASCII, respectively.
Edit - discovered that [0,2,-1] creates a unique three-character string for each entry, saving 31 bytes

I see that you've got "coffee" hardcoded. My brain does, too.

Is there a place where I can test it out?

@Zizouz212 Any Windows computer. There's also this, but it doesn't seem to be working and apparently it's PASH, not PowerShell proper.

@Zizouz212 PowerShell is pseudo-proprietary, in that it's Windows-only. There are free ways to install virtualized Windows (evaluation versions, developer editions, etc.) if you're a FOSS user. PASH is an open-source blend of PowerShell and BASH, but it's reverse-engineered rather than direct, and only implements about 40% of the PowerShell v1 features, so it is rather limited.

JavaScript (ES6), 108 bytes
a=>[/A\w*i|Che|CR|ke/,/my|Be|lan|^H.*y$|lt|aw|:|Pa|Ou|Wr/,/gn.|^e|Et|^H.*S|gui|rc|lf|To/].map(b=>+b.test(a))

Creates an array composed of regex matches unique to each of the three smallest groups (1 character, 3 character, and non-ascii), then maps a test on the data for each array. When the output is stringified, it evaluates to 1,0,0 for non-ascii, 0,1,0 for 3 characters, 0,0,1 for 1 character, and 0,0,0 for 2 characters.

Jelly, 41 bytes
ȷ;€ȷḥ€ɠḋ“¥ẏ⁻ỵŻŀ]Ḥ6Iɠçịƥṃƈ=ẈQk®bȷƥ!?’b5¤%5

Try it online!
Full program: input from standard input, output to standard output. Output is 1/2/3/0 for 1 character / 2 characters / 3 characters / non-ASCII.
Discussion
Hey, I found another question where my algorithm for automatically generating answers to "map this input to that output" questions beats all the existing answers. So here we go.
I used this generator (which I wrote myself) in order to automatically generate this output. For information on the underlying algorithm and how it works, see this answer and this answer.
This question isn't an ideal fit for the algorithm in question, incidentally. There are two issues which mean that it could well be beatable.
The first issue is that 4 (the number of possible outputs) is not a prime number. The algorithm itself doesn't technically require the number of outputs to be prime, just a prime power (because we need a finite field of the appropriate size). 4 is a prime power (2²), so it would be an ideal fit for the question. However, Jelly doesn't have any builtins for operating on GF(4), so we're using GF(5) instead, which multiplies the size of our long constant by a factor of log(5)/log(4), an increase of about 16%.
The second issue is that 2 is an overwhelmingly common output, with most of the inputs mapping to it. The algorithm doesn't care about this at all, and works equally well with any distribution of outputs. However, an output that did care about this fact could probably take advantage of it in order to use a shorter constant string. Although it's easy to imagine what such an algorithm could look like (and it could use almost the same program shell), I can't think of any efficient way to calculate the string constant that most of the program is built around.
Of course, there's also the fact that the total amount of data required is so small that the overhead of the decompressor is rather notable, and a less efficient algorithm could beat it simply by needing a smaller amount of boilerplate!
So I imagine there's scope for improvement here, although I can't immediately see how. It's still interesting to see a machine-generated solution beating all the human-written solutions, though.
Explanation
ȷ;€ȷḥ€ɠḋ“…’b5¤%5
ȷ;€ȷ               Generate 1000 different (arbitrary) hash configurations
    ḥ              Hash
      ɠ              standard input
     €               using each of the hash configurations
       ḋ           Take the dot product of the resulting vector of 1000 hashes
             ¤       with
        “…’b5        a particular list of numbers in the range 0…4 inclusive
              %5   {The output is} that dot product, modulo 5

The long list of numbers is chosen to give the correct output for every input (by asking a computer, specifically my generator written in a mix of Jelly and Sage, to find a short list that happens to give the correct input/output mapping).

Why'd you make this CW?

I make all my posts community wiki. There's normally no real connection between the sorts of answers that get you lots of reputation and the sorts of answers that actually make the site better. I'd much rather be posting the latter than the former, and CWing all my posts helps to avoid any incentive to post answers purely to get upvotes. (It also makes my posts easier to edit – I think people should be editing posts more often, although I don't do it myself because there's an unavoidable +2 reputation gain for low-reputation post editors.)


text:
Expand a bash brace expansion
For mostly historical reasons, bash is quite a hodge-podge of syntax and programming paradigms - this can make it awkward and sometimes frustrating to golf in.  However it does have a few tricks up its sleeve that can often make it competitive with other mainstream script languages.  One of these is brace expansion.
There are two basic types of brace expansion:

List braces may contain comma-separated lists of arbitrary strings (including duplicates and the empty string).  For example {a,b,c,,pp,cg,pp,} will expand to a b c  pp cg pp (note the spaces around the empty strings).
Sequence braces may contain sequence endpoints separated by ... Optionally another .. may follow, followed by a step size.  Sequence endpoints may be either integers or characters.  The sequence will automatically ascend or descend according to which endpoint is greater.  For example:

{0..15} will expand to 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
{-10..-5} will expand to -10 -9 -8 -7 -6 -5
{3..-6..2} will expand to 3 1 -1 -3 -5
{a..f} will expand to a b c d e f
{Z..P..3} will expand to Z W T Q

Beyond this, sequence and list braces may exist with list braces:

{a,b,{f..k},p} will expand to a b f g h i j k p
{a,{b,c}} will expand to a b c

Braces expand with non-whitespace strings either side of them.  For example:

c{a,o,ha,}t will expand to cat cot chat ct

This also works for multiple braces concatenated together:

{ab,fg}{1..3} will expand to ab1 ab2 ab3 fg1 fg2 fg3

This can get quite complex.  For example:

{A..C}{x,{ab,fg}{1..3},y,} will expand to Ax Aab1 Aab2 Aab3 Afg1 Afg2 Afg3 Ay A Bx Bab1 Bab2 Bab3 Bfg1 Bfg2 Bfg3 By B Cx Cab1 Cab2 Cab3 Cfg1 Cfg2 Cfg3 Cy C

However, if there is whitespace between expansions, then they simply expand as separate expansions.  For example:

{a..c} {1..5} will expand to a b c 1 2 3 4 5

Note how order is always preserved.

Entries for this challenge will expand bash brace expansions as described above.  In particular:

eval by bash (or other shells that perform similar expansion) is not allowed
sequence braces will always be number-to-number, lowercase-to-lowercase or uppercase-to-uppercase with no mixing.  Numbers will be integers in the 32-bit signed range.  If given, the optional step size will always be a positive integer.  (Note that bash will also expand {A..z} as well, but this may be ignored for this challenge)
individual items in list braces will always be composed only of upper- and lower-case alphanumeric characters (empty string included)
list braces may contain arbitrary nestings of other brace expansions
braces may be concatenated arbitrary numbers of times.  This will be limited by your language's memory, so the expectation is that you can theoretically do arbitrary numbers of concatenations but if/when you run out of memory that won't count against you.

The examples in the text above serve as testcases.  Summarised, with each line of input corresponding to the same line of output, they are:
Input
{0..15}
{-10..-5}
{3..-6..2}
{a..f}
{Z..P..3}
{a,b,{f..k},p}
{a,{b,c}}
c{a,o,ha,}t
{ab,fg}{1..3}
{A..C}{x,{ab,fg}{1..3},y,}
{a..c} {1..5}
{a{0..100..10},200}r

Output
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
-10 -9 -8 -7 -6 -5
3 1 -1 -3 -5
a b c d e f
Z W T Q
a b f g h i j k p
a b c
cat cot chat ct
ab1 ab2 ab3 fg1 fg2 fg3
Ax Aab1 Aab2 Aab3 Afg1 Afg2 Afg3 Ay A Bx Bab1 Bab2 Bab3 Bfg1 Bfg2 Bfg3 By B Cx Cab1 Cab2 Cab3 Cfg1 Cfg2 Cfg3 Cy C
a b c 1 2 3 4 5
a0r a10r a20r a30r a40r a50r a60r a70r a80r a90r a100r 200r

I looked into this and it's a pain simply to parse because of all the edge cases :-(

I quite like bash brace expressions.

Ruby, 405 403 401 400 bytes
A wise man (Jamie Zawinski) once said, "Some people, when confronted with a problem, think 'I know, I'll use regular expressions.' Now they have two problems."
I don't think I fully appreciated that quote until I tried to solve this problem with recursive regex. Initially, the regex cases seemed simple, until I had to deal with the edge cases involving letters adjacent to brackets, and then I knew that I was in hell.
Anyways, run it online here with test cases
->s{s.gsub!(/{(-?\w+)..(-?\w+)(..(\d+))?}/){x,y=$1,$2;a,b,c=[x,y,$4].map &:to_i
$1[/\d/]?0:(a,b=x,y)
k=a<b ?[*a..b]:[*b..a].reverse
?{+0.step(k.size-1,$4?c:1).map{|i|k[i]}*?,+?}}
r=1
t=->x{x[0].gsub(/^{(.*)}$/){$1}.scan(/(({(\g<1>|,)*}|[^,{}]|(?<=,|^)(?=,|$))+)/).map{|i|i=i[0];i[?{]?r[i]:i}.flatten}
r=->x{i=x.scan(/({(\g<1>)*}|[^{} ]+)/).map(&t)
i.shift.product(*i).map &:join}
s.split.map(&r)*' '}

Ungolfed:
->s{
  s.gsub!(/{(-?\w+)..(-?\w+)(..(\d+))?}/){  # Replace all range-type brackets {a..b..c}
    x,y=$1,$2;a,b,c=[x,y,$4].map &:to_i     # Set up int variables
    $1[/\d/]?0:(a,b=x,y)                    # Use int variables for a,b if they're numbers
    k=a<b ?[*a..b]:[*b..a].reverse          # Create an array for the range in the correct direction
    '{'+                                    # Return the next bit surrounded by brackets
      0.step(k.size-1,$4?c:1).map{|i|k[i]   # If c exists, use it as the step size for the array
      }*','                                 # Join with commas
      +'}'
  }
  r=1                                       # Dummy value to forward-declare the parse function `r`
  t=->x{                                    # Function to parse a bracket block
    x=x[0].gsub(/^{(.*)}$/){$1}             # Remove outer brackets if both are present
                                            # x[0] is required because of quirks in the `scan` function
    x=x.scan(/(({(\g<1>|,)*}|[^,{}]|(?<=,|^)(?=,|$))+)/)
                                            # Regex black magic: collect elements of outer bracket
    x.map{|i|i=i[0];i[?{]?r[i]:i}.flatten   # For each element with brackets, run parse function
  }
  r=->x{                                    # Function to parse bracket expansions a{b,c}{d,e}
    i=x.scan(/({(\g<1>)*}|[^{} ]+)/)        # Regex black magic: scan for adjacent sets of brackets
    i=i.map(&t)                             # Map all elements against the bracket parser function `t`
    i.shift.product(*i).map &:join          # Combine the adjacent sets with cartesian product and join them together
  }
  s.split.map(&r)*' '                       # Split on whitespace, parse each bracket collection
                                            #   and re-join with spaces
}

Python 2.7, 752 728 bytes
Wow, this is like a bunch of code golfs in one challenge!
Thanks to @Neil for shortening a lambda
def b(s,o,p):
 t,f=s>':'and(ord,chr)or(int,str);s,o=t(s),t(o);d=cmp(o,s)
 return list(map(f,range(s,o+d,int(p)*d)))
def e(s):
 c=1;i=d=0
 while c:d+=-~'{}}'.count(s[i])%3-1;i+=1;c=i<len(s)and 0<d
 return i
def m(s):
 if len(s)<1:return[]
 if','==s[-1]:return m(s[:-1])+['']
 i=0
 while i<len(s)and','!=s[i]:i+=e(s[i:])
 return[s[:i]]+m(s[i+1:])
n=lambda a,b:[c+d for c in a for d in b]or a or b
def p(s):
 h=s.count
 if h('{')<1:return[s]
 f,l=s.index('{'),e(s)
 if h('{')<2and h('..')>0and f<1:s=s[1:-1].split('..');return b(s[0],s[1],s[2])if len(s)>2 else b(s[0],s[1],1)
 if f>0 or l<len(s):return n(p(s[:f]),n(p(s[f:l]),p(s[l:])))
 return sum(map(list,map(p,m(s[1:-1]))),[])
o=lambda s:' '.join(p('{'+s.replace(' ',',')+'}'))

Explanation

b: calculates range according to specs.
e: returns position of first outermost close brace. Iterative.
m: splits outermost elements on commas. Recursive.
n: combines arrays while checking for empties. I couldn't get and/or to work.
p: Where most of the work is done. Checks all the cases (Range, just list, needs to combine). Recursive.
o: What should take input. Formats input/output to p.

I feel I can improve in some places, so I will try to golf more. Also I should put in more detail in the explanation.

I would have expected [c+d for c in a for d in b] or a or b to work.

JavaScript (Firefox 30-57), 465 427 425 bytes
f=s=>/\{/.test(s)?f(s.replace(/([^,{}]*\{[^{}]*\})+[^,{}]*/,t=>t.split(/[{}]+/).map(u=>u.split`,`).reduce((a,b)=>[for(c of a)for(d of b)c+d]))):s.split`,`.join` `
s=>f(`{${s.split` `}}`.replace(/\{(-?\w+)\.\.(-?\w+)(\.\.(\d+))?\}/g,(m,a,o,_,e)=>{m=(a>'@')+(a>'_');a=parseInt(a,m?36:10);o=parseInt(o,m?36:10);e=+e||1;if(o<a)e=-e;for(r=[];e<0?o<=a:a<=o;a+=e)r.push(m?a.toString(36):a);r=`{${r}}`;return m-1?r:r.toUpperCase()}))

ES6 version of f weighs in at an extra 10 bytes:

f=s=>/\{/.test(s)?f(s.replace(/([^,{}]*\{[^{}]*\})+[^,{}]*/,t=>t.split(/[{}]+/).map(u=>u.split`,`).reduce((a,b)=>[].concat(...a.map(c=>b.map(d=>c+d)))))):s.split`,`.join` `
g=s=>f(`{${s.split` `}}`.replace(/\{(-?\w+)\.\.(-?\w+)(\.\.(\d+))?\}/g,(m,a,o,_,e)=>{m=(a>'@')+(a>'_');a=parseInt(a,m?36:10);o=parseInt(o,m?36:10);e=+e||1;if(o<a)e=-e;for(r=[];e<0?o<=a:a<=o;a+=e)r.push(m?a.toString(36):a);r=`{${r}}`;return m-1?r:r.toUpperCase()}))
h=(s,t=s.replace(/\{[^{}]*\}/,""))=>s!=t?h(t):!/[{}]/.test(s)
<input oninput="o.textContent=h(this.value)?g(this.value):'{Invalid}'"><div id=o>

Explanation: Starts by changing spaces into commas and wrapping the entire string in {} for consistency (thanks to @Blue for the idea). Then searches for all the {..} constructs and expands them into {,} constructs. Next uses recursion to repeatedly expands all {,} constructs from the inside out. Finally replaces all commas with spaces.
f=s=>/\{/.test(s)?                  while there are still {}s
 f(s.replace(                       recursive replacement
  /([^,{}]*\{[^{}]*\})+[^,{}]*/,    match the deepest group of {}s
  t=>t.match(/[^{}]+/g              split into {} terms and/or barewords
   ).map(u=>u.split`,`              turn each term into an array
   ).reduce((a,b)=>                 loop over all the arrays
    [for(c of a)for(d of b)c+d]))   cartesian product
  ):s.split`,`.join` `              finally replace commas with spaces
s=>f(                               change spaces into commas and wrap
 `{${s.split` `}}`.replace(         match all {..} seqences
   /\{([-\w]+)\.\.([-\w]+)(\.\.(\d+))?\}/g,(m,a,o,_,e)=>{
    m=(a>'@')+(a>'_');              sequence type 0=int 1=A-Z 2=a-z
    a=parseInt(a,m?36:10);          convert start to number
    o=parseInt(o,m?36:10);          convert stop to number
    e=+e||1;                        convert step to number (default 1)
    if(o<a)e=-e;                    check if stepping back
    for(r=[];e<0?o<=a:a<=o;a+=e)    loop over each value
     r.push(m?a.toString(36):a);    convert back to string
    r=`{${r}}`;                     join together and wrap in {}
    return m-1?r:r.toUpperCase()})) convert type 1 back to upper case

source: Stack Exchange

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

sort: votes


text:
Highly composite numbers
A highly composite number is a positive integer that has more divisors than any smaller positive integer has. This is OEIS sequence A002182. Its first 20 terms are
1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260, 1680, 2520, 5040, 7560

For example, 4 is in the sequence because it has 3 divisors (namely 1, 2, 4), whereas 3 only has 2 divisors, 2 also has 2 divisors, and 1 has 1 divisors.
Challenge
Given a positive integer input n, output either the n-th highly composite number or the first n highly composite numbers, at your choice (but the choice must be the same for every input n).
Rules
The program or function should theoretically work for arbitrarily large inputs given infinite time and memory, and without considering data type limitations. Essentially, this means no hardcoding a finite number of values.
In practice, the program or function should run in a reasonable amount of time, say less than 1 minute, for n up to 20. Maximum input or output may be limited by your language standard data type (but again, the algorithm should theoretically work for arbitrarily large numbers).
Any reasonable input and output format is allowed, including unary.
Code golf. Fewest bytes wins.

This conversation has been moved to chat.

Can the nth-index be zero-indexed or must this be 1-indexed?

@AandN I hadn't thought of that, so let's say both are accepted. (I seem to recall a meta post proposing both 1-based and 0-based are allowed, but I can't find it. Anyone?)

05AB1E, 15 14 bytes
The input in zero-indexed. That means that n = 0 gives 1, n = 1 gives 2, etc. Code:
$µ>DÑgD®›i©¼}\

Explanation:
$               # Pushes 1 and input
 µ              # Counting loop, executes until the counting variable is equal to input
  >             # Increment (n + 1)
   DÑ           # Duplicate and calculate all divisors
     gD         # Get the length of the array and duplicate
       ®        # Retrieve element, standardized to zero
        ›i  }   # If greater than, do...
          ©     #   Copy value into the register
           ¼    #   Increment on the counting variable
             \  # Pop the last element in the stack

Calculates n = 19, which should give 7560 in about 10 seconds.
Try it online!
Uses CP-1252 encoding.

Jelly, 15 bytes
,®ÆDL€ṛ©0>/?µƓ#

For input n, this prints the first n highly composite numbers.
For n = 20, it takes less than two seconds on Try it online!
How it works
,®ÆDL€ṛ©0>/?µƓ#  Main link. No implicit input.

            µ    Push the chain to the left on the local link stack.
             Ɠ   Read an integer n from STDIN.
              #  Execute the chain for k = 0, 1, 2, ..., until it returned a truthy
                 value n times. Return the list of matches.

,®               Pair k with the value in the register (initially 0).
  ÆD             Compute the divisors of k and the register value.
    L€           Count both lists of divisors.
           ?     If
         >/        k has more divisors than the register value:
      ṛ©             Save k in the register and return k.
        0          Else: Return 0.

Alternate version, 13 bytes (non-competing)
While the below code worked in the latest version of Jelly that precedes this challenge, the implementation of M was very slow, and it did not comply with the time limit. This has been fixed.
ÆDL®;©MḢ’>µƓ#

Try it online!
How it works
ÆDL®;©MḢ’>µƓ#  Main link. No implicit input.

          µ    Push the chain to the left on the local link stack.
           Ɠ   Read an integer n from STDIN.
            #  Execute the chain for k = 0, 1, 2, ..., until it returned a truthy
               value n times. Return the list of matches.

ÆD             Compute the divisors of k.
  L            Count them.
   ®;          Append the count to the list in the register (initially 0 / [0]).
     ©         Save the updated list in the register.
      M        Obtain all indices the correspond to maximal elements.
       Ḣ       Retrieve the first result.
        ’>     Subtract 1 and compare with k.
               This essentially checks if the first maximal index is k + 2, where
               the "plus 2" accounts for two leading zeroes (initial value of the
               register and result for k = 0).

There's also RÆDL€MḢ=µƓ# (11 bytes), but it takes 44 minutes on my machine...

MATL, 26 24 bytes
~XKx`K@@:\~s<?@5MXKx]NG<

Try it online!
The current largest number of divisors found is kept in clipboard K. Highly composite numbers (HCN) are kept directly on the stack. A loop keeps testing candidates to HCN. When one is found it is left on the stack, and clipboard K is updated. The loop exits when the desired number of HCN have been found.
~         % take input implicitly (gets stored in clipboard G). Transform into a 0
          % by means of logical negation
XKx       % copy that 0 into clipboard K, and delete
`         % do...while
  K       %   push largest number of divisors found up to now
  @       %   push iteration index, i: current candidate to HCN
  @:      %   range [1,...,i]
  \       %   modulo operation
  ~s      %   number of zeros. This is the number of divisors of current candidate
  <       %   is it larger than previous largest number of divisors?
  ?       %   if so: a new HCN has been found
    @     %     push that number
    5M    %     push the number of divisors that was found
    XKx   %     update clipboard K, and delete
  ]       %   end if
  N       %   number of elements in stack
  G<      %   is it less than input? This the loop condition: exit when false
          % end do...while implicitly
          % display all numbers implicitly

Perl, 60 57 + 1 = 58 bytes
$,++;$==grep$,%$_<1,1..$,;$_--,$m=$=if$=>$m;$_?redo:say$,

Requires -n and the free -M5.010|-E:
$ perl -nE'$,++;$==grep$,%$_<1,1..$,;$_--,$m=$=if$=>$m;$_?redo:say$,' <<< 10
120

How it works:
$,++;
     $==grep$,%$_<1,1..$,;                                # Calculate total numbers of divisors for `$,`
                          $_--,$m=$=if$=>$m;              # Set `$m`ax divisors to `$=`ivisors if `$m>$=`
                                            $_?redo:say$, # Repeat or print

Pyth, 17 16 bytes
1 byte thanks to Jakube
uf<Fml{yPd,GTGQ1

Test suite
Takes a 0-indexed n, and returns the nth highly composite number.
Explanation:
uf<Fml{yPd,GThGQ1
                     Input: Q = eval(input())
u              Q1    Apply the following function Q times, starting with 1.
                     Then output the result. lambda G.
 f           hG      Count up from G+1 until the following is truthy, lambda T.
          ,GT        Start with [G, T] (current highly comp., next number).
    m                Map over those two, lambda d.
        Pd           Take the prime factorization of d, with multiplicity.
       y             Take all subsets of those primes.
      {              Deduplicate. At this point, we have a list of lists of primes.
                     Each list is the prime factorization of a different factor.
     l               Take the length, the number of factors.
  <F                 Check whether the number of factors of the previous highly
                     composite number is smaller than that of the current number.

JavaScript (ES6) 72
Straightforward implementation. Time near 20 sec for input 20
x=>{for(i=e=n=0;i<x;d>e&&(++i,e=d))for(d=1,j=++n;--j;)n%j||++d;return n}

The eval trick could save a byte doubling the run time
x=>eval("for(i=e=n=0;i<x;d>e&&(++i,e=d))for(d=1,j=++n;--j;)n%j||++d;n")

Less golfed
x=>{
  for(i = e = 0, n = 1; i < x; n++)
  {
    for(d = 1, j = n; --j; )
    {
      if (n%j == 0)
        ++d;
    }
    if (d > e)
      ++i,
      e = d;
  }
  return n;
}

Jelly, 10 bytes
1Æd€<Ṫ$PƊ#

Try it online!
Returns the first \$n\$ highly composite numbers.
My guess is that this uses features unavailable when Dennis first posted a Jelly answer, but this uses a sufficiently different algorithm that I thought it was ok to post as a separate answer
How it works
1Æd€<Ṫ$PƊ# - Main link. Takes no arguments
1       Ɗ# - Read an integer n from STDIN and run the following over k = 1, 2, 3, ... until n return true:
   €       -   Generate the range [1, 2, ..., k] and do the following over each:
 Æd        -     Calculate the divisor count of each, yielding [σ₀(1), σ₀(2), ..., σ₀(k)]
      $    -   Group the previous two commands together:
     Ṫ     -     Remove σ₀(k) from the list and return it
    <      -     Generate [σ₀(1)<σ₀(k), σ₀(2)<σ₀(k), ..., σ₀(k-1)<σ₀(k)]
       P   -   Are all values true?

Ruby, 70 69 67 66 64 62
->n{r=k=0
0until(r<t=(1..k+=1).count{|d|k%d<1})&&1>n-=t/r=t
k}

Straightforward implementation.

C, 98 bytes
f,i,n,j;main(m){for(scanf("%d",&n);n--;printf("%d ",i))for(m=f;f<=m;)for(j=++i,f=0;j;)i%j--||f++;}

Try it here.
Ungolfed
f,i,n,j;

main(m)
{
    for(scanf("%d",&n); /* Get input */
            n--; /* Loop while still HCN's to calculate... */
            printf("%d ",i)) /* Print out the last calculated HCN */
        for(m=f;f<=m;) /* Loop until an HCN is found... */
            for(j=++i,f=0;j;) /* Count the number of factors */
                i%j--||f++;
}

Python 3, 97 bytes
i=p=q=0;n=int(input())
while q<n:
 c=j=0;i+=1
 while j<i:j+=1;c+=i%j==0
 if c>p:p=c;q+=1
print(i)

A full program that takes input from STDIN and prints the output to STDOUT. This returns the nth 1-indexed highly composite number.
How it works
This is a straightforward implementation. The input n is the highly composite number index.
The program iterates over the integers i. For each integer j less than i, i mod j is taken; if this is 0, j must be a factor of i and the counter c is incremented, giving the number of divisors of i after looping. p is the previous highest number of divisors, so if c > p, a new highly composite number has been found and the counter q is incremented. Once q = n, i must be the nth highly composite number, and this is printed.
Try it on Ideone
(This takes ~15 seconds for n = 20, which exceeds the time limit for Ideone. Hence, the example given is for n = 18.)

Python 2, 207 bytes
n,i,r,o=input(),1,[],[]
while len(o)<n:
 r+=[(lambda n:len(set(reduce(list.__add__,([i,n//i]for i in range(1,int(n**0.5)+1)if n%i==0)))))(i)];h=max(r)
 if r.index(h)>i-2 and r.count(h)<2:o+=[i]
 i+=1
print o

Uses the same method as Dennis' Jelly answer. Calculates the first 20 terms in <2 seconds.

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

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


text:
Crunch vowels out of a string
Task description
Sometimes, you really need to fit something you’re writing in a small space. It may be tempting to drop the vowels and wrt lk ths – and failing that, who really needs spaces? Thssprfctlrdbl!†
Write a function or program that removes lowercase vowels aeiou, and then spaces, and then any characters from an input string. Furthermore, each time you remove a character, it must be the rightmost character eligible for removal. It must repeat this process until the string is no longer than some given input length.
† “This is perfectly readable!” But if you’re reading this footnote, it probably isn’t, really... :)
Examples
Here, you can see this process applied for successively smaller input sizes:
23: Hello, Code Golf World!
22: Hello, Code Golf Wrld!
21: Hello, Code Glf Wrld!
20: Hello, Cod Glf Wrld!
19: Hello, Cd Glf Wrld!
18: Hell, Cd Glf Wrld!
17: Hll, Cd Glf Wrld!
16: Hll, Cd GlfWrld!
15: Hll, CdGlfWrld!
14: Hll,CdGlfWrld!
13: Hll,CdGlfWrld
12: Hll,CdGlfWrl
11: Hll,CdGlfWr
(etc.)

After squeezing the string down to 17 characters, we run out of vowels to remove, so the next character we remove is the rightmost space; when we hit 14 characters, we’ve removed all vowels and spaces, so we simply start munching the string from right to left.
Here is some pseudocode Python code that solves this challenge:
def crunch_string(string, to_length):
    while len(string) > to_length:
        # Store the best candidate index for deletion here.
        best = None

        # First, find the rightmost vowel's index.
        for i in range(len(string)):
            if string[i] in 'aeiou':
                best = i

        # If there were no vowels, find the rightmost space's index.
        if best is None:
            for i in range(len(string)):
                if string[i] == ' ':
                    best = i

        # If there were no spaces either, use the final index.
        if best is None:
            best = len(string) - 1

        # Remove the selected character from the string.
        string = string[:best] + string[best + 1:]

    # Return the string once `len(string) <= to_length`.
    return string

Rules

This is code-golf, so the shortest code in bytes wins.
The input string will consist of the printable ASCII characters from space (, decimal 32) up to and including tilde (~, decimal 126). There will be no uppercase vowels AEIOU in the string. In particular, there will be no Unicode, tabs, or newlines involved.
Call the input string s, and the input target length t. Then 0 < t ≤ length(s) ≤ 10000 is guaranteed. (In particular, the input string will never be empty. If t = length(s), you should just return the string unmodified.)

Test cases
Input:  50, Duis commodo scelerisque ex, ac consectetur metus rhoncus.
Output: Duis commodo scelerisque ex, ac cnscttr mts rhncs.

Input:  20, Maecenas tincidunt dictum nunc id facilisis.
Output: Mcnstncdntdctmnncdfc

Input:  150, golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf
Output: glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glf glfglfglfglfglfglfglfglfglfglf

Is y a vowel ?

Can’t believe I forgot to explain that! No, aeiou are vowels, and AEIOU will not occur, for simplicity. (The whole uppercase/lowercase thing is not what I want to focus on.) I added clarification.

Very nice challenge!

@edc65 Don't forget w (for example, in the word cow, w is a vowel!) Of course, that's settled for this one, but for where it's not stated that the set of vowels is aeiou, you should sometimes include y and w. :-O

Unrelated to golfing, but consider for index, char in enumerate(string) instead of the range(len(str)) construct

@JeremyWeirich I intentionally wrote the code in such a way that non-Pythonistas might still be able to read it without knowing Python :)

MATL, 20 bytes
t11Y2mEG32=+K#Si:)S)

Try it online!
t       % implicitly input string. Duplicate
11Y2    % predefined literal 'aeiou'
m       % ismember. Gives true for input characters that are vowels
E       % multiply by 2
G       % push input string again
32      % ASCII for space
=       % gives true for input characters that are spaces
+       % add: gives 2 for vowels, 1 for space, 0 for non-vowels-and-non space
K#S     % sort and push only the indices of the sorting. Sorting is stable, so first
        % will be non-vowels-and-non space characters in their original order, then
        % spaces in their original order, then vowels in their original order
i       % input number n of characters that should be kept
:       % range [1,2,...,n]
)       % index with that: keep first n indices of the sorting
S       % sort those indices to restore their original order
)       % index into input string to keep only those characters. Implicitly display

Perl, 48 45 43 bytes
Includes +4 for -Xlpi (-X can be left out but leaves ugly warnings on STDERR)
Run with the number after the -i option and the input on STDIN (supports multiple lines too). e.g. perl -Xlpi50 crunch.pl <<< "Duis commodo scelerisque ex, ac consectetur metus rhoncus."
crunch.pl:
s/.*\K[aeiou]|.*\K |.$// while pos=-$^I

You don't need the space between /$+/ and while

I think you shave a byte by using a ^I (tab character) instead of "^I". (Untested.)

@chilemagic: dropping the space between /$+/ and while only works with older perls. Recent perls changed the parser to keep open the ability to add new regex modifiers (like a w modifier)

@msh210: Works for some magic variables, but not for the ones based on whitespace

JavaScript (ES6), 66 61 bytes
Saved 5 bytes thanks to @Neil
f=(s,n)=>s[n]?f(s.replace(/(.*)[aeiou]|(.*) |.$/,"$1$2"),n):s

I don't think the regex is golfable further. Surprisingly, the shortest I can come up with to remove front-to-back is a byte longer:
f=(s,n)=>s[n]?f(s.replace(/(.*?)[aeiou]|(.*?) |./,"$1$2"),n):s

More interesting attempt (ES7), 134 bytes
(s,n,i=0)=>[for(c of s)[/[aeiou]/.test(c)*2+(c<'!'),i++,c]].sort(([x],[y])=>x-y).slice(0,n).sort(([,x],[,y])=>x-y).map(x=>x[2]).join``

This uses an approach similar to the MATL answer.

I don't care if it's not golfable, that's a beautiful regex.

Although I've just noticed that you can use |.$/,"$1$2" to save 5 bytes.

@Neil Thanks for the tip!

sh + gnu sed, 78 61
Supply the string to STDIN, the length as first argument.
rev|sed -r ":                       # reverse + invoke sed + jump label ":"
/..{$1}/!q                          # if the length is not greater $1, quit
p                                   # print
s/[aeiou]//                         # delete the first vowel
t                                   # if successful, start over at ":"
s/ //                               # delete the first space
t                                   # if successful, start over at ":"
s/.//                               # delete the first character
t"|rev                              # if successful, start over at ":" + reverse

Perl, 68
Removing from the right adds a ton of characters, maybe there is a better way to do this.
$_=reverse;while(length>$^I){s/[aeiou]//||s/ //||s/.//}$_=reverse

Use -i to input the number. It is 65 characters plus 3 for the i, p, and l on the command line.
Run with:
echo 'Hello, Code Golf World!' | perl -i13 -ple'$_=reverse;while(length>$^I){s/[aeiou]//||s/ //||s/.//}$_=reverse'

You can use y///c instead of length and you can move the while loop to the end: s///||s///||s///while$^I<y///c

Java 8, 303 bytes
(s,j)->{String t="";for(int i=s.length()-1;i>=0;t+=s.charAt(i--));while(t.length()>j&&t.matches(".*[aeiou].*"))t=t.replaceFirst("[aeiou]","");while(t.length()>j&&t.contains(" "))t=t.replaceFirst("\\s","");s="";for(int i=t.length()-1;i>=0;s+=t.charAt(i--));return s.substring(0,Math.min(t.length(),j));};

This is WAY too long. Ill try to shorten it soon. It would be much shorter if java had a method for reversing strings and backward replacements.
Test with the following:
public class StringCruncher {
    public static void main(String[] args) {
        Tester test = (s,j)->{String t="";for(int i=s.length()-1;i>=0;t+=s.charAt(i--));while(t.length()>j&&t.matches(".*[aeiou].*"))t=t.replaceFirst("[aeiou]","");while(t.length()>j&&t.contains(" "))t=t.replaceFirst("\\s","");s="";for(int i=t.length()-1;i>=0;s+=t.charAt(i--));return s.substring(0,Math.min(t.length(),j));};
        System.out.println(test.crunch("golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf", 150));
    }
}
interface Tester {
    String crunch(String s, int j);
}

The underwhelming majority on meta says you can save a byte with currying

@Cyoce it seems that currying does not work in this case (s->j->{...}). I think either Java does not support it very well or I am setting it up wrong.

Compiled languages probably have a hard time with currying  because of first class functions

@GamrCorps  I'll check and see if I can make it work when I get home

Scala, 160 bytes
type S=String;def f(s:S,l:Int)={def r(s:S,p:S):S=if(s.size>l){val j=s.replaceFirst("(?s)(.*)"+p,"$1");if(j==s)s else r(j,p)}else s;r(r(r(s,"[aeiou]")," "),".")}

Tester:
val t="Hello, Code Golf World!"
println((t.size to 11 by -1).map(f(t,_)).mkString("\n"))

C#, 180 bytes
string c(int l,string s){while(s.Length>l){int i=0;Func<string,bool>f=t=>(i=s.LastIndexOfAny(t.ToCharArray()))!=-1;if(!(f("aeiou")||f(" ")))i=s.Length-1;s=s.Remove(i,1);}return s;}

Tester:
using System;
class Crunch
{
    static int Main()
    {
        var x = new Crunch();
        Console.WriteLine(x.c(50, "Duis commodo scelerisque ex, ac consectetur metus rhoncus."));
        Console.WriteLine(x.c(20, "Maecenas tincidunt dictum nunc id facilisis."));
        Console.WriteLine(x.c(150, "golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf golf"));
        Console.Read();
        return 0;
    }
    string c(int l,string s){while(s.Length>l){int i=0;Func<string,bool>f=t=>(i=s.LastIndexOfAny(t.ToCharArray()))!=-1;if(!(f("aeiou")||f(" ")))i=s.Length-1;s=s.Remove(i,1);}return s;}

    static string crunch(int len, string str)
    {
        Console.WriteLine($"{str.Length}: {str}");
        while (str.Length > len) {
            int idx=0;
            Func<string,bool> f = s => (idx = str.LastIndexOfAny(s.ToCharArray()))!= -1;
            if (!(f("aeiou") || f(" "))) idx = str.Length-1;
            str = str.Remove(idx,1);
            Console.WriteLine($"{str.Length}: {str}");
        }
        return str;
    }
}

Dyalog APL, 77 45 42 bytes
t[⌽i~⌽⎕↓⌽∪∊(t∊'aeiou')(' '=t)1/¨⊂i←⍳⍴t←⌽⍞]

t[…] letters of t with indices...
t←⌽⍞ t gets reversed text input
i←⍳⍴t i gets indices of length of t
/¨⊂i multiple (3) boolean selections of elements of i:
1. (t∊'aeiou') boolean where vowel
2. (' '=t) boolean where space
3. 1 all
∪∊ unique of the enlisted (flattened) 3 selections
⌽⎕↓⌽ drop last evaluated-inputted characters (same as (-⎕)↓)
⌽i~ reverse the remaining indices after removing some

Original answer:
⎕{⍺≥≢⍵:⌽⍵⋄∨/⍵∊⍨v←'aeiou':⍺∇⍵/⍨~<\(⍳⍴⍵)∊⍵⍳v⋄' '∊⍵:⍺∇⍵/⍨~<\(⍳⍴⍵)=⍵⍳' '⋄⍺∇1↓⍵}⌽⍞

Ehm, yeah, that is a bit hard to read. Basically the direct translation of OP into APL:

Reverse input.
If required length is longer or equal to the count of (reversed) input string, then return reversed (reversed) argument.
Else, if argument has any vowel, remove the first (i.e. last) one and call recursively on what remains.
Else, if argument has any space, remove the first (i.e. last) one and call recursively on what remains.
Else, remove the first (i.e. last) character and call recursively on what remains.

Lua, 120 bytes
s=arg[2]:reverse()a=s:len()-arg[1]s,n=s:gsub('[aeiou]','',a)s,m=s:gsub(' ','',a-n)print(s:gsub('.','',a-n-m):reverse())

Takes input as command line arguments, in the format lua crunch.lua 10 "This is a string", with output Ths sstrng.
Explanation:
-- Set 's' to the reverse of the string
s=arg[2]:reverse()
-- Set 'a' to the number of characters to be removed
a=s:len()-arg[1]
-- Remove 'a' vowels, set 'b' to the number of substitutions
s,b=s:gsub('[aeiou]','',a)
-- Remove 'a-b' spaces, set 'c' to the number of substitutions
s,c=s:gsub(' ','',a-b)
-- Remove 'a-b-c' characters, and print the now un-reversed string
print(s:gsub('.','',a-b-c):reverse())

Mathematica, 201 Bytes
f@x_:=StringReplaceList[x,"a"|"e"|"i"|"o"|"u"->""];g@x_:=StringReplaceList[x," "->""];x_~l~y_:=NestWhile[If[f@#!={},Last@f@#,If[g@#!={},Last@g@#,Last@StringReplaceList[#,_->""]]]&,x,StringLength@#!=y&]

There must be a better way than this..

R, 169 143 bytes
function(x,y){d=utf8ToInt(x);o=c(rev(which(d%in%utf8ToInt('aeiou'))),rev(which(d==32)));intToUtf8(d[sort(tail(c(o,setdiff(nchar(x):1,o)),y))])}

*edit saved 36 bytes through rewrite with utf8ToInt -> intToUtf8 conversions  not strstplit and paste0(...,collapse)
ungolfed with explanation
function(x,y){d=utf8ToInt(x);         # convert string (x) to integer
o=c(
 rev(which(d%in%utf8ToInt('aeiou'))), # index of vowels (reversed)
 rev(which(d==32)));                  # index of spaces
 intToUtf8(d[                         # convert subset back to character
   sort(tail(                         # return the first y index of
                                      # "left over" characters
   c(o,setdiff(nchar(x):1,o))         # combine vowels, spaces and
                                      # other indices in appropriate order
  ,y))])}


text:
Determining vertical slices
Given an image, output the [width in pixels of a full vertical section]1 (if one exists). If no vertical section exists, output 0.
Input may be provided as a local file or a nested array. If you choose to take input as a nested array, white pixels should be represented by a truthy value while non-white pixels should be represented by a falsey value.
1. the number of contiguous, all-white columns

You can assume that

no image will be larger than 1000 square pixels
there will be no more than one full vertical section per image

Examples
Inputs:

Outputs:
50
57
0
0

Here are the first two examples, highlighted (in yellow) to show their sections:

Can there be islands of black in the middle so that there's multiple vertical sections?

@xnor: There will only ever be one full vertical section per image. I'll add that to the spec.

My code is outputting 50 for the first test case, but correct numbers for the last 3, with the vertical slice from columns 233 to 282 (=50 pixels across). Can you confirm 48 is the correct number?

@David: I see the correct slice from columns 232 to 282 (exclusive). I believe you're right.

If we take input as a nested array, can the nesting go either way (column nesting vs row nesting)?

@xnor: Only row nesting ;)

I don't think anyone's having problems, but it might be worth explicitly mentioning that you're looking for the number of contiguous, all-white columns. It's clear from the example, but it's generally preferred to not rely on examples or test cases.

@MichaelS: Great idea. I'm gonna quote you on that. Thanks!

Jelly, 2 bytes
PS

Try it here!
If I encode an image like so:
0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

Into a nested array like this:
[[0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0],...]

Then P takes the element-wise product of all of the row vectors, and S sums all of the ones in the result, yielding the length of the vertical slice. (This works only because there’s guaranteed to be only one contiguous slice.) In our case, the answer is 3.

ಠ_ಠ This level of golf astounds me.

What is the output for when there is no contiguous slices? (valid input)

ps works in MATL too!

Then there will be no column of all 1s, meaning the result of P will be [0,0,0...0], of which the Sum is 0, as expected.

@David Post it then? You might need Xps, though, if the image can be a single row (or ask the OP if there's a minimum size)

@DonMuesli: There's no minimum size.

APL, 4 bytes
+/×⌿

Try it here.
This is my first APL answer!
Thanks to @jimmy23013 and @NBZ for saving bytes!

This is not a function. (+/×/⍉) doesn't work.

But you can use (+/×⌿) and that's 1 byte shorter.

Save another 2 bytes by removing the parentheses. Lots of other APL answers have just an anonymous function train that must named or parenthesized to be used: +/×⌿ f←+/×⌿ f picture

Perl, 21 22 bytes
Fixed version
Includes +2 for -lp (-l can be omitted and would still be a valid solution, but it's ugly without the final newline)
Give sequences of 1's and 0's on 0 or more lines on STDIN.
You can add spaces or commas or whatever between the digits if you want as long as the usage is.consistent on all lines.
$a|=~$_}{$_=$a=~y;\xce;

This works as shown, but replace \xce by the literal byte value to get the claimed score
If there are multiple vertical sections this returns the sum of all section widths. If you want the width of a vertical section use
$a|=~$_}{$a=~/\xce+/;$_="@+"-"@-"

Old version
I originally misunderstood the challenge and implemented a program that gives true or false based on if a vertical line exists at all. Code and explanation here are for this old version
$a|=~$_}{$_|=~$a=~1

If only I could add 1=~ at the left for almost perfect symmetry... I suppose the closest would be
1=>$a|=~$_}{$_|=~$a=~1

Explanation
$a|=~$_     The bitwise operators in perl (&, |, ^, ~) also work on strings by
            working on the sequence of byte values. The digits "0" and "1" happen
            to have the same ASCII value differing only in the last bit which is
            0 for "0" and 1 for "1". So I would really like to do an "&" here.
            Unfortunately "&" of two different length strings shortens the result
            to the shortest of the strings and my accumulator starts as an empty
            string. The "|" of two strings however extends to the longest string.
            So instead I will apply De Morgan's law and use "|" on the
            complemented byte string
}{          Standard perl golf trick. "-p code" transforms to (simplified)
            "while (<>) { code; print }". So if code is "code1 } { code2" this
            becomes "while (<>) { code1 } {code2; print }". So you can use code1
            for the loop operation, use code2 for the final calculation and get a
            free print by assigning to $_
$_|=~$a=~1  I would like to match the accumulator with the bit complement of "1",
            but $a=~~1 doesn't work because the 1 is not a string but a number.
            $a=~~"1" would work but is too long. Next up is complementing $a back
            and matching with 1, so $_=~$a=~1. That also doesn't work since the
            first =~ will be interpreted as a string match insteads of equals
            followed by complement. Easily solved by writing it as $_= ~a=~1. But
            if I am going to give up a byte I can at least have some fun with it.
            Using $_|= also makes the parse work and has the advantage that the
            failure case will give 0 instead of an empty string, which looks
            nicer. It also makes the code look very symmetric. I can also bring
            out the symmetry more by putting 1=> in front (which evaluates 1
            before the assignment and then immediately discards it)

Bash + common utilities, 17
rs -Tc|grep -vc 0

If you're not using grep for image-processing, then you're doing it wrong ;-).
This uses the rs utility to do transposition.  rs is bundled in OSX, but will need installing in most linux with something like sudo apt-get install rs.
Input columns are TAB separated, and rows are newline separated:
0   0   0   0   1   1   1   1   1   1   1   1   1   1   0   0   0   0   0
0   0   0   0   0   0   0   1   1   1   1   1   1   1   1   1   0   0   0
0   0   0   0   0   0   0   0   0   1   1   1   1   1   0   0   0   0   0
0   0   0   0   0   0   0   0   1   1   1   1   1   0   0   0   0   0   0
0   0   0   1   1   1   1   1   1   1   1   1   1   1   1   1   1   0   0
0   0   0   0   0   0   1   1   1   1   1   1   0   0   0   0   0   0   0
0   0   0   0   0   0   0   1   1   1   1   1   1   1   1   0   0   0   0
0   0   0   0   1   1   1   1   1   1   1   1   1   1   0   0   0   0   0

If you like, you can preprocess the example input images into this format with imagemagick and (GNU) sed.  E.g:
$ for img in "AmXiR.jpg" "vb2Yt.jpg" "1V7QD.jpg" "MqcDJ.jpg" ; do
>     convert -depth 1 "$img" xpm:- | \
>     sed -nr '/pixels/{:l;n;/}/q;s/^"(.*)",?$/\1/;y/ ./01/;s/./&\t/g;p;bl}' | \
>     rs -Tc|grep -vc 0
> done
50
57
0
0
$

JavaScript (ES6), 54 45 43 bytes
a=>a[s=0].map((_,i)=>s+=a.every(b=>b[i]))|s
a=>a[s=0].map((_,i)=>s+=!a.some(b=>b[i]))|s

Based on @Lynn's Jelly answer, though since golfed by using every or some instead of reduce. The first version encodes black = 0 while the second encodes black = 1.
Edit: Saved 2 further bytes thanks to @edc65.

Try using map

It's 45 in my count. And you did not tried hard enough because it could be 43.

a=>a[s=0].map((_,i)=>s+=!a.some(b=>b[i]))|s

@edc65 Well, you know the two hard problems of computing are cache invalidation, naming and off-by-one errors...

Python 2, 30 bytes
There is a surprisingly elegant solution using many of my favourite built-in functions chained together.
lambda c:sum(map(all,zip(*c)))

Using the test image from @Lynn:
>>> image = [[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]]
>>> func = lambda c:sum(map(all,zip(*c)))
>>> func(image)
3

Pyth, 5
s*VFQ

Try it here
This uses Lynn's algorithm, but I decided to post it just to show how to golf vector operations in Pyth. The trick here is to chain the "sugar" syntax helpers V and F so that the fold is applied as a vector operation. The operator that is folded is of course multiplication, and then the result is summed to get the final answer.

J, 5 6 bytes
Takes Boolean matrix as argument.
[:+/*/

This is my first J answer! (was wrong for 1½ years…)
*/ columnwise product
+/ sum
[: cap (serves as placeholder since +/ should not take a left argument)
Try it online!

CJam, 7 bytes
q~:.*:+

Try it online!
q~      e# read input and evaluate: push nested array
:.*     e# fold vectorized product over nested array: element-wise product of rows
:+      e# fold addition over array: compute its sum

Mathematica 24
Length@Cases[Total@#,0]&

Takes an array in the following form:
{{1, 0, 0, 0, 1, 0},
{1, 0, 0, 1, 1, 1},
{1, 1, 0, 0, 0, 0},
{1, 1, 0, 0, 1, 1},
{1, 0, 0, 1, 1, 1}}

And in this case outputs:
1

Or Length[Total@#~Cases~0]& but same byte count

1 and 0 are not truthy or falsy in Mathematica (and if they were the assignment would probably be the other way round).

, 7 chars / 9 bytes
⨭МƟïⓜ⨴$

Try it here (Firefox only).
This is @Lynn's great algorithm, but I found it independently. (I thought there was a builtin for this somewhere, still looking :P)
Explanation
МƟï transposes the input array, ⓜ⨴$ turns each inner vector into its product, and ⨭ sums the resulting array.

Japt, 6 4 bytes
Takes input as an array of rows, with 1 being white and 0 being black.
y xe

2 bytes saved thanks to ETH.

Test it

Explanation
y xe
          :Implicit input of array U.
y         :Transpose.
   e      :Map over each sub-array, checking if every element is truthy.
  x       :Reduce by summing, converting booleans to 1 or 0.
          :Implicit output of resulting integer.

I think you can do y x_× for 5. Actually, e works as well as ×, so y xe for 4 :-)

Missed that comment over the weekend, @ETHproductions - thanks :)


text:
Chaotic Number Shuffling
You have a deck of cards, consisting of cards with non-negative numbers on them, and you haven't shuffled it yet, and no player trusts the other players to be fair at shuffling. You devise a way to shuffle the deck that is completely deterministic, but chaotic enough that the other players are okay with using it. Here's how you perform a single shuffle:

Start with the deck face down. There are a series of M empty piles (where M is the maximum number in the deck) labeled as the 1st, 2nd, 3rd, ... ,Mth pile, and there is also an empty storage pile.
While the deck is not empty, do the following: Take the first card off the top of the deck, let N be its number and put the card face down on the top of the storage pile. If there are at least N cards left in the deck, deal the top N cards face down such that the top card goes in the 1st pile, the second card from the top goes in the 2nd pile, etc. until the Nth card gets put in the Nth pile. If there are fewer than N cards in the deck, deal all of them.
Construct the new deck by putting the first pile on the storage pile, then the second pile on the new pile, then the third pile on that new pile, then the fourth pile on that one, until all piles are in your deck.

This method is pretty intuitive when doing by hand, but after a few games some players want a computer to do it, due to the deep-seated mistrust within the group and a few lucky draws. They refuse to use other deck shuffling programs that would work better. Write a program that takes as input a list of non-negative integers (in some format you specify) and shuffles it once using this method, outputting the result. You may assume the integers and the length of the list are less than 2^16.
Here are some worked-out examples (layout is deck|storage|1st|2nd|3rd|...|Mth, cards go from bottom to top):
9,8,7,6,5,4,3,2,1,0|||||||||||
9,8,7,6,5,4,3,2,1|0||||||||||
9,8,7,6,5,4,3|0,1|2|||||||||
9,8,7|0,1,3|2,4|5|6|||||||
|0,1,3,7|2,4,8|5,9|6|||||||
0,1,3,7,2,4,8,5,9,6||||||||||| (starting another iteration)
0,1,3|6|9|5|8|4|2|7||||
|6,3|9,1|5,0|8|4|2|7||||
6,3,9,1,5,0,8,4,2,7|||||||||||

Here is a long string of successive shuffles:
[9,8,7,6,5,4,3,2,1,0]->[0,1,3,7,2,4,8,5,9,6]->[6,3,9,1,5,0,8,4,2,7]->
[7,3,2,6,4,8,0,5,1,9]->[9,1,5,0,8,4,6,2,3,7]->[7,1,3,9,2,6,4,8,0,5]->
[5,9,0,3,8,1,4,7,6,2]->[2,4,9,6,1,5,7,8,3,0]->[0,3,1,9,8,6,4,7,2,5]->
[5,9,2,1,7,3,4,0,6,8]->[8,5,6,0,4,3,7,1,2,9]->[9,2,1,7,3,4,0,6,5,8]

Another few:
[1,0,1,0]->[0,1,1,0]->[0,1,0,1]->[1,1,0,0]->[0,0,1,1]->[1,0,0,1]->[1,0,1,0]
[1,1,1,0]->[0,1,1,1]->[1,1,1,0]
[1,0,1,1]->[1,0,1,1]
[4,3,2,1]->[1,3,2,4]->[4,2,3,1]->[1,2,3,4]->[4,3,2,1]
[1,2,1,2,1,2]->[2,1,1,1,2,2]->[2,1,2,2,1,1]->[1,2,2,1,2,1]->[1,1,2,2,2,1]

Perl 5, 81 bytes
A naive approach (just shuffling per the specs). Doubtless someone will find a shorter way to do it (even in Perl 5, I mean).
{while(@_){for(1..($.=pop)){push@{$a[$_]},pop}push@{$a[0]},$.}$,=$/;say@$_ for@a}

This is a subroutine, but what it prints (not returns) is the shuffled deck. It requires -M5.01 (which is free).
$ perl -M5.01 -e'sub{while(@_){for(1..($.=pop)){push@{$a[$_]},pop}push@{$a[0]},$.}$,=$/;say@$_ for@a}->(9,8,7,6,5,4,3,2,1,0)'
0
1
3
7
2
4
8
5
9
6

It also adds extra newlines in various places (depending on the deck), but there's… well, nothing technically in the specs forbidding that. :-)

Ruby, 91 bytes
There is probably a better way to create an array of arrays. There's probably a shorter way to do all the shuffling, too. We'll see what future answers and comments bring to the table and all golfing suggestions are welcome.
->d{z=(1..d.size).map{[]};([d[-1]+1,d.size].min.times{|i|z[i]<<d.pop})while d[0];z.flatten}

Ungolfing:
def shuffle(deck)
  # an array of arrays
  z = (1..deck.size).map{[]}

  # while there are still cards in the deck
  while deck[0]
    # if we're almost out of cards, use how many are left
    # else, put in deck[-1] + 1 in the piles (that is, including deck[-1])
    card = [deck[-1] + 1, deck.size].min
    card.times do |i|
      z[i] << deck.pop
    end
  end

  # flatten all of those arrays done and return
  return z.flatten
end


text:
Help Jason format his JSON
Jason has a big JSON but it's unreadable, so he needs to prettify it.
Formatting Spec
The JSON has 4 different types:

Numbers; Just 0-9
Strings; Double quoted " strings escaped with \
Arrays; Delimited by [], with items separated by ,, items can be any of these types
Objects; Delimited by {}, format is key: value where key is a string and value is any of these types

Spacing

Arrays should have exactly one space after the commas between items
Objects should have have just one space between the key and the value, after the :

Indentation

Each nesting level is indented 2 more than the previous
Each object key/value pair is always on its own line. Objects are indented
An array is indented across multiple lines if it contains another array or object. Otherwise the array remains on one line

Rules

Built-ins which trivialize this task are not allowed.
As always standard loopholes are disallowed

Examples
[1,2,3]
[1, 2, 3]

{"a":1,"b":4}
{
  "a": 1,
  "b": 4
}

"foo"
"foo"

56
56

{"a":[{"b":1,"c":"foo"},{"d":[2,3,4,1], "a":["abc","def",{"d":{"f":[3,4]}}]}]}
{
  "a": [
    {
      "b": 1,
      "c": "foo"
    },
    {
      "d": [2, 3, 4, 1],
      "a": [
        "abc",
        "def",
        {
          "d": {
            "f": [3, 4]
          }
        }
      ]
    }
  ]
}

[2,["foo123 ' bar \" baz\\", [1,2,3]]]
[
  2,
  [
    "foo123 ' bar \" baz\\",
    [1, 2, 3]
  ]
]

[1,2,3,"4[4,5]"]
[1, 2, 3, "4[4,5]"]

[1,2,3,{"b":["{\"c\":[2,5,6]}",4,5]}]
[
  1,
  2,
  3,
  {
    "b": ["{\"c\":[2,5,6]}", 4, 5]
  }
]

Are JSON parsing builtins allowed?

Can objects/arrays be empty? Can we still print a space after commas in arrays if they split over multiple lines?

@MartinBüttner no, and yes

@Pietu1998 hm, I'm going to say no

Are language parser languages allowed?

@ӍѲꝆΛҐӍΛПҒЦꝆ if it is a built in hat is used to parse a JSON then no, because it's a JSON parsing built in

Re Numbers; Just 0-9 — JSON actually allows floating-pointing numbers as well as negative. Can we safely assume the input won’t contain any of those?

@Timwi yeah, you can assume that.

JavaScript (ES6), 368 bytes
f=(s,r=[],i='',j=i+'  ',a=[])=>s<'['?([,,r[0]]=s.match(s<'0'?/("(?:\\.|[^"])*")(.*)/:/(\d+)(.*)/))[1]:s<'{'?(_=>{for(;s<']';s=r[0])a.push(f(s.slice(1),r,j));r[0]=s.slice(1)})()||/\n/.test(a)?`[
${j+a.join(`,
`+j)}
${i}]`:`[${a.join`, `}]`:(_=>{for(a=[];s<'}';s=r[0])a.push(f(s.slice(1),r,j)+': '+f(r[0].slice(1),r,j));r[0]=s.slice(1)})()||`{
${j+a.join(`,
`+j)}
${i}}`

Less golfed:
function j(s, r=[], i='') { // default to no indentation
    if (s < '0') { // string
        let a = s.match(/("(?:\\.|[^"])*")(.*)/);
        r[0] = a[2]; // pass the part after the string back to the caller
        return a[1];
    } else if (s < '[') { // number
        let a = s.match(/(\d+)(.*)/);
        r[0] = a[2]; // pass the part after the string back to the caller
        return a[1];
    } else if (s < '{') { // array
        let a = [];
        while (s < ']') { // until we see the end of the array
            s = s.slice(1);
            a.push(j(s, r, i + '  ')); // recurse with increased indentation
            s = r[0]; // retrieve the rest of the string
        }
        r[0] = s.slice(1); // pass the part after the string back to the caller
        if (/\n/.test(a.join())) { // array contained object
            return '[\n  ' + i + a.join(',\n  ' + i) + '\n' + i + ']';
        } else {
            return '[' + a.join(', ') + ']';
        }
    } else { // object
        let a = [];
        while (s < '}') { // until we see the end of the object
            s = s.slice(1);
            let n = j(s, r, i + '  ');
            s = r[0].slice(1);
            let v = j(s, r, i + '  ');
            a.push(n + ': ' + v);
            s = r[0]; // retrieve the rest of the string
        }
        r[0] = s.slice(1); // pass the part after the string back to the caller
        return '{\n  ' + i + a.join(',\n  ' + i) + '\n' + i + '}';
    }
}


text:
Bit Manipulator/Reader
Introduction
There are often times that we have challenges which require communication of some sort (such as in team KOTH), where density of information may be more important than density of code. There are a number of compression techniques that can allow us to convey more information in less space, but for simple data flags, sometimes flipping bits themselves can be a great way to achieve desired data density.
Challenge
Write a program or function in the language of your choice that can take an integer to be manipulated (must handle at least 32 bit), a start bit position (integer), a number of bits to manipulate (integer), and a manipulation mode (integer), and returns the original integer manipulated in the way specified below. In addition, write a second program or function that serves as a bit reader, taking in an integer, a start bit position (integer), and a number of bits to read (integer), and returns an integer consisting of just that group of bits shifted down, and every other bit as 0.
Some further details and rules are as follows:

The first argument will be an integer, signed or unsigned.
The second argument will be the bit position to start from (counting from least significant bit, zero-indexed).
The third argument will be the number of bits to be read/manipulated, moving up in bit significance from the start bit. If not given as an argument, the value should default to 1.
The fourth argument (manipulator only) will be the manipulation mode:

When passed a 0 or null value, the behavior will be to flip (xor) all of the specified bits (default if no value given).
When passed a positive value, the behavior will be to set all of the specified bits to 1.
When passed a negative value, the behavior will be to set all of the specified bits to 0.

The return value of the manipulator function should be the initial integer with the above bit manipulations applied.
The return value of the reader function should be the start bit shifted to the least significant bit, and every bit beyond the length of bits set to 0.
Assume that only valid input will be used. Don't worry about error handling.

The winner will be determined by the shortest sum of the length of both programs/functions. They will be selected in at least 7 days, or if/when there have been enough submissions. In the event of a tie, the answer that came earlier wins.
Examples
Here's a few examples of input and output that your code should be able to handle. I've golfed both functions in JavaScript that I can release if people want to test their results, but otherwise I'll probably wait a few days before I post it up.
Manipulator
F(0, 2) => 4 (0 => 100)

F(4, 2) => 0 (100 => 0)

F(0, 2, 4) => 60 (0 => 111100)

F(170, 2, 4, 0) => 150 (10101010 => 10010110)

F(170, 2, 4, 1) => 190 (10101010 => 10111110)

F(170, 2, 4, -1) => 130 (10101010 => 10000010)

F(0, 31) => (+/-)2147483648 (0 => 10000000000000000000000000000000)

Reader
F(0, 2) => 0 (0 => 0)

F(4, 2) => 1 (100 => 1)

F(60, 2, 4) => 15 (111100 => 1111)

F(170, 2, 4) => 10 (10101010 => 1010)

F((+/-)2147483648, 0, 32) => (+/-)2147483648 (10000000000000000000000000000000 => 10000000000000000000000000000000)

What if a language doesn't support optional function arguments?

@Zgarg Then you can pass in the default values 1 and 0, respectively.

Ok, thanks. Also, can we have shared code between the two functions, and can one of them use the other in its definition?

@Zgarb I'll allow that, so long as they are still called as specified. Your function can reference another function, and your program can reference another program, but all of the code used must be summed up in the end.

You should add some test cases that use 32-bit integers, since that it the requirement.

@mbomb007 Good point. Added some simple cases to just ensure they work at that level. Thanks!

JavaScript (ES6), 75 bytes
Saved 4 bytes thanks to @Mwr247
Manipulator: (47 bytes)
(a,b,c=1,d=0,z=(1<<c)-1<<b)=>d?d<0?a&~z:a|z:a^z

Reader: (28 bytes)
(a,b,c=1)=>a>>b&(1<<c-1)*2-1

How it works
Manipulator
The first thing we need to do is figure out the number that has c bits set, starting at the bth bit. Possibly the best way to do this is z=(1<<c)-1<<b, which works like so:
b  c    1<<c     -1     <<b    z
2  1      10     01    0100    4
2  2     100    011   01100   12
2  3    1000   0111  011100   28
1  4   10000  01111  011110   30

Now we take into account d. For case 0, we flip the bits with a^z; for case 1, we set the bits to 1 with a|z; for case -1, we set the bits to 0 with a&~z.

Did you peek at my computer? Because that's almost exactly the code I had, down to the variable names XD Very nice!

@Mwr247 Haha! I guess this is another instance of great minds thinking alike :)

You can actually save 4 bytes on the manipulator with z=(1<<c)-1<<b

@Mwr247 Wow, that helps a lot, thanks!

@mbomb007 Thanks, I had just messed up the decimal translations of those numbers.

Just tested the 32 bit cases I just added, and your reader function doesn't work quite right. This seems to work correctly though (haven't tried shortening further): (a,b,c=1)=>a>>b&(1<<(c-1))*2-1

This would be the winning submission, but the reader is still wrong. See above.

@Mwr247 Thanks, fixed. It's a bummer that JS's 32-bit type only really works with 31-bit integers (the top bit is sign, I think)...

Python 2, 89 bytes
Done in a method similar to ETH. Python lambdas aren't as short as in JS. Also, default parameter values can't depend on other parameters.
Manipulator, 63 bytes
def f(a,b,c=1,d=0):
    z=2**c-1<<b;return[a^z,a|z,a&~z][cmp(d,0)]

Reader, 26 bytes
lambda a,b,c=1:a>>b&2**c-1

Try it online

I was in the midst of trying to figure out where my Python 2.7 was installed when you posted the online testing, thanks ;) Looks good!


text:
Italicize ASCII art
Given an input of an ASCII art picture, output the ASCII art italicized.
To italicize the ASCII art:

Insert zero spaces before the last line, one space before the second-last
line, two spaces before the third-last line, etc.
Remove any extra leading whitespace that may have been created. That is, if
each line has at least n spaces preceding it, remove n spaces from the
beginning of each line.
Replace all \s with |, all |s with /, and all /s with _. Keep
existing _s the same.
The input is guaranteed to contain only the characters \|/_ and space.

For example, the input
/\/\/\    /\/\/\      /\/\/\    /\/\/\
 /\    /\  /\    /\  /\        /\
  /\/\/\    /\/\/\    /\        /\  /\/\
   /\        /\        /\        /\    /\
    /\        /\          /\/\/\    /\/\/\

must output
_|_|_|    _|_|_|      _|_|_|    _|_|_|
_|    _|  _|    _|  _|        _|
_|_|_|    _|_|_|    _|        _|  _|_|
_|        _|        _|        _|    _|
_|        _|          _|_|_|    _|_|_|

which in turn, provided as input, outputs
    _/_/_/    _/_/_/      _/_/_/    _/_/_/
   _/    _/  _/    _/  _/        _/
  _/_/_/    _/_/_/    _/        _/  _/_/
 _/        _/        _/        _/    _/
_/        _/          _/_/_/    _/_/_/

which would output
        ______    ______      ______    ______
      __    __  __    __  __        __
    ______    ______    __        __  ____
  __        __        __        __    __
__        __          ______    ______

Input and output may be either a single string (with optional trailing newline)
or an array of lines.
Since this is code-golf, the shortest code in bytes will win.
Extra test cases:
|||||
  /////
 \\\\\
   _____

 /////
  _____
|||||
 _____

________

________

(that is, input of empty string results in output of empty string)

Can we assume that the input is padded to a rectangle?

Are trailing spaces acceptable in each output line?

@MartinBüttner Yes, you can.

@DonMuesli Trailing spaces are okay, just no leading spaces.

May we take input as a rectangular array (matrix)?

Why does an underscore not output a backslash?

@ZachGates The challenge was inspired by figlet: the second example is figlet -f block PPCG, and the third is figlet -f lean PPCG. It would look super ugly anyway if underscores became backslashes.

Ah, now that makes more sense. Here's what it would look like if the underscores became backslashes, though.

@ZachGates Actually, the underscores in your link would be /s.

CJam, 43 38 bytes
qN/W%eeSf.*:sW%z_{S-}#>zN*"\|/__"_(+er

Requires the input to be padded to a rectangle.
Try it online!
Explanation
qN/     e# Read input, split into lines.
W%      e# Reverse lines.
ee      e# Enumerate them (pairing each line with its index starting from 0).
Sf.*    e# Turn each index i into i spaces.
:s      e# Flatten each pair into a single string, prepending the spaces.
W%      e# Reverse the lines again.
z_      e# Transpose the character grid, duplicate it.
{S-}#   e# Find the first row index that contains non-spaces.
>       e# Discard that many rows.
zN*     e# Transpose back and join with linefeeds.
"\|/__" e# Push this string.
_(+     e# Make a copy that's rotated one character to the left, i.e. "|/__\".
er      e# Perform character transliteration mapping from the first string to the second.

Anecdotal, but I tried the PCCG example from the question, feeding each output back into the program, but without padding to a rectangle. Worked fine.

@alexwlchan Well yeah, trailing spaces beyond the bounding rectangle don't matter (but will not necessarily be preserved). But if yout take the original PPCG example itself for instance, and remove the trailing spaces inside the G then the transformation will collapse it to the top.

MATL, 38 33 29 bytes
P"NZ"@Y:'\|/' '|/_'XEh]XhPcYv

Output lines have trailing spaces to match the longest line (this is allowed by the challenge).
Input is a cell array (list) of strings. The array uses curly braces, and strings use single quotes, as follows (click each link to Try it online!).

First example:
{'/\/\/\    /\/\/\      /\/\/\    /\/\/\'  ' /\    /\  /\    /\  /\        /\'  '  /\/\/\    /\/\/\    /\        /\  /\/\' '   /\        /\        /\        /\    /\' '    /\        /\          /\/\/\    /\/\/\'}

Second example:
{'_|_|_|    _|_|_|      _|_|_|    _|_|_|' '_|    _|  _|    _|  _|        _|      ' '_|_|_|    _|_|_|    _|        _|  _|_|' '_|        _|        _|        _|    _|' '_|        _|          _|_|_|    _|_|_|'}

Third example:
{'    _/_/_/    _/_/_/      _/_/_/    _/_/_/' '   _/    _/  _/    _/  _/        _/       ' '  _/_/_/    _/_/_/    _/        _/  _/_/  ' ' _/        _/        _/        _/    _/   ' '_/        _/          _/_/_/    _/_/_/    '}

Explanation
The array is initially flipped. Each string is processed in a loop and the modified string is pushed onto the stack. Processing consists in replacing the characters and appending a number of spaces. The number of spaces equals the current number of elements in the stack (thanks to the fact that the array has been flipped).
After the loop the strings are collected in an array, which is flipped back, converted to a 2D char array, and disposed of unwanted leading spaces: leading spaces that are present in all rows of the 2D char array.
P             % implicitly input cell array of strings. Flip it (reverse order)
"             % for each
  NZ"         %   string with as many spaces as elements there are on the stack
  @Y:         %   push current input string
  '\|/'       %   push string: origin for replacement
  '|/_'       %   push string: target for replacement
  XE          %   replace
  h           %   concatenate string with spaces and modified-character string
]             % end for each
Xh            % collect all processed strings in a cell array
P             % flip back to restore original order
c             % convert to 2D char array
Yv            % remove trailing spaces common to all rows. Implicitly display

Pyth, 32
jCf|Z=Z-Td.t_.e+*kd.rb"\|/__"_Qd

Try it here or run the Test Suite
Each line has several trailing spaces. This works by applying .r which is the rotation built-in to each line of the string. The rotation takes each character in the string that matches one in the other argument "\|/__" and replaces it with the next character. The double underscore nicely prevents underscores from becoming backslashes. The strings are also padded based on their index.
Once that is done, the lines are zipped together, then we filter out each column that only contains spaces, until one of them doesn't. Then we unzip and join on newlines.

Dyalog APL (older versions), 23 48 bytes
Adjusting whitespace is expensive:
{{⍵↓⍨0,⌊/+/∧\' '=⍵}(⍳≢⍵)⌽'|/ _'['\| '⍳(∊,⊢,∊)⍵]}

This requires ⎕ML←0, which was default until recently.

JavaScript (ES6), 171 149 148 bytes
a=>a.map(s=>(t=' '.repeat(--i)+s,l=t.match` *`[0].length,n=l<n?l:n,t),n=i=a.length).map(s=>s.slice(n).replace(/./g,c=>"|/__ "["\\|/_ ".indexOf(c)]))

Accepts and returns lines as an array of strings.
Edit: Saved 22 bytes thanks to @user81655. Saved 1 byte by realising that the input is limited to the 5 characters \|/_ and space.

replaces can be combined into .replace(/[\\|/]/g,m=>"|/_"["\\|/".indexOf(m)]), match(/ */) can be match\ *`, first two maps can be combined into a.map(s=>(t=' '.repeat(--i)+s,(l=t.match` *`[0].length)<n?n=l:l,t),..., outer parentheses ((a=...)) can now be removed. 149 bytes: a=>a.map(s=>(t=' '.repeat(--i)+s,(l=t.match` *`[0].length)<n?n=l:l,t),n=i=a.length).map(s=>s.slice(n).replace(/[\|/]/g,m=>"|/_"["\|/".indexOf(m)]))`

@user81655 Wow, thanks! (Then I somewhat spoiled it by golfing a byte off your replace.)

Vyxal, a 39 37 bytes
-2 thanks to @Aaron Miller
ṘėṘƛt`\|/``|/_`Ŀnh$꘍;:ƛ`^ *`$et;g£ƛ¥ȯ

Really bad answer, id like to fix it;
the program takes in the string, breaks it into chunks, transliterates to the correct characters, and then spends most of the chars trying to fix the spacing.
Try it Online!

-2 bytes

thanks for fixing that, my bad

Pip -rl, 39 38 37 36 bytes
How do you golf an elephant? One byte at a time...
YsXRV,#g.:gWw~=@ZyY@>*yyTR"\|/""|/_"

Try it online!

Jelly, 32 bytes
JU⁶ẋ$;¥"µEƤS$€Ṃ$‘ṫ€@µ“\|/“|/_”yⱮ

Try it online!
The number in STDIN just indicates how many times italicization will be run (for easier testing). Set it to 1 for normal execution.

Stax, 24 bytes
╦'Fi╘◘¥╘τ9jq'∟w7#ù╢→↨↨─╟

Run and debug it
Takes a list of lines as input. They are formatted as ascii codepoints for convenience, but you can still pass a list of strings directly.

Python 3.8 (pre-release), 84 bytes
def f(s):
 i=len(s)
 for x in s:print(' '*i+x.translate({92:124,124:47,47:95}));i-=1

Try it online!


text:
Text on a circle
Write a program or function that prints an input string around the discrete circle that has the minimum possible radius. For example, for input This is an example, your program should output:
  a si
 n     s
        i
e       h
x       T
a
m
 p
  le

Circle generation
You shall use the Midpoint circle algorithm to compute the coordinates of each point of the discrete circle. You can find examples on how to implement this algorithm on this Wikipedia page.
Here is the pseudo code of the algorithm (based on Wikipedia's C example):
integer x = radius
integer y = 0
int decisionCriterion = 1 - x

while y <= x
    point at coordinates (x,y) belongs to the circle   // Octant 1
    point at coordinates (y,x) belongs to the circle   // Octant 2
    point at coordinates (-x,y) belongs to the circle  // Octant 4
    point at coordinates (-y,x) belongs to the circle  // Octant 3
    point at coordinates (-x,-y) belongs to the circle // Octant 5
    point at coordinates (-y,-x) belongs to the circle // Octant 6
    point at coordinates (x,-y) belongs to the circle  // Octant 7
    point at coordinates (y,-x) belongs to the circle  // Octant 8

    y++
    if decisionCriterion <= 0
        decisionCriterion += 2 * y + 1
    else
        x--
        decisionCriterion += 2 * (y - x) + 1
end while

You may use a different algorithm if and only if it produces the exact same circles that the Midpoint circle algorithm produces, for all radiuses.
The circle must have the smallest possible radius that still allows to write all letters of the input.
If the circle ends up with more points than the number of characters in the string, then the last filling characters will be spaces .
The first character of the input must be printed on the point with coordinates (Radius,0). The subsequent characters are printed in an anticlockwise fashion.
Inputs
The input is a string of any ASCII characters between the space  (32) and the tilde ~ (126).
You may assume the input will always be valid, shorter than 256 characters and at least 5 characters long.
The input may be taken from STDIN, or as a function parameter, or anything similar.
Outputs
You may output the result either to STDOUT, or return it as string from a function.
You may have trailing spaces, provided that it does not cause the line to exceed the longest line (the middle one) (as such, the middle line cannot have trailing spaces).
A trailing new line is permitted.
Test cases
Input: Hello, World!
Output:
  ,ol
     l
W     e
o     H
r
 l
  d!

Input: 4 8 15 16 23 42
Output:
  51
     8
1
6     4

 2   2
  3 4

Input: Programming Puzzles & Code golf
Output:
     gnim
  uP     ma
 z         r
 z         g
l           o
e           r
s           P

&

 C
  od     f
    e Gol

Input: Ash nazg durbatuluk, ash nazg gimbatul, ash nazg thrakatuluk agh burzum-ishi krimpatul.
Output:
            zan hsa ,
           g         ku
        ig             lu
      bm                 ta
     a                     b
    t                       r
   u                         u
   l                         d
  ,
                              g
 a                             z
 s                             a
h                               n

n                               h
a                               s
z                               A
g

t
h
 r
 a                             .
  k                           l
  a                           u
   t                         t
   u                         a
    l                       p
     u                     m
      k                  ri
        ag              k
          h          hi
            burzum-is

Scoring
This is code-golf, so the shortest answer in bytes wins.

Mathematica, 359 357 354
(L=Length;T=Tuples;c=Characters@#;For[r=1,L[p=RotateRight[SortBy[#,ArcTan@@N@#&]+r+1,L@#/4+1]&@(f=1-r;X=1;Y=-2r;x=0;y=r;q={{0,r},{0,-r},{r,0},{-r,0}};While[x<y,If[f>0,y--;f+=Y+=2];x++;f+=X+=2;q=Join[q,T@{{x,-x},{y,-y}},T@{{y,-y},{x,-x}}]];Union@q)]<L@c,r++];R=2r+1;s="";Do[s=s<>({u,v}/.Thread[p~Take~L@c->c]/.{_,_}->" ")<>If[v==R,"\n",""],{u,R},{v,R}];s)&

Ungolfed:
(
  L = Length;
  T = Tuples;
  c = Characters@#;
  For[r = 1,
   L[
     p = RotateRight[
         SortBy[#, ArcTan @@ N@# &] + r + 1, L@#/4 + 1
         ] &@(
        f = 1 - r;
        X = 1;
        Y = -2 r;
        x = 0;
        y = r;
        q = {{0, r}, {0, -r}, {r, 0}, {-r, 0}};
        While[x < y,
         If[f > 0,
          y--;
          f += Y += 2
          ];
         x++;
         f += X += 2;
         q = Join[q, T@{{x, -x}, {y, -y}}, T@{{y, -y}, {x, -x}}]
         ];
        Union@q
        )] < L@c,
   r++];
  R = 2 r + 1;
  s = "";
  Do[s = s <> ({u, v} /. Thread[p ~ Take ~ L@c -> c] /. {_, _} -> " ") <>
      If[v == R, "\n", ""],
   {u, R}, {v, R}];
  s
  ) &

C, 367 Bytes
#include<math.h>
main(){char*m="12345678",b[9999];int p,i,n,q,c,l=strlen(m),r=1,d,f=0;float o,s;for(;!f;r++){f=0;q=r*r;c=r/4;o=6.3,s=o/99.;memset(b,0,q);for(i=0;i<l;i++){p=1;f=0;while(p&&o>0){d=(c-1+(int)(sin(o)*c))*r+c-1+(int)(cos(o)*c);f+=p=b[d];if(!p)b[d]=m[i];o-=s;}}if(f){for(n=p=0;n<q;n++){p+=c=b[n];putchar(c?c:32);if(n%r==r-1){if(!p)n=q;putchar(10);p=0;}}}}}

Test Here
I'm sure it can be golfed much further but it’s starting to give me a headache.
C, 324 Bytes
Smaller code but the results are not the same as OP's
#include<math.h>
main(){char*m="12345678",b[9999];int q,c,l=strlen(m),r=1,d,i=0;float o;for(;i<l;r++){i=0;c=r/2;q=r*r;memset(b,0,q);for(o=6.28;o>=0&&i<l;o-=0.001){d=(c-1+(int)(sin(o)*c))*r+c-1+(int)(cos(o)*c);if(!b[d]){b[d]=m[i++];}}}for(d=i=0,--r;d<q;d++){i+=c=b[d];putchar(c?c:32);if(d%r==r-1){putchar(10);d=i?d:q;i=0;}}}

       an hsa ,k
      gz       ulu
    ig           ta
   bm             br
  ta               ud
 lu                  g
 ,                   z
a                    an
s
h                     h
                      s
n                     A
a
z
g                     l
 t                   tu
 h                   a
 ra                 mp
  ka               ri
   tu              k
    lu           hi
     k a       -is
       gh burzum

You can drop the void for 5 bytes, and declare some of the integers in the global scope for some more bytes, since variables in the global scope without a type are assumed int and are automatically initialized to 0.

It appears you made an anonymous edit while logged out. I went ahead and approved it, but in general you should log in to make your edits. ;)

322 bytes

C, 494 Bytes
This one uses the actual Midpoint circle algorithm:
void main(){char s[]="12345678";int a[9999],b[9999],f=0,c,h,x,y,e,q,t,u,v,g,i,d,l,r=0,k=strlen(s);for(;f<k;r++){c=r;e=r*2+1;q=e*e;memset(b,0,q*4);f=0;l=0;for(i=0;i<8;i++){x=r;y=0;d=1-x;for(x=r,y=0,d=1-x;y<=x;y++,d+=2*d>0?y- --x:y+1){t=(i+1)%4>1;u=t?y:x;v=t?x:y;h=(c+v*(i>3?1:-1))*e+(c+u*(i>1&&i<6?-1:1));if(!b[h])b[h]=f<k?s[f]:0,a[f]=h,f++;}if(i%2){for(g=0;g<(f-l)/2;g++)t=b[a[l+g]],b[a[l+g]]=b[a[f-1-g]],b[a[f-1-g]]=t;}l=f;}}for(i=0;i<q;i++){c=b[i];putchar(c?c:32);if(i%e==e-1)putchar(10);}}

De-golfed Code:
void main() {
    char text[]="Ash nazg durbatuluk, ash nazg gimbatul, ash nazg thrakatuluk agh burzum-ishi krimpatul.";

    char points[9999];
    int pos[9999];

    int sl = strlen(text);
    int r = 0;
    int pc = 0; // point count
    int lc = 0; // last count

    int c, h, x, y, e, q, t, u, v, g, i, d;

    // increase radius until number of points => strlen(text)
    for(; pc<sl; r++) {
        c = r;
        e = r * 2 + 1;
        q = e * e;
        memset(points,0,q);
        pc = 0;
        lc = 0;

        // loop through the octants
        for(i=0; i<8; i++) {

            // midpoint loop
            x = r;
            y = 0;
            d = 1 - x;
            while (y <= x) {

                // calc index of point
                t = (i + 1) % 4 > 1;
                u = t ? y : x;
                v = t ? x : y;
                h = (c + v * (i > 3 ? 1 : -1)) * e + (c + u * (i > 1 && i < 6 ? -1 : 1));

                // add point if space is empty
                if(!points[h]) {
                    points[h] = pc < sl ? text[pc] : 0;
                    pos[pc] = h;
                    pc++;
                }

                y++;
                d += 2 * d > 0 ? y- --x : y + 1;
            }

            if(i % 2) {
                // reverse point order for odd octants
                for(g=0; g<(pc-lc)/2; g++)
                {
                    t = points[pos[lc + g]];
                    points[pos[lc + g]] = points[pos[pc - 1 - g]];
                    points[pos[pc - 1 - g]] = t;
                }
            }
            lc = pc;
        }
    }

    // write output
    for(i=0;i<q;i++)
    {
        c = points[i];
        putchar(c ? c : 32);
        if(i % e == e - 1)
            putchar(10);
    }
}