text:
Print element from the periodic table
Your task is simple: given a number as an input, you have to print the English name of the chemical element with that atomic number, up to and including ununoctium. For example, for an input of 77, your program has to print Iridium, and nothing else.
You can use any language, but no library (or other, in-built feature) which includes the names of the elements is allowed, your program has to store or generate the names on its own. Use names in wikipedia for the spelling of the names of the elements.
Shortest code wins, not sooner than 1 days after first valid answer.

It would be nice to know that http://en.wikipedia.org/wiki/Periodic_table_(large_version) is THE (not just that we are free to use it) periodic table for this challenge, otherwise someone might use older names for some of the elements, which might result in shorter code.

Writing an own compression mechanism is probably longer than using zlib, so challenge here is "who can invoke zlib with the shortest code"

It would be more modern to use the wikipedia page as source, and create a program that read that page and extract correct information, libraries allowed.

As added challenge, why not output it's electronic configuration (orbitals) while at it? That adds a bit of math to the problem, with a slight overhead in the data file.

The rule should be to use the official IUAPAC names. (That means aluminium (not aluminum) and sulfur (not sulphur).)

Tcl, 567 577
puts [lindex [zlib i =SÑä\ ü(EH¡Îmöêþý2û0%C¤éÆæï¿Tï¢r\"§ÔVOÔfÝçzgQáA\;¸Í¸.ß÷>^´Dcb´¯CÊ®èp2ÞxG£QËvåª2ì§k¤±èµ4åJzî\v2axqÊ^w¶\töÏäªÒ£%`M15g+Ð4¶ù\vÉþ\]júiÓ\t¡êDí:Ð.¦86¦ñùÒû¦ëhÞmv\;ºçÔ\}þ45Q\;â&º¼éb®~_×¬®5ftÐ`y»\fÅ´VN`ÍºðmHDË6«6jßÈþ&1åüÙý\n»sFO\\\n¥ÜË¿Ñeú0^y@Z\\*ÏP<ÙDuIåVâªC<_f\]ôãÉÐ¡¸Â+@ÔvAÏ1Í2úLBFèÕîE`7¡:j^jÊëó^PÒÑF·IG(¦cî*Lj´Í\nìÑ-äùH1Ç=Òçoriñ2rÁaÍØ4Ê1xÛ¯Ø³e\{ú5llîer\ ³ÒÛ¡åxÖ\nþ(>Ü¶ÔbYGì-Ú\vW5F\{Ð±M- Ý\$0\ Ï3iG£ä\r/\{¾UÞÜa^jæ·Ùùaú?±äþ] [gets stdin]]

Who said that you can not embed binary data in your program code?
(zlib requires Tcl 8.6)
base64 encoded version:
cHV0cyBbbGluZGV4IFt6bGliIGkgPVPRkuRcIAj8FX+NKBOtRUihzm326v79EDL7MCVDpOnG5u+/VO+i
clwip4rUVk/UZt3ngXqTZw5R4ZRBD1w7uM24Lt/3Pl60RBtjYrSvQ8qu6HAyjh0Brd54R6NRy3blqjLs
p2uksei1NOVKAQF67lx2MmF4cQbKXpqBHXe2XHQO9gYGz+Sq0qMln2BNMTVnKwfQNLb5XHbJ/lxdF2r6
aZzTXHSh6kTtAQY60C6mgYSeODam8fnS+5oGputo3m2Ydp5cO7rn1Fx9/jQ1UVw74iaHExG6j4K86WKu
jH5f16wBrjVmdBmP0GCTeRu7XGbFlbSPVk5gzbrwbUhEyxs2qzZq38j+JjHlA/wb2f1cbrtzRk9cXFxu
A6Xcjsu/0WX6MF55QI9aXFwql88FilA82UR1SeUeVuKdqpBDPF9mXF30jOPJ0JqhuMIrQIzUdkGai88x
zTL6TEJG6NUY7kVgmjcDoZI6al5qyuvzXoRQ0tFGt0maRyimDmPuKkxqtM2NXG7sltEYLeT5SDHHPdLn
b3JpGIDxMnLBYc0H2Ag0h8oxeNuHr9gQs2Vce4n6NWxsmgLuZY5yB1wgF7PS26HleNZcbv4oPty2F9QQ
nGJZR+wHgi3aGVx2VzVGGFx70LFNjhctoN1cJJcwlVwgzzOGaRZHo+RcchYvDlx7vghV3p/chWFeaua3
HgPZ+WH6P7HkHf4HXSBbZ2V0cyBzdGRpbl1d

History:

changed compression mechanism. Saves me 10 chars.

First time I've seen a Tcl accepted answer!

Python, 69 + 536 = 605 (lazy solution)
I took the liberty of not capitalizing the names of the elements. That allows me to shave off extra 41 bytes. zlib is most likely not the best compressor for plaintext, it takes 1292 bytes down to 536.
python file:
import zlib
print (eval(zlib.decompress(open('a').read())))[input()]

data file a (b64 encoded for web):
eJxNVNGS5CAI/Jd5vj+62gdUJlpDMIU6t9mvPzSQ2YetZVCbpmny9/H488hnkrohzxCpjF0DKj1f
UUA5ybKhSp3XIkhYAZfuT+v3eQVPGlUK4zzGdavVdL3fYWNsVww09sJX3AqVuK4euTb9k9FmetBz
yKyXySFBtuti7dAMKgJFA4rAVquXDgb/BgbLxix1dzK8gdKZqMX6qgGor77iC2lljgMnhZ/CUf9t
4FpsKLsXAGmoTyYBJLRkmJUW55ecR18FZIRiTJoqx/2Kz97lin6KqBBXzKUGo1rpDAn5agxjZrSX
Mnr2gpJd50NZeseq7Xt1ECFZ5+Wj0SQFSmOvfC5somFUiqIt+t/INnWfXQC7Q/o2w8UroiUPgYY1
nVaNf8WHaoLurAa74+CQepiukCq5MTqKSZDOpo+tfq5kgPd5z4NuMe8sje5KZXg6qJKe7pvh4K31
ZVu5dazNdRIf1kGgWl38KqU5EpQ4ZGmWb08QwjwLpe06l+VS8mlC6xNjCira4toUATbjio8LYr+b
1z24Zeu/Doa48RgPbcE5jn4XU3rFoKMPVDf55futK1OeVew6FlYVHP6pzjbfISc19NuK1XB/HuCf
4M19elAUzVpII/heI+gnY/OPRxYfhW/ujqWz+yaB7CpScmtX5L75UHQRUelaycGDfWWehFLfn/yB
vlZU1Pm7izjPmur1+VXj+vH1H5EjvoY=

zlib isn't even the best compressor for zlib-compatible output. kzip, 7zip, and zopfli are among the tools which beat it.

"your program has to store or generate the names on its own" that obviously means no external files.

@vsz: For me it isn't automatically clear from that, that all the code has to be in one file. If the limitation is that I cannot have a purely data file, then I will move the printing and indexing inside the zlibbed data. But really I'm just wondering why make such an arbitrary rule.

Would it not be better to have the b64 text in the python file to save bytes by not needing the open and read methods?

GolfScript, 577 characters
~(
'ž�®Ñ/ž!Z!Ó1ã„9î¸dÊÓªí[o@ÁlD®�K®ÆšTB˜Þ6(ËH¼¡)ßÝ•|O¨U˜É/Œ�DÚvU$.âxŠ²¤Æ³n’t8[¢êqHyÍlÂSbYÈ*1~˜|†ï¨ŸÊ*Þk0âg%&‘Ÿ¶2ö¼Eë˜Áaq[¦Ä;ø7[–Î¯_ªtë½¢Ÿ\‰`Ãö”{ÉOUÈÜ¿Ò‰Fös–ß<µ‰x�#¶w+ìÊ®¼äH$Ìª¦ùoh�7™ÐbÙÑîâóÂø8Ö;•9ÁÃ)T°¤vWOUð~È¡jžK¯V¹8K?«à‚ª–0)ÚFj]îõc„ ¼´¢�Ã#æ¯Uƒ¡Mh$Šº^9V$Ùš`½†2±Žžk™+®5ª.„bC x%XJ<ç†78N¥5á2ù@<ù��ž£ªØ¸ÅÆŒç™ Î½¨ñøŽjZ±@,, íªluzÀ¡‹ØÈ[$5† S¾,‰‚TÊ_"ñÍÈ�Â» Úïº @ð_D«�.kX©(0ÎX]®c´c.Åm,‰æªQ)•‚t®§>‰j)tŸ.Z!�|0Å‡Ì¢‰ùc êš™‡ãÂÓT<xsY(ª2!¦93ãœ¤¡�Ç"mÎç£COKcÎ}¶!0Ö·£—sÂÃžíÛê”[lœX£€Ã6{È‚¡�ˆFâóVP8‡4�ës†´ïç]Ó{±éˆñz~bºs8¿U/ªY²Öm4 ÍP3CI7‹'
{32-}%218base 32base{96+}%''+'j'/'ium`'*'`'/=([32-]\+

Base64 encoded version:
fignnp2u0S+eIVoh0zHjhDnuuGTK06rtW29AwWxEroFLrsaaVEKY3jYoy0i8oSnf3ZV8T6hVmMkv
jIFE2nZVJC7ieIqypMazbpJ0OFui6nFIec1swlNiWcgqMX6YfIat76ifyireazDiZyUmkZ+2Mva8
ReuYwWFxW3+mxDv4N1uWzq9fqnTrvaKfXIlgw/aUe8lPVcjcv9KJRvZzlt88tYl4nSO2dyvsyq68
5EgkzKqm+W9okDeZ0GLZ0e7i88L4ONY7lTnBwylUsKR2V09V8H7IoWqeS69WuThLP6vggqqWMCna
Rmpd7vVjhKC8tKKdwyPmr1WDoU1oJIq6XjlWJNmaYL2GMrGOnmuZK641qi6EYkMgeCVYSjznhjc4
TqV/NeEy+UA8+YGNnqOq2LjFxoznmSDOvajx+I5qWrFALCwg7apsdXrAoYvYyFskNYYgU74siYJU
yl8i8c3IncK7oNrvuqBA8F9Eq50ua1ipKDDOWF2uY7RjLsVtLInmqlEplYJ0rqc+iWopdJ8uWiGQ
fDDFh8yiifljIOqamYfjwtNUPHhzWSiqMiGmOTPjnKShkMcibc7no0NPS2POfbYhMNa3o5dzrcLD
nu3b6pRbbJxYo4DDNnvIgqGdiEbi81ZQOIc0getzhrTv513Te7HpiPF6fmK6czi/VS+qf1my1m00
IM1QM0NJN4snezMyLX0lMjE4YmFzZSAzMmJhc2V7OTYrfSUnJysnaicvJ2l1bWAnKidgJy89KFsz
Mi1dXCsNCg==

It also does the capitalization correct. No libraries, no zlib, just base encoding. With a little bit tweaking it might be possible to shave off a few chars.


text:
Can you barcode code in a bar?
Welcome to the piNapple bar, Melbourne. All of the finest code golfers are here, with their laptops, sampling cocktails and programming increasingly badly.
I feel a special need to reemphasise the last point. Increasingly badly. Alcohol can do funny things to programming logic.
So - a few of the Golfers were attempting some nested quines in increasingly exotic languages. Somebody had hit the forth order in INTERCAL. Then the flow of alcohol stopped. He drunkedly, accidentally deleted the barcode reading algorithms from a completely different computer... that wasn't even connected to any network! (Kids - don't INTERCAL. For the sake of you. For the sake of your family.)
Normally, this wouldn't be a big issue. But, some golfer had designed the system years ago, and none of the barcodes were standard. Assuming 1's are lines, and 0's are space, they all start with 101 and finish with 1001. Everything in the middle is 7-bit ASCII encoded.
The barkeep does have a big fancy barcode reader that will return a string of arbitrary length (though less then 300 bits) of 1's and 0's, via STDIN, argument or file depending on your program. And it might come forward, or backwards depending on which way the bottle is being held. Your program must return the string from the middle of the barcode, via STOUT or file.
Unfortunately, he didn't spend as much on his storage, so the program with the shortest source will be chosen, and win free drinks and drunken programming tutorials from the other golfers.
Good luck!

In other words, determine if the input is 101...1001 or 1001...101 and reverse in the latter case, then pack the center into bytes.

Completely accurate. But what's the fun in that? :p

GolfScript, 30 characters
.-1%]$1=3>7/);{{1&}%2base}%""+

Input is provided on STDIN. Example:
> 1011000001100001010000111001
ABC

> 1001110000101000011000001101
ABC

J - 35 bytes
_7(a.{~#.)\_4}.3}.|.^:([:-.2{])"."0

Explanation coming later :).

How much later? ;-)

Pyth, 21
smCid2c:?zv@z2_z3_4 7

Explanation:
        ?zv@z2_z           Input if 3rd character of input is 1, else reversed input.
       :        3_4        Slice out the middle portion, ASCII of the above string.
      c             7      Chop into 7 character chunks.
 mCid2                     Convert each chunk from binary to integer, then to a character.
s                          Sum up the characters into a string and print.

Note that while the question is older than the language, the existence of the question did not influence the design of the language in any way, because I haven't seen the question before today.
Still rules are rules, so I'm making it CW.

OK, I'll make it CW then.

AWK, 116 bytes
/101$/{r=1}{L=split($0,a,"")
n=r?L-2:3
N=r?-1:1
while(d<L-7){c=0
for(k=0;k<7;k++){c*=2;c+=a[n+=N];d++}printf"%c",c}}

I know this question hasn't seen a lot of love, but I was curious about seeing and AWK solution.
This isn't all that clever, but it seems to work and I don't see any obvious areas to golf. I originally reversed the string when needed, but that added more bytes than just tweaking the increment logic to move backwards.

@tailsparkrabbitear Suggest golfs in comments, don't edit them in

@chartz Hi. I'm sorry at that time when I didn't have a privilege to add a comment yet. I wanted to suggest length().

While you are correct that there is a length() function, that would not provide the array 'a'

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:
Ratetod text fexir
I heva this wierd text where vewols seem to be ratetod :

I'm a badly written text. Some lunatic guy played with the order of vowels. Please fix me !

So I'd need a pragrom which can rateto the vewols (and the 'y' letter as it seems) back so that the text is raadeble agian.
Ouy can choeso the lungaega of ouyr chieco privedod ouy meka a cempleto pragrom (so not just a finctoun). The yntre can be an unpit feild, a text feli, or the cammond leni. The uutpot mya olsa vyra as ouy leki.
Of cuerso I'll anvilid yna pragrom uutpitong bad texts. There's no vulea in a pragrom which mekas texts ouy can't endarstund. But ouy can wreti ouyr cemmonts and qeistouns in ratetod texts if ouy want.

Clarifications

Your program is only required to handle ASCII text.
For the purposes of this question, the following characters are vowels: aeiouy
The positions of the vowels within each word should be rotated. There is some flexibility in deciding what qualifies as a word: the minimum requirement is that two characters separated by a space are in different words, and that two alphabetic characters (a-zA-Z) separated only by alphabetic characters are in the same word.
The desired direction of rotation should be inferred from the test cases below.

Test cases
Input: I'm a badly written text. Some lunatic guy played with the order of vowels. Please fix me !
Output: I'm a bydla wrettin text. Semo lanituc gyu plyead with the erdor of vewols. Plaese fix me !
Input: AeiOuy
Output: EioUya
Input: Hyphenated-word
Output: Hephanetyd-word or Hephanetod-wyrd

Define vowel.

@PeterTaylor Isn't that clear from the question ?

Damn, the Ruby answer was very good, apart the minor fact it did exactly the opposite. I hope to see it again.

I heva a neci 114-charectar sulotion in ceffeiscropt, but it braeks the charectar cesa. Deos that meka it anvilid?

Do I need to preserve the cesa?

@JanDvorak eys ouy need.

Then ouy won't see my sulituon and I'll heva to wreti a new eno.

I leki "preserve" in this centoxt.

Mya I ussema that aech word is iether lewarcose, Upparcese or SCRAIMANG-CESE?

What is the cerroct fix for "screaming-case"? "scraimang-cese", or "scraimeng-cesa"?

The question is deliberately opaque. Given that there are several possible definitions (among others, only the 10 code-points corresponding to aeiouAEIOU in ASCII / Basic Latin; those code-points plus any others in Basic Latin and Latin-1 Supplement which have those basic characters combined with a diacritic), the question should be explicit.

@PeterTaylor I assume ASCII

@JanDvorak For "screaming-case", both solutions would be accepted. Don't assume the case, just keep it based on char position.

The game should not be about guessing the problem. See the FAQ: "All questions on this site, whether a programming puzzle or a code golf, should have … A clear specification of what constitutes a correct submission."

I added a Ruby solution

Why are these answers treating y as a vowel?

@Gareth because the question did it too.

@dystroy But the question was asked in english so the reasonable assumption (given that vowel is not explicitly defined) is that you are talking about vowels in the english language: [aeiou]. Without an explicit definition (as requested by Peter Talyor in the first comment) it's impossible to judge whether the given answers are correct or not.

@Gareth There was a legitimate error in the question. I'm sorry for that. I think it's clear now ?

Wouldn't "Some" become "Semo"? (First test case)

If nobody is writing another answer or can point a problem in the GolfScript one, I'll accept it.

@dystroy, you can unaccept an answer or change the accepted answer, so if someone is currently working on an answer and it turns out to be shorter they'll post it anyway.

GolfScript, 68 67 57 characters
" "/{..+{95&"AEIOUY"?)}:C,1>\{.C!!{96&\(31&@|}*}%\;}%" "*

Input must be given on STDIN. Example (online):
> You!!! I'm a badly written text. Some lunatic guy played with the order of vowels. Please fix me !
Ouy!!! I'm a bydla wrettin text. Semo lanituc gyu plyead with the erdor of vewols. Plaese fix me !

Ruby, 91 90 characters
$><<gets.gsub(/\S+/){|x|x.gsub(r=/[aeiouy]/i){|y|z=$'[r]||x[r];y>?Z?z.downcase: z.upcase}}

Coffeescript, 148 charectars
alert prompt().replace /\S+/g,(x)->x.replace r=/[aeiouy](?=(.*))/gi,(y,z)->((t=z.match r)&&t[0]||x.match(r)[0])[['toLow','toUpp'][y>'Z']+'erCase']()

No ussimtoans, except that "holf-cerract" is a word, and not my sulitoon.
Test:
> To test this program, simply enter a long sentence that appears half-broken
  To test this pragrom, sympli enter a long sentence that eppaars holf-brekan

> No MaTtEr HoW mUcH cAsE yOu uSe, It WoRkS
  No MeTtAr HoW mUcH cEsA oUy eSu, It WoRkS

Regarding the Ruby code: 1) spare 2 characters by using $& instead of the second gsub() block's y parameter; 2) spare 1 character by using ?Z instead of 'Z'.

@manatwork $& cannot be used because it is changed before I use it. z=$'[r] changes it. Concerning ?Z - thanks, I totally forgot about this syntax.

Oops. No idea how I tested it yesterday so appeared to work…

Haskell, 159 characters
Didn't end up quite as short as I'd hoped, but I decided to post it anyway:
import Data.Char
f s=let(v,t)=foldr g(v,[])s in t
g x(v,t)=last$(v,x:t):[(x,c v:t)|c<-[toUpper,toLower],x`elem`map c"AEIOUY"]
main=interact$unwords.map f.words

Ungolfed version:
import Data.Char

rotateVowels :: String -> String
rotateVowels word = result
  where (vowel, result) = foldr step (vowel, []) word
        step ch (vowel, rest)
          | ch `elem` "AEIOUY" = (ch, toUpper vowel : rest)
          | ch `elem` "aeiouy" = (ch, toLower vowel : rest)
          | otherwise          = (vowel, ch : rest)

main = interact $ unwords . map rotateVowels . words

This is a nice example of how lazy evaluation can let you do cool tricks. In rotateVowels, each time a new vowel is found, it is passed on to the left, while replacing it with the one coming from the right. This part of the output from the fold is fed back as the input so that the leftmost vowel becomes the replacement for the rightmost one.
(vowel, result) = foldr step (vowel, []) word
 ^^^^^                        ^^^^^
 this part of the output      is part of the input

Python 2, 172 bytes
for w in input().split():p=[];q=list(w);z=filter(lambda c:c in'aeiouyAEIOUY',q);x=z[1:]+z[:1];print''.join(y in z and[str.upper,str.lower][y>'Z'](x.pop(0))or y for y in q),

Try it online!

@KevinCruijssen fixed it

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


text:
Convert this character based table into html one
Take a following character table:
-------------------------------------------------------
|       |1233456 | abc    | xyz    |        |         |
|-------|--------|--------|--------|--------|---------|
|       |abcdefgh| 1234567|        | 12345  |         |
|   abc |xyzabcqw|        |        |        |         |
|       |zzzz    |        |        |        |         |
|-------|--------|--------|--------|--------|---------|

It can have a variable number of columns or rows. Column width and row height can vary. Cells can be empty or have text, but the row height is optimized to wrap the text. So, second row has three lines because second cell content in second row is three lines high.
Input is ASCII text as shown in example. Cells can not contain | or - characters. Cell content should be escaped, but no need to worry about rowspan and colspan, since the table structure is always simple (every row same number of columns and every column same number of rows).
Output should be well-formed xhtml. Html table should reflect the table structure, content and line breaks. So, resulting html based on the sample input above is the following:

    1233456
    abc
    xyz

    abc
    abcdefgh
xyzabcqw
zzzz
    1234567

    12345

Shortest code which takes this table and turns it into an xhtml table wins.

Please add some specification to your challenge. What are allowed input formats? Are all columns of even size (as your example indicates)? Why are some contents padded by spaces/empty lines? What features do we need to reflect also in the html table? Column widths? Padding? Text wrapping? Do we need to output well-formed html?

@Howard hope the last edit will help.

Are colspan and rowspan support required? Are the cell contents expected to be escaped, or do we need to escape them?

Do you you require the output to be XHTML-compliant (every tag is closed or self-closing), as the output example suggests, or HTML 4.0 Transitional (most closing tags are not required) will suffice?

@PeterTaylor I edited the text to respond your question, in short: no need for row and colspan, but should escape content.

@JanDvorak should be valid xhtml.

You say XHTML, but then your "HTML table" link points to the HTML 4.0 spec. Which one is it, then?

@JanDvorak xhtml. Just wondering: what is the difference between the two except that in xhtml you have to close the tags properly?

@Dan XHTML is valid XML while HTML is valid SGML. Apart from the need to close every tag, the differences include a different doctype and, more importantly, the handling of character data: In XHTML, you need to enclose data like scripts in <![CDATA[...]]> or similar (I don't remember the exact syntax) or XML-escape them, whereas in HTML literal handling is assumed. This makes dual-XHTML/HTML scripts a little unwieldy (//<![CDATA[...//]]>). Another difference is that XML supports namespaces whereas HTML merely supports colons in tag names. XHTML is practically dead now (thankfully).

Maybe some special characters in the sample input would help to exemplify the escaping part of the requirement.

@manatwork I assume "valid XML that displays the input characters"

@JanDvorak, I understand that. But I see tmartin used the sample input for testing his code, just as I did. So I wish we have a better official sample, including as much catchy items as possible.

It's my first question, so I appreciate contributions to the question to make it "golfy"; I think that basic idea is clear.

Ruby: 233 characters
BEGIN{puts"
";f=[]};if/^[-|]+$/ then if f!=[] then puts"
\n#{f[1..-2].map{|i|"    #{i.join"
"}	"}*$/}\n
\n";f=[]end else$F.each_index{|i|f[i]||=[];f[i]<<CGI.escapeHTML($F[i])if$F[i]>""}end;END{puts"
"}

Sample run:
bash-4.2$ ruby -naF' *\| *' -r cgi -e 'BEGIN{puts"
";f=[]};if/^[-|]+$/ then if f!=[] then puts"
\n#{f[1..-2].map{|i|"    #{i.join"
"}	"}*$/}\n
\n";f=[]end else$F.each_index{|i|f[i]||=[];f[i]<<CGI.escapeHTML($F[i])if$F[i]>""}end;END{puts"
"}' table.txt

    1233456
    abc
    xyz

    abc
    abcdefgh
xyzabcqw
zzzz
    1234567

    12345

(Out of contest CW, due to the shameless amount of used command line options.)

It's better to wait until the spec is fairly complete before answering, because otherwise there's a risk that either you'll have to rewrite to accommodate clarifications or that you'll bias the clarifications towards your implementation (which might mean biasing them away from the more interesting problem).

Use of command line options is fine, but they must be included into the code length.

@JanDvorak, I know that -p counts 1 in case of perl and ruby. But never found a concise set of rules for them. Do you know about such rule collection?

@manatwork Try ruby -h to get you started.

@steenslag, you misunderstood the question. I know the interpreter's command line options. I not know how their use should be counted in code-golf challenges' results.

K, 186
Haven't put any effort into golfing this.
{-1',/(,"<",g;,/{,/(,"
";x;,"
")}'{("",/:*:'x),\:"	"}'{{$[1<+/~""~/:x;,"
"/:x;x@&~""~/:x]}'+x}'-1_'/:1_'/:f@&~()~/:f:$`$"|"\:''1_'(&"-"in/:x)_x;,"</",g:"table>");}

.
k)t
"-------------------------------------------------------"
"|       |1233456 | abc    | xyz    |        |         |"
"|-------|--------|--------|--------|--------|---------|"
"|       |abcdefgh| 1234567|        | 12345  |         |"
"|   abc |xyzabcqw|        |        |        |         |"
"|       |zzzz    |        |        |        |         |"
"|-------|--------|--------|--------|--------|---------|"

k){-1',/(,"<",g;,/{,/(,"
";x;,"
")}'{("",/:*:'x),\:"	"}'{{$[1<+/~""~/:x;,"
"/:x;x@&~""~/:x]}'+x}'-1_'/:1_'/:f@&~()~/:f:$`$"|"\:''1_'(&"-"in/:x)_x;,"</",g:"table>");} t

1233456
abc
xyz

abc
abcdefgh
xyzabcqw
zzzz
1234567

12345

GNU Awk: 277 characters
BEGIN{split("38&60<62>34\"39'",e,/\W/,c)
FS=" *\\| *"
print"
"}/^[-|]+$/&&n{print"
"
for(i=2;i<n;i++)print"    "f[i]"	"
print"
"
delete f
next}{for(i=1;i<6;i++)gsub(c[i],"\\&#"e[i]";")
for(i=2;i<n=NF;i++)$i&&f[i]=f[i](f[i]?"
":"")$i}END{print"
"}

Note that the above code requires gawk version 4.0 or never, because

delete for an entire array is GNU extension
split()'s 4th parameters was implemented in version 4.0

Without HTML escaping: 201 characters
As there is not specified how HTML escaping should happen (whether the use of built-in or third party functions is allowed, the set of characters to escape, whether using entity names or character codes matters), I believe this challenge was neater without the escaping:
BEGIN{FS=" *\\| *"
print"
"}/^[-|]+$/&&n{print"
"
for(i=2;i<n;i++)print"    "f[i]"	"
print"
"
delete f
next}{for(i=2;i<n=NF;i++)$i&&f[i]=f[i](f[i]?"
":"")$i}END{print"
"}

Sample run:
bash-4.1$ awk -f table.awk table.txt

    1233456
    abc
    xyz

    abc
    abcdefgh
xyzabcqw
zzzz
    1234567

    12345


text:
Determine stability of a system using the Routh-Hurwitz stability criterion
The Routh-Hurwitz is a criteria which serves to prove or disprove the stability of an electric control system.
Idea
Given a system which has an equation of the form P(s)/Q(s) where P(s) and Q(s) are polynomials of any degree, it is said to be stable if all the roots of the polynomial Q(s) are in the left half of the complex plane, which means the real part of the root is negative.
For polynomials of degree less than or equal to 2, it is trivial to determine the roots and notice whether or not the system is stable. For polynomials Q(s) of higher degrees, the Routh–Hurwitz theorem can be useful to determine whether the system is Hurwitz-stable or not.
Process
One of the methods to apply this theorem for any degree is described on Wikipedia that consists of performing operations on rows of a table, then counting the number of sign changes in the first column of the table. It goes as follows:

Fill the first two rows with the coefficients of the polynomial, in the following pattern: 1st row consists of the even coefficients s^n, s^n-2, ..., s^2, s^0; 2nd row consists of the odd coefficients s^n-1, s^n-3, ..., s^3, s^1;
Keep calculating the following rows by calculating the determinant of the matrix (last 2 rows of the first column, last 2 rows of the next column) divided by (the value of the first column on the row above); it is detailed in this part of the Wikipedia article.
If you encounter a row full of zeros, set it to the derivative of the polynomial that the row above it represents. Depending on the row it is on, the number on each cell represents a coefficient. It is illustrated in the example later.
If you encounter a zero with other non-zero values, the system is not stable: you can stop there. (You could continue but you'll get the same result). A zero on the first column would mean a root of real value 0, which renders the system unstable.
Otherwise, continue until the end. Then, if not all the values in the first column are of the same sign, the system is not stable.

Examples
Here are some examples of that process:
# Polynomial: 1 3 6 12 8.00

s^4  1 6  8
s^3  3 12 0
s^2  2 8  0
s^1--0-0--0-- < Row of zero - replace it by:
s^1  4 0  0   < Derivative 2*s^2 + 8*s^0 = 4*s^1
                 (between each 2 columns the power of s is lowered by 2)
s^0  8 0  0   < Continue normally

# Sign Changes: 0 (equivalent to no root in the right half plane)
# Stable: Yes

Another one:
s^2   1  -2
s^1   1   0
s^0  -2   0

# Sign Changes: 1 (equivalent to 1 root in the right half plane)
# Stable: No

Rules

The program will keep reading polynomials from standard input until a blank line, and output 0/1 for stable/non-stable respectively for each polynomial on a new line.
The program can read the polynomial coefficients in any form. It could be 1 3 6 12 8 for the first example (it suits this problem better, but it doesn't really matter in the end).
It has to handle cases where 0 in the first column, or 0 in the following columns, or a row full of 0 is encountered properly. (Note: just in case, no need to see how many roots are in rhp/lhp/jw axis).
It can short-circuit the process at any time if a condition is met, there is no need to show the RH table in the end.
You do not have to use this method. Any method which will determine whether or not a system is Hurwitz-stable can do the job.
It doesn't matter which language you chose to do it with, as long as it's not done in one single built-in function call. I did mine in Python, I'll post it soon.
This is a code golf. The shortest code wins.

Here's a sample input/output (given in the above mentioned way) to test your program with:
#input:
1 12 6 10 10 6 14
1 1 -2
1 2 1 2
1 3 1 3 16
1 2 3 6 2 1
1 2 14 88 200 800
1 2 3 6 2 1
1 3 6 12 8
1 4 5 2 4 16 20 8

#output:
0
0
1
0
0
0
0
1
0

If you need more clarifications, let me know, I'll do my best to clarify.

How are the rows calculated?

It is written on the wikipedia page in details

It's a great example of a Wikipedia page which is only of any use to anyone who already knows the topic well and just needs to be reminded on some detail. Since you've recently studied the subject and written a computer program to do it, I'm sure you can write a description which is actually implementable.

Followup thought: why not simplify the question by just asking for a program which takes real polynomials as inputs and outputs whether or not they are Hurwitz-stable (with suitable constraints to disallow one-token Mathematica solutions)? That way people can approach the problem using this tabular approach, a principal-minor-of-Sylvester-matrix approach, factorisation to irreducible polynomials over the reals, ... Allowing a variety of approaches tends to give more interesting challenges.

@PeterTaylor Yes, you are right. Sorry, it's the first time I post here. I'll try to fix it now :)

Haskell - 264 bytes
p(a:b:s)=(a,b):p s
p[a]=[(a,0)]
p[]=[]
s((a:w),m@(b:v))=a:s(m,m%zipWith(\c d->(b*c-a*d)/b)w v)
s((a:_),_)=[a]
m%(0:v)|all(==0)v=fst$foldr(\b(d,p)->(b*p:d,2+p))([],0)m
m%v=v
q(a:s)|all((>0).(a*))s="1\n"
q _="0\n"
main=interact$(>>=q.s.unzip.p.map read.words).lines

Running the sample inputs:
& runhaskell 11847-Stability.hs
1 12 6 10 10 6 14
1 1 -2
1 2 1 2
1 3 1 3 16
1 2 3 6 2 1
1 2 14 88 200 800
1 2 3 6 2 1
1 3 6 12 8
1 4 5 2 4 16 20 8
0
0
1
0
0
0
0
1
0

(The output is interleaved with the input if you type it one line at a time, as per spec. If you bulk paste, you see all the output after the input.)

Python (645 bytes)
That's what I managed to do (and golf):
from decimal import*
R=xrange
def s(p):
 d=len(p)
 if 0 in p:return 0
 elif sum(1 for c in p if c>0) not in (0,d):return 0
 p=p+[0] if d%2 else p[:]
 r=[[0 for j in R(len(p)//2)] for i in R(d)]
 r[:2]=[[v for v in p[i::2]] for i in (0,1)]
 for i in R(2,len(r)):
  a,h,b = 1,0,0
  for k in R(len(r[i])-1):
   v=(r[i-1][0]*r[i-2][k+1]-r[i-2][0]*r[i-1][k+1])/r[i-1][0]
   r[i][k],a,h,b=v,a and v==0,h or v==0,b or (h and v!=0)
  if a:r[i]=[v*max(0,d-i-2*k) for k,v in enumerate(r[i-1])]
  elif b:return False
 return sum(1 for v in r if v[0]>0) in (0,d)
while 1:
 r=raw_input()
 if not r:break
 print 1 if s([Decimal(x) for x in r.split()]) else 0

It takes as input the coefficients of the polynomials in decreasing order (highest power of s to lowest 0).

You should probably add that this is Python 2.x

I haven't actually tested this, but it seems like R=xrange can drop the x and 1 if s([Decimal(x) for x in r.split()]) else 0 can be replaced by int(s([Decimal(x) for x in r.split()])).

return False can probably be return 0 and can definitely be return 0>1.

0>1. That is plain evil.


text:
Quickly divide in Manufactoria
Background
Manufactoria has been marketed as a game, but we code-golfers can see it for what it really is: a two-dimensional programming language.  The Manufactoria programming language is based around a single queue, which contains a series of colorful markers.  The instruction pointer moves around the game board using conveyor belts, and it encounters a series of writers and branches which read from and write to the queue.
The language is very easy to understand, so the quickest way to learn it is to play the first few levels of the game (linked above).
Challenge
Your challenge is to create a program that can divide one number by another number in the least amount of time.
The input to the program will be a string of X blue markers followed by Y red markers.  The required output will be a string of red markers with a length of X/Y.
The game board to be used is found in this official contest level:
http://pleasingfungus.com/Manufactoria/?ctm=Divide_and_Conquer;Input_will_be_X_blues_followed_by_Y_reds,_output_X/Y_reds;bbbbbbrr:rrr|bbbrrr:r|bbbbr:rrrr|r:|bbbbbbbbbbbbrrrr:rrr|bbbbbbbbbbbbrrr:rrrr|bbbbbbbbbrrr:rrr|bbbbbbbbbbrr:rrrrr;13;3;0
It is 13x13 (the maximum size) and it is pre-equipped with the correct tests (see the scoring section).
Scoring
The score of your program is the total amount of time that it takes for the program to pass all of the tests in the official contest level.  The total time is given on the level-complete screen.
While running the tests, you will most likely have to use the 50x accelerate slider in the bottom left in order to receive the results quickly (time acceleration does not affect the score).
Here is a list of division problems that are involved in the tests:
 6/2 = 3
 3/3 = 1
 4/1 = 4
 0/1 = 0
12/4 = 3
12/3 = 4
 9/3 = 3
10/2 = 5

Example I/O
12/3=4
in:  BBBBBBBBBBBBRRR
out: RRRR

10/2=5
in:  BBBBBBBBBBRR
out: RRRRR

9/3=3
in:  BBBBBBBBBRRR
out: RRR

0/1=0
in:  R
out:

Cool stuff, that game! Don't really gave time to golf these days but will remember this.

Score 3:29
Might as well special case dividing by 1,2,3,4.  Makes it a lot faster.

http://pleasingfungus.com/Manufactoria/?lvl=34&code=c9:13f2;c10:13f2;c11:13f2;p12:2f7;y13:2f0;p11:2f0;c11:4f3;c10:3f0;p11:5f0;c10:5f0;c9:5f0;c11:6f3;p11:7f0;c10:7f0;p11:3f0;r10:6f1;q8:5f4;q8:6f1;q9:6f1;c7:5f3;c7:6f3;q10:2f0;r10:1f3;r10:4f1;q9:3f4;q9:4f1;c9:2f3;c8:3f3;c8:4f3;r10:8f1;q10:9f6;q9:9f1;q9:8f4;q9:7f4;c8:8f3;c8:9f3;c8:10f3;c8:11f3;c8:12f3;c8:13f2;c7:7f2;c8:7f3;r11:9f3;r11:10f0;r10:10f0;r9:10f3;r9:11f2;p11:11f6;r11:12f1;g11:8f3;b10:11f2;c16:10f2;q17:10f6;q17:11f3;g18:11f0;c12:11f1;c12:10f2;c13:10f2;c14:10f2;c15:10f2;c17:12f0;p16:12f4;c16:11f3;c16:13f1;q15:12f0;r15:13f1;c14:12f3;c14:13f0;c13:13f0;q17:7f6;q17:9f1;q18:9f6;q18:8f5;q17:6f1;g16:6f2;y18:6f0;p17:5f5;r18:5f0;c16:5f0;p15:5f0;r15:6f3;b15:7f2;p16:7f6;r16:8f1;q14:5f0;y14:4f3;g14:6f1;p13:5f0;p13:6f0;p13:7f0;p13:8f0;p13:9f1;g12:9f0;c17:8f1;&ctm=Divide_and_Conquer;Input_will_be_X_blues_followed_by_Y_reds,_output_X/Y_reds;bbbbbbrr:rrr|bbbrrr:r|bbbbr:rrrr|r:|bbbbbbbbbbbbrrrr:rrr|bbbbbbbbbbbbrrr:rrrr|bbbbbbbbbrrr:rrr|bbbbbbbbbbrr:rrrrr;13;3;0;

I should have predicted this, but anyways good job.  I wish the game engine allowed me to create more than 8 test cases.  Should I create more Manufactoria challenges in the future?

Sure, I like them.

Score: 15:51

Does division by repeated subtraction.  Uses a Y amongst the R to keep track of how much divisor we've subtracted so far.  Uses Gs to count the quotient.
For instance, the state at the start of each outer loop (right after the initial G writer) for 12/4 is:
BBBBBBBBBBBB RRRR G
BBBBBBBB RRRR GG
BBBB RRRR GGG
RRRR GGGG

When there are no Bs left, the gadget at the bottom left strips Rs and then outputs #G-1 Rs.
The inner loop strips one B at a time and uses Y to keep track of position.  Starting at the outer loop:
BBBBBBBB RRRR GG
BBBBBBB RYRRR GG
BBBBBB RRYRR GG
BBBBB RRRYR GG
BBBB RRRR GG

The inner loop is the 3x4 box in the lower right.  The layout of the rest can probably be improved a bit, but the inner loop is tight.
http://pleasingfungus.com/Manufactoria/?lvl=34&code=c11:13f2;g12:2f3;p12:3f7;c13:3f3;p13:4f3;b12:4f2;r14:4f3;p14:7f7;r13:7f2;q14:8f7;g13:8f2;p14:9f4;r13:10f2;p14:10f7;b15:10f0;q14:11f7;p15:11f3;r16:11f1;p15:8f0;r15:9f1;c16:8f0;c13:2f0;c15:2f0;c16:2f0;c17:2f0;c11:3f3;c11:4f3;c11:6f3;c11:7f3;c11:8f3;c11:9f3;c11:5f3;p11:10f7;q11:11f6;q11:12f7;r10:12f2;c10:10f2;q16:10f5;y14:6f3;q14:5f3;g15:5f1;c15:4f1;c15:3f1;c17:9f1;c17:8f1;c17:7f1;c17:6f1;c17:5f1;c17:4f1;c17:3f1;y16:9f1;g17:10f1;q14:2f4;g14:1f3;&ctm=Divide_and_Conquer;Input_will_be_X_blues_followed_by_Y_reds,_output_X/Y_reds;bbbbbbrr:rrr|bbbrrr:r|bbbbr:rrrr|r:|bbbbbbbbbbbbrrrr:rrr|bbbbbbbbbbbbrrr:rrrr|bbbbbbbbbrrr:rrr|bbbbbbbbbbrr:rrrrr;13;3;0;

By drastically rearranging the parts of your design, I have been able to reduce the score to 13:28 with 53 parts.

Score 20:35
A completely different approach - less parts but considerably slower.

http://pleasingfungus.com/Manufactoria/?lvl=34&code=p12:2f3;g11:2f3;b11:3f3;c12:4f2;c11:4f2;c13:2f3;c13:3f3;c13:4f3;c12:5f3;c11:5f1;c10:5f2;c9:8f3;c9:9f3;c10:11f2;c11:11f1;c11:9f1;c11:10f1;c11:12f2;c13:8f0;c11:8f0;c13:7f0;c14:7f0;c14:6f3;c12:7f3;y14:5f0;y10:6f1;y11:7f1;g12:6f2;g9:11f2;g10:10f0;q9:10f3;q13:5f7;q13:6f7;b11:6f1;b10:9f1;p10:7f1;r9:7f2;p10:8f4;p12:8f3;q12:12f3;r13:12f0;r8:10f2;c12:9f3;c12:10f3;c12:11f3;&ctm=Divide_and_Conquer;Input_will_be_X_blues_followed_by_Y_reds,_output_X/Y_reds;bbbbbbrr:rrr|bbbrrr:r|bbbbr:rrrr|r:|bbbbbbbbbbbbrrrr:rrr|bbbbbbbbbbbbrrr:rrrr|bbbbbbbbbrrr:rrr|bbbbbbbbbbrr:rrrrr;13;3;0;


text:
Return the last color of the input in Manufactoria
This puzzle is the next in my series of Manufactoria challenges.
Background
Manufactoria is a game / two-dimensional programming language.  The player must create programs that will manipulate a queue to arrive at the desired output.  It is easy to learn but hard to master, so it lends itself to creating a wide variety of challenges.  If you don't know what I am talking about, I advise that you play the first few tutorial levels of the game.
Challenge
Your challenge is to create a machine that will return the very last element of the input string.  To make this even more challenging, the input string can be any combination of all four colors.
The official custom level to be used is found here:
http://pleasingfungus.com/Manufactoria/?ctm=Last_in_Line!;IN:_a_series_of_colors_OUT:_the_very_last_color;byrgyrbyrrgry:y|bbrrbryyyrrbr:r|ggryybrryr:r|b:b|:|gyrbrygbrygbyrb:b|brbrbryyrygbrg:g|rrrrrrrrrr:r;13;3;0;
This week's challenge is mostly focused on the idea of compression. I chose this challenge to require a huge mess of conveyor belts. The fact that all four colors appear in the input means that it is very hard to store information.
Although I did not attempt compression, my first working prototype had 114 parts and fit into the 13x13 space with almost no room to spare.
Scoring
The goal of this challenge is to use a few parts as possible.  The score is the number of parts placed, and the lowest score wins.
Although there are only 8 test cases, your creation should be able to theoretically function under any test case.  The test cases provided are for debugging purposes.
Examples
in:  byrgyrbyrrgry
out: y
in:  ggryybrryr
out: r
in:         #don't you love degenerate cases?
out:
in:  gyrbrygbrygbyrb
out: b

65 parts

To be honest I couldn't even come up with the idea of putting pairs of readers directly against each other until I saw it in the already-posted solutions. But later I started to come up with a lot of optimization tricks.
Link

...you can put conveyor belts on top of eachother?

73 69 parts

Organizing as a strip seems to save a lot of devices.  Left-to-right, the columns are "last color was yellow", "last color was blue", two columns of devices, "last color was red", "last color was green", and "all done".
http://pleasingfungus.com/Manufactoria/?lvl=35&code=c10:8f2;q11:6f5;i11:7f0;p11:8f5;i12:6f4;q12:7f5;p12:8f5;c13:8f0;i10:7f6;i10:6f6;i13:6f7;i13:7f7;c9:6f3;c9:7f3;c9:8f3;q11:9f3;q12:9f3;c9:9f2;i10:9f3;i13:9f2;g12:12f3;c10:10f1;c13:11f1;c13:10f1;c10:11f1;p12:2f3;q12:3f3;c13:2f3;i13:3f5;c11:2f0;c10:2f3;i10:3f1;c11:3f0;c9:3f3;p11:11f3;p12:10f3;i11:10f1;i12:11f5;c14:3f3;c14:6f3;c14:7f3;c14:8f3;c14:9f0;i14:4f5;c14:5f3;i13:4f5;c13:5f3;y11:12f3;c11:13f2;c9:4f3;c9:5f3;c10:4f3;c10:5f3;b11:5f1;c11:4f2;c12:4f2;c15:4f3;c15:5f3;c15:6f3;c15:8f3;c15:7f3;c15:9f3;c15:10f3;c15:11f3;c15:12f3;c15:13f0;c14:13f0;c13:13f0;r12:5f1;&ctm=Last_in_Line!;IN:_a_series_of_colors_OUT:_the_very_last_color;byrgyrbyrrgry:y|bbrrbryyyrrbr:r|ggryybrryr:r|b:b|:|gyrbrygbrygbyrb:b|brbrbryyrygbrg:g|rrrrrrrrrr:r;13;3;

I've built like five different solutions to this one and they were all over 100 parts in size. Your solution blows me away.

99 90 84 81 Parts

Yes - this is a mess of conveyer belts. But finally considerably less than 100 parts - also thanks to Volatility.
http://pleasingfungus.com/Manufactoria/?lvl=33&code=p12:9f3;i12:2f1;c11:9f0;c9:8f2;c10:8f2;i11:8f7;i12:8f5;i12:4f5;i12:5f5;c12:6f3;i12:7f1;i13:9f3;c14:8f3;i13:8f3;q12:3f3;q15:4f7;p15:5f7;c14:5f3;i14:6f1;i14:7f1;i13:7f0;i13:6f0;i13:5f4;c11:7f3;c10:7f2;c15:7f0;c16:5f3;c16:7f0;c11:2f3;c13:2f0;c14:2f0;c15:2f0;c16:3f1;c16:4f1;c16:2f0;c17:4f0;c17:5f1;c17:7f1;c17:8f1;c8:8f1;c8:7f1;c8:5f1;c8:4f2;c16:6f3;c17:6f1;g15:6f0;c8:6f1;c8:9f1;c8:10f1;c9:9f1;c9:10f0;p10:9f7;q10:10f3;b10:11f2;c11:10f2;c11:11f2;i12:10f5;c12:11f3;c13:10f1;c13:11f0;c16:10f2;c17:9f1;c17:10f1;c12:12f3;p14:9f7;q14:10f7;r14:11f0;c15:9f1;c15:8f1;c15:10f2;c11:3f3;q11:4f3;p11:5f3;y11:6f2;c10:5f3;c10:6f3;c9:4f2;c10:4f2;c13:3f3;c13:4f2;c14:4f2;&ctm=Last_in_Line!;IN:_a_series_of_colors_OUT:_the_very_last_color;byrgyrbyrrgry:y|bbrrbryyyrrbr:r|ggryybrryr:r|b:b|:|gyrbrygbrygbyrb:b|brbrbryyrygbrg:g|rrrrrrrrrr:r;13;3;0;

A little rearranging of conveyor belts reduced this down to 81 parts. See here. Also, changing the colours around seems to make it faster (although it really doesn't matter) from 6:23 to 5:38. See this paste for the URL.

@Volatility Thank you for the 3 parts. The seems faster totally depends on the test cases, so it really doesn't matter ;-)

91 88 parts

The upper left gadget handles green/blue, the lower right gadget handles red/yellow.
http://pleasingfungus.com/Manufactoria/?lvl=35&code=q8:6f5;c8:7f2;c9:5f2;p9:6f4;q9:7f2;i10:5f7;c10:6f0;p10:7f3;i12:6f6;i13:6f6;c13:11f0;i14:6f6;p14:10f3;r14:11f0;c15:6f0;p15:9f6;q15:10f0;c15:11f2;c16:6f0;q16:9f5;c16:10f0;i16:11f3;c17:6f0;c17:7f1;c17:8f1;c17:9f1;c17:11f1;b10:8f2;i11:8f7;c12:4f3;c12:7f3;c12:8f3;i12:9f5;i12:10f1;c12:11f3;i12:12f5;c14:3f3;c14:4f3;c9:4f2;i10:4f7;i11:4f7;c7:8f2;i8:8f3;c9:8f3;c9:9f2;c10:9f2;i11:9f7;i13:9f7;c14:9f2;c13:10f0;i11:10f6;c10:10f0;c9:10f0;c8:10f1;c8:9f1;c15:7f0;i14:7f6;i13:7f6;c15:8f0;i14:8f6;c13:8f3;c8:4f2;c16:7f0;g8:5f1;y16:8f1;q12:3f7;c13:2f3;i13:3f5;c13:4f3;i11:3f6;c10:3f3;p12:2f7;c11:2f3;c7:6f3;c7:7f3;c11:5f3;i11:6f6;c11:7f3;c12:5f3;c13:5f3;c14:5f3;c17:10f1;c11:11f3;c11:12f2;c13:12f2;c14:12f2;c15:12f2;c16:12f1;&ctm=Last_in_Line!;IN:_a_series_of_colors_OUT:_the_very_last_color;byrgyrbyrrgry:y|bbrrbryyyrrbr:r|ggryybrryr:r|b:b|:|gyrbrygbrygbyrb:b|brbrbryyrygbrg:g|rrrrrrrrrr:r;13;3;0;

+1 - several ideas: shift the top red/blue divider three places south, you can save the bottom left part (shift one to the left)

75 parts

http://pleasingfungus.com/Manufactoria/?lvl=34&code=c11:9f1;q11:11f3;p11:12f7;g11:13f2;i12:9f1;i12:10f1;i12:11f1;i12:12f5;p13:9f7;i13:11f1;i13:12f5;i14:11f0;q13:10f3;c14:9f0;c15:11f0;c14:12f1;i14:10f4;c15:9f3;c15:10f3;c10:12f1;i10:11f0;i10:10f0;c10:9f1;c9:11f1;c9:10f1;c9:9f1;b13:13f0;c11:10f0;c9:6f2;c9:7f1;c9:8f1;c10:5f3;i10:6f5;i10:7f1;c10:8f2;r11:4f2;i11:5f0;i11:6f4;q11:7f5;p11:8f1;c12:4f3;i12:5f1;i12:6f5;i12:7f5;i12:8f5;y13:4f0;p13:5f1;q13:6f5;c13:7f2;c13:8f3;c14:5f3;i14:6f5;i14:7f5;c14:8f3;c15:6f3;c15:7f3;c15:8f3;p12:2f7;q12:3f3;c11:3f0;i14:3f5;c13:3f2;c15:3f3;c15:4f3;c15:5f3;c14:4f3;c10:4f3;c9:5f3;c9:4f3;c9:3f3;c10:2f3;c14:2f3;c13:2f2;c11:2f0;i10:3f1;&ctm=Last_in_Line!;IN:_a_series_of_colors_OUT:_the_very_last_color;byrgyrbyrrgry:y|bbrrbryyyrrbr:r|ggryybrryr:r|b:b|:|gyrbrygbrygbyrb:b|brbrbryyrygbrg:g|rrrrrrrrrr:r;13;3;0;
Yeah, I know, it's six parts more than Keith Randall's solution, but what can I say?  I like the symmetry.


text:
Generate Skolem sequences
Skolem sequences
A Skolem sequence is a sequence of 2n numbers where every number i between 1 and n occurs exactly twice, and the distance between the two occurrences of i is exactly i steps.
Here are some examples of Skolem sequences:
1 1
1 1 4 2 3 2 4 3
16 13 15 12 14 4 7 3 11 4 3 9 10 7 13 12 16 15 14 11 9 8 10 2 6 2 5 1 1 8 6 5

The following sequences are not Skolem sequences:
1 2 1 2      (The distance between the 1's is 2, not 1)
3 1 1 3      (The number 2 is missing)
1 1 2 1 1 2  (There are four 1's)

Objective
Write a program, function, or expression to count the number of all Skolem sequences of a given length.
More explicitly, your input is an integer n, and your output is the number of Skolem sequences of length 2n.
This sequence has an OEIS entry.
For n = 0, you may return either 0 or 1.
The first few values, starting from 0, are
0, 1, 0, 0, 6, 10, 0, 0, 504, 2656, 0, 0, 455936, 3040560, 0, 0, 1400156768

Rules and scoring
This is code golf.
Output format is lax within reason.

Just curious, but what is the 0, 1, 0, 0, 6... in your question? Is that the code snippet, if so what language is that?

@PhiNotPi: It represents the number of Skolem sequences of length 2n, starting at n=0 (first element is 0).

"expression to count Skolem sequences of length n" -- I believe you meant "... of length 2n".

Why is the first item in your output 0? If you're going to admit 0 as a valid input then the output should be 1.

Some (including my code) believe that there are zero empty sequences.  If 1 makes you feel better, return it.

AFAIK in every context you assume there is one and only one empty sequence/null object/empty set etc/function-to/from-the-empty-set/empty graph/whatever else.

@boothby: Out of curiosity, what language is your program written in?

@Bakuriu Only fools argue about values of 0^0.

@boothby, did you just call Knuth a fool?

@PeterTaylor Yeah, probably.  Only fools go around saying things like "Only fools ___".

GolfScript, 48 46 characters
:b,1,{)2\?){{.2$&!{.2$|@@}*.+.4b?<}do;;}+%}@/,

The faster version (try online) - runs reasonable fast, e.g. n=8 takes about two seconds. And the chosen approach takes really few characters.
This version also works with bitmasks. It builts the possible result array from 1 upwards, i.e. for n=3:
1: 000011        000110 001100 011000 110000
2: 010111 101011 101110        011101 110101 111010

While some results (like 000011) have two possible continuations, others (i.e. 001100) have none and are removed from the result array.
Explanation of the code:
:b           # save the input into variable b for later use
,            # make the list 0..b-1 (the outer loop)
1,           # puts the list [0] on top of the stack - initially the only possible
             # combination
{)           # {...}@/ does the outer loop counting from i=1 to b
  2\?)       # computes the smalles possible bit mask m=2^i+1 with two bits set
             # and distance of those equal to i (i.e. i=1: 11, i=2: 101, ...)
  {          # the next loop starts with this bitmask (prepended to code via
             # concatination {...}+
             # the loop itself iterates the top of the stack, i.e. at this point
             # the result array
             # stack here contains item of result array (e.g. 00000011)
             # and bitmask (e.g. 00000101)
    {        # the inner-most loop tries all masks with the current item in the result set
      .2$&!  # do item and result set share not single bit? then - {...}*
      {
        .2$| # then generate the new entry by or-ing those two
        @@   # push it down on the stack (i.e. put working items to top)
      }*
      .+     # shift the bit mask left by one
      .4b?<  # if still in the range loop further
    }do;;    # removes the remainders of the loop (i.e. item processed and mask)
  }+%        # stack now contains the new result array
}@/
,            # length of result array, i.e. the number of Skolem sequences

Accepting the faster of tied solutions.

GolfScript (46 chars)
:&1,\,{0,2@)?)2&*{2${1$^}%@+\2*}*;+}/{4&?(=},,

This is an expression which takes input on the stack. To turn it into a full program which takes input on stdin, prepend ~
It is fairly inefficient - most of the savings I made in golfing it down from 56 chars ungolfed were by expanding the range of loops in ways which don't introduce incorrect results but do waste calculation.
The approach is bitwise masking of Cartesian products. E.g. (using binary for the masks) for n=4 the ungolfed code would compute the xor of each element in the Cartesian product [00000011 00000110 ... 11000000] x [00000101 00001010 ... 10100000] x ... x [00010001 ... 10001000]. Any result with 8 bits could only be achieved by non-overlapping masks.
In order to optimise for size rather than speed, the code accumulates partial products (S1 u S1xS2 u S1xS2xS3 ...) and makes each product be of 2n elements rather than just the 2n-1-i which can actually contribute to a valid sequence.
Speed
The golfed version runs for n=5 in 10 seconds on my computer, and more than 5 minutes for n=6. The original ungolfed version computes n=5 in less than a second, and n=6 in about 1 minute. With a simple filter on intermediate results, it can compute n=8 in 30 seconds. I've golfed it to 66 chars (as a program - 65 chars as an expression) while keeping the loops as restricted as possible and filtering intermediate collisions:
~:&1,\,{0,\).2\?)2&*@-{.{[\].~^.@~+<{;}*}+3$%@+\2*}*;\;}/{4&?(=},,

Damn. Just when I've thought my 48char J solution was good enough to be posted.

Damn. Our 47-character tie didn't last very long. +1

J expression, 47 characters
 +/*/"1((=&{:+.2-#@])#;.2)\"1~.(i.!+:y)A.,~>:i.y

Example:
    y=:5
    +/*/"1((=&{:+.2-#@])#;.2)\"1~.(i.!+:y)A.,~>:i.y
10

Takes about 30 seconds for y=:5 on my machine.
the algorithm is as slow as can be:

~.(i.!+:y)A.,~>:i.y generates every permutation of 1 2 .. y 1 2 .. y and removes duplicate entries
((=&{:+.2-#@])#;.2)\"1 computes:

(...)\"1 for every prefix of every row:

#;.2 counts the the elements before each occurence of the last element
#@] counts the number of counts (i.e. the number of occurences of the last element)
=&{: determines the "equality" "of" "last element"s of the count list and of the original list.
+. is a logical OR. =&{:+.2-#@] reads "either the last elements [of the count list and the original list] are equal, or there is only one element [in the count list] rather than two".

*/"1 multiplies (logical AND) over the rows of the condition table, determining which permutations are Skolem sequences.
+/ sums the ones and zeroes together.

GolfScript, 49 characters
~:/..+?:d(,{d+/base(;:w;/,{.w?)w>1$?=},,/=},,/1=+

Expects the number n on STDIN. This is code-golf - don't try the code with n greater than 5.

Ouch, no greater than 5?

@boothby It was the first, direct attempt. We often have to take the decision speed vs. size - and code-golf is about size. That's why I also added the fast version - which originally was much longer but now is even shorter.

Husk, 20 19 bytes
₁ḣ
ṁo=¹⁰(moF-¥)uPṘ2

Try it online!
Can be shortened further.
returns 1 for 0.
-1 byte from Jo king.
Explanation
ṁo=ḣ¹`(moF-¥)ḣ¹uPṘ2ḣ
                   ḣ range from 1..n
                 Ṙ2  replicate each element 2 times
               uP    unique permutations of the list
ṁo                   map each permutation to the following two functions
                     and sum the results
     `               flip: f x y = f y x
      (mo   )        map each number to the following:
      (    ¥)ḣ¹      index of each number in 1..n in the permutation
      (  F- )        folded by subtraction
  =ḣ¹                are the differences equal to 1..n?

Sage, 70
This is a little shorter than my original.
sum(1for i in DLXCPP([(i-1,j,i+j)for i in[1..n]for j in[n..3*n-i-1]]))

How it works:
Given a 0/1 matrix, the exact cover problem for that matrix is to find a subset of the rows that sum (as integers) to the all-ones vector.  For example,
11001
10100
01001
00011
00010

has a solution
10100
01001
00010

My favorite approach to problems is to cast them to an exact cover problem.  Skolem sequences efficiently facilitate this.  I make an exact cover problem where solutions are in bijection with Skolem sequences of length 2n.  For example, a row of the problem for n=6 is
  a   |  b
001000|001001000000 # S[b] = S[b+a+1] = a

where a 1 in position a < n means that symbol a is used.  The remaining positions correspond to actual locations in the sequence.  An exact cover corresponds to each symbol being used exactly once, and each location being filled exactly once.  By construction, any symbol k in a location is k spaces away from its partner.
In Sage, DLXCPP is a "dancing links" implementation -- it solves the exact cover problem in an exceptionally graceful manner.  It's one of my favorite algorithms ever, and being right at the surface in Sage makes combinatorial enumeration a joy.

Wow, dancing link. Use len(list(...)) will save 4 chars.

@Ray My computer would simply die if I computed len(list(...)) for n=16.  And it'd utterly kill the runtime.

That's right, because converting a generator into a list cost many memory.

05AB1E, 22 bytes
Ý¦©€DœʒU®εXQ0Úg<}®Q}Ùg

Results in \$0\$ for \$n=0\$.
Try it online or verify the test cases in the range \$[0,4]\$. (Unfortunately times out for \$n\geq5\$.)
Explanation:
Ý                 # Push a list in the range [0, (implicit) input `n`]
 ¦                # Remove the leading 0
                  # (builtin `L` would become list [1,0] for n=0 unfortunately,
                  # resulting in an incorrect result of 3 at the end)
  ©               # Store this list in variable `®` (without popping)
   €D             # Duplicate each, resulting in a flattened list [1,1,2,2,3,3,...,n,n]
     œ            # Get all permutations of this list
      ʒ           # Filter it by:
       U          #  Pop and store the current permutation in variable `X`
        ®         #  Push the ranged list [1,n] from variable `®`
         ε        #  Map it to:
          X       #   Check for each value in list `X`
           Q      #   whether it's equal to the current map value
                  #   (1 if truthy; 0 if falsey)
            0Ú    #   Remove all leading and trailing 0s
              g   #   Pop and get the length of the list
               <  #   Decrease it by 1
         }®Q      #  After the map: check if it's equal to the [1,n] ranged list
      }Ù          # After the filter: uniquify the remaining permutations
        g         # And pop and push the length
                  # (after which this is output implicitly as result)


text:
Generate numerical permutations with conditions and template metaprogramming
This, but via template metaprogramming:
template <int n> struct insanity { int[][n] permutations; }

Generate all numbers with n digits (0-9) such that each digit is either:

Zero
The first digit
Already present
Greater than the maximum digit to the left

Don't worry about leading zeros either way.
Valid examples:
012333
012391

Invalid examples:
012945

(Is this even possible?)
Winning code will be explainable and concise, but I'll take a clear short answer over the shortest.
Clarification on conditions: Shortest code with a complete explanation for what's going on. "Complete" means: Explain it to someone who knows how templates work, but not how TMP works.

What is the objective winning criteria? Do you have a solution?

I do not have a solution. Let me clarify my criteria.

There are a number of things which aren't clear to me. What is a digit (i.e. are you assuming base 10)? What is the purpose of case 4? Why does the title talk about permutations?

Success!!!! It only took me 3 hours or so. (Note: Requires C++11 support)
4,410 characters (including output functions)
Compiled on GCC 4.7.2 (Ideone)
#include<iostream>
#include<type_traits>

int constexpr powOf10(size_t power)
{
    return power == 0 ? 1 : 10 * powOf10(power - 1);
}

template<int... digits>
struct buildNumber;

template<int first, int... digits>
struct buildNumber<first, digits...> : std::integral_constant<int, first * powOf10(sizeof...(digits)) + buildNumber<digits...>::value>
{
};

template<>
struct buildNumber<> : std::integral_constant<int, 0>
{
};

template<int... digits>
struct areAllDigits;

template<int first, int... digits>
struct areAllDigits<first, digits...>
{
    static bool constexpr value = first > 0 && first < 10 && areAllDigits<digits...>::value;
};

template<int first>
struct areAllDigits<first>
{
    static bool constexpr value = first>0 && first < 10;
};

template<class T>
struct buildNumberT;

template<int... digits>
struct digitContainer
{

};

template<int... digits>
struct buildNumberT<digitContainer<digits...>> : buildNumber<digits...> {};

template<class T1, class T2>
struct concatCtr;

template<int... digits1, int... digits2>
struct concatCtr<digitContainer<digits1...>, digitContainer<digits2...>>
{
    typedef  digitContainer<digits1..., digits2...> type;
};

template<int number, size_t digit>
struct breakIntoDigits
{
    typedef typename concatCtr<digitContainer<number / powOf10(digit)>, typename breakIntoDigits<number % powOf10(digit), digit - 1>::ctr>::type ctr;
};

template<int number>
struct breakIntoDigits<number, 0>
{
    typedef digitContainer<number> ctr;
};

template<int needle, int... haystack>
struct contains;

template<int needle, int first, int... haystack>
struct contains<needle, first, haystack...>
{
    static bool constexpr value = needle == first || contains<needle, haystack...>::value;
};

template<int needle>
struct contains<needle>
{
    static constexpr bool value = false;
};

template<int... values>
struct max;

template<int first, int... rest>
struct max<first, rest...>
{
    static constexpr int value = first > max<rest...>::value ? first : max<rest...>::value;
};

template<>
struct max<>
{
    static int constexpr value = 0;
};

template<class container, int... digits>
struct ruleChecker;

template<int current, int... allPrevious, int... rest>
struct ruleChecker<digitContainer<allPrevious...>, current, rest...>
{
    static bool constexpr value = (current == 0 || sizeof...(allPrevious) == 0 || contains<current, allPrevious...>::value || current > max<allPrevious...>::value) && ruleChecker<digitContainer<allPrevious..., current>, rest...>::value;
};

template<class container>
struct ruleChecker<container>
{
    static bool constexpr value = true;
};

template<class ctr1, class ctr2>
struct ruleCheckerT;

template<class ctr1, int... set2>
struct ruleCheckerT<ctr1, digitContainer<set2...>> : ruleChecker<ctr1, set2...>{};

template<int number, int length>
struct isValidNumber : ruleCheckerT<digitContainer<>, typename breakIntoDigits<number, length>::ctr>
{
};

template<int number, int length>
struct generateList
{
    typedef typename std::conditional<number % powOf10(length) == 0,
        digitContainer<>,
        typename concatCtr<
            typename generateList<number + 1, length>::container,
            typename std::conditional<isValidNumber<number, length>::value,
                    digitContainer<number>,
                    digitContainer<>
                >::type
            >::type
        >::type container;
};

template<int number>
struct generateList<number, 1>
{
    typedef typename concatCtr<
        typename generateList<number + 1, 1>::container,
        typename std::conditional<isValidNumber<number, 1>::value,
                digitContainer<number>,
                digitContainer<>
            >::type
        >::type container;
};

#define DEFINE_ENDPOINT_FOR_LENGTH(length) template<> struct generateList<powOf10(length), (length)>{typedef digitContainer<> container;}

template<int length>
struct insanity
{
    static_assert(length > 0, "Length must be greater than 0.");
    typedef typename concatCtr<typename generateList<1, length>::container, digitContainer<0>>::type numberList;
};

template<int first, int... rest>
void outputContainer(digitContainer<first, rest...> values)
{
    std::cout<<first<<'\n';
    outputContainer(digitContainer<rest...>{});
}

void outputContainer(digitContainer<> empty)
{
    std::flush(std::cout);
}

Explanation
insanity is the entry point, as used in the OP.  buildNumber builds a number from a list of digits; breakIntoDigits does the opposite; it takes a number and breaks it into length digits.  areAllDigits is just a helper I used earlier.  It isn't used in the final code.  It's value property is true if all the numbers passed to it are base-10 digits.  It generates a list of valid numbers (validated by isValidNumber) and puts them in a digitContainer (originally I was only going to use this for digits, but I decided to use it for both things).
Limitations

It can only calculate up to the point the compiler errors out from template recursion depth.
You need to define an ending point for each length because otherwise it keeps instantiating templates up to the limit because of std::conditional. You define an ending point for each length by typing DEFINE_ENDPOINT_FOR_LENGTH(i) where i is the length.

I'm really impressed. I'm slowly getting the time to understand this, but either way, I'll give you the answer in a day or two since you satisfy the criteria.


text:
Generate a pronounceable word
The challenge is simple:
generate a word.
Specifications:

Word must be pronounceable.

This is defined as "alternating between a consonant and a vowel."
A consonant is one of the following letters: bcdfghjklmnpqrstvwxz
A vowel is one of the following letters: aeiouy

Word must be randomly generated.
Words must be able to contain every consonant and vowel. (You can't just use bcdf for consonants and aei for vowels.)
Word must contain 10 letters.
Shortest code (in character count) wins.

http://codegolf.stackexchange.com/questions/11215/alien-name-generator

@JanDvorak Okay... what does that have to do with this?

With this xkcd strip in mind, the program echo buxitiwymu technically conforms to the specification. I assure you, I generated the word randomly:P

@AardvarkSoup "Words must be able to contain every consonant and vowel"

y is a vowel !?

Would something like this be allowed ? alert('abecidof'+'uy'[Math.round(Math.random())]+'ghijklmnpqrstvwxz'[Math.round(Math.random()*19)]);

@Kartik depends on the context, in 'yes' it's a consonant, in 'why' it's a vowel, but this would make it impossible to define a pronounceable word as alternating between vowels and consonants, eg. yyyyyyyy would be a valid word.

@Ragnagord No, it won't. But, yyyyyyyyyy would.

I actually made a generator on Scratch a while back. It had specific rules for when you can treat y as a vowel, where you can use q and x, and when you can use two-letter combinations like ng or ea

Similar to https://codegolf.stackexchange.com/questions/199139/write-some-random-english

GolfScript, 32 characters
['aeiouy'.123,97>^]5*{.,rand=}%+

Run it online.

COBOL, 255
So I'm learning COBOL at the moment. Used this question as some practice. Tried to golf it.
It's 255 without the leading whitespace, and 286 bytes with.
For what it's worth, this runs in Microfocus COBOL for VS2012, and I have no idea if it will run anywhere else.
       1 l pic 99 1 s pic x(26) value'aeiouybcdfghjklmnpqrstvwxz' 1 r
       pic 99 1 v pic 9 1 q pic 99. accept q perform test after varying
       l from 1 by 1 until l>9 compute v=function mod(l,2) compute r=1+
       function random(q*l)*5+v*15+v*5 display s(r:1)end-perform exit

Python, 81
from random import*
print''.join(map(choice,["bcdfghjklmnpqrstvwxz","aeiouy"]*5))

Good luck pronouncing them.

They're actually quite easy to pronounce, for example the first word I got was "viketuziwo" :P

@Doorknob maybe it's just my luck. I keep getting 'words' like "qijepyjyga". My computer's attempts to pronounce them make up for it though :)

I just had a lot of fun doing python grc.py | say on my machine. Thanks for the idea.

Ruby: 56 characters
([v=%w(a e i o u y),[*?a..?z]-v]*5).map{|a|$><<a.sample}

Example outputs:

itopytojog
umapujojim
ipagodusas
yfoqinifyw
ebylipodiz

'aeiouy'.chars would be one char shorter.

@Howard then the subtraction operator raises TypeError: can't convert Enumerator into Array

@JanDvorak Sorry, forgot to mention that you need Ruby 2.0 for this trick.

APL (34)
,⍉↑(V[5?6])((⎕A~V←'AEIOUY')[5?20])

JavaScript, 74
for(a=b=[];a++-5;)b+="bcdfghjklmnpqrstvwxz"[c=new Date*a%20]+"aeiouy"[c%6]

Does not generate all combinations, but I think that all consonants and vowel appear.
JavaScript, 79
for(a=b=[];a--+5;)b+="bcdfghjklmnpqrstvwxz"[c=Math.random()*20^0]+"aeiouy"[c%6]

More "random" version.

What's the ^0 for?

@Alpha Math.random gives a float, we need an integer. ^0 truncates the number

Clever trick. I haven't seen the ^ operator in JavaScript before and less heard about using it to truncate a float. Thanks!

@copy i like the use of ^

Ruby: 70 66 characters
10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}

Sample run:
bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
izogoreroz

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
onewijolen

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
amilyfilil

You can use 10.times for one char less.

Also the question doesn't require that each letter must have same probability. *10->*4, skip *3, rand 60->rand 20 and you have saved 3 chars.

Good catch on the rule, @Howard. Thank you.

Processing, 100 99 93 87
int i=10;while(i-->0)"aeiouybcdfghjklmnpqrstvwxz".charAt((int)random(i%2*6,6+i%2*i*2));

Upon closer inspection of the question, I see it doesn't require any output. I've adjusted this accordingly.

R: 105 characters
a=c(1,5,9,15,21,25)
l=letters
s=sample
cat(apply(cbind(s(l[-a],5),s(l[a],5)),1,paste,collapse=""),sep="")

J (51)
,|:>(<"1[5?6 20){&.>'aeiouy';'bcdfghjklmnpqrstvwxz'

Unix tools: 73 bytes
And not guaranteed running time :)
</dev/urandom grep -ao '[aeiouy][bcdfghjklmnpqrstvwxz]'|head -5|paste -sd ''

Only problem is that the generated string will start with a "vowel" every time.
(edit: changed  ' ' to '' in the args of paste)
(another edit: removed -P from grep options, thanks to manatwork)

Something could be fine tuned around the grep parameters. I got “of e� ap ag ak”.

Hmm... strange. I got nothing like that. I thought -a would be enough.

My test indicates that -P is the one. Seems the man warns about its highly experimental status with a reason. (grep 2.16) But anyway, it works fine without -P.

You are right thank you, I didn't consider that. I don't even know why I used -P in the first place. I'll edit my answer.

By the way, tr -d \\n is shorter for joining the lines.

yes, but it also removes the last '\n' messing up bash prompt :)

Doh. Indeed. And the “grep: write error” gets concatenated with the output. :(

66 bytes with a few optimisations (and a lot faster)

PHP 79 bytes
<?for($c=bcdfghjklmnpqrstvwxz,$v=aeiouy;5>$i++;)echo$c[rand()%20],$v[rand()%6];

Fairly concise.

Javascript, 85
for(r=Math.random,s="",i=5;i--;)s+="bcdfghjklmnpqrstvwxz"[20*r()|0]+"aeiouy"[6*r()|0]

If run from the console, output is shown. Explicit display would add alert(s) at 8 chars, still shorter than the other JS solutions.
Thanks C5H8NNaO4 and Howard!

Nice one, save a character by removing the last ';'

Instead of ~~(###) you can write ###|0 which saves 4 chars.

Java AKA the most verbose language ever created, 176
with help of Doorknob, Daniero and Peter Taylor (thanks guys!)
class w{public static void main(String[]a){int i=11;while(--i>0)System.out.print((i%2==0?"aeiouy":"bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6+(i%2)*14)));}}

Ungolfed:
    class w {

        public static void main(String[] a) {
            int i = 11;
            while (--i > 0) {
                System.out.print((i % 2 == 0 ? "aeiouy" : "bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6 + (i % 2) * 14)));
            }
     }

}

Suggested improvements: Change String a[] to String[]a (-1 characters), change w W = new w(); to w W=new w(); (-2 characters)

Suggestions: Let the word always start on a consonant (or wovel); no need to randomize this when the question doesn't mention it! So, skip the boolean f and use i%2 instead. Also, the for loop can be shortened, and you can put both the strings inside the conditional operator (also,no need for parens here), and use the charAt on the outside. Here's the whole thing, 195 CHARS, 38 SAVED: import java.util.*;class w{public static void main(String[]a){Random r=new Random();for(int i=0;++i<11;)System.out.print((i%2>0?"bcdfghjklmnpqrstvwxz":"aeiouy").charAt(r.nextInt(6+(i%2)*14)));}}

Continuing @Daniero's simplification: 1) do not declare a variable for Random; 2) remove the parenthesis from the formula. 183 characters: import java.util.*;class w{public static void main(String[]a){for(int i=0;++i<1100;)System.out.print((i%2>0?"bcdfghjklmnpqrstvwxz":"aeiouy").charAt(new Random().nextInt(6+i%2*14)));}}.

“Java AKA the most verbose language ever created” – Ever tried Shakespeare? ;-)

@manatwork, don't forget to remove the import once you've got it down to being used only in one place.

Possibly controversial suggestion: One could squeeze a few more characters out of it by insisting that the program has to be run with two command line arguments (that should be counted in the character total of course), namely aeiouy and bcdfghjklmnpqrstvwxz. This minimizes the overhead of the strings as you don't need the "'s anymore, and you can access them with a[i%2] (a is already defined in the boilerplate code). 142+20(?) chars: class w{public static void main(String[]a){int i=11;while(--i>0)System.out.print(a[i%2].charAt(new java.util.Random().nextInt(6+(i%2)*14)));}}

@Daniero, why only +20? Shouldn't that be +6+20? And no idea why you (and anakata) insist on the parenthesis around i%2. Its priority is higher than the preceding addition's anyway. http://pastebin.com/5reTnRDL

@manatwork, 26 yes off course, I did this very rapidly, just vaguely remembered that some string in there was 20 chars long (my native language's alphabet is longer than the English one, so 26 doesn't mean that much to me) ;) The parenthesis can obviously go, nice. The first time I used the expression 14*(i%2), in which the parens must stay, didn't think off switching 14 to the back. Last time I just copied the whole thing from anakata's answer to show the a[i%2] trick, didn't think about the parenthesis any longer.

@manatwork maybe we like lisp ?? ok, sorry, gonna take those parenthesis out when I get home from work

I know it's been 6 years (lol), but you can golf it to 163 bytes by changing int i=11;while(--i>0) to for(int i=11;--i>0;); i%2==0 to i%2<1 and new java.util.Random().nextInt(6+(i%2)*14) to (int)(Math.random()*(6+i%2*14)). EDIT: Actually, 160 bytes like this: class W{public static void main(String[]a){for(int i=11,t;--i>0;System.out.print((i%2<1?"aeiouy":"bcdfghjklmnpqrstvwxz").charAt(t*=Math.random())))t=6+i%2*14;}}, or an additional -3 with Java 8+ changing class W{public static void main to interface W{static void main. Try it online.

Objective-C, 129
main(){int i=10;while(i-->0)printf("%c",[(i%2==0)?@"aeiouy":@"bcdfghjklmnpqrstvwxz"characterAtIndex:arc4random()%(6+(i%2)*14)]);}

With the help of Daniero
(I love to use the tends to operator (-->)

PHP, 100 Characters
<?while($i<6){echo substr('bcdfghjklmnpqrstvwxz',rand(0,20),1).substr('aeiouy',rand(0,5),1);$i++;}?>

acually I think that's 100 chars long

APL  30 26
,('EIOUY'∪⎕A)[6(|,+)⍪5?20]

Explanation is very similar to the past version below, just reordered a bit to golf the solution.
Note: ⎕IO is set to 0

('EIOUY'∪⎕A)[,6(|,(⍪+))5?20]

Explanation:
'EIOUY'∪⎕A    puts vowels in front of all letters.
5?20            for the indexes we start choosing 5 random numbers between 0 and 19
6(|,(⍪+))        then we sum 6 and the random numbers, convert to 5x1 matrix (⍪), add a column before this one containing 6 modulo the random numbers.
                [[[ this one can be rewritten as: (6|n) , ⍪(6+n)  for easier understanding]]]
,6(|,(⍪+))5?20  the leading comma just converts the matrix to a vector, mixing the vowel and consonants indexes.

Tryapl.org

('AEIOUY'∪⎕A) ≡ (∪'AEIOUY',⎕A) but it's one byte shorter.

Deferring 'A' to ⎕A saves another byte: ,('EIOUY'∪⎕A)[6(|,+)⍪5?20]

Nice! down to 26. Thanks

Pyth, 26 characters
J-G"aeiouy"VT=k+kOJ=J-GJ;k

You can try it in the online compiler here.
Someone posted a very similar challenge but it was closed after I had made a solution. I didn't realize it, but this question actually predates the creation of Pyth. Anyway, here is the breakdown:
J                             Set string J equal to:
  G                            the entire alphabet (lowercase, in order)
 - "aeiouy"                    minus the vowels
           VT                 For n in range(1, 10):
             =k                   Set string k to:
                k                  k (defaults to empty string)
               + OJ                plus a random character from J
                   =J             Set J to:
                      G            the entire alphabet
                     - J           minus J
                        ;     End of loop
                         k    print k

Every time the loop is run, J switches from being a list of consonants to a list of vowels. That way we can just pick a random letter from J each time.
There may be a way to initialize J in the loop or remove the explicit assignments from the loop, but I have not had success with either yet.

Bumping old questions is generally considered fine. However, when you use a language newer than the question (I created Pyth in 2014) you should note this in your answer.

Thanks for clearing that up for me. I didn't realize that Pyth was created after this question and I've added that to the answer.

K, 40 bytes
,/+5?/:("bcdfghjklmnpqrstvwxz";"aeiouy")

5?"abc" will generate 5 random letters from the given string.
5?/: will generate 5 random letters from each of the strings on the right, producing two lists.
+ transposes those two lists, giving us a list of tuples with one random character from the first list and then one from the second list.
,/ is "raze"- fuse together all those tuples in sequence.
K5 can do this in 33 bytes by building the alphabet more cleverly and then using "except" (^) to remove the vowels, but K5 is much too new to be legal in this question:
,/+5?/:((`c$97+!26)^v;v:"aeiouy")

Javascript, 104 87
a="";for(e=10;e--;)a+=(b=e&1?"bcdfghjklmnpqrstvwxz":"aeiouy")[0|Math.random()*b.length]

golfed a whole lot of simple unnecessary stuff, still not nearly as nice as copys' one
Oh, and that one just opped up during golfing: "dydudelidu"
Now I tried one using the 2 characters at once approach. Turns out it's almost the same as copys' second one, so I can't count it, also at 79.
a="";for(e=5;e--;)a+="bcdfghjklmnpqrstvwxz"[m=0|20*Math.random()]+"aeiouy"[m%6]

C: 101
main(){int x=5;while(x-->0){putchar("bcdfghjklmnpqrstvwxyz"[rand()%21]);putchar("aeiou"[rand()%5]);}}

Brachylog, 9 bytes
Ḍ;Ẉṣᵐzh₅c

Try it online!
Gives output as a list of letters through the output variable.
   ṣ         Randomly shuffle
 ;  ᵐ        both
Ḍ            the consonants without y
  Ẉ          and the vowels with y,
     z       zip them into pairs,
      h₅     take the first five pairs,
             and output
        c    their concatenation.

"Random Word Generator", 70 +2 = 72 bytes
C=b c d f g h j k l m n p q r s t v w x z
V=a e i o u y
syllable:$C$V

Set minimum and maximum number of syllables settings to 5 (which I'm counting as flags, so 1 byte each).
This is written in a (WIP) tool I wrote for generating words from a sound inventory for conlanging (making constructed languages). I made the tool due to the other word generators (that I know of) having flaws (in my opinionated opinion).
The above code sets two categories C and V, and defines a syllable as a C followed by a V. The flags (minimum and maximum syllables) define how many syllables will be generated for a given word.
No changed settings, 86 bytes
C=b c d f g h j k l m n p q r s t v w x z
V=a e i o u y
syllable:$C$V$C$V$C$V$C$V$C$V

Due to a bug in my implementation, this solution is extremely slow due to the large syllable size.

F#, 166 characters
open System;String.Join("",(Random(),"aeiouybcdfghjklmnpqrstvwxz")|>(fun(r,s)->[0..5]|>List.collect(fun t->[s.Substring(6+r.Next()%20,1);s.Substring(r.Next()%6,1)])))

R, 83 bytes
cat(outer((l<-letters)[a<-c(1,5,9,15,21,25)],l[-a],paste0)[sample(1:120,5)],sep="")

Generate all possible vowel-consonant sequences in a matrix, then randomly sample 5 of them, yielding a 10-letter word.

05AB1E, 10 bytes
5FžPΩ?žOΩ?

Try it online or output \$n\$ amount of random words.
Explanation:
Pretty straight-forward:
5F      # Loop 5 times:
  žP    #  Push string "bcdfghjklmnpqrstvwxz"
    Ω   #  Pop and push a random character from this string
     ?  #  Output it without newline
  žOΩ?  #  Do the same with string "aeiouy"

K (ngn/k), 57 47 46 54 bytes
{`prng@0;,/{(1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"}'!5}

Try it online!
Down 1 byte thanks to ngn
Takes inspiration from the PHP answer. This one now outputs random words at each call, with the cost of 8 extra bytes.
Explanation:
{`prng@0;,/{(1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"}'!5} Main function. Takes no input
                                                   !5  Generate a array with range from 0 to 4 ([0..4])
                                                  '    For each number...
           {                                     }     Execute a function that...
            (1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"      Chooses one random consonant, followed by one random vowel
         ,/                                            Joined each of these strings together
 `prng@0;                                              Use current time to set state of randomness (Thus allow random words)

""/ -> ,/

Japt -P, 20 17 bytes
;`Á<`
5Æö iCkU ö

Test it
Note that there is an unprintable character in front of the Á
;          # C = "abcdefghijklmnopqrstuvwxyz"
 `ŒÁ<`     # U = "oueayi"

5Æ         # Do this 5 times:
  ö        #  Pick a random letter from U
    i      #  Prepend:
     CkU   #   Remove the letters in U from C
         ö #   Get a random letter from the result

-P         # Print all the pairs with no separator

19 bytes. And you can save another 2 bytes with the -P flag.

Japt -P, 14 bytes
;Cü_èyi%Ã®ö5ÃÕ

Test it
;Cü_èyi%Ã®ö5ÃÕ
;C                 :Lowercase alphabet
  ü                :Group by
   _               :Passing each character through the following function
    è              :  Count
     yi%           :    "y" prepended with "%", giving the Japt RegEx "%y"=/[aeiouy]/i
        Ã          :End grouping
         ®         :Map
          ö5       :  5 random characters
            Ã      :End map
             Õ     :Transpose
                   :Implicitly join & output

JavaScript (V8), 89 bytes
for(;a=Math.random().toString(36).match(/([bcdfghj-np-tvwxz][aeiouy]){5}/g),!a;);print(a)

Try it online!
/g makes the result without an extra appearance of pair

Thunno 2 J, 9 bytes
5ıkykz,€ɼ

Try it online!
Explanation
5ıkykz,€ɼ  # Implicit input
5ı         # Repeat 5 times:
  ky  , ɼ  #  Random vowel
    kz €ɼ  #  Random consonant
           # Join into a string
           # Implicit output

Vyxal s, 8 bytes
k¹k∪"5ƈ∩

Try it Online!
    "    # Pair
k¹       # Consonants
  k∪     # And vowels
     5ƈ  # Choose 5 random items from each
       ∩ # Interleave

Jelly, 13 bytes
Øy,ØYẊ€Zs5ḢŒl

Explanation:
Øy,ØYẊ€Zs5ḢŒl
Øy,ØY         Makes a list of two lists of characters: [[list-of-vowels-with-y], [list-of-consonants-without-y]]
     Ẋ€       Shuffle €ach.
       Z      Zip those two lists together. [[random-vowel, random-consonant],...]
        s5    Split them into chunks of five (because each pair contains two letters, this splits them into chunks of 10 letters)
          Ḣ   Take the list of 5 pairs.
           Œl Make each of the characters in it lowercase
              Implicit concatenation and print.

Try it online!

C (gcc), 63 bytes
c;f(n){for(n=10;n;81192%c-n&1||putchar(c,n--))c=97+clock()%26;}

Try it online!

Zsh --braceccl, 57 bytes
Try it Online!
shuf -n5 <(echo {bcdfghj-np-tvwxz}{aeiouy}|rs 0 1)|rs -g0

Alternates: 67b using jot ;
77b using arrays