text:
Element names above 118
IUPAC in their insufferable wisdom have created a systematic element name for any newly created element. This is the temporary name of an element until they finally make up their minds about an actual name. It works like so: each digit of an element number is assigned a prefix based on its value. The prefixes are concatenated with ‘ium’ at the end. When this is done and if you get double i’s (ii) or triple n’s (nnn), replace them with single i’s and double n’s. The symbol for the element is the first letter of each prefix used concatenated and result capitalized. The prefixes used are below.
0 nil       5 pent
1 un        6 hex
2 bi        7 sept
3 tri       8 oct
4 quad      9 enn

So for this golf, your code needs to generate both the element name and its symbol for a given positive integer. So if your code was given 137, it should print to stdout or return both untriseptium and Uts. It should be valid from at least 118 to 558. Any higher is valid if it doesn't increase your code's length.
Python example showing the method:
def elename(n):
    '''Return name and symbol of new element for given element number.'''
    prefixes=['nil','un','bi','tri','quad','pent','hex','sept','oct','enn']
    nmeFixes, symFixes = [], []

    while n:  # each digit of element number is assigned a prefix
        n, i = divmod(n, 10)
        pf = prefixes[i]

        symFixes.append(pf[0])  # symbol uses only first letter of prefix
        nmeFixes.append(pf)

    # loop assembled prefixes in reverse order
    nmeFixes.reverse()
    symFixes.reverse()

    nmeFixes.append('ium')  # suffix
    name = ''.join(nmeFixes)
    symb = ''.join(symFixes).capitalize()

    # apply rule about too many n's or i's
    name = name.replace('nnn','nn')  # can happen with -90-
    name = name.replace('ii','i')  # -2ium or -3ium

    return name, symb

Eric Towers wins with cadmium bytes!

I'm going to start calling Boron by its IUPAC systematic element name: "Pentium"

@Michael Intel Boron Processor

Must we have the correct case?

@BetaDecay But does this "fifth element" support MultiPass?

Mathematica 10.1, indium (49) cadmium (48)
This solution uses a built-in library of element properties, including IUPAC names and abbreviations.  (I haven't seen this as a technique to be avoided in Golf.  It seems to be encouraged.  But this might be on (perhaps over) the edge of acceptable -- Mathematica implements this library (and many others) by downloading data from Wolfram's servers the first time you use it (and I presume checks for updates occasionally).)
f=ElementData@@@{{#,"Abbreviation"},{#,"Name"}}&
(*
Improved by @user5254 from
f[n_]:=ElementData[n,#]&/@{"Abbreviation","Name"}
*)

f[48]
(* {"Cd", "cadmium"} *)

f[118]
(* {"Uuo", "ununoctium"} *)

f[122]
(* {"Ubb", "unbibium"} *)

f[190]
(* {"Uen", "unennilium"} *)

f[558]
(* {"Ppo", "pentpentoctium"} *)

f[10^100-1]
(* {"Eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "ennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennium"} *)

How would this compare to using elements.py or periodictable.py in Python?
Edit:  Months later:  Noticed I had typo'ed the abbreviation output for 122.  I've re-run the code and verified that I made this error, not Mathematica.

When I was writing up the challenge, I thought "Should I prevent built in functions? Nah, its unlikely this is built-in to any language. Wait, Mathematica might have it." But I didn't know how to check that and then promptly forgot about it.

Holy parentheticals, Batman! That paragraph looks like something I could've written (I, too, am guilty of using parentheticals as asides in an attempt to mitigate my verbosity -- they usually become like this, though).

You can save one more byte by using inner apply and making f itself a pure function: f=ElementData@@@{{#,"Abbreviation"},{#,"Name"}}&.

Won't this code become invalid for 118 if the element in question gains an official name?

@ais523 : According to the specification "So for this golf, your code needs to generate both the element name and its symbol for a given positive integer."  If the element has a name or symbol, that name or symbol should be reported.  By your metric, then, every other submission on this page will fail to meet the specification if any element with atomic number >=118 gets a systematic symbol or name.

Python 3, Unhexseptium (167) bytes
h=x='';r=str.replace
for i in input():s=r('nubtqphsoeinirueeecnl  ianxptn    dt t'[int(i)::10],' ','');h+=s;x+=s[0]
print(r(r(h+'ium\n','ii','i'),'nnn','nn')+x.title())

These are the results when the program is run on every number from 1 to 999 (inclusive)

Your header now makes me want everyone list the number of bytes that way.

@Status Hear, hear. This is going to make those Pyth guys very sad... :)

@beaker I'm disappointed that your profile picture isn't Beaker ;)

@BetaDecay If only I could find an image that did his manly profile justice. I shall renew my search so as not to disconcert you further. ;)

@beaker Correct answer ;)

@BetaDecay Done.

@beaker I love you :D

@Status : if someone manages to do it in less than 112 bytes, they can have a classical element name in the title :) Like rutherfordium. Or gold.

@vsz Challenge accepted

How would this compare to using elements.py or periodictable.py in Python?

Pip, Thorium Actinium Radon (86)
(Don't inhale this entry, it'll give you lung cancer.)
P(aR,tY"nil un bi tri quad pent hex sept oct enn"^s)."ium"R`ii|nnn`_@>1Yy@_@0MaUC:y@0y

Takes the element number as a command-line argument and outputs the name & abbreviation on separate lines.
Explanation (somewhat ungolfed):
Y"nil un bi tri quad pent hex sept oct enn"^s  Build list of prefixes & store in y

    ,t                                         Range(10)
 (aR  y)                                       Replace each digit in input with
                                                 corresponding element in prefix list
        ."ium"                                 Append "ium"
              R`ii|nnn`_@>1                    Reduce too-long runs of letters
P                                              Print

 {y@a@0}Ma                                     For each digit in input, get first character
                                                 of corresponding prefix
Y                                              Store that list in y
          UC:y@0                               Uppercase the first item of y in place
                y                              Print y (items concatenated)

The ii and nnn handling uses a regex replacement with a callback function (added in the most recent version of Pip): for every match of ii|nnn, take all but the first character and use as a replacement.

Protip: While inhaling other entries may not give you lung cancer, they still probably aren't the best for your health.

GNU sed, 171 (unseptunium)
s/0/Nil/g
s/1/Un/g
s/2/Bi/g
s/3/Tri/g
s/4/Quad/g
s/5/Pent/g
s/6/Hex/g
s/7/Sept/g
s/8/Oct/g
s/9/Enn/g
s/$/ium/
h
s/[a-z]//g
G
s/./\L&/g
s/./\U&/
s/\n/ /
s/ii/i/g
s/nnn/nn/g

I assume it doesn't matter what order the name and symbol are returned in.  Here, symbol comes first:
$ seq 180 190 | sed -f iupac.sed
Uon unoctnilium
Uou unoctunium
Uob unoctbium
Uot unocttrium
Uoq unoctquadium
Uop unoctpentium
Uoh unocthexium
Uos unoctseptium
Uoo unoctoctium
Uoe unoctennium
Uen unennilium
$

I don't think the last two replaces need g; the only cases would be biium/triium and ennnil, all of which can only happen once in numbers under 1000.

JavaScript (ES6) 164 (unhexquadium) 171
The capitalization is the tricky part. (Test in FireFox)
Edit 3 bytes saved thx user2786485

f=n=>[([...n+(l='')].map(c=>(c='nil,un,bi,tri,quad,pent,hex,sept,oct,enn'.split`,`[c],n=l?n+c[0]:c[0].toUpperCase(),l+=c)),l+'ium').replace(/i(i)|n(nn)/g,'$1$2'),n]

function test() { O.innerHTML=f(+I.value) }

test()

for(o='',i=99;i++<999;)o+=i+' '+f(i)+'\n';P.innerHTML=o
<input id=I onchange="test()" value="164">

Returns *enium instead of *ennium for anything that's *9

Unhexhexium version:
n=>[([...n].map(c=>(c='nil,un,bi,tri,quad,pent,hex,sept,oct,enn'.split`,`[c],i=c[0],s=s?s+i:i.toUpperCase(),c),s='').join``+'ium').replace(/ii|nnn/g,r=>r.slice(1)),s]

@molarmanful [...n] will fail for an int parameter. The challenge is about a given positive integer

You can get unhexoctium if you replace your 'replacecall toreplace(/i(i)|n(nn)/g,'$1$2')`

@user2786485 thx I thought about using captures but did not find the right way

Mathematica, unhexunium 163 161 bytes
now capitalises symbol
This is Mathematica without the built-in ElementData.
f=StringReplace[##<>"ium, "<>{ToUpperCase@#1,##2}~StringTake~1&@@ToString/@nil[un,bi,tri,quad,pent,hex,sept,oct,enn][[IntegerDigits@#]],{"ii"->"i","nnn"->"nn"}]&

Test on 10 random numbers:
# -> f[#]& /@ RandomInteger[{118, 558}, 10] // ColumnForm

155->unpentpentium, Upp
338->tritrioctium, Tto
477->quadseptseptium, Qss
261->bihexunium, Bhu
158->unpentoctium, Upo
164->unhexquadium, Uhq
266->bihexhexium, Bhh
331->tritriunium, Ttu
404->quadnilquadium, Qnq
389->trioctennium, Toe

Ruby - 163 156 147 143 134 (Untriquadium) bytes
o=u='';gets.bytes{|c|k=%w[Nil un bI trI quad pent hex sept oct enN Ium][c%48];o+=k;u+=k[0]};puts o.tr_s('IN','in'),u[0..-2].capitalize

I'm hoping to golf this way down
Edit: Thanks for @steveverrill for shaving off 9 bytes!
Edit2: Thanks for @steveverrill again for another 4 bytes! (Really clever solution!)

Instead of each_char you can use chars. According to official Ruby documentation this is "deprecated" (but not in codegolf!) You'd probably do better with each_byte or bytes then c.to_i becomes for example i%48 . 2. Also by chance \n has ascii code 10, so maybe you can get rid of the chop and  include ium in your  array (works great for the element name, but adds a spurious i to the element symbol .)

You can save another 5 bytes with tr_s like this: o=u='';gets.bytes{|c|k=%w[Nil un bI trI quad pent hex sept oct enN Ium][c%48];o+=k;u+=k[0]};puts o.tr_s('IN','in'),u[0..-2].downcase.capitalize

u.chop is shorter than u[0..-2]. Maybe I should have posted my own answer, but my initial idea was to do it exactly like you did it. Its been fun helping you golf this though. I completely missed that you don't need downcase before capitalize.

CJam, 74 72 71 70 69 bytes (Thulium)
r:i"Ø¾aÈÁaÎE<Ä+&:¬úD±"380b24b'af+)/f=_:c(euoS@s'n3*/"nn"*)"ium"|

Note that the code contains unprintable characters.
Thanks to @Sp3000 for pointing out an error in my initial revision and suggesting the )/ approach.
Try it online in the CJam interpreter:.
How it works
r:i     e# Read a token and push the array of its character codes.
"…"     e# Push a string of unprintable characters.
380b24b e# Convert it from base 380 to base 24.
'af+    e# Add the character 'a' to each base-24 digit.
        e# This pushes "bijtrijquadjpentjhexjseptjoctjennjniljunj".
)/      e# Pop the last character and split the string at the remaining occurrences.
f=      e# For each character code in the input, select the correspoding chunk.
_:c     e# Push a copy and cast each string to character.
(euo    e# Shift out the first character, convert to uppercase, and print.
S@      e# Push a space and rotate the array of string on top of it.
s       e# Flatten the array of string.
'n3*/   e# Split at occurrences of "nnn".
"nn"*   e# Join, using "nn" as separator.
)"ium"| e# Pop the last character and perform setwise union with "ium".
        e# If the last character is, e.g., 't', this pushes "tium".
        e# If the last character is 'i', this pushes "ium".

Fun fact: Tungsten is often used in counterfeit gold bars and coins, due to its extreme density comparable to gold's and its relative cheapness.

Lutetium is an absurdly cool name for an element.

@ThalesPereira Even cooler than Ytterbium though?

Fun fact: Erbium, terbium, yttrium, and ytterbium are all named after the same place.

Pyth, 67 bytes (Holmium)
rshMJ@Lcs@LGjC"]ß!âÿeóÑiSÑA¼R¬HE"24\fjQT3-"ium"epj"nn"csJ*\n3

Try it online in the Pyth Compiler/Executor.
How it works
            jC"…"24       Convert the string from base 256 to base 24.
        s@LG              Select the letter that corresponds to each digit.
       c           \f     Split at 'f'.
     @L              jQT  Select the chunk that corresponds to each input digit.
    J                     Save in J.
 shM                      Form a string of the first letters of the chunks.
r                       3 Capitalize the first character.
                          Print. (implicit)

             csJ*\n3      Split the flattened J at "nnn".
        j"nn"             Join, separating by "nn".
       p                  Print.
-"ium"e                   Remove the last character ('i'?) from "ium".
                          Print. (implicit)

JavaScript (ES6), 210 202 Bytes (Biunnilium Binilbium)
Minus octium (8) bytes, thanks to @edc65!
130 159 147 Bytes (Untrinilium Unpentennium Unquadseptium)
f=z=>(c=(b=(z+"").split``.map(x=>"nil.un.bi.tri.quad.pent.hex.sept.oct.enn".split`.`[+x])).join``.replace(/nnn/g,"n"))+(c[c.length-1]!="i"?"i":"")+"um,"+(a=b.map(x=>x[0])).shift().toUpperCase()+a.join``

Input like f(324). Ugh, I felt so golf-y.

@edc65 Fixed all three problems.

Fine. Now, using template strings you can avoid some brackets and save maybe 8 bytes http://codegolf.stackexchange.com/a/52204/21348

TI-BASIC, 223 218 bytes
Input N
"nil un  bi  tri quadpenthex septoct enn→Str4
"int(10fPart(N/10^(X→Y₁
"sub(Str4,1+4Y₁,int(3fPart(e^(Y₁)1.5154)+2^not(X=2 and .9=fPart(N%) or X=1 and 1=int(5fPart(.1N→Y₂
"ium,"+sub("UBTQP",int(N%),1
For(X,1,3
Y₂+Ans+sub(Y₂(3-X),1,1
End
sub(Ans,1,length(Ans)-1

Element number N can only have a triple "n" if it ends in 90, and can only have a double-"i" if the last digit is 2 or 3. We use math to check those cases.
The magic number 1.5154, which stores the length of each prefix, was found using a Python script to search all decimals of length ≤7 using the functions cosh(, cos(, and e^(.
Not done golfing yet, but TI-BASIC's two-byte lowercase letters and lack of string manipulation commands, as always, will hurt this program's score.

I'll work on golfing it down. ^_^ I'll let you know what I come up with.

I don't think it's possible for anyone to get this down to 118 or less, but if someone manages, I'll give 500 rep.

Two questions: What is N% and what are "" and ""?

@CᴏɴᴏʀO'Bʀɪᴇɴ Sorry, % is a two-byte token that you can't type into your calculator. Use Cemetech's SourceCoder or TI's tools to edit it into the source, or use the file I provided.

@CᴏɴᴏʀO'Bʀɪᴇɴ  is the subscript 10; I've replaced it with a regular 10.

Matlab, 170 (Unseptnilium)
Works on all inputs you can throw at it, from nilium up to, well as far as you care to go. I got to ennennennennennennennennennennennennennennennennennennennennennennium before I gave up with pressing the 9 key.
l=['nubtqphsoe';'inirueeecn';'l  ianxptn';'    dt t  '];i=input('','s')-47;s=l(1,i);s(1)=s(1)-32;a=l(:,i);disp([strrep(strrep([a(a>32)' 'ium '],'nnn','nn'),'ii','i') s]);

And an explanation:
%Create a 2D array of the prefixes transposed
l=['nubtqphsoe';'inirueeecn';'l  ianxptn';'    dt t  '];
%Grab the input number
i=input('','s')     %Request the input and convert to string
               -47; %Convert from ASCII into an array of indecies (1 indexed)
%Generate the short form
s=l(1,i);
%Capitalise first letter in short form
s(1)=s(1)-32;
%Extract required prefixes for long form
a=l(:,i);
%Now the fun bit:
                     a(a>32)'                                    %Combine the prefixes removing spaces and transpose into a string
                    [         'ium ']                            %Append 'ium ' to the string (the space is to separate the short form)
             strrep(                 ,'nnn','nn')                %Replace 'nnn' with 'nn'
      strrep(                                    ,'ii','i')      %Replace 'ii' with 'i'
disp([                                                     s]); %And display both full and short form strings together

CJam, 95 bytes
liAbA,"nil un bi tri quad pent hex sept oct enn"S/er_:c(eu\+_1>"en"={\W"il"t\}&S@:+)_'i=!*"ium"

Try it online
This competes in the category "languages without regex, and only using printable characters." ;) Didn't really expect it to be as short as some of the already posted solutions, but I was curious how long it would end up anyway. And since I got it now, I might as well post it.
Explanation:
li      Get input and convert to int.
Ab      Encode in decimal.
A,      Build list [0 .. 9].
"..."   String with prefixes.
S/      Split at spaces.
er      Transliterate. We now have a list of the prefix for each digit.
_:c     Copy and take first character of each, for short form.
(       Pop off first character.
eu      Convert it to upper case.
\+      Put it back in place. Done with short form.
_1>     Remove first character.
"en"=   Compare with "en", corresponding to the 90 special case.
{       Handle 90 case, replace
  \       Swap full prefix list to top.
  W"il"t  Replace "nil" by "il" to avoid "nnn".
  \       Swap short form back to top.
}&      End of 90 case.
S       Push space between short form and full name.
@       Swap prefix list to top.
:+      Concatenate all the prefixes.
)       Pop off the last letter.
_'i=    Compare it with 'i.
!*      Multiply letter with comparison result. This gets rid of letter if it's 'i.
"ium"   Add the final part of the output.

Just for reference, Dennis only saves 6 bytes with all that base encoding :P

Retina, 206 196 186 179 (Unseptennium) bytes (Try it online)
Thanks to @MartinBüttner (https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner) for teaching me this language.
Thanks to @FryAmTheEggman for chopping off 7 bytes.
T`d`nubtq\p\hs\oe
.+
$&, $&
(?<=,.*n)
il
(?<=,.*e)n?
nn
(?<=,.*u)
n
(?<=,.*b)
i
(?<=,.*t)
ri
(?<=,.*q)
uad
(?<=,.*p)
ent
(?<=,.*h)
ex
(?<=,.*s)
ept
(?<=,.*o)
ct
r`i?$
ium
T`l`L`^.

Ueh-byte version: here
Bnh-byte version: here

Python 3, unpentquadium (156 155 154) bytes
n=e=""
for c in input():s="nil un bi tri quad pent hex sept oct enn".split()[int(c)];n+=s[c<"1"<"nn"==n[-2:]:];e+=s[0]
print(n.strip("i")+"ium",e.title())

Instead of replacing ii with i we rstrip any is before we tack on the ium, since that's the only possible source of double is. Similarly, we strip ns by checking for an enn/nil case.

PHP, 152  153 163 bytes, unpentbium
Well, at least PHP is somewhere around average this time.
while(null!=$x=$argv[1][$i++]){$a.=$y=[nil,un,bi,tri,quad,pent,hex,sept,oct,enn][$x];$b.=$y[0];}echo str_replace([ii,nnn],[i,nn],$a.'ium ').ucfirst($b);

Runs form command line like:
pentium.php 163

Output:
unhextrium Uht

Ungolfed
$y = array('nil','un','bi','tri','quad','pent','hex','sept','oct','enn');

while (null != ($x = $argv[1][$i++])) {
    $a .= $y[$x];
    $b .= $y[$x][0];
}

echo str_replace(
        array('ii','nnn'),
        array('i','nn'),
        $a . 'ium ')
     .ucfirst($b);

Edit

saved 10 bytes by replacing all (not only one, duh) array()-initializer with []
saved 1 byte by adding the whitespace along with 'ium ' instead using an extra concatenation .' '.

Go, 322 Bytes (tribibium)
package main
import("os"
"strings"
"fmt")
func main(){p,n,s:="nil un  bi  tri quadpenthex septoct enn ","",make([]byte,0)
b:=make([]byte,3)
os.Stdin.Read(b)
var d byte=32
for _,r:=range b{i:=r-48
n+=p[4*i:4*i+4]
s,d=append(s,p[4*i]-d),0}
fmt.Printf("%sium %s",strings.NewReplacer(" ","","ii","i","nnn","nn").Replace(n),s)}

Reads three characters from STDIN, more are ignored, less result in a crash. So it works for every number between unnilnilium and ennennennium.

Also, shouldn't the element for 322 bytes be tribibinium? 321 is tribiunium.

Damn, I missed that one when adding the "i". Now everything should be in order

Haskell, bipentbium (305 271 269 265 261 259 253 252 bytes)
import Data.Char
main=getLine>>=putStr.a
m=map toLower
a n=(r.m$p)++(k.filter isUpper$p)where p=(n>>=(words"Nil Un Bi Tri Quad Pent Hex Sept Oct Enn"!!).digitToInt)++"ium "
r('n':'n':'n':x)="nn"++r x
r('i':'i':x)='i':r x
r(x:z)=x:r z
r x=x
k(h:t)=h:m t

Shaved 34 bytes off thanks to nimi.

You can hardcode the nnn and ii cases into r, i.e. r('i':'i':a)='i':r a;r('n':'n':'n':a)="nn"++r a;r(x:a)=x:r a;r x=x and call it without arguments: t=r.m.p.

@nimi Cheers for that!

Some more bytes to save: concatMap is >>=, i.e. p n=(n>>=(words"..."!!))++"ium "

@nimi Cheers again.

PowerShell, 170 168 165 (Unhexpentium)
-join($a="$input"[0..9]|%{(($x=(-split'Nil Un Bi Tri Quad Pent Hex Sept Oct Enn')["$_"]).ToLower(),$x)[!($y++)]})+'ium'-replace'(nn)n|(i)i','$1$2'
-join($a|%{$_[0]})

Fairly straightforward and no surprises here. Except maybe that I solved the capitalization issue by lower-casing everything but the first part and having the individual parts already in title-case. Agrressively inlined by now to avoid losing characters for bare variable assignments.
Bonus after the last change: Now works for longer element numbers as well:
> echo 1337| powershell -noprofile -file "element.ps1"
Untritriseptium
Utts

C on x86, 192 (Unennbium)
int c,s,a[8],x,main(){while((c=getchar()-48)>=0)x="nil\0un\0\0bi\0\0tri\0quadpenthex\0septoct\0enn"+4*c,strncat(a,x+(c<s-8),4),strncat(a+5,x,1),s=c;printf("%s%s %s",a,"ium"+((s&14)==2),a+5);}

Reads digits from stdin and prints the results to stdout. Relies on sizeof(char*) == sizeof(int).
Ungolfed version:
int c, s, // Current and last digit, initially zero (0-9, not '0'-'9')
    a[8], // Buffer to write to (type doesn't matter when passed by pointer)
    x; // Int-pointer into lookup table

main() {
    while ((c = getchar() - 48) >= 0) { // 48 == '0'
        x = "nil\0un\0\0bi\0\0tri\0quadpenthex\0septoct\0enn" + 4*c;
        strncat(a, x+(c<s-8), 4); // Write digit, skip first char if c==0 && s==9
        strncat(a+5, x, 1); // Write first digit character somewhere else
        s = c;
    }
    printf("%s%s %s", a, "ium"+((s&14)==2), a+5); // Append "ium" (or "um" if s==2||s==3)
}

GNU sed, unhexunium (161 bytes)
h
y/0123456789/nubtqphsoe/
s/./\u&/
x
s/$/ium/
:
s/0/nil/
s/1/un/
s/2/bi/
s/3/tri/
s/4/quad/
s/5/pent/
s/6/hex/
s/7/sept/
s/8/oct/
s/9/enn/
s/nnn/nn/
s/ii/i/
t
G

I generate the symbol first, then stash that into hold space and create the name.  A loop is golfier than using /g for four or more replacements (we can have only one ii and/or one nnn, so they don't need to be inside the loop, but it doesn't hurt).  Finally, retrieve and append the held symbol.
(N.B. I hadn't seen the existing sed answer when I wrote this)
Test cases
These exercise the ii and nnn special rules:
$ seq 100 89 1000 | ./60208.sed
unnilnilium
Unn
unoctennium
Uoe
biseptoctium
Bso
trihexseptium
Ths
quadpenthexium
Qph
pentquadpentium
Pqp
hextriquadium
Htq
septbitrium
Sbt
octunbium
Oub
ennilunium
Enu
ennennilium
Een

And a ridiculous one, showing how much more this code gives, compared to the physical world:
$ ./60208.sed <<<281039817
bioctunniltriennoctunseptium
Bounteous

T-SQL 329 bytes
creat proc x(@a char(3))as select replace(replace((select a.b as[text()]from(select left(@a,1)a union select substring(@a,2,1)union select right(@a,1))z join(values(0,'nil'),(1,'un'),(2,'bi'),(3,'tri'),(4,'quad'),(5,'pent'),(6,'hex'),(7,'sept'),(8,'oct'),(9,'enn'))a(a,b)on z.a=a.a for xml path(''))+'ium','ii','i'),'nnn','nn')

Formatted:
create proc x(@a char(3))as
select replace(replace(
(select a.b as[text()]from
    (
    select left(@a,1)a
    union select substring(@a,2,1)
    union select right(@a,1))z
join(values(0,'nil'),(1,'un'),(2,'bi'),(3,'tri'),(4,'quad'),(5,'pent'),(6,'hex'),(7,'sept'),(8,'oct'),(9,'enn')
    )a(a,b)on z.a=a.a
for xml path('')
)+'ium','ii','i'),'nnn','nn')

R, 278 bytes
g<-function(x){k<-data.frame(c("nil","un","bi","tri","quad","pent","hex","sept","oct","enn"));row.names(k)<-0:9;n<-unlist(strsplit(as.character(x),""));return(sub("nnn","nn",sub("ii","i",paste(c(as.vector(k[n,]),"ium"," ",sapply(k[n,],function(x)substr(x,1,1))),collapse=""))))}

Not the best... but I'm still learning R so I thought I'd post my attempt. Any suggestions to make it better? Now that I think about it it's probably possible to subset on the nth-1 row rather than wasting space creating row names.
Example usage
> g(118)
[1] "ununoctium uuo"
> g(999)
[1] "ennennennium eee"
> g(558)
[1] "pentpentoctium ppo"
> g(118)
[1] "ununoctium uuo"
> g(90)
[1] "ennilium en"
> g(2)
[1] "bium b"

Ungolfed
g <- function(x) {
    k <- data.frame(c("nil","un","bi","tri","quad","pent","hex","sept","oct","enn"))
    row.names(k) <- 0:9
    n <- unlist(strsplit(as.character(x),""))
    return(
        sub("nnn", "nn", sub("ii", "i", paste(c(as.vector(k[n,]),"ium"," ", sapply(k[n, ],function(x)substr(x,1,1))), collapse = ""))))
}

Create a key, convert to data frame, and set as the variable k
Set the row names as 0-9 for easy identification
Take the input x, convert to character, split it up (e.g. 137 to "1" "3" "7")
Subset k based on the split number input and return the entries
Concatenate them together and add -ium
Also subset k using substring to pull the first letter of the matches. This is concatenated to the output of step 5 with a blank space between them
Use sub() to replace the nnn and ii patterns

You forgot to capitalize the first letter of symbol. For example, it should be "Uuo", not "uuo", for 118.

Javascript - 169 bytes
n=>eval(`q='nil0un0bi0tri0quad0pent0hex0sept0oct0enn'.split(0);for(b of (_=$='')+n){c=q[b];$+=q[b];_+=(_?c:c.toUpperCase())[0]}$.replace(/i$()|n(nn)/g,'$1$2')+'ium '+_`)

Bizarrely, my attempts to use map were longer than the for loop.
EDIT: Oops, forgot to check the date.

PHP, 131+1 bytes (untriunium)
still awfully long:
for(;~$c=$argn[$i];print$i++?$n[0]:$n&_)$r.=$n=[nil,un,bi,tri,quad,pent,hex,sept,oct,enn][$c];echo strtr(_.$r.ium,[ii=>i,nnn=>nn]);

Run as pipe with -nR or try it online.

Perl, 109 (Unnilennium) bytes
108 code + 1 switch
perl -pe 's!.!qw{Nil Un Bi Tri Quad Pent Hex Sept Oct Enn}[$&]!ge;s!nnN!nN!g;s!i?$!ium!;$_=lc$_.y!a-z!!dr;s!\b.!\U$&!g'

Takes input from STDIN as one number per line.

You mean unnilseptium :)

Ah, thanks for pointing that out :) Fixed it now

C# 229 (Bibiennium) 198 unennoctium bytes
The "n-'0'" trick is a way to convert from ascii to int. Char 9 = ASCII 57. Char 0 = ASCII 48, so 57-48 = 9.
        static private string ToText(int  v)
        {
            return (string.Join("",v.ToString().Select((char n)=>"nil un bi tri quad pent hex sept oct enn".Split()[n-'0']))+"ium").Replace("nnn","nn").Replace("ii","i")+" "+string.Join("",v.ToString().Select((char n)=>"nubtqphsoe"[n-'0']));
        }
    static private string ToText(int  v)
    {
        string u,r="",t="";
        return v.ToString().Select((char n)=>{u="nil un bi tri quad pent hex sept oct enn".Split()[n-48];r+=u;t+=u[0];return r;}).Last()+"ium".Replace("nnn","nn").Replace("ii","i")+" "+t;
    }

This approach takes the int, converts to a string, then performs a LINQ select of characters that fires off a lambda.
The lambda generates an array on the fly (less characters than defining it) by splitting the string of prefixes. It then pulls the index of the prefix to use by looking at the current character's int value (the n-'0' trick mentioned above).
All that is wrapped in a string.Join which concatenates all of the LINQ results together. Tack on the "ium", then a couple of .Replace statements at the end to clean up the nnn' and ii's.
Added the missing symbol output. I think there's a more efficient way by merging the two LINQs, but it's way to late to keep poking at it.

Instead of n-'0', why not n-30?

Good call, but it depends on the character set. 48 works for me though ;)

Java 8 216Bytes
String f(int i){
String[] s = {"nil","un","bi","tri","quad","pent","hex","sept","oct","enn"};
return ((""+i).chars().mapToObj(y->s[y-48]).collect(Collectors.joining())+"ium").replace("ii","i").replace("nnn","n");
}

Welcome to Programming Puzzles & Code Golf! 1. Your code, in form of a full program or a function, should accept an integer as input and generate the proper name. 2. This does not account for ii and nnn, as explained in the question. 3. The objective of code golf is to make the code as short as possible. The answer should contain its score in the title. You can reduce your score by eliminating whitespace and shortening the variable name.

@Dennis Thanks! but why count the whitespace? it just makes the code even more unreadable.

@Rnet The goal is not to make the code readable. ;) Also some whitespace might be significant, so it's not obvious which whitespace to count and which not. Therefore, the answer should remove as much whitespace as possible and simply count the bytes of that version. If you want to provide a readable version with proper indentation, you can always do so separately below the counted code. See relevant consensus on meta.

C, 210 204 unennennium (199) bytes
This requires ASCII as the runtime character set.
f(char*n,char*s){char*c="NilUnBiTriQuadPentHexSeptOctEnn",*p,*o=n,i,j;for(;*n;){for(j=i=*n-48,p=c;*p&32||i--;++p);for(*s++=*n=*p+32;*++p&32;)*s++=*p;s-=*n++-j==39||j/2-*n==1;}*o-=32;strcpy(s,"ium");}

I did try a recursive solution (which avoids the need for p and o) but that turned out longer.
I'm particularly proud/ashamed of the matcher for the regexp 90|[23]$, which relies on 9 and 0 being the furthest separated digits (and therefore the only pair that differ by 9 - the 39 in the code is a consequence of j being an integer value and *n still an ASCII character) and that 2 and 3 differ only in the last bit, so dividing by 2 conflates them.
Expanded code:
void f(char *n,                 /* input number / output symbol */
       char *s)                 /* output name */
{
    char *c = "NilUnBiTriQuadPentHexSeptOctEnn", /* digit names */
        *p,
        *o = n,                 /* first char of input */
        i, j;                   /* current digit value */
    for (;*n;) {
        j = i = *n-48;
        for (p=c;  *p&32 || i--;  ++p) /* Find the i'th capital letter in c */
                ;
        for (*s++ = *n++ = *p++ + 32;  *p&32;  ) /* Downcase and copy following lowercase */
            *s++ = *p++;
        s -= *n-j==39 || j/2-*n==1;   /* backup one if 9 is followed by 0, or if 2 or 3 is at end of input */
    }
    *o -= 32;                   /* Capitalise symbol */
    strcpy(s,"ium");            /* Finish name */
}

Test harness:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    char buf[1024];
    while (*++argv) {
        f(*argv, buf);
        printf("%s %s\n", *argv, buf);
    }
    return EXIT_SUCCESS;
}


text:
print difference between icmp timestamp in request/reply ping
The challenge involves printing the difference between ICMP originate and receive timestamps.
The idea is being able to determine which asymmetric internet path is responsible for packet delay.
One can use hping with --icmp-ts option to gain the raw data on ICMP_TSTAMP.  The task is complicated by the fact that hping does a fully-buffered output when piped, so, an extra bit of non-portable code is required to unbuffer hping prior to applying something like perl.
Your programme snippet must execute from POSIX shell, ksh or tcsh, and output icmp_seq (int), rtt (float), tsrtt (int), Receive − Originate (int), Originate + rtt − Transmit (int), one set per line, unbuffered or line buffered.
Shortest snippet wins.  If needed, you can assume that unbuffer is available (taking 9 characters), and hping doesn't have an extra 2 in its name.  (E.g., do the math to compensate if either are missing from your system and require an alias, which you must provide for your shell and system, but without penalising the score.)  Also, subtract the domain name, too (extra bonus if you can make it easier to modify, e.g., appearing as the final argument of the snippet).
This is a sample raw data produced by hping, should you wish to use it:
# hping --icmp-ts www.internet2.edu
HPING www.internet2.edu (re0 207.75.164.248): icmp mode set, 28 headers + 0 data bytes
len=46 ip=207.75.164.248 ttl=50 id=21731 icmp_seq=0 rtt=114.0 ms
ICMP timestamp: Originate=34679222 Receive=34679279 Transmit=34679279
ICMP timestamp RTT tsrtt=114

len=46 ip=207.75.164.248 ttl=50 id=21732 icmp_seq=1 rtt=114.1 ms
ICMP timestamp: Originate=34680225 Receive=34680282 Transmit=34680282
ICMP timestamp RTT tsrtt=115

^C
--- www.internet2.edu hping statistic ---
2 packets tramitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 114.0/114.0/114.1 ms
#

This is a screenshot of a sample complete solution which generates the required output in required format:
# unbuffer hping --icmp-ts www.internet2.edu \
| perl -ne 'if (/icmp_seq=(\d+) rtt=(\d+\.\d)/) {($s, $p) = ($1, $2);} \
if (/ate=(\d+) Receive=(\d+) Transmit=(\d+)/) {($o, $r, $t) = ($1, $2, $3);} \
if (/tsrtt=(\d+)/) { \
print $s, "\t", $p, "\t", $1, " = ", $r - $o, " + ", $o + $1 - $t, "\n"; }'
0       114.0   114 = 56 + 58
1       113.8   114 = 57 + 57
2       114.1   115 = 57 + 58
3       114.0   114 = 57 + 57
4       114.3   115 = 57 + 58
5       114.1   115 = 57 + 58
6       113.9   114 = 57 + 57
7       114.0   114 = 57 + 57
8       114.0   114 = 57 + 57
9       114.0   114 = 57 + 57
^C
#

(Note that the math values might be negative.)

@LegionMammal978, you can use any language!  But it has to be executable from POSIX shell or tcsh, so perl is naturally the likely contender (but surprises are welcome!).  You aren't at all required to use hping, unbuffer or perl!  I think it's also been implied that you can install any packages using standard OS tools, without such steps affecting the total character count, either.

...so can I ssh into my computer to use Mathematica? :P

@LegionMammal978, if you can send ICMP timestamp packets that way, go ahead!

I'm not sure whether the question is requiring all answers to use hping (in which case it seems rather perverse that you seem to assume that the answer will call hping rather than just act as a filter to take its output and reformat it) or whether it allows other methods to access ICMP packets. I'm also not sure why all the palaver about unbuffer, which seems completely unnecessary.

@PeterTaylor, no, mentioned many times that hping use is not required; and, no, without unbuffer the presented solution won't work; i'm just presenting all the facts so people have a better idea of where they could start

source: Stack Exchange

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

sort: votes


text:
Sᴍᴀʟʟ Cᴀᴘꜱ Cᴏɴᴠᴇʀᴛᴇʀ
Portable Spec.
Iɴꜱᴘɪʀᴇᴅ ʙʏ @ConorO'Brien's ᴜꜱᴇʀɴᴀᴍᴇ.
Aʟꜱᴏ ᴛʜᴀɴᴋꜱ ᴛᴏ @Dᴏᴏʀᴋɴᴏʙ ꜰᴏʀ ꜱʜᴏᴡɪɴɢ ᴍᴇ ᴛʜᴇ ᴇxɪꜱᴛᴇɴᴄᴇ ᴏꜰ ǫ ᴀɴᴅ x.
Sᴍᴀʟʟ Cᴀᴘꜱ ᴀʀᴇ ᴘʀᴇᴛᴛʏ ᴄᴏᴏʟ. Tʜᴇʏ ᴀʀᴇ ᴜɴɪᴄᴏᴅᴇ ᴄʜᴀʀᴀᴄᴛᴇʀꜱ ᴛʜᴀᴛ ʀᴇᴘʟᴀᴄᴇ ꜱᴍᴀʟʟ ʟᴇᴛᴛᴇʀꜱ. Tʜᴇʏ ʟᴏᴏᴋ ᴊᴜꜱᴛ ʟɪᴋᴇ ᴛʜᴇ ᴄᴀᴘɪᴛᴀʟ ᴏɴᴇꜱ, ʙᴜᴛ ꜱᴍᴀʟʟᴇʀ, ᴀɴᴅ ʟᴏᴏᴋ ʀᴇᴀʟʟʏ ᴏꜰꜰɪᴄɪᴀʟ. Yᴏᴜʀ ᴛᴀꜱᴋ ɪꜱ ᴛᴏ ᴡʀɪᴛᴇ ᴀ ᴘʀᴏɢʀᴀᴍ ᴛʜᴀᴛ ᴄᴏɴᴠᴇʀᴛꜱ ʀᴇɢᴜʟᴀʀ ᴛᴇxᴛ ɪɴᴛᴏ ꜱᴍᴀʟʟ ᴄᴀᴘꜱ.
Hᴇʀᴇ ɪꜱ ᴀ ʟɪꜱᴛ ᴏꜰ ᴛʜᴇ ᴜɴɪᴄᴏᴅᴇ ᴄʜᴀʀᴀᴄᴛᴇʀꜱ ꜰᴏʀ ꜱᴍᴀʟʟ ᴄᴀᴘꜱ:
ᴀ ʙ ᴄ ᴅ ᴇ ꜰ ɢ ʜ ɪ ᴊ ᴋ ʟ ᴍ ɴ ᴏ ᴘ ǫ ʀ ꜱ ᴛ ᴜ ᴠ ᴡ x ʏ ᴢ

Cʟᴀʀɪꜰɪᴄᴀᴛɪᴏɴꜱ

Rᴇɢᴜʟᴀʀ ᴄᴀᴘꜱ ʀᴇᴍᴀɪɴ ʀᴇɢᴜʟᴀʀ ᴄᴀᴘꜱ ᴀɴᴅ ꜱᴏ ᴅᴏ ᴘᴜɴᴄᴛᴜᴀᴛɪᴏɴꜱ, ꜱᴘᴀᴄᴇꜱ, ᴇᴛᴄ.
Iɴᴘᴜᴛ ᴄᴀɴ ʙᴇ ᴍᴜʟᴛɪᴘʟᴇ ʟɪɴᴇꜱ.
Tʜɪꜱ ɪꜱ code-golf, ꜱᴏ ꜱʜᴏʀᴛᴇꜱᴛ ᴄᴏᴅᴇ ɪɴ ʙʏᴛᴇꜱ ᴡɪɴꜱ!

Tᴇꜱᴛ Cᴀꜱᴇꜱ
Hello World -> Hᴇʟʟᴏ Wᴏʀʟᴅ

abcdefghijklmnopqrstuvwxyz -> ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ

Welcome to Programming Puzzles and Code Golf Stackexchange!
It is a website ->
Wᴇʟᴄᴏᴍᴇ ᴛᴏ Pʀᴏɢʀᴀᴍᴍɪɴɢ Pᴜᴢᴢʟᴇꜱ ᴀɴᴅ Cᴏᴅᴇ Gᴏʟꜰ Sᴛᴀᴄᴋᴇxᴄʜᴀɴɢᴇ!
Iᴛ ɪꜱ ᴀ ᴡᴇʙꜱɪᴛᴇ.

What are all of those boxes? I think they are ss...

F and S are boxes for me. The rest are fine, for some reason.

I feel obligated fo answer, now. :P

Any ideas what the font situation is that causes the F and S not to render for a lot of us?

There is no dedicated Unicode character range for "small caps". The letters are taken from several different character ranges, intended for phonetic pronunciations. Therefore, the character codes are out of order (making this programming task more interesting), and fonts may have support for some, but not others. The missing F and S is because your font has support for the IPA Extensions and Phonetic Extensions Unicode block, but not the Latin Extended-D block, which is where small F and S are defined.

Can you provide an external link to an ASCII version? I can't read it on my Android.

@IsmaelMiguel The first line of the question body is a link to a portable spec.

Your question says to write a program. Does that mean that submitting a function is not allowed?

@Dennis Android hates UTF-8... Can't read most of the output.

The F and S don't appear on my 2 Windows 7 PCs but it's working on my Win10 laptop, although in a different font from the rest

Does the code have to handle Unicode input, or can we restrict it to ASCII (or even to just ASCII up to 126)?

@DavidYaw Given what you said plus some digging I find many unicode pages that look like Swiss cheese or worse--is there any decent fix for this to get everything supported?

There seem to be small caps  S and F available in the character set that display correctly. Taken from Conor O'Brien's profile: Sᴍᴀʟʟ Cᴀᴘs Fᴏʀ Tʜᴇ Wɪɴ! Which has both an S and an F.

@LorenPechtel It's not a bug, or anything like that; it's that the font doesn't have those characters present. This is a normal decision made by the author of the font. (To see the difference, open up Character Map on Windows, and look at the "Arial" and "Arial Unicode MS" fonts. Scroll through the list, and see all the additional characters present in the latter.) The fix would be to install a font that supports those characters. (The default fonts in newer versions of Windows do support additional Unicode blocks: F and S don't show up for me on Win7, but they do for other people on Win10.)

Why should it add a dot after It is a website  -> Iᴛ ɪꜱ ᴀ ᴡᴇʙꜱɪᴛᴇ.?

@Dorus srry that's a typo.

FYI the Unicode::Tussle (http://search.cpan.org/~bdfoy/Unicode-Tussle-1.11/lib/Unicode/Tussle.pm) module includes a unicaps Fɪʟᴛᴇʀ ᴛᴏ ᴄᴏɴᴠᴇʀᴛ ᴛᴏ sᴍᴀʟʟ ᴄᴀᴘs, among other goodies.

@DavidYaw Yeah, I know it's not a bug--but that doesn't mean there isn't some way to work around the problem.

If you want a list of fonts that support those characters you (and I) cannot see: FileFormat.info. Unfortunately, I don't have a single font installed the supports those.

Why you shouldn't use small caps: Google auto-detects Vietnamese and translates it as WEDDING ᴘʀᴇᴛᴛʏ ᴄᴏᴏʟ ᴄᴏᴏʟ. Tᴀʀᴇ ᴜɴɪᴄᴏᴅᴇ ᴄʜᴀʀᴀᴄᴛᴇʀꜱ ᴛʜᴀᴛ ʀᴇᴘʟᴀᴄᴇ ꜱᴍᴀʟʟ ʟᴇᴛᴛᴇʀꜱ ʟᴇᴛᴛᴇʀꜱ. Tʟᴏᴏᴋ ᴊᴜꜱᴛ ʟɪᴋᴇ ᴛʜᴇ ᴄᴀᴘɪᴛᴀʟ ᴏɴᴇꜱ ᴏɴᴇꜱ, ꜱᴍᴀʟʟᴇʀ ꜱᴍᴀʟʟᴇʀ, ʟᴏᴏᴋ ʀᴇᴀʟʟʏ ᴏꜰꜰɪᴄɪᴀʟ ᴏꜰꜰɪᴄɪᴀʟ. Yᴛᴀꜱᴋ ɪꜱ ᴛᴏ ᴡʀɪᴛᴇ ᴘʀᴏɢʀᴀᴍ ᴛʜᴀᴛ ᴄᴏɴᴠᴇʀᴛꜱ ʀᴇɢᴜʟᴀʀ ᴛᴇ ᴛxɪɴᴛᴏ ꜱᴍᴀʟʟ ᴄᴀᴘꜱ ᴄᴀᴘꜱ.

The whole text is full of boxes, mind give a version of pure ascii text?

@l4m2 That's already given in the "Portable spec" link.

Retina, 73 bytes
T`a-z`ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ

This is exactly what Retina's transliterate mode was made for. It replaces all lowercase letters (a-z) with their corresponding small caps version. Annoyingly, the character codes of the small caps characters are all over the place, so it can't take advantage of ranges for the second part: ideally it would be T`a-z`ᴀ-ᴢ.
Try it online.

It's not really surprising - what's surprising, bearing in mind the rules for what gets to be a unicode character, is that all of the small caps characters are defined in the first place.

It's not surprising. You can see the same in Unicode subscript and superscript characters. ¹, ² and ³ exist in ISO-8859-1 long before Unicode, so they are in a separated block from the rest digits and letters

Pyth, 61 59 58 bytes
LXbGsmC+*7389<dGCd"#ʙ'(*ꜰɢʜɪ-.ʟ0ɴ2;ǫʀꜱ>?CDxʏE

This defines a named function y. Try it online in the Pyth Compiler/Executor.
The code contains no unprintable characters.
Idea
Among the small caps, there are 14 characters in the range 7424 – 7458, and all of them require three bytes to be stored verbatim. By subtracting 7389 from their code points, we map them in the printable ASCII range 35 – 69, so each of them will occupy only one byte.
To decode the string, we simply add 7389 to the code points of all characters that come before a.
Code
L                       Define y(b):
 Xb                       Transliterate b...
   G                      by replacing the lowercase ASCII letters...
                          with the characters of result of the following:
     m            "…          Map; for each d in that string:
        *7389<dG              Calculate (7389 * (d < 'abc...xyz')).
       +        Cd            Add the product to int(d).
      C                       Cast to character.
    s                       Turn the resulting char array into a string.

Javascript (ES6), 114 bytes

a=>a.replace(/[a-z]/g,b=>'ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ'[b.charCodeAt()-97])

// snippet
var o = document.getElementById("o");
var t = document.getElementById("t");
t.onkeyup = _=>o.textContent = (a=>a.replace(/[a-z]/g,b=>'ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ'[b.charCodeAt()-97]))(t.value);

<input id="t" placeholder='Sample Text' />

Unless you're targetting IE8 or earlier, I'd suggest preferring oninput to onkeyup.

@Neil ok, will do in the future

It's 1 byte cheaper to match everything, and default to b: a=>a.replace(/./g,b=>'ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ'[b.charCodeAt()-97]||b)

CJam, 78 74 67 66 63 bytes
q'{,97>"#ʙ'(*ꜰɢʜɪ-.ʟ0ɴ2;ǫʀꜱ>?CDxʏE"{_'a<7389*+}%er

This uses the same idea as my other answer.
The code contains no unprintable characters. Try it online in the CJam interpreter.
How it works
q       e# Read all input and push it on the stack.
'{,     e# Push the range of all characters up to 'z'.
97>     e# Remove the first 97 characters. This leaves lowercase letters.

"#ʙ'(*ꜰɢʜɪ-.ʟ0ɴ2;ǫʀꜱ>?CDxʏE"

{       e# Map; for each character in that string:
  _'a<  e#   Check if a copy of the character is lower than 'F'. Pushes 1 or 0.
  7389* e#   Multiply the resulting Boolean by 7389.
  +     e#   Add the product to the character's code point.
}%      e#
er      e# Perform transliteration; replace each letter in the input by the
        e# corresponding character of the modified string.

Python 3, 140 bytes
import sys;print(sys.stdin.read().translate(dict(zip(range(97,123),'ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ'))))

Try it online!
Hooray for built-in Unicode support! Now works with multi-line input.
-10 bytes thanks to @Bakuriu

why not {x for x in zip(range(97,123), ...)}? afaik this is the same length of what you have, but now you can shorten the code by using dict(zip(...)) resulting in 10 less bytes or so.

@FelipeNardiBatista input() only takes single-line input. The challenge specifies that multi-line input needs to be handled.

><>, 118 116 Bytes
-2 bytes thanks to @torcado.
I'll try to think of a way to remove that entire alphabet from my code later.
I haven't been able to test it with newlines, but I see no reason for it not working with them.
!oi:0(?;::"{"($"`")*0$.
v"a"%&"ᴢʏxᴡᴠᴜᴛꜱʀǫᴘᴏɴᴍʟᴋᴊɪʜɢꜰᴇᴅᴄʙᴀ"&
>:?!v1-$~
~00.>

Try it online.
Emoticons found in the code: 0:(, :0, :"{, >:, 0=, and the debatable ones: i:, >:?, :?, ?;

Oh wow i love how you used the true/false results for the jump position! You can shave off 2 bytes by using >:?!v1-$~ and ~00.> as your last 2 lines

@torcado Thanks, changing now.

More emoticons: :0(, :?

@DanTheMan I was debating those but I guess I'll add them.

Julia, 126 bytes
t->join([(i=Int(c);96<i<123?split("ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ","")[i-96]:c)for c=t])

Ungolfed:
function f(t::AbstractString)
    # Split the small caps into an array (this particular Unicode
    # string does not like to be indexed for whatever reason)
    s = split("ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ", "")

    # Create an array with replaced letters
    r = [(i = Int(c); 96 < i < 123 ? s[i-96] : c) for c in t]

    # Join the array back into a string
    join(r)
end

Where does AbstractString fit into the golfed code?

@VoteToSpam It doesn't; it's just there in the ungolfed code to illustrate the type of input that's expected. It's entirely unnecessary beyond that.

Perl 5, 84 bytes
(83 bytes script and -p)
use utf8;y/a-z/ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ/

Nothing particularly different, but it's worth noting the necessity of the use utf8; statement to get legible text. A warning is displayed as well, but I believe the consensus is that they are acceptable:
$perl -p smallcaps.pl <<< 'Programming Puzzles and Code Golf'
Wide character in print, <> line 1.
Pʀᴏɢʀᴀᴍᴍɪɴɢ Pᴜᴢᴢʟᴇꜱ ᴀɴᴅ Cᴏᴅᴇ Gᴏʟꜰ
$perl -p smallcaps.pl <<< 'Programming Puzzles and Code Golf' 2> /dev/null
Pʀᴏɢʀᴀᴍᴍɪɴɢ Pᴜᴢᴢʟᴇꜱ ᴀɴᴅ Cᴏᴅᴇ Gᴏʟꜰ

Perl, 80 bytes
(74 bytes script and -pMutf8)
Thanks @hobbs!
y/a-z/ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ/

$perl -pMutf8 -e'y/a-z/ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ/' <<< 'Programming Puzzles and Code Golf' 2> /dev/null
Pʀᴏɢʀᴀᴍᴍɪɴɢ Pᴜᴢᴢʟᴇꜱ ᴀɴᴅ Cᴏᴅᴇ Gᴏʟꜰ

Subtract 9 for use utf8; and add 5 for -Mutf8.

@hobbs Of course! I did play with that earlier, but I'm often unsure how to score correctly when abusing a lot of the commandline switches... I'll add that in!

05AB1E, 73 bytes (non-competing)
Yet again, I wish Adnan had published this language earlier.
A"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"‡

Try it online!
Explanation:
A                              - Push a-z
 "ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"   - Push "ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"
                             ‡ - Pop a, b, c Push a.transliterate(b -> c)

Java, 306 275 217 215 189 bytes
Well, Java is definetely not the best language to accomplish this task in... but, here it is anyway:
void p(String s){for(int i=1;i<27;s=s.replace("abcdefghijklmnopqrstuvwxyz".charAt(++i),"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ".charAt(i)));System.out.print(s);

Thanks to @ThomasKwa and @DHall for help in shaving off 91 characters!

@ThomasKwa it probably can be golfed more, but the unicode shoots up the byte count.

@ThomasKwa Yep, you were right. Had some debug code left in there....

a couple hints to improve this further: 1)string.replace(str1, str2) replaces ALL instances of str1 with str2, and returns the original string as is if str1 isn't found. 2)this is O(n), can you make it O(1) ?

@DHall looking over it, str.replace() would likely be shorter. At work now so I'll try to fix it once I get home.

Ignore my previous deleted comment, I misread the specs. However, you can still golf it like this void p(String s){for(char c:s.toCharArray())System.out.print(c>96&c<123?"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ".charAt(c-97):c);} (PS: You're missing a closing bracket (}) in your current answer.)

Ruby, 89 bytes
p ARGV[0].tr "a-z","ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"

To use:
ruby <file-name> "<string>"

Welcome to Programming Puzzles & Code Golf! I'm not sure if surrounding the output in quotes is allowed, but you can save a few bytes by turning your code into a lambda. ->s{s.tr"a-z","ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"} is only 84 bytes.

(After reading the question again, I'm not sure function are allowed. A few answers are using functions. I'll request clarification from the OP.)

you can replace p ARGV[0] with p$*[0] to save 3. `

Julia, 105 bytes
t->map(c->96<c<123?["ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"...][c-'`']:c,t)

This is simple - for each character in t, it checks to see if the character, c, is lowercase (96<c<123) - if it is, it subtracts the character with value 96 ('`') from the character, and looks up the corresponding character in the array [ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"...]. If it's not lowercase, then just use c itself. The map function applies this procedure for each character in the string.
Alternative, if we can restrict input to ASCII less than 127:
Julia, 104 bytes
t->join(['\1':'`';"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ{|}~"...][t.data])

In this case, the array is longer, including all characters between ASCII 1 ('\1') and 126 ('~'), with the lowercase letters replaced as appropriate - it then uses the characters in t, expressed as unsigned integers (t.data), to lookup the values in the array, and joins the new characters back into a string at the end.

Sed, 97 bytes
y/abcdefghijklmnopqrstuvwxyz/ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ/

I am not a sed user but can abcdefghijklmnopqrstuvwxyz be replaced with a-z to save many bytes?

No, sadly it can't. I didn't post this as something competitive with the best solutions here, just because it's something easy to do with sed. It's also a good test of sed - broken, non-multibyte-aware sed implementations like the one in busybox (and perhaps ones in some proprietary unices?) will likely fail to run it.

Okay, that is a shame. Great answer, though!

Sacred JavaScript ES6, 600 Bytes
Hey look, I answered!
( ))) ) )( ) ))( ))) () (((  (( ()((( ))( )  ( )() (((( () ) () ( () )( )(( ((() () (((  (( ()((( (( (((((((() ) )( ) ))((  )( ) )((( ) ( () )( )(( ) (( ) ( ()(((((( (((( ()() )    ((() ( () () (( )( ( )) ((   ((    (((( ()(  ((() () (((  (( ()((( (( (((( (((((( () (())( ) ) ((() ) )( ) )) ( )((()))) ())() ( () ((() )  ( ()((()() ) )(()) ()(  ()( () )()()(( () )(()(()())()   ()()) ( ( ) ()))))    )  (()  ()(((( )  )()  )  ( )(( ( (( ) )( ((  ((()( ( ((((() () (( )  ( )()( ()((( )  )((((( ( ( ) (( ) ) )( )(( )) (((( ((() ()   ) (  )  (( (( ((()(((()((((() ((() () (( ))((( ( ( )) ((  )( () ( ()

Here's a cool image:

JavaScript ES6, 120 Bytes
This is the code.
k=>k.match(/./g).map(z=>new Array(26) .fill(0).map((q,e)=>"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"[e])[z.charCodeAt()-97]||z).join``)

This is the snippet.

while(1)alert(prompt().match(/./g).map(z=>new Array(26) .fill(0).map((q,e)=>"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"[e])[z.charCodeAt()-97]||z).join``

Scala, 125 bytes
(s:String)=>s.map(c=>('a'to'z'zip "ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"toMap).getOrElse(c,c))

An anonymous function that has string as an input and output. Iterate through its chars and get the unicode version of them by matching them from dict/map. Return original char if the unicode one doesn't exist.
Usage

Open Scala REPL and paste the code above
It will create a function (resX) that can be called by passing a string (e.g. resX("my String"))

Perl 6, 78 bytes
The simplest command line version:
$ perl6 -pe'tr/a..z/ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ/' # 76 + 2 = 78

It gets a bit larger if you put it into a file.
$_=$*IN.slurp-rest;tr/a..z/ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ/;.print # 102

Japt v2.0a0, 81 80 78 75 bytes
r\aÈcg"ʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢᴀʙᴄᴅᴇꜰɢ

Saved 2 bytes thank to ETHproductions

Try it

If you move ᴀʙᴄᴅᴇꜰɢ to the end of the string you can remove the 7+ :-)

So I can. Thanks, once again, @ETHproductions :)

Vyxal U, 56 bytes
ka`#Ẏṗ'(*¥ṫ§Ẋ⟨ẎṫẊ₅-.Ẏẏ0Ẋ¦2;Ṫ₆Ẏ↓¥ṫε>?CDxẎḋE`C:70<7389*+CĿ

Try it Online!
Port of CJam.
How?
ka`#Ẏṗ'(*¥ṫ§Ẋ⟨ẎṫẊ₅-.Ẏẏ0Ẋ¦2;Ṫ₆Ẏ↓¥ṫε>?CDxẎḋE`C:70<7389*+CĿ
ka                                         # Push the lowercase alphabet
  `#Ẏṗ'(*¥ṫ§Ẋ⟨ẎṫẊ₅-.Ẏẏ0Ẋ¦2;Ṫ₆Ẏ↓¥ṫε>?CDxẎḋE` # Push string "#ʙ'(*ꜰɢʜɪ-.ʟ0ɴ2;ǫʀꜱ>?CDxʏE"
                             C             # Convert to character codes: [35, 665, 39, 40, 42, 42800, 610, 668, 618, 45, 46, 671, 48, 628, 50, 59, 491, 640, 42801, 62, 63, 67, 68, 120, 655, 69]
                              :            # Duplicate
                               70<         # For each, is it less than 70?
                                  7389*    # Multiply by 7389
                                       +   # Add
                                        C  # Convert from character codes
                                         Ŀ # Transliterate the implicit input from the lowercase alphabet to this

Previous answer:
Vyxal, 61 bytes
ka»7ȧ∵ẋǍ}Żq(ṗ⌐>⁋8≤M?↵:‡⌊&fǍ≈⁋D5£ɾ|øP₂@ġĿ≤ǔxτ¶_ṙɾ|ȧ.,=»»₃↲»τCĿ

Try it Online!
How?
ka»7ȧ∵ẋǍ}Żq(ṗ⌐>⁋8≤M?↵:‡⌊&fǍ≈⁋D5£ɾ|øP₂@ġĿ≤ǔxτ¶_ṙɾ|ȧ.,=»»₃↲»τCĿ
ka                                                            # Push the lowercase alphabet
  »7ȧ∵ẋǍ}Żq(ṗ⌐>⁋8≤M?↵:‡⌊&fǍ≈⁋D5£ɾ|øP₂@ġĿ≤ǔxτ¶_ṙɾ|ȧ.,=»         # Push compressed integer 454193002670633612531343815167055208136573147142298478503419521655224802790872780438775790455172058745698867697958481400
                                                     »₃↲»     # Push compressed integer 42802
                                                         τ    # Convert the big integer to that custom base as a list: [7424, 665, 7428, 7429, 7431, 42800, 610, 668, 618, 7434, 7435, 671, 7437, 628, 7439, 7448, 491, 640, 42801, 7451, 7452, 7456, 7457, 120, 655, 7458]
                                                          C   # Convert it from character codes to characters
                                                           Ŀ  # Transliterate the implicit input from the lowercase alphabet to that

You can use the U flag to decode strings from the Vyxal encoding as UTF-8 which might allow for a golfier decoder

@emanresuA Good idea, that saved one byte

Also the U flag implicitly includes D.

Python, 99 bytes
def s(t):return"".join([(a,"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"[(ord(a)+7)%26])[96<ord(a)<123] for a in t])

I tried to find some pattern in the Unicode codes for small capitals, but I'm not sure there is one.

You can shorten this by using a lambda: instead of def s(t):return, use lambda t:

Some more golfs bring this to 127 bytes (86 chars)  as you need to count this in UTF-8.

Raku, 69 bytes
{S:g[(q)|<[a..wyz]>]=$0??'ǫ'!!'ᴀ'.uniname.subst(/.$/,$/).uniparse}

Try it online!
Special handling for q; for other lowercase letters other than x, generate the Unicode name for the small caps (eg, LATIN LETTER SMALL CAPITAL S) and parse it.
I saved a few bytes by using the Unicode name of the character ᴀ (LATIN LETTER SMALL CAPITAL A) as a template, and replacing the final character with the letter I want to convert.

Lua, 160 bytes
function c(a)
return a:lower():gsub("%w",function(d)b=a.byte(d)-96;return("ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ"):sub(b,b)end)end

I'm not a Lua programmer, but i guess return("ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ") can be transformed to return"ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ" to save 2 bytes

Jelly, 65 bytes
“⁾ḋḷ?D8=ƙʂȤ£²^ĖẸI)¡e[µ°⁾ṢJ*MĠɓ¤Ḃġ⁽vEEɲạ®G{(ŀ³⁻¹ƭTẸⱮ’ṃ“ȥ3’Ọ
Øaż¢Fy

Attempt This Online!
“⁾ḋḷ?D8=ƙʂȤ£²^ĖẸI)¡e[µ°⁾ṢJ*MĠɓ¤Ḃġ⁽vEEɲạ®G{(ŀ³⁻¹ƭTẸⱮ’ṃ“ȥ3’Ọ : Link 1

“⁾ḋḷ?D8=ƙʂȤ£²^ĖẸI)¡e[µ°⁾ṢJ*MĠɓ¤Ḃġ⁽vEEɲạ®G{(ŀ³⁻¹ƭTẸⱮ’       : Compressed integer for 454193002670633612531343815167055208136573147142298478503419521655224802790872780438775790455172058745698867697958481400

                                                     “ȥ3’  : Compressed integer for 42802

                                                    ṃ      : Base decompression; convert x to base length(y) then index into y; results in character codes

                                                         Ọ : Cast to characters
Øaż¢Fy : Main Link
Øa     : Lowercase alphabet
   ¢   : Last link as a nilad
  ż    : Zip; interleave x and y
    F  : Flatten list
     y : Translate the elements of y according to the mapping in x; change the characters

Integers used to get the character codes borrowed from Steffan's Vyxal Answer

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:
Remove Whitespace from a Java Program
In this challenge, you will be given the source code of a Java program. Your task is to write a function or full program that will remove the whitespace from this program. The whitespace-removed program should work exactly the same as the original program. Your program can be in any language. In this challenge, every space, tab, and newline will be considered whitespace.
Summary
Input can be through command-line arguments, function parameters, or STDIN/equivalent.
Output will be the input program without whitespace through STDOUT/equivalent, along with an integer representing the amount of whitespace removed. Your score will be determined by (number of bytes) - (whitespace removed in sample program)
Sample Program (You can remove 104 whitespace characters from this)
class Condition {
    public static void main(String[] args) {
        boolean learning = true;

        if (learning == true) {
            System.out.println("Java programmer");
        }
        else {
            System.out.println("What are you doing here?");
        }
    }
}

http://pastebin.com/0kPdqZqZ
Whitespace-free version: class Condition{public static void main(String[]args){boolean learning=true;if(learning==true){System.out.println("Java programmer");}else{System.out.println("What are you doing here?");}}}
Clarifications from Comments (see below)

The programs passed as input will be at the same whitespace complexity as the sample program.
The programs will not contain comments.

Closing question
Due to the amount of confusion involved with the question, I have decided to close the competition and accept @MartinBüttner's answer. Sorry for any misunderstanding. However, I would believe the answers to be good as a tool for java golfers, which is why I did not delete the question.

Note: If anyone believes this to be a code golf rather than a code challenge question, feel free to change the tag.

Does the program just have to work with this single test case? If not, how do we ensure that the program is actually correct for all possible Java programs? I'm sure there must be tons of edge cases in a language as elaborate as Java. (You don't even have weird mixes of strings, character literals and comments.)

Make it work with programs on the same level of complexity as the sample one (same indentation rules, etc.). I never would expect programs that could handle removing all 93 whitespace characters from even the sample.

I hope someone does write an overly long program that detects/removes them all. I'm sure it won't win on score, but it would be nice to have a snippet to run on my golfs instead of doing it manually (or with some online minifier) ;)

What about statements broken over multiple lines? Like int\nfoo=5;?

@MartinBüttner statements like those will be contained in a single line.

@mbomb007 Strings should remain as is.

Can you show us the fully whitespace-fixed version, please?

Isn't actually possible to remove 104 whitespaces from the example, including newlines? Tested on a raw wgot of the linked file and I'm pretty sure I removed 104 characters, and it still compiles.

@daniero if you can manage to remove that much, feel free to edit the post

@daniero I believe you've counted the newlines as \r\n, giving 22 characters for removing newlines, instead of just 11.

I'm still not sure what "the same whitespace complexity" means. Can there be double-spaces inside strings? Can there be double spaces inside statements or expressions, e.g. int<SP><SP>foo = 5;, where <SP> is a space (otherwise the browser would display only one)? Currently the answers seem to make vastly different assumptions, so I'm this on hold as unclear until this is sorted out.

@MartinBüttner That's probably what I did. ı used  wc -c to check the difference, on the linked raw file from pastebin. It's not really stated how to deal with this, and my platform doesn't recognize \r\n as one character. I think counting bytes is a better option. I also addressed this in my own answer post below.

@daniero sorry for the confusion, please read this the new section in the question

CJam, 25 bytes - 83 removed = -58
Since Java doesn't have multiline strings nor significant indentation, we can simply remove all leading spaces. Also, since there won't be any comments, and statements will not be split across lines (as per the OP's comments), I think I should be able to remove all newlines as well.
That makes for safe and short code with pretty decent savings for the test file:
q_,\N/{S\+e`1>e~}%_oNos,-

Test it here.
For the test case it yields
class Condition {public static void main(String[] args) {boolean learning = true;if (learning == true) {System.out.println("Java programmer");}else {System.out.println("What are you doing here?");}}}
83

C̶a̶n̶'̶t̶ ̶y̶o̶u̶ ̶a̶l̶s̶o̶ ̶r̶e̶m̶o̶v̶e̶ ̶n̶e̶w̶l̶i̶n̶e̶s̶?̶ ̶D̶o̶n̶'̶t̶ ̶k̶n̶o̶w̶ ̶C̶J̶a̶m̶ ̶t̶h̶o̶u̶g̶h̶,̶ ̶s̶o̶ ̶m̶a̶y̶b̶e̶ ̶i̶t̶ ̶w̶i̶l̶l̶ ̶b̶e̶ ̶w̶o̶r̶t̶h̶ ̶l̶e̶s̶s̶ ̶p̶o̶i̶n̶t̶s̶.̶ Sorry, realized that you can't always remove newlines in java.

@Zereges If I can (waiting for clarification from the OP) it will actually save a byte of code (I'm explicitly writing the newlines back with the second N).

Well, I found out, that my counter example did not work, so maybe you can remove newlines. You can also remove spaces before and after following symbols { } ( ) [ ] , ; = . and maybe some more

@Zereges only if they don't appear inside strings.

The Java Language Specification does not permit newlines in string literals. edit: oh, I see- that apparently wasn't a point of confusion.

@MartinBüttner Right, probably not worth the bytes.

@Mego Good point, I missed that. Fixed.

JavaScript (ES6), 72 bytes - 92 removed = -20
(partially invalid?)
x=>(z=x.replace(/\s*[{}()=;]\s*/g,y=>y.trim()))+`
`+(x.length-z.length)

The output:
class Condition{public static void main(String[] args){boolean learning=true;if(learning==true){System.out.println("Java programmer");}else{System.out.println("What are you doing here?");}}

I believe the one space I could still remove is the one in (String[] args), but this would not be worth it. This is pretty much the lowest score JS can get (for this specific case, anyway).

You forgot to print the amount of whitespace removed (just like I did)

For input programs with a string literal containing any of {}()=; next to whitespace, it alters the string.

Ruby, 63 bytes - 104 removed = -41
edit: 104 bytes that is.
$><<j=(i=$<.read).gsub(/(?<=\W)\s|\s(?=\W)/,"")
p i.size-j.size

Removes all newlines, so the printed number at the end comes on the same line too:
$ curl -s http://pastebin.com/raw.php?i=0kPdqZqZ | ruby remove_whitespace.rb
class Condition{public static void main(String[]args){boolean learning=true;if(learning==true){System.out.println("Java programmer");}else{System.out.println("What are you doing here?");}}}104

Did you count the newlines as \r\n? Otherwise, I'm not sure how you'd get 104.

Also, this would fail if there were two significant spaces in a row anywhere (e.g. in a string or int<SP><SP>foo = 5;)

@MartinBüttner I used wc before and after - curl -s http://pastebin.com/raw.php?i=0kPdqZqZ | wc -c gives a difference of 104 if I don't print the numbers afterwards ("104\n"). As for the "significant spaces", there are none in the example so I think we're good (with "the same whitespace complexity" mentioned in the question). edit: I agree with putting the question on hold, this is all unclear.

Python, 92 bytes - 88 removed = 4
import re,sys
p=sys.stdin.read()
s=re.sub('\s+(=|{|}|(|))\s+',r'\1',p)
print len(p)-len(s),s

Test it here
Once again, regex to the rescue. There's a strange discrepancy between ideone and my python install - I'm getting 90 chars removed.

jprog.py source:
#!/usr/bin/env python

print """class Condition {
    public static void main(String[] args) {
        boolean learning = true;

        if (learning == true) {
            System.out.println("Java programmer");
        }
        else {
            System.out.println("What are you doing here?");
        }
    }
}"""

Java 8 : 79 Bytes
s->{System.out.print(s.replaceAll("(\\s+|\\n)?(\\{|\\}|=+|;)(\\s+|\\n)", "$2"));}

Regular expression with grouping can remove the extra white spaces between curly braces and equals sign used in assignment or equality check.
Regular expression is something like, (\s+|\n)?({|}|=+|;)(\s+|\n)
It will provide following output, which is valid Java program.
class Condition{public static void main(String[] args){boolean learning=true;if (learning==true){System.out.println("Java programmer");}else{System.out.println("What are you doing here?");}}}

right tool for the job lol


text:
Shortening str.replace()
In Python it is often necessary to use str.replace(a,b), however .replace is rather long and feels unnecessary. So is there a shorter alternative to str.replace.
Alternatively is there a similar trick to how you can use r=range for golfing for str.replace?
Example code for golfing
m=input()
f="hello"
print m.replace('t','Ushd')
print m.replace('h','gyhj')
print f.replace('o','%£&')

r=str.replace; print r('abc', 'b', 'c')?

@kirbyfan64sos Nope, Python doesn't work like that unfortunately :(

Uh, yes it does. I just tried it now in Python 2, Python 3, Skulpt, and PyPy.js.

@BetaDecay How many downvotes do you need until you believe it?

@kirbyfan64sos Well whaddaya know, that's brilliant, thanks

@flawr -15 once again! ;P

I don't think this is necessarily a duplicate. Aliasing the function is a possible solution, but there might be others using different functions or methods.

@xnor True, but the second half of the question is just asking for a dupe of the question I linked. If it is removed, I will retract my vote

r=str.replace;print r('abc','b','c')

The magic is real.
Shortening str.replace()

Regex Replace
You can use re.sub, but it will take several uses to pay off if you're only doing it one character at a time.
import re
s="hello"
r=s.replace('h','m')
r=re.sub('h','m',s)

Translate
You may also wish to look at string.translate, which can be used for large numbers of single-character replacements. Requires Python 3. If using Python 2, maketrans is required first. For an example, see here. In Python 3, it's used like this (taking a literal dictionary of ASCII values):
print("hello".translate({104:109}))

Output:
mello

You don't need to use maketrans, try "hello".translate({104:105}). This is a trick some python golfers have used in the past

@FryAmTheEggman Ah right. I always forget you can do that, since the documentation doesn't show that anywhere. Thanks.

@FryAmTheEggman Just realized that requires Python 3. Edited answer to reflect that.

Also re.sub fails if you use regex metachars.

@CatsAreFluffy No it doesn't, you just have to escape them as a regex string like r'\' or with a backslash like '\\'.

Though it becomes pointless if your search is r"\.\.\.\.\.\.\.\." Too many backslashes. (Also r"something" is called a raw string.)

@CatsAreFluffy The entire premise of the question was to replace a single character at a time. And if that's your search, you'd do string multiplication.


text:
Curse you Turing!!! Make a partial halting solver that yells at Turing when he tries to break it
Here goes a quick proof by Alan Turing that there is no program H that can solve the halting problem. If there was, you could make a program X such that X(n) = if H(n,n) == Halt then output X(n) else output ":-)". What is the value of H(X,X)?
Your job is to make a partial halting solver, such that when some X of your choice is inputted, your program will output "Curse you Turing!!!" repeatedly.
Specifically, you will make two programs in the same programming language. One will be H, the partial halting solver. Given a program P (in the same programming language) and an input, H will:

output "halts" if P halts
output "no halts" if P doesn't halt
If P is program X (with input X), output "Curse you Turing!!!" infinitely, on different lines.
If H isn't X, and H can't figure out if P halts, go into an infinite loop without output.

Program X, will be given an input n, and then it will check H(n,n). If it outputs "not halts", it will terminate at some point. For any other result of H(n,n), it will go into an infinite loop. The output of X is unimportant.
H and X will not have access to external resources. Specifically, that means that there is a mutual-quine-aspect to this problem.
As to how hard H has to try to figure out whether a program halts:

Once it determines that its input isn't X and X, it will run the program with the input for 10 seconds. If it terminates (either correctly or with error) it will output "halts".
You must identify an infinite number of "no halts" programs.

Oh, and this may be go without saying, but the programming language needs to be Turing complete (I knew you were thinking of an esoteric language without infinite loops. Sorry.) (That said, Turing complete subsets of languages are also okay.)
Your score is the number of bytes in H. Least number of bytes wins!
Bonuses:

-50 bytes: If H captures output from its input program, and reoutputs it but with "PROGRAM OUTPUT: " in front of every line. (This is only done when H runs the program to test it.)
-20 bytes: If H outputs "halts" based on criteria other than time as well.

Try and find a fun combination of H and X calls to put together to make it interesting (like H(H,(X,X)) or even more crazy stuff.)

Poor Turing....

@AlexA. Addressed

How would your H recognize an X?

@LegionMammal978 You only have to detect one X of your choosing. (I think it may actually be impossible to detect X programs in general.)

@ThomasKwa It is a mathematical challenge. The Halting problem is a mathematical subject. Implementations will also most likely require a quine-aspect, which is a part of computer science, a branch of mathematics. You may be confusing math with arithmetic.

The challenge is mathematical only in genre—its only link to math is that the Halting problem is a mathematical topic. Entries will need to use quine techniques, but solve no math problems. I quote from the tag wiki: "Challenges relating to or in some way involving mathematics; that is, solving a math problem is needed to come up with a solution, or the solution is a program that solves a math problem, or the program generates math problems, etc." It mentions nothing about genre. We didn't tag Minimal NetHack "game".

@ThomasKwa Quines are a mathematical problem. Additionally, the challenge requires partially solving the halting problem, which is also a mathematical problem. This is a mathematically intricate challenge, requiring mathematically intricate answers.

Yes, but again only in genre. A sufficiently talented programmer who knows nothing of math, computer-scientific or otherwise, could solve the challenge as well as Turing himself. The solutions do not "partially [solve] the halting problem" in a mathematical sense; they simply determine whether the input is its source code, or if it halts in less than 10 seconds.

Mathematica, 140 138 127 bytes
H=(While[#==#2[[1]]=="While[#~H~{#}==\"halts\"]&",Print@"Curse you Turing!!!"];TimeConstrained[#=="#&"||ToExpression@#@@#2;"halts",10,"no halts"])&

Defines a function H that takes a function string and argument list as arguments. This also receives the -20 bonus, with the extra criteria being that if the program is #&, then it halts. This is to show that it is flawed. Here is the X:
While[#~H~{#}=="halts"]&

You should test your own submissions, but I'll fire up my copy of Mathematica, try to find out how it works, and look at this.

For which programs does it output "no halts"? It looks like it outputs "no halts" for programs over 10 seconds. They could still halt, its just unknown.

@LegionMammal978 That's to determine if it halts. It doesn't tell you if it doesn't halt.

@LegionMammal978 Analyze the source. Figure out an infinite number of cases, then the program gives up.

@LegionMammal978 Only one X, but a smallish infinity of other infinite loops (not all of them, just an infinite number of them).

@LegionMammal978 Yes, but your program also outputs "no halts" for programs that take 11 seconds to run.

@LegionMammal978 This is only one test. It must do other tests as well.

@PyRulez ...but I did put another test, which is that if the input program is #&, then it definitely halts.


text:
CUDDLE calculation
According to the Wikipedia page on the number 69, it is of note that \$69^2 = 4761\$ and \$69^3 = 328509\$ together use all decimal digits. The number 69 is in fact the lowest number that satisfies this property.
For a similar reason, \$32043\$ is remarkable: \$32043^2 = 1026753849\$ uses all decimal digits.
If we're going to keep talking about numbers that are interesting this way, we'll need some notation.
For most integers \$n\$, the powers \$n^2, ..., n^k\$ will use all ten decimal digits (not counting leading zeroes) at least once for sufficiently large values of \$k\$ . If it exists, we'll call the lowest such \$k\$ the CUDDLE (CUmulative Decimal Digits, Least Exponent) of \$n\$.
Task
Write a program or a function that accepts a single non-negative integer \$n\$ as input and calculates and returns its CUDDLE.
If \$n\$ does not have a CUDDLE, you may return anything but a positive integer, including an error or an empty string, as long as your code halts eventually.
Test cases
Left column is input, right column is output.
0
1
2          15
3          10
4          10
5          11
6          12
7           7
8           5
9           6
10
11          7
12          6
13          6
14          7
15          9
16          5
17          7
18          4
19          5
20         15
26          8
60         12
69          3
128         3
150         9
200        15
32043       2
1234567890  3

Additional rules

Your code must work for all inputs up to \$255\$.
Note that this involves dealing with pretty large numbers. \$20^{15}\$ is already larger than \$2^{64}\$.

If you print the result, it may be followed by a linefeed.

Standard code-golf rules apply.

I was wondering how we went from CUDDLE to 69, and I find it a bit disturbing that it has to do with power ;)

If the number has no CUDDLE, is it okay if the program halts... eventually? (i.e. when the integer counter overflows)

Also, for the first additional rule: Does this mean that if your language's integer type can store numbers > 255, your code must work for them?

@Doorknob Eventually is fine, as long as it actually halts. I've put an upper limit of 255 on the input. Still involves some pretty big numbers in the calculations though...

@Dennis Can my code run forever on some numbers bigger than 255?

@xnor Behavior for integers larger than 255 is undefined.

@Dennis Can I rely on a finite recursion limit for halting with error?

@xnor That halts, so yes.

I added the test case 26->8 because it's the smallest example where including n^1 gives the wrong answer (of 6), an error I had made in my code.

I like 0^23456789=1 and I think this means I win?

Variants:  Print out the digits in the order they are satisfied by n^2..n^k, or print out the digits that are provided by n^k that weren't provided by n^2..n^k-1

Pyth, 16 bytes
hf<9l{=+k^QTtS15

Try it online: Demonstration or Test Suite
Like other solutions, I use 15 as an upper limit. I believe that this is also the maximal CUDDLE. I tested all numbers up to 10.000.000, and there's no number with a CUDDLE greater than 15.
Numbers with a CUDDLE >= 10 are already quite rare. The only numbers with a CUDDLE of 15 are the numbers 2*10^k. There are no numbers with a CUDDLE of 14 or 13, the CUDDLE 12 only appears for the numbers 6*10^k, the CUDDLE 11 only for 5*10^k.
So I think this code works perfectly for any natural number.
Prints an error message, if there is no solution.
Explanation:
hf<9l{=+k^QTtS15   implicit: Q = input number
                             k = empty string
            tS15   the list [2, 3, 4, ..., 15]
 f                 filter this list for elements T, which satisfy:
         ^QT          compute Q^T
       +k             k + ^ (converts to string implicitly)
      = k             save the result in k
    l{  k             length of set of k (number of different chars)
  <9                  test if 9 is smaller than ^
h                  print the first number in the filtered list
                   (throws error if empty)

Python 2, 56
f=lambda n,i=2,s='L':len(set(s))>10or-~f(n,i+1,s+`n**i`)

A recursive solution. Counts up exponents i starting from 2 and accumulates the digits of powers n**i into the string s. When s has all ten digits, returns True, which equals 1, and otherwise recurses and adds 1. This turned out shorter than returning i.
Calling the function on a number without a CUDDLE terminates with Internal error: RangeError: Maximum call stack size exceeded. Numbers up to 255 that do output never need more than 15 iterations.
Because of Python 2's annoying habit of appending an L to large numbers, we actually initialize the digit string to L and check if the set size is at least 11. Python 3 saves 2 chars by not needing this, but loses 3 chars on using str over backticks. Python 3.5 saves 2 more chars with set unpacking, saving a char over Python 2 in total:
f=lambda n,i=2,s='':len({*s})>9or-~f(n,i+1,s+str(n**i))

Ruby, 67 65 chars
->n{s='';[*2..99].index{|i|(s+="#{n**i}").chars.uniq.size==10}+2}

Works near-instantaneously for all the test cases, even the ones > 255.
Errors for numbers with no CUDDLE.
Explanation:
-> n {                         # define function with short lambda syntax
  s = ''                       # the string we are storing the numbers in
  [*2..99]                     # for all numbers from 2 to 99...
    .index {|i|                # find index of the number `i` for which...
      (s+="#{n**i}")           # after appending pow(n,i) to s...
        .chars.uniq.size==10}  # num of uniq chars in s is 10 (each digit)
  + 2                          # add 2, because our index starts from 2
}

CJam, 28 bytes
LliG,2>f#{s+_&_}%:,A#)_)s\g*

Try it online
This relies on the fact that the CUDDLE (if it exists) is never larger than 15 for the input range, as first observed by @xnor.
There's probably a better way of producing the output for the case where there's no solution. I'll update if I think of anything.
Explanation:
L     Push empty string, will be used for accumulating digits.
li    Get input and convert to integer.
G,    Build list of exponents [0 .. 15].
2>    Slice off first two values, to produce [2 .. 15].
f#    Apply power operator with all exponents to input.
{     Start loop over powers.
  s     Convert to string. We care about the digits here.
  +     Concatenate with previously found digits.
  _&    Uniquify using set intersection of digit list with itself.
  _     Copy for continued accumulation in next loop iteration.
}%    End of loop over powers. We'll have an extra copy of the last value here,
      but it does no harm so we just keep it.
:,    Apply length operator to accumulated digit lists.
A#    Find 10 in the list. The search result will correspond to the first power
      that resulted in 10 different accumulated digits. If not found, the result
      will be -1. Note that 0 corresponds to power 2, since that was the first
      power we used. So we need to add 2 to get the result, and check for -1.
)     Increment value. 0 now corresponds to no solution.
_     Copy this value. Will be used as multiplier to create empty string if 0.
)     Increment again, to get the +2 needed for the result.
s     Convert to string.
\     Swap once-incremented value to top, which is 0 for no solution, non-zero
      otherwise.
g     Signum to get 0/1 for no solution vs. solution.
*     Multiply with result string, to get empty string for no solution.

Mathematica, 103 bytes
f=(d=DigitCount;x=1;y=d[0];For[n=0,!IntegerQ@Log10[#]&&MemberQ[y,0],++n,x*=#;y+=d[x]];Print[#,"\t",n])&

It appears that only powers of 10 would not eventually have CUDDLEs, so they are skipped. Function keeps a list of seen digits and stops when there are no longer zeros in it.
Output:
1    0
2    15
3    10
4    10
5    11
6    12
7    7
8    5
9    6
10    0
11    7
12    6
13    6

Fun fact: As long as log_10(n) is irrational, given any positive integer k there exists m such that the decimal representation of n^m starts with k. Which means that skipping the powers of 10 (and 0) is fine :)

JavaScript (ES6) 188
Not bad for a language that is limited to 53 bits integers.
Test running the snippet below in a browser that implements EcmaScripts 6, including arrow functions and spread operator (AFAIK Firefox)

f=n=>{for(p=1,d=[],v=n=[...n+''].reverse();++p<20;){v.map((a,i)=>n.map((b,j)=>r[j+=i]=a*b+~~r[j]),r=[],c=0),r=r.map(r=>(r+=c,c=r/10|0,d[r%=10]=r));v=c?[...r,c]:r;if(d.join``[9])return p;}}

// Less golfed
U=n=>{
// Arbitrary precision multiplication
  M=(A,B,R=[],c=0)=>
  (
    A.map((a,i)=>B.map((b,j)=>R[j+=i]=a*b+~~R[j])),
    R=R.map(r=>(r+=c,c=r/10|0,r%10)),
    c?[...R,c]:R
  );
  v=n=[...n+''].reverse();
  for(p=1,d=[];++p<20;)
  {
    v=M(n,v)

    v.map(c=>d[c]=c)
    if (d.join``[9])return p
  }
}

// TEST
for(i=o='';++i<300;)o+=i+' : '+f(i)+'\n'
O.innerHTML=o

PowerShell, 94 bytes
param($n,$s='')
2..99|%{$s+=[bigint]::Pow($n,$_);if(($s-split''|sort -U).Count-eq11){$_;break}}

(As a single line)

Nothing too clever about it, but piping to sort -U[nique] is a neat way to ape Python's set() functionality for this kind of use, without explicitly adding items to a hashtable.
param($n,$s='')                              # Take command line parameter.
2..99 |%{                                    # Loop from 2 to 99, inclusive.
    $s+=[bigint]::Pow($n,$_)                 # $n^Loopvar, concatenate to string.
    if (($s-split''|sort -U).Count-eq11) {   # Convert to unique-characters-array; count.
        $_;break                             # Print current loopvar and quit.
    }
}                                            # Otherwise, finish (silently).

e.g.
PS C:\> .\CUDDLE-of-n.ps1 10

PS C:\> .\CUDDLE-of-n.ps1 12
6

PS C:\> .\CUDDLE-of-n.ps1 255
5

gawk 4, 73 + 5 for flags = 78 bytes
{for(n=$0;a-1023&&++i<15;j=0)for($0*=n;j++<NF;)a=or(a,2^$j)}$0=i<15?++i:_

For every digit 0 bis 9 it encounters in the powers of the input, it sets the bit representing 2^digit in a, until the first 10 digits are found (a == 1023 == 2^10-1) or there's been more than 15 iterations.
Has to be called with an empty field seperator and the -M flag for big numbers.
echo 17 | awk -M '{for(n=$0;a-1023&&++i<15;j=0)for($0*=n;j++<NF;)a=or(a,2^$j)}$0=i<15?++i:_' FS=

Fiddling around with this I found the following sequences for the different CUDDLEs:

2: 32043 32286 33144 35172 35337 35757 35853 37176 37905 38772 39147 39336 40545 42744 43902 44016 45567 45624 46587 48852 49314 49353 50706 53976 54918 55446 55524 55581 55626 56532 57321 58413 58455 58554 59403 60984 61575 61866 62679 62961 63051 63129 65634 65637 66105 66276 67677 68763 68781 69513 71433 72621 75759 76047 76182 77346 78072 78453 80361 80445 81222 81945 83919 84648 85353 85743 85803 86073 87639 88623 89079 89145 89355 89523 90144 90153 90198 91248 91605 92214 94695 95154 96702 97779 98055 98802 99066
3: 69 128 203 302 327 366 398 467 542 591 593 598 633 643 669 690 747 759 903 923 943 1016 1018 1027 1028 1043 1086 1112 1182 1194 1199 1233 1278 1280 1282 1328 1336 1364 1396 1419 1459 1463 1467 1472 1475 1484 1499 1508 1509 1519 1563 1569 1599 1602 1603 1618 1631 1633 1634 1659 1669 1687 1701 1712 1721 1737 1746 1767 1774 1778 1780 1791 1804 1837 1844 1869 1889 1895 1899 1903 1919 1921 1936 1956 1958 1960 1962 1973 1984 1985 1991 1994 1996 2003 2017 2019 2030 2033 2053 2075 2123 2126 2134 2157 2158 2159 2168 2175 2183
4: 18 54 59 67 71 84 93 95 97 108 112 115 132 139 144 147 148 152 156 157 159 169 172 174 178 179 180 181 182 184 195 196 213 214 215 216 221 223 227 228 232 234 235 239 241 242 248 265 266 267 270 272 273 279 281 285 287 294 298 299 306 311 312 314 315 316 323 326 329 332 336 338 342 343 353 354 356 361 362 364 365 368 369 379 388 391 393 395 396 397 403 412 413 414 416 419 423 426 431 434 439 442 443 444 448 451 452 453 454 455 457 459 463 466 469 472 473 477 479 482 484 486 489 493 494 496 503 507 508 509 515 517 523
5: 8 16 19 27 28 38 44 47 55 57 61 77 79 80 82 83 86 87 91 92 103 106 113 116 117 118 121 123 125 126 129 131 133 136 138 140 141 142 143 145 146 151 154 158 160 161 165 167 173 175 176 177 183 185 186 187 189 190 191 192 193 197 198 204 207 218 224 226 229 230 231 236 240 243 246 249 253 255 257 258 259 261 263 268 269 271 275 276 277 278 280 282 283 284 286 288 289 292 293 304 309 322 328 331 339 341 344 345 346 347 348 349 352 357 359 367 371 372 373 374 375 377 380 381 384 387 389 402 407 408 409 411 417 418 422 427
6: 9 12 13 22 23 24 33 36 37 39 42 43 45 46 49 51 53 58 62 66 72 73 75 78 81 88 90 94 98 105 107 109 114 119 120 122 127 130 134 137 149 153 155 162 163 164 166 168 170 194 199 206 211 212 217 219 220 222 225 233 237 238 244 247 252 254 256 262 264 274 291 295 296 301 308 317 319 321 324 325 330 333 334 337 351 355 358 360 370 376 378 382 383 385 386 390 394 399 401 404 405 406 415 420 421 424 425 429 430 433 435 438 446 450 460 471 476 478 488 490 498 502 504 506 510 513 514 519 530 539 548 556 578 620 628 631 634 636
7: 7 11 14 17 29 31 32 35 41 48 52 56 63 64 70 74 85 89 96 99 102 104 110 111 135 171 188 201 202 205 208 245 251 290 297 303 305 307 310 313 318 320 335 350 363 392 410 465 475 480 483 485 501 511 518 520 521 560 582 584 595 601 630 640 682 700 736 740 786 798 850 890 952 956 965 975 982 990 999 1002 1005 1011 1020 1040 1054 1100 1110 1171 1219 1313 1331 1350 1379 1414 1447 1468 1601 1707 1710 1735 1748 2001 2010 2020 2050 2080 2450 2510 2534 2641 2745 2900 2914 2955 2970 3030 3050 3070 3100 3130 3136 3180 3193 3200
8: 21 25 26 30 34 65 76 124 209 210 250 260 300 340 505 650 1004 1240 2002 2090 2100 2500 2600 2975 3000 3400 3944 4376 5050 6500 6885 7399 10040 12400 15483 20002 20020 20900 21000 25000 26000 29750 30000 34000 43760 50500 65000 68850 73990
9: 15 68 101 150 1001 1010 1500 10001 10010 10100 15000
10: 3 4 40 400 4000 40000
11: 5 50 500 5000 50000
12: 6 60 600 6000 60000
15: 2 20 200 2000 20000

Jelly, 13 bytes
*Ḋ}DFQL
çⱮ⁴i⁵

Try it online!
Assumes that the CUDDLE of a number is never greater than 16. This is a 14 byte version that only assumes the CUDDLE exists (runs forever for \$n = 0, 1, 10\$)
How it works
*Ḋ}DFQL - Helper link. Takes n on the left and k on the right
  }     - To k:
 Ḋ      -   Dequeue; Yield [2, 3, ..., k]
*       - Raise each to the power n
   D    - Convert to digits
    F   - Flatten
     Q  - Deduplicate
      L - Length

çⱮ⁴i⁵ - Main link. Takes n on the left
  ⁴   - 16
 Ɱ    - Over each k in [1, 2, ..., 15, 16]:
ç     -   Run the helper link with n on the left and k on the right
    ⁵ - 10
   i  - First index of 10 or yield 0 if not present

05AB1E, 12 bytes
₂L.ΔL¦mS9ÝåP

Outputs -1 if \$n\$ does not have a CUDDLE.
Try it online or verify all test cases.
Explanation:
₂L            # Push a list in the range [1,26]
              # (note: 26 is the smallest single-byte builtin integer above 15)
  .Δ          # Find the first integer k in this list which is truthy for:
              # (results in -1 if none were truthy)
    L         #  Push a list in the range [1,k]
     ¦        #  Remove the first item to make the range [2,k]
      m       #  Take the (implicit) input-integer to the power of each of these
       S      #  Convert the list of integers to a flattened list of digits
        9Ý    #  Push a list in the range [0,9]
          å   #  Check for each digit it it's in the flattened list of digits
           P  #  And check if this is truthy for all of them
              # (after which the result is output implicitly)

The S9ÝåP could also have been JÙgTQ for the same byte-count:
       J      #  Join the list of integers together to a single string
        Ù     #  Uniquify its characters/digits
         g    #  Pop and push its length
          TQ  #  And check that this length is equal to 10

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


text:
Counting Abelian groups of a given size
Background
Last time, we counted groups of a given size, which is a non-trivial problem.
This time, we'll only count Abelian groups, i.e., groups with a commutative operation. Formally, a group (G, ∗) is Abelian if x ∗ y = y ∗ x for for all x, y in G.
The problem becomes much simpler this way, so we're going to count them efficiently.
Task
Write a program or function that accepts a non-negative integer n as input and prints or returns the number of non-isomorphic Abelian groups of order n.
One way of calculating the number of groups – which we'll denote by A(n) – is by observing the following:

A(0) = 0

If p is a prime, A(pk) is equal to the number of integer partitions of k. (cfr. OEIS A000041)

If n = mk, and m and k are co-prime, A(n) = A(m)A(k).

You may use this or any other method of calculating A(n).
Test cases
Input               Output
0                   0
1                   1
2                   1
3                   1
4                   2
5                   1
6                   1
7                   1
8                   3
9                   2
10                  1
11                  1
12                  2
13                  1
14                  1
15                  1
16                  5
17                  1
18                  2
19                  1
20                  2
4611686018427387904 1300156
5587736968198167552 155232
9223371994482243049 2

(taken from OEIS A000688)
Additional rules

Given enough time, RAM and a register size that can hold the input, your code should work (in theory) for arbitrarily large integers.

Your code must work for all integers between 0 and 263 - 1 and finish in under 10 minutes on my machine (Intel i7-3770, 16 GiB RAM, Fedora 21).
Please make sure you time your code for the last three test cases before submitting your answer.

Built-ins that trivialize this task, such as Mathematica's FiniteAbelianGroupCount, are not allowed.

Built-ins that return or count the integer partitions of a number or the partitions of a list are not allowed.

Standard code-golf rules apply.

Pyth's prime factorization system is too slow for this challenge - I need to fix that.

CJam (39 38 bytes)
qimF{~M\{_ee{~\)<1b}%1+a\+}*0=1be&}%:*

Online demo
This follows the suggested line of finding a prime factorisation (mF) and then calculating the partitions of each power and taking their product.
There are two special cases for mF: it factors 0 as 0^1 and 1 as 1^1. The latter doesn't require special treatment: there is one Abelian group of size 1, and one partition of 1. However, zero does require a special case.
The partition counting uses a recurrence for A008284(n, k), the number of partitions of n into k parts. In OEIS it is given as
T(n, k) = Sum_{i=1..k} T(n-k, i), for 1<=k<=n-1; T(n, n) = 1 for n >= 1.

but I think it's more useful to think of the sum as ranging from 1 to min(k, n-k).
Dissection
q~              e# Parse input into an integer
mF              e# Factorise it
{               e# For each factor p^a
  ~             e#   Split the array [p a]
                e#   The following lines count partitions of a
                e#   (Note: they would be buggy if a were ever 0, but it isn't)
  M\{           e#   Starting with a table of zero rows, repeat a times
    _ee         e#     Copy table and pair each row with its index
    {~\)<1b}%   e#     Extract that prepended index and use it to sum for each j
                e#     the first jth items of row j
    1+          e#     Append a 1 for P(i, i)
    a\+         e#     Prepend the new row to the table (which is stored in reverse)
  }*
  0=1b          e#   Sum the elements in the latest (first) row

  e&            e#   If p was 0 then replace with 0
}%
:*              e# Take the product

CJam, 50 49 47 43 bytes
ri_mF{1=_L{1$0>{,f{):X-Xj}:+}{;!}?}2j}%:*e&

Uses CJam's builtin mF factorisation and a memoised port of this Python partition number function:
p=lambda n,x:n==0 or n>0and sum(p(n+~a,a+1)for a in range(x))

or ungolfed:
def p(n, x): # Call like p(n, n). n is number remaining, x is max part size
  if n > 0:
    return sum(p(n-a-1,a+1)for a in range(x))
  else:
    return (n==0)

Like @RetoKoradi's answer, the last case takes about 17 seconds on the offline interpreter because that's how long it takes CJam to factorise the number. Hence I've left it out of this online test suite.
Full explanation
[Main body]
ri                                Read input and convert to int
  _          e&                   Logical AND input with final result to special case 0
   mF                             Factorise input into [base, exponent] pairs
     {...}%                       Map, converting each pair to a partition number
           :*                     Take product

[Pair -> partition]
1=_                               Get exponent and copy (n,x in above Python)
   L                              Initialise empty cache
    {                       }2j   Memoise with 2 arguments
     1$0>                         Check if n > 0
         {            }{  }?      Execute first block if yes, else second block
                        ;!        Return (n == 0)
          ,f{      }              For each a in range(x) ...
             ):X-Xj               Call p(n-a-1,a+1) recursively
                    :+            Sum the results

Mathematica, 96 94 88 bytes
f=1##&@@#&;f[SeriesCoefficient[1/f[1-x^Range@#],{x,0,#}]&/@Last/@FactorInteger@#]Sign@#&

I'm not that proficient with Mathematica, but I thought I'd give it a try. Thanks to @MartinBüttner for -6 bytes.
This uses the generating function formula for integer partitions.

CJam, 58 bytes
li_mF{1=_L{_1>{_2$<{\;_j}{\,f{)_@\-j}:+}?}{;;1}?}2j}%:*\g*

Try it online
The very last test example takes forever (or at least longer than I was willing to wait) in the online interpreter, but finishes in 17 seconds with the offline version of CJam on my laptop. All other test examples are pretty much instantaneous.
This uses the CJam mF operator, which gives the prime factorization with exponents. The result is then the product of the partition counts for each exponent.
The main part of the code is calculating the partition counts. I implemented the recursive algorithm on the wikipedia page, using the j operator that supports recursion with memoization.
Explanation:
li    Get input and convert to int.
_     Make a copy to handle 0 special case at the end.
mF    Factorization with exponents.
{     Loop over factors.
  1=    Take exponent from [factor exponent] pair.
  _     Repeat it, recursive calls are initiated with p(n, n).
  L     Empty list as start point of memoization state.
  {     Start recursive block. Argument order is (m, n), opposite of Wikipedia.
    _1>   Check for n > 1.
    {     Start n > 1 case.
      _2$   Copy both m and n.
      <     Check for n < m.
      {     n < m case.
        \;    Pop m.
        _     Copy n.
        j     Make the p(n, n) recursive call.
      }     End n < m case.
      {     Main part of algorithm that makes recursive calls in loop.
        \,    Generate [0 1 ... m-1] range for k.
        f{    Start loop over k.
          )     Increment, since k goes from 1 to m.
          _     Copy k.
          @\    Rotate n to top, and swap. Now have k n k at top of stack.
          -     Subtract, now have k n-k at top of stack.
          j     Make the p(n-k, k) recursive call.
        }     End loop over k.
        :+    Sum up all the values.
      }?    Ternaray operator for n < m condition.
    }     End n > 1 case.
    {     n <= 1 case.
      ;;1   Pop m, n values, and produce 1 as result.
    }?    Ternary operator for n > 1 condition.
  }2j   Recursive call with memoization, using 2 values.
}%    End loop over factors.
:*    Multiply all values.
\     Swap original input to top.
g     Signum.
*     Multiply to get 0 output for 0 input.