text:
Splitting up ASCII
Given the 95 printable characters in ASCII plus newline, break it apart into two equal, 48 character groups (hereafter called group A and group B). Create a one-to-one mapping of your choice (you have total discretion) between the two groups. In other words, A might map to a, and vice versa, but A might also map to > and vice versa, if that's what you need for your program.
Once you've broken up ASCII into two groups, write two programs and/or functions, using only the characters in each group, respectively. In other words, write one program / function that only uses the characters in group A, and another program / function that only uses the characters in group B.
These programs must be able to receive one character as input. The program written with the characters in Group A should output / return the same character if the input was a group A character, and the mapped group A character if it received a group B character; the Group A program should always output a group A character. Similarly, the Group B program should output the same character if it's a group B character, and the mapped group B character if the input is a group A character.
That might not be so clear, so here's an example. If you assume that all capital letters are in group A, and all lowercase letters are in group B, and you've chosen that your one-to-one mapping for these letters are from one to the other, then: then here are some sample input/outputs:
Program A:
Input    Output
A        A
D        D
a        A
q        Q

Program B:
Input    Output
A        a
D        d
a        a
q        q

Other rules:

The two programs do not need to be in the same language.
They don't need to be both programs or both functions; one could be a program, the other a function, that is fine.
They don't need to work the same way, be of similar length, anything like that; they simply must meet the the other rules above.
Yes, only one of your programs may use newlines, and only one can use spaces (this could be the same, or a different program).
You do not need to use all 48 characters in each program.

Standard loopholes are banned, as normal. All programs must be self contained, no files containing the mapping you choose.
Scoring criteria: code-golf. Specifically, the sum of the bytes of the text of the two programs.
Please post your answer like this:

Language - # bytes + Language - # bytes = # bytes

An unambiguous description of your mapping. If it's complicated, use a chart like this:

ABCDEFGHIJKLMNOPQRSTUVWXYZ (etc.)
zyxwvutsrpqonmlkjihgfedcba (etc.)

Or, you can just explain it (first 48 maps to last 48 in sequence), followed by your answer as normal.

I'm going to try using the same language for both. :)

I honestly think you should change the rules, restricting it to "both programs have to be the same language." Otherwise it's probably WAY too easy/broad.

I actually wonder if this is possible in Self-modifying Brainfuck. You just have to have one program using + and >, and the other using - and <. Then you have to try to generate the missing operators, such as a , or . in the program that cannot use them.

If the implementation can be via two different functions within one program, can they share common code (i.e. a global variable)?

They can't be two functions in one program. If you do two functions it has to be in two programs.

@durron597 Thanks! Also, does the restriction to repeat characters apply to non-alphanumeric characters as well? For instance, if I use the "=" symbol in the first program, I can't use it in the second one?

@durron597 Sorry, last question... If I opt for the two "function" approach, does only code inside of the actual function that takes the character and returns the mapped one count, or does the whole program still count? If the latter is the case, then the same language would simply be impossible (i.e. if both programs can't have "void main() { ... }" or "#include", etc).

@Ruslan It's the whole program. And then maybe you should try a different programming language, one without includes or required brackets. See if it's possible in Python. I think it is.

I mean, one of them should be in brainfuck :)

@Ruslan Try using SQL. It's not case sensitive and uses keywords (begin and end) for code blocks. If you use SQL Server 2014, you can use DBCC Bulk Insert for one program, and a procedure for the other one. In the first one, you can avoid using parentheses. Then use a select case when statement for both programs.
Also, I believe it's possible in Java by using the \u trick for a program replacing every character with unicode values and using a function for the other that doesn't use the letter u, a backslash, or numbers.

Hardest. Challenge. Ever.

Was knee-deep into a solution using JavaScript for both; got tired but I'm almost positive it's possible. Figured out that a function normally requiring parentheses can be written without them, by creating a new Function with tagged template syntax and executing it with another tagged template. Then just a lot of hexadecimal escapes inside the eval'd string..... TL;DR this challenge is extremely difficult.

@Blackhole it's possible to complete if you use two sepearate languages: use Unary for one and Whitespace for the other.

Exactly @bmarks with esolangs this is quite an easy challenge to complete... Doing it golfed is the hard part.

@bmarks Yes, I also thought about SQL at first. But then one issue is spaces (although maybe I can find a way around that).

@Ruslan try using newlines in one and spaces in the other. I believe they are equivalent in T-SQL.

Hmm, since the answer formatting is specified, I was expecting a leaderboard stack snippet :)

@aditsu I suck at Javascript, but I welcome others to edit one in

CJam - 11 bytes + CJam - 25 bytes = 36 bytes
Characters are selected in alternating groups of 16:
 !"#$%&'()*+,-./@ABCDEFGHIJKLMNO`abcdefghijklmno
0123456789:;<=>?PQRSTUVWXYZ[\]^_pqrstuvwxyz{|}~\n

It's cool that a few of the mappings can be obtained with the shift key :)
Program A:
lL,H-f&'o+c

Try it online
Program B:
q_S<\_0=16|_127<\S0=42^??

Try it online
Explanation:
Program A:
l      read a line from the input, this is a 1-character string
        or the empty string if the input was a newline
L,     get the length of an empty string/array (0)
H-     subtract 17, obtaining -17 (~16)
f&     bitwise-"and" each character (based on the ASCII code) with -17
'o+    append the 'o' character
c      convert to (first) character
        the result is the "and"-ed character, or 'o' for newline

Program B:
q_       read the whole input and duplicate it
S<\      compare with " " and move the result before the input
_0=      duplicate the input again, and get the first (only) character
16|      bitwise-"or" with 16 (based on the ASCII code)
_127<    duplicate and compare (its ASCII code) with 127
\        move the result before the "or"-ed character
S0=      get the space character (first character of the space string)
42^      xor with 42, obtaining a newline character
          stack: (input<" ") (input) ("or"-ed char<127) ("or"-ed char) (newline)
?        if the "or"-ed character is less than 127, use the "or"-ed character
          else use the newline character
?        if the input was smaller than space (i.e. it was a newline),
          use the input, else use the character from the previous step

Nice! Glad to see that "even/odd" isn't the only answer.

Still a 1 bit toggle... Impressive sizes!  2nd program w/input of 'o' doesn't seem to output the \n... bug in program or online cjam?

@BrianTuck it does output a newline (not a literal \n), it's just not easy to see without inspecting the html. You can append an i at the end of the program to see the ASCII code instead (or ci to also deal with a newline input, since it outputs a newline string rather than a character in that case)

Oh, or you/I could change _0= to 0=_ so that it always outputs a character

CJam - 46 44 26 11 bytes + GolfScript - 142 125 115 93 68 47 40 36 bytes = 47 bytes
Thanks to Peter Taylor for golfing 6 bytes off the GolfScript program (and paving the way for many more.)
Thanks to Dennis for golfing 15 bytes off the CJam program and 4 bytes off the GolfScript program.
Group A: all characters with even character code.
Group B: all characters with odd character code, plus newline.
I'm using the obvious mapping between the two, i.e. pair those characters which only differ in the least significant bit, as well as ~ and \n. Here is the complete map (the columns):
 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~
!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}\n

Program A (CJam, test it here):
lX~f&"~"|X<

Program B (GolfScript, test it here):
{1}'{-'{)}%'115)%11-[9)ie'9/{))}%++%

Explanation
Program A
(Outdated, will update tomorrow.)
This program should turn odd character codes into even ones, i.e. set the least significant bit to 0. The obvious way to do this is bitwise AND with 126 (or 254 etc), but it's shorter to set it to 1 (via bitwise OR with 1) instead and then decrement the result. Finally, we need to fix newlines manually:
"r"(  e# Push the string "r" and pull out the character.
(~    e# Decrement to q and eval to read input.
(     e# Pull out the character from the input string.
2(|(  e# (input OR (2-1))-1 == input AND 126
0$    e# Copy the result.
N&    e# Set intersection with a string containing a newline.
"~"   e# Push "~".
"@@"( e# Push "@@" and pull out one @.
(|    e# Decrement to ?, set union with the other string to give "@?".
~     e# Eval to select either the computed character or "~" if it was a newline.

Program B
(Outdated, will update tomorrow.)
This program can simply set the least significant bit to 1 via bitwise OR with 1 now. But it has to check for both \v (character code 0x0B) and <DEL> (character code 0xFF) manually and set them to ~ instead. In GolfScript I didn't have access to eval, but instead you can add a string to a block (which then becomes part of the code in that block), which I could map onto the input with %:
{1}    # Push this block without executing it.
'{--'  # Push this string.
{)}%   # Increment each character to get '|..'.
')1)7?=[11=+9)?ie'
       # Push another string...
7/     # Split it into chunks of 7: [')1)7?=[' '11=+9)?' 'ie']
{))}%  # For each chunk, split off the last character and increment it.
+      # Add the array to the string, flattening the array: '|..)1)7?=\11=+9)@if'
+      # Add it to the block: {1|..)1)7?=\11=+9)@if}
%      # Map the block onto the input, i.e. apply it to the single character.

And as for the generated code in the block:
1|..   # Bitwise OR with 1, make two copies.
)1)7?= # Check if the result is one less than 2^7 == 128 (i.e. if it's <DEL>).
\11=   # Check with the other copy if it's equal to 11 (i.e. if it's \v).
+      # Add them to get something truthy either way.
9)     # Push a 10 (i.e. \n).
@      # Pull up the original value.
if     # Select the correct result.

Java - 1088 bytes + Java - 1144 bytes = 2232 bytes
Thanks to @durron597 for helping to golf 1090 bytes from the first program.
Proof that it is possible to do in one language (and a non-esolang at that).
Use the unicode trick to convert the first one to all unicode characters. The second one uses reflection to get access to System.out in order to print to std. out. It couldn't use the u because that was used in the first program. I know this can be golfed more, but I wanted to post a valid solution first.
The groups are fairly arbitrarily mapped, but basically, the first one required only u,\, and the hexadecimal digits (in any case).
The groups:
!#7$&89'0123456>fB@UXZ\^AKCDEGH_JL`NOkQRxzVWYu~\n
 "%()*+,-./:;<=?FIMPST[]abcdeghijlmnopqrstvwy{|}

First program:
\u0076\u006F\u0069\u0064
k\u0028\u0069\u006E\u0074
x\u0029\u007B\u0069\u006E\u0074\u005B\u005Du\u003D\u007B33\u002C33\u002C35\u002C35\u002C36\u002C55\u002C38\u002C39\u002C36\u002C38\u002C56\u002C57\u002C39\u002C48\u002C49\u002C50\u002C48\u002C49\u002C50\u002C51\u002C52\u002C53\u002C54\u002C55\u002C56\u002C57\u002C51\u002C52\u002C53\u002C54\u002C62\u002C62\u002C64\u002C65\u002C66\u002C67\u002C68\u002C69\u002C102\u002C71\u002C72\u002C66\u002C74\u002C75\u002C76\u002C64\u002C78\u002C79\u002C85\u002C81\u002C82\u002C88\u002C90\u002C85\u002C86\u002C87\u002C88\u002C89\u002C90\u002C92\u002C92\u002C94\u002C94\u002C95\u002C96\u002C65\u002C75\u002C67\u002C68\u002C69\u002C102\u002C71\u002C72\u002C95\u002C74\u002C107\u002C76\u002C96\u002C78\u002C79\u002C107\u002C81\u002C82\u002C120\u002C122\u002C117\u002C86\u002C87\u002C120\u002C89\u002C122\u002C117\u002C126\u002C10\u002C126\u007D\u003B\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006Fu\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0028x>10\u003F\u0028\u0063\u0068\u0061\u0072\u0029u\u005Bx\u002D32\u005D\u003A'\u005C\u006E'\u0029\u003B\u007D

Equivalent to
void
k(int
x){int[]u={33,33,35,35,36,55,38,39,36,38,56,57,39,48,49,50,48,49,50,51,52,53,54,55,56,57,51,52,53,54,62,62,64,65,66,67,68,69,102,71,72,66,74,75,76,64,78,79,85,81,82,88,90,85,86,87,88,89,90,92,92,94,94,95,96,65,75,67,68,69,102,71,72,95,74,107,76,96,78,79,107,81,82,120,122,117,86,87,120,89,122,117,126,10,126};System.out.print(x>10?(char)u[x-32]:'\n');}

Second program:
void n(int r)throws Throwable{int p=(int)Math.PI;int q=p/p;int t=p*p+q;int w=q+q;int[]g={t*p+w,t*p+w,t*p+q+p,t*p+q+p,t*(q+p),t*p+t-p,t*(q+p)+q,t*(q+p)+q+p,t*(q+p),t*(q+p)+q,t*(q+p)+w,t*(q+p)+p,t*(q+p)+q+p,t*(q+p)+p+w,t*(q+p)+p+p,t*(q+p)+t-p,t*(q+p)+p+w,t*(q+p)+p+p,t*(q+p)+t-p,t*(p+w)+t-w,t*(p+w)+t-q,t*(p+p),t*(p+p)+q,t*p+t-p,t*(q+p)+w,t*(q+p)+p,t*(p+w)+t-w,t*(p+w)+t-q,t*(p+p),t*(p+p)+q,t*(p+p)+p,t*(p+p)+p,t*(t-p)+t-p,t*(t-q)+t-p,t*(t-p)+p,t*(t-q)+t-q,t*t,t*t+q,t*(t-p),t*t+p,t*t+q+p,t*(t-p)+p,t*t+p+p,t*(t-q)+t-w,t*t+t-w,t*(t-p)+t-p,t*(t+q),t*(t+q)+q,t*(t-w),t*(t+q)+p,t*(t+q)+q+p,t*(t-w)+p,t*(t-w)+q+p,t*(t-w),t*(t+q)+t-w,t*(t+q)+t-q,t*(t-w)+p,t*(t+w)+q,t*(t-w)+q+p,t*(t-q)+q,t*(t-q)+q,t*(t-q)+p,t*(t-q)+p,t*t+p+w,t*t+t-q,t*(t-q)+t-p,t*(t-q)+t-w,t*(t-q)+t-q,t*t,t*t+q,t*(t-p),t*t+p,t*t+q+p,t*t+p+w,t*t+p+p,t*(t+q)+w,t*t+t-w,t*t+t-q,t*(t+q),t*(t+q)+q,t*(t+q)+w,t*(t+q)+p,t*(t+q)+q+p,t*(t+q)+p+w,t*(t+q)+p+p,t*(t+w)+p,t*(t+q)+t-w,t*(t+q)+t-q,t*(t+q)+p+w,t*(t+w)+q,t*(t+q)+p+p,t*(t+w)+p,t*(t+w)+q+p,t*(t+w)+p+w,t*(t+w)+q+p};java.io.PrintStream o=(java.io.PrintStream)System.class.getFields()[p/p].get(p);o.print((r<=t)?"}":(char)g[r-t*p-w]);}

Try them out here: https://ideone.com/Q3gqmQ

There are no characters you can pull out of the first program that don't need to be unicode escaped? Can't you pull out some of the numbers? What if you did void x(int z), those are characters in the first charset too

I'm sure it's possible. I could rename some variables and replace all spaces with new lines or tabs. I'll do that when I get home. I just wanted to prove a single language solution first.

FIXED! Pyth - 23 bytes + Pyth - 30 bytes = 53 bytes
oops Fixing error --- please be patient
same ASCII split as Martin's:
1: "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~
2:!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}\n

Prog#1: Test Online
.xhft<zT.Dr\¡b:Z140 2\~

Prog#2: Test Online
C?%KCwy1K?qy5Ky5?qy+1y31Ky5+1K


text:
Asciimation Jumping Jacks
This is my first challenge, so I'm keeping it fairly simple.
If you've ever typed telnet towel.blinkenlights.nl on your command line and pressed enter, you will have experienced the joy of asciimation. Asciimation is, quite simply, doing an animation with ascii art. Today we will be doing a very basic asciimation of a person doing jumping jacks.
There will be two ascii pictures that we will put together into one asciimation.
Number 1:
_o_
 0
/ \

Number 2:
\o/
_0_
<blank line>

Note that the second one has a blank line at the end.
So your program should do these steps:

Clear the console screen.
Print the correct ascii art image.
Set a flag or something so you know to do the other image next time.
Wait a moment (about a second).
Continue at 1.

Rules

Your program must be a (theoretically) infinite loop.
The programming language you use must have been created before this challange was posted.
This is code-golf, so shortest code in bytes wins.
Standard loopholes apply.

Enjoy!

Can there be some spaces on the ?

Does this have to be platform independent because the Linux clear command (clear) is different to the Windows one (cls)

Is the blank line just to explain the positioning? If printing from the top of the screen so that the blank line makes no visible difference, can it be omitted?

@Jakube yes there can be spaces.

@BetaDecay no it does not have to work on all platforms as long as you specify which platform(s) it will work on.

@trichoplax yes. The blank line is just to point out that the head must stay in the same position.

Thanks for clarifying. I think quite a few answers can now be made shorter by omitting the blank line.

Nice question bitsnbites ; )

@CanadianLuke yes. I'll edit it to change that.

I think you should've added an additional stick figure (The straight up position):     o
|0|
| |

You've got another Good Question badge.

CJam, 51 45 42 38 36 bytes
"c\o/
_0_""^[c_o_
 0
/ \^["{_o\6e4m!}g

The above uses caret notation; the sequence ^[ is actually the ASCII character with code point 27.
I've borrowed the escape sequence (^[c) from @DomHastings' answer (with his permission) to save 4 bytes.
Verification
You can recreate the file like this:
base64 -d > jj.cjam <<< ImNcby8KXzBfIiIbY19vXwogMAovIFwbIntfb1w2ZTRtIX1n

To run the code, download the CJam interpreter and execute this:
java -jar cjam-0.6.5.jar jj.cjam

This will work on any terminal that supports console_codes or an appropriate subset.1
How it works
e# Push both jumping jacks on the stack.

"c\o/
_0_"

"^[c_o_
 0
/ \^["

e# When chained together, they contain two occurrences of the string "\ec",
e# which resets the terminal. Encoding the ESC byte in the second string
e# eliminates the need two escape a backslash before the string terminator.

{         e# Do:
  _o      e#   Copy the jumping jack on top of the stack and print the copy.
  \       e#   Swap the order of the jumping jacks.
  6e4m!   e#   Calculate the factorial of 60,000 and discard the result.
          e#   This takes "about a second".
}g        e# Since the discarded factorial was non-zero, repeat the loop.

1 The jumping jacks will look better if you hide the terminal's cursor before running the program. In Konsole, e.g., you can set the cursor's color to match the background color. This has to be done via your terminal's settings, since ^[c resets the terminal.

+1 just for Calculate the factorial of 60,000 and discard the result. This takes "about a second". ;)

Maybe 2Fm* is a good one-byte-shorter alternative to 6e4m! for "senseless operation that returns a truthy value and takes about a second to compute".

@Mauris I had tried something similar with e!, but they seem to get memoized. After the first iteration, poor Jack gets a heart attack...

Pyth - 41 40 39 bytes
.VZ"\x1b[H\x1b[J"@c"_o_
 0
/ \\\o/
_0_"Tb .p9

(I'm counting the \x1b's as one byte since SO destroys special characters).
Clearly doesn't work online since its a) an infinite loop and b) uses terminal escape codes.
#                Infinite loop
 "..."           Print escape sequences to clear screen
 @               Modular indexing
  c     T        Chop at index ten into the constituent frames
   "..."         Frames 1 & 2 concatenated (Pyth allows literal newlines in strings)
  ~              Post assign. This is an assign that returns the old value.
   h             Increment function. Putting it after an assign makes it augmented assign.
   Z             Variable auto-initialized to zero.
 .p9             Permutations(range(9), 9). Takes about a second on my machine.

I was surprised to find out that augmented-assign worked with post-assign.  Pyth is awesome.

use .V0 as infinite loop

You may be able to save a byte now that the OP has confirmed that the blank line doesn't need to be explicitly printed

@Jakube that does not seem to save anything.

You explanation doesn't correspond to your code :P

QBasic, 58 54 bytes
Tested on QB64 and at Archive.org.
CLS
?"_o_
?0
?"/ \
SLEEP 1
CLS
?"\o/
?"_0_
SLEEP 1
RUN

The right language for the problem can be surprisingly competitive, even if it is usually verbose. The ? shortcut for PRINT helps too, of course. CLS is clear screen; RUN without arguments restarts the program, which is the shortest way to get an infinite loop.
The only other trick here is printing 0 for the midsection of the first picture. QBasic puts a space in front of (and after) nonnegative numeric values when it prints them, resulting in  0 . Saved 2 characters over " 0.
I may also point out that the delay in this code is literally a second, and is not machine-dependent. ;^P

I remember being annoyed by the surrounding spaces when printing numbers in various versions of BASIC. Nice to see there is a good use for it...

Perl (*nix), 54 bytes
sleep print"\x1bc",$-++%2?'\o/
_0_
':'_o_
 0
/ \
'while 1

(\x1b is counted as 1 byte but escaped for easier testing.) The above has been tested with Bash and shortened by another byte thanks to @Dennis!
Perl (Windows), 56 bytes
sleep print"\x1b[2J",$-++%2?'\o/
_0_
':'_o_
 0
/ \
'while 1

Thanks to @Jarmex for his testing and advice!

Afraid that doesn't work on Windows, but you can get away only 1 byte more with: print"@[2J", replacing the @ inside the quotes with ASCII 27 (for testing purposes, print"\033[2J" might be easier).

You can replace \e with a literal ESC byte. -- Would you mind if I use the \ec trick in my answer?

@Dennis of course, because "\e" is just a shortcut for that anyway. Please, go ahead!

Javascript (ES6), 109 93 79 70 bytes + HTML, 12 10 bytes = 120 106 91 80 bytes
Fairly straightforward. Uses template strings to store the images, and toggles a boolean value to determine which to use.
NOTE: This solution may not be valid, as it does not actually use a console. However, I don't believe it's possible to clear a browser console using JS, at least not while using Firefox.

a=!1,setInterval(_=>O.innerHTML=(a=!a)?`_o_
 0
/ \\`:`\\o/
_0_`,1e3)

Code snippet does nothing (Chrome @ Windows).

Please, use proper language identification.

@orlp Code creates the animated man. (Chrome @ Windows). This is GUI based rather than console based however. Might not be considered valid as such.

On my computer, this works fine in Firefox but not in Chrome, so I guess you should label it as ECMAScript 6 to avoid confusion. 2. If you put
 in the HTML part, you don't need the
 tags in the code.

Or, better yet, get rid of the HTML and replace document.getElementById`a`  with document.body.

You can use 1e3 instead of 999 and be precise without using any extra bytes.

You can also use document.children[0] instead of document.getElementById\a`and remove the id from the` tag.

document.all[0] might also work.

May I ask what a!=a does?

@BetaDecay It's a=!a. Toggling it changes which stickman is printed.

@undergroundmonorail Oh I see. That's clever :D

@darkness3560 but you are not requested to be precise: about a second

To add to all the contributions, using a.a as your flag instead of a, and using that implicit reference to the element with id=a you should be able to save more bytes too!

Wow, thanks for all the tips, guys! Sorry for not labeling as ES6; I was tired and on my way to bed.

You may be able to save a byte now that the OP has confirmed that the blank line doesn't need to be explicitly printed (as long as you can make the head stay in the same place)

I got 87 bytes by making the HTML
 and doing document.all[4]. This lets you get rid of the wrapper string and just make it innerHTML=a?`...`:`...`}.

Then output in the html also doesn't contain a trailing newline

This has stopped working for me on Chrome

@BetaDecay It was working for me right before I posted it, but for some reason it stopped. Fixed now.

@NinjaBearMonkey Thanks for the document.all[4] suggestion! Removing the id reference from the
 tag seems to make it quit working for me, running Firefox 33.

@Justin I guess it's not entirely possible in a web browser then, at least not Firefox. EDIT: It's possible in Chrome; I'll see about posting another solution.

Bash, 86 84 bytes
while sleep 1;do printf "\e[2J_o_\n 0\n/ \\";sleep 1;printf "\r\e[2J\o/\n_0_\n";done

Dash, 67 bytes
Also bash, ksh, zsh, ash, yash and probably many more besides.  While it apparently works in these other shells, their own features and idiosyncrasies may allow for further golfing.  I'll leave that as an exercise for the reader.
Notably not fish or tcsh.
f(){ clear;echo "$1";sleep 1;f "$2" "$1";};f '_o_
 0
/ \' '\o/
_0_'

Try it online! (with STDERR issue -- see Caveats)
Try it online! (with visible escape codes issue -- see Caveats)
How it works
Hopefully fairly self explanatory, even so:
Set up a function f which

Clears screen
Prints contents of $1
Sleeps 1 second
Calls f passing $1 and $2 in reverse order.  This means the next iteration will display the "other" glyph before flipping them again... and so on.

Outside of the function is the initial call to f with literal depictions of the two character glyphs as two arguments.
Caveats
TIO's terminal implementation doesn't handle the clear well -- produces an error to STDOUT.  If you add export TERM=vt100 as a header the error stops and it displays the literal escape string.  This is a feature/limitation of TIO, not an issue with my submission.  I've included links to both for reference.
Code should work as intended in a "proper" terminal.
The recursion will eventually cause it to fail.  Tried a soak test with sleep 0 in a Docker container and it threw a Segmentation Fault within a minute.  Adding a trivial counter, which may or may not have quantum implications, it managed ~15000 iterations in my environment. So like 4 hours with the sleep -- and who's going to watch it that long? :-)
But I'd still argue that this complies with "theoretically" infinite, because it could go forever if it had "theoretically" infinite resources.  That's my story and I'm sticking to it.

awk - 95 92 86 84 83
END{
    for(;++j;)
        system("clear;printf '"(j%2?"_o_\n 0\n/ \\":"\\o/\n_0_")"';sleep 1")
}

Nice workout :D Just wondered if this was doable. No prices to gain though... ;)
If someone wants to test this: after you run the program you have to press Ctrl+D (end of input) to actually start the END block. To terminate it I have to use Ctrl+Z.
I also have this, which is only 74 bytes, but it starts with pausing a second which isn't the wanted behaviour I think
END{
    for(;1;print++j%2?"_o_\n 0\n/ \\":"\\o/\n_0_")
        system("sleep 1;clear")
}

Does sleep measure intervals of three seconds?

Oh my god. thanks for the hint :) Or if it wasn't a hint: No, this only slept 0.33 seconds.

I don't know awk but it seemed likely it would measure in seconds. :)

It just looks so more funny if it's moving faster, that I forgot about the golfing there ;D

the sleep command is not awk, it's bash, btw

Python 2, 99 bytes
Runs on Windows
import os,time
g=0
while 1:os.system("cls");print["\\o/\n_0_","_o_\n 0 \n/ \\"][g];time.sleep(1);g=~g

For UNIX machines, add two bytes:
import os,time
g=0
while 1:os.system("clear");print["\\o/\n_0_","_o_\n 0 \n/ \\"][g];time.sleep(1);g=~g

JavaScript ES6, 100 95 bytes
(f=_=>{console.log(_?`_o_
 0
/ \\`:`\\o/
_0_`)
(b=setTimeout)(q=>(clear(),b(b=>f(!_))),1e3)})()

Logs to the console. Tested on Safari Nightly

Batch, 151 130 118 bytes
cls
@echo _o_
@echo  0
@echo / \
@PING -n 2 127.0.0.1>NUL
cls
@echo \o/
@echo _0_
@PING -n 2 127.0.0.1>NUL
%0

You may be able to save a few bytes now that the OP has confirmed that the blank line doesn't need to be explicitly printed

You should be able to golf off 12 characters by using @PING 127.0.0.1 -n 2>NUL instead. Ping defaults to waiting about a second between attempts, so this is within a few milliseconds of being accurate, plenty close enough for this challenge. Reference

golfed off 12 bytes thanks to TimmyD

CBM 64 BASIC V2, 121 119 112 117 bytes
2?CHR$(147)+"\o/":?" 0":?"/ \"
3GOSUB7
4?CHR$(147)+"_o_":?"_0_"
5GOSUB7
6RUN
7A=TI
8IFTI-A<60THENGOTO8
9RETURN

Does ?CHR$(147) clear the screen? If so you may be able to save 2 bytes now that the OP has confirmed that the blank line doesn't need to be explicitly printed

This doesn't produce the first animation frame (i.e., where the arms are level).

you're right... I'm going to fix it!

Batch - 82 bytes
Edit: Muted the timeout command and removed the extra newline.
cls&echo _o_&echo  0&echo / \&timeout>nul 1&cls&echo \o/&echo _0_&timeout>nul 1&%0

I've seen 2 other similar batch answers so I didn't really want to post this, but this is my first ever golf.

But a bare timeout 1 will put a lot of unrequested output on the console

True, I had extra output. Edited.

maybe >mul it's type error, or maybe you don't know what nul is. https://en.wikipedia.org/wiki/Null_device

@edc65 The backdraws of copy-paste and not testing. Thank you!

BBC BASIC, 75 bytes
Note that tokenisation pulls it down to 75 bytes. The whitespace is added in by the IDE.
      g=0
   10 IFg=0THENPRINT"\o/":PRINT"_0_"ELSEPRINT"_o_":PRINT" 0 ":PRINT"/ \"
      g=1-g:WAIT 100CLS:GOTO10

Javascript (ES6), 82 bytes
A modification of my previous answer that uses the console. Works partially in Firefox, but only clears the console in Chrome, AFAIK.

a=!0,c=console,setInterval(_=>c.log(c.clear(a=!a)|a?`_o_
 0
/ \\`:`\\o/
_0_`),1e3)

As always, suggestions welcome!

Love it! I notice via this that Chrome is executing ES6 for me now as well!

@DomHastings I've never developed in Chrome before, but I'd heard it didn't support ES6 by default, so I was just as surprised as you! :)

Julia, 70 bytes
(on Windows, by replacing clear with cls, thanks to undergroundmonorail)
n(i=1)=(sleep(1);run(`cls`);print(i>0?"_o_
 0
/ \\":"\\o/
_0_");n(-i))

On Linux, 72 bytes
n(i=1)=(sleep(1);run(`clear`);print(i>0?"_o_
 0
/ \\":"\\o/
_0_");n(-i))

This uses actual newlines rather than \n to save a byte; otherwise, the i is either 1 or -1 as the "flag", and it uses recursion to achieve the infinite loop. Call it as either n(1) or just n().
Also, run(`clear`)/run(`cls`) uses a shell command to clear the window, because Julia doesn't have a built-in window-clear command.

If you run this on windows you save two bytes by changing clear to cls (I'm assuming, I don't know anything about Julia).

@undergroundmonorail - Thanks, but I use Ubuntu, cls doesn't work. Hopefully Julia decides to implement a real terminal-clearing function.

@GlenO On Windows cls works (see my answer)

Windows Batch, 83 89
Edit removed the empty line after the clarification by OP
@cls&echo _o_&echo  0&echo./ \&timeout>nul 1&cls&echo \o/&echo _0_&timeout>nul 1&%0

If you get rid of the empty line in the jumping man (that cannot be seen anyway), the score is 83
Note: timeout is not present in Windows XP. It works in Vista or newer versions. Moreover timeout is not precise to the second, so it's a perfect choice to implement step 4 (Wait a moment (about a second))

JavaScript, 92 91 89 bytes
x=0;setInterval(function(){console.log("\033c"+["_o_\n 0\n/ \\","\\o/\n_0_"][x^=1])},1e3)

No ES6 features (but would be significantly shorter with them)
Works with Node.js on Linux (don't know about other environments)
Partially works in Chrome's console (c is shown instead of clearing the console, breaking the output)

Removing "\033c"+ from the above code, the following works in the browser, but doesn't clear the console.

x=0;setInterval(function(){console.log(["_o_\n 0\n/ \\","\\o/\n_0_"][x^=1])},1e3)

Impressive work! Using ES6 features, I get 77: x=0;setInterval(_=>console.log("\033c"+[`_o_<line break> 0<line break>/ \\`,`\\o/<line break>_0_`][x^=1]),1e3) For some reason, JS won't let me pass console.log as the function and the ASCII man as an extra param.

@ETHproductions Thanks! I thought about doing it in ES6, but having never used it and not having io.js installed I decided not to. As far as not being able to pass console.log to setInterval, the reason is that we're not passing the function, but calling it. It would be evaluated before setInterval was called, and since console.log doesn't return, it would essentially be passing undefined to setInterval. Make sense? And thanks for shortening it!

I understand what you're saying, but according to this page, this code should work: x=0;setInterval(console.log,1e3,"\033c"+[o 0/ \,\o/0][x^=1]) In fact, it doesn't bring up an error if I replace console.log with alert.

Ah, I get what you're saying. I think the problem though is that we need to log something different each time, but "\033c"+[\o 0/ `,\o/0`][x^=1]gets evaluated before the call tosetInterval`.

CBM BASIC v2.0 (68 characters)
0?"S_o_q||0q||N M":goS1:?"SMoN":?"_0_":goS1:gO
1wA161,255,pE(161):reT

The above requires some explanation, since Stack Exchange markup doesn't properly represent PETSCII characters:

The program is shown here for convenience in lowercase, but can and should be entered and run in uppercase mode on a Commodore 64.
The first and third "S" characters are actually in reverse video, and produced by pressing the CLR key (SHIFT+HOME).
The "q" characters are actually in reverse video, and produced by pressing the down cursor (CRSR ⇓).
The "|" characters are actually in reverse video, and produced by pressing the left cursor (SHIFT+CRSR ⇒).

I will try it later. PETSCII always looks more beautiful than ASCII.

Very good, the WAIT is especially useful, here is a video about it from my favourite YouTube channel 8-BIT Show and Tell -> https://youtu.be/iQbBlH6tHkI

TI-Basic, 58 56 bytes
While 1
ClrHome
If not(Ans
Disp "_o_"," 0","/ \
If Ans
Disp "\o/","_0_"
not(Ans
If dim(rand(70
End

-2 bytes for assuming that the code is run on a fresh interpreter.

Ruby, 79 bytes
k=!0;loop{puts((k)?"\e[H\e[2J_o_\n 0\n/ \\":"\e[H\e[2J\\o/\n_0_");k=!k;sleep 1}

Requires escape codes.

Forth, 86 bytes
Requires GNU Forth for the escaped strings. To run in a non-GNU Forth, just change S\" to S", and the escaped characters won't print correctly.
: P PAGE TYPE CR 999 MS ;
: R BEGIN S\" \\o/\n_0_" P S\" _o_\n 0 \n/ \\" P 0 UNTIL ; R

beeswax, 119 113 bytes
ph0`J2[`}ghq'-<gh0N}`0`}gN`/o\`Ngh0`J`<
>g}`o`}N` `0>'d`0 `N`/ \`0hg>-'phg}`[2`b
dF1f+5~Zzf(.FP9f..F3_#     d   <

Explanation of the important parts of the program:
left to right  right to left

3FBf   or       fBF3          27       ASCII code for (esc)
3             [x,x,3]•        set lstack 1st to 3
 F            [3,3,3]•        set lstack to 1st
  B           [3,3,27]•       1st=1st^2nd
   f                          push lstack 1st on gstack
——————
9PF.(f   or    f(.FP9         102400   counter to roughly match a wait time
                                       of 1 s on my i5 2410M Laptop
9             [x,x,9]•        set lstack 1st to 9
 P            [x,x,10]•       increment 1st
  F           [10,10,10]•     set lstack to 1st
   .          [10,10,100]•    1st=1st*2nd
    (         [10,10,102400]• 1st=1st<<2nd (100<<10=102400, arithmetic shift left)
     f                        push lstack 1st on gstack
——————
zZ~5+f   or    f+5~Zz         95       ASCII for '_'
z             [0,0,0]•        initialize lstack to zero
 Z            [0,0,90]•       get value from relative coordinate (0,0),
                              which is the location of `Z` itself, ASCII(Z)=90
  ~           [0,90,0]•       flip 1st and 2nd lstack values
   5          [0,90,5]•       set lstack 1st to 5
    +         [0,90,95]•      1st = 1st+2nd
     f                        push lstack 1st on gstack

The f’s push the values on the gstack (global stack) for later use. These values are accessed by the 0gh (or the mirrored hg0) and hg (gh) instructions. h rotates the gstack upwards, g reads the top value of gstack and pushes it onto the lstack (local stack) of the bee (instruction pointer).
}`o`}N` 0 `N`/ \`                      sequence to print the standing man

N`\o/`Ng}`0`}N                         sequence to print the jumping man

}`[2J`                        equivalent to the ANSI escape sequence (esc)[2J
                              to clear the screen
>-'p  or >-'q  or >  p        loop for counting down (wait 1 s)
d  <      b  <    d'-<

In-depth explanation follows later, if needed. Maybe with animation.

Noodel, noncompeting 24 bytes
Noncompeting because Noodel was born after the challenge was created:)
”ṛ|ọBCḊCBCḣ“\o/¶_0_ḷėçḍs

Try it:)
How it works
”ṛ|ọBCḊCBCḣ              # Creates a string that gets decompressed into "_o_¶¤0¤¶/¤\" and places it into the pipe.
           “\o/¶_0_      # Creates a string and places it into the pipe.
                   ḷ     # Unconditionally loop the code up to a new line or end of program.
                    ė    # Takes what is in the front of the pipe and puts it into the back.
                     ç   # Clears the screen and prints.
                      ḍs # Delays for one second.

There currently is not a version of Noodel that supports the syntax used in this challenge. Here is a version that does:
24 bytes
\o/¶_0_ _o_¶¤0¤¶/¤\ḷçėḍs

Nim, 107 bytes
import os,terminal
var f=0
while 0<1:eraseScreen();sleep 999;echo ["_o_\n 0 \n/ \\","\\o/\n_0_\n"][f];f=1-f

Don't Try it online!

source: Stack Exchange

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

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

sort: votes


text:
Print the character names
Every Unicode character has a name, like "LATIN CAPITAL LETTER A". A Unicode character name may contain only uppercase letters, white spaces, and the minus sign.
Write a program that reads a text and outputs the names of each character on a new line. For example, if the input were "Hello, World!", the output would be
LATIN CAPITAL LETTER H
LATIN SMALL LETTER E
LATIN SMALL LETTER L
LATIN SMALL LETTER L
LATIN SMALL LETTER O
COMMA
SPACE
LATIN CAPITAL LETTER W
LATIN SMALL LETTER O
LATIN SMALL LETTER R
LATIN SMALL LETTER L
LATIN SMALL LETTER D
EXCLAMATION MARK

Input should come from a file or from user input, not just a string in code.
Output should be written to a file or stdout or printed to the screen.
Internet and external libraries are not allowed, all necessary data should be in the code.
Assume that the input only contains printable ASCII characters in the Basic Latin code range 32-126. You can ignore a trailing newline.
All programming languages allowed. Shortest code in bytes wins.

The official Unicode character names can be found here. Other sources:

http://www.w3schools.com/charsets/ref_utf_basic_latin.asp
http://www.ssec.wisc.edu/~tomw/java/unicode.html#x0000

This is my first question so I'd appreciate any suggestion if this can be improved.
For the purpose of this challenge the list below shall be normative.
    32  0020        SPACE
!   33  0021        EXCLAMATION MARK
"   34  0022        QUOTATION MARK
#   35  0023        NUMBER SIGN
$   36  0024        DOLLAR SIGN
%   37  0025        PERCENT SIGN
&   38  0026        AMPERSAND
'   39  0027        APOSTROPHE
(   40  0028        LEFT PARENTHESIS
)   41  0029        RIGHT PARENTHESIS
*   42  002A        ASTERISK
+   43  002B        PLUS SIGN
,   44  002C        COMMA
-   45  002D        HYPHEN-MINUS
.   46  002E        FULL STOP
/   47  002F        SOLIDUS
0   48  0030        DIGIT ZERO
1   49  0031        DIGIT ONE
2   50  0032        DIGIT TWO
3   51  0033        DIGIT THREE
4   52  0034        DIGIT FOUR
5   53  0035        DIGIT FIVE
6   54  0036        DIGIT SIX
7   55  0037        DIGIT SEVEN
8   56  0038        DIGIT EIGHT
9   57  0039        DIGIT NINE
:   58  003A        COLON
;   59  003B        SEMICOLON
<   60  003C        LESS-THAN SIGN
=   61  003D        EQUALS SIGN
>   62  003E        GREATER-THAN SIGN
?   63  003F        QUESTION MARK
@   64  0040        COMMERCIAL AT
A   65  0041        LATIN CAPITAL LETTER A
B   66  0042        LATIN CAPITAL LETTER B
C   67  0043        LATIN CAPITAL LETTER C
D   68  0044        LATIN CAPITAL LETTER D
E   69  0045        LATIN CAPITAL LETTER E
F   70  0046        LATIN CAPITAL LETTER F
G   71  0047        LATIN CAPITAL LETTER G
H   72  0048        LATIN CAPITAL LETTER H
I   73  0049        LATIN CAPITAL LETTER I
J   74  004A        LATIN CAPITAL LETTER J
K   75  004B        LATIN CAPITAL LETTER K
L   76  004C        LATIN CAPITAL LETTER L
M   77  004D        LATIN CAPITAL LETTER M
N   78  004E        LATIN CAPITAL LETTER N
O   79  004F        LATIN CAPITAL LETTER O
P   80  0050        LATIN CAPITAL LETTER P
Q   81  0051        LATIN CAPITAL LETTER Q
R   82  0052        LATIN CAPITAL LETTER R
S   83  0053        LATIN CAPITAL LETTER S
T   84  0054        LATIN CAPITAL LETTER T
U   85  0055        LATIN CAPITAL LETTER U
V   86  0056        LATIN CAPITAL LETTER V
W   87  0057        LATIN CAPITAL LETTER W
X   88  0058        LATIN CAPITAL LETTER X
Y   89  0059        LATIN CAPITAL LETTER Y
Z   90  005A        LATIN CAPITAL LETTER Z
[   91  005B        LEFT SQUARE BRACKET
\   92  005C        REVERSE SOLIDUS
]   93  005D        RIGHT SQUARE BRACKET
^   94  005E        CIRCUMFLEX ACCENT
_   95  005F        LOW LINE
`   96  0060        GRAVE ACCENT
a   97  0061        LATIN SMALL LETTER A
b   98  0062        LATIN SMALL LETTER B
c   99  0063        LATIN SMALL LETTER C
d   100 0064        LATIN SMALL LETTER D
e   101 0065        LATIN SMALL LETTER E
f   102 0066        LATIN SMALL LETTER F
g   103 0067        LATIN SMALL LETTER G
h   104 0068        LATIN SMALL LETTER H
i   105 0069        LATIN SMALL LETTER I
j   106 006A        LATIN SMALL LETTER J
k   107 006B        LATIN SMALL LETTER K
l   108 006C        LATIN SMALL LETTER L
m   109 006D        LATIN SMALL LETTER M
n   110 006E        LATIN SMALL LETTER N
o   111 006F        LATIN SMALL LETTER O
p   112 0070        LATIN SMALL LETTER P
q   113 0071        LATIN SMALL LETTER Q
r   114 0072        LATIN SMALL LETTER R
s   115 0073        LATIN SMALL LETTER S
t   116 0074        LATIN SMALL LETTER T
u   117 0075        LATIN SMALL LETTER U
v   118 0076        LATIN SMALL LETTER V
w   119 0077        LATIN SMALL LETTER W
x   120 0078        LATIN SMALL LETTER X
y   121 0079        LATIN SMALL LETTER Y
z   122 007A        LATIN SMALL LETTER Z
{   123 007B        LEFT CURLY BRACKET
|   124 007C        VERTICAL LINE
}   125 007D        RIGHT CURLY BRACKET
~   126 007E        TILDE

Hi, I've gone ahead and edited your question, roll back if you disagree. You don't need more sources of the information, you need one, normative version in the question, to avoid issues with discrepancies. I picked http://www.ssec.wisc.edu/~tomw/java/unicode.html#x0000 as it was the most concise. Other than that, +1

Thanks for the edit @steveverrill, I was too lazy to do that myself.

Apparently the values are available as part of Windows, in C:\Windows\System32\getuname.dll. Does this also count as an "external library", even if it's built in to Windows?

I just learned the word solidus.

I’m voting to close this question because, as discussed in chat here, it's unclear what exactly constitutes an "external library".

Java - 113 bytes (152 if read from command line)
Edit: removed useless curly brackets.
Edit2: removed unnecessary variable.
Edit3: Instead of Character.getName() I use c.getName().
Edit4: Passing string as command line argument.
With command line argument (113 bytes):
class Z{public static void main(String[]x){for(Character c:x[0].toCharArray())System.out.println(c.getName(c));}}

With read line (152 bytes):
class Z{public static void main(String[]x){for(Character c:new java.util.Scanner(System.in).nextLine().toCharArray())System.out.println(c.getName(c));}}

Java has everything needed. I'm sure this could be golfed down.

Damn! A builtin! In order to make this an interesting challenge, I would consider this to be in non-compliance with "all necessary data should be in the code." Very clever, though.

@steveverrill Oh well :) . I've seen another challenge where common lisp did something similar (counting from one to 100 if I remember right).

Wow, this time Java has the chance to beat a lot of golfing languages.

Alternative Java 8 solution: x[0].chars().forEach(i->System.out.println(Character.getName(i))); This saves 2 chars compared to the command-line argument solution (by replacing the for-loop).

Or maybe x[0].chars().map(' '::getName).forEach(System.out::println);

Python 3, 56 bytes
Uses a built-in function unicodedata.name(), so this may be non-competent. The Java answer did it similarly, so I thought it was at least worth posting.
from unicodedata import*
for i in input():print(name(i))

I've also wanted to post one in python but my java answer was cheaty enough :) .

Surely for i in input():print(unicodedata.name(i)) is shorter?

@Eric No. You have to import unicodedata, so that's longer.

Same length using lambda+map

JavaScript (ES6) 594 618 626
Note I could save ~30 bytes compressing the long string with atob/btoa, but the utf8 character above '~' are not well accepted by the Stack Exchange post editor. I prefer to keep a running snippet instead.
Edit 8 chars saved thx @Ypnypn
Obvious compression of repeated words. The newline inside backticks is significant and counted.
Test running the snippet in Firefox.

// TEST SUITE
// for testing purpose, redefine alert() to write inside the snippet body
alert=x=>O.innerHTML=x
// for testing purpose, redefine prompt() to have a default text containing all characters
_prompt=prompt
prompt=(i,s)=>{
  for(s='',i=32;i<127;i++)s+=String.fromCharCode(i);
  return _prompt("Insert your message or keep the default",s);
}

// That's the answer code:
z='SPACE/EXCLAMA0QUOTA0NUMBER1DOLLAR1PERCENT1AMPERSAND/APOSTROPHE3242ASTERISK/PLUS1COMMA/HYPHEN-MINUS/FULL STOP/78ZERO8ONE8TWO8THREE8FOUR8FIVE8SIX8SEVEN8EIGHT8NINE86SEMI6LESS-THAN1EQUALS1GREATER-THAN1QUES0COMMERCIAL AT3SQUARE5REVERSE 7/4SQUARE5CIRCUMFLEX9/LOW LINE/GRAVE93CURLY5VERTICAL LINE/4CURLY5TILDE'.replace(/\d/g,c=>'TION MARK/, SIGN/,PARENTHESIS/,/LEFT ,RIGHT , BRACKET/,COLON/,SOLIDUS,/DIGIT , ACCENT'.split`,`[c]).split`/`,alert([...prompt()].map(c=>(q=c.charCodeAt()-32)<33?z[q]:q<59?'LATIN CAPITAL LETTER '+c:q<65?z[q-26]:q<91?'LATIN SMALL LETTER '+c.toUpperCase():z[q-52]).join`
`)

R, 54 bytes 62
library(Unicode)
cat(u_char_name(utf8ToInt(scan(,""))),sep="\n")

Edit: per @flodels comment, I need to read it from connection first, so had to add scan. This is also probably non-competent solution according to all the rules.
Usage
> cat(u_char_name(utf8ToInt(scan(,""))),sep="\n")
1: 'Hello, World!'
2:
Read 1 item
LATIN CAPITAL LETTER H
LATIN SMALL LETTER E
LATIN SMALL LETTER L
LATIN SMALL LETTER L
LATIN SMALL LETTER O
COMMA
SPACE
LATIN CAPITAL LETTER W
LATIN SMALL LETTER O
LATIN SMALL LETTER R
LATIN SMALL LETTER L
LATIN SMALL LETTER D
EXCLAMATION MARK

You can also wrap it up into a function for more convenient usage
UNI <- function(x)cat(paste0(u_char_name(utf8ToInt(x)),"\n"))

Then, the usage is just
UNI("Hello, World!")

Your byte count is correct :)

And welcome to PPCG! :D

Good for you having a built in for the task, but the output is not what is requested - 4 columns table instead of 1 column table. I think you should add some core to obtain the correct output

@edc65 that easy to fix, I just thought of it as a bonus.

@edc65 fixed it.

+1 and welcome to PPCG. Depending on the question, kindly consider adding function(x) or a function reading from stdin like scan or readLines, otherwise this is stretching the rules a bit.

function(x)cat(Unicode::u_char_name(utf8ToInt(x)),sep="\n") would be an acceptable solution for example.

@flodel I already have that... You are right regarding reading from connection though, need to add that too.

Well, you don't have function(x) in your byte count... See this for example: http://codegolf.stackexchange.com/a/55702/5163. Or look at other people's R answers, you'll get the idea (and learn some of the tricks too :-)

@flodel where is it written that this should be a function? Most of the answers here aren't wrapped into functions neither

Let us continue this discussion in chat.

Perl 5 + -M5.10.0 -MCompress::Zlib -00F, 459 bytes
@d=split/,/,inflateInit->inflate(<DATA>);say$d[-32+ord]for@F
__END__
x.m.or.0.......!.#....I&I.......v......0O.)q.g.*...PH.q....u..k...85.:sgM\.8P..Fu......r..=tR...e......9k.{.2.xUj.P\_}..Qr...!..[..$O.2.%{.bmgl.....|U.tnC...K-?..;.3..1.\s......K>.....T..y.$v.E.....6.....JaM.$.G!.5$...A..5.....y...g....s.....Y0...s..1o...av.............;..)..R..G...8..t...K)k.e.~.J..Gi. .r\.v>.........!L.'..pF. \.f......aAX.6....P..BG8......._..
....W...s"9.t....
.2......

Try it online!
Explanation
Pretty straight-forward, @d is constructed from Zlib compressed data (stored after __END__), which is just the compressed list of raw comma separated character names that is inflated, split on , and can be indexed via ord - 32. -00 sets the input record separator to \x00 (NUL) which slurps the __DATA__ in one call to <DATA> instead of having it split on newline. @F is initialised with the input data as an array (via -F), which is iterated over and the corresponding index from @d is output.

Perl 5 + -M5.10.0 -F, 672 bytes
$b=BRACKET;say+(SPACE,<"{EXCLAMATION,QUOTATION} MARK">,<"{NUMBER,DOLLAR,PERCENT} SIGN">,AMPERSAND,APOSTROPHE,<"{LEFT,RIGHT} PARENTHESIS">,ASTERISK,'PLUS SIGN',COMMA,'HYPHEN-MINUS','FULL STOP',$s=SOLIDUS,<"DIGIT {ZERO,ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE}">,<{,SEMI}COLON>,<"{LESS-THAN,EQUALS,GREATER-THAN} SIGN">,'QUESTION MARK','COMMERCIAL AT',<"LATIN CAPITAL LETTER {A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z}">,"LEFT SQUARE $b","REVERSE $s","RIGHT SQUARE $b",'CIRCUMFLEX ACCENT','LOW LINE','GRAVE ACCENT',<"LATIN SMALL LETTER {A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z}">,"LEFT CURLY $b",'VERTICAL LINE',"RIGHT CURLY $b",TILDE)[-32+ord]for@F

Try it online!
Explanation
A (marginally) less boring version of the script without tool-based compression, mostly taking advantage of globs.

C, 644 656
Full program, reading from standard input
Test on Ideone
This is a porting of my JavaScript answer to C. The C language is good at manipulating single characters as numbers (no need of .toUpperCase and the like), but it's weaker in string manipulation.
char*s,*p,*q,b[999],*d=b+99,c,*l[129];
main(k){for(k=32,p="/SPACE/EXCLAMAaQUOTAaNUMBERbDOLLARbPERCENTbAMPERSAND/APOSTROPHEdcecASTERISK/PLUSbCOMMA/HYPHEN-MINUS/FULL STOP/hiZEROiONEiTWOiTHREEiFOURiFIVEiSIXiSEVENiEIGHTiNINE/gSEMIgLESSnbEQUALSbGREATERnbQUESaCOMMERCIAL ATdkfREVERSE h/ekfCIRCUMFLEXj/LOWmGRAVEjdlfVERTICALmelfTILDE/";
c=*p;p++)c>96?q?(p=q,q=0):(q=p,p=strchr("aTION MARK/b SIGN/cPARENTHESIS/d/LEFT eRIGHT f BRACKET/gCOLON/hSOLIDUSi/DIGIT j ACCENTkSQUARElCURLYm LINE/n-THANz",c)):c-47?*d++=c:(*d++=0,l[k++]=d);
for(;~(k=getchar());puts(k<65?l[k]:(k&31)<27?b:l[k<97?k-26:k-52]))sprintf(b,"LATIN %s LETTER %c",k<91?"CAPITAL":"SMALL",k&95);}

Less golfed
char *all = "/SPACE/EXCLAMAaQUOTAaNUMBERbDOLLARbPERCENTbAMPERSAND/APOSTROPHEdcecASTERISK/PLUSbCOMMA/HYPHEN-MINUS/FULL STOP/hiZEROiONEiTWOiTHREEiFOURiFIVEiSIXiSEVENiEIGHTiNINE/gSEMIgLESSnbEQUALSbGREATERnbQUESaCOMMERCIAL ATdkfREVERSE h/ekfCIRCUMFLEXj/LOWmGRAVEjdlfVERTICALmelfTILDE/";
char *subs = "aTION MARK/b SIGN/cPARENTHESIS/d/LEFT eRIGHT f BRACKET/gCOLON/hSOLIDUSi/DIGIT j ACCENTkSQUARElCURLYm LINE/n-THANz";

main(int k)
{
    char c, *s, *p, *q=0,
    b[999], // work buffer
    *d = b+99, // first part of buffer is used later
    *l[129]; // characters descriptions (used 32 to 126)

    // Uncompress the descriptions of all char except letters
    for(k = 32, p = all; c = *p; ++p)
    {
       c >= 'a' // substitution word are marked as lowercase letters
        ? q
           ? (p = q, q = 0)
           : (q = p, p = strchr(subs, c))
        : c != '/'
           ? *d++ = c
           : (*d++ = 0, l[k++] = d); // end char description
    }
    // Scan the input string and print each char description
    for(; (k=getchar()) != -1; )
    {
       sprintf(b,"LATIN %s LETTER %c", k<91 ? "CAPITAL":"SMALL", k & 95);
       puts( k<65 ? l[k] : k<91 ? b : k<97 ? l[k-26] : k<123 ? b : l[k-52]);
    }
}

Perl 6, 21 bytes
I did not see a rule specifically against using a built-in method for getting the unicode names.
(Also the Java answer which is the currently highest voted one does the same)
.say for get.uninames

Perl 6 is weird. I love it, though.

awk - 794 739

     1  LATIN CAPITAL LETTER B
     2  LATIN CAPITAL LETTER E
     3  LATIN CAPITAL LETTER G
     4  LATIN CAPITAL LETTER I
     5  LATIN CAPITAL LETTER N
     6  LEFT CURLY BRACKET
     7  LATIN SMALL LETTER S
     8  LATIN SMALL LETTER P
     9  LATIN SMALL LETTER L
    10  LATIN SMALL LETTER I
    11  LATIN SMALL LETTER T
    12  LEFT PARENTHESIS
    13  QUOTATION MARK
    14  LATIN SMALL LETTER I
    15  COMMA
    16  LATIN CAPITAL LETTER L
    17  LATIN SMALL LETTER V
    18  COMMA
    19  LATIN CAPITAL LETTER S
    20  LATIN SMALL LETTER V
    21  COMMA
    22  LATIN SMALL LETTER A
    23  LATIN SMALL LETTER X
    24  COMMA
    25  CIRCUMFLEX ACCENT
    26  LATIN SMALL LETTER X
    27  COMMA
    28  LEFT SQUARE BRACKET
    29  LATIN SMALL LETTER X
    30  COMMA
    31  LATIN CAPITAL LETTER Q
    32  COMMA
    33  LATIN CAPITAL LETTER O
    34  COMMA
    35  LATIN SMALL LETTER T
    36  LATIN CAPITAL LETTER K
    37  COMMA
    38  LATIN SMALL LETTER C
    39  LATIN CAPITAL LETTER K
    40  COMMA
    41  LATIN CAPITAL LETTER V
    42  COMMA
    43  LATIN SMALL LETTER Q
    44  LATIN SMALL LETTER X
    45  COMMA
    46  LATIN SMALL LETTER G
    47  COMMA
    48  LATIN CAPITAL LETTER I
    49  COMMA
    50  LATIN SMALL LETTER W
    51  LATIN SMALL LETTER U
    52  COMMA
    53  LATIN CAPITAL LETTER X
    54  COMMA
    55  LATIN SMALL LETTER B
    56  LATIN SMALL LETTER Y
    57  COMMA
    58  LATIN SMALL LETTER B
    59  LEFT CURLY BRACKET
    60  COMMA
    61  LATIN SMALL LETTER B
    62  LATIN SMALL LETTER Z
    63  COMMA
    64  LATIN SMALL LETTER B
    65  LATIN SMALL LETTER D
    66  COMMA
    67  LATIN SMALL LETTER B
    68  LATIN SMALL LETTER P
    69  COMMA
    70  LATIN SMALL LETTER B
    71  LATIN SMALL LETTER R
    72  COMMA
    73  LATIN SMALL LETTER B
    74  RIGHT CURLY BRACKET
    75  COMMA
    76  LATIN SMALL LETTER B
    77  LATIN SMALL LETTER K
    78  COMMA
    79  LATIN SMALL LETTER B
    80  LATIN SMALL LETTER L
    81  COMMA
    82  LATIN SMALL LETTER B
    83  LATIN SMALL LETTER O
    84  COMMA
    85  LATIN SMALL LETTER E
    86  COMMA
    87  LATIN CAPITAL LETTER P
    88  COMMA
    89  LATIN CAPITAL LETTER R
    90  LATIN SMALL LETTER X
    91  COMMA
    92  LOW LINE
    93  LATIN SMALL LETTER X
    94  COMMA
    95  LATIN CAPITAL LETTER J
    96  LATIN SMALL LETTER X
    97  COMMA
    98  LATIN CAPITAL LETTER U
    99  LATIN SMALL LETTER V
   100  COMMA
   101  LATIN CAPITAL LETTER M
   102  TILDE
   103  COMMA
   104  SPACE
   105  LATIN SMALL LETTER T
   106  GRAVE ACCENT
   107  LATIN CAPITAL LETTER Y
   108  COMMA
   109  LATIN CAPITAL LETTER Z
   110  LATIN CAPITAL LETTER X
   111  COMMA
   112  LATIN SMALL LETTER C
   113  GRAVE ACCENT
   114  LATIN CAPITAL LETTER Y
   115  COMMA
   116  LATIN CAPITAL LETTER N
   117  REVERSE SOLIDUS
   118  REVERSE SOLIDUS
   119  COMMA
   120  VERTICAL LINE
   121  LATIN SMALL LETTER S
   122  COMMA
   123  LATIN SMALL LETTER M
   124  REVERSE SOLIDUS
   125  REVERSE SOLIDUS
   126  COMMA
   127  SPACE
   128  LATIN SMALL LETTER T
   129  LATIN SMALL LETTER H
   130  LATIN CAPITAL LETTER Y
   131  COMMA
   132  LATIN CAPITAL LETTER T
   133  LATIN SMALL LETTER S
   134  COMMA
   135  LATIN SMALL LETTER C
   136  LATIN SMALL LETTER H
   137  LATIN CAPITAL LETTER Y
   138  COMMA
   139  LATIN SMALL LETTER F
   140  SPACE
   141  LATIN CAPITAL LETTER H
   142  LATIN CAPITAL LETTER Y
   143  LATIN CAPITAL LETTER P
   144  LATIN CAPITAL LETTER H
   145  LATIN CAPITAL LETTER E
   146  LATIN CAPITAL LETTER N
   147  HYPHEN-MINUS
   148  LATIN CAPITAL LETTER M
   149  LATIN CAPITAL LETTER I
   150  LATIN CAPITAL LETTER N
   151  LATIN CAPITAL LETTER U
   152  LATIN CAPITAL LETTER S
   153  SPACE
   154  LATIN CAPITAL LETTER G
   155  LATIN CAPITAL LETTER R
   156  LATIN CAPITAL LETTER E
   157  LATIN CAPITAL LETTER A
   158  LATIN CAPITAL LETTER T
   159  LATIN CAPITAL LETTER E
   160  LATIN CAPITAL LETTER R
   161  HYPHEN-MINUS
   162  LATIN CAPITAL LETTER T
   163  LATIN CAPITAL LETTER H
   164  LATIN CAPITAL LETTER A
   165  LATIN CAPITAL LETTER N
   166  SPACE
   167  LATIN CAPITAL LETTER P
   168  LATIN CAPITAL LETTER A
   169  LATIN CAPITAL LETTER R
   170  LATIN CAPITAL LETTER E
   171  LATIN CAPITAL LETTER N
   172  LATIN CAPITAL LETTER T
   173  LATIN CAPITAL LETTER H
   174  LATIN CAPITAL LETTER E
   175  LATIN CAPITAL LETTER S
   176  LATIN CAPITAL LETTER I
   177  LATIN CAPITAL LETTER S
   178  SPACE
   179  LATIN CAPITAL LETTER E
   180  LATIN CAPITAL LETTER X
   181  LATIN CAPITAL LETTER C
   182  LATIN CAPITAL LETTER L
   183  LATIN CAPITAL LETTER A
   184  LATIN CAPITAL LETTER M
   185  LATIN CAPITAL LETTER A
   186  LATIN CAPITAL LETTER T
   187  LATIN CAPITAL LETTER I
   188  LATIN CAPITAL LETTER O
   189  LATIN CAPITAL LETTER N
   190  SPACE
   191  LATIN CAPITAL LETTER C
   192  LATIN CAPITAL LETTER O
   193  LATIN CAPITAL LETTER M
   194  LATIN CAPITAL LETTER M
   195  LATIN CAPITAL LETTER E
   196  LATIN CAPITAL LETTER R
   197  LATIN CAPITAL LETTER C
   198  LATIN CAPITAL LETTER I
   199  LATIN CAPITAL LETTER A
   200  LATIN CAPITAL LETTER L
   201  SPACE
   202  LATIN CAPITAL LETTER C
   203  LATIN CAPITAL LETTER I
   204  LATIN CAPITAL LETTER R
   205  LATIN CAPITAL LETTER C
   206  LATIN CAPITAL LETTER U
   207  LATIN CAPITAL LETTER M
   208  LATIN CAPITAL LETTER F
   209  LATIN CAPITAL LETTER L
   210  LATIN CAPITAL LETTER E
   211  LATIN CAPITAL LETTER X
   212  SPACE
   213  LATIN CAPITAL LETTER A
   214  LATIN CAPITAL LETTER P
   215  LATIN CAPITAL LETTER O
   216  LATIN CAPITAL LETTER S
   217  LATIN CAPITAL LETTER T
   218  LATIN CAPITAL LETTER R
   219  LATIN CAPITAL LETTER O
   220  LATIN CAPITAL LETTER P
   221  LATIN CAPITAL LETTER H
   222  LATIN CAPITAL LETTER E
   223  SPACE
   224  LATIN CAPITAL LETTER S
   225  LATIN CAPITAL LETTER E
   226  LATIN CAPITAL LETTER M
   227  LATIN CAPITAL LETTER I
   228  LATIN CAPITAL LETTER C
   229  LATIN CAPITAL LETTER O
   230  LATIN CAPITAL LETTER L
   231  LATIN CAPITAL LETTER O
   232  LATIN CAPITAL LETTER N
   233  SPACE
   234  LATIN CAPITAL LETTER A
   235  LATIN CAPITAL LETTER M
   236  LATIN CAPITAL LETTER P
   237  LATIN CAPITAL LETTER E
   238  LATIN CAPITAL LETTER R
   239  LATIN CAPITAL LETTER S
   240  LATIN CAPITAL LETTER A
   241  LATIN CAPITAL LETTER N
   242  LATIN CAPITAL LETTER D
   243  SPACE
   244  LATIN CAPITAL LETTER L
   245  LATIN CAPITAL LETTER E
   246  LATIN CAPITAL LETTER S
   247  LATIN CAPITAL LETTER S
   248  HYPHEN-MINUS
   249  LATIN CAPITAL LETTER T
   250  LATIN CAPITAL LETTER H
   251  LATIN CAPITAL LETTER A
   252  LATIN CAPITAL LETTER N
   253  SPACE
   254  LATIN CAPITAL LETTER Q
   255  LATIN CAPITAL LETTER U
   256  LATIN CAPITAL LETTER O
   257  LATIN CAPITAL LETTER T
   258  LATIN CAPITAL LETTER A
   259  LATIN CAPITAL LETTER T
   260  LATIN CAPITAL LETTER I
   261  LATIN CAPITAL LETTER O
   262  LATIN CAPITAL LETTER N
   263  SPACE
   264  LATIN CAPITAL LETTER V
   265  LATIN CAPITAL LETTER E
   266  LATIN CAPITAL LETTER R
   267  LATIN CAPITAL LETTER T
   268  LATIN CAPITAL LETTER I
   269  LATIN CAPITAL LETTER C
   270  LATIN CAPITAL LETTER A
   271  LATIN CAPITAL LETTER L
   272  SPACE
   273  LATIN CAPITAL LETTER Q
   274  LATIN CAPITAL LETTER U
   275  LATIN CAPITAL LETTER E
   276  LATIN CAPITAL LETTER S
   277  LATIN CAPITAL LETTER T
   278  LATIN CAPITAL LETTER I
   279  LATIN CAPITAL LETTER O
   280  LATIN CAPITAL LETTER N
   281  SPACE
   282  LATIN CAPITAL LETTER A
   283  LATIN CAPITAL LETTER S
   284  LATIN CAPITAL LETTER T
   285  LATIN CAPITAL LETTER E
   286  LATIN CAPITAL LETTER R
   287  LATIN CAPITAL LETTER I
   288  LATIN CAPITAL LETTER S
   289  LATIN CAPITAL LETTER K
   290  SPACE
   291  LATIN CAPITAL LETTER C
   292  LATIN CAPITAL LETTER A
   293  LATIN CAPITAL LETTER P
   294  LATIN CAPITAL LETTER I
   295  LATIN CAPITAL LETTER T
   296  LATIN CAPITAL LETTER A
   297  LATIN CAPITAL LETTER L
   298  SPACE
   299  LATIN CAPITAL LETTER S
   300  LATIN CAPITAL LETTER O
   301  LATIN CAPITAL LETTER L
   302  LATIN CAPITAL LETTER I
   303  LATIN CAPITAL LETTER D
   304  LATIN CAPITAL LETTER U
   305  LATIN CAPITAL LETTER S
   306  SPACE
   307  LATIN CAPITAL LETTER B
   308  LATIN CAPITAL LETTER R
   309  LATIN CAPITAL LETTER A
   310  LATIN CAPITAL LETTER C
   311  LATIN CAPITAL LETTER K
   312  LATIN CAPITAL LETTER E
   313  LATIN CAPITAL LETTER T
   314  SPACE
   315  LATIN CAPITAL LETTER R
   316  LATIN CAPITAL LETTER E
   317  LATIN CAPITAL LETTER V
   318  LATIN CAPITAL LETTER E
   319  LATIN CAPITAL LETTER R
   320  LATIN CAPITAL LETTER S
   321  LATIN CAPITAL LETTER E
   322  SPACE
   323  LATIN CAPITAL LETTER P
   324  LATIN CAPITAL LETTER E
   325  LATIN CAPITAL LETTER R
   326  LATIN CAPITAL LETTER C
   327  LATIN CAPITAL LETTER E
   328  LATIN CAPITAL LETTER N
   329  LATIN CAPITAL LETTER T
   330  SPACE
   331  LATIN CAPITAL LETTER A
   332  LATIN CAPITAL LETTER C
   333  LATIN CAPITAL LETTER C
   334  LATIN CAPITAL LETTER E
   335  LATIN CAPITAL LETTER N
   336  LATIN CAPITAL LETTER T
   337  SPACE
   338  LATIN CAPITAL LETTER L
   339  LATIN CAPITAL LETTER E
   340  LATIN CAPITAL LETTER T
   341  LATIN CAPITAL LETTER T
   342  LATIN CAPITAL LETTER E
   343  LATIN CAPITAL LETTER R
   344  SPACE
   345  LATIN CAPITAL LETTER D
   346  LATIN CAPITAL LETTER O
   347  LATIN CAPITAL LETTER L
   348  LATIN CAPITAL LETTER L
   349  LATIN CAPITAL LETTER A
   350  LATIN CAPITAL LETTER R
   351  SPACE
   352  LATIN CAPITAL LETTER E
   353  LATIN CAPITAL LETTER Q
   354  LATIN CAPITAL LETTER U
   355  LATIN CAPITAL LETTER A
   356  LATIN CAPITAL LETTER L
   357  LATIN CAPITAL LETTER S
   358  SPACE
   359  LATIN CAPITAL LETTER S
   360  LATIN CAPITAL LETTER Q
   361  LATIN CAPITAL LETTER U
   362  LATIN CAPITAL LETTER A
   363  LATIN CAPITAL LETTER R
   364  LATIN CAPITAL LETTER E
   365  SPACE
   366  LATIN CAPITAL LETTER N
   367  LATIN CAPITAL LETTER U
   368  LATIN CAPITAL LETTER M
   369  LATIN CAPITAL LETTER B
   370  LATIN CAPITAL LETTER E
   371  LATIN CAPITAL LETTER R
   372  SPACE
   373  LATIN CAPITAL LETTER D
   374  LATIN CAPITAL LETTER I
   375  LATIN CAPITAL LETTER G
   376  LATIN CAPITAL LETTER I
   377  LATIN CAPITAL LETTER T
   378  SPACE
   379  LATIN CAPITAL LETTER R
   380  LATIN CAPITAL LETTER I
   381  LATIN CAPITAL LETTER G
   382  LATIN CAPITAL LETTER H
   383  LATIN CAPITAL LETTER T
   384  SPACE
   385  LATIN CAPITAL LETTER T
   386  LATIN CAPITAL LETTER H
   387  LATIN CAPITAL LETTER R
   388  LATIN CAPITAL LETTER E
   389  LATIN CAPITAL LETTER E
   390  SPACE
   391  LATIN CAPITAL LETTER C
   392  LATIN CAPITAL LETTER O
   393  LATIN CAPITAL LETTER L
   394  LATIN CAPITAL LETTER O
   395  LATIN CAPITAL LETTER N
   396  SPACE
   397  LATIN CAPITAL LETTER T
   398  LATIN CAPITAL LETTER I
   399  LATIN CAPITAL LETTER L
   400  LATIN CAPITAL LETTER D
   401  LATIN CAPITAL LETTER E
   402  SPACE
   403  LATIN CAPITAL LETTER C
   404  LATIN CAPITAL LETTER O
   405  LATIN CAPITAL LETTER M
   406  LATIN CAPITAL LETTER M
   407  LATIN CAPITAL LETTER A
   408  SPACE
   409  LATIN CAPITAL LETTER C
   410  LATIN CAPITAL LETTER U
   411  LATIN CAPITAL LETTER R
   412  LATIN CAPITAL LETTER L
   413  LATIN CAPITAL LETTER Y
   414  SPACE
   415  LATIN CAPITAL LETTER S
   416  LATIN CAPITAL LETTER P
   417  LATIN CAPITAL LETTER A
   418  LATIN CAPITAL LETTER C
   419  LATIN CAPITAL LETTER E
   420  SPACE
   421  LATIN CAPITAL LETTER S
   422  LATIN CAPITAL LETTER M
   423  LATIN CAPITAL LETTER A
   424  LATIN CAPITAL LETTER L
   425  LATIN CAPITAL LETTER L
   426  SPACE
   427  LATIN CAPITAL LETTER S
   428  LATIN CAPITAL LETTER E
   429  LATIN CAPITAL LETTER V
   430  LATIN CAPITAL LETTER E
   431  LATIN CAPITAL LETTER N
   432  SPACE
   433  LATIN CAPITAL LETTER E
   434  LATIN CAPITAL LETTER I
   435  LATIN CAPITAL LETTER G
   436  LATIN CAPITAL LETTER H
   437  LATIN CAPITAL LETTER T
   438  SPACE
   439  LATIN CAPITAL LETTER G
   440  LATIN CAPITAL LETTER R
   441  LATIN CAPITAL LETTER A
   442  LATIN CAPITAL LETTER V
   443  LATIN CAPITAL LETTER E
   444  SPACE
   445  LATIN CAPITAL LETTER L
   446  LATIN CAPITAL LETTER A
   447  LATIN CAPITAL LETTER T
   448  LATIN CAPITAL LETTER I
   449  LATIN CAPITAL LETTER N
   450  SPACE
   451  LATIN CAPITAL LETTER N
   452  LATIN CAPITAL LETTER I
   453  LATIN CAPITAL LETTER N
   454  LATIN CAPITAL LETTER E
   455  SPACE
   456  LATIN CAPITAL LETTER F
   457  LATIN CAPITAL LETTER O
   458  LATIN CAPITAL LETTER U
   459  LATIN CAPITAL LETTER R
   460  SPACE
   461  LATIN CAPITAL LETTER P
   462  LATIN CAPITAL LETTER L
   463  LATIN CAPITAL LETTER U
   464  LATIN CAPITAL LETTER S
   465  SPACE
   466  LATIN CAPITAL LETTER F
   467  LATIN CAPITAL LETTER I
   468  LATIN CAPITAL LETTER V
   469  LATIN CAPITAL LETTER E
   470  SPACE
   471  LATIN CAPITAL LETTER L
   472  LATIN CAPITAL LETTER I
   473  LATIN CAPITAL LETTER N
   474  LATIN CAPITAL LETTER E
   475  SPACE
   476  LATIN CAPITAL LETTER L
   477  LATIN CAPITAL LETTER E
   478  LATIN CAPITAL LETTER F
   479  LATIN CAPITAL LETTER T
   480  SPACE
   481  LATIN CAPITAL LETTER S
   482  LATIN CAPITAL LETTER T
   483  LATIN CAPITAL LETTER O
   484  LATIN CAPITAL LETTER P
   485  SPACE
   486  LATIN CAPITAL LETTER M
   487  LATIN CAPITAL LETTER A
   488  LATIN CAPITAL LETTER R
   489  LATIN CAPITAL LETTER K
   490  SPACE
   491  LATIN CAPITAL LETTER F
   492  LATIN CAPITAL LETTER U
   493  LATIN CAPITAL LETTER L
   494  LATIN CAPITAL LETTER L
   495  SPACE
   496  LATIN CAPITAL LETTER S
   497  LATIN CAPITAL LETTER I
   498  LATIN CAPITAL LETTER G
   499  LATIN CAPITAL LETTER N
   500  SPACE
   501  LATIN CAPITAL LETTER Z
   502  LATIN CAPITAL LETTER E
   503  LATIN CAPITAL LETTER R
   504  LATIN CAPITAL LETTER O
   505  SPACE
   506  LATIN CAPITAL LETTER T
   507  LATIN CAPITAL LETTER W
   508  LATIN CAPITAL LETTER O
   509  SPACE
   510  LATIN CAPITAL LETTER O
   511  LATIN CAPITAL LETTER N
   512  LATIN CAPITAL LETTER E
   513  SPACE
   514  LATIN CAPITAL LETTER L
   515  LATIN CAPITAL LETTER O
   516  LATIN CAPITAL LETTER W
   517  SPACE
   518  LATIN CAPITAL LETTER S
   519  LATIN CAPITAL LETTER I
   520  LATIN CAPITAL LETTER X
   521  SPACE
   522  LATIN CAPITAL LETTER A
   523  LATIN CAPITAL LETTER T
   524  QUOTATION MARK
   525  COMMA
   526  LATIN SMALL LETTER W
   527  RIGHT PARENTHESIS
   528  SEMICOLON
   529  LATIN SMALL LETTER Y
   530  EQUALS SIGN
   531  LATIN SMALL LETTER W
   532  LEFT SQUARE BRACKET
   533  DIGIT TWO
   534  RIGHT SQUARE BRACKET
   535  SEMICOLON
   536  LATIN SMALL LETTER F
   537  LATIN SMALL LETTER O
   538  LATIN SMALL LETTER R
   539  LEFT PARENTHESIS
   540  LATIN SMALL LETTER X
   541  EQUALS SIGN
   542  LATIN SMALL LETTER W
   543  LEFT SQUARE BRACKET
   544  DIGIT ONE
   545  RIGHT SQUARE BRACKET
   546  SEMICOLON
   547  LATIN SMALL LETTER I
   548  PLUS SIGN
   549  PLUS SIGN
   550  LESS-THAN SIGN
   551  DIGIT TWO
   552  DIGIT SIX
   553  SEMICOLON
   554  LATIN SMALL LETTER X
   555  EQUALS SIGN
   556  LATIN SMALL LETTER X
   557  QUOTATION MARK
   558  LATIN SMALL LETTER N
   559  LATIN CAPITAL LETTER W
   560  RIGHT SQUARE BRACKET
   561  COMMA
   562  QUOTATION MARK
   563  RIGHT PARENTHESIS
   564  LATIN SMALL LETTER Y
   565  EQUALS SIGN
   566  LATIN SMALL LETTER Y
   567  QUOTATION MARK
   568  LATIN SMALL LETTER N
   569  LATIN SMALL LETTER J
   570  RIGHT SQUARE BRACKET
   571  COMMA
   572  QUOTATION MARK
   573  SEMICOLON
   574  LATIN SMALL LETTER F
   575  LATIN SMALL LETTER O
   576  LATIN SMALL LETTER R
   577  LEFT PARENTHESIS
   578  LATIN SMALL LETTER S
   579  LATIN SMALL LETTER P
   580  LATIN SMALL LETTER L
   581  LATIN SMALL LETTER I
   582  LATIN SMALL LETTER T
   583  LEFT PARENTHESIS
   584  LATIN SMALL LETTER X
   585  SPACE
   586  LATIN SMALL LETTER Y
   587  SPACE
   588  LATIN SMALL LETTER W
   589  LEFT SQUARE BRACKET
   590  DIGIT THREE
   591  RIGHT SQUARE BRACKET
   592  COMMA
   593  LATIN SMALL LETTER B
   594  COMMA
   595  QUOTATION MARK
   596  COMMA
   597  QUOTATION MARK
   598  RIGHT PARENTHESIS
   599  SEMICOLON
   600  LATIN SMALL LETTER J
   601  PLUS SIGN
   602  PLUS SIGN
   603  LESS-THAN SIGN
   604  DIGIT ONE
   605  DIGIT TWO
   606  DIGIT SIX
   607  SEMICOLON
   608  LATIN CAPITAL LETTER F
   609  LATIN CAPITAL LETTER S
   610  EQUALS SIGN
   611  LOW LINE
   612  RIGHT PARENTHESIS
   613  LATIN SMALL LETTER D
   614  LEFT SQUARE BRACKET
   615  LATIN SMALL LETTER S
   616  LATIN SMALL LETTER P
   617  LATIN SMALL LETTER R
   618  LATIN SMALL LETTER I
   619  LATIN SMALL LETTER N
   620  LATIN SMALL LETTER T
   621  LATIN SMALL LETTER F
   622  LEFT PARENTHESIS
   623  QUOTATION MARK
   624  PERCENT SIGN
   625  LATIN SMALL LETTER C
   626  QUOTATION MARK
   627  COMMA
   628  LATIN SMALL LETTER J
   629  RIGHT PARENTHESIS
   630  RIGHT SQUARE BRACKET
   631  EQUALS SIGN
   632  LATIN SMALL LETTER J
   633  RIGHT CURLY BRACKET
   634  LEFT CURLY BRACKET
   635  LATIN SMALL LETTER F
   636  LATIN SMALL LETTER O
   637  LATIN SMALL LETTER R
   638  LEFT PARENTHESIS
   639  LATIN SMALL LETTER K
   640  EQUALS SIGN
   641  DIGIT ZERO
   642  SEMICOLON
   643  LATIN SMALL LETTER K
   644  PLUS SIGN
   645  PLUS SIGN
   646  LESS-THAN SIGN
   647  LATIN CAPITAL LETTER N
   648  LATIN CAPITAL LETTER F
   649  SEMICOLON
   650  LATIN SMALL LETTER P
   651  LATIN SMALL LETTER R
   652  LATIN SMALL LETTER I
   653  LATIN SMALL LETTER N
   654  LATIN SMALL LETTER T
   655  SPACE
   656  LATIN SMALL LETTER I
   657  EQUALS SIGN
   658  LOW LINE
   659  RIGHT PARENTHESIS
   660  LATIN SMALL LETTER W
   661  LATIN SMALL LETTER H
   662  LATIN SMALL LETTER I
   663  LATIN SMALL LETTER L
   664  LATIN SMALL LETTER E
   665  LEFT PARENTHESIS
   666  LATIN SMALL LETTER I
   667  PLUS SIGN
   668  PLUS SIGN
   669  LESS-THAN SIGN
   670  LATIN SMALL LETTER S
   671  LATIN SMALL LETTER P
   672  LATIN SMALL LETTER L
   673  LATIN SMALL LETTER I
   674  LATIN SMALL LETTER T
   675  LEFT PARENTHESIS
   676  LATIN SMALL LETTER B
   677  LEFT SQUARE BRACKET
   678  LATIN SMALL LETTER D
   679  LEFT SQUARE BRACKET
   680  DOLLAR SIGN
   681  LATIN SMALL LETTER K
   682  RIGHT SQUARE BRACKET
   683  HYPHEN-MINUS
   684  DIGIT THREE
   685  DIGIT ONE
   686  RIGHT SQUARE BRACKET
   687  COMMA
   688  LATIN SMALL LETTER Q
   689  RIGHT PARENTHESIS
   690  RIGHT PARENTHESIS
   691  LATIN SMALL LETTER P
   692  LATIN SMALL LETTER R
   693  LATIN SMALL LETTER I
   694  LATIN SMALL LETTER N
   695  LATIN SMALL LETTER T
   696  LATIN SMALL LETTER F
   697  LEFT PARENTHESIS
   698  LATIN SMALL LETTER Z
   699  EQUALS SIGN
   700  LATIN SMALL LETTER W
   701  LEFT SQUARE BRACKET
   702  LATIN SMALL LETTER D
   703  LEFT SQUARE BRACKET
   704  LATIN SMALL LETTER Q
   705  LEFT SQUARE BRACKET
   706  LATIN SMALL LETTER I
   707  RIGHT SQUARE BRACKET
   708  RIGHT SQUARE BRACKET
   709  HYPHEN-MINUS
   710  DIGIT SIX
   711  DIGIT NINE
   712  RIGHT SQUARE BRACKET
   713  RIGHT PARENTHESIS
   714  QUOTATION MARK
   715  SPACE
   716  QUOTATION MARK
   717  LEFT PARENTHESIS
   718  LATIN SMALL LETTER Z
   719  TILDE
   720  SOLIDUS
   721  LATIN CAPITAL LETTER T
   722  LATIN CAPITAL LETTER T
   723  SOLIDUS
   724  QUESTION MARK
   725  LATIN SMALL LETTER T
   726  LATIN SMALL LETTER O
   727  LATIN SMALL LETTER U
   728  LATIN SMALL LETTER P
   729  LATIN SMALL LETTER P
   730  LATIN SMALL LETTER E
   731  LATIN SMALL LETTER R
   732  LEFT PARENTHESIS
   733  DOLLAR SIGN
   734  LATIN SMALL LETTER K
   735  RIGHT PARENTHESIS
   736  COLON
   737  LOW LINE
   738  RIGHT PARENTHESIS
   739  RIGHT CURLY BRACKET

Just kidding ;D
BEGIN{split("i,Lv,Sv,ax,^x,[x,Q,O,tK,cK,V,qx,g,I,wu,X,by,b{,bz,bd,bp,br,b},bk,bl,bo,e,P,Rx,_x,Jx,Uv,M~, t`Y,ZX,c`Y,N\\,|s,m\\, thY,Ts,chY,f HYPHEN-MINUS GREATER-THAN PARENTHESIS EXCLAMATION COMMERCIAL CIRCUMFLEX APOSTROPHE SEMICOLON AMPERSAND LESS-THAN QUOTATION VERTICAL QUESTION ASTERISK CAPITAL SOLIDUS BRACKET REVERSE PERCENT ACCENT LETTER DOLLAR EQUALS SQUARE NUMBER DIGIT RIGHT THREE COLON TILDE COMMA CURLY SPACE SMALL SEVEN EIGHT GRAVE LATIN NINE FOUR PLUS FIVE LINE LEFT STOP MARK FULL SIGN ZERO TWO ONE LOW SIX AT",w);x=w[1];for(y=w[2];C++<26;x=x"nW],")y=y"nj],";for(split(x y w[3],b,",");j++<126;FS=_)d[sprintf("%c",j)]=j}{for(k=0;k++<NF;print i=_)while(i++<split(b[d[$k]-31],q))printf(z=w[d[q[i]]-69])" "(z~/TT/?toupper($k):_)}

Works with stdin/stdout.
More "readable":
BEGIN{

  # This string (508 bytes) holds a representation of the character names in
  # the right order, plus a list of the used words.

    split("i,Lv,Sv,ax,^x,[x,Q,O,tK,cK,V,qx,g,I,wu,X,by,b{,bz,bd,bp,br,b},bk,bl,bo,
    e,P,Rx,_x,Jx,Uv,M~, t`Y,ZX,c`Y,N\\,|s,m\\, thY,Ts,chY,f HYPHEN-MINUS GREATER-T
    HAN PARENTHESIS EXCLAMATION COMMERCIAL CIRCUMFLEX APOSTROPHE SEMICOLON AMPERSA
    ND LESS-THAN QUOTATION VERTICAL QUESTION ASTERISK CAPITAL SOLIDUS BRACKET REVE
    RSE PERCENT ACCENT LETTER DOLLAR EQUALS SQUARE NUMBER DIGIT RIGHT THREE COLON
    TILDE COMMA CURLY SPACE SMALL SEVEN EIGHT GRAVE LATIN NINE FOUR PLUS FIVE LINE
     LEFT STOP MARK FULL SIGN ZERO TWO ONE LOW SIX AT",w);

  # Since the letters each appear 26 times I construct that part at runtime.
  # The array b will hold the coded combinations of which words need to
  # be printed for each input character.

    x=w[1];
    for(y=w[2];C++<26;x=x"nW],")
        y=y"nj],";

  # The array d is an ASCIICodeFromChar function replacement.
  # I set the field separator to empty, so each character of the input is
  # an input field. That's why using a BEGIN part was mandatory.

    for(split(x y w[3],b,",");j++<126;FS=_)
        d[sprintf("%c",j)]=j
}

  # Here I go through the element of b that matches the input and print
  # the requested words, using the input to produce a capital letter if
  # needed. I excluded these from the word list to save another 26 bytes

{
    for(k=0;k++<NF;print i=_)
        while(i++<split(b[d[$k]-31],q))
            printf(z=w[d[q[i]]-69])" "(z~/TT/?toupper($k):_)
}

C++11, 739 bytes
#include<iostream>
#define D,"DIGIT "
#define G" SIGN",
int main(){std::string a=" BRACKET",s="SQUARE"+a,c="CURLY"+a,t="TION MARK",p="PARENTHESIS",l="LEFT ",r="RIGHT ",x="LATIN ",y="L LETTER ",z[]{"SPACE","EXCLAMA"+t,"QUOTA"+t,"NUMBER"G"DOLLAR"G"PERCENT"G"AMPERSAND","APOSTROPHE",l+p,r+p,"ASTERISK","PLUS"G"COMMA","HYPHEN-MINUS","FULL STOP","SOLIDUS"D"ZERO"D"ONE"D"TWO"D"THREE"D"FOUR"D"FIVE"D"SIX"D"SEVEN"D"EIGHT"D"NINE","COLON","SEMICOLON","LESS-THAN"G"EQUALS"G"GREATER-THAN"G"QUES"+t,"COMMERCIAL AT",l+s,"REVERSE SOLIDUS",r+s,"CIRCUMFLEX ACCENT","LOW LINE","GRAVE ACCENT",l+c,"VERTICAL LINE",r+c,"TILDE"};getline(std::cin,s);for(char c:s)std::cout<<(c<65?z[c-32]:c<91?x+"CAPITA"+y+c:(c-=32,c<65?z[c-26]:c<91?x+"SMAL"+y+c:z[c-52]))+"\n";}

Based on sweerpotato's solution, but modified heavily.

Nicely done :~)!

C++14, 1043 1000 998 996 972 bytes
Grotesque solution in C++14:
#include<iostream>
#include<map>
#define b cout
#define d string
#define e },{
using namespace std;char l='\n';d s[]{"DIGIT ","LATIN CAPITAL LETTER ","LATIN SMALL LETTER "};map<char, d> m{{' ',"SPACE"e'!',"EXCLAMATION MARK"e'\"',"QUOTATION MARK"e'#',"NUMBER SIGN"e'$',"DOLLAR SIGN"e'%',"PERCENT SIGN"e'&',"AMPERSAND"e'\'',"APOSTROPHE"e'(',"LEFT PARENTHESIS"e')',"RIGHT PARENTHESIS"e'*',"ASTERISK"e'+',"PLUS SIGN"e',',"COMMA"e'-',"HYPHEN-MINUS"e'.',"FULL STOP"e'/',"SOLIDUS"e':',"COLON"e';',"SEMICOLON"e'<',"LESS-THAN SIGN"e'=',"EQUALS SIGN"e'>',"GREATER-THAN SIGN"e'?',"QUESTION MARK"e'@',"COMMERCIAL AT"e'[',"LEFT SQUARE BRACKET"e'\\',"REVERSE SOLIDUS"e']',"RIGHT SQUARE BRACKET"e'^',"CIRCUMFLEX ACCENT"e'_',"LOW LINE"e'`',"GRAVE ACCENT"e'{',"LEFT CURLY BRACKET"e'|',"VERTICAL LINE"e'}',"RIGHT CURLY BRACKET"e'~',"TILDE"}};int main(){d str;getline(cin,str);for(char c:str){islower(c)?b<<s[2]<<(char)(c-32):isupper(c)?b<<s[1]<<c:isdigit(c)?b<<*s<<c:b<<m.at(c);b<<l;}}

Thanks to kirbyfan64sos for golfing off two bytes

Can you do *s instead of s[0]?

Sure can! Totally missed that

Common Lisp (SBCL), 52 79
(map()(lambda(y)(format t"~:@(~A~)~%"(substitute #\  #\_(char-name y))))(read))

This is built-in and implementation-dependent, so you may want to ignore it when choosing the accepted answer. This is not enough to beat Python, unfortunately. The updated version conforms to the expected output (I have to replace underscores by spaces).
Example
CL-USER> (map()(lambda(y)(format t"~:@(~A~)~%"(substitute #\  #\_(char-name y))))(read))
"(λ(r)(* 2 ᴨ r))"
LEFT PARENTHESIS
GREEK SMALL LETTER LAMDA
LEFT PARENTHESIS
LATIN SMALL LETTER R
RIGHT PARENTHESIS
LEFT PARENTHESIS
ASTERISK
SPACE
DIGIT TWO
SPACE
GREEK LETTER SMALL CAPITAL PI
SPACE
LATIN SMALL LETTER R
RIGHT PARENTHESIS
RIGHT PARENTHESIS

Pyth, 41
$from unicodedata import name as neg$Vz_N

Uses same builtin as mbomb007's python answer. Note that this cannot be executed online because the $ operator is unsafe.

Clojure, 56 bytes
(doseq[c(read-line)](println(Character/getName(int c))))

Inspired by @peter's answer. Uses Clojure for the Java interop.

CJam, 517
l{i32-["SPACE""EXCLAMA""TION MARK":T+"QUOTA"T+"NUMBER DOLLAR PERCENT"{S/" SIGN"am*~}:H~"AMPERSAND""APOSTROPHE""LEFT PARENTHESIS":L"RIGHT ":R1$5>+"ASTERISK""PLUS"H"COMMA""HYPHEN-MINUS""FULL STOP""SOLIDUS":D"DIGIT "a"ZERO ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE"S/m*~"COLON""SEMI"1$+"LESS-THAN EQUALS GREATER-THAN"H"QUES"T+"COMMERCIAL AT""CAPITA"{["LATIN "\"L LETTER "]a'[,65>m*~L5<}:Z~"SQUARE BRACKET":Q+"REVERSE "D+RQ+"CIRCUMFLEX ACCENT""LOW LINE""GRAVE"2$A>+"SMAL"Z"CURLY"33$B>+:C+"VERTICAL LINE"RC+"TILDE"]=N}/

Online version
I have tried different solutions but simply storing all the names in a huge array seems most efficient.
This is my first real CJam program by the way.

Perl - 894 bytes
Lovingly crafted by hand. First time golfing in Perl so any tips are appreciated.
$_=$ARGV[0];s/(.)/$1\n/g;s/([A-Z])/& CAPITAL' $1/g;s/([a-z])/& SMALL' \U$1/g;s/,/COMMA/g;s/& /LATIN /g;s/' / LETT, /g;s/&/AMP,SAND/g;s/'/APOSTROPHE/g;s/ \n/SPACE\n/g;s/\*/AST,ISK/g;s/-/HYPHEN-MINUS/g;s/\./FULL STOP/g;s/@/COMM,CIAL AT/g;s/~/TILDE/g;s/:/&/g;s/;/SEMI&/g;s/&/COLON/g;s/\|/V,TICAL&/g;s/_/LOW&/g;s/&/ LINE/g;s/\^/CIRCUMFLEX&/g;s/`/GRAVE&/g;s/&/ ACCENT/g;s/\//&/g;s/\\/REV,SE &/g;s/&/SOLIDUS/g;s/!/!&/g;s/"/"&/g;s/\?/?&/g;s/!/EXCLAMA/g;s/"/QUOTA/g;s/\?/QUES/g;s/&/TION MARK/g;s/#/NUMB,&/g;s/\$/DOLLAR&/g;s/%/P,CENT&/g;s/\+/PLUS&/g;s/</LESS-THAN&/g;s/=/EQUALS&/g;s/>/GREAT,-THAN&/g;s/&/ SIGN/g;s/\(/<&/g;s/\)/>&/g;s/&/ PARENTHESIS/g;s/\[/<&/g;s/\]/>&/g;s/&/ SQUARE'/g;s/{/<&/g;s/}/>&/g;s/&/ CURLY'/g;s/'/ BRACKET/g;s/</LEFT/g;s/>/RIGHT/g;s/0/&Z,O/g;s/1/&ONE/g;s/2/&TWO/g;s/3/&THREE/g;s/4/&FOUR/g;s/5/&FIVE/g;s/6/&SIX/g;s/7/&SEVEN/g;s/8/&EIGHT/g;s/9/&NINE/g;s/&/DIGIT /g;s/,/ER/g;print;

C++14 716 706 704
#include<iostream>
char*q,x,b[584],*t=b,a[]=R"(space}exclamation|mark}quot"-number|sign}dolla!apercent!mam"%sand}apostrophe}left|par%3hesis}righ"Wasterisk}plus*<comma}hy)#n{minus}full|stop}solid"Ldigit|zero!Tone!Gtw"kthre#&four!Uiv#&six!Heve>^!_e6r!ani,1colon}semi!Fless{than8Eequal:$grea<s$2quesMj>EJoial|at}lQ9n|capit"?let('|Jes+\re|bracket}r5urse|C5M?%2circumflex|acXR}low|l:bgrave#'0=smaNy0+curly*s/Ytic4z)$/\$itilde)",*s=a;int c,z,l='{';int main(){for(;x=*s++;)if(z=x-32,x>96)*t++=x<l?z:"- "[x%l];else for(c=z*95+*s++-32,q=t-c/13,x=3+c%13;x--;)*t++=*q++;while(std::cin.get(x)){for(s=b,z=0,c=x<65?x-32:x<91?z=33:x<97?x-57:x<l?z=40:x-82;c--;)while(*s++);auto&o=std::cout<<s;(z?o.put(x&~32):o)<<"\n";}}

Live version.
With some whitespace:
#include <iostream>

// a is compressed using an LZ like compression scheme
char *q, x, b[584],
    *t = b,
    a[] =
        R"(space}exclamation|mark}quot"-number|sign}dolla!apercent!mam"%sand}apostrophe}left|par%3hesis}righ"Wasterisk}plus*<comma}hy)#n{minus}full|stop}solid"Ldigit|zero!Tone!Gtw"kthre#&four!Uiv#&six!Heve>^!_e6r!ani,1colon}semi!Fless{than8Eequal:$grea<s$2quesMj>EJoial|at}lQ9n|capit"?let('|Jes+\re|bracket}r5urse|C5M?%2circumflex|acXR}low|l:bgrave#'0=smaNy0+curly*s/Ytic4z)$/\$itilde)",
    *s = a;

int c, z, l = '{';

int main() {
    // Decompress from a into b
    for (; x = *s++;)
        if (z = x - 32, x > 96)
            *t++ = x < l ? z : "- "[x % l];
        else
            for (c = z * 95 + *s++ - 32, q = t - c / 13, x = 3 + c % 13; x--;) *t++ = *q++;

    // Process input a char at a time, performing a lookup into b for the c'th null separated string
    while (std::cin.get(x)) {
        for (s = b, z = 0,
            c = x < 65 ? x - 32 : x < 91 ? z = 33 : x < 97 ? x - 57 : x < l ? z = 40 : x - 82;
             c--;)
            while (*s++)
                ;
        auto& o = std::cout << s;
        (z ? o.put(x & ~32) : o) << "\n";
    }
}

The compressed string a decompresses to:

space}exclamation|mark}quotation|mark}number|sign}dollar|sign}percent|sign}ampersand}apostrophe}left|parenthesis}right|parenthesis}asterisk}plus|sign}comma}hyphen{minus}full|stop}solidus}digit|zero}digit|one}digit|two}digit|three}digit|four}digit|five}digit|six}digit|seven}digit|eight}digit|nine}colon}semicolon}less{than|sign}equals|sign}greater{than|sign}question|mark}commercial|at}latin|capital|letter|}left|square|bracket}reverse|solidus}right|square|bracket}circumflex|accent}low|line}grave|accent}latin|small|letter|}left|curly|bracket}vertical|line}right|curly|bracket}tilde

And during decompression } is replaced with \0, | with   (space) and { with - and lowercase letters are converted to uppercase.
The string is compressed LZ style as either a literal [a-~] or a two character encoded offset/length to a match earlier in the string.

Factor, 58 bytes
[ readln [ char>name "-"" " replace >upper print ] each ]

Pretty simple; does the exact same thing as the Java and Perl 6 answers.

Go, 145 bytes
package main
import(."golang.org/x/text/unicode/runenames"
."fmt")
func main(){r:='!'
for{_,e:=Scanf("%c",&r)
if e!=nil{break}
println(Name(r))}}

Some have address a concern with the above answer. I tried vendoring the code in
question, but my answer bypassed the 65,536 byte limit [1], so I think the above
answer is fine as is.

https://github.com/golang/text/blob/v0.3.6/unicode/runenames/tables13.0.0.go

From the question, Internet and external libraries are not allowed, all necessary data should be in the code.

When I run code myself, it says cannot find package "golang.org/x/text/unicode/runenames" in any of:  /usr/lib/golang/src/golang.org/x/text/unicode/runenames (from $GOROOT)  /home/runner/go/src/golang.org/x/text/unicode/runenames (from $GOPATH)

But it is my job to make sure that answers comply with the spirit and letter of the challenge. This runenames import appears to be an external library, which is disallowed.

Well, you keep insisting that it is a standard library, and I'm trying to figure out what reasoning you have behind it. I'd also like to note I have golfed with Go before, but am not entirely familiar with the import system. It's just pretty obvious which of the two libraries you are using is external and which is not.

Whether JoKing is a moderator or not is irrelevant here - any user should be able to check if an answer is valid by the rules. Obviously, not everyone is familiar with Go, so it is up to you to demonstrate that your answer follows all rules, including "Internet and external libraries are not allowed" If this answer requires the internet to work, then it isn't valid per the question. It'd be helpful if you could verify this or not, as you clearly know more about Go than either me or JoKing

discussion in chat starting here

PHP>=7, 54 Bytes
for(;a&$c=$argn[$i++];)echo"
".IntlChar::charName($c);

IntlChar::charName

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


text:
The Coin Problem
Background
The official currency of the imaginary nation of Golfenistan is the foo, and there are only three kinds of coins in circulation: 3 foos, 7 foos and 8 foos.
One can see that it's not possible to pay certain amounts, like 4 foos, using these coins.
Nevertheless, all large enough amounts can be formed.
Your job is to find the largest amount that can't be formed with the coins (5 foos in this case), which is known as the coin problem.
Input
Your input is a list L = [n1, n2, ..., nk] of positive integers, representing the values of coins in circulation.
Two things are guaranteed about it:

The GCD of the elements of L is 1.
L does not contain the number 1.

It may be unsorted and/or contain duplicates (think special edition coins).
Output
Since the GCD of L is 1, every large enough integer m can be expressed as a non-negative linear combination of its elements; in other words, we have
 m = a1*n1 + a2*n2 + ... + ak*nk
for some integers ai ≥ 0.
Your output is the largest integer that cannot be expressed in this form.
As a hint, it is known that the output is always less than (n1 - 1)*(nk - 1), if n1 and nk are the maximal and minimal elements of L (reference).
Rules
You can write a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.
If your language has a built-in operation for this, you may not use it.
There are no requirements for time or memory efficiency, except that you should be able to evaluate the test cases before posting your answer.
After I posted this challenge, user @vihan pointed out that Stack Overflow has an exact duplicate.
Based on this Meta discussion, this challenge will not be deleted as a duplicate; however, I ask that all answers based on those of the SO version should cite the originals, be given the Community Wiki status, and be deleted if the original author wishes to post their answer here.
Test Cases
[3, 7, 8] -> 5
[25, 10, 16] -> 79
[11, 12, 13, 14, 13, 14] -> 43
[101, 10] -> 899
[101, 10, 899] -> 889
[101, 10, 11] -> 89
[30, 105, 70, 42] -> 383
[2, 51, 6] -> 49

FrobeniusNumber in Mathematica.

@alephalpha Good catch, I had forgotten to disallow built-ins.

There is a way better upper bound, found in this paper that establishes (p - 1)(q - 1) as the upper bound, where p and q are the smallest and biggest element of the set.

Are there any limits of run time or memory usage?

On Stack Overflow there was a code golf question like this a while back

@orlp Thanks. That'll teach me to actually read a paper before citing it...

@Dennis No hard limits, I just edited that in.

@vihan Good find. This may count as a duplicate question then.

Please add a test case [2, 51, 6] -> 49 to force numeric sorting instead of the text one. See my solution (1st and 2nd revisions) for more details.

@Qwertiy Thanks, added.

I have a 13 byte Pyth solution that can do [2,3] in a reasonable amount of time and nothing else. [2,5] would create about a million Python lists in memory.

A tighter upper bound is $\min(n_i-1)(n_j-1)$, minimised over all pairs of coprime elements of the sequence.

Pyth, 23 bytes
ef!fqTs.b*NYQY^UTlQS*FQ

It's very slow, as it checks all values up to the product of all the coins. Here's a version that is almost identical, but 1) reduces the set of coins to those not divisible by each other and 2) only checks values up to (max(coins) - 1) * (min(coins) - 1) (47 bytes):
=Qu?.A<LiHdG+GHGQYef!fqTs.b*NYQY^UTlQS*thSQteSQ

Explanation
                   S            range 1 to
                    *FQ         product of input
 f                             filter by
               UT                range 0 to T
              ^  lQ              cartesian power by number of coins
   f                            filter by
      s.b*NYQY                   sum of coin values * amounts
    qT                           equals desired number T
  !                             nothing matching that filter
e                             take last (highest) element

Perl, 60 54 51 bytes
50 bytes code + 1 bytes command line
$.*=$_,$r.=1x$_."|"}{$_=$.while(1x$.--)=~/^($r)+$/

The basic approach is to let the regex engine do the hard work with string matching. For example, it will construct a regex similar to ^(.{3})*(.{7})*(.{8})*$ and match against a string of length n where n descends from the product of the inputs until it fails to match.
Note that this will become exponentially slow as the number of arguments increases.
Usage:
Arguments are read in from STDIN (new line separated), for example:
printf "101\n10" | perl -p entry.pl

R, 84 78 72 bytes
For an arbitrary entry of coprimes, \$a_1, a_2,\ldots\$, Frobenius' amount is given by
a=scan();max((1:(b<-min(a)*max(a)))[-colSums(combn(outer(a,0:b),sum(!!a)))])

Try it online!
since it is always smaller than the product of the extreme \$a_i\$'s. It is then a matter of combining all possible combinations (and more) within that range. Thanks to Cole Beck for suggesting outer with no "*" and colSums rather than `apply(...,2,sum)'.
A faster but longer (by two bytes) version only considers max(a):
a=scan();max((1:(min(a)*(b<-max(a))))[-colSums(combn(outer(a,0:b),sum(!!a)))])

A slightly shorter version (72 bytes) that most often takes too log or too much space to run on Try it online is
a=scan();max((1:(b<-prod(a)))[-colSums(combn(outer(a,0:b),sum(!!a)))])

Python2, 188 187 bytes
def g(L):
 M=max(L);i=r=0;s=[0]*M;l=[1]+s[1:]
 while 1:
    if any(all((l+l)[o:o+min(L)])for o in range(M)):return~-s[r]*M+r
    if any(l[(i-a)%M]for a in L):l[i]=1
    else:r=i
    s[i]+=1;i=(i+1)%M

The second indentation is rendered as 4 spaces on SO, those should be tabs.
Actually a 'fast' solution, not bruteforce, uses 'Wilf's Method' as described here.

Javascript ES6, 120 130 126 128 127 125 chars
f=a=>`${r=[1|a.sort((a,b)=>a-b)]}`.repeat(a[0]*a[a.length-1]).replace(/./g,(x,q)=>r[q]|a.map(x=>r[q+x]|=r[q])).lastIndexOf(0)

Alternative 126 chars version:
f=a=>{r=[1];a.sort((a,b)=>a-b);for(q=0;q<a[0]*a[a.length-1];++q)r[q]?a.map(x=>r[q+x]=1):r[q]=0;return r.join``.lastIndexOf(0)}

Test:
"[3, 7, 8] -> 5\n\
[25, 10, 16] -> 79\n\
[11, 12, 13, 14, 13, 14] -> 43\n\
[101, 10] -> 899\n\
[101, 10, 899] -> 889\n\
[101, 10, 11] -> 89\n\
[30, 105, 70, 42] -> 383\n\
[2, 51, 6] -> 49".replace(/(\[.*?\]) -> (\d+)/g, function (m, t, r) {
  return f(JSON.parse(t)) == r
})

You can replace the forEach( with map(

Ruby, 108 bytes
->a{b=[0];m=a.min
(1..1.0/0).map{|n|c=p
a.map{|x|c|=(b!=b-[n-x])}
c&& b<<=n
return n-m if b[-m]&&b[-m]>n-m}}

Try it online!
Explanation
->a{                                         input list
    b=[0];                                      list of representable integers
        m=a.min                                     minimum input
    (1..1.0/0).map{|n|                       n in range 1..
        c=p                                    c = false
          a.map{|x|c|=(b!=b-[n-x])}              check if n goes in b
            c&& b<<=n                                   put n in b
              return n-m if b[-m]&&b[-m]>n-m}}            return if m values in a row

authors: Xi'an ні війні