text:
Play Best Card in Euchre
Input:
Firstly
An array of three cards representing the cards played by each player formatted like
[JD][TH][9S]

Representing
Jack of Diamonds, 10 of Hearts, and Nine of Spades.

As you always sit across from your team-mate in Euchre, the second element represents your team mate's play. Here, the TH.
Secondly
A Single Char, String, etc representing the trump suit formatted like
S, D, C, H

representing
Spades, Diamonds, Clubs, Hearts

Thirdly
an array of four cards representing your hand formatted like
[KD][JC][QH][AS]

representing
King of Diamonds, Jack of Clubs, Queen of Hearts, Ace of Spades

Objective:
Given the three inputs, output the best possible card to add to the cards that have been played such that it meets the following criteria:

It takes the hand if it can, if not output the least valuable card
It takes the hand if it can, however it will not trump your team mate unless it is unavoidable
If it can take the hand, it does so by using the least valuable card. (If you have an ace and a queen that can win the hand, you play the queen).
Any plays must follow suit as required by the rules at the bottom.

Output format like [JD]
Formatting
A - Ace
K - King
Q - Queen
J - Jack
T - Ten
9 - Nine

H - Hearts
D - Diamonds
S - Spades
C - Clubs

TH, 9D, JD, QH, AD, 9C, TC

Examples
In: [QD][KD][9C], "C", [AH][JH][QH][9H]
Out: 9H
Reason: As clubs are trump, the 9C is winning the hand, we are unable to take the hand so we should discard our lowest card, here the 9H
In: [QD][KD][AD], "H", [AH][JH][QH][9H]
Out: 9H
Reason: As Hearts are trump, the Ace of Diamonds is currently winning the hand, we are able to trump the hand so we should use our lowest card, here the 9H
In: [QD][KD][TD], "D", [AD][JH][QH][9D]
Out: 9D
Reason: As diamonds are trump and we are currently winning the hand, we should play the 9D because our partner currently is winning the hand, so we want to play the 9D over the AD
In: [QH][KH][JH], "D", [AD][JD][QH][9D]
Out: QH
Reason: As Diamonds are trump our opponents are winning with the left Bower JH We have the right bower but cannot trump him because QH was led and we must follow suit, the QH
In: [QH][KH][JH], "D", [AD][JD][QC][9D]
Out: JD
Reason: As Diamonds are trump our opponents are winning with the left Bower JH We have the right bower and since we have no Diamonds we can trump over him with the JD
Euchre Card Strengths
If Hearts is trump:
JH
JD
AH
KH
QH
TH
9H

See the Euchre Rules if you are unfamiliar with the strength of different cards in Euchre
Since this is Code-Golf the shortest code wins!
Good Luck and have fun!

I think the play should be described here not with a link.

@JonathanAllan I thought about it, but it is better described in the link. Probably not the best challenge for those who are unfamiliar with the game. Unless they want to learn on the fly.

The example with 9D as the result has hearts set as trumps (although I don't think it affects this result).

@JonathanAllan nice catch, thank you.

Would it maybe be better if 10 was denoted as T? Would make the card parsing less of a headache.

Good idea, I will make the change

Why take a trick that your partner has already won?

@Sparr the 2nd-to-last test case addresses this: In: [QH][KH][JH], "D", [AD][JD][QH][9D] Out: QH. We play the QH because our partner already won. Although, this hand is not possible in euchre because it has the QH both in-play and in-hand.

I'm more asking from a strategy standpoint. Seems like bad euchre play.

@Sparr because the first card played was [QH] meaning the rest of the play is hearts by default. So you would only be able to play [QH] because you have a hearts card so you have to play it. I think that's how this game works, at least a similar Chinese card game works this way.

I just read the examples and it seems like they match my expectations and violate the objective. I think whoever wrote this used "trump your team mate" when they meant any play over them, not just trumps?

Would the rules be better stated as this? 1) If your team mate is winning, play the lowest ranked legal card. 2) If your team mate is losing, play the lowest ranked legal card that wins the hand if you can, otherwise play the lowest ranked legal card.

Yes, that is a clearer and more concise description of the objective. 'Legal card' is defined as cards matching the lead suit (the suit of the first card played), or all cards if no cards in-hand match the lead suit. 'Trump' is considered a suit, and the Jack of the same color as trump is considered trump (not its actual suit). 'Lowest ranked' is defined as: Jack of trump > Jack of same color as trump > (A > K > Q > T > 9) of trump > (A > K > Q > J > T > 9 of lead suit) > all other cards.

Agreed but its been 2 years go golf something else :)

@jacksonecac thanks for the problem, I had fun with it.

Perl - 557 532 511 490 482 384 363
($p,$t,$h)=@ARGV;%L=(H=>D,D=>H,C=>S,S=>C);$B=%L{$t};$_="\]$p$h\[";s/(.$t)/0$1/g;s/J$B/01$B/;s/0J/00/;s/J/R/g;s/9/Z/g;($T,@C)=split/\]\[/,$_;$s=$C[0];$s=~s/.+(.)/$1/;$s=~s/$t/0/;$X=(sort@C[0..2])[0];@M=@C[3..6];@F=(grep{/$s/}@M);@M=@F if@F;$w=(sort@M)[@M-1];push@M,$X;foreach$g(sort@M){$g ne$X?$b=$g:last}$_=$C[1]eq$X||!$b?$w:$b;s/.(..)/$1/;s/Z/9/;s/0|1|R/J/;print

How it works
Try it online!
First it reads args and finds the left-bauer's suit (jack of the same color as trump) with a hash lookup:
($p,$t,$h)=@ARGV;
%L=(H=>D,D=>H,C=>S,S=>C);
$B=%L{$t};

Then it combines all cards into one string and does some replacements, making the cards naturally sort in the correct order for euchre:
$_="\]$p$h\[";
s/(.$t)/0$1/g; # trump cards start with '0'
s/J$B/01$B/;   # left-bauer's 'J' changes to '01', making it trump
s/0J/00/;      # right-bauer's 'J' changes to '0'
s/J/R/g;       # all other jacks have 'J' changed to 'R'
s/9/Z/g;       # all 9s change to Z
($T,@C)=split/\]\[/,$_;

At the end of this block, the card string is then split on the brackets, which builds an array of all cards where:

index 0 = opponent's lead card
index 1 = teammate's card
index 2 = other opponent's card
indices 3-6 represent the hand

The lead suit is parsed from the first card, but the suit changes to '0' to represent trump if trump was led:
$s=$C[0];
$s=~s/.+(.)/$1/;
$s=~s/$t/0/;

The best card in-play is found by sorting the first three cards and retrieving the first card:
$X=(sort@C[0..2])[0];

The playable cards are found. If any cards in-hand match the lead suit, then only those cards remain. Otherwise all cards are considered playable:
@M=@C[3..6];
@F=(grep{/$s/}@M);
@M=@F if@F;

The 'throwaway' card is found by returning the last card in the sorted array of playable cards:
$w=(sort@M)[@M-1];

The lowest 'winning' card that can win the trick is found by adding the highest card in-play to the array of playable cards, sorting the array, and iterating over it until the highest card in-play is found. The 'winning' card is the card from the previous iteration:
push@M,$X;
foreach$g(sort@M){$g ne$X?$b=$g:last}

The correct play is then evaluated. The 'throwaway' card is chosen if any of the following are true:

The best card on the table has an index of 1 in the unsorted array of all cards, meaning it belongs to our teammate
The search for the lowest 'winning' card came up null, meaning our opponent's best card is higher than all cards in the hand

Otherwise the 'winning' card is returned:
$_=$C[1]eq$X||!$b?$w:$b;
s/.(..)/$1/; # remove the '0' that indicated trump
s/Z/9/;      # get those 9s back
s/0|1|R/J/;  # fix the jacks
print


text:
North by North by North by South East
Given a string of N, S, E and W, output a bearing (angle clockwise from North in degrees), correct to 5 decimal places.
In traditional compass notation, a string is made up of only 2 of these characters (like NNW or ESE). Here you must also accept strings that contain all 4 (like WNNNSE). Using only 2 symbols allows humans to intuitively understand the meaning. Allowing 4 symbols makes it horrible to read, but allows shorter ways of describing a bearing to a given accuracy.
(As pointed out in the comments by user2357112, it turns out you can prove that for any given bearing, the 4 symbol string will be exactly the same length as the 2 symbol string, so I've based this challenge on a false assumption. Hopefully this lack of a practical purpose doesn't detract from your enjoyment of the challenge...)
The exact method is described below, and is equivalent to the traditional notation (it expands on it rather than changing it).
Input

The input is a single string containing only the characters NESW.
The input may be a sequence of characters if you prefer, provided this does not include any preprocessing. For example, taking a nested list [N, [E, [S, [W]]]] to help with the order of processing is not permitted.
Taking different characters is not permitted. You may not take a string of 1234 instead of NESW.

Output

The output must be a decimal number or string representation of one (not a rational/fraction).
Trailing zeros do not need to be displayed. If the bearing is 9.00000, then the output 9 also counts as correct to 5 decimal places.
The output is in the range [0, 360). That is, including 0 but excluding 360.
Correctness is checked by rounding the output to 5 decimal places. If the bearing is 0.000005, this rounds to 0.00001. Outputs 0.00001 and 0.000005 are both correct.
Output in scientific notation for some inputs is acceptable. For example, 1e-5 instead of 0.00001.

Conversion

The single character compass points N, E, S, and W correspond to 0, 90, 180, and 270 degrees respectively.
Prepending one of these to a string results in the bearing that bisects the bearing of the single character and the bearing of the original string.
The closest of the two possible bisecting bearings is chosen, so that NE represents 45 degrees, not 225 degrees.
This is unambiguous except where the angle to be bisected is 180 degrees. Therefore NS, SN, WE, and EW correspond to undefined bearings, and the input will never end in any of these. They may however appear anywhere else in the input string, as this causes no ambiguity.
If the final two characters are identical, the final character will be redundant as the bisection will return the same bearing. Since this adds nothing to the notation, your code does not need to handle this. Therefore NN, EE, SS, and WW correspond to undefined bearings, and the input will never end in any of these. They may however appear anywhere else in the input string.

Examples
N: 0
E: 90
S: 180
SE: halfway between S and E: 135
NSE: halfway between N and SE: 67.5
NNSE: halfway between N and NSE: 33.75
NNNSE: halfway between N and NNSE: 16.875
NNNNSE: halfway between N and NNNSE: 8.4375

Test cases
A submission is only valid if it gives correct output for all of the test cases. Note that the test cases push to the limits of what can be handled with double precision. For languages that default to single precision, you will probably need to spend the bytes to specify double precision in order to get correct outputs.
Test case outputs are shown rounded to 5 decimal places, and also to arbitrary precision. Both are valid outputs.
WNE 337.5 337.5
WEN 337.5 337.5
WEWEWEWEWEWEWEWEWEWEWEN 330.00001 330.000007152557373046875
NESWNESWNESWNESWNESWNESWNESW 90 89.99999932944774627685546875
NNNNNNNNNNNNNNNNNNNNNNNE 0.00001 0.0000107288360595703125
NNNNNNNNNNNNNNNNNNNNNNNW 359.99999 359.9999892711639404296875
SNNNNNNNNNNNNNNNNNNNNNNNE 90.00001 90.00000536441802978515625
SNNNNNNNNNNNNNNNNNNNNNNNW 269.99999 269.99999463558197021484375

Scoring
This is code-golf. The score is the length of the source code in bytes, and the shortest wins.

Pedantry

 I made the mistake of thinking that "North by North West" was a valid compass direction. A happy mistake, since it led to a challenge idea, but I then discovered from the Wikipedia page:
"The title of the Alfred Hitchcock 1959 movie, North by Northwest, is actually not a direction point on the 32-wind compass, but the film contains a reference to Northwest Airlines."
It also turns out that the method used for this challenge is only consistent with traditional compass points up to and including the 16 point compass. The 32-wind compass described on that page is subtly different and I have conveniently overlooked its existence for this challenge.
Finally, for anyone who thinks I should use "Southeast" instead of "South East", it seems to be a regional difference.

WNNNSE <= what would be the output for this example entry at start of your post ? it sounds invalid for me, but it's hard to tell.

@Tensibai For input WNNNSE the output would be 323.4375. See the example section for a walkthrough that would apply in the same way to this case.

Is input like f(N,N,N,S,E) okay?

@KarlNapf I've expanded the input section to clarify. If I understand correctly, your example input with multiple arguments seems equivalent to a sequence of characters, so it would be acceptable.

Is scientific notation accepted as output? For example, 1e-5 instead of 0.00001 when taking "NNNNNNNNNNNNNNNNNNNNNNNE" as input.

@Osable I've edited the output section to allow scientific notation.

As ever, I upvote for a good explanation.

@trichoplax I made the mistake of thinking that "North by North West" was a valid compass direction What? It is a valid compass direction. The Wikipedia page you linked to even says so. It's listed under "16-wind compass rose" as well as in the table of "32 cardinal points".

@mbomb007 I thought that section would clear up the pendantry :P Oh well, here goes: NNW (which I used to think was called "North by North West") is a point on the 16-wind compass, but it is called "North-Northwest". The names containing "by" are from the 32-wind compass, which puts the Northwest first, giving "Northwest by North". Note that NNW, called North-Northwest on the 16-wind compass, is a different direction than NWbN, called Northwest by North on the horribly confusing 32-wind compass (see 30 & 31 of 32). Hence my decision to quietly pretend the 32-wind compass never happened...

@trichoplax Same diff. As long as it's NNW, we know what you mean. Agreed. What 32-wind compass. That's what degrees are for.

Related topic but that one is a Kolmogorov complexity challenge.

"Allowing 4 symbols makes it horrible to read, but allows shorter ways of describing a bearing to a given accuracy." - are you sure about that? It seems like all inputs that describe the same bearing have the same length, since if you assign each bearing a dyadic rational from 0 to 1, a length-N string with N>1 always corresponds to a dyadic rational with denominator 2^(N+1) in lowest terms. Also, allowing more than 2 distinct letters in a bearing adds no expressive power; any bearing expressed with 3 or 4 letters can be expressed with 2.

@user2357112 Thank you for this insight! Yes, your explanation is correct (excluding precisely those strings excluded by the challenge). I thought that "to a given accuracy" would make a difference, since there will then be a range of different values that are close enough, but it turns out that even if you find the shortest string that gives a bearing that rounds to the desired accuracy, there is a string of that length containing only 2 symbols. So much for my plan for another challenge to find the shortest string - it becomes trivial with only 2 symbols...

JavaScript (ES6), 84 80 78 74 72 bytes
Saved a byte thanks to @Titus, 1 thanks to @Neil
f=([c,...s],b="NESW".search(c))=>b*90-(s[0]?(b-=f(s)/90)-4*(b*b>4):0)*45

It took a while, but I think I've finally perfected the formula...
Test snippet

f=([c,...s],b="NESW".search(c))=>b*90-(s[0]?(b-=f(s)/90)-4*(b*b>4):0)*45
g=(s,n)=>console.log('f("'+s+'"):',f(s),"expected:",n)

g("N", 0)
g("NE", 45)
g("E", 90)
g("SE", 135)
g("S", 180)
g("SW", 225)
g("W", 270)
g("NW", 315)
g("WNE", 337.5)
g("WEN", 337.5)
g("WEWEWEWEWEWEWEWEWEWEWEN", 330.00001)
g("NESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESW", 90)
g("NNNNNNNNNNNNNNNNNNNNNNNE", 0.00001)
g("NNNNNNNNNNNNNNNNNNNNNNNW", 359.99999)
g("SNNNNNNNNNNNNNNNNNNNNNNNE", 90.00001)
g("SNNNNNNNNNNNNNNNNNNNNNNNW", 269.99999)

Explanation
Let's start with the simplest case: a single-char string. The result is simply its (0-indexed) position in the string NESW, multiplied by 90.
For a two-char string, the result lies halfway between the result of the first char and the result of the second. However, there's a catch: if the absolute difference between the two is greater than 180 (e.g. NW or WN), we must 180 to the angle so that it's not pointing the opposite direction.
For any longer string, the result lies halfway between the result of the first char and the result of the rest of the string. This can be generalized in the following way:

If the input is a single char, return its index in the string NESW times 90.
Otherwise, return the index of the first char in the string NESW times 45, plus half the result of the rest of the string; add an extra 180 if the absolute difference between the two is greater than 90.

Excellent way to cutting the first character off the string! You can save one byte if you calculate with values divided by 45.

@Titus I can save 2 bytes with that technique, thanks!

search instead of indexOf to save you a byte.

@Neil Thanks again! I managed to golf off three more by completely rearranging the equation.

C#6, 226 217 207 185 bytes
using System.Linq;double N(string s){double b=f(s.Last());foreach(var c in s.Reverse()){b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0))/2;b=(b+4)%4;}return b*90;}int f(char x)=>"NESW".IndexOf(x);

Edit: -10 bytes by "borrowing" idea from ETHproductions's submission
-22 bytes thanks to @Titus
Ungolfed
// Call this method
double N(string s){
    // Initialize bearing with last direction
    double b=f(s.Last());
    // Do backward. Doing last direction once more doesn't impact result
    foreach(var c in s.Reverse()){
        // Average current bearing with new bearing, adjusted with wrapping
        b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0))/2;
        // Make bearing back to range [0,4)
        b=(b+4)%4;
    }
    // Change from "full circle = 4" unit to degree
    return b*90;
}
// helper method to convert direction to bearing. This returns bearing with full circle = 4.
int f(char x)=>"NESW".IndexOf(x);

I think you can make your range adjustment back to [0,360) shorter by using %

@trichoplax Won´t that cut the decimals?

@Titus C# % works for floats as well as integers.

Save 10 bytes with b=(b+360)%360; instead of b+=b>360?-360:b<0?360:0;. Save another 12 bytes with dividing everything by 90 and return b*90;.

Here are 10 more bytes: merge the two assignments and remove braces: b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0)+8)/2%4; then distribute +8 to the ternary results b=(b+f(c)+(b-f(c)>2?12:f(c)-b>2?4:8))/2%4;

Convert your methods to Funcs i.e. Func<string, double> and Func<char, int> saves around 28 bytes although I may have miscounted

@TheLethalCoder I think I tried Func<char,int> and it was worse. I can try Func<string,double> but I need to qualify it with System.Func. Will try

You do not need to include the Func in the byte count only s=>.... see: http://codegolf.stackexchange.com/a/90139/38550, note that answer also makes use of currying

PHP, 95 88 86 100 127 104 101 bytes

-7 bytes with the null coalescing operator
-2 bytes by not replacing N (and more, because that allows to put the translation to the loop head: N is truthy, but evaluates to 0 in the calculation.)
+41 bytes for fixing the bisection (cough)
-7 bytes directly and -16 indirectly inspired by @ETHproductions´ code
-3 bytes by replacing strtr with one of my bit jugglings

for($i=strlen($s=$argv[1]);$i--;$p=($q+$p=$p??$q)/2+2*(abs($q-$p)>2))$q=ord($s[$i])/.8+3&3;echo$p*90;

This is officially the first time ever that I use the null coalescing operator. Run with -r.
PHP 7.1
Negative string offsets in the upcoming PHP version will save 12 bytes:
Replace strlen($s=$argv[1]) with 0 and $s with $argv[1].

Free bytes for (almost) everyone:

Calculating with 0,1,2,3 instead of 0,90,180,270 and multiplying the final result with 90 will save two bytes and probably allow further golfing.
There are some patterns in the ASCII codes of the characters. Try one of these in your language:

(a/2%6+2)%5
a<87?a/2&3^3:3 or a/2&3^3*(a<87)
a&1?a&2|a/4&1:0
a/.8-1&3

C, 184 bytes
double h(char c){return ((c=='E')+(c=='S')*2+(c=='W')*3);}double d(char*s){double f=h(*s);if(s[1]){double t=f;f=(f+d(s+1)/90)/2;if(((t-f)>1)||((f-t)>1))f+=2;if(f>=4)f-=4;}return f*90;}

Ungolfed
// a helper function
double direction_(char ch)
{
    if (ch=='N')
        return 0.;
    else if (ch=='E')
        return 90.;
    else if (ch=='S')
        return 180.;
    else
        return 270.;
}

// this is the main function to call
double direction(char* str)
{
    double fAngle = direction_(str[0]);
    if (str[1])
    {
        double tmp = fAngle + direction(str+1);
        if (tmp>=360.)
            tmp-=360.;
        tmp/=2;

        if (((tmp-fAngle)>90.) || ((tmp-fAngle)<-90.))
        { //  check if we need to take the "other side"; if the resulting angle is more than 90 degrees away, we took the wrong on
            if (tmp>=180.)
                tmp-=180.;
            else
                tmp+=180.;
        }
        fAngle = tmp;
    }
    return fAngle;
}

seems that using float, doesn't give you the precision needed.

Welcome to PPCG! :D

Won't the names of the functions conflict with each other (since the names are both d)?

@qwerp, different signature (one takes char*, other takes only char)

So C++ automatically chooses the correct one based on the argument? Huh, TIL. Also, welcome to PPCG!

yes Qwerp, the strong typing in C (and C++) means that the type in the argument list, make it a part of the function signature.

I think you can save 14 bytes with dividing everything by 90; maybe more if that can give you a different approach on the helper function.

@titus my golfed helper function has the 90 degrees factored out.  now if I were to factor out the 90 degrees from the main function, I'll need to warp it by another function that will multiply the result by 90 degrees.  not sure that will save 14 bytes

saves 6 bytes by doing it this way (multiplying by 90 before the return, and dividing by it after the recursive call).

Function names are not name mangled in C, as they are in C++, so you need to rename one of them if you want it to be C.

changed the helper function to h

Python 3, 133 113 bytes
Just improving on @L3viathan's answer because I just made this account and therefore can't make comments yet.
d={"N":0,"E":.5,"S":1,"W":1.5}
def B(s):
 b=d[s[-1]]
 for c in s[::-1]:b=(b+d[c])/2+(abs(b-d[c])>1)
 return b*180

Welcome to Programming Puzzles & Code Golf, and nice improvement...

I didn't see your answer, but Titus had a similar idea, plus I had another, I'm down to 98 now :)

Python 3, 146 145 117 107 97 94 93 92 bytes
f(s):u='NESW'.find(s[0])*90;return(u+f(s[1:]))/2+180*(abs(u-f(s[1:]))>180)if s[1:]else u

Call f with the string.

You can't have the two ...0else they throw SyntaxErrors.

@JonathanAllan What version of Python are you using? I'm on 3.5.2 and it works.

I ran it on 3.3.3 - can you remove the space between else and - too? (can in 3.3.3)

@JonathanAllan Yes I can! Thanks, that saves me another byte.

You can save 6 bytes with dividing everything by 90 and returning 90*b; 3 more with d='NESW' and d.find(...).

@Titus: Thanks! Plus another one by putting d inside the function.

Can assigning d.find(c) to a variable save anything? I guess not because that variable would have to be declared first.

@Titus d.find can, I had the exact idea a minute ago; see updated answer.

f='NESW'.find is very elegant. I was about to test this, thinking "but the parentheses are missing from find!", then I realised it makes a function which you reuse. Beautiful

@trichoplax I assume I can also ask the user for input and print the output? Then I could save another 3 bytes.

According to our defaults for input and output, yes and yes. Go for it.

I'm getting 94 bytes for what you have so far, not 95. ( https://mothereff.in/byte-counter ) Also: you can save a byte by doing s=input()[::-1] (and just doing for c in s: in your loop), and initializing b=f(s[0]).

@mathmandan Good point about the s=input()[::-1], but I get 94 bytes with that improvement. Using wc -c to count. Edit: You're right, for some reason my file has a final newline.

OK, we can get to 92 by writing it as a recursive function: def f(s):u='NESW'.find(s[0])*90;return(u+f(s[1:]))/2+180*(abs(u-f(s[1:]))>180)if s[1:]else u.  Note that this is tremendously inefficient: it calculates f(s[1:]) twice, which means that adding one to the input length will double the runtime.  So its runtime is exponential in the input length--compared to what you have now, which is linear!  On the other hand, it's one byte shorter, so...

05AB1E, 48 42 37 32 bytes
Saved 6 bytes thanks to Emigna.
Saved 5 bytes thanks to Titus' idea to work on range [0,4[ and multiply by 90 at the end.
Saved 5 bytes thanks to Adnan's mastery of ancient xor/modulo metamorphosis.
So every angle is reduced from range [0,360[ to range [0,4[ throughout the execution. Result is then multiplied by 90 and displayed.
Ç30^5%R¬U¦vXy+;DX-Ä0›2*+4%U}X90*

It can be divided into two sequentially called subprograms.
First program: convert input string into an array of the corresponding angles in range [0,4[
Ç      Take the ascii value of all input characters
 30^5% Dark ascii manipulation that yields [0,1,2,3] for [N,E,S,W]

Now we have an array of integers in range [0,4[.

Second program: actually compute the final angle
R                          Reverse the array
 ¬                         Take the first value (the last of the non-reversed array)
  U                        Pop it from the stack and set X to the same value
   ¦                       Strip the first element
    v                      For each remaining element
     Xy+;                  Compute the average value between the leftmost value and X
         DX-Ä0›            Push 1 if angular distance cast to integer is > 0 (i.e. if it is >= 1), 0 otherwise. It's equivalent to checking >= 90 degrees
               2*+         Multiply by 2 (=2 if angular distance is >= 1 and 0 otherwise) and add it to the formerly computed average value. It's equivalent to multiplying by 180
                  4%       Perform mod 4. It's equivalent to performing mod 360
                    U      Store the result back to X
                     }     End for, mandatory if input has only one character
                      X90* Push X*90 and implicitly display it

Try it online!
Potential axes of golfing:

Not sure if that mod 4 is required (it would save 2 bytes). All test cases work without it, but maybe there exists a tricky case. A mathematical proof to either validate it or nullify it would be top-notch.
There is no implicit stuff besides displaying the result (closing quote marks, closing brackets).

Doesn't seem to give the requested result on the NNNNNNNNNNNNNNNNNNNNNNNE and SNNNNNNNNNNNNNNNNNNNNNNNE test cases.

Also, there are at least 6 bytes to save in your solution, but I don't know if there is much point in doing it before it's fixed.

I get respectively 1.0728836059570312e-05 and 90.00000536441803, which are the requested results if I'm not wrong. OP said that scientific notation was fine.

Weird. Now I do as well. I must have pasted wrong or something, sorry. You can shorten the code down to v"NESW"yk90*})R¬U¦vXy+;DX-Ä89›180*+360%U}X.

Seems I had an extra space at the end of the test cases :)

Ok I thought something went wrong. Thanks for the golfing!
I actually found out about 89›, but is it a bug or a feature? I initially started with 90› but it took some time to realize where the error did come from.
Edit: Wow, surprisingly never used U/X before, nor V/Y.
Also do you have any insight about the mod 360 being mandatory or not?

Not sure what you mean by bug or feature. You had 90‹_ meaning not lesser than 90 which is the same as 89› meaning greater than 89. I haven't looked into the math behind it so I'm afraid I can't answer about 360.

Actually i had this problem when trying to understand why the following test case wasn't right: NESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESW. Here you can see a minimal example, where the absolute value of the diff and the comparison >90 are displayed.
I get false with 90.3515625 > 90
http://05ab1e.tryitonline.net/#code=diJORVNXInlrOTAqfSnCpMKpXFvCqERnXyPCpMKuKztEwq4tw4Q9OTDigLo9MTgwKiszNjAlwqlzXVw&input=V05FU1dORVNX

Oh I deduce from the code that both operands are evaluated as integers before the comparison, so it's more like a feature than a bug. However it is still disturbing if you don't know that ^^ . A better example would be 3;1›. It is supposed to evaluate 1.5>1 and yields a falsy value.

Ah yes, now I follow what you mean. There are indeed a bunch of quirks/features in the language that aren't obvious until you actually run into them :)

Great explanation! It might be worth including a note that 89› actually means the integer part is greater than 89, which is equivalent to saying the complete number is greater than or equal to 90 (which still works fine because exactly 90 should never occur). Currently the comment in the explained code makes it sound like it's checking for greater than 89, whereas your code passes the test cases so is clearly correctly checking for greater than 90.

I edited the explanation so, however I wrote "cast to integer" since I'm not sure how the operator › should behave towards negative floating point values. There is no problem here since it works on the absolute value, but I prefer not making too strong assumptions on the operator.

You can replace v"NESW"yk}) with Ç30^5% :)

That's a hell of a hack. I like it!

I found other ways to do it using ascii codes, but they were 7 bytes long. Nice trick :) .

R, 172 146 bytes
z=rev((0:3*90)[match(scan(,""),c("N","E","S","W"))]);p=z[1];l=length(z);for(i in 2:l)p=(p+z[i])/2+(abs(p-z[i])>180)*180;if(l<2)p=z;sprintf("%f",p)

Ungolfed
z=rev((0:3*90)[match(scan,""),c("N","E","S","W"))]); #1
p=z[1];                                              #2
l=length(z)                                          #3
for(i in 2:l)p=(p+z[i])/2+(abs(p-z[i])>180)*180;     #4
if(l<2)p=z                                           #5
sprintf("%f",p)                                      #6

Explained

Read input from stdin

Match input by index to c("N","E","S","W")
From matched indices: match to the vector of degrees 0:3*90 (instead of c(0,90,180,270))
Reverse and store as z

Initialize p to the degree equivalent to last char in input
Store length of input as l
Iteratively, calculate the closest of the two possible bisecting bearings.
If only one input is given, set p to z
Format and print

Try the test cases on R-fiddle
(note that this is a function due to scan not working on R-fiddle)

Provided that the output is correct to 5 decimal places, you don't need to perform the rounding. From the challenge: Outputs 0.00001 and 0.000005 are both correct. So you should be able to save some bytes by not rounding

@trichoplax I understand. Can the input also be a vector of string characters like. c("N","N","E") instead of "NNE"? This equivalent to a non-nested python list ["N","N","E"].

Yes. I intended "sequence" to be a general term to include things like arrays, vectors, lists, tuples.

I think you can save 4 bytes if you divide everything by 90 and printf(p*90).

Haskell, 109 105 103 bytes
h=180
a#b|abs(a-b)<h=n|n>h=n-h|1>0=n+h where n=(a+b)/2 -- calculates the new "mean" on the cirlce
f 'N'=0                                          -- translates characters to angles
f 'E'=90
f 'S'=h
f _=270
foldr1(#).map f                                  -- traverses the whole string

Thanks for -2 byte @xnor!

The exhaustive list for f looks long, but I'm having trouble finding anything shorter. Closest I got was f c=90*until(\i->"NESW"!!i==c)(+1)0 (35). I think you can replace 'W' with _.

Yeah I also expected there to be something shorter, but didn't find anything. Thanks for the _!

Dyalog APL, 55 45 38 bytes
Solution
Requires ⎕IO←0, which is default on many systems. Asks for direction.
360|÷○÷180×12○(+÷(|+))/¯12○○2÷⍨'NES'⍳⍞

Explanation
Goes around the problem by converting each letter to a complex number 1∠θ ⇔ a + b · i, then doing a sum reduction from right-to-left (APL's forte) while normalizing at each step. The final θ is then converted to degrees and normalized to be within [0, 360):
'NES'⍳⍞ the indices of each input letter in "NES"; N→0, E→1, S→2, anything else→3
○2÷⍨ convert to angles in radians; θ = π · x∕2
¯12○ convert to complex numbers on the unit circle; ei · θ
(...)/ reduce the list with... (i.e. insert the function between the elements of...)
 +÷(|+) ... the normalized sum; xn - 1 + xn∕|xn - 1 + xn|
12○ convert to angle; θ
÷○÷180× convert to degrees; 1∕π · 1∕180 · x
360| division remainder when divided by 360
TryAPL online!
Anecdote
If input and output was as orthogonal complex units, the entire solution would be just:
(+÷(|+))/

The rest of the code is parsing input and formatting output.

I notice the test outputs do not match those in the challenge to 5 decimal places, making this invalid. Does Dyalog APL have the option of using double precision?

@trichoplax Yes, ⎕FR←1287 makes use of 128 bit floats, but TryAPL doesn't allow it.

I think anything greater than or equal to 64 bit floats should work (I've only tested in Python though). Does this mean you can make the code valid but it will then only work for people who have installed the language? Maybe you could show the full valid code for the score, and include the online version that doesn't quite have the required accuracy so people can see that the algorithm is correct.

@trichoplax Actually, TryAPL uses double precision, but your test cases accumulate errors beyond 53 bits.

If it can be shown that the difference is due to differences in interpretation of the IEEE 754 standard, that are still standard compliant, then I'll adjust the test cases to make sure both interpretations give the same result to 5 decimal places. I chose the test cases such that they gave the same result to 5 decimal places in Python for both float (double precision) and arbitrary precision decimals. I'll have a look into it.

I'm still reading up on this, but just thought I'd check: do the slightly different results only happen with TryAPL  online? Do you get the same outputs locally or do they match the test case outputs when it's not online?

@trichoplax TryAPL is just a web frontend to an actual Dyalog APL running on a virtual Linux on one of our office servers. However, when I compare the TryAPL printed results with my local results (on Windows), I get a difference of 0 0 0 ¯0.00002146121247 5.082197684E¯21 0 0 0

Ah I see. So a slight difference but still not matching the test case outputs. This is clearly close enough that it isn't single precision, so I'll do a bit more reading and then probably tweak the test cases. At least I have your online implementation to test my new test cases with...

Let us continue this discussion in chat.

Sorry for the delay - I've replied in chat.

Common Lisp, 347 327 bytes
Thanks to @Titus for taking off a few
This can probably be golfed more, but at least it works (I think):
(defun d(c)(if(eql c #\N)0(if(eql c #\E)1(if(eql c #\S)2(if(eql c #\W)3)))))(defun m(a b)(if(> a b)(rotatef a b))(if(<(+(- 4 b)a)(- b a))(+(/(+(- 4 b)a)2)b)(+(/(- b a)2)a)))(defun f(s)(let((c))(setf c(d(char s(1-(length s)))))(do((a)(p(-(length s)2)(1- p)))((< p 0))(setf a(char s p))(setf c(m(d a)c)))(format t"~5$"(* c 90))))

Usage:
* (f "WNE")
337.50000
NIL

Function d takes a character N, E, W, or S and returns the appropriate degree. Function m gets the approprate combined degree of two given directions. Function f iterates through the provided string, computes the appropriate degree, and prints it as a floating point.

My LISP is rusty, but can dividing everything by 90 save 6 bytes?

@Titus I think it would. I've realized some other improvements so I'll add this when I'm at my computer

Befunge, 183 181 175 bytes
>~#+:#25#%6*#/`#2_$>5%4*:00p"Z}"4*:***20g#v_+2/00g10g-:8`\0\-8`+!v
v5:+*:*:"d"/+55+5$_^#!:\p01/**:*4"}Z":p020<%**:*"(2Z"+**5*:*"0}"!<
>5>+#<%#56#58#:*#/+\#5:#5_$$$,,,".">:#,_@

Try it online!
Explanation
This follows a similar algorithm to many of the other answers, only it's using fixed point calculations emulated with integers since Befunge doesn't support floating point.
Thanks to @Titus for the ASCII-to-int routine.
 ~ : 5 6* ` _$        while ((c = getchar()) > 30)  // ends with any ctrl char or EOF
> + 2 %6 / 2            push(c / 2 % 6 + 2)         // partial conversion to int

                      do {
  5%                    dir = pop() % 5             // completes the conversion to int
  4*:00p                dir *= 4; lowres_dir = dir  // used by the 180-flip calculation
  "Z}"4*:***            dir *= 22500000             // this is 90000000 / 4
  20g_                  if (!first_pass) {
    +2/                   dir = (dir+last_dir)/2    // last_dir is second item on stack
    00g10g-               diff = lowres_dir - last_lowres_dir
    :8`\0\-8`+!!          flip = diff>8 || -diff>8
    "}0"*:*5**+           dir += flip * 180000000   // add 180 degrees if we need to flip
    "Z2("*:**%            dir %= 360000000          // keep within the 360 degree range
                        }
  020p                  first_pass = false
  :"Z}"4*:**/10p        last_lowres_dir = dir / 22500000
  \                     last_dir = dir              // saved as second item on stack
  :!_                 } while (!stack.empty())

$                     pop()                         // this leaves the final dir on top
5+55+/                dir = (dir + 5)/10            // round down to 5 decimal places
"d":*:*+              dir += 100000000              // add a terminating digit
                      while (true) {                // convert into chars on stack
:55 + % 6 8 * +\ : _    push(dir%10+'0'); if (!dir) break
   > < 5 5 : /+ 5 5     dir /= 10
                      }

$$$                   pop() x 3                     // drop the chars we don't need
,,,                   putchar(pop()) x 3            // output first three chars
"."                   push('.')                     // add a decimal point
>:#,_@                while(c=pop()) putchar(c)     // output the remaining chars

Does that just mean you need to emulate a larger fixed point type (more decimal places)? The test cases are designed to require double precision, which is no more than 17 significant figures (a maximum of 16 decimal places), and 14 decimal places might possibly be enough.

APL (Dyalog Classic), 30 27 bytes
90×(4|2÷⍨+-4×2<∘|-)/'NES'⍳⎕

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:
5 Favorite Letters
The challenge is actually extremely simple. Pick 5 distinct letters (you can just pick the 5 that allow you the shortest code if you like) and output them to the console. However, the twist is that they must be from the following list:
 AAA      BBBB       CCCC     DDDD      EEEEE     FFFFF      GGG      H   H
A   A     B   B     C         D   D     E         F         G         H   H
AAAAA     BBBB      C         D   D     EEEE      FFFF      G  GG     HHHHH
A   A     B   B     C         D   D     E         F         G   G     H   H
A   A     BBBB       CCCC     DDDD      EEEEE     F          GGG      H   H

IIIII         J     K   K     L         M   M     N   N      OOO
  I           J     K  K      L         MM MM     NN  N     O   O
  I           J     KKK       L         M M M     N N N     O   O
  I       J   J     K  K      L         M   M     N  NN     O   O
IIIII      JJJ      K   K     LLLLL     M   M     N   N      OOO

PPPP       QQQ      RRRR       SSSS     TTTTT     U   U     V   V     W   W
P   P     Q   Q     R   R     S           T       U   U     V   V     W   W
PPPP      Q   Q     RRRR       SSS        T       U   U     V   V     W   W
P         Q  QQ     R  R          S       T       U   U      V V      W W W
P          QQQQ     R   R     SSSS        T        UUU        V        W W

X   X     Y   Y     ZZZZZ
 X X       Y Y         Z
  X         Y         Z
 X X        Y        Z
X   X       Y       ZZZZZ

Additional Rules:

5 of the same letter is not allowed, no repeat choices.
Each letter must use the capital of itself as the ascii-character to draw it.
Each letter output must be on the "same line" and have 5 spaces between each letter.
You may choose any 5 letters that you want, this will allow you to reuse some code and lower your byte count. Figuring out which letters will allow you to do this most efficiently is part of the challenge.
Trailing spaces are acceptable.
A single trailing newline is acceptable, no more than one trailing newline though.
This is code-golf, lowest byte-count wins.

Examples:
A B C D E
 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E
AAAAA     BBBB      C         D   D     EEEE
A   A     B   B     C         D   D     E
A   A     BBBB       CCCC     DDDD      EEEEE

E F L I P
EEEEE     FFFFF     L         IIIII     PPPP
E         F         L           I       P   P
EEEE      FFFF      L           I       PPPP
E         F         L           I       P
EEEEE     F         LLLLL     IIIII     P

C R A Z Y
 CCCC     RRRR       AAA      ZZZZZ     Y   Y
C         R   R     A   A        Z       Y Y
C         RRRR      AAAAA       Z         Y
C         R  R      A   A      Z          Y
 CCCC     R   R     A   A     ZZZZZ       Y

Don't be afraid to submit more than one answer with different letters or different strategies each time, this can be accomplished various different ways.

I like that you get to choose which letters to output; that adds another layer to the golfing. Minor issues with the ASCII art: there's a ton of trailing spaces, and two Js.

@ETHproductions Rofl, the 2 J's got past both ME and the sandbox, fixing.

Can you add a bonus for taking 5 letters as input?

Bonuses are frowned upon and there are too many answers to make a drastic change such as that. But I will give you an upvote ;).

Are leading blanks ok?

@Titus no, only trailing.

What about a leading linebreak instead of a trailing one?

@Titus I don't know why you'd need them; trailing makes more sense. If you can logically explain how a limitation of the language you are using and not the logic you've written is causing a leading \n, I will allow it.

Not needing them, they would only save a byte on my code.

@Titus then no. The trailing newlines and spaces are due to programmatic limitations of certain languages.

Jelly,  41  40 bytes
N.B. I have a 39 byte answer too.
LICTE
141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11“LICTE”K¤żⱮŒṙY

TryItOnline!
Idea
Use a run length decode with letters that have as similar middle as possible with only one run length of each "pixel value" per row per letter.
Put a flat start like "L" to avoid different run length decode values for the rows.
Place the one different letter (could not find 5) of the three middle rows at the end so the smallest difference may be added arithmetically.
Output wanted; the run lengths; and these converted from base 11:
                                                  L,  , I,  , C,  , T,  , E   value
                                                  -------------------------
L         IIIII      CCCC     TTTTT     EEEEE     1, 9, 5, 6, 4, 5, 5, 5, 5   399633415
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
L           I       C           T       EEEE      1,11, 1, 7, 1,11, 1, 7, 4   431646160+4
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
LLLLL     IIIII      CCCC       T       EEEEE     5, 5, 5, 6, 4, 7, 1, 7, 5   1179122455

The three values 399633415, 431646160, and 1179122455 in base 250 as Jelly code page indices are then ðƁ ƥ, ȷɓSɠ, and JrŀṘ which can be used to encapsulate the run-length information.
The code
141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11“LICTE”K¤żⱮŒṙY - Main link
141D                                     - 141 as a decimal list: [1, 4, 1]
     “ȷɓSɠ’                              - 431646160
    +                                    - add: [431646161, 431646164, 431646161]
           “ðƁ ƥ“JrŀṘ’                   - list [399633415,1179122455]
                      j                  - join: [399633415, 431646161, 431646164, 431646161, 1179122455]
                       ḃ11               - convert to bijective base 11: [[1, 9, 5, 6, 4, 5, 5, 5, 5], [1, 11, 1, 7, 1, 11, 1, 7, 1], [1, 11, 1, 7, 1, 11, 1, 7, 4], [1, 11, 1, 7, 1, 11, 1, 7, 1], [5, 5, 5, 6, 4, 7, 1, 7, 5]]
                                  ¤      - nilad followed by link(s) as a nilad:
                          “LICTE”        -   list of characters "LICTE"
                                 K       -   join with spaces   "L I C T E"
                                    Ɱ    - map across (the lists of numbers) applying:
                                   ż     -   zip             e.g. [['L',1],[' ',9],['I',5],[' ',6],['C',4],[' ',5],['T',5],[' ',5],['E',5]]
                                     Œṙ  - run-length decode e.g. "L         IIIII      CCCC     TTTTT     EEEEE"
                                       Y - join with line feeds

You did the idea I had initially that I was not smart enough to do in 05AB1E!!! Amazing job man.

Charcoal, 51 49 bytes (ECXKI)
Ｇ←⁵↓³→⁴EＭ⁷→Ｇ↑²↗²→⁴CＭ⁶→ＧＨ↘↗³XＭ⁶→ＧＨ↓→↗³KＭ⁸→ＰTIII‖Ｏ↓

Outputs
EEEEE      CCCC     X   X     K   K     IIIII
E         C          X X      K  K        I
EEEE      C           X       KKK         I
E         C          X X      K  K        I
EEEEE      CCCC     X   X     K   K     IIIII

Try it online!
Using characters that are vertically symmetrical, draws the top halves and then reflects. Most of these make use of Polygon (Ｇ) and PolygonHollow (ＧＨ) to draw a series of connected line segments with a particular character. I can more easily be done with MultiPrint (Ｐ), using T as the direction.
Note: PolygonHollow just draws the segments specified, without completing the polygon or filling it. Polygon will complete and fill (not what we want) if the polygon can be completed with a simple line in one of the eight cardinal or intercardinal directions. Otherwise, it behaves like PolygonHollow, for a savings of one byte.
The order of characters was chosen to require only horizontal moves from the endpoint of one to the start of the next. Here's how the cursor proceeds:

Nice. I was trying a charcoal solution but the lack of documentation honestly killed me

@Bassdrop Yeah, we're... um... working on that. [goes to add ＧＨ to the docs]

PowerShell v2+, 138 128 114 112 106 105 bytes (LICTD)
"L1    IIIII1 CCCC1TTTTT1DDDD
$("L11 I1  C11 T1  D   D
"*3)LLLLL1IIIII1 CCCC1  T1  DDDD"-replace1,'     '

The idea is to maximize the spaces between the letters so we can get repeated compressions.
Borrows the middle-row deduplication trick from Florent's answer. Saved 6 bytes thanks to Ben Owen by using string multiplication for the middle three rows, and an additional byte thanks to Matt.
Output is like the following at 227 bytes, for a 53.7% reduction --
PS C:\Tools\Scripts\golfing> .\5-favorite-letters.ps1
L         IIIII      CCCC     TTTTT     DDDD
L           I       C           T       D   D
L           I       C           T       D   D
L           I       C           T       D   D
LLLLL     IIIII      CCCC       T       DDDD

I love it when the first answer is something you didn't expect at all. Neat method.

How about $("L11 I1  C11 T1  D   D`n"*3) instead of the middle 3 lines

@BenOwen Excellent idea - thanks!

PHP, 107 104 102 94 86 bytes
Ok I'm confident I have the smallest possible source with this method now. I wrote a script to generate and then gzip every possible combination of five letters. There are two solutions that match for the shortest compressed -- LODIC and LDOIC. I'm going with the former because it's more fun to say.
Source:
<?=gzinflate(base64_decode('81GAA39/fwjDBQggLE8QgDCdgYDLB6EYioGqoRisHkrTSCUIEOtWAA'));

Output:
% php foo.php
L          OOO      DDDD      IIIII      CCCC
L         O   O     D   D       I       C
L         O   O     D   D       I       C
L         O   O     D   D       I       C
LLLLL      OOO      DDDD      IIIII      CCCC

you can save 2 bytes by dropping the 's: the string will get treated as a constant with a value of itself.

Damnit, I always forget to do that. :)

If L was your last letter you'd save more bytes too.

Nice exploiting of a loophole.

Which loophole?

The problem here is that you just compress the string, not the algorithm. I would have loved to see a compress program that you would eval

Compression is not a loophole and at this size, the uncompressor and evaluator would add more characters than the compression saves. I.e., eval()'ing compressed source code doesn't help until your code is well into the hundreds of bytes. Here is an example where I did just that.

Not very creative, is it ?

Creativity is subjective and immeasurable. The goal of the challenge is to minimize code size and this is the shortest entry for a non-golfing language.

I like this answer, because, although it seems unimaginative by just compressing the output, the fact that you found the shortest combination to compress shows that you actually put effort into the answer, rather than just choosing, say ABCDE, and compressing that

JavaScript, 110 109 bytes (CLOUD)
` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))

console.log(
` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))
)

Output is 227 bytes:
 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

Nice use of deduplication in the middle three rows.

ES6 (Javascript), 194, 181 bytes (IGOLF/ANY)
This one is long, and is not really optimized (not yet at least), but can be modified to print any particular message, by only changing the bitmap data.
EDIT: Replaced inner reduce with map, use bit shift for padding
Golfed
[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

Demo
[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

IIIII      GGG       OOO      L         FFFFF
  I       G         O   O     L         F
  I       G  GG     O   O     L         FFFF
  I       G   G     O   O     L         F
IIIII      GGG       OOO      LLLLL     F

Theory
Take a letter:
IIIII
  I
  I
  I
IIIII

convert it to binary matrix (bitmap)
11111
00100
00100
00100
11111

do the same for other 4 letters, scan a line, by taking "top" 5 bits off each
11111 01110 01110 10000 11111
convert to a hexadecimal string (should be using base36 or even printable ASCII here)
0x1f73a1f
apply the same algorithm to other 4 lines, to get the bitmap.
Render in the reverse order.

You can remove the parentheses in the regex to save 2 bytes :-)

[32979487,4736528,4834846,4769296,32979952]  is shorter than its hexadecimal representation

@ETHproductions True, will make use of this,  when I'll be back to optimize it. Thx!

You could replace /(1|0)/g by /\d/g to save a few bytes. Also \n could be replace by an actual new line.

is shorter than its hexadecimal representation
Yep, that is true (due to 0x), at least for these specific letters, I'll probably compress this into a continuous hex (or even Base32/Base36/ASCII) string, on the next iteration.

You could replace /(1|0)/g by /\d/g to save a few bytes. Also \n could be replace by an actual new line.
Yep, thank you for your tips, I will make use of them once I'm back to this one.

Also, (p+1)*b could be either p*b+b or -~p*b, saving 2 bytes.

05AB1E, 44 bytes
This was a fun one. I feel like I need to come back and try and golf it some more when I have time.
Uses CP-1252 encoding.
Inspired by carusocomputing's answer.
ECOIH
‘ÓÑOIHH‘SðýJ3×S•Td<UÕ‘áÓ?Â¢tWvkÔÚ•S)øü×J3äû»

Try it online!
Explanation
‘ÓÑOIHH‘ pushes the string "ECOOIHH".
SðýJ3×S joins the string by spaces, repeats it thrice and converts it to a list.
The resulting list is ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].
•Td<UÕ‘áÓ?Â¢tWvkÔÚ• pushes the number 564631055513119191317171314619131717500.
S)ø zips the list and the number together.
ü×J does pairwise string repetition and joins them together.
The result is the string EEEEE      CCCC      OOO      IIIII     H   HE         C         O   O       I       H   HEEEE      C         O   O       I       HHHHH.
3äû»splits that into 3 pieces, adds the first and second piece in reverse order and joins by newlines.

"•Td<UÕ‘áÓ?Â¢tWvkÔÚ• pushes the number 564631055513119191317171314619131717500" because why wouldn't it...

@geisterfurz007: To be more precise, it's the base-214 representation of the base-10 number :)

So potentially if you could go up to a higher base, your string would get shorter?

@geisterfurz007: If we could yes. Unfortunately 214 is the max in 05AB1E.

You can beat Jelly, I believe in you; 3 bytes left to go haha!

JavaScript (ES6), 96 bytes (DIOCL)
`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d))

The idea here is to not only make the middle three lines identical, but also make the first line nearly identical to the last. Since there are only 4 letters that perfectly fit this description CDIO, L is the next best option, as it only requires 4 added characters at the end of the string.
As with Florent's answer, this is a snippet that returns the result. Add 3 bytes if it needs to be a function.
Test snippet

console.log(`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d)))

You can save a byte by putting the D first.

@Neil Thanks. I had to move the C past the I and O as well

Ah, right, you can't have the I immediately after the C, although interestingly doing that improves my Batch solution, for the same reason.

Bash+coreutils with figlet, 55440 solutions, 112 106 bytes each
 set H E L P D;for l;do figlet -f banner $l|sed "s/.//3;s/.//5;s/#/$l/g;2d;5d">$l;done;paste $@|expand -t10

Output:

H   H     EEEEE     L         PPPP      DDDD
H   H     E         L         P   P     D   D
HHHHH     EEEE      L         PPPP      D   D
H   H     E         L         P         D   D
H   H     EEEEE     LLLLL     P         DDDD

Hey, we already have a program for ASCII art! The banner font almost does the job, except it outputs 7x7 letters. Hmm, let's just remove the 3rd and 5th columns, and the 2nd and 5th lines, and see what it gives...
It turns out that many letters will be output the required way, namely, B D E F H J L P T U Z.
It suffices to replace the arguments of the first set command with any combination of those letters to still obtain a correct result! Hence, this gives us 11*10*9*8*7=55440 solutions, each of those being 106 bytes long.

My first thought when reading the challenge was "one has to use figlet to solve this"

05AB1E, 102 90 89 69 bytes (EOIXC)
•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ•34B2ð:2ôvy`×}J3äû»

Try it online!
Output (230 bytes):
EEEEE      OOOO     IIIII     X   X      CCCC
E         O    O      I        X X      C
EEEE      O    O      I         X       C
E         O    O      I        X X      C
EEEEE      OOOO     IIIII     X   X      CCCC

69 / 230 = 70% Compression

Explanation:
The theory was to pick vertically symmetrical letters, then encode the first 3 lines an palindromize them. Basically, I encoded as {#} of {Letter} in 2 byte pairs. I'm sure there's a better way to do this.
•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅrè‘¾)jM•34B
                    <decodes to>
"E5 6O4 5I5 5X1 3X1 6C4E1 9O1 4O1 6I1 8X1 1X1 6C1 4E4 6O1 4O1 6I1 9X1 7C1 4"

2ô            # Split into encoded pairs.
  vy   }      # Loop through each letter and number pair.
    `×        # Add the letter X number of times.
       J      # Join together.
        3ä    # Split into 3 parts length.
          û   # Palindromize.
           »  # Print separated by newlines.

-20 bytes thanks to Emigna, I'll be in the chat to ask some questions soon ;).

You can save 19 bytes by replacing the string with •Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅrè‘¾)jM•34B2ð:. Hop in the 05AB1E chat if you have questions about encoding.

Also, 45ô can be 3ä.

@Emigna A is not vertically symmetrical, and neither is F. Going to guess that once you start using G or higher it'll ruin what you're talking about right? Also, with my compression methodology I wanted to avoid letters that had more than 1 occurrence per row. If you want to golf that solution and beat me I'd welcome the example :).

There's a 0 in the O (center row, right side)

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ• fixes the O at the same byte count.

MATL, 49 bytes
5:lyI&(g84*t0*ytP+g73*yy!qy5XyPl5LY(90*yy!P12-&hc

Try it online!
This produces the letters TIHZN:
TTTTT     IIIII     H   H     ZZZZZ     N   N
  T         I       H   H        Z      NN  N
  T         I       HHHHH       Z       N N N
  T         I       H   H      Z        N  NN
  T       IIIII     H   H     ZZZZZ     N   N

Explanation
T is relatively easy to build from scratch. I can be obtained essentially as T plus its vertical reflection. H is I transposed. N is Z transposed and vertically reflected.
5:        % Push [1 2 3 4 5]
lyI&(     % Write [1 ;2; 3; 4 ;5] in the third column, filling with zeros.
          % This gives the shape of the 'T'
g84*      % Change nonzeros into 84 (ASCII for 'T'). Zeros will be displayed
          % as spaces
t0*       % Duplicate and multiply by zeros. This gives the separator
y         % Duplicate from below: pushes the 'T' again
tP+       % Duplicate, flip vertically, add. Gives the shape of the 'I'
g73*      % Change nonzeros into 73 (ASCII for 'I')
yy        % Duplicate separator and 'I' array
!         % Transpose. Gives the shape of the 'H'
q         % Subtract 1. Transformss 73 into 72 (ASCII for 'H'), and 0 into -1,
          % which will later be changed back into 0 when converting to char
y         % Duplicate separator
5XyP      % Size-5 identity matrix flipped vertically: gives slash of the 'Z'
l5LY(     % Fill first and last rows with ones. Gives the shape of the 'Z'
90*       % Multiply by 90 (ASCII for 'Z')
yy        % Duplicate separator and 'Z' array
!P        % Transpose and flip vertically. Gives shape of the 'N'
12-       % Subtract 12 to yield ASCII code for 'N'. 0 is converted to -12
&h        % Concatenate the nine arrays horizontally
c         % Convert to char. Implicitly display

Vim, 116 bytes 99 bytes
ELITC
Golfed it under 100 with the help of @DrMcMoylex.
9i59Yo191919171
E L I T CPqqjx:%s/\d/\=repeat('"',submatch(0))
q8@q3bi  Y7w.PP4rE{wl4r 22wl.2x

This contains unprintable characters, so I've added them in below (Vim style), so you can see them.
9i5^[9^AYo191919171
E L I T C^[Pqqjx:%s/\d/\=repeat('^R"',submatch(0))
q8@q3bi  ^[Y7w.PP4rE{wl4r 22wl.2x

TryItOnline!
It basically uses the same run-length decode that the jelly answer does.  I used letters where I could (hopefully) repeat the top on the bottom, and the middles would all 3 be the same.  Once the tops, bottoms, and middles are created I edit the characters to make them correct:

Add two spaces to the I (more on that below)
Add two spaces to the T
Add the bar of the E
Remove the top of the L
Remove the bottom of the T (and delete the 2 spaces)

I have to add two spaces to the I, because I didn't allow two digit numbers (so I wouldn't need a separator.  This leads to a 9 space run where I need 11.

Welcome to PPCG, nice answer :).

I was almost begging for a Vim answer.

I always upvote vim. :) Some improvements I see. 1) you don't need the trailing slash on your substitute command. 2) Some useful synonyms: Y instead of Vy, FI instead of ?I<cr>, { instead of gg, w instead of fl. 3) If you use r instead of R, you can remove the <esc>.

JavaScript ES6, 168 bytes, CHAMP
We can stop looking guys, we have a CHAMP over here

f=_=>
` C3cHaHdA2dMaMcP3
CgHaHcAaAcMM MMcPaP
CgH4cA4cM M McP3
CgHaHcAaAcMaMcP
 C3cHaHcAaAcMaMcP`.replace(/[a-z\d]/g,(a,i,c)=>+a?c[i-1].repeat(a):' '.repeat(parseInt(a,36)-7))

a.innerHTML = f()
<pre id=a>

Brainf*** 512 411 Bytes
Better redo:
This one does a better job at optimizing the tape, sacrificing setup characters for printing characters. The tape in this one looks like 'C' 'E' ' ' 'F' 'I' 'L' '\n', improving efficiency. I chose these because they lack internal spaces, making it so that they don't have to go back and forth between character and space more than necessary
++++++++[>+++++++++>+++++++++>++++>+++++++++>+++++++++>+++++++++>+<<<<<<<-]>----->--->>-->+>++++>++<<<<.<<....>>.....<.....>.....>.....<.....>>.....<<.....>>>.>.<<<<<<.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<<<.>>.........<....>......>....<........>>.<<.......>>>.>.<<<<<<.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<.<<....>>.....<.....>.....>.<.........>>.....<<.....>>>.....

If you want to read what it's doing:
Set the tape with 67,69,32,70,73,76,10
++++++++[>+++++++++>+++++++++>++++>+++++++++>+++++++++>+++++++++>+<<<<<<<-]>----->--->>-->+>++++>++<<<<
.<<....>>.....<.....>.....>.....<.....>>.....<<.....>>>.>.<<<<<< First Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<<< Second Line
.>>.........<....>......>....<........>>.<<.......>>>.>.<<<<<< Third Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<< Fourth Line
.<<....>>.....<.....>.....>.<.........>>.....<<.....>>>..... Fifth Line

Output:
 CCCC     EEEEE     FFFFF     IIIII     L
C         E         F           I       L
C         EEEE      FFFF        I       L
C         E         F           I       L
 CCCC     EEEEE     F         IIIII     LLLLL

Former Submission:
++++++++[>++++<-]>[>++>++>++>++>++>+<<<<<<-]>+>++>+++>++++>+++++>>++++++++++<.<<<<<...>>>>>......<<<<....>>>>.......<<<....>>>.....<<....>>......<.....>>.<<<<<<.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<<.....>>>>>.....<<<<....>>>>......<<<.>>>.........<<.>>...<<.>>.....<....>>.<<<<<<.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<<.>>>>>...<<<<<.>>>>>.....<<<<....>>>>.......<<<....>>>.....<<....>>......<.....

I chose to go with ABCDE because it make setting up the tape for output much easier, but the time and characters I wasted in going from the letter to ' ' for all the negative space inside the A, B, and D and the placement of the endline at the end of the tape kinda killed me, I think.
I ended up with a tape that had the values 0 0 'A' 'B' 'C' 'D' 'E' ' ' \n and then output from there
++++++++[>++++<-]>[>++>++>++>++>++>+<<<<<<-]>+>++>+++>++++>+++++>>++++++++++     This all sets up the tape as 0 0 A B C D E ' ' '\n'
<.<<<<<...>>>>>......<<<<....>>>>.......<<<....>>>.....<<....>>......<.....>>.<<<<<< First Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Second Line
.....>>>>>.....<<<<....>>>>......<<<.>>>.........<<.>>...<<.>>.....<....>>.<<<<<< Third Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Fourth Line
.>>>>>...<<<<<.>>>>>.....<<<<....>>>>.......<<<....>>>.....<<....>>......<..... Last Line

Output:
 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E
AAAAA     BBBB      C         D   D     EEEE
A   A     B   B     C         D   D     E
A   A     BBBB       CCCC     DDDD      EEEEE

You can use [<]> on 3 occasions to save 6 bytes.

V, 62, 53 bytes
iC±  I· D³ Dµ O³ O¸ Z3ñYp$XñS ´Cµ µIµ ´D· ³O¶ µZYHP

Try it online!
This outputs C I D O Z:
 CCCC     IIIII     DDDD       OOO      ZZZZZ
C           I       D   D     O   O        Z
C           I       D   D     O   O       Z
C           I       D   D     O   O      Z
 CCCC     IIIII     DDDD       OOO      ZZZZZ

Stax, 33 bytes "BCDEO"
┌☼&.àτ▲█╟;c♦▌ΩÅ╡≤♫¿(┌▲▲≡3*╤J s*è«

Run and debug it
I picked letters that

have vertical symmetry
whose middle three columns are identical

These properties mean that each letter can be represented by a 3x3 grid.  Here are the 9 regions, represented by digits.
12223
45556
78889
45556
12223

Consider the letter "B".  It can be represented by 3 octal digits: 656.  Each digit contains three bits, which control which regions are enabled for that letter.  This technique also works for "CDEO".
Unpacked, ungolfed, and commented, the program looks like this.
"!^*14>G2eo"!   crammed integer literal             [63672, 54545, 64565]
|p              palindromize                        [63672, 54545, 64565, 54545, 63672]
m               for each, run this and output...
  E             extract decimal digits to array     [6, 3, 6, 7, 2]
  `)"+0`        compressed string literal           "BCDEO"
  \             zip arrays                          [[6, 66], [3, 67], [6, 68], [7, 69], [2, 79]]
  {             map array using block
    E           explode array                       6, 66
    Z\          tuck a zero under, and make pair    6, [0, 66]
    :B          custom base convert                 [66, 66, 0]
    3)          pad to length 3                     [66, 66, 0]
    3O\         tuck a one under a 3 and pair       [66, 66, 0], [1, 3]
    :B          repeat elements corresponding times [66, 66, 66, 66, 0]
    A(          pad right to length 10              [66, 66, 66, 66, 0, 0, 0, 0, 0, 0]
  m

Run this one

Ruby, 110 107 102 bytes (DOCIL)
puts a=?D*4+(t=' '*7)+?O*3+t+?C*4+(s=' '*5)+?I*5+s+?L,['D   D'+s+'O   O'+s+?C+' '*11+?I+t+?L]*3,a+?L*4

Prints
DDDD       OOO       CCCC     IIIII     L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
DDDD       OOO       CCCC     IIIII     LLLLL

EDIT: Saved some chars by avoiding join and moving things around

Perl 5 -p, 82 bytes (DOCIL)
Using the same letters and strategy everyone else is using (reusing the lines where possible), combined with an RLE decoder.
}{$_=($;="4D7 3O7 4C5 5I5 L")."
D3 D5 O3 O5 C11 I7 L"x3 ."
$;4L";s/\d+(.)/$1x$&/ge

Try it online!

Perl 5 -p, 95 bytes (ABCDE)
Contains unprintables, so the link includes them in \x## notation. Verification for 95 bytes.
}{$_=unpack B125,"w...0.?.G..#....";s;.;($&?(A..E)["@-"/5%5]:$").("@+"%25?$"x5x!("@+"%5):$/);ge

Try it online!
Explanation
The main data is stored as a binary matrix in the 16 byte string passed to unpack, which is called to convert to binary. Then s/// is called to replace each character with either $" (space) or if $& is falsy (0) or (A..E)["@-"/5%5] otherwise, where "@-" is the start index of the current character (@- is a list so $-[0] would return the first element, but interpolating into a string is 1 byte shorter) and we divide it by 5 and then take that result modulo 5 resulting in 0-4 (as the decimal part is ignored in list indices) based on the position, this correctly gets the letters in the right place for each of the larger letters. This is then appended to with, if "@+"%25 (like "@-" above, but @+ contains the end index of the current match) is truthy, $"x5x!("@+"%5) (space repeated [x] five times, repeated once when "@+"%5 is false) which adds the required spaces after each letter, or $/ (newline) otherwise.

C#, 290 279 267 265 Bytes
Edit: Saved 12 bytes thanks to @milk! And 2 more thanks to @TheLethalCoder
Golfed:
void F(){string g="     ",h="H   H",A="A   A",B=h+"|"+A;Func<string,string>j=a=>a.Replace("|",g)+"\n";Console.Write(j(" SSSS|"+h+"| AAA |RRRR |PPPP")+j("S    |"+B+"|R   R|P   P")+j(" SSS |HHHHH|AAAAA|RRRR |PPPP")+j("    S|"+B+"|R  R |P")+j("SSSS |"+B+"|R   R|P"));}

Ungolfed:
public void F()
{
  string g = "     ", h = "H   H", A = "A   A", B = h + "|" + A;
  Func<string, string> j = a => a.Replace("|", g) + "\n";
  Console.Write(j(" SSSS|" + h + "| AAA |RRRR |PPPP") +
  j("S    |" + B + "|R   R|P   P") +
  j(" SSS |HHHHH|AAAAA|RRRR |PPPP") +
  j("    S|" + B + "|R  R |P") +
  j("SSSS |" + B + "|R   R|P"));
}

Outputs:
 SSSS     H   H      AAA      RRRR      PPPP
S         H   H     A   A     R   R     P   P
 SSS      HHHHH     AAAAA     RRRR      PPPP
    S     H   H     A   A     R  R      P
SSSS      H   H     A   A     R   R     P

There was a second where I thought that your C code was 290279 bytes in length.

@StevenH. It feels that way Golfing in C# :)

-12 bytes if you define the local function like this Func<string,string>j=a=>a.Replace("|",g)+"\r\n";

@milk Cool, thanks! :)

Do you need the \r in the \r\n? Would save 2 bytes

Also convert to an Action so the declaration is then just ()=>... and a ; after the last } for -5 bytes

@TheLethalCoder Cheers :) I'll take the -2 for removal of "\r" - I know it works without, but I tend to leave it in so I can output to a text file to paste the text here. And the other one, I can't get to work - is this only in a new version of .NET?

I'm in my phone at the moment but I believe it should be Action action = () => { ... };

Befunge, 120 bytes (CKYTF)
Source
#&49+14489+56*1449135*44711425*:12p9138*7+:89+:56*55*v_@
-1g05$$_\#!:2#-%#16#\0#/g#20#,g#+*8#4<80\9*2p06%5p05:<^:,g2!%5:

Output
  CCCC     K   K     Y   Y     TTTTT     FFFFF
 C         K  K       Y Y        T       F
 C         KKK         Y         T       FFFF
 C         K  K        Y         T       F
  CCCC     K   K       Y         T       F

Try it online!
In case it matters, I should point out that my output has a leading space on each line. The rules didn't explicitly prohibit that, so I'm hoping that's OK. If not, please just consider this a non-competing entry.
Explanation
The letters of the word are encoded as a simple sequence of 25 integers, each integer being a binary representation of 5 pixels. Since Befunge requires you to perform a calculation to instantiate any integer greater than 9, the letters were chosen so as to minimize the number of calculations required, and ordered so potential repeating values could be duplicated rather than recalculated.
We also need to store the ASCII value of each letter, offset by 32, in an array which is indexed by the modulo 5 of a decrementing index (so it goes 0 4 3 2 1 ...). The reason for offsetting by 32 is so the value can be multiplied by a pixel bit (1 or 0) and then added to 32 to produce either a space or the character required.
This array of letter values is stored in the first 5 bytes of the code, so it's easy to access. This also then influenced the choice of letters, since those values needed to be meaningful when interpreted as a code sequence. This is the sequence #&49+. The # jumps over the & and the 49+ just pushes 13 onto the stack which is subsequently ignored.

You're asking for integer input with the &, but your program doesn't actually take input...what's going on?

That character is skipped by '#'

@12Me21 I explained the reasoning behind that in the last paragraph.

Befunge-98, 109 98 bytes (FUNGE / ANY)
:5%!2>j#4_;\$&\#;\:0`!#@_:::'@/'@*-\'@/2%*' +,:'@/:2/-'@*-\1+:5%!2>j#4_;' 3k:4k,#;:55*%!2>j#4_;a,;

Try it online!
Input (115 characters):
2022 1141 1134 935 2021 102 1141 1262 103 101 998 1141 1390 1639 997 102 1141 1646 1127 101 102 949 1134 935 2021 0

Input is the integer version of a binary number with the format aaaaabbbbbb where aaaaa is a reversed map of the character to print (for example, the second row in the N is NN  N, so the mask is 10011), and bbbbbb is the ascii character to print, minus 32.
I also created a befunge-98 program to create my inputs:
4k~44p34p24p14p04p          v
+1.+-**244g4%5\**88_@#`0:&::<

Try it online!
Output (255 characters):
FFFFF     U   U     N   N      GGG      EEEEE
F         U   U     NN  N     G         E
FFFF      U   U     N N N     G  GG     EEEE
F         U   U     N  NN     G   G     E
F          UUU      N   N      GGG      EEEEE

(255 - (115 + 98)) / 255 = 16% compression

Explanation:
:5%!2>j#4_;\$&\#;\:0`!#@_     Get input if it is available, else end program
:::'@/'@*-\'@/2%*' +,         Output the current input character (or a space,
                              if the mask dictates so)
:'@/:2/-'@*-                  Throw away current mask bit
\1+                           Swap loop iterator to top of stack, increment it
:5%!2>j#4_;' *3k:4k,#;        If iterator % 5 == 0, print five spaces
:55*%!2>j#4_;a,;              If iterator % 25 == 0, print newline character

This is probably pretty golfable; I've spent barely any time thinking about potential reductions.
Theoretically this can print any sequence of 5x5 ascii art.
Thanks to James Holderness for helping me get out of triple digits!

To take the idea further, 48* can be replaced with '  (since this is 98 after all), and 88* can be replaced with '@. Thanks for helping me get out of triple digits!

Python 2, 124 bytes
d,i,o,c,l,s,n='DIOCL \n'
T=d*4+s*6+i*5+s*6+o*3+s*7+c*4+s*5+l
M=d+s*3+d+s*7+i+s*7+o+s*3+o+s*5+c+s*9+l+n
print T+n,M,M,M,T+l*3

Similar to my other answer, but with better letter choices. Outputs this:
DDDD      IIIII      OOO       CCCC     L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
DDDD      IIIII      OOO       CCCC     LLLL

Python 3, 234 228 227 166 bytes (CLOUD):
import base64,gzip;b=b'ABzY86gn$d0{>HR1_A{T@KJyRe}8`nBNU1i6kLFS%Nec$q1YdaQ51tPO;sx(oDBkK&Q=Hwg(wC)8vxUXJX_-c000';print(gzip.decompress(base64.b85decode(b)).decode())

Prints:
 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

Python 3, 178 bytes
e,f,i,t,h,s='EFITH '
p=print
S=s*5
D=i+s*9+t+s*7
A=e*5+S
F=S+i*5+S
B=e+s*9+f+s*11+D+h+s*3+h
C=h+s*3+h
p(A+f*5+F+t*5+S+C)
p(B)
p(e*4+s*6+f*4+s*8+D+h*5)
p(B)
p(A+f+s*4+F,s+t+s*7+C)

Won't win, but does not use any compression. It makes this:
EEEEE     FFFFF     IIIII     TTTTT     H   H
E         F           I         T       H   H
EEEE      FFFF        I         T       HHHHH
E         F           I         T       H   H
EEEEE     F         IIIII       T       H   H

Any help is welcome, I probably missed something. I didn't use Python 2 because you can't do the p=print, and that saves 17 bytes. Try it on repl.it.

What is up with that F?

@DestructibleWatermelon I don't know how I missed that, but it is fixed now.

Golfed below original size: 160 bytes, Python 2

Rather than using p=print, you can use a single print statement with the kw argument sep='\n'.

Ruby, 101 bytes (TIFLE)
"o@h@u".bytes{|i|k=3+i%2;puts "%-10s"*5%"TIFLE".chars.map{|j|i/=2;(i/16>i%2*3?'  ':'')+j+j*k*(i%2)}}

TTTTT     IIIII     FFFFF     L         EEEEE
  T         I       F         L         E
  T         I       FFFF      L         EEEE
  T         I       F         L         E
  T       IIIII     F         LLLLL     EEEEE

I picked letters that required a single block of letters (1,4 or 5 letters long) on each line. F,L and E are left justified, but T and I require leading spaces where a single letter (vertical part) is printed. The code for adding these spaces looks like it could be improved.
ungolfed
"o@h@u".bytes{|i|               #for each byte (64 always set, 32...2 bits set for horiz bar, 1 bit=length of bar)
   k=3+i%2                      #decode least sig. bit for no of chars printed if a 1 is found
   puts "%-10s"*5%              #puts "%-10s%-10s%-10s%-10s%-10s" format string (expects array of subsitutes)
     "TIFLE".chars.map{|j|      #for each letter
        i/=2                    #halve i
        (i/16>i%2*3?'  ':'')+   #if i large enough and i%2 zero, add leading space (or T and I)
        j+j*k*(i%2)             #print the letter once, then additional letters if bar required.
     }
}

C 176 bytes
If implicit ints are allowed then it's possible to cut off another 8 bytes.
#define C ,//11 bytes
#define R(r)r r r r r//21 bytes
T(int l){int c=324;printf(R(R("%c")R(" "))"\n" R(R(C(++c,l>>=1)&1?c/5:32)));}//77 bytes
f(){T(67010460);T(34702434);T(66160574);T(34702434);T(67010466);}//65 bytes

Output: E D C B A
EEEEE     DDDD       CCCC     BBBB       AAA
E         D   D     C         B   B     A   A
EEEEE     D   D     C         BBBB      AAAAA
E         D   D     C         B   B     A   A
EEEEE     DDDD       CCCC     BBBB      A   A

How it works: The macro R just repeats a piece of code 5 times. Given how often fives appear in this problem, very useful. Now: here's what T(int) does. T takes an integer, and uses it as a bit field to determine where to print letters and where to print white space. For example, if given T(0b11111111100111111110011100), it will output: EEEEE     DDDD       CCCC     BBBB       AAA . It progressively counts down as to what letter it prints. First it prints E, then D, then C, then B, then A. Calling f() will print the entire thing.

perl 94 bytes.
The first 4 letters (D, O, I, C) are specifically chosen to have the upper and lower lines similar, and the middle ones similar. As there is not any other similar letter, I chose the "L" to be able to apply the same algorithm and add the missing 4L.
for(($a="D5 6O3 6I5 6C4 5L")."
","D 3D 5O 3O 7I 7C 9L
"x3,$a."4L
"){s/(.)(\d)/$1x$2/eg;print}

I saved some extra bytes by replacing the \n in the code with a real new line.
Result:
DDDD       OOO      IIIII      CCCC     L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
DDDD       OOO      IIIII      CCCC     LLLLL

Batch, 135 bytes (DOCILe)
@set b=
@set s=@echo DDDD%b%  OOO%b%  CCC%b% IIIII%b%L
@set t=@echo D   D%b%O   O%b%C%b%%b% I%b%  L
%s%
%t%
%t%
%t%
%s%LLLL

Note: the first line ends in 5 spaces.

BASH, 95, 111 bytes (EBASH)
Golfed
base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

Explanation
Base64 over raw LZMA byte stream
Demo
>base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

EEEEE     BBBB       AAA       SSSS     H   H
E         B   B     A   A     S         H   H
EEEE      BBBB      AAAAA      SSS      HHHHH
E         B   B     A   A         S     H   H
EEEEE     BBBB      A   A     SSSS      H   H

Disclaimer
Yes, I'm well aware that this is not really portable, that's why I've paid a byte to suppress the xz warnings with -q in the first case >:)

Python 2, 208 194 193 bytes
This is my first ever code golf ;) Fun to do
for i in range(0,25,5):
 for c,p in {'M':18732593,'O':15255086,'N':18667121,'T':32641156,'Y':18157700}.items():
  print format(p,'025b')[i:i+5].replace('0',' ',).replace('1',c)+'   ',
 print

Output:
Y   Y    M   M    TTTTT     OOO     N   N
 Y Y     MM MM      T      O   O    NN  N
  Y      M M M      T      O   O    N N N
  Y      M   M      T      O   O    N  NN
  Y      M   M      T       OOO     N   N

Using a dictionary destroys the sort order of the letters, but that was not a requirement

It could do -4 if we take letters that do not use the upper left corner. This would result in a 24 bit (instead of a 25 bit) number which takes up one less digit in hex.

brainfuck, 380 371 351 bytes
Edit: -9 bytes by switching to multiples of 17 and combining printing the first line with correcting the offsets
Edit: -20 by just using one cell to store the letters, you moron past me
+[[-<+>>++<]>]<<<++....<.......>+....<.....>++.....<......>++...<......>-.....----<<------.>>.<...>.<.....>+.<.........>++.<.........>++.<.........>-.----<<.>>.....<.....>+.<.........>++....<......>++.<..>..<.....>-....----<<.>>.<...>.<.....>+.<.........>++.<.........>++.<...>.<.....>-.----<<.>>....<.......>+....<.....>++.....<......>++...<......>-.

Try it online!
The best thing about this code is that it vaguely represents the actual letter themselves when the appropriate whitespace is added.
How It Works
Sets up the tape in the format:
1 2 4 8 16 32 64 128 0 0'

+[[-<+>>++<]>]

....<. ..... .>+.... <..... >++..... <..... .>++...<. ..... >-..... ----<<------.>>
.<...>.<.....>+.<.... ..... >++.<.... ..... >++.<.... ..... >-.     ----<<.>>
..... <..... >+.<.... ..... >++....<. ..... >++.<..>..<.....>-....  ----<<.>>
.<...>.<.....>+.<.... ..... >++.<.... ..... >++.<...>.<..... >-.     ----<<.>>
....<. ..... .>+....< ..... >++.....< ..... .>++...<. ..... >-.

Jelly,  40  39 bytes (FSLIC)
- Yep, the United States' Federal Savings & Loan Insurance Corporation!
“=;⁻ʋ®Ʋ\⁸d°5ġ$SƲ!ėɠẈvr’ḃ13s9“Ƭß»K¤żⱮŒṙY

Try it online!
How?
A similar method to my other answer (LICTE) but "FSLIC" is in Jelly's dictionary*, making up for the lack of vertical symmetry of the three middle rows which I made use of there.
“...’ḃ13s9“Ƭß»K¤żⱮŒṙY - Link: no arguments
“...’                 - (base 250) number     56608997404020628145427517841908851108342355529865
     ḃ13              - to bjective base 13   [5,6,4,5,1,9,5,6,4,1,9,1,9,1,11,1,7,1,4,7,3,6,1,11,1,7,1,1,13,1,5,1,11,1,7,1,1,9,4,6,5,5,5,6,4]
        s9            - split into nines      [[5,6,4,5,1,9,5,6,4],[1,9,1,9,1,11,1,7,1],[4,7,3,6,1,11,1,7,1],[1,13,1,5,1,11,1,7,1],[1,9,4,6,5,5,5,6,4]]
               ¤      - nilad followed by link(s) as a nilad:
          “Ƭß»        -   list of characters  "FSLIC"
              K       -   join with spaces    "F S L I C"
                 Ɱ    - map across (the lists of numbers) applying:
                ż     -   zip                 [[['F',5],[' ',6],['S',4],[' ',5],['L',1],[' ',9],['I',5],[' ',6],['C',4]],...]
                  Œṙ  - run-length decode     ["FFFFF      SSSS     L         IIIII      CCCC",...]
                    Y - join with newline characters

* In fact it is the only dictionary entry with five (or more) distinct capital letters with single runs on every row (CEFILSTZ, as required by the method), and it also happens to start with one which is also a flat-left letter (EFL, again as required for the method).

Python 3, 153 138 136 133 130 bytes
for l in"ffffbjfff blbhblbhb eibhblbhe blbhblbhb bjfffhbhf".split():print("".join("F I L T E"[i]*(ord(l[i])-97)for i in range(9)))

or for 128 bytes
for l in"           ".split(" "):print("".join("F I L T E"[i]*ord(l[i])for i in range(9)))

this uses the first 11 characters instead, which don't show up on stackoverflow, this does compile and run though.
Output:
FFFFF     IIIII     L         TTTTT     EEEEE
F           I       L           T       E
FFFF        I       L           T       EEEE
F           I       L           T       E
F         IIIII     LLLLL       T       EEEEE

This is a quick attempt, I was thinking of seeing if I could generate the numbers in the list without just writing them out. I picked letters which didn't had any "gaps" horizontally (e.g. H wouldn't work) which are FILTECZ.
Annoyingly it's lengthened by some of the gaps being 11 (two characters), not sure if there's a combination with makes it only gaps 9 and less, would shorten it to 125 chars
saved some bytes by using adding i%2*3
saved 2 bytes by using split() instead of a list
saved 3 bytes by using ord instead of i%2*3, would be great if I didn't have to -97 but using the first characters doesn't seem to work with split() well
saved 2 bytes by using range instead of enumerate
can save 2 bytes by using the first characters, to generate the string required you can use the following code snippet, but I'm not sure if this is allowed!
alpha="".join(chr(i) for i in range(20))
def convert(s):
    new_s = ""
    for c in s:
        if c == " ":
            new_s += c
        else:
            n = 11
            if c != "x": n = int(c)
            new_s += alpha[n]
    return new_s
print(convert("555519555 1x171x171 48171x174 1x171x171 195557175"))

L before Move L after T and all 11 gaps are removed.

@carusocomputing second row F to I would still be 11

Errr, I know there's a combination of those letters that does accomplish it. My initial strategy was the exact same as yours.

there are combinations that would allow for this, but due to the way I've done it, the first character has to have a straight vertical edge at the start, so there are no leading spaces (like F). Because of this I don't think it's possible to get below 11.

PHP, 109 bytes (LHKNM+BDEFP)
Talking about looping over a single value ... take a hex string as value (LHKNM):
for(;$i<25;)echo strtr(decbin(16+hexdec("011110129b0fc5501231f1111"[$i])<<5),[" ",LHKNN[$i%5]]),"\n"[++$i%5];

PHP, 122 bytes
foreach([4369,4763,64597,4657,987409]as$x)for($i=5;$i--;$x>>=4)echo strtr(decbin(512|32*$x&480),[" ",LHKMN[$i]]),"\n"[$i];

This exploits that all used letters have all pixels set in the first column:
The integer array holds the values for the other pixels converted from binary to decimal.
I didn´t test, but I think I have the shortest decimals possible.
In the loop body, the missing first column and the 5 spaces are added to the value before converting it back to binary; after that, 0 is replaced with space and 1 with space the letter (MNKHL).

I just noticed: If I had a 128 bit system; I could do a single loop over just one value :D

PHP, 246 bytes (EFOIH)
$q='~([A-Z';$r='preg_replace';$c=$r.'_callback';$m=' 7I 7O"';$v='E 9F 9H"'.$m;echo $r("$q])\"~", '$1   $1', $c("$q\s])([1-9])~",function($m){return str_repeat($m[1],$m[2]);},'E5 5F5 5H" 5I5 6O3
'.$v.'
E4 6F4 6H5'.$m.'
'.$v.'
E5 5F 9H" 5I5 6O3'));

Which prints:
EEEEE     FFFFF     H   H     IIIII      OOO
E         F         H   H       I       O   O
EEEE      FFFF      HHHHH       I       O   O
E         F         H   H       I       O   O
EEEEE     F         H   H     IIIII      OOO

Scala, 122 bytes (DIOCL)
()=>{val t="DDDDgIIIIIgOOOhCCCCfL"
val m="DdDhIhOdOfCjL\n"
t+"\n"+m+m+m+t+"L"*4 map(c=>if(c<90)c else " "*(c-97))mkString}

Explanation:
()=>{                          //define an anonymous function with no args
  val t="DDDDgIIIIIgOOOhCCCCfL"  //define these strings
  val m="DdDhIhOdOfCjL\n"
  t+"\n"+m+m+m+t+"L"*4           //return this string
    map(c=>                        //map each char...
      if(c<90)                       //if it's an uppercase letter
        c                              //...to itself
      else                           //else
        " "*(c-97)                     //...to a space repeated (the index of c in the latin alphabet) times
    )mkString}                     //and join the mix of chars and strings together

PHP, 124 bytes (ABCDE+FHOPSTU)
This version works for all characters where the middle three pixels are either all set or all empty, except for J, which would require an additional case for the ternary mapping.
for(;$x="2636755454764565545456367"[$i];)echo strtr(sprintf("%5b     ",($x&7)+($x>5?24:12)),[" ",ABCDE[$i%5]]),"\n"[++$i%5];

The string contains octal representations of the character lines; the middle bit is used three times:
($x&7)+($x>5?24:12) is short for (4&$x)*4|($x&2)*7|$x&1, but that does not work for 001.
sprintf converts to binary (it is shorter here to add the 5 spaces literally than shifting the number (that would require additional parentheses);
and strtr replaces 0 with space and 1 with the letter, like in my other answer.

Again, looping through a string saves a couple of bytes from looping through an array of integers,
in this case 20 bytes.

PHP, 123 bytes (TIDOC)
I wanted a purely calculating variant ... ITDOC would have cost another 7 bytes, unfortunately.
for(;$i<25;)echo strtr(sprintf("%10b",$i>4&$i<21?$p>1?18.5-$p/2:4:($p>2?$p+11:31.5-$p/2)),[" ",TIDOC[$p]]),"\n"[$p=++$i%5];

the .5s ruin it all ... nothing saved from the partly mapping version:
for(;$i<25;)echo strtr(sprintf("%10b",($i>4&$i<21?[4,4,17,17,16]:[31,31,30,14,15])[$p=$i++%5]),[" ",TIDOC[$p]]),"\n"[$p<4];

CJam, 46 bytes, FPLHB
"\x1ca-8
6"512b4b{2bEbG+32*2b}%5/"FPLHB"f.f{S?}N*

Replace \x1c with the actual byte.
Try it online!
Output:
DDDDD     PPPP      L         H   H     BBBB
D         P   P     L         H   H     B   B
DDDD      PPPP      L         HHHHH     BBBB
D         P         L         H   H     B   B
D         P         LLLLL     H   H     BBBB

This seems golfable.

Jelly, 43 bytes
Bs5ŒḄ;ÆP$×
“BỊ“z£“qġ“z¤“Eḃ’ç"5R¤o-51+83ỌẎZY

Try it online!
Maybe this could be shorter, I'm not good at compressing stuff in Jelly.
Bs5                   Convert to binary, split into three 5-bit chunks.
   ŒḄ                 Bounce: turn [α, β, γ] into [α, β, γ, β, α].
     ;ÆP$             Concat by is-prime. This turns our 5×5 binary matrix
                        into a 10×5 binary matrix, padding with zeroes.
         ×            Multiply by the right argument.

“BỊ“z£“qġ“z¤“Eḃ’      The list 16927,30753,28737,30754,17732.

…ç"5R¤                Do the above with those numbers and [1, 2, 3, 4, 5].
      o-51+83Ọ        Map the resulting matrices to spaces and “TUVWX”.
              ẎZY     Stitch them together, and join by newlines.

I thought to make use of the fact that TUVWX is an adjacent run of letters where each letter has horizontal symmetry, making it easy to encode (15 bits per letter).

C (gcc), 124 bytes
Chose symmetrical letters to try and exploit that somehow. Haven't quite found a way yet.
f(i,j){for(i=0;i<25;printf("%5c",++i%5?32:10))for(j=5;j--;)printf("%c",("QQQQQQQQJJQQQDDQJUJDNDJQD"[i]-64>>j&1)?85+i%5:32);}

Try it online!

Suggest putchar() for the second printf() and you can ditch the parens before the ?:

R, 175 or 215
The size to beat is 9×5×5=225 bytes, so...
The obvious (and... surprisingly efficient!) solution in 175 bytes is just to hard-code the lines, noticing that two are identical:
e="        "
y=c(" T",e,"I        C",e,"E",e,"L    \n")
cat(gsub(0,s,c("TTTTT0IIIII0 CCCC0EEEEE0L    \n",y," T    0I  0C    0EEEE 0L    \n",y," T0  IIIII0 CCCC0EEEEE0LLLLL")))

If one needs to prove that he has a Ph.D. in programming, (s)he may use the slightly longer version, still beating the original string length, with the help of run-length encoding (215 bytes).
v=el(strsplit(" T I C E L \n",""))
j=c(2,1,9,1,7,1,9)
f=rep(5,3)
m=matrix(c(0,f,6,4,f,1,4,1,j,1,9,1,4,1,j,4,6,1,4,1,2,1,7,5,6,4,f,5,0,1),4,,T)
m=m[c(1:3,2,4),]
for(r in 1:5)for(i in 1:12)cat(rep(v[i],m[r,i]),sep="")

Premature optimisation is the root of all evil. (D. E. K.)

Stax, 48 45 44 bytes(DOXHI)
ü⌠_Δs☺₧╞i╥⌂6⌂╤°qû╬╛∟|▀Ig‼£=U╣♪'q÷k╘îî♀P<ç)n½

Run and debug it
Thanks @recursive for -1 byte.
Chosen letters have two (in-plane) 2-fold axes except for "D". If there were another letter with two 2-fold axes the answer would be shorter.

0]5* is z5(, which saves a byte even after packing.

This actually exposes a bug. If I assign the D after palindromizing, it still works while it shouldn't. Maybe the subarrays aren't copied properly upon palindromization. I think we had this issue with transposition, I don't know whether there are more instructions with this issue.

I've found a bunch of inappropriate mutation bugs so far. There are probably many more to go.

Python 2, 171 bytes
Best I could get after 2 hours:
E,s,I,L,T,U,n="E ILTU\n"
S,b,B,D,u=s*5,s*11,s*9,s*7,"U   U"
C,Z=u+n+E,I+D+L+b+T+D
print E*5+S+I*5+S+L+B+T*5+S+C+b+Z+C+E*3+s*8+Z+C+b+Z+U+s*3+U+n+E*5+S+I*5+S+L*5+D+T+s*8+U*3
Try it online!
Outputs:
EEEEE     IIIII     L         TTTTT     U   U
E           I       L           T       U   U
EEEE        I       L           T       U   U
E           I       L           T       U   U
EEEEE     IIIII     LLLLL       T        UUU

Java 8, 218 bytes (CHLTU)
v->{String s="     ",n="\n",c="C    ",h="H   H",l="L    ",t="  T  ",u="U   U";return" CCCC"+s+h+s+l+s+"TTTTT"+s+u+n+c+s+h+s+l+s+t+s+u+n+c+s+"HHHHH"+s+l+s+t+s+u+n+c+s+h+s+l+s+t+s+u+n+" CCCC"+s+h+s+"LLLLL"+s+t+s+" UUU";}

Explanation:
Try it online.
v->{                 // Method with empty unused parameter and String return-type
  String s="     ",  //  String containing five spaces
         n="\n",     //  String containing new-line
         c="C    ",  //  String for three repeated parts in C
         h="H   H",  //  String for four repeated parts in H
         l="L    ",  //  String for four repeated parts in L
         t="  T  ",  //  String for four repeated parts in T
         u="U   U";  //  String for four repeated parts in U
  return" CCCC"+s+h+s+l+s+"TTTTT"+s+u+n        //  Line 1
        +c+s+h+s+l+s+t+s+u+n                   //  Line 2
        +c+s+"HHHHH"+s+l+s+t+s+u+n             //  Line 3
        +c+s+h+s+l+s+t+s+u+n                   //  Line 4
        +" CCCC"+s+h+s+"LLLLL"+s+t+s+" UUU";}  //  Line 5

At first I was using letters that looked similar and used a replace function with if-checks. This ended up over 400 bytes however, so I dropped it completely instead of trying to golf it.
I then looked at letters with repeated parts. There are four letters with four repeated parts on their five lines: H, L, T and U.
And although I already had them in alphabetic order, it is also the best order for these five letters, because I can omit the trailing space in the bottom part of the U (" UUU " → " UUU").

Powershell, 89 bytes
Inspired by the AdmBorkBork's nice trick.
$d="DDDD5  OOO5  CCCC5IIIII5L"
"$d
$("D   D5O   O5C55 I5  L
"*3)$d`LLLL"-replace5,'     '

Output:
DDDD       OOO       CCCC     IIIII     L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
DDDD       OOO       CCCC     IIIII     LLLLL

Powershell (without tricks), 106 bytes
Any 5 letters, 25 chars with 5 lower bits as mask:
0..4|%{-join(0..4|%{0..4|%{(' ','GOLFA'[$i%5])[(+'NNA_NAQAAQYQAG_QQAAQNN_AQ'[+$i]-shr$_)%2]}
$i++
' '*5})}

Output:
 GGG       OOO      L         FFFFF      AAA
G         O   O     L         F         A   A
G  GG     O   O     L         FFF       AAAAA
G   G     O   O     L         F         A   A
 GGG       OOO      LLLLL     F         A   A

FEU, 83 bytes, DOCIL
a/4\n5554LLLL
m/5/D1D2O1O2C0020I03\n/4/DDDD02OOO02CCCC2IIIII3/3/2L/2/10/1/0 /0/  /g

Try it online!
Explanation
0, 1, and 2 are for spacing. They're 2, 3, and 5 spaces respectively.
3 starts the letter L.
4 is line 1, and line 5 is just line 1 with 4 extra L's.
5 is line 2, 3, and 4.

APL (Dyalog Classic), 87 bytes
Decodes 45 vertical lines of 5 types from 15 characters. Converts them to binary matrix and then multiplies it by a coefficient matrix. The final matrix contains indices of letters in a string.
' DILOC'[1+(⊃,/{9\⍪5⍴⍵}¨⍳5)×(⍉5 5⍴(25⍴2)⊤47679)[;1+∊(5 5 5⊤⊢)¯6+⎕AV⍳'ÏSSS9i⌶⌶⌶⌶RSÐSS']]

Output:
DDDD      IIIII     L          OOO       CCCC
D   D       I       L         O   O     C
D   D       I       L         O   O     C
D   D       I       L         O   O     C
DDDD      IIIII     LLLLL      OOO       CCCC

Try it online!

MAWP, 700 bytes
It would've been real dandy if this question was about 4 characters.
499WA;48W!!;;;499WA;48W!!!!!;;;;;;188WM!!;;;48W!!!!!!;;;;;;;299WA!!;;;48W!!!!!;;;;;;699WM;48W!!;;;699WM;48W!!!!;;;;;199WA!!!;;;;25W;499WA!;;48W;499WA!;;48W!!!!;;;;;188WM;48W!!;;;188WM;48W!!!!;;;;;299WA;48W!!;;;299WA;48W!!!!;;;;;699WM;48W!!;;;699WM;48W!!!!;;;;;199WA;48W!!;;;199WA;25W;499WA;48W;499WA;48W;499WA;48W!!!!;;;;;188WM!!!!;;;;;48W!!!!;;;;;299WA;48W!!;;;299WA;48W!!!!;;;;;699WM;48W!!;;;699WM;48W!!!!;;;;;199WA!!!;;;;25W;499WA;48W!!;;;499WA;48W!!!!;;;;;188WM;48W!!;;;188WM;48W!!!!;;;;;299WA;48W!!;;;299WA;48W!!!!;;;;;699WM;48W;699WM;48W;699WM;48W!!!!;;;;;199WA;25W;499WA;48W!!;;;499WA;48W!!!!;;;;;188WM;48W!!;;;188WM;48W!!!!!;;;;;;299WA!!;;;48W!!!!!!;;;;;;;699WM;48W;699WM;48W!!!!!;;;;;;199WA;

Made with the help of Kevin Cruijssen's MAWP string generator and a lot patience and exclamation marks.
Output:
M   M      AAA       OOO      W   W     PPPP
MM MM     A   A     O   O     W   W     P   P
M M M     AAAAA     O   O     W   W     PPPP
M   M     A   A     O   O     W W W     P
M   M     A   A      OOO       W W      P

Try it!

I can view transcript, but I can't access the chatting page. (Any ideas?)

i meant cookies

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