[Question]
  [
### Monopoly Board
For this code-golf challenge we will be building the board game Monopoly.
### Rules:
* Take no input.
* Output a 11x11 board where each ASCII character forming the board is the first letter of each space of the U.S. version of the Monopoly board.
* The characters must be separated by spaces.
* `Go` should start in the bottom right.
The exact string to produce is
```
F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 
```
Note that from bottom right to bottom left the squares are as follows:
```
G --> Go
M --> Mediterranean Avenue
C --> Community Chest
B --> Baltic Avenue
I --> Income Tax
...
J --> Jail
```
**Edit**
Wow! you guys sure liked this one! :)
  
[Answer]
## [Retina](http://github.com/mbuettner/retina), 74 bytes
```
FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG
S_`(._.)
_
9$*
\B
1
```
The third to last and last lines should contain a single space.
[Try it online!](http://retina.tryitonline.net/#code=CkZLQ0lJQkFWV01HTl9QVF9OQ19DU19QUF9TVl9DU19QRV9MU19CSkNWQ09SSUJDTUcKU19gKC5fLikKXwo5JCoKXEIKIAoxCiA&input=)
### Explanation
```
FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG
```
This replaces the (empty) input with the string on the second line.
```
S_`(._.)
```
This is split stage, which splits the string around matches of the regex `(._.)` (that is, any three characters with a `_` in the middle). The reason we put the whole regex in a group is that split stages also return the results of capturing groups. E.g. splitting `abcd` around `bc` gives `[a, d]`, but splitting it around `b(c)` gives `[a, c, d]`. This way we get all the `._.` parts on separate lines but also the 11-character parts at the beginning and end. We use the `_` option to omit empty results between the individual `._.` matches. The result would be this:
```
FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG
```
Next we process the underscores:
```
_
9$*
```
This replaces each underscore with nine `1`s. The reason we use `1`s here instead of spaces immediately is that it makes it easier to insert the padding spaces next.
```
\B
```
Remember that there's a space on the second line. This inserts a space in every position that *isn't* a word boundary, i.e. everywhere except at the beginning and end of the lines.
```
1
```
And finally, we replace all those `1`s with spaces as well.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 44 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCcwqPEizlOybJU4oG0TeG7tcaHw7FkTeG7iuG4nirCtTdTyoLJk8Kixbt94bqhwqXEi3fDnuKAmeG4gzIz4bmjNOG7i8OYQXrigbbhuZkxRw&input=)
### Idea
If we remove every second column and transpose rows with columns, we get the following board.
```
FNTCSPVSESJ
K         C
C         V
I         C
I         O
B         R
A         I
V         B
W         C
M         M
GPNCPSCPLBG
```
Now, we can rotate each column one unit to the right, moving all remaining spaces to the right.
```
JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB
```
Then, we remove the remaining spaces and replace linefeeds with the letter **D**.
```
JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB
```
Now, we replace each letter with its 1-based index in the alphabet.
```
10  6 14 20  3 19 16 22 19  5 19  4  3 11  4 22  3  4  3  9  4 15  9  4 18
 2  4  9  1  4  2 22  4  3 23  4 13 13  4  7  7 16 14  3 16 19  3 16 12  2
```
Then, we convert this digit array from bijective base **23** to integer.
```
54580410997367796180315467139871590480817875551696951051609467717521
```
Now, we convert this integer to bijective base **250**.
```
  2 232  57  78 163  84 132  77 228 144  27 100  77 176 195
 42   9  55  83 167 155   1 210 125 211   4 232 119  20
```
Finally, we use these digits to index into [Jelly's code page](https://github.com/DennisMitchell/jelly/wiki/Code-page).
```
£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ
```
This is the encoded data we'll include in the program (**29 bytes**). To produce the desired output, we just have to reverse the steps above.
### Code
```
“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G  Main link. No arguments.
“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’               Convert the string from bijective
                                              base 250 (using the indices in
                                              Jelly's code page) to integer.
                               ḃ23            Convert that integer to bijective
                                              base 23.
                                  ṣ4          Split the resulting array at
                                              occurrences of 4.
                                    ịØA       Replace the remaining digits in the
                                              resulting 2D array with the
                                              corresponding uppercase letters.
                                       z⁶     Zip/transpose rows and columns,
                                              padding shorter rows with spaces.
                                         ṙ1   Rotate the rows one unit down.
                                           G  Grid; join rows by spaces, columns
                                              by linefeeds.
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~48~~ 47 bytes
Thanks to *Emigna* for saving a byte!
```
•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»
```
**Explanation:**
First some compression. `•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•` is a compressed version of the following number:
```
120860198958186421497710412212513392855208073968557051584380118734764403017
```
After that, this is converted to **base 33**, which results into the following string:
```
FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG
```
The zeroes are replaced by **9 spaces**, using the following code `¾9ð×:`. After that, we `S`plit the string into characters and slice them into pieces of **11** elements (done with `11ô`). We get the following 2-dimensional array:
```
[['F', 'K', 'C', 'I', 'I', 'B', 'A', 'V', 'W', 'M', 'G'], 
 ['N', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['T', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'N'], 
 ['C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'S'], 
 ['V', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'L'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B'], 
 ['J', 'C', 'V', 'C', 'O', 'R', 'I', 'B', 'C', 'M', 'G']]
```
We *gridify* this array with `»` and output it implicitly.
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=4oCiKEvCtzvigJzigKbCrMOIwqZ6IjnDpHXFuMOpO1TDnsOuw5Vz4oChw5PDkFY5WMOSdFw84oCiMzNCwr45w7DDlzpTMTHDtMK7&input=)
[Answer]
## Python 2, 89 bytes
```
l='%s '*11+'\n'
print(l+'%s%20s\n'*9+l)%tuple("FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG")
```
Creates the template 
```
? ? ? ? ? ? ? ? ? ? ? 
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
? ? ? ? ? ? ? ? ? ? ? 
```
to substitute in letters via string formatting. The template uses two types of lines:
* The outer line `l` of 11 copies of letter-plus-space, then a newline. It's also used for the first and last line. It has a trailing space.
* The inner line of a character, then a character preceded by 19 characters of padding spaces, then a newline. It's copied 9 times for the center lines.
Python 3.5 can save a byte with tuple unpacking `(*'...',)`.
[Answer]
## PowerShell v2+, ~~131~~ ~~123~~ ~~114~~ ~~110~~ 99 bytes
```
'F K C I I B A V W M G
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
J C V C O R I B C M G'-replace0,(" "*19)
```
This is just a literal string with newlines placed on the pipeline, with a little `-replace` at the end to turn the `0` into `19` spaces. The first and last lines are just verbatim. With only 10 spaces and little repetition otherwise, there wasn't enough room to golf them. This string is left on the pipeline, and output via implicit `Write-Output` happens at program completion.
```
PS C:\Tools\Scripts\golfing> .\take-a-ride-on-reading.ps1
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
```
[Answer]
# Javascript ES6 [REPL](http://meta.codegolf.stackexchange.com/questions/7842/when-is-code-that-requires-a-repl-acceptable/7844#7844), ~~105~~ ~~102~~ 101 bytes
Not much interesting happening here.
Paste in the console to see the desired results
Saved 3 bytes thanks to @Arnauld  
Saved 1 more byte thanks to @Neil
```
`FKCIIBAVWMG
N P
T N
C C
S P
P S
V C
S P
E L
S B
JCVCORIBCMG`.replace(/.( ?)/g,`$& `+`$1`.repeat(17))
```
```
a.innerHTML = 
`FKCIIBAVWMG
N P
T N
C C
S P
P S
V C
S P
E L
S B
JCVCORIBCMG`.replace(/.( ?)/g,`$& `+`$1`.repeat(17))
```
```
<pre id=a>
```
[Answer]
# [///](http://esolangs.org/wiki////), ~~100~~ 98 bytes
```
/s/    //p/ssss   //q/pC
SpP
//!/ C /F K!I I B A V W M G 
NpP
TpN
CqPpS
VqEpL
SpB
J!V!O R I B!M G 
```
[Try it online!](//slashes.tryitonline.net#code=L3MvICAgIC8vcC9zc3NzICAgLy9xL3BDClNwUAovLyEvIEMgL0YgSyFJIEkgQiBBIFYgVyBNIEcgCk5wUApUcE4KQ3FQcFMKVnFFcEwKU3BCCkohViFPIFIgSSBCIU0gRyA)
For some mysterious reason, there seem to be trailing spaces after the `G`s. Without them, my code would have been 96 bytes.
Thanks to [42545 (ETHproductions)](/users/42545) and [56258 (daHugLenny)](/users/56258) for reducing 1 byte each!
[Answer]
# [Turtlèd](https://github.com/Destructible-Watermelon/Turtl-d), 72 bytes
```
"K C I I B A V W M G">"GPNCPSCPLBG">"G M C B I R O C V C J">"JSESVPSCTNF
```
[Try it online](http://turtled.tryitonline.net/#code=IksgQyBJIEkgQiBBIFYgVyBNIEciPiJHUE5DUFNDUExCRyI-IkcgTSBDIEIgSSBSIE8gQyBWIEMgSiI-IkpTRVNWUFNDVE5G&input=)
`>` rotates turtle, `"foo"` writes strings on grid. last `"` was elidable
[Answer]
# [V](http://github.com/DJMcMayhem/V), ~~75, 62~~, 59 bytes
```
iFKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG-ò9á lli
òÍ./& 
```
[Try it online!](http://v.tryitonline.net/#code=aUZLQ0lJQkFWV01HCk5QVE5DQ1NQUFNWQ1NQRUxTQgpKQ1ZDT1JJQkNNRxstw7I5w6EgbGxpCsOyw40uLyYg&input=)
Since this codel contains non-ASCII characters, here is a hexdump:
```
0000000: 6946 4b43 4949 4241 5657 4d47 0a4e 5054  iFKCIIBAVWMG.NPT
0000010: 4e43 4353 5050 5356 4353 5045 4c53 420a  NCCSPPSVCSPELSB.
0000020: 4a43 5643 4f52 4942 434d 471b 2df2 39e1  JCVCORIBCMG.-.9.
0000030: 206c 6c69 0af2 cd2e 2f26 20               lli..../& 
```
Explanation. First, we enter the following text:
```
FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG
```
Then, we `<esc>` back to normal mode. At this point, the cursor is on the third line on the last `G`. Conveniently, there is a command to put us on the first column of the line right above the cursor. That command is `-`. Then, once we end up on the second line (on the `N`), we run the following loop:
```
ò9á lli
ò
```
Explanation:
```
ò           " Recursively:
 9á         "   Append 9 spaces
    ll      "   Move to the right twice. This will fail on the last time because there isn't a space to move into
      i     "   Enter a newline
ò           " End
```
Now, the buffer looks like this:
```
FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG
```
Now we use a compressed regex to replace each character with that character and a space. That's the `Í./&` part. This translates to the following vim regex:
```
:%s/./& /g
```
Which means:
```
:%          " On any line
  s/        " Substitute
    ./      " Any character with
      & /   " That same character and a space
         g  " Allow for multiple substitutions on the same line
```
[Answer]
# R, 149 146 bytes
Not so impressive but also not sure how this would be golfed. Exploiting `paste` somehow is my first guess. Compare to raw text of 241 bytes.
```
x=strsplit("NTCSPVSESPNCPSCPLB","")[[1]];cat("F K C I I B A V W M G\n");for(i in 1:9)cat(x[i],rep("",18),x[i+9],"\n");cat("J C V C O R I B C M G")
```
[R-fiddle](http://www.r-fiddle.org/#/fiddle?id=7yy7jpqu&version=2)
[Answer]
## Python 2, 108 bytes
Slightly different than the other python answer, using no replaces, only string joins.
```
print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))
```
[Answer]
## Perl, 90 bytes
Pretty boring approach, can't think of a better way to reduce... Requires `-E` at no extra cost. Outputs an additional space at the end of every line. -2 bytes thanks to [@Dada](https://codegolf.stackexchange.com/users/55508/dada)!
```
say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr
```
### Usage
```
perl -E 'say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'
```
[Answer]
# Jolf, 72 bytes
```
Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"wΖhζ♣
```
Replace all `♣` with `\x05`, or [try it here!](http://conorobrien-foxx.github.io/Jolf/#code=zpYwz4EsYWh0aHQiMTExIicuZD89SAVRBSsuIkZLQ0lJQkFWV01HTlBUTkNDU1BQU1ZDU1BFTFNCSkNWQ09SSUJDTUcid86WaM62BQ)
```
Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."..."wΖhζ♣
Ζ0                                   ζ = 0
   ,ahtht"111"                       a box of width&height 11, with borders "1"
  ρ           '.d                    replace each char in that string with...
                 ?=H♣                 is it a space?
                     Q♣                if so, return two spaces.
                                      otherwise
                        ."..."         get the Nth member of this string
                              wΖhζ      where N = (++ζ) - 1
                       +          ♣      and add a space to the end
```
This gives the desired string.
[Answer]
# Java 7, ~~177~~ ~~165~~ ~~142~~ 131 bytes
```
String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM".replace("_","         ").replace(""," ");}
```
-15 bytes thanks to *@BassdropCumberwubwubwub*.  
-11 bytes thanks to *@Numberknot*.
**Ungolfed & test code:**
[Try it here.](https://ideone.com/SkdsIK)
```
class M{
  static String c(){
    return "FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM"
      .replace("_","         ").replace(""," ");
  }
  public static void main(String[] a){
    System.out.print(c());
  }
}
```
**Output:**
```
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
```
[Answer]
# Befunge, 120 bytes
```
<v"FKCIIBAVWMG NPTNCCSPPSVCSPELSB $JCVCORIBCMG "
:<,*48 ,_v#-*48<
>1-:#v_\,>$52*, :48*-!#v_,54*
^,*84<         ^p19*88$<
```
First line has the string to be printed in reverse (it looks like it's not, but the code is going backwards on that line). Second line prints the top and bottom rows. Third line and the left side of the fourth line print the middle rows, and the small chunk on the bottom right does an interesting thing: it moves the cursor back to the second row to print out the last line, but after finishing it, it quits.
As you can see on the first line, the strings are separated by spaces to distinguish between the first, middle, and last rows. The spaces can be anything else, and if I used ASCII characters 0-9, I could've easily saved 4 bytes. The $ you see is just a garbage character that has to be there and could be replaced with anything but a space.
[Answer]
# J, ~~77~~ 73 bytes
```
' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5
```
Note that 43 bytes, over half the total, are used just for the string `' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'`.
## Explanation
First, make a list
```
   |i:5
5 4 3 2 1 0 1 2 3 4 5
   5-|i:5
0 1 2 3 4 5 4 3 2 1 0
```
Then make its times table
```
   */~5-|i:5
0 0  0  0  0  0  0  0  0 0 0
0 1  2  3  4  5  4  3  2 1 0
0 2  4  6  8 10  8  6  4 2 0
0 3  6  9 12 15 12  9  6 3 0
0 4  8 12 16 20 16 12  8 4 0
0 5 10 15 20 25 20 15 10 5 0
0 4  8 12 16 20 16 12  8 4 0
0 3  6  9 12 15 12  9  6 3 0
0 2  4  6  8 10  8  6  4 2 0
0 1  2  3  4  5  4  3  2 1 0
0 0  0  0  0  0  0  0  0 0 0
```
Then test for equality with zero
```
   0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 1
```
Flatten it, find the cumulative sums, and multiply elementwise
```
   ,0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1
   +/\,0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 12 12 12 12 12 12 12 12 12 13 14 14 14 14 14 14 14 14 14 14 15 16 16 16 16 16 16 16 16 16 16 17 18 18 18 18 18 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 23 24 24 24 24 24 24 24 24 24 24 25 26 26 26 26 26 26 26 26 26 26 27 28 28 28 28 28 28 28 28 28 28 29 30 31 32 33 34 35 36 37 38 39 40
   (*+/\),0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 0 0 0 0 0 0 0 0 0 13 14 0 0 0 0 0 0 0 0 0 15 16 0 0 0 0 0 0 0 0 0 17 18 0 0 0 0 0 0 0 0 0 19 20 0 0 0 0 0 0 0 0 0 21 22 0 0 0 0 0 0 0 0 0 23 24 0 0 0 0 0 0 0 0 0 25 26 0 0 0 0 0 0 0 0 0 27 28 0 0 0 0 0 0 0 0 0 29 30 31 32 33 34 35 36 37 38 39 40
```
Then join with zeros, split it into sublists of length 22, drop the head of each sublist, and use the values as indices in the string `' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'`
```
   ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
```
[Answer]
# [Actually](http://github.com/Mego/Seriously), 74 bytes
```
"%s"9⌐α' j;"%s%20s"9α'
j(k'
j"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%
```
[Try it online!](http://actually.tryitonline.net/#code=IiVzIjnijJDOsScgajsiJXMlMjBzIjnOsScKaihrJwpqIkZLQ0lJQkFWV01HTlBUTkNDU1BQU1ZDU1BFTFNCSkNWQ09SSUJDTUciI0Al&input=)
This program works off of the same basic principle as xnor's [Python 2 answer](https://codegolf.stackexchange.com/a/96797/45941).
Explanation (newlines replaced with `\n` for clarity):
```
"%s"9⌐α' j                                       ' '.join(["%s"]*11)
;                                                duplicate
"%s%20s"9α'\nj                                   '\n'.join(["%s%20s"]*9)
(                                                move bottom of stack to top
k'\nj                                            '\n'.join(stack)
"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%                    %tuple(longstring)
```
[Answer]
# C#6, ~~192~~ 190 Bytes
```
using System.Linq;
string f()=>string.Join("\n","FKCIIBAVWMG~N!P~T!N~C!C~S!P~P!S~V!C~S!P~E!L~S!B~JCVCORIBCMG".Replace("!","         ").Split('~').Select(s=>string.Join(" ",s.Select(c=>c))));
```
Without trailing space; without trailing newline.
A straightforward solution. Start with the literal string. `Replace` `!` by 9 spaces. Then `Split` into 11 strings by `~`, and further to `char`s (inner `Select`). Append a space to each character, then `Join` back to 11 strings. Finally another `Join` by newline character.
[Answer]
# Ruby, 92
Full program, prints to stdout using `$> <<`
```
40.times{|i|$><<"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"[i]+(i%29>9?[$/,' '*19][i%2]:' ')}
```
There are 40 total letters to plot. Letters 10 to 28 alternate between being followed by a newline or `' '*19`. The earlier and later letters are separated by single spaces.
[Answer]
# Perl, ~~115~~ 112 bytes
```
print FKCIIBAVWMG=~s/(.)/\1 /gr.NPTNCCSPPSVCSPELSB=~s/(.)(.)/"\n$1".$"x19 .$2/gre."\nJCVCORIBCMG"=~s/(.)/\1 /gr;
```
Produces the following output:
```
F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 
```
The first and last rows of output have a trailing space.
The code makes use of regex replacements and the fact that if objects are not defined, they are interpreted as strings (e.g. FKCIIBAVWMG is treated as "FKCIIBAVWMG". Couldn't take the quotes out of the last row because of the preceeding newline, which I couldn't finagle anywhere else.
Edit 1: Saved 3 bytes by replacing `" "` with `$"`, removing the outer parentheses and inserting a space after print, and removing the parentheses around `$"x19` and adding a space afterwards (so the `.` wouldn't be interpreted as a decimal)
[Answer]
# [Charcoal](http://github.com/somebody1234/Charcoal), 66 bytes
```
Ｂ²¹¦¹¹F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN
```
[Try it online!](http://charcoal.tryitonline.net/#code=77yiwrLCucKmwrnCuUYgSyBDIEkgSSBCIEEgViBXIE0gR1BOQ1BTQ1BMQkcgTSBDIEIgSSBSIE8gQyBWIEMgSlNFU1ZQU0NUTg&input=&args=LW8+RiBLIEMgSSBJIEIgQSBWIFcgTSBHCk4gICAgICAgICAgICAgICAgICAgUApUICAgICAgICAgICAgICAgICAgIE4KQyAgICAgICAgICAgICAgICAgICBDClMgICAgICAgICAgICAgICAgICAgUApQICAgICAgICAgICAgICAgICAgIFMKViAgICAgICAgICAgICAgICAgICBDClMgICAgICAgICAgICAgICAgICAgUApFICAgICAgICAgICAgICAgICAgIEwKUyAgICAgICAgICAgICAgICAgICBCCkogQyBWIEMgTyBSIEkgQiBDIE0gRw)
`Box(21, 11, 'F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN')`.
[Noncompeting, 36 bytes](http://charcoal.tryitonline.net/#code=Qm94KDExLCAxMSwgJ0ZLQ0lJQkFWV01HUE5DUFNDUExCR01DQklST0NWQ0pTRVNWUFNDVE4nKTsgRXh0ZW5kKDEpOw&input=&args=LXNs+LXY+LW8+RiBLIEMgSSBJIEIgQSBWIFcgTSBHCk4gICAgICAgICAgICAgICAgICAgUApUICAgICAgICAgICAgICAgICAgIE4KQyAgICAgICAgICAgICAgICAgICBDClMgICAgICAgICAgICAgICAgICAgUApQICAgICAgICAgICAgICAgICAgIFMKViAgICAgICAgICAgICAgICAgICBDClMgICAgICAgICAgICAgICAgICAgUApFICAgICAgICAgICAgICAgICAgIEwKUyAgICAgICAgICAgICAgICAgICBCCkogQyBWIEMgTyBSIEkgQiBDIE0gRw)
[Answer]
# Python 2, 116 Bytes
Pretty straightforward, for whatever reason even though string replacing is so verbose it was the best thing I could come up with. Possibly using `re` might be shorter.
```
print' '.join('FKCIIBAVWMG!N@P!T@N!C@C!S@P!P@S!V@C!S@P!E@L!S@B!JCVCORIBCMG').replace(' ! ','\n').replace('@',' '*17)
```
[Answer]
## Batch, 171 bytes
```
@echo F K C I I B A V W M G
@set s=NPTNCCSPPSVCSPELSB
:l
@echo %s:~0,1%                   %s:~1,1%
@set s=%s:~2%
@if not "%s%"=="" goto l
@echo J C V C O R I B C M G
```
[Answer]
# GameMaker Language, 148 bytes
I know it's pretty basic, but I don't think this can be beat in GML...
```
a="                   "return"F K C I I B A V W M G #N"+a+"P#T"+a+"N#C"+a+"C#S"+a+"P#P"+a+"S#V"+a+"C#S"+a+"P#E"+a+"L#S"+a+"B#J C V C O R I B C M G "
```
[Answer]
## [Pip](http://github.com/dloscutoff/pip), 64 bytes
63 bytes of code, +1 for `-S` flag.
```
.*"NTCSPVSES".sX19.^"PNCPSCPLB"PE^"FKCIIBAVWMG"AE^"JCVCORIBCMG"
```
[Try it online!](http://pip.tryitonline.net/#code=LioiTlRDU1BWU0VTIi5zWDE5Ll4iUE5DUFNDUExCIlBFXiJGS0NJSUJBVldNRyJBRV4iSkNWQ09SSUJDTUci&input=&args=LVM)
### Explanation
Operators used:
* `.` (binary) concatenates (operates item-wise on lists).
* `X` (binary) string-multiplies. (`s` is a variable preinitialized to `" "`.)
* `^` (unary) splits a string into a list of characters.
* `.*` is another way to split a string into characters. It consists of unary `.`, which is a no-op on strings, paired with the `*` meta-operator, which maps a unary operator to each item in its (iterable) operand. Using `.*"..."` lets us save a byte over `(^"...")`--the parentheses would be required because `.` is higher precedence than `^`.
* `PE` prepends an element to a list. `AE` appends an element to a list.
With that background, here's the code step by step:
```
.*"NTCSPVSES"
['N 'T 'C 'S 'P 'V 'S 'E 'S]
.sX19
["N                   "
 "T                   "
 "C                   "
 "S                   "
 "P                   "
 "V                   "
 "S                   "
 "E                   "
 "S                   "]
.^"PNCPSCPLB"
["N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]
PE^"FKCIIBAVWMG"
[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]
AE^"JCVCORIBCMG"
[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"
 ['J 'C 'V 'C 'O 'R 'I 'B 'C 'M 'G]]
```
When this result is autoprinted, the `-S` flag joins the sublists on spaces and the main list on newlines, giving the desired output.
[Answer]
# C, ~~171~~ 156 Bytes
```
i,j;char*b="FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG ";f(){for(i=1;*b;j=i%21==0?putchar(*b++),puts(""),i++,*b++:i<21||i>210?i&1?*b++:32:32,putchar(j),i++);}
```
Outputs a trailing newline character as well... Could probably be golfed down a bit more.
[Answer]
# Perl 5, 92 86 bytes
* saved 6 bytes thanks to Dada
```
$a="%s "x11;printf"$a
"."%s%20s
"x9 .$a,FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG=~/./g
```
Uses `sprintf`, padding and the string repeat operator `x`.
[Answer]
## Haskell, ~~128~~ ~~125~~ 114 bytes
```
mapM(putStrLn.((:" ")=<<))$"FKCIIBAVWMG":zipWith(\a b->a:"         "++[b])"NTCSPVSES""PNCPSCPLB"++["JCVCORIBCMG"]
```
[Try it here](https://ideone.com/aEoOU8)
* `((:" ")=<<)` is `concatMap (\a -> [a,' '])` - pads by adding a space behind every letter in its input
[Answer]
# Powershell, 95 bytes
*Inspired by @AdmBorkBork's [answer](https://codegolf.stackexchange.com/a/96733/80745).*
```
'FKCIIBAVWMG
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
JCVCORIBCMG'-replace0,(' '*9)-replace'.','$0 '
```
## Explanation
The first replacing operator makes the rectangle `11x11`.
```
FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG
```
The second replacing operator inserts a space after each character. The result has trailing spaces.
```
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G
```
]