text:
Generate alphabet with 4 copies of each letter
Note that this is not the same as Print the alphabet four times.
This task is to write a program to generate four copies of each letter of the English alphabet, one letter per line, on standard output:
A
A
A
A
B
B
B
B

etc.
The output should include newlines after each letter.
Lowercase letters and/or extra whitespace are acceptable.
The solution must be a complete program.
This is code-golf so answers will be scored in bytes with a lower score being the goal.

I'm slightly confused. Is the challenge here just to output the alphabet with each letter repeated four times, or does the output actually need to be stored in a file as well?

And do I have to output only the alphabet?

@MarkReed Do I need to print it with newlines in between? Why not just print it, but newlines optional?

Also, I recommend rephrasing your challenge so that it is more like a challenge and less like telling the story of how you invented your answer.

The last bit muddies the whitespace rules just a tad. Could you please clarify? Particularly, am I reading it right to interpret that extra whitespace is okay but omission of newlines is not?

APL (5)
⍪4/⎕A

Matrix format (⍪) of 4-replication (4/) of alphabet (⎕A).

Seems unlikely to be beaten. :)

I count 9 bytes.

APL uses a code-page that maps each of the characters it uses to one byte.  This code page can be found here, on IBM's website.

@StevenH. Link is dead

@StanStrum I believe the link is dead because of deprecation, but for the sake of code golfing this meta answer should work.

Python 2 - 37
for i in range(104):print chr(i/4+65)

As i goes from 0 to 104, it is divided by four and added to the ASCII value for A, and the resulting character is printed.

I take it Python uses integer division by default? Would kinda be nice if PowerShell did right now. As it is, the code necessary to force it into integer division is too long for this trick to help me save anything on my script.

@lszi - Python takes its cue from the type of the operands.  3/4 is 0, while 3.0/4.0 is 0.75; range() generates integers.

This does not work on newer versions of python. First, the print function must be called with brackets, and / no longer does integer division by default (even if both numbers are integers), which is //'s job
Try: for i in range(104):print(chr(i//4+65))

@Consciousness I know that. I deliberately chose to use an old version so that it can be golfed better. If you were to run this at Ideone.com, you'd choose "Python" instead of "Python 3"

@Consciousness - by "newer versions of python", you're referring to "Python 3", which is far from universally adopted at this point. I generally assume that anything claiming to be "Python" without a specified version is Python 2.x until proven otherwise; Python 3 code tends to be explicitly so labeled.

The above is no longer the case in 2022, so I took the liberty of editing this answer to mark it explicitly as Python 2.

R, 30 28 27 25
write(rep(LETTERS,e=4),1)

Former version with 30 bytes:
cat(rep(LETTERS,e=4),sep="\n")

I think a literal newline is a byte shorter :)

@Giuseppe Can you specify this idea?

Try it online!

@Giuseppe Really good idea! Thanks for pointing out.

You can use 1 instead of "" to specify stdout in write as well, which saves another byte.

@Giuseppe Thanks for the hint.

The final 1 is not necessary, making it 25 bytes.

@RobinRyder Thanks for pointing out.

C, 59
I submit this, an uncompetitively long answer, simply because I don't see a C submission yet. And that makes me sad.  :-/
LATER: Props to @moala for doing a "/4" int version of this, saving 13 chars!
float i;main(){while(i<26)printf("%c\n",65+(int)i),i+=.25;}

I've edited my answer, now saving even 2 more chars!

and another one!

J: 18 13
4#u:65+i.26 1

I'm still pretty shaky with J, so this could probably be improved

You can use replicate (#) instead of division like so: 4#u:65+i.26 1. Also, ~ swaps a function's arguments, so if you ever find yourself doing (expression) F value, you can replace that with value F~ expression to save a character.

@marinus Thanks for the tip. I'm still learning J and it's hard to find any good info with those kinds of tricks.

4#65{26,.\a. for 12 bytes.

PowerShell: 32 23
Golfed code:
[char[]](65..90*4)|Sort

Walkthrough:
[char[]](...) takes an array of objects and converts them to ASCII characters.
65..90 are the ASCII codes for A-Z.
*4 repeats the series 4 times.
|Sort sorts the output.
Note:
If you want this written to a file, just throw >, followed by a file name, at the end.

Befunge 98 - 18
1+::'g`#@_4/'A+,a,

Works by storing a number and ending when it reaches 104. Prints out the corresponding character of the alphabet for the number divided by 4, followed by a newline. But if I need not add a newline after each letter, then it is 16 chars:
1+::'g`#@_4/'A+,

Can be reduced if I can print more characters (ie all of them four times)(7 6 chars, even works in Befunge 93):
1+:4/,

With newline:
1+:4/,a,

Ruby, 23
puts ([*?A..?Z]*4).sort

All credit to @manatwork -- upvote his comment, not this. :)

Huge. @manatwork, I'll make the edit but obviously I don't deserve any credit!

Better make it puts [*?A..?Z].map{|i|[i]*4} or puts ([*?A..?Z]*4).sort, so the letters get ordered as in the example.

@manatwork: puts (?A..?Z).map{|i|[i]*4} is a character shorter.  You can call map directly on a Range, so you don't need the splat in this case.

C, 46 44 43
46:
i;main(){while(i<104)printf("%c\n",65+i++/4);}

44:
i=260;main(j){for(;(j=i++>>2)<91;puts(&j));}

44 too:
i=260;main(j){while(j=i++>>2,j<91)puts(&j);}

Thanks to @marinus, 43:
i=260;main(j){while(j=i++/4,j<91)puts(&j);}

Should I add a bounty for getting to 42? :)

50 rep. is needed to comment on anything, and you have 101 at the time of posting this comment.

You can replace >>2 by /4.

42 bytes Can I get the bounty :-)

Haskell, 46
x a=a++a
main=putStr$['A'..'Z']>>=x.x.(:"\n")

putStr$['A'..'Z']>>=("golf">>).(:"\n") saves 8 bits

Java: 56
for(int i=0;i<104;)System.out.println((char)(i++/4+65));

edit: changed from 'print' to 'println'

The output should include newlines after each letter.

thanks for pointing that out, it should print a new line each time now

The solution must be complete enough to execute. I should be able to invoke an implementation of the language, paste the code from the answer, and get results, without typing any additional code.  i think your solution violates this condition

@user902383 If you paste it into JShell (the Java REPL in Java 9) it works, and you don't even need the final semicolon.

@DavidConrad Its awesome then, I think I might start using REPL/JShell.

@user902383 You can download an early access release here. It was glitchy under Cygwin so I run it directly from a cmd prompt; should be find on other OS's and hopefully they'll fix the Cygwin problems for the final release.

brainfuck, 48 bytes
+++[[-<+>>++<]+>]<<<<<<+[->,++++[->.<<<.>>]>+<<]

Try it online!
Prints in lowercase, separated by carriage returns. Uses wrapping 8 bit cells as well as cells left of the origin, though you can prepend a > to counter the latter.

I was about to post a new one, but you managed to completely out-do my best, i got 71 bytes with ++++++[->++>++++>++++++++++<<<]++++>+>++>+++++<[->.<<.>>.<<.>>.<<.>>.+<<.>]

GolfScript: 17 15 characters
26,{65+...}%+n*

Bash: 24 characters
printf %s\\n {A..Z}{,,,}

Perl 5, 20 bytes
print"$_
"x4for A..Z

Try it online!

Perl 5 + -M5.10.0, 20 bytes
eval"say;"x4for A..Z

Try it online!

It has never occurred to me to put a literal newline inside a double-quoted string in Perl. +1.

I should note, that I didn't either, but @manatwork mentioned it on another answer of mine and it's stuck!

Forth, 37
'h 0 [do] [i] 4 / 'A + emit cr [loop]

35 bytes by avoiding +.

BrainF* ,79 60
+++++++++++++[->++>+>+++++<<<]>>---<[->>>++++[-<.<.>>]<+<<]

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

Actually, 6 bytes
4ú*SÖi

Try it here!
Explanation
4ú*SÖi

4 *         Do 4 times
 ú          Create string of alphabet in lowercase
   S        Sort it
    Ö       Switch Case
     i      Push each character of string

4 Bytes with lowercase and no newline:
4ú*S

Welcome to PPCG!

16-bit x86 machine code MS-DOS COM, 25 bytes
In hex:
B409BA160189D7B96800F6C1037502FE05CD21E2F5C3400A24

This is a complete MS-DOS .COM program. Copy the byte sequence to the file with .com extension and run it from DOSBox
Disassembly:
00: B4 09        mov    ah,0x09         ;INT 21h "Write string to STDOUT" function
02: BA 16 01     mov    dx,0x116        ;Address of the string s ('$'-terminated)
05: 89 D7        mov    di,dx           ;Because there's no way to dereference address in DX
07: B9 68 00     mov    cx,104          ;CX=26*4
_0000000A:
0A: F6 C1 03     test   cl,0x03         ;When lower two bits are zero...
0D: 75 02        jne    _00000011       ;...do not skip the next instruction
0F: FE 05        inc    b,[di]          ;*s++
_00000011:
11: CD 21        int    21              ;Print the string
13: E2 F5        loop   _0000000A       ;Until --CX==0
15: C3           retn
16: 40           db     0x40            ;s[0], starts with 'A'-1
17: 0A           db     0x0A            ;'\n'
18: 24           db     '$'             ;Terminator required by the print function

Jelly, 5 bytes
ØAx4Y

Try it online!
Explanation:
ØAx4Y Main link
ØA    “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
   4  4
  x   Repeat each element of x y times
    Y Join x with newlines

x86-16 ASM, IBM PC DOS, 22 19 bytes
Binary:
00000000: 400a 24b8 1109 8bd6 b168 d0c8 102c cd21  @.$......h...,.!
00000010: e2f8 c3                                  ...

Build with xxd -r and test in DOSBox or your favorite DOS VM.
Unassembled:
40 0A 24    DB   '@', 0AH, '$'      ; the letter + NL + '$' string terminator
B8 0911     MOV  AX, 0911H          ; AH = DOS print string; AL = 0001 0001 bit pattern
8B D6       MOV  DX, SI             ; DX to output string
B1 68       MOV  CL, 26*4           ; Loop 4 times for each letter in alphabet
        ALOOP:
D0 C8       ROR  AL, 1              ; roll repeating bit pattern to the right
10 2C       ADC  BYTE PTR[SI], CH   ; add rightmost bit to ASCII character
CD 21       INT  21H                ; print letter to console
E2 F8       LOOP ALOOP              ; continue looping
C3          RET                     ; return to DOS

Notes:
For most flavors of DOS, we know the values of many CPU registers at the start of execution and we know SI is 0100H, and CH is 0.  So by placing the output string in the beginning of the program, [SI] will already be pointing to it.  These bytes ('@',0AH,'$') decode to two benign instructions (INC AX, OR AH, [SI]), which have no effect on the program.
AL contains the bit pattern of 0001 0001 which is bit rolled right each time and the rightmost bit added to the ASCII value of the output char in memory.

Vyxal j, 5 bytes
kAdds

Try it Online!
Look ma, no Unicode!
kA    # Uppercase output
  dd  # Quadruple
    s # Sorted
      # (j flag) join by newlines

the explanation here is wrong: clearly, the Adds here is what is adding everything 4 times ;)

@lyxal Honestly, this is the first time I've unintentionally done a letters-only answer...

Raku, 34 21 bytes
('A'..'Z'Xxx 4)».say

I think this is the first time that Perl 6 was the first solution I thought of, but the hyperoperator just seemed a natural fit.

Updated, @JoKing. Thanks! I was able to mostly predict what your re-golfed solution was before looking, now that I have 9 more years of Raku under my belt. Though I got stuck at 22 bytes; didn't think the space before Xxx would be removable. I also left the hyperop as » instead of >>; it's two bytes either way, and I prefer the look of the guillemet .

Julia 0.2, 39, 36
println([char(i/4+64.5)for i=0:103])

Mathematica 50 41 30
With help from alephalpha and Mark S.
Print/@{#,#,#,#}&/@Alphabet[];

Print /@ {#, #, #, #} & /@ "A"~CharacterRange~"Z";

The semicolon in @alephalpha's comment is necessary. Also, using a newer version of Mathematica you can use Print/@{#,#,#,#}&/@Alphabet[]; instead of Print/@{#,#,#,#}&/@"A"~CharacterRange~"Z";

Echo/@{#,#,#,#}&/@Alphabet[]; shaves another character. Theoretically, #+0{,,,} might let you get to 28 (since it's one shorter than {#,#,#,#}), but I couldn't get the precedence to work.

Q (13)
.........
-1@''4#'.Q.A;

AWK, 48
Lets try it with AWK...
END{s=65;for(i=104;i--;s+=0==i%4)printf"%c\n",s}

As suggested by manatwork we can get rid of 2 chars
AWK, 46 (Edit)
END{for(i=104;i--;s+=0==i%4)printf"%c\n",s+65}

AWK,40 (editing MarkReed's code)
END{for(;i<104;){printf"%c\n",i++/4+65}}

By removing the initialization of variable s you can spare 2 characters: END{for(i=104;i--;s+=0==i%4)printf"%c\n",s+65}.

Putting the code in an END block means it requires an input stream (even if it's /dev/null) to work.  Does that modify the char count?  Anyway, BEGIN{for(;++i<104;){printf"%c\n",i/4+65}} is 5 chars shorter.

@MarkReed Your code isn't working. Check this

D'oh.  So close! :) But I still don't like the END pattern's requirement for an input stream...

PowerShell, 21
65..90|%{,[char]$_*4}

A slightly different approach to Iszi's. And shorter :-)

Damn, I got close to this at 22 using what looks like a blend of y'all's:
65..90|%{[char[]]$_*4}

C# LINQ 115 Bytes110 Bytes
Enumerable.Range(65, 26).SelectMany(i => Enumerable.Repeat(i,4))
.ToList().ForEach(i=> Console.WriteLine((char)i));

Welcome to PPCG! Nice first post!

05AB1E, 6 bytes
A4×{S»

Explanation:
A       # Push 'abcdefghijklmnopqrstuvwxyz'
 4×     # Repeat four times
   {    # Sort
    S   # Split into list
     »  # Join by newlines
        # Implicit print

Without newlines, 4 bytes
A4×{

Try it online!

you beat me by >5 years ://

05AB1E, 5 bytes
Aε4F=

Try it online!

C# (Visual C# Interactive Compiler), 46 bytes
for(var a=259;a++<363;WriteLine((char)(a/4)));

Try it online!

Canvas, 5 bytes
Ｚ４１＊⟳

Try it here!
Explanation:
Code        | Explanation                                  | Stack
------------+----------------------------------------------+------------------------------
Ｚ          | The uppercase alphabet                       | "ABC..."
  ４１＊     | Stretched by 4 horizontally and 1 vertically | "AAAABBBBCCCC..."
        ⟳  | Rotated clockwise                            | "A¶A¶A¶A¶B¶B¶B¶B¶C¶C¶C¶C¶..."
            | Print ToS (implicit)                         |

With ¶ replaced with \n upon printing.

VBA, 30 bytes
An anonymous VBE immediate window function that takes no input and outputs to the console.
For i=260To 363:?Chr(i\4):Next

Kotlin, 66 59 bytes
Save 7 bytes removing for loop.
fun main(a:Array<String>){repeat(104){println('A'+(it/4))}}

Try it online!

jq -nr, 27 bytes
range(104)/4+65|[.]|implode

Try it online!
implode seems to convert floating point to their floored value, which is quite useful here.

Unless I'm misremembering the rules, I believe command-line options count toward the total, so -nr adds three bytes and takes you to an even 30. :)

@MarkReed You're not misremembering, but the rules have changed since 2013 ;). Here is the "new" concensus. In short, jq -nr is considered a different language than jq and the flag is not counted as any amount of bytes

jq -nr, 32 bytes
range(26)+65|[.]|implode|.,.,.,.

Try it online!
.,.,.,. may just be the funniest thing I've written on this site. This language's generator system never ceases to amaze me.

Dc: 35 characters
[rdP10Pr1-d1<p]sp65[5lpx+d91>l]dslx

F#: 61 62 49
for i in 'A'..'Z'do for j in 0..4 do printfn"%c"i

hm, do you not need ;; at the end?

@MarkReed If executed from fsi.exe, yes, you would usually need that. However, this is a complete program by itself, so you can simply compile and run it as is.

Scala, 42
('A'to'Z')map(x=>List.fill(4)(println(x)))

PHP, 53
for($i=65;$i<91;$i++)echo str_repeat(chr($i)."\n",4);

I count 53 chars; where's the 44 from?

I know a 44 character long solution, but definitely not with that str_repeat(): http://pastebin.com/decsAZXi

@manatwork - that looks like 40, even. Why not post it as an answer?

Sorry, I didn't count the $i

It doesn't includes ZZZZ

@MarkReed, indeed. Seems my character counter bookmarklet fails on pastebin. I not consider it significantly different to post it as separate answer. Just intended to help ub3rst4r to get into codegolfing.

What VarunAgw said; needs to be $i<91 instead of $i<90.  Doesn't affect the char count, though.

Its been fixed.

@ub3rst4r, if you feel the improvement I suggested earlier is too far from your taste, you can still manipulate the loop: 1) remove the explicit incrementation: for($i=65;$i<91;)echo str_repeat(chr($i++)."\n",4); and/or 2) remove the explicit initialization: for(;$i<26;)echo str_repeat(chr($i+++65)."\n",4);.

Matlab, 38
x=repmat(char(65:90)',1,4)';disp(x(:))

Javascript 55
for(i=65;i<91;i+=1/4)document.write("&#"+(i|0)+";<br>")
1 character shorter, but outputs to the screen instead of console.

(i|0) => ~~i

Pyke, 6 bytes (noncompetitive)
G4m*_X

Try it here!
Or 4 bytes without newline separation
G4m*

CJam, 15 13 characters
'[,65>4f*e_N*

Probably very golf-able; I'm new to CJam and even code golfing.

Swift 3, 53
(0...103).map{print(String(UnicodeScalar($0/4+65)!))}
IF one day Apple decided to include Foundation by default, we could have
(0...103).map{print(String(format:"%c",$0/4+65))} //49 bytes

Common Lisp, 58 bytes
(dotimes(i 26)(format t"~4@{~c
~:*~}"(code-char(+ 65 i))))

Explanation
(dotimes(i 26) ; loop for i from 0 to 25
(format t"~4@{~c
~:*~} ;output four times character given by (code-char(+ 65 i)) followed by newline

Try it online!

Japt -R, 7 6 bytes
;B²²¬n

Test it
;B²²¬n
;B         :Uppercase alphabet
  ²        :Duplicate
   ²       :Duplicate
    ¬      :Split
     n     :Sort
           :Implicitly join with newlines

Vim, 27 bytes
:h<_
jjYZZPVUqqx4O<C-r>"<esc>jq25@q

Thanks @Lynn for the trick of grabbing the alphabet from helpfiles.

Brain-Flak, 122 bytes
(((((()()()()){}){}){}){}())((((()()()){}){}()){}){({}<(()()()()){({}<(({})<((()()()()()){})>)>[()])}{}({}())>[()])}{}{}

this is 120 bytes of source code, and +2 bytes for the -Ar flags.
Try it online!

Pyth, 8 bytes
-2 bytes thanks to Mr. Xcoder
VGj*4rN1

Try it online!
Explanation
VG          # For N in G (the alphabet)...
     rN1    # ...convert N to uppercase...
   *4       # ...generate the string NNNN...
  j         # ...join on newlines
            # Implicit print for each iteration

8 bytes: VGj*4rN1

VrG1NNNN is also 8 bytes and is way simpler...

PHP, 36 bytes
while($i<104)echo"
",chr($i++/4+65);

bonus version, 38 bytes
while($i<104)echo"@K"^chr($i++/4+1).A;

Run with -nr or try it online.

Perl 6, 22 bytes
.say xx 4 for "A".."Z"

Even though this is an old challenge, I found a different approach to the Perl 6 answer, so I decided to post it.
Try it online!

///, 73 bytes
/./\/A
A
A
A
\/A\///~/.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.

Try It Online!
This just replace . by /AAAA/A/ to get AAAA/A/B/AAAA/A/C/AAAA... (newlines excluded for legibility). The /~/ is the first part of a dummy replacement which does nothing; it's there to grab initial / from the first replacement. We don't need to worry about the final /A/ (/Z/ by the time the interpreter gets there), because /// simply exits if it encounters EOF while reading a replacement

Pyth - 7 Bytes
VrG1V4N

Explanation
VrG1V4N
V       For each character N in
  G     The alphabet
 r 1    Converted to uppercase:
    V4  For each variable from 0 to 3:
      N Implicitly print N

Pyt, 6 bytes
ʊ4*ąşÁ

Explanation:
ʊ     Pushes "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
4*    Quadruples the string
ą     Convert to array of characters
ş     Sort the array in ascending order
Á     Push contents of the array onto the stack
      implicit output

Try it online!

If outputting it as an array is acceptable:
Pyt, 5 bytes
ʊ4*ąş

Whitespace, 126 117 bytes
[S S S T    S S S S S S N
_Push_64][S N
S _Duplicate][N
S S S N
_Create_Label_LOOP][S N
N
_Discard_top][S S S T   N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][S S S T   S T T   S T T   N
_Push_91][T S S T   _Subtract][N
T   S S S N
_Jump_to_Label_EXIT_if_0][S S S T   S S N
_Push_4][N
S S T   N
_Create_Label_INNER_LOOP][S S S T   N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   T   S N
_Jump_to_Label_LOOP_if_negative][S N
T   _Swap_top_two][S N
S _Duplicate][T N
S S _Print_as_character][S S S T    S T S N
_Push_10][T N
S S _Print_as_character][S N
T   _Swap_top_two][N
S N
T   N
_Jump_to_Label_INNER_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (containing raw spaces, tabs and new-lines only).
General explanation in pseudo-code:
Integer i = 64
Start Loop:
  i = i+1
  If i == 91: Exit program with error
  Integer j = 4
  Start Inner Loop:
    j = j-1
    If j is negative: Go to the next iteration of the outer Loop
    Print i as character
    Print new-line
    Go to the next iteration of the Inner Loop

Example run:
Command        Explanation                            Stack            STDOUT    STDERR

SSSTSSSSSSN    Push 64                                [64]
SNS            Duplicate top (64)                     [64,64]
NSSSN          Create Label_LOOP                      [64,64]
 SNN            Discard top                           [64]
 SSSTN          Push 1                                [64,1]
 TSSS           Add (64+1)                            [65]
 SNS            Duplicate top (65)                    [65,65]
 SNS            Duplicate top (65)                    [65,65,65]
 SSSTSTTSTTN    Push 91                               [65,65,65,91]
 TSST           Subtract (65-91)                      [65,65,-26]
 NTSSSN         If 0: Jump to Label_EXIT              [65,65]
 SSSTSSN        Push 4                                [65,65,4]
 NSSTN          Create Label_INNER_LOOP               [65,65,4]
  SSSTN          Push 1                               [65,65,4,1]
  TSST           Subtract (4-1)                       [65,65,3]
  SNS            Duplicate top (3)                    [65,65,3,3]
  NTTSN          If negative: Jump to Label_LOOP      [65,65,3]
  SNT            Swap top two                         [65,3,65]
  SNS            Duplicate top (65)                   [65,3,65,65]
  TNSS           Print as character                   [65,3,65]        A
  SSSTSTSN       Push 10                              [65,3,65,10]
  TNSS           Print as character                   [65,3,65]        \n
  SNT            Swap top two                         [65,65,3]
  NSNTN          Jump to Label_INNER_LOOP             [65,65,3]

  SSSTN          Push 1                               [65,65,3,1]
  TSST           Subtract (2-1)                       [65,65,2]
  SNS            Duplicate top (2)                    [65,65,2,2]
  NTTSN          If negative: Jump to Label_LOOP      [65,65,2]
  SNT            Swap top two                         [65,2,65]
  SNS            Duplicate top (65)                   [65,2,65,65]
  TNSS           Print as character                   [65,2,65]        A
  SSSTSTSN       Push 10                              [65,2,65,10]
  TNSS           Print as character                   [65,2,65]        \n
  SNT            Swap top two                         [65,65,2]
  NSNTN          Jump to Label_INNER_LOOP             [65,65,2]

  SSSTN          Push 1                               [65,65,2,1]
  TSST           Subtract (2-1)                       [65,65,1]
  SNS            Duplicate top (1)                    [65,65,1,1]
  NTTSN          If negative: Jump to Label_LOOP      [65,65,1]
  SNT            Swap top two                         [65,1,65]
  SNS            Duplicate top (65)                   [65,1,65,65]
  TNSS           Print as character                   [65,1,65]        A
  SSSTSTSN       Push 10                              [65,1,65,10]
  TNSS           Print as character                   [65,1,65]        \n
  SNT            Swap top two                         [65,65,1]
  NSNTN          Jump to Label_INNER_LOOP             [65,65,1]

  SSSTN          Push 1                               [65,65,1,1]
  TSST           Subtract (1-1)                       [65,65,0]
  SNS            Duplicate top (1)                    [65,65,0,0]
  NTTSN          If negative: Jump to Label_LOOP      [65,65,0]
  SNT            Swap top two                         [65,0,65]
  SNS            Duplicate top (65)                   [65,0,65,65]
  TNSS           Print as character                   [65,0,65]        A
  SSSTSTSN       Push 10                              [65,0,65,10]
  TNSS           Print as character                   [65,0,65]        \n
  SNT            Swap top two                         [65,65,0]
  NSNTN          Jump to Label_INNER_LOOP             [65,65,0]

  SSSTN          Push 1                               [65,65,0,1]
  TSST           Subtract (0-1)                       [65,65,-1]
  SNS            Duplicate top (-1)                   [65,65,-1,-1]
  NTTSN          If negative: Jump to Label_LOOP      [65,65,-1]

 (Note: Contains additional trailing `[65,` here, but we'll ignore that for now.)
 SNS            Discard top                           [65]
 SSSTN          Push 1                                [65,1]
 TSSS           Add (65+1)                            [66]
 SNS            Duplicate top (66)                    [66,66]
 SNS            Duplicate top (66)                    [66,66,66]
 SSSTSTTSTTN    Push 91                               [66,66,66,91]
 TSST           Subtract (66-91)                      [66,66,-25]
 NTSSSN         If 0: Jump to Label_EXIT              [66,66]
 SSSTSSN        Push 4                                [66,66,4]
 NSSTN          Create Label_INNER_LOOP               [66,66,4]
  SSSTN          Push 1                               [66,66,4,1]
  TSST           Subtract (4-1)                       [66,66,3]
  SNS            Duplicate top (3)                    [66,66,3,3]
  NTTSN          If negative: Jump to Label_LOOP      [66,66,3]
  SNT            Swap top two                         [66,3,66]
  SNS            Duplicate top (66)                   [66,3,66,66]
  TNSS           Print as character                   [66,3,66]        B
  SSSTSTSN       Push 10                              [66,3,66,10]
  TNSS           Print as character                   [66,3,66]        \n
  SNT            Swap top two                         [66,66,3]
  NSNTN          Jump to Label_INNER_LOOP             [66,66,3]

  ... etc. etc. for all letters in the alphabet

 SNN            Discard top                           [90]
 SSSTN          Push 1                                [90,1]
 TSSS           Add (90+1)                            [91]
 SNS            Duplicate top (91)                    [91,91]
 SNS            Duplicate top (91)                    [91,91]
 SSSTSTTSTTN    Push 91                               [91,91,91]
 TSST           Subtract (91-91)                      [91,91,0]
 NTSSSN         If 0: Jump to Label_EXIT              [91,91]                    error
                (Label_EXIT doesn't exit, so exits program with an error to STDERR)

SmileBASIC, 29 bytes
FOR I=260TO 363?CHR$(I/4)NEXT

This is a polyglot, and will function in Yabasic - Try it online!

@NUM, 43 bytes
#1@13#0@65|#1$#0$#1$#0$#1$#0$#1$#0$+<90{*0}

(I messed up on some of the code, now it works, but is almost double the size...)

Welcome to PPCG! Languages are required to have an implementation (interpreter/compiler), so you'll need to either link to one or write one.

I would call your language implementation an interpreter. Also, I am unsure if a leading newline is valid. Furthermore, I would recommend not to send the execution time to stdout.

Charcoal, 6 5 bytes
ＦαＥ⁴ι

-1 byte thanks to @Neil.
Try it online (verbose) or try it online (pure).
Explanation:
Loop over the characters of the uppercase alphabet:
For(a)
Ｆα

Create an array of size 4, each mapped to the current letter. (Items of an Array are each printed on a separated line by default.)
Each(4, i)
Ｅ⁴ι

Hm, that's 6 characters, but I don't see how you can encode them into 6 bytes.  I would change the title to just claim "6" instead of "6 bytes". Sadly, 6 characters is still one more than APL.

@MarkReed In UTF-8 this would indeed be a bit more than 6 bytes (15 to be exact). However, Charcoal uses, just like most codegolf languages (i.e. Jelly, 05AB1E, etc.), a custom code page for all 256 characters it knows, where each character is encoded as a single byte.

Ah, my mistake. Didn't realize it was limited to a single code page. Carry on. :)

5 bytes: ＦαＥ⁴ι

@Neil I see you're going through all my Charcoal answer. :) And nice golf! I didn't even knew the Each/Map builtin could be used like that.

Heh, I hadn't realised there were so many!

K (oK), 17 16 bytes
Solution:
`0:`c$+,65+&26#4

Try it online!
Explanation:
`0:`c$+,65+&26#4 / the solution
            26#4 / generate a vector of 26 4s
           &     / where, turns this into 0 0 0 0 1 1 1 1 2 2 2 2 etc
        65+      / add 65 to this vector
       ,         / enlist (,:) each-both (')
      +          / flip
   `c$           / convert to characters
`0:              / print to stdout

Notes:

-1 byte with thanks to @ngn!

,:' -> +,

Cardinal, 68 bytes
%+v
(A+
~ =
([t
' >t*~v
8 v~'n<
D<v< #
-~
~+,
 ,,
 ,,~
 ,,-
 ,~
>^R^

Try it online!
Explanation
%+v
(A+
~ =
([t
' >t*~v
8 v~'n<
**** #

Sets up loops for printing and corrects timing between loops. Right column sets up space to be printed in a loop of 25 times while left column sets up letters of alphabet starting with A to be printed.
D<v<
-~
~+,
 ,,
 ,,~
 ,,-
 ,~
>^R^

Left 2 columns print out each letter in alphabet while right 2 columns print out newlines.
How the loops work:
The inactive value of the pointer is set to the number of times to iterate through the loop. The timing of the loops is set up so that it will print alphabet character then newline four times before decrementing the inactive value of the pointer. The alphabet character to print was selected at the start by assigning the ascii value of A to the active value of the pointer "(A" in the code. After each loop of printing, this active value is incremented by one to print the next character in the alphabet.

Brian & Chuck, 32 bytes
A{<?
!{>-_{.>.<.>.<.>.<.+>.>-?

Try it online!
code:
Brian:
A                       ["A", 11, 26] Variables: Letter, newline+1, letter count
{<?                        restart current code portion of Chuck

Chuck:
code 1:
{>-                        go to "newline+1" and decrement it, so it becomes a newline

code 2:
{                          go to letter
.>.<.>.<.>.<               print letter and newline three times
.+                         print and increment letter
>.                         print 4th newline
>-                         decrement counter
?                          if counter > 0, switch to Brian (who just restarts Chuck's code 2)

Keg, 20 bytes (SBCS on Keg wiki)
AZɧ^(\
(3|$:\
)$(8|,

Push range from A to Z and then 4-speak it.

naz, 72 bytes
9a1a2x1v9m2x2v3d2m4a1x1f1a2x3v1o1v1o3v1o1v1o3v1o1v1o3v1o1v1o3v3x2v1l0x1f

Explanation (with 0x commands removed)
9a1a2x1v                                         # Set variable 1 equal to 10 (newline)
9m2x2v                                           # Set variable 2 equal to 90 ("Z")
3d2m4a                                           # Set the register to a value of 64 ("@")
1x1f                                             # Function 1
    1a                                           # Add 1 to the register
      2x3v                                       # Store the new value in variable 3
          1o1v1o3v1o1v1o3v1o1v1o3v1o1v1o         # Output it, then a newline, four times
                                        3v       # Load variable 3 into the register
                                          3x2v1l # Jump back to the start of the function
                                                 # if the register is less than variable 2
1f                                               # Call function 1

Jelly, 7 bytes
ØAṄ4¡€*

Try it online!
Explanation
ØAṄ4¡€*
   ØA: alphabet
   Ṅ: print w/ new line
   4¡: repeat 4 times
   €: each
   *: to error out(see below)

The reason I use the * is to error out the code so it wont print the whole alphabet at the end (I'm very new to jelly). If anyone can tell me what character to use in combination with Ṅ to achieve this, I would appreciate it!

Welcome to Code Golf, and impressive first answer! Jelly implicitly outputs the final value at the end of the program, and so Jelly programs normally avoid using Ṅ in favour of printing at the end. For example, rather than printing each one 4 times, you can repeat each letter 4 times (to create 'AAAABBBBCCCC....'), then join by newlines. This approach takes 5 bytes

thank you for the quick response! I see what you mean about editing te string rather than the output... I learned something new!

If you're interested in learning more Jelly, feel free to drop by the Jelly Hypertraining chat room :)

Vyxal, 6 bytes
4kA*s⁋

Try it Online!
4      - Literal
 kA    - Uppercase alphabet
   *   - Multiplication
    s  - Sort
     ⁋ - Join by newlines

Vyxal j, 4 bytes
kA4•

Try it Online!
Multiplies each letter of the alphabet by 4, and joins on newlines.

Bash 28 26
echo {a..z}{,,,}|tr \  \\n

A shame bash doesn't do curly-brace expansion on here-strings.

Q, 16
........
-1@'(,/)4#'.Q.A;

4DOS, 59 (including newlines)
Why? Because not enough people use it any more and it's still the same size as C and shorter than F#!
do i=65 to 90
@for %j in (1 2 3 4) do echo %@CHAR[%i]
enddo

JavaScript (59 56)
for(i=65;i<91;i+=1/4)console.log(String.fromCharCode(i))

Hey @user113215, you can save 1 extra char by doing i|0 instead of i,10!

@DomHastings No, i,10 prints a newline as well as the letter. i|0 is the same as just i. Considering that console.log adds an implicit newline, however, I suppose this could be shortened to just i.

Ahhh, i see! Apologies, for some reason I thought it was doing some kind of parseInt!

Clojure 41 45 bytes
(doseq[i(range 65 91 0.25)](println(char i)))

except that outputs the letters in reader character syntax (\A, \B, etc).  And I don't count leading backslashes as "whitespace". :)  Replacing prn with println yields the correct output at a cost of 4 additional characters.

you'r right, i was too lazy to test it out :D fixed

C#, 86 bytes
class P{static void M(){for(var i=65d;i<91;i+=.25)System.Console.WriteLine((char)i);}}

a full program...

LINQ, 59 bytes
from i in Enumerable.Range(0, 104)select(char)(65+i/4)+"\n"

LINQ expression, try it with LinqPad. The select part is a bit too C#ist but I guess that fine.
from i                        // for each variable
in Enumerable.Range(0, 104)   // in the range 0, 26*4
select(char)(65+i/4)+"\n"     // get the letter and a newline

C#, 88 bytes
var s="";int i,j;for(i=0;i++<26;){for(j=0;j++<4;)s+=(char)(i+64)+"\n";}Console.Write(s);

Try it with this REPL shell: https://csharppad.com/

dc, 23 bytes
260[d4/PAP1+d364>M]dsMx

Try it online!
Since precision is 0 by default, 260, 261, 262, and 263 all return 65 when divided by 4. All we need to do, then, is start with 260 on the stack, and continue duplicating the top of stack, dividing by 4, printing that code point and a line feed and then incrementing by one until we hit 364 (91*4).

SOGL V0.12, 5 bytes
Z{4⌡T

Try it Here!

Taxi, 1215 449 bytes
(I am calling this the Magna Carta byte count)
It turns out to be way shorter to just hard code the text.
'A\nA\nA\nA\nB\nB\nB\nB\nC\nC\nC\nC\nD\nD\nD\nD\nE\nE\nE\nE\nF\nF\nF\nF\nG\nG\nG\nG\nH\nH\nH\nH\nI\nI\nI\nI\nJ\nJ\nJ\nJ\nK\nK\nK\nK\nL\nL\nL\nL\nM\nM\nM\nM\nN\nN\nN\nN\nO\nO\nO\nO\nP\nP\nP\nP\nQ\nQ\nQ\nQ\nR\nR\nR\nR\nS\nS\nS\nS\nT\nT\nT\nT\nU\nU\nU\nU\nV\nV\nV\nV\nW\nW\nW\nW\nX\nX\nX\nX\nY\nY\nY\nY\nZ\nZ\nZ\nZ' is waiting at Writer's Depot.Go to Writer's Depot:w 1 r 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.

Try it online!
Ungolfed / formatted:
'A\nA\nA\nA\nB\nB\nB\nB\nC\nC\nC\nC\nD\nD\nD\nD\nE\nE\nE\nE\nF\nF\nF\nF\nG\nG\nG\nG\nH\nH\nH\nH\nI\nI\nI\nI\nJ\nJ\nJ\nJ\nK\nK\nK\nK\nL\nL\nL\nL\nM\nM\nM\nM\nN\nN\nN\nN\nO\nO\nO\nO\nP\nP\nP\nP\nQ\nQ\nQ\nQ\nR\nR\nR\nR\nS\nS\nS\nS\nT\nT\nT\nT\nU\nU\nU\nU\nV\nV\nV\nV\nW\nW\nW\nW\nX\nX\nX\nX\nY\nY\nY\nY\nZ\nZ\nZ\nZ' is waiting at Writer's Depot.
Go to Writer's Depot: west 1st right 3rd left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.

Tcl, 51 bytes
time {puts [format %c [expr (259+[incr i])/4]]} 104

Try it online!

Clever use of time to avoid the for loop.

Lua, 53 Bytes
Simple solution, we're using the range [260,363] which is 65*4 and 90*4+3 (letter A and Z) to iterate.
Then we just have to do an euclidian division by 4 and print out each letter 4 times this way.
Edit: Approved @MCAdventure10's edit that pointed out a rounding error that made only one Z being printed out, it wasn't deviating from my original idea and didn't change the byte count, thus,I approved it.
for i=260,363 do print(("").char(math.floor(i/4)))end

Funky, 32 bytes
fori=0i<104i++print("%c"%65+i/4)

Try it online!

F# (.NET Core), 43 bytes
for i in 260..363 do printfn"%c"(char(i/4))

Try it online!

Add++, 19 bytes
L,91 65rbU€C4€*JbUn

Try it online!
How it works
L,			; Create an anonymous function
	91 65rbU	; Push [65 ... 90]	STACK = [65 66 ... 89 90]
	€C		; Convert to chars;	STACK = ['A' 'B' ... 'Y' 'Z']
	4€*		; Repeat each 4 times;	STACK = ['AAAA' ... 'ZZZZ']
	JbUn		; Join by newlines;	STACK = ['A\nA\n ... Z\nZ']

Jelly, 5 bytes
ØAx4Y

Try it online!

Python 2.7, 78 bytes
x='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for e in x:
    for d in range(0, 4):
        print e

Golfing challenge submissions have to make an attempt at golfing. In your code there is unnecessary white space, the variable x is declared once so could be inlined and the last for loop's body is not a compound statement so could be put on the same line. I also suggest reading the Python tips page.

Attache, 28 bytes
Print@Char=>Flat!4&`&=>65:90

Try it online!

BRAINF 115 BYTES...
++++[->+++>+++>+++<<<]>+>+>+<<<++++[->>+++>+++<<<]>>+>+<<<+++++++++++++[->>>+++<<<]>>[->.<<.>>.<<.>>.<<.>>.<<.>>+<]

I know this isn't going to in any awards for being the smallest, but I just thought it would be funny to use one of the hardest to understand languages.
Breakdown of Code
Cell zero is used for counting for setup, cell 1 and 3 are used to print, and cell two is used to count for the printing sequence
0          1             2                    3
[setup][newline char][print counter][output char (set to A to begin)]
++++[->+++>+++>+++<<<]>+>+>+  sets cells 1, 2, and 3 to 13(new line)
<<<++++[->>+++>+++<<<]>>+>+   sets cells 2 and 3 to 26 (length of alphabet)
<<<+++++++++++++[->>>+++<<<]  sets cell  3 to 65(A)
>>[->.<<.>>.<<.>>.<<.>>.<<.>>+<] increments cell 3, prints alternating between cell 1
                              and 3, and decrements cell 2.

Here is a Brainf compiler to test it (use the one w/out any newlines)

Is it so hard to just say brainfuck? At the very least brainf*ck if you're that uncomfortable with swearing. Saying BRAINF just makes everyone confused about what you're referring to

also, the triple exclamation mark is a bit too excitable for almost twice the bytecount of the previous brainfuck answer

@JoKing I wrote this before i realized that there was another Brainfuck program, sorry about that, i never got to fixing it

having a longer answer is okay, especially in a language like brainfuck. the tips for golfing in brainfuck page might interest you for future submissions

Python 2, 39 bytes
i=65;exec('print chr(i);'*4+'i+=1;')*26

Try it online!

05AB1E, 6 bytes
A€D€D»

Try it online!
Explanation
A        # push lowercase alphabet
 €       # for each char:
  D      # duplicate it
   €D    # duplicate each char again
     »   # join by newlines
         # implicit output

cQuents, 18 bytes
|
#104&h64+k,Z,Z,Z

Try it online!
Explanation
|
                  use newline as delimiter
#104              default input n = 104
    &             print first n terms in sequence
                  each term is the next term in the comma-delimited sequence, restarting
                  and incrementing k when the end of the terms list is reached
     h64+k        chr ( 64 + k )
          ,Z,Z,Z  next three terms equal the previous term

GolfScript, 17 bytes
91,65>''+{...}%n*

Try it online!
Explanation
91,65>            # Genearate initial alphabet
      ''+         # Convert to a string
         {...}%   # For every item, copy 3 times
               n* # Join the resulting string by newlines
                  # (because a string is a codepoint array)

Burlesque, 16 bytes
@AZr@4?*{)'
}\mQ

Try it online!
@AZr@ # Array of A-Z as chars
4?*   # 4 of each as strings
{
 )'   # Add a newline between each letter
}\m   # Map for each string of 4 and concatenate
Q     # Pretty print for newlines instead of "\n"

Google Sheets, 40
Output per cell:
=ArrayFormula(CHAR(SEQUENCE(104,1,260)/4

If newlines are important, 49:
=ArrayFormula(JOIN("
",CHAR(SEQUENCE(104,1,260)/4

No, Sequence does not support floating point steps.

F#, 57 bytes
for i in 97..122 do for _ in 0..3 do printf"%c\n"(char i)

Try it online!
Loop through the alphabet (for i in 97..122), then through 4 times (for _ in 0..3), and finally print the character with a newline (printf"%c\n"(char i)).
Here is another one, 71 bytes:
for i in 97..122 do printf"%s"(String.replicate 4(string(char i)+"\n"))

Ungolfed code:
for i in 97..122 do for _ in 0..3 do printf "%c\n" (char i)

Julia 1.0, 26 bytes
@.print((('A':'Z')*"
")^4)

Try it online!

Haskell, 43 bytes
main=mapM(putStrLn.pure)$['A'..'Z']<*[1..4]

Try it online!
This has two parts mapM(putStrLn.pure) takes a list of characters and prints each on it's own line.
['A'..'Z']<*[1..4] produces the list of desired characters.  It does this with the monadic operator (<*) which works like (>>) except it keeps the values from the first arguement instead of the second.

Excel, 21 bytes
=CHAR(ROW(260:363)/4)

Link to Spreadsheet
I think this would have worked when the question was asked if 104 cells were selected and Ctrl+Shift+Enter were used.

Python 3, 46 45 bytes
print(*["\n%c"%(i//4+65)for i in range(104)])

Python 3, 39 bytes
for i in range(104):print(chr(i//4+65))

I prefer the first solution for being a true one-liner. But a correction of Justin's answer leads to a shorter solution.

You can save a byte with "\n%c"%(i//4+65) on your first program: TIO

Noether, 22 bytes
65~i91(0~l4(iBP?!l)!i)

Try it online!

Zsh, 21 bytes
eval '<<<'{A..Z}{,,,}
Attempt This Online!

Nice one, taking advantage of the fact that a bare here-string (or here-doc) in zsh acts like there's a cat in front of it. Clever!

Google Sheets, 48 bytes
=flatten(sort(if({1,1,1,1},char(row(A65:A90)))))

you can get this down to 25 bytes if you port over Axuary's Excel answer as =Sort(Char(Row(260:363)/4 (Sheets handles arrays quite differently) or 38 bytes by optimizing your addresses, and removing the if function as =Flatten(Sort(Char({1,1,1,1}*Row(65:90

Pip -n, 10 bytes
_MWV(zRL4)

Try It Online!
_MWV(zRL4)
    (zRL4)     ; repeat z="abcde...xyz" 4 times, forming the list [z,z,z,z]
  WV           ; weave the the 4 z's together, forming the string "aaaabbbb...yyyyzzzz"
_M             ; convert to a list
               ; implicitly joined by newlines by the -n flag and printed

Excel, 28 bytes.
=CHAR(SEQUENCE(104,,65,1/4))

No need to drag it will spill if one uses MS365 or Excel 2021.

///, 207 bytes
A
A
A
A
B
B
B
B
C
C
C
C
D
D
D
D
E
E
E
E
F
F
F
F
G
G
G
G
H
H
H
H
I
I
I
I
J
J
J
J
K
K
K
K
L
L
L
L
M
M
M
M
N
N
N
N
O
O
O
O
P
P
P
P
Q
Q
Q
Q
R
R
R
R
S
S
S
S
T
T
T
T
U
U
U
U
V
V
V
V
W
W
W
W
X
X
X
X
Y
Y
Y
Y
Z
Z
Z
Z

bash shell, 19 bytes
echo {A..Z}{,,,}'
'

This seems to print \n instead of actual newlines between characters. Try it online!

@WheatWizard Replace \n with a real line feed. It's more a wrong byte count

You can use ANSI quotes. echo {A..Z}{,,,}$'\n' That takes it to 21 bytes. You also have a leading space before every letter except the first A. You can fix that by using printf %s\\n {A..Z}{,,,} at a cost of taking it to 24 bytes.

yeah, thks for that.

Factor + sequences.repeating spelling, 38 bytes
ALPHABET 4 repeat 10 interleaved print

Attempt This Online!
ALPHABET       ! "abcdefghijklmnopqrstuvwxyz"
4 repeat       ! "aaaabbbbccccddddeeeeffffgggghhhhiiiijjjjkkkkllllmmmmnnnnooooppppqqqqrrrrssssttttuuuuvvvvwwwwxxxxyyyyzzzz"
10 interleaved ! "a\na\na\na\nb\nb\nb\nb\nc\nc\nc\nc\nd\nd\nd\nd\ne\ne\ne\ne\nf\nf\nf\nf\ng\ng\ng\ng\nh\nh\nh\nh\ni\ni\ni\ni\nj\nj\nj\nj\nk\nk\nk\nk\nl\nl\nl\nl\nm\nm\nm\nm\nn\nn\nn\nn\no\no\no\no\np\np\np\np\nq\nq\nq\nq\nr\nr\nr\nr\ns\ns\ns\ns\nt\nt\nt\nt\nu\nu\nu\nu\nv\nv\nv\nv\nw\nw\nw\nw\nx\nx\nx\nx\ny\ny\ny\ny\nz\nz\nz\nz"
print          ! (print to stdout)

Wren, 57 bytes
for(c in 65..90)System.write((String.fromByte(c)+"\n")*4)

Try Wren

Headascii, 59 bytes
+++++[]]ONE.+++++[]]]]]++^[]]+[U{D-^)!:RP]PRP]PRP]PRP]PN][}

"Try it" on DSO (links to a version which only supports number output, but should get the point across)
Alternatively, try it here, but code will have to be pasted in as shown:
erun("+++++[]]ONE.+++++[]]]]]++^[]]+[U{D-^)!:RP]PRP]PRP]PRP]PN][}")

short breakdown:
+++++[]]O                                        save 10 to global array
         NE                                      go to next code block
.                                                code block separator
+++++[]]]]]++^                                   set r1 to 27
              []]+[                              set r2 to 55
                   U                             grab 10 from the global array
                    {D-^) :                   }  while --r1 + 1 != 0
                           RP                      send out ascii 10 (newline)
                             ]P                    send out ascii 10 + r2 (letter)
                               RP]PRP]PRP]P        (four times total)
                                           N][     r2++
                         !                       finally, print all 'send out' chars

However, I must note that if instead of using erun we run it with lrun, newlines are automatically appended at the end of each print (and ! is no longer required because technically it's a Headass program), making this 38 byter possible:
Headass lrun, 38 bytes
+++++[]]]]]++^+++++[]][{D-^):N][]PPPP}

DSO link, still prints as numbers, must-paste-in-code interpreter link
Which... I guess its just dawning on me that that's a different.. Version? ...But I'm not going to go and mark all my Headas(s|cii) answers based on which "interpreter" they use unless it's actually relevant to the challenge :P
Oh and of course, a breakdown:
+++++[]]]]]++^                          set r1 to 27
              +++++[]][                 set r2 to 64
                       {D-^):        }  while --r1 != 0
                             N][]PPPP     print ++r2 four times

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

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


text:
Build an exact change calculator
When I'm at a store and I pay for something in cash, I always try to give as exact change as possible in order to minimize the number of coins I have left in my wallet afterwards.
Your task is to build a program that will automate this process for me.
Your program will accept as input:

a line containing a single decimal number representing the price of an item.
a line consisting of a list of pairs of numbers, each pair representing the value of a denomination of coin or bill, and then the current amount of that denomination that I have in my wallet.
a line consisting of a list of denominations that the cashier has (you may assume they have an unlimited amount of each).

For example, the following input:
21.36
0.01 6 0.05 2 0.10 3 0.25 4 1.00 1 2.00 2 5.00 1 20.00 5
0.01 0.05 0.10 0.25 1.00 2.00 5.00 10.00 20.00 50.00 100.00

represents that I'm buying an item costing $21.36, and I have six pennies, two nickels, three dimes, four quarters, one loonie, two toonies, one five-dollar bill, and five 20-dollar bills.
Your program will then output the following:

the change that I should give to the cashier.
the change that the cashier will give me in return. You must optimize this as well in order to have a good solution.
the list of coins and bills still left in my wallet.
the total number of coins and bills left in my wallet after the transaction.

In this case, the optimal output is:
0.01 6 0.05 2 0.10 2 0.25 4 20.00 1

0.10 1 1.00 1 2.00 2 5.00 1 20.00 4
12

because I have exact change and this configuration uses the most coins to give that change. The second line is blank because no change was given in return.
Note that your program must support unconventional denominations such as 0.04 or 15.32, if they are part of the input. You are not guaranteed that every denomination will be a multiple or factor of another, except that every denomination will be a multiple of the lowest one, so that there is always a valid solution. You may assume that I will always have enough money to pay for the item whose price is listed.
In a few days, I will be posting a suite of 1,000 test cases for this program. Your program will be scored by the sum of the total number of coins and bills left in my wallet for each test case, with shorter code being a tie-breaker.

"Note that your program must support unconventional denominations". Guess that means I can't use the Greedy Algorithm

What is the largest number you want us to make? Must we use arbitrary precision or is long precision or int precision enough?

You can assume that the transactions in question will not exceed 1 million dollars.

You are asking for lowest amount of coins? Or for lowest amount of money types? $5 and $20 are bills, not coins, so do you care about those?

I kind of lumped everything into "coins", but yes, I mean lowest number of all monetary objects.

Also, you can indeed use the greedy algorithm, but it will produce suboptimal solutions.

@Quincunx Regarding precision, why not just use integers? .01 becomes 1, etc.

@DavidCarraher Yeah I know that. I meant arbitrary length integers.

@DavidCarraher: A note on using integers - using those in the internal data representation is fine, but you still have to take input and present output in decimal form.

Yes, that makes sense.

How much time do we still have on this question?  "A few days" was mentioned on the 14th, but nobody's answered so far.  Is it worth trying to join this late?

Also can we always assume that a denomination is written in form x*.yy?

Lastly how efficient does this have to be?

@Panzercrisis: "A few days" was supposed to be the timeline in which I created test cases. You can join in as late as you want; I will always adjust the accepted answer to be the one that currently wins, regardless of how late it was posted. You may always assume that the currency amounts will be x*.yy, and the code should run at least fast enough that you can test all 1,000 test cases in a day.

@JoeZ. Thanks!  I wasn't sure earlier about asking about that last question.

I thought it was a requirement to maximize the amount of coins used, but your example does not (4 quarters is clearly better than 1 dollar in this regard). Is the goal to 1) maximize payment coin count, 2) minimize total coin count after transaction (yours + cashier's return), or 3) just to pay in exact change?

Actually, that's just me being an idiot. Thanks for catching that error! (Also, it's number 2.)

I always try to give as exact change as possible in order to minimize the number of coins I have left in my wallet afterwards. Then the best solution is to give the cashier all of you cash. They will(should) then return to you the most efficient way to represent what's left

Is it possible that we have a type of coin that the cashier doesn't have?

Yes, it is possible, and in this case I think my algorithm was borked from the beginning. I think I should be minimizing coins given + coins left in wallet afterwards.

Otherwise I could impose the restriction that the cashier cannot return any denominations that you gave them, which will always still produce an "optimal" solution because transactions of change can be cancelled out.

If you change the scoring, as described in your comment, the only value that matters will the the number of coins received in change. That's because coins given+coins in wallet at the end is equal to coins in wallet at start+change received and coins in wallet at start is a constant. So, rather than making the scoring have two parts, why not just say to minimize the number of coins given in the change?

Your example still isn't minimal for the current scoring system. You should give an additional 2x $20s, 1x $5, 2x $2s and 1x $1 and get 1x $50 back.

My god, you're right. Maybe we should close this question and post a new one, since I think this question has gone through too many rule changes and discussion for the work of people who were going by the old rules to still be salvageable.

Related: Euro coins and notes

I think I have a Python 3 solution that should work for any test case. It took me quite a few tries to get something that wouldn't explode for certain degenerate inputs. It's still pretty slow for some large inputs where you have thousands of coins in your wallet to start, but I don't think it's possible to do much better in those cases (you must search a very large set of possible combinations of payment and change).
I've made two version of my solution, one that minimizes the number of coins you end up with in your wallet at the end (as per the current scoring rule), and another that minimizes the number of coins you are given in change (which is equivalent to minimizing the number of coins in your wallet at the end plus the number of coins you paid with, which Joe Z. has been considering changing the scoring rule to). You can switch which version is run by moving the leading # for the comment in the if __name__ == "__main__" block to the previous line. Both versions are based on of the same recursive change making algorithm (in the make_change function), they just run it with slightly different inputs.
The code exploits the effect that Cruncher noted in the question's comments, that the best overall algorithm is to give all your money to the cashier and then get ideal change for your final balance back. What my code does is give all the money to the cashier, then charge a "cost" to the solution for each coin or bill returned to the customer. The best solution is the one with the combined cost for its bills and coins. Later I do some cleaning up, and eliminate any payments that get directly returned using the same bills or coins.
For the version optimized for the original scoring rule, the cost is 1 for every coin or bill. For the alternative scoring rule, the cost is 0 for bills and coins that were originally in the customer's wallet (and are being returned), and 1 for anything that needs to come from the cashier's drawer.
The core algorithm is a depth-first search for combinations of coins that yield exact change. Larger coins are tried first, and more of them before fewer. This means the first result we find will be the "greedy" one (though we keep searching and may find a better result later).
The interesting part of the algorithm is that it keeps track of the cost of the best result found so far, and stops searching for more results down any branch that costs more than that that result. This lets it avoid considering a lot of possible combinations that require too much from the cashier (like thousands of pennies).
I do get a different optimal result for the example case given in the question, but it is in fact better for the current scoring rule (I pay several extra small bills and get a single $50 in change). My output is:
0.01 6 0.05 2 0.10 2 0.25 4 1.00 1 2.00 2 5.00 1 20.00 3
50.00 1
0.10 1 20.00 2 50.00 1

For the alternate scoring rule I get the same result shown in the question.
I've not made much effort at minimizing the number of characters in this code, though some parts were written in terse, code-golf style before I got more distracted by performance issues and correctness. I think I've factored out the all the repeated code into separate functions, but let me know if you see any obvious improvements.
def make_change(value, coins, best_cost=float("inf")):
    if value == 0:
        return [], 0

    best_solution=None
    for i, (coin, count, cost) in enumerate(coins):
        max_num = min(count, value//coin, best_cost//cost if cost else float("inf"))
        for num in range(max_num, 0, -1):
            coin_value = num*coin
            coin_cost = num*cost
            if coin_cost < best_cost: # this is always true the first iteration, but may not be later
                solution, solution_cost = make_change(value-coin_value, coins[i+1:],
                                                      best_cost-coin_cost)
                if solution is not None:
                    best_solution = [(coin, num)] + solution
                    best_cost = coin_cost + solution_cost
    return best_solution, best_cost

def parse():
    value = int(input().replace(".",""))
    wallet = dict(zip(*[iter(map(int,input().replace(".","").split()))]*2))
    cashier = list(map(int,input().replace(".","").split()))
    return value,wallet,cashier

def print_output(pay, change, final_wallet):
    print(" ".join("{:.2f} {}".format(coin/100, count) for coin, count in pay if count != 0))
    print(" ".join("{:.2f} {}".format(coin/100, count) for coin, count in change if count != 0))
    print(" ".join("{:.2f} {}".format(coin/100, count) for coin, count in final_wallet if count != 0))

def solve(value, wallet, coins):
    result, cost = make_change(value, coins)
    pay=[]
    change=[]
    for coin, count in result:
        if coin in wallet:
            if wallet[coin] > count:
                pay.append((coin, wallet[coin] - count))
            elif wallet[coin] < count:
                change.append((coin, count - wallet[coin]))
            del wallet[coin]
        else:
            change.append((coin, count))
    pay.extend(wallet.items())
    pay.sort()
    change.sort()
    result.sort()
    return pay, change, result

def minimize_wallet(value, wallet, cashier):
    wallet_value = sum(coin*count for coin,count in wallet.items())
    coin_dict = wallet.copy()
    coin_dict.update((coin, wallet_value//coin) for coin in cashier)
    coin_list = [(coin, count, 1) for coin, count in sorted(coin_dict.items(), reverse=True)]
    return solve(wallet_value-value, wallet, coin_list)

def minimize_change(value, wallet, cashier):
    wallet_value = sum(coin*count for coin,count in wallet.items())
    coin_list = [(coin, count, 0) for coin, count in wallet.items()]
    coin_list.extend((coin, wallet_value//coin, 1) for coin in cashier)
    coin_list.sort(key=lambda x: (-x[0], x[2]))
    return solve(wallet_value-value, wallet, coin_list)

if __name__ == "__main__":
    print_output(*minimize_wallet(*parse()))
    #print_output(*minimize_change(*parse())) # use this if the scoring rules are changed

I'd also like to suggest a testcase that is likely to break many implementations:
1.00
100.00 10000
0.01 0.05 0.10 0.25 1.00 2.00 5.00 10.00 20.00 50.00 100.00 999999.00

This testcase comes with a story I like to call "The bank robber and the debt limit":

One day, Alice robbed a bank. She made a clean getaway with exactly one million dollars in $100 bills. On her way home from the bank, she stopped off at a convenience store to buy a candy bar, but realized that she had not brought her wallet with her, so the only money she had was her bag of stolen money (ten thousand $100 bills will fit snugly in a decent sized backpack if they're shrink wrapped). She hoped the clerk would be willing to break a $100 bill.
Unbeknownst to Alice, Bob the convenience store clerk had been recently laid off as a worker at the US Mint. He had worked for several months this past spring and summer preparing high-denomination platinum coins in case they would be the only way for the US Government to make its interest payments without Congress increasing the debt limit. It turned out the coins were not needed, so their existence was never acknowledged. When he was told his job was being cut, Bob decided he would keep on of the coins he had worked so hard on. He smuggled out a single $1,000,000-denominated coin in his box of personal effects.
Sadly for everyone involved, Bob was showing off his million dollar coin to a coworker when Alice came to his register to see if he'd give her $99 in change for her $1 candy bar. Alas, seeing the coin, Alice's compulsion to receive the smallest amount of change possible got the better of her. She misinterpreted the text on the coin saying it was "0.999999 pure Platinum" to mean it was worth that fraction of its face value. If that was the case, it would be exact change for her candy bar if she paid Bob with her backpack full of money. She'd go from having 10,000 bills to having just one coin!

Can your code satisfy Alice? Expected output:
100.00 10000
999999.00 1
999999.00 1

I'm sorry I put you through all those rule changes.

@JoeZ. No problem. The same basic algorithm works for either version, with just minor tweaks. And minimizing the change you get back (the newer scoring method) is probably a bit more interesting, since it's not just a pure change-making problem.

source: Stack Exchange

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

sort: votes


text:
Dungeon Construction Set
When I was a kid, I played the Intellivision game Advanced Dungeons and Dragons: Treasure of Tarmin.  The 3-D graphics put you in a first-person-perspective point of view with shocking realism:

But then I got a C-64.  And I was able to draw on the 40x25 character grid by cursoring around the screen, setting the color with the Ctrl key and a digit, and putting symbols anywhere I wanted (why doesn't bash let me do that?).  The character set had triangular components and solid block components.  So I was able to reason through how one might generate a rendering of one's perspective in a grid through that medium.
I found the nearly-three-decades-old spec, in spiral-bound notebook paper, about "Dungeon Construction Set" this week:

(UPDATE: Careful readers will notice that this doesn't quite hold together on the slanted parts.  Corrected numbers are provided below.)
Though Treasure of Tarmin was played on a grid, the walls existed only on the edges of grid squares.  Having learned what bytes were, I realized that if I made the map out of bytes...then each square on the map could have four possible states for each of its edges:

Unobstructed
Wall
Door
Something Else?

I never did get around to writing it (until last night).  I thought it might be fun for others to try.
So your task is to implement a character-mode-based maze renderer that implements my (corrected!!) spec...but using the technologies of 2013.
Input
Because the spec doesn't define rendering for doors, we'll just assume the only options are wall-and-not-wall.  For simplicity, your input is a map composed of lines of strings that look like this:
WN.. .N.. .N.. .N.. .N.E
W... .... .... ..S. ...E
W... .N.E W... .N.. ...E
W... .... .... .... ...E
W.S. ..S. ..S. ..S. ..SE

That would be a 5x5 map.  The upper left corner (1,1) has its West and North wall set.  The lower right corner (5,5) has its South and East wall set.
This is considerably less fun with no map navigation.  So at minimum, put your player at (1,1) facing north and offer them:
[F]orward, [B]ackward, turn [L]eft, turn [R]ight or [Q]uit?

At each step, output a 16x15 display of the first-person perspective, as defined by the notebook paper spec.  To keep you from having to count, the size of flat walls at the three distances are:
14x13  (directly in front of you; e.g. wall is in same cell)
8x7    (one step away)
6x5    (two steps away)

The bounding sizes of the slanted walls are:
1x15   (your direct left or right; e.g. wall is in same cell)
3x13   (one step away)
1x7    (two steps away)

Clarifications

Adjacent cells may disagree about shared walls.  So the south edge on a square might be a wall, while the north edge on the square to the south of it would be unobstructed.  In the original design I considered this a feature: it permits interesting ideas like one-way doors...or invisible walls that only appear after you passed through them.  For this simplification, follow the same rule: for navigation and rendering, pay attention only to the edge status on the cell closest to you in the direction you are facing.
The view is a lot better with "shading".  So for your full blocks, alternate either Unicode 2593 ▓ and 2591 ░, or use X and + if your implementation is ASCII.
Unicode triangle characters (25E2 ◢, 25E3 ◣, 25E4 ◤, 25E5 ◥) are a bit lame for drawing this.  Besides not having any shaded variants, they often stretch only the width of the character and not the full height...even in fixed width fonts.  You can draw full blocks or slash characters or something of your choosing in the places I wanted diagonals.  Interesting creative solutions that incorporate color and use these characters instead of shading appreciated.
You may assume the outermost walls are set to bound the playing area, so you don't have to worry about rendering anything outside of the maze.  Any walls farther away from you than the spec are ignored and just leave empty space.
The shading of the wall you see directly in front of you if facing North at (1,1) should be DARK.  Alternate shading on adjacent walls in the map, such that if all walls were present then a light wall would never abut a dark wall.
A C-64 implementation that actually does what I originally intended...with the diagonal characters and all...will trump any other entry criterion.  :-)

Examples
For the sample map given above...
At (1,3) facing south:
               /
              /+
             /X+
            /XX+
           /XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
           \XXX+
            \XX+
             \X+
              \+
               \

At (3,2) facing south:
                      /* blank line */
X             /
X            /+
X           /++
X           +++
X           +++
X           +++
X           +++
X           +++
X           +++
X           +++
X           \++
X            \+
X             \
                      /* blank line */

At (3,2) facing east:
                      /* blank line */
              /
             /X
            /XX
            XXX
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
            XXX
            \XX
             \X
              \
                      /* blank line */

At (2,3) facing north:
               /
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
               \

I suggest making this a [tag:code-challenge] - a golf would be way too unreadable and hard :P

@Doorknob Don't let it fool you...it's actually not all that hard.  There's a pretty good hint with the lists of 3 bounding sizes.  And what is a golf but a challenge that is solved and then pared down?  :-)  But I'll let people pick how they want to solve it... NP

Could you please explain the two columns of Xs in your view of 3, 2 facing south?

Especially the one on the right hand side. I see why the left one is there. But the right one seems to violate Clarification #1.

@jazzpi Oops, you're right, the map I put up does need to obey clarification 1!  Well done.  Fixed.  (I'd put the missing south wall in on my own version at some point apparently...but good to have a test case in the sample...so let's leave the south wall out!)

Commodore 64 Basic
Man, that was fun. And hard. C64 Basic is almost undebuggable, you can't even use print debugging because the screen is already taken for rendering the dungeon. You know you're having fun when you're writing code like 55250 goto 55110. Dijkstra will kill me.
The program uses two colors, and diagonal characters.
Needless to say I didn't golf it. It says code challenge now, after all. It's 7183 bytes if you're interested.
It's slow - at default speed it takes several seconds for it to render the scene. The maximum map size is 10 by 10 but it can be changed by editing line 120.
I have developed and tested this using the VICE emulator. The code below is displayed in ASCII, so that means shifted PETSCII. However, when inputting the map, you should use unshifted PETSCII.
Screenshot:

Code:
10 rem c64 dungeon construction set.
20 rem enter using lowercase mode
99 rem DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
100 rem initialisation
110 poke 53272,21
115 poke 53280,0
120 dim m%(10,10)
121 dim di$(3),wa$(1),ma%(2,2)
122 di$(0)="north"
123 di$(1)="east "
124 di$(2)="south"
125 di$(3)="west "
126 wa$(1)="-wall"
127 wa$(0)="     "

130 x=0:y=0:di=0:xs=0:ys=0:wa=0
134 rem read map
135 print "input map"
140 l$="":input l$
150 if len(l$)=0 goto 250
160 cz=0
170 for i=1 to len(l$)
180   c$=mid$(l$,i,1)
190   if c$="n" then cz=cz or 8
200   if c$="e" then cz=cz or 4
205   if c$="s" then cz=cz or 2
210   if c$="w" then cz=cz or 1
215   if c$=" " then m%(x,y)=cz:cz=0:x=x+1
220   if x>=xs then xs=x
225 next
230 m%(x,y)=cz:x=0:y=y+1
240 goto 140
250 rem come from 150
260 print chr$(147)
265 ys=y:xs=xs+1
270 x=0:y=0

500 rem loop
510 gosub 1000: rem status
515 gosub 2000: rem render
520 gosub 55000: rem input
530 goto 500

1000 rem display current (x,y) value
1010 sx=5
1020 sy=17
1030 sl$="    "
1035 sw=14
1040 gosub 63900
1050 cz=m%(x,y)
1060 sx=5:sl$=".":if cz and 8 then sl$="n"
1065 gosub 63900
1070 sx=6:sl$=".":if cz and 4 then sl$="e"
1075 gosub 63900
1080 sx=7:sl$=".":if cz and 2 then sl$="s"
1085 gosub 63900
1090 sx=8:sl$=".":if cz and 1 then sl$="w"
1095 gosub 63900
1100 return

2000 rem render dungeon
2010 rem DDDDDDDDDDDDDD
2020 rem clear area
2030 sw=14:sz=32
2040 for sy=0 to 15
2050   for sx=0 to 16
2060      gosub 63950
2070   next
2080 next
2090 rem find cells / reorient sw
2100 rem store in ma% - we're at (0,1)
2110 sx=x:sy=y
2113 co=di+x+y and 1
2115 for ty=0 to 2
2120    gosub 59800:rem left/right sx/sy
2125    ma%(1,ty)=0
2126    if sx>=0 and sy>=0 and sx<xs and sy<ys then ma%(1,ty)=m%(sx,sy)
2130    ma%(0,ty)=rl
2140    ma%(2,ty)=rr
2150    gosub 59900:rem advance
2160 next
2170 rem draw back walls
2180 sa=ma%(1,2):gosub 59700
2190 if rf=0 goto 2245
2195 sw=14-11*co:sz=160
2200 for sy=5 to 9
2210    for sx=5 to 10
2220       gosub 63950
2230    next
2240 next
2245 sw=3:if co=1 then sw=14
2250 for de=0 to 2 step 2
2260    sa=ma%(de,2):gosub 59700
2270    if rf=0 goto 2350
2280    for sx=de*5.5 to 4+de*5.5
2290       for sy=5 to 9
2300          gosub 63950
2310       next
2340    next
2350 next
2360 rem 1,2 left wall
2370 sa=ma%(1,2):gosub 59700
2380 if rl=0 goto 2430
2390 sx=4:sz=160
2400 for sy=5 to 9:gosub 63950:next
2410 sy=4:sz=223:gosub 63950
2420 sy=10:sz=105:gosub 63950
2430 rem 1,2 right wall
2440 if rr=0 goto 2490
2450 sx=11:sz=160
2460 for sy=5 to 9:gosub 63950:next
2470 sy=4:sz=233:gosub 63950
2480 sy=10:sz=95:gosub 63950
2490 rem 1,1 back wall
2500 sa=ma%(1,1):gosub 59700
2510 sz=160
2520 sw=14:if co=1 then sw=3
2520 if rf=0 goto 2580
2530 for sy=4 to 10
2540    for sx=4 to 11
2550       gosub 63950
2560    next
2570 next
2580 rem (0-2),1 back walls
2590 sw=14:if co=1 then sw=3
2600 for de=0 to 2 step 2
2610    sa=ma%(de,1):gosub 59700
2620    if rf=0 goto 2680
2630    for sx=de*6 to 3+de*6
2640       for sy=4 to 10
2650          gosub 63950
2660       next
2670    next
2680 next
2690 rem 1,1 left side wall
2700 sw=14:if co=1 then sw=3
2710 sa=ma%(1,1):gosub 59700
2720 if rl=0 goto 2760
2730 for sx=1 to 3
2735   sy=sx:sz=223:gosub 63950
2736   sy=14-sx:sz=105:gosub 63950
2737   sz=160
2740   for sy=1+sx to 13-sx:gosub 63950:next
2750 next
2760 rem 1,1 right side wall
2770 if rr=0 goto 2850
2780 for qx=1 to 3
2790   sx=15-qx
2800   sy=qx:sz=233:gosub 63950
2810   sy=14-qx:sz=95:gosub 63950
2820   sz=160
2830   for sy=1+qx to 13-qx:gosub 63950:next
2840 next
2850 rem 0,1 back wall
2860 sa=ma%(1,0):gosub 59700
2870 if rf=0 goto 2930
2880 for sy=1 to 13
2890   for sx=1 to 14
2900     gosub 63950
2910   next
2920 next
2930 rem (0,2)-0 back walls
2940 sw=3:if co=1 then sw=14
2950 for de=0 to 2 step 2
2960   sa=ma%(de,0):gosub 59700
2970   if rf=0 goto 3000
2980   sx=de*7.5
2990   for sy=1 to 13:gosub 63950:next
3000 next
3010 rem (1,0) left side wall
3020 sa=ma%(1,0):gosub 59700
3030 if rl=0 goto 3080
3040 sx=0:sy=0:sz=223:gosub 63950
3050 sy=14:sz=105:gosub 63950
3060 sz=160
3070 for sy=1 to 13:gosub 63950:next
3080 rem (1,0) right side wall
3085 if rr=0 goto 3130
3090 sx=15:sy=0:sz=233:gosub 63950
3100 sy=14:sz=95:gosub 63950
3110 sz=160
3120 for sy=1 to 13:gosub 63950:next
3130 rem done
3140 return

55000 rem ask for prompt & handle input
55010 sx=0:sy=20:gosub 63850
55013 print "at";x+1;y+1;"going ";di$(di);" size";xs;ys;wa$(wa)
55020 print "{f}rwd {b}kwd {l}eft {r}ight {q}uit"
55030 input c$
55040 if c$="q" goto 63999
55050 if c$="f" then dm=1:goto 55100
55060 if c$="b" then dm=-1:goto 55100
55070 if c$="l" then di=(di-1)and 3
55080 if c$="r" then di=(di+1)and 3
55090 return
55100 goto 55200:rem check walls
55110 if di=0 then y=y-dm
55120 if di=1 then x=x+dm
55130 if di=2 then y=y+dm
55140 if di=3 then x=x-dm
55145 wa=0
55146 if y>=ys then y=0
55147 if y<0   then y=ys-1
55148 if x>=xs then x=0
55149 if x<0   then x=xs-1
55150 return
55200 rem check walls
55205 cz=m%(x,y)
55207 if dm=-1 goto 55280
55210 if (di=0) and (cz and 8) goto 55260
55220 if (di=1) and (cz and 4) goto 55260
55230 if (di=2) and (cz and 2) goto 55260
55240 if (di=3) and (cz and 1) goto 55260
55250 goto 55110
55260 wa=1
55270 return : rem wall in the way
55280 rem backward
55290 if (di=2) and (cz and 8) goto 55260
55300 if (di=3) and (cz and 4) goto 55260
55310 if (di=0) and (cz and 2) goto 55260
55320 if (di=1) and (cz and 1) goto 55260
55330 goto 55110

59700 rem return front/back/left/right
59710 rem given sa and d
59720 sn=0:if sa and 8 then sn=1
59725 se=0:if sa and 4 then se=1
59730 ss=0:if sa and 2 then ss=1
59735 zw=0:if sa and 1 then zw=1
59740 if di=0 then rf=sn:rr=se:rb=ss:rl=zw
59745 if di=1 then rf=se:rr=ss:rb=zw:rl=sn
59750 if di=2 then rf=ss:rr=zw:rb=sn:rl=se
59755 if di=3 then rf=zw:rr=sn:rb=se:rl=ss
59760 return

59800 rem return left/right from sx/sy/d
59810 if di=0 then ly=sy:ry=sy:lx=sx-1:rx=sx+1
59820 if di=1 then lx=sx:rx=sx:ly=sy-1:ry=sy+1
59830 if di=2 then ly=sy:ry=sy:lx=sx+1:rx=sx-1
59840 if di=3 then lx=sx:rx=sx:ly=sy+1:ry=sy-1
59850 rl=0:rr=0
59860 if lx<0 or lx>=xs or ly<0 or ly>=ys goto 59880
59870 rl=m%(lx,ly)
59880 if rx<0 or rx>=xs or ry<0 or ry>=ys goto 59895
59890 rr=m%(rx,ry)
59895 return

59900 rem step forward
59910 if di=0 then sy=sy-1:rem N
59920 if di=1 then sx=sx+1:rem E
59930 if di=2 then sy=sy+1:rem S
59940 if di=3 then sx=sx-1:rem W
59950 return

63850 rem set cursor position
63851 rem sx=x sy=y
63860 poke 781,sy
63870 poke 782,sx
63880 poke 783,0
63890 sys 65520
63895 return

63900 rem write str to screen
63901 rem sl$ = string
63910 gosub 63850
63920 print sl$;
63930 return

63950 rem write chr to screen
63951 rem sx = x coordinate
63952 rem sy = y coordinate
63953 rem sz = character code
63954 rem sw = color
63950 sv=sx+sy*40
63960 poke 1024+sv,sz
63970 poke 55296+sv,sw
63980 return

63998 rem quit program
63999 print chr$(147):end

Tape image: download here.
The examples:

OMG.  If others want to solve this for the heck of it, great... but you have won the bounty by definition of the trump card in the challenge.  I was tempted to pull out an emulator and do it for nostalgia reasons, but thought it was more productive to write it in Red to see how well the compiler cross-compiler could hold-up.  source for that.  I'll Rebmu-ify it and post it at some point...but the bounty is yours!  Big applause.

Also, RE: Dijkstra, he has a funny quote on immortality: "I mean, if 10 years from now, when you are doing something quick and dirty, you suddenly visualize that I am looking over your shoulders and say to yourself 'Dijkstra would not have liked this', well, that would be enough immortality for me."  So I guess he got his wish!  :-)

@Dr.Rebmu: thanks for the bounty! This took me literally all day to write :)

Amazing! Thanks.

(why doesn't bash let me do that?)

I just had to now.
Bash, 12743 chars
#!/bin/bash
IFS=
declare -a term
typeset -i term[0] term[1]
IFS=' ' read -a term <<< `stty size`
front[0]='\e[2;2H██████████████
\e[3;2H██████████████
\e[4;2H██████████████
\e[5;2H██████████████
\e[6;2H██████████████
\e[7;2H██████████████
\e[8;2H██████████████
\e[9;2H██████████████
\e[10;2H██████████████
\e[11;2H██████████████
\e[12;2H██████████████
\e[13;2H██████████████
\e[14;2H██████████████'
front[1]='\e[5;5H████████
\e[6;5H████████
\e[7;5H████████
\e[8;5H████████
\e[9;5H████████
\e[10;5H████████
\e[11;5H████████'
front[2]='\e[6;6H██████
\e[7;6H██████
\e[8;6H██████
\e[9;6H██████
\e[10;6H██████'
lfront[0]='\e[2;1H█
\e[3;1H█
\e[4;1H█
\e[5;1H█
\e[6;1H█
\e[7;1H█
\e[8;1H█
\e[9;1H█
\e[10;1H█
\e[11;1H█
\e[12;1H█
\e[13;1H█
\e[14;1H█'
lfront[1]='\e[5;1H████
\e[6;1H████
\e[7;1H████
\e[8;1H████
\e[9;1H████
\e[10;1H████
\e[11;1H████'
lfront[2]='\e[6;1H█████
\e[7;1H█████
\e[8;1H█████
\e[9;1H█████
\e[10;1H█████'
rfront[0]='\e[2;16H█
\e[3;16H█
\e[4;16H█
\e[5;16H█
\e[6;16H█
\e[7;16H█
\e[8;16H█
\e[9;16H█
\e[10;16H█
\e[11;16H█
\e[12;16H█
\e[13;16H█
\e[14;16H█'
rfront[1]='\e[5;13H████
\e[6;13H████
\e[7;13H████
\e[8;13H████
\e[9;13H████
\e[10;13H████
\e[11;13H████'
rfront[2]='\e[6;12H█████
\e[7;12H█████
\e[8;12H█████
\e[9;12H█████
\e[10;12H█████'
left[0]='\e[1;1H▙
\e[2;1H█
\e[3;1H█
\e[4;1H█
\e[5;1H█
\e[6;1H█
\e[7;1H█
\e[8;1H█
\e[9;1H█
\e[10;1H█
\e[11;1H█
\e[12;1H█
\e[13;1H█
\e[14;1H█
\e[15;1H▛'
left[1]='\e[2;2H▙
\e[3;2H█▙
\e[4;2H██▙
\e[5;2H███
\e[6;2H███
\e[7;2H███
\e[8;2H███
\e[9;2H███
\e[10;2H███
\e[11;2H███
\e[12;2H██▛
\e[13;2H█▛
\e[14;2H▛'
left[2]='\e[5;5H▙
\e[6;5H█
\e[7;5H█
\e[8;5H█
\e[9;5H█
\e[10;5H█
\e[11;5H▛'
right[0]='\e[1;16H▟
\e[2;16H█
\e[3;16H█
\e[4;16H█
\e[5;16H█
\e[6;16H█
\e[7;16H█
\e[8;16H█
\e[9;16H█
\e[10;16H█
\e[11;16H█
\e[12;16H█
\e[13;16H█
\e[14;16H█
\e[15;16H▜'
right[1]='\e[2;13H  ▟
\e[3;13H ▟█
\e[4;13H▟██
\e[5;13H███
\e[6;13H███
\e[7;13H███
\e[8;13H███
\e[9;13H███
\e[10;13H███
\e[11;13H███
\e[12;13H▜██
\e[13;13H ▜█
\e[14;13H  ▜'
right[2]='\e[5;12H▟
\e[6;12H█
\e[7;12H█
\e[8;12H█
\e[9;12H█
\e[10;12H█
\e[11;12H▜'

echo -e "\e[2J"

# Read map
typeset -i cout
cout=0
echo "Please input your map!"
echo "Please input the next row (or leave it blank if you're finished!)"
read input

declare -A map

typeset -i xlen ylen
ylen=0

until [ -z $input ]
do
    IFS=' ' read -a inputmap <<< "$input"
    xlen=${#inputmap[*]}
    let ylen++
    for index in "${!inputmap[@]}"
    do
        typeset -i map[$index,$cout]
        map[$index,$cout]=0
        el=${inputmap[index]}
        if [[ $el == W??? ]]
        then
            let "map[$index,$cout]|=1"
        fi
        if [[ $el == ?N?? ]]
        then
            let "map[$index,$cout]|=2"
        fi
        if [[ $el == ??S? ]]
        then
            let "map[$index,$cout]|=4"
        fi
        if [[ $el == ???E ]]
        then
            let "map[$index,$cout]|=8"
        fi
    done
    echo "Please input the next row (or leave it blank if you're finished!)"
    read input
    cout+=1
done

echo -ne "\e[2J"

typeset -i dir x y
dir=0
x=0
y=0

move() {
    if ((dir == 0)) && ( ((${map[$x,$y]} & 2)) || ((y == 0)) )
    then
        return 1
    elif ((dir == 1)) && ( ((${map[$x,$y]} & 8)) || (($x == $xlen)) )
    then
        return 1
    elif ((dir == 2)) && ( ((${map[$x,$y]} & 4)) || ((y == $ylen)) )
    then
        return 1
    elif ((dir == 3)) && ( ((${map[$x,$y]} & 1)) || ((x == 0)) )
    then
        return 1
    fi
    x=$1
    y=$2
}

input=

until [[ $input == [qQ] ]]
do
    if [[ $input == [DlL] ]]
    then
        let dir-=1
        if (( dir == -1 ))
        then
            dir=3
        fi
    elif [[ $input == [CrR] ]]
    then
        let dir+=1
        if (( dir == 4 ))
        then
            dir=0
        fi
    elif [[ $input == [AfF] ]]
    then
        if (( dir == 0 ))
        then
            move $x $(( y-1 ))
        elif (( dir == 1 ))
        then
            move $(( x+1 )) $y
        elif (( dir == 2 ))
        then
            move $x $(( y+1 ))
        elif (( dir == 3 ))
        then
            move $(( x-1 )) $y
        fi
    elif [[ $input == [bB] ]]
    then
        if (( dir == 0 ))
        then
            dir=2
            move $x $(( y+1 ))
            dir=0
        elif (( dir == 1 ))
        then
            dir=3
            move $(( x-1 )) $y
            dir=1
        elif (( dir == 2 ))
        then
            dir=0
            move $x $(( y-1 ))
            dir=2
        elif (( dir == 3 ))
        then
            dir=1
            move $(( x+1 )) $y
            dir=3
        fi
    fi
    echo -ne "\e[2J"
    echo -ne "\e[16;1Hd=$dir; x=$x; y=$y\e[48;5;29m"
    for (( y2=1; y2 <= 15; y2++ ))
    do
        echo -ne "\e[$y2;16H\e[1K"
    done
    if (( dir == 0 ))
    then
        for (( y2=(y-2); y2 <= y; y2++ ))
        do
            if (( y2 < 0 )); then continue; fi
            let i=y-y2
            if (( x > 0 )) && (( ${map[$((x-1)),$y2]} & 2 ))
            then
                if (( ((x-1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( (x+1) < xlen )) && (( ${map[$((x+1)),$y2]} & 2 ))
            then
                if (( ((x-1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( ${map[$x,$y2]} & 1 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x,$y2]} & 8 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x,$y2]} & 2 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    elif (( dir == 1 ))
    then
        for (( x2=x+2; x2 >= x; x2-- ))
        do
            if (( x2 > 16 )) || (( x2 >= xlen )); then continue; fi
            let i=x2-x
            if (( y > 0 )) && (( ${map[$x2,$((y-1))]} & 8 ))
            then
                if (( (x2 + (y-1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( (y+1) < ylen )) && (( ${map[$x2,$((y+1))]} & 8 ))
            then
                if (( (x2 + (y-1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( ${map[$x2,$y]} & 2 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x2,$y]} & 4 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x2,$y]} & 8 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    elif (( dir == 2 ))
    then
        for (( y2=(y+2); y2 >= y; y2-- ))
        do
            if (( y2 > 15 )) || (( y2 >= ylen )); then continue; fi
            let i=y2-y
            if (( x > 0 )) && (( ${map[$((x-1)),$y2]} & 4 ))
            then
                if (( ((x-1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( (x+1) < xlen )) && (( ${map[$((x+1)),$y2]} & 4 ))
            then
                if (( ((x+1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( ${map[$x,$y2]} & 8 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x,$y2]} & 1 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x,$y2]} & 4 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    elif (( dir == 3 ))
    then
        for (( x2=(x-2); x2 <= x; x2++ ))
        do
            if (( x2 < 0 )); then continue; fi
            let i=x-x2
            if (( y > 0 )) && (( ${map[$x2,$((y-1))]} & 1 ))
            then
                if (( (x2 + (y-1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( (y+1) < ylen )) && (( ${map[$x2,$((y+1))]} & 1 ))
            then
                if (( (x2 + (y+1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( ${map[$x2,$y]} & 4 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x2,$y]} & 2 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x2,$y]} & 1 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    fi
    echo -ne "\e[0m"
    echo -ne "\e[${term[0]};0H[F]orward, [B]ackward, turn [L]eft, turn [R]ight or [Q]uit?"
    read -n 1 input
done

echo

Please keep in mind that this is pretty much the first thing I did with bash that was more than just piping a few commands together. It would probably be reducable by quite a lot if I didn't hardcode all the walls, but it seemed easier. It's got no consistency whatsoever. The byte format for each square is picked in a horrible way. But it works.
I even added support for movement through the arrow keys :)
These are some screenshots for the sample input ( Note that my map starts at (0|0) ):

Apart from the fourth one they all look like the sample ones as well (see my comment on the OP).
These screenshots were taken on urxvt v9.15 with 256 color support, it probably would look quite crap on a 88 color terminal, and terminals without unicode support don't work at all. The font I used was Source Code Pro by Adobe.

Haha, in bash, and in color too!  Nice.  You were totally right about that wall, apparently I had at some point "fixed it" in my program.  So I un-fixed it. :-)  Thanks for the catch!

Here's my version, in Python 3. It's something like 3k characters and could get a bit smaller with a little effort (there's lots of white space that could be removed, to start with).
It currently uses +X/\ as its drawing characters, but it is set up to draw with Unicode characters if you have a fixed width font that will render them properly. It supports using separate tiles for the angled parts of the differently collored walls, though I'm not using that feature. It also lets you provide ceiling, floor and "distant" tiles, and you can use different ones for when the player is facing east or west vs north or south. Alas this never looked very good, so probably all of these should be blank (or something solid, like █).
Alas, on my Windows 7 system I had a horrible time trying to find a monospaced font with the full set of block characters (e.g. ▜ and ▟). Most of the ones I found could not be made available in the cmd console for some reason (perhaps because they're not perfectly monospaced?). If you think your console is more functional, try using the alternate character set that I've commented out near the top of the file, which doesn't look too bad even with just two colors. It has filled in ceilings and floors and mostly transparent walls.
The code:
from itertools import product as p
r=range
cs=r"+X//\\//\\      " #" ░▛▛▜▜▟▟▙▙██████"
shapes=[(1,[(x,y,0)for x,y in p(r(5),r(5,10))]),
        (0,[(x,y,0)for x,y in p(r(5,11),r(5,10))]),
        (1,[(x,y,0)for x,y in p(r(11,16),r(5,10))]),
        (1,[(4,4,4),(4,10,6)]+[(4,y,0)for y in r(5,10)]),
        (1,[(11,4,2),(11,10,8)]+[(11,y,0)for y in r(5,10)]),
        (0,[(x,y,0)for x,y in p(r(4),r(4,11))]),
        (1,[(x,y,0)for x,y in p(r(4,12),r(4,11))]),
        (0,[(x,y,0)for x,y in p(r(12,16),r(4,11))]),
        (0,[(1,1,4),(2,2,4),(3,3,4),(1,13,6),(2,12,6),(3,11,6)]+
           [(x,y,0)for x,y in p(r(1,4),r(2,14)) if x<y<14-x]),
        (0,[(14,1,2),(13,2,2),(12,3,2),(14,13,8),(13,12,8),(12,11,8)]+
           [(x,y,0)for x,y in p(r(12,15),r(2,14)) if 15-x<y<x-1]),
        (1,[(0,y,0) for y in r(1,14)]),
        (0,[(x,y,0) for x,y in p(r(1,15),r(1,14))]),
        (1,[(15,y,0) for y in r(1,14)]),
        (1,[(0,0,4),(0,14,6)]+[(0,y,0)for y in r(1,14)]),
        (1,[(15,0,2),(15,14,8)]+[(15,y,0) for y in r(1,14)])]
def rr(s):
    for r in s:print("".join(r))
def dw(s,a,p,d):
    for i,r in enumerate(s):r[:]=cs[10+i//5*2+d%2]*16
    for w,(pl,sh) in zip(a,shapes):
        if w:
            for x,y,c in sh:
                s[y][x]=cs[c+(p+d+pl)%2]
dx=[1,0,-1,0]
def ga(x,y,d,m):
    fx=dx[d];fy=lx=dx[d-1];ly=dx[d-2]
    return [m[y+2*fy+ly][x+2*fx+lx][d],m[y+2*fy][x+2*fx][d],
            m[y+2*fy-ly][x+2*fx-lx][d],m[y+2*fy][x+2*fx][d-1],
            m[y+2*fy][x+2*fx][d-3],m[y+fy+ly][x+fx+lx][d],
            m[y+fy][x+fx][d],m[y+fy-ly][x+fx-lx][d],
            m[y+fy][x+fx][d-1],m[y+fy][x+fx][d-3],
            m[y+ly][x+lx][d],m[y][x][d],
            m[y-ly][x-lx][d],m[y][x][d-1],m[y][x][d-3]]
def rd():
    l=input();
    while l!="":
        if "\n" in l:yield from l.split("\n")
        else:yield l
        l=input()
def rm():
    m=[[[d in s for d in"ESWN"]for s in r.strip().split()]+[[1]*4]*2
       for r in rd()]
    return m+[[[1]*4 for _ in m[0]]]*2
def cl():print("\n"*30)
def gl():
    print("Enter map, followed by a blank line.")
    x=y=0;d=3;m=rm();mv="";s=[[""]*16 for _ in r(15)]
    while True:
        cl();dw(s,ga(x,y,d,m),x+y,d);rr(s)
        print("X:",x+1,"Y:",y+1,"Facing:","ESWN"[d])
        if mv:print("Last move:",mv)
        mv=input("[FBLRQ]? ").upper()
        if mv=="F":
            if not m[y][x][d]:x+=dx[d];y+=dx[d-1]
            else:mv+=" (Blocked)"
        elif mv=="B":
            if not m[y][x][d-2]:x+=dx[d-2];y+=dx[d-3]
            else:mv+=" (Blocked)"
        elif mv=="L":d=(d-1)%4
        elif mv=="R":d=(d+1)%4
        elif mv=="Q":break
        else:mv="I didn't understand %r."%mv
gl()

The character set is specified near the top of the file. The order of the characters are:

even parity wall
odd parity wall
even parity top right wall angle (e.g. / with a wall below it)
odd parity top right wall angle
even parity top left wall angle
odd parity top left wall angle
even parity bottom right wall angle
odd parity bottom right wall angle
even parity bottom left wall angle
odd parity bottom left wall angle
ceiling facing E/W
ceiling facing N/S
horizon facing E/W (the middle of the screen if there are no walls)
horizon facing N/S
floor facing E/W
floor facing N/S

There are 15 walls that might need to be rendered by the game, in a pattern like this (with V indicating the player's position and arc of view):
_ _ _
_|_|_
_|_|_
 |V|

The tiles used by the 15 walls are defined in the shapes list. It's a list of 2-tuples. The first value of the tuple indicates the "parity" of the wall, with 0 indicating that it should be drawn with the same characters as a wall directly in front of the character and a 1 indicating that it should be the alternate pattern (e.g. + vs X). The second value is a list of x,y,t tuples indicating the screen coordinates and tile index of one pixel (walls being rendered with odd parity will have 1 added to each of these indexes). The shapes are ordered by distance, so the first three represent the perpendicular walls two tiles ahead of the character, followed by the two parallel walls two tiles ahead, and so on.
The functions are:

rr: "render" the screen (by printing the tiles in the screen buffer).
dw: "draw walls" to a provided screen buffer. This uses the painters algorithm, so the most distant walls are drawn first and may get covered up by closer ones.
ga: "get area" returns a list of boolean values indicating which walls are opaque for a given map position and facing.
rd: "read", a generator that reads the map, yielding the lines. This is only needed because IDLE's console does weird stuff when you paste multi-line inputs rather than entering one line at a time.
rm: "read map", parses the map into a nested list of booleans, indexed by m[y][x][d] (with d=0 being East and d=1 being South). It also adds two rows and two columns of padding squares, to avoid index errors in the other code.
cl: "clear" the output (by writing enough newlines to scroll the old view off the top of the most consoles).
gl: "game loop", where the input is gathered and the above stuff gets called.

A few "screenshots":
The starting position:
\
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
/
X: 1 Y: 1 Facing: N
[FBLRQ]?

Looking along the north wall:
\
X\
X+\
X++\
X+++\
X+++X
X+++X
X+++X
X+++X
X+++X
X+++/
X++/
X+/
X/
/
X: 1 Y: 1 Facing: E
Last move: R
[FBLRQ]?

A couple of shots matching your examples (note, the blank first lines are being chopped off by Stack Overflow, they're in the program output):
X             /
X            /+
X           /++
X           +++
X           +++
X           +++
X           +++
X           +++
X           +++
X           +++
X           \++
X            \+
X             \

X: 3 Y: 2 Facing: S
Last move: F
[FBLRQ]?

And:
              /
             /X
            /XX
            XXX
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
            XXX
            \XX
             \X
              \

X: 3 Y: 2 Facing: E
Last move: L
[FBLRQ]?

Here's one of the stranger views in the supplied map, as the wall parallel to our view is the same color as the perpendicular wall sticking out behind it:
 \
 +\
 ++\
++++        ++++
++++        ++++
++++        ++++
++++        ++++
++++        ++++
++++        ++++
++++        ++++
 ++/
 +/
 /

X: 3 Y: 4 Facing: N
Last move: R
[FBLRQ]?

Here's what the area of last shot would look like from above:
_   _
 |
  V

Nice added analysis and diagrams!  Hm, those walls wind up being the same color on that last one in my implementation too.  Good point about the edge case.  I didn't think that would happen, but it sort of has to.  Guess it's like map coloring, and two colors isn't actually enough... :-/