text:
Take a ride on the Reading, If you pass Go, collect $200
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! :)

I don't mean to be a stickler but... how does one pass Go while advancing to Boardwalk?

If you are on boardwalk :)

Which you can't get a chance card if you are on boardwalk :(

I failed you all

Is the trailing space on the bottom-right needed?

There's also one on the first row. I assumed these were editing mistakes.

@jacksonecac, I have an idea to extend this puzzle in another question, your input would be great!

Are trailing spaces allowed?

@jacksonecac Of course you can get a chance card on boardwalk. If you don't cheat at monopoly, you're not playing monopoly right :D

That's why I am always the banker

@Sp3000 While we are being sticklers, how does one NOT pass go while advancing to Reading?

This must be what American monopoly looks like. Huh, weird.

@jacksonecac No, this is what Monopoly looks like ;)

@ArtOfCode It is identical. except for those random images on the properties.

@jacksonecac Property names. We get Fleet Street, Old Kent Road, Mayfair, etc, over here.

@Kevin I think this one is legit.. If you are on the community chest between Go and Reading railroad, you could get that card. (If that card is indeed a community chest and not a chance card)

http://thesaltcollective.org/wp-content/uploads/2014/04/Chance-Take-a-Ride-on-the-Reading-604x270.png
Failed again! I am the WORST! I suppose this stickler is for Hasbro this time, passing the buck.

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!
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 1s. The reason we use 1s 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 1s with spaces as well.

Nice Job! That was fast!

+1 for (._.).

^ was just about to say that ahha

Jelly, 44 bytes
“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G

Try it online!
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.
£ċ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.

Thanks for the detailed explanation. It's always interesting to see the process behind answers to code golf questions. :)

Code Golf - where it's perfectly normal to see a number in base 250 and base 23.

Nice compression technique. Why is transposing necessary?

@ETHproductions Jelly doesn't have a padding atom, so I can either manually pad all rows with spaces to the same length or use the dyadic zip (z) with a filler.

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 Split 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!

Compressing with 0 instead of D saves a byte •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»

@Emigna Ah, that's clever! Thanks :).

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 (*'...',).

Switching to Python 3.5 should save a byte.

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

Javascript ES6 REPL, 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>

I don't think REPL is allowed.

@NoOneIsHere http://meta.codegolf.stackexchange.com/a/7844/8478

I managed to shave off another byte. Replace the 1s with spaces and use this regexp instead: .replace(/.( ?)/g,\$& `+`$1`.repeat(17))`

A different way to shave off another byte is to replace the 1s with spaces and use this function instead: a=>a-1?a.repeat(18):a+' '

@Neil thanks, love your approach!

///, 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!
For some mysterious reason, there seem to be trailing spaces after the Gs. Without them, my code would have been 96 bytes.
Thanks to 42545 (ETHproductions) and 56258 (daHugLenny) for reducing 1 byte each!

@ETHproductions Wrong link maybe? I can't save any byte like that.

Isn't this 98 bytes if you remove the space after the Gs on the first and last line?

@Emigna Whole discussion about the extra spaces.

@Emigna I know, but the exact output contains them, so I won't remove them.

My bad, try this.

You can save 1 byte by adding a C replacement

@ETHproductions Updated my code.

@daHugLenny Updated my code.

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
> rotates turtle, "foo" writes strings on grid. last " was elidable

V, 75, 62, 59 bytes
iFKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG-ò9á lli
òÍ./&

Try it online!
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

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

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!
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'

2 bytes shorter (but basically the same code as you) : perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'. (Replace \n by literal newlines to get to 90).

@Dada Ahhh, much nicer! Thanks!

"much nice" would have been finding a 40 bytes solution, but thanks :D

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']))

I knew zip was the way forward! Had pretty much the same solution down to 118 earlier and was going to golf it this evening. I was missing the map. Guess you beat me to it. +1

Jolf, 72 bytes
Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"wΖhζ♣

Replace all ♣ with \x05, or try it here!
Ζ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.

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.
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

String c(){String s="                 ";return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace(""," ").replace("_",s);} for 150 (note that stackexchange removes excessive spaces)

@BassdropCumberwubwubwub Umm.. this outputs only 3 spaces between the 'vertical walls', instead of 19.. Here is an ideone of your code.

Hence my note, there should be more spaces in s but stackexchange removed them. Here's the ideone, now even at 142 bytes

@BassdropCumberwubwubwub Ah ok. Didn't knew you ment between the s="  ". In that case it's indeed shorter. And.replace(""," ").replace("_",s); can be .replace("_",s).replace(""," "); instead for an additional -8 bytes

String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace("_","         ").replace(""," ");}(131 bytes)

You could use some \t instead of space to the replace, two seams to do it perfectly ;)

@AxelH Hmm, the \t spacing is dependent on the OS settings if I'm not mistaken, though. Here in this ideone I had to us 5x \t for the same output. :(

it is suppose to move to the next 8-column but this is maybe OS depends...

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)

You can still save a few bytes : s/(.)/\1 / can be replaced by s/./$& /. Drop the final semicolon. Use say instead of print (for that you'll need to either add -M5.010 or use -E instead of -e, but both are free (see here)). Literal newlines instead of \n.

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.

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.

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

The best I could get using generic string compression is 90 bytes: (' ',@,.~]);._1';FKCIIBAVWMG;N_P;T_N;C_C;S_P;P_S;V_C;S_P;E_L;S_B;JCVCORIBCMG'rplc'_';9#' '

@ConorO'Brien Yeah, it's hard to golf string compression in J when other languages have dictionaries and builtin compression.

@ConorO'Brien I tried golfing your idea a bit more and got it to 76 bytes _11,@,.&' '\'FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG'rplc'_';9#' '

Actually, 74 bytes
"%s"9⌐α' j;"%s%20s"9α'
j(k'
j"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%

Try it online!
This program works off of the same basic principle as xnor's Python 2 answer.
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)

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!
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

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 chars (inner Select). Append a space to each character, then Join back to 11 strings. Finally another Join by newline character.

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)

print'F K C I I B A V W M G\nN@P\nT@N\nC@C\nS@P\nP@S\nV@C\nS@P\nE@L\nS@B\nJ C V C O R I B C M G'.replace('@',' '*19) is also 116 bytes without using join if you want to be more straight-forward.  Alternately, 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) is 115 bytes if trailing whitespace is allowed. (The argument to replace is '! ', instead of ' ! '.)

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

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.

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 "

Thanks @NiCkNewman, but I've actually used it before on this site quite a few times - https://codegolf.stackexchange.com/search?q=GameMaker

I see, I was thinking of doing some in GDScript, language from the Godot game engine. But, not sure if it would be ok :)

Ah, if only the board was bigger; string_repeat(" ",19) is the same length as "                   ".

@NiCkNewman That should be okay, tell me if you write some :)

@lastresort I know... GML allows tricks with smashing things together but its commands are so verbose...

Pip, 64 bytes
63 bytes of code, +1 for -S flag.
.*"NTCSPVSES".sX19.^"PNCPSCPLB"PE^"FKCIIBAVWMG"AE^"JCVCORIBCMG"

Try it online!
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.

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.

Nice solution. You can save a few bytes though : replaces \n with literal newlines, you don't need spaces between the x operator and the number that follows, and finally replace split//,xxx with xxx=~/./g.

Haskell, 128 125 114 bytes
mapM(putStrLn.((:" ")=<<))$"FKCIIBAVWMG":zipWith(\a b->a:"         "++[b])"NTCSPVSES""PNCPSCPLB"++["JCVCORIBCMG"]

Try it here

((:" ")=<<) is concatMap (\a -> [a,' ']) - pads by adding a space behind every letter in its input

Powershell, 95 bytes
Inspired by @AdmBorkBork's answer.
'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

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


text:
Compute the Eulerian number
The Eulerian number A(n, m) is the number of permutations of [1, 2, ..., n] in which exactly m elements are greater than the previous element. These are also called rises. For example, if n = 3, there are 3! = 6 permutations of [1, 2, 3]
1 2 3
 < <  2 elements are greater than the previous

1 3 2
 < >  1 ...

2 1 3
 > <  1 ...

2 3 1
 < >  1 ...

3 1 2
 > <  1 ...

3 2 1
 > >  0 ...

So the outputs for A(3, m) for m in [0, 1, 2, 3] will be
A(3, 0) = 1
A(3, 1) = 4
A(3, 2) = 1
A(3, 3) = 0

Also, this is the OEIS sequence A173018.
Rules

This is code-golf so the shortest code wins.
The input n will be a nonnegative integer and m will be a integer in the range [0, 1, ..., n].

Test Cases
n   m   A(n, m)
0   0   1
1   0   1
1   1   0
2   0   1
2   1   1
2   2   0
3   0   1
3   1   4
3   2   1
3   3   0
4   0   1
4   1   11
4   2   11
4   3   1
4   4   0
5   1   26
7   4   1191
9   5   88234
10  5   1310354
10  7   47840
10  10  0
12  2   478271
15  6   311387598411
17  1   131054
20  16  1026509354985
42  42  0

Any limits on n, m?

There is no limit, but it's not required that your submission be able to completely execute a test case in a certain amount of time, only have the correct logic. Preferably, I'd like submissions to handle values up to 20, but I left it without a performance requirement to allow brute-force solutions that may only work up to n = 10.

Can the input have m >= n, n > 0?

Shouldn't, "m will be a integer in the range [0, 1, ..., n]" be "...[0, 1, ..., n-1]"?

@feersum Your solution can support any m if desired, but I only require that it be valid for 0 <= m <= n with 0 <= n.

I ask because you don't have any such example in your test cases (where m = n and the answer is 0).

@JonathanAllan That was my original definition but I changed it in meta to fit the OEIS sequence, but this was probably hard to observe since I didn't update the test cases to include m = n.

@feersum Thanks, it slipped my mind to add those test cases after I changed the definition in meta.

Jelly, 8 bytes
Œ!Z>2\Sċ

Try it online! (takes a while) or verify the smaller test cases.
How it works
Œ!Z>2\Sċ  Main link. Arguments: n, m

Œ!        Generate the matrix of all permutations of [1, ..., n].
  Z       Zip/transpose, placing the permutations in the columns.
   >2\    Compare columns pairwise with vectorizing greater-than.
          This generates a 1 in the column for each rise in that permutation.
      S   Compute the vectorizing sum of the columns, counting the number of rises.
       ċ  Count how many times m appears in the computed counts.

JavaScript (ES6), 50 46 45 bytes
f=(n,m,d=n-m)=>m?d&&f(--n,m)*++m+f(n,m-2)*d:1

Based on the recursive formula:
A(n, m) = (n - m)A(n - 1, m - 1) + (m + 1)A(n - 1, m)

Test cases

f=(n,m,d=n-m)=>m?d&&f(--n,m)*++m+f(n,m-2)*d:1

console.log(f( 0,  0));  // 1
console.log(f( 1,  0));  // 1
console.log(f( 1,  1));  // 0
console.log(f( 2,  0));  // 1
console.log(f( 2,  1));  // 1
console.log(f( 2,  2));  // 0
console.log(f( 3,  0));  // 1
console.log(f( 3,  1));  // 4
console.log(f( 3,  2));  // 1
console.log(f( 3,  3));  // 0
console.log(f( 4,  0));  // 1
console.log(f( 4,  1));  // 11
console.log(f( 4,  2));  // 11
console.log(f( 4,  3));  // 1
console.log(f( 4,  4));  // 0
console.log(f( 5,  1));  // 26
console.log(f( 7,  4));  // 1191
console.log(f( 9,  5));  // 88234
console.log(f(10,  5));  // 1310354
console.log(f(10,  7));  // 47840
console.log(f(10, 10));  // 0
console.log(f(12,  2));  // 478271
console.log(f(15,  6));  // 311387598411
console.log(f(17,  1));  // 131054
console.log(f(20, 16));  // 1026509354985
console.log(f(42, 42));  // 0

CJam (21 19 bytes - or 18 if argument order is free)
{\e!f{2ew::>1b=}1b}

This is an anonymous block (function) which takes n m on the stack. (If it's permitted to take m n on the stack then the \ can be saved). It computes all  permutations and filters, so the online test suite must be rather limited.
Thanks to Martin for pointing out an approximation to filter-with-parameter.
Dissection
{        e# Define a block. Stack: n m
  \      e#   Flip the stack to give m n
  e!f{   e#   Generate permutations of [0 .. n-1] and map with parameter m
    2ew  e#     Stack: m perm; generate the list of n-1 pairs of consecutive
         e#     elements of perm
    ::>  e#     Map each pair to 1 if it's a rise and 0 if it's a fall
    1b   e#     Count the falls
    =    e#     Map to 1 if there are m falls and 0 otherwise
  }
  1b     e#   Count the permutations with m falls
}

Note that the Eulerian numbers are symmetric: E(n, m) = E(n, n-m), so it's irrelevant whether you count falls or rises.
Efficiently: 32 bytes
{1a@{0\+_ee::*(;\W%ee::*W%.+}*=}

Online test suite.
This implements the recurrence on whole rows.
{          e# Define a block. Stack: n m
  1a@      e#   Push the row for n=0: [1]; and rotate n to top of stack
  {        e#   Repeat n times:
           e#     Stack: m previous-row
    0\+_   e#     Prepend a 0 to the row and duplicate
    ee::*  e#     Multiply each element by its index
           e#     This gives A[j] = j * E(i-1, j-1)
    (;     e#     Pop the first element, so that A[j] = (j+1) * E(i-1, j)
    \W%    e#     Get the other copy of the previous row and reverse it
    ee::*  e#     Multiply each element by its index
           e#     This gives B[j] = j * E(i-1, i-1-j)
    W%     e#     Reverse again, giving B[j] = (i-j) * E(i-1, j-1)
    .+     e#     Pointwise addition
  }*
  =        e#   Extract the element at index j
}

It's shorter to avoid the variable by using a map: {e!f{2ew::>1b=}1e=}. Or just for fun: {e!f{2ew::>+:-}0e=}

That was stupid, of course. The 1e= in the first solution can be 1b.

You are allowed to use your own argument order

MATL, 10 bytes
:Y@!d0>s=s

Try it online!
Explanation
Consider as an example inputs n=3, m=1. You can place a % symbol to comment out the code from that point onwards and thus see the intermediate results. For example, the link shows the stack after the first step.
:      % Input n implicitly. Push [1 2 ... n]
       % STACK: [1 2 ... n]
Y@     % Matrix of all permutations, one on each row
       % STACK: [1 2 3; 1 3 2; 2 1 3; 2 3 1; 3 1 2; 3 2 1]
!      % Transpose
       % STACK: [1 1 2 2 3 3; 2 3 1 3 1 2; 3 2 3 1 2 1]
d      % Consecutive differences along each column
       % STACK: [1 2 -1 1 -2 -1; 1 -1 2 -2 1 -1]
0>     % True for positive entries
       % STACK: [1 1 0 1 0 0; 1 0 1 0 1 0]
s      % Sum of each column
       % STACK: [2 1 1 1 1 0]
=      % Input m implicitly. Test each entry for equality with m
       % STACK: [0 1 1 1 1 0]
s      % Sum. Implicitly display
       % STACK: 4

Python, 55 56 bytes
a=lambda n,m:n>=m>0and(n-m)*a(n-1,m-1)-~m*a(n-1,m)or m<1

All tests at repl.it
Applies the recursive formula on OEIS.
Note that +(m+1)*a(n-1,m) is golfed to -~m*a(n-1,m).
(May return boolean values to represent 1 or 0. Returns True when n<0 and m<=0 or m<0.)

There are various other ways to handle the edge cases. It suffices to handle m<1 ? 1 : m==n ? 0 : formula, equivalently m%n<1 ? (m<1) : formula; or alternatively m<1 ? (n>=0) : formula.

I got it, just updating thanks

Since our answers are very similar, and yours was posted first (and is shorter), I'll go ahead and delete mine.

@Loovjo A little bit of frantic tweaking though :( You got an ^vote from me anyway!

Mathematica, 59 56 bytes
_~f~0=1
n_~f~m_:=If[m>n,0,(n-m)f[n-1,m-1]+(m+1)f[n-1,m]]

And here is a 59 byte version implementing the definition more literally:
Count[Count@1/@Sign/@Differences/@Permutations@Range@#,#2]&

Why not just f[n_,m_]:=... for 49?

@JonathanAllan I'm not sure I understand. How does that handle the base case?

OK, something was cached - just did it in a new worksheet and it failed with recursion limit. :)

There is also the formula which uses 46 bytes Sum[Binomial[#+1,k](#2+1-k)^#(-1)^k,{k,0,#2}]& which might be possible to golf more

Python, 53 bytes
t=lambda n,k:n and(n-k)*t(n-1,k-1)-~k*t(n-1,k)or k==0

Recursion from OEIS. Outputs Boolean True as 1 when n==k.

MATLAB / Octave, 40 bytes
@(n,m)sum(sum(diff((perms(1:n))')>0)==m)

This is a port of my MATL answer, in the form of an anonymous function. Call it as ans(7,4).
Try it at Ideone.

GameMaker Language, 62 bytes
This is a recursive script A based on @Arnauld's formula.
n=argument0;m=argument1;return (n-m)*A(n-1,m-1)+(m+1)*A(n-1,m)

Haven't seen THAT in a while!

Perl, 98 bytes
sub a{my($b,$c)=@_;return$c?$c>$b?0:($b-$c)*a($b-1,$c-1)+($c+1)*a($b-1,$c):1;}print a(@ARGV[0,1]);

Based on the same property as Arnauld's answer.

R, 72 bytes
Recursive function following the logic on OEIS.
A=function(n,m)if(!m)1 else if(m-n)0 else(n-m)*A(n-1,m-1)+(m+1)*A(n-1,m)

This challenge turned out to be quite close between the different approaches I tried. For instance, using the wikipedia formula and looping over the sum resulted in 92 bytes:
function(n,m){s=0;if(!n)1 else for(k in -1:m+1)s=c(s,(-1)^k*choose(n+1,k)*(m+1-k)^n);sum(s)}

or the vectorized version for 87 bytes:
function(n,m)if(!m)1 else sum(sapply(-1:m+1,function(k)(-1)^k*choose(n+1,k)*(m+1-k)^n))

and finally the brute force solution (103 bytes) that generates a matrix of all permutations by using the permute package and the function allPerms. This approach only works up to n<8 though.
function(n,m){if(!m)1 else sum(apply(rbind(1:n,permute:::allPerms(n)),1,function(x)sum(diff(x)>0))==m)}

Racket 141 bytes
(count(λ(x)(= x m))(for/list((t(permutations(range 1(+ 1 n)))))(count
(λ(x)x)(for/list((i(sub1 n)))(>(list-ref t(+ 1 i))(list-ref t i))))))

Ungolfed:
(define (f n m)
  (let* ((l (range 1 (add1 n)))                ; create a list till n
         (pl (permutations l))                 ; get all permutations
         (enl (for/list ((t pl))               ; check each permutation;
                (define rl
                  (for/list ((i (sub1 n)))     ; check if an element is a 'rise'
                    (> (list-ref t (add1 i))
                       (list-ref t i))))
                (count (lambda(x)x) rl))))     ; how many numbers are 'rises'
    (count (lambda(x) (= x m)) enl)))          ; how many permutations had m rises
                                               ; i.e. Eulerian number

Testing:
(f 3 0)
(f 3 1)
(f 3 2)
(f 3 3)
(f 4 2)
(f 5 1)
(f 7 4)

Output:
1
4
1
0
11
26
1191

Actually, 21 19 bytes
This answer uses an algorithm similar to the one Dennis uses in his Jelly answer. The original definition counts < while I count >. This ends up being equivalent in the end. Golfing suggestions welcome. Try it online!
;R╨`;\ZdX"i>"£MΣ`Mc

Ungolfing
         Implicit input m, then n.
;        Duplicate n. Stack: n, n, m
R        Push range [1..n].
╨        Push all n-length permutations of the range.
`...`M   Map the following function over each permutation p.
  ;\       Duplicate and rotate p so that we have a list of the next elements of p.
  Z        Zip rot_p and p.
           (order of operands here means the next element is first,
            so we need to use > later)
  dX       Remove the last pair as we don't compare the last and first elements of the list.
  "i>"£    Create a function that will flatten a list and check for a rise.
  M        Map that function over all the pairs.
  Σ        Count how many rises there are in each permutation.
c        Using the result of the map and the remaining m,
          count how many permutations have m rises.
         Implicit return.

Swift 3, 82 88 Bytes
func A(_ n:Int,_ m:Int)->Int{return m<1 ?1:n>m ?(n-m)*A(n-1,m-1)+(m+1)*A(n-1,m):0}
Just the same recursive formula in a language that is definitely not for golf

J, 28 bytes
+/@((!>:)~*(^~#\.)*_1^])i.,]

Uses the formula

Usage
   f =: +/@((!>:)~*(^~#\.)*_1^])i.,]
   0 f 0
1
   1 f 0
1
   1 f 1
0
   (f"+i.,]) 6
1 57 302 302 57 1 0
   20x f 16x
1026509354985

Explanation
+/@((!>:)~*(^~#\.)*_1^])i.,]  Input: n (LHS), m (RHS)
                        i.    Range [0, 1, ..., m-1]
                           ]  Get m
                          ,   Join to get k = [0, 1, ..., m]
                      ]       Get k
                   _1^        Raise -1 to each in k
              #\.               Get the length of each suffix of k
                                Forms the range [m+1, m, ..., 2, 1]
            ^~                  Raise each value by n
                  *           Multiply elementwise with (-1)^k
    (   )~                      Commute operators
      >:                        Increment n
     !                          Binomial coefficient, C(n+1, k)
          *                   Multiply elementwise
+/@                           Reduce by addition to get the sum and return

source: Stack Exchange

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

sort: votes


text:
C# is the Main problem
This programming puzzle is inspired by another question which has been asked here yesterday but which was deleted by the author...
The challenge:
Create an executable binary (Windows .EXE or Linux binary) using Visual C# (or your favorite C# IDE) which prints the following text to the standard output:
Main() is the main method of C# programs!

... without using the 4 consecutive letters M-A-I-N appearing in any source file!
Notes:

If your source code contains the text remainder (for example) it contains the 4 consecutive letters M-A-I-N, however if it contains mxain the 4 letters would not be consecutive any more so mxain would be allowed.
You are not allowed to run any programs but the C# IDE nor change the settings of the C# IDE to run other programs (but the ones it would normally run such as the C# compiler).
Otherwise you could simply say: "I write a Pascal program using the C# IDE and invoke the Pascal compiler in the 'pre-build' steps of my C# project".
This would be too simple.
Users of an IDE that can be extending using "plug-ins" (or similar) or that have built-in binary file editors (hex-editors) would have a too large advantage over users of other C# IDEs.
Therefore these featrues should also not be used.
Using the other non-ASCII-Editors (such as the dialog window editor) is explicitly allowed!
The user asking the original question proposed using the backslash in function names just like this: static void M\u0061in() Because this answer has already been read by other users it will not be accepted any more!
A user asked if it would be allowed to simply type in an .EXE file into the source code editor and to save the file as ".exe" instead of ".cs". Answer: I doub't that this is possible because both valid Windows and Linux binaries contain NUL bytes. However if you find a valid binary that can be created this way you have a valid solution.

The name of this site is "Programming Puzzles & Code Golf" - this is a "Programming Puzzle", not "Code Golf": The challenge is to find a working solution before all other users, not to find a solution shorter than all other solutions.
Therefore the first post describing a working solution wins!
Good luck!
By the way: I have a solution working under Visual C# Express 2010.

What stops me from using my C# IDE as a text (or binary) editor to directly type out an executable?

Which answer wins the challenge? The first valid answer? You should specify the winning condition

If the IDE contains some hexadecimal editor or similar this would NOT be allowed. If you manage to use the ASCII text editor to type in a valid binary file this would be allowed. Note that a valid binary file contains bytes in the range 0x00 to 0x1F!

@MartinRosenau Then you are disallowing newlines

@TùxCräftîñg 1) Why did you delete your answer? It was not my solution but it was correct! 2) Why disallowing newlines?

@MartinRosenau It was not deleted by me, others deleted it

I think this is overall an interesting challenge. "Write a C# program without main". However, most of the rules are about which tools/IDEs to use and banning certain approaches. I'd love to see more programming puzzles, (as opposed to code-golf) but this one is underspecified. I'd recommend using the sandbox next time.

@MartinRosenau I voted to delete the answer, as it was explicitly against your rules.

@TimmyD As far as I remember TùxCräftîñg was one of the users discussing about the question yesterday and not the user asking it. Was I wrong?

@MartinRosenau \n is codepoint 0xA

...Consider the sandbox next time.

C# Interactive Window
Open the C# Interactive Window (View > Other Windows > C# Interactive in Visual Studio 2015). I suppose not all IDEs will have this.
This approach executes C# in the Interactive Window in order to create a C# exe that prints the desired string without the author ever writing main. As a bonus, the exe's IL also does not contain main.
Run the following code in the Interactive Window
using System.Reflection;
using System.Reflection.Emit;
var appMeow = (dynamic)System.Type.GetType("System.AppDom" + "ain").GetProperty("CurrentDom" + "ain", BindingFlags.GetProperty | BindingFlags.Static | BindingFlags.Public).GetValue(null);
var asmName = new AssemblyName("MEOW");
var asmBuilder = appMeow.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
var module = asmBuilder.DefineDynamicModule("MEOW", "MEOW.exe");
var typeBuilder = module.DefineType("Meow", TypeAttributes.Public);
var entryPoint = typeBuilder.DefineMethod("EntryPoint", MethodAttributes.Static | MethodAttributes.Public);
var il = entryPoint.GetILGenerator();
il.Emit(OpCodes.Ldstr, "Meow() is the meow method of C# programs!");
il.Emit(OpCodes.Ldstr, "eow");
il.Emit(OpCodes.Ldstr, "ain");
il.EmitCall(OpCodes.Call, typeof(string).GetMethod("Replace", new[] { typeof(string), typeof(string) }), null);
il.EmitCall(OpCodes.Call, typeof(Console).GetMethod("Write", new[] { typeof(string) }), null);
il.Emit(OpCodes.Ret);
var type = typeBuilder.CreateType();
asmBuilder.SetEntryPoint(type.GetMethods()[0]);
asmBuilder.Save("MEOW.exe");

Use Environmnent.CurrentDirectory to see where the exe was created. Run it to observe the desired output.

Resulting IL:

I actually like this one better, then the WPF one, because you actually have no Main() in your Assembly whatsoever.

Your solution is interesting. It is the second one so you will win if the users should convince me that the first post is not a valid solution (for what reason ever).

If you ask me it doesn't really matter which post wins, since they are both by the same user.

@hstde - Sorry, I did not see this. Thanks.

@milk You posted two valid solutions (well, some users have doubt about the first one) so you win. Congratulations.

WPF Application

Create a new WPF application.

Replace all instances of Main with Meow

Rename MainWindow.xaml to MeowWindow.xaml. This will automatically rename MainWindow.xaml.cs to MeowWindow.xaml.cs.

In project properties, change the Output type to Console Application so the console is created.

Add console write for the desired output string in your MeowWindow constructor

Ctrl+Shift+F to confirm there's no main anywhere in the source directory.

F5 / compile and run.

How it works
For WPF applications, Visual Studio generates obj\Debug\App.g.cs which contains the Main method. The generated Main creates an instance of your WPF app and starts it.

Interesting solution. Anyone who thinks that this is not a valid solution? If anyone thinks that this post is not valid please post a comment. Otherwise I will declare this solution the winning one because it was obviously the first one posted.

@MartinRosenau I feel that since you could decompile the wpf app and there would be a main method that this is invalid, more strongly because the same user posted another answer that does not have this ambiguity

I just saw that both answers were posted by the same user. In this case this user will win anyway.

Just as a reference
My idea was similar to "milk"'s second idea:
Find a way to let the IDE execute code and write an executable to the disk.
I explicitly mentioned Windows and Linux binaries because I thought about writing the binary .EXE file using System.IO.File.WriteAllBytes() so it would not neccessarily be a .NET EXE file.
My problem was that VS Express 2010 seems not to have an interactive console so I had to find a replacement for that - I found the following:
Create a DLL project with a dialog window and a custom control; compile the project and add the custom control to the dialog window. The dialog window editor will then call the code of the custom control - and in this code you may write the .EXE file to the disk...

I had to break the rules because I used vim with csc...
class C {
    static void \u004d\u0061\u0069\u006e(){
        Syste\u006d.Co\u006esole.Write("\u004d\u0061\u0069\u006e() is the \u006d\u0061\u0069\u006e \u006dethod of C# progra\u006ds!");
    }
}

Could you please explain the downvotes?

Surely this would contain "Main" in the binary?

Maybe because you directly stated that you broke the rules.

@DJMcMayhem It was mainly to show this rule was simply stupid >_>

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


text:
Sieve of Eratosthenes, Step by Step
Given a number N, draw a left aligned NxN board of numbers, leaving 1 blank (as a space) (I will show diagrams with N=5)
   2  3  4  5
6  7  8  9  10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25

Your job is to construct the Sieve of Eratosthenes, step by step. First, start with 2. It's prime, so leave it there, and replace all other numbers divisible by 2 with the proper number of spaces.
   2  3     5
   7     9
11    13    15
   17    19
21    23    25

Next, go to the next unprinted number (3 in this case) and do the same.
   2  3     5
   7
11    13
   17    19
      23    25

And so on, until you reach N.
You need to first print the complete grid, and every time you go to a new number, print the board with the multiples removed. Make sure you print a blank line in between!
Examples
Text in parenthesis () are just for reference, you don't need to print it
N = 2:
  2 (complete grid)
3 4

  2 (remove multiples of 2)
3

N = 3:
  2 3 (complete grid)
4 5 6
7 8 9

  2 3 (remove multiples of 2)
  5
7   9

  2 3 (remove multiples of 3)
  5
7

Remember, this is code-golf, so the code with the smallest number of bytes wins.

Normally for an N×N sieve you stop sieving after N.

@Neil Fixed. lol

Must the numbers be left aligned?

@xnor Yes.They do

Is there a maximum value of N we must support? (Could we always pad numbers to a fixed number of spaces?)

@mbomb007 There has two be one space between numbers of the same length

@Oliver Then what's the output for N=4 (double digits) or N=10 or 11 (triple digits)?

For example, if N=10, 100 is not prime, so will be removed at some point. Must all numbers be padded to 3 characters because 100 has 3 digits?

Why would you left-align numbers?

yes. they do have to

Are trailing newlines acceptable?

Are built-in grids allowed? The output will look identical to the example in the post, but will not be a string.

@Dennis Yes, they ae.

@mbomb007 Yes..

Jelly, 34 bytes
Ṿ€“1“ ”ys³G
>®i©1ḍoṛ®¦
²R;1©ÇÐĿÑ€Y

Try it online!
How it works
²R;1©ÇÐĿÑ€Y  Main link. Argument: n (integer)

²            Yield n².
 R           Range; yield [1, ..., n²].
   1©        Yield 1 and copy it to the register.
  ;          Append 1 to the range.
             This is the initial state. Let's call it S.
     ÇÐĿ     Call the second helper link until the results are no longer unique.
             This returns all unique results as an array.
        Ṅ€   Call the first helper link on each result.
          Y  Join, separating by linefeeds.

>®i©1ḍoṛ®¦   Second helper link. Argument: S (state)

>®           Compare all integers in S with the value in the register.
  i 1        Find the first index of 1 (i.e., the first number that is greater
             than the register.
   ©         Copy the index to the register. Let's call the index p.
     ḍ       Test all numbers in S for divisibility by p. This yield 1 for
             multiples of p, 0 otherwise.
      o      Logical OR; replace 0's with the corresponding values of S.
       ṛ®¦   Replace the 0 at index p with the corresponding element of S (p).
             For the purposes of the explanation, S is now the updated state.

Ṿ€“1“ ”ys³G  First helper link. Argument: A (array)

Ṿ€           Uneval each; convert all integers in A into strings.
  “1“ ”y     Replace each string "1" with the string " ".
        s³   Split into chunks of length n (command-line argument).
          G  Grid; separate row items by spaces (left-padding since the row items
             are strings), the rows themselves by linefeeds.

Perl, 250 243 231 202 157 bytes
$n=<>;@a=0..($e=$n*$n);$a[1]=$";for$p(1..$n){next if!$a[$p];for(1..$e){$a[$_]=""if!($p~~[(1,$_)]||$_%$p);printf"%-*s",1+length$e,$a[$_];say""if!($_%$n)}say}

Test the current golf online! (be sure to run as perl -M5.010 main.pl)
The two literal newlines each save 1 byte in place of \n.
Sample output (input of 7):
   2  3  4  5  6  7
8  9  10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

   2  3     5     7
   9     11    13
15    17    19    21
   23    25    27
29    31    33    35
   37    39    41
43    45    47    49

   2  3     5     7
         11    13
      17    19
   23    25
29    31          35
   37          41
43          47    49

   2  3     5     7
         11    13
      17    19
   23
29    31
   37          41
43          47    49

   2  3     5     7
         11    13
      17    19
   23
29    31
   37          41
43          47

I'm positive I didn't golf it very well, so when I get home I'll take another look at it to see just how much I can shave off.
Edit 1: -7 bytes (changing "print sprintf" to the obvious "printf")
Edit 2: Saved 12 bytes by using $d explicitly in the one place it was called instead of creating a separate variable, by combining some declarations, and by eliminating one of my conditions for the next statement inside the first foreach loop by adding a space somewhere else.
An additional 29 bytes were golfed out by reworking two for loops into a single loop, eliminating two variable declarations, and turning unless statements into if-not statements.  Declaring my$e=$n*$n; then replacing the three instances of $n*$n with $e (allowing me to drop a paren for one of them) turned out to yield ±0 bytes, but I kept it in anyway.
Edit 3: Thanks to @Dada, another 40 bytes were golfed out (variable declarations, 'foreach' becoming 'for', implicit $_ in several locations, and cutting down on the printf statement size).  An additional 1 byte was shaved off by turning if!($c%$p||$c==$p||$p==1) into if!($p~~[(1,$_)]||$_%$p).  Unfortunately, the [] around the array is necessary, because the smartmatch operator ~~ is still experimental and doesn't seem to work properly on actual arrays, but does work on references to them instead.  4 more bytes were removed by removing two semicolons and an empty set of quotation marks after the last say.

That's a good start, but you can golf it a lot more. Don't declare variables (so don't use my). Use -p flag to have N inside $_ instead of using $n=<>. Write for instead of foreach (this instruction are equivalents). Drop the parenthesis around the condition of the if that are in statement modifier position (for instance if!$c%$n instead of if(!$c%$n). No parenthesis needed to initialize @a : @a=0..$e. You can drop to for variable and $_ wiil be used instead. Write printf"%*s",1+length$e,$a[$c] (the ``sprintfdoc for details about that*`)

Use $" instead of " ". say"" instead of print"\n" (you have a litteral newline in your code but I can't write it in comment) (you will add to add -M5.010 to the command line, but that doesn't count in the byte count). You can probably use 0..$e=$n*$n to save one byte at the initialisation of $e. Have a look at the perl golfing tips, it contains a lot of usefull tips. But it's nice to see a new perl golfer, welcome! :) (and forgive my spelling mistakes, I may have write my previous comment too fast)

@Dada Thank you for your advice!  I'm not very familiar with running code on the command line (I tend to run it as a file) but I'll take a look at doing it that way.  As for if!$c%$n, the ! operator has precedence over the % operator, so technically this would be if((!$c)%$n) which comes out to false for anything other than $c = 0 (which I don't want).  As for your other tips, I'll see what I can do!  Thank you very much!

You don't have to run it on the command line, those modifications will work if you put them inside a file as well. Sorry for the !, I wasn't on my computer to check it. You should be able to get down to 160 characters I think.

PHP, 155 Bytes
for(;$d++<$n=$argv[1];$x&$a[$d]<1?:print"\n".chunk_split(join($a),$n*$l))for($i=$d*$x=$d>1;$n**2>=$i+=$d;)$a[$i]=str_pad($x|$i<2?"":$i,$l=strlen($n**2)+1);

@Crypto -3 Bytes Thank You
@Titus -6 Bytes Thank You
Try it
First time that I use print in a after loop condition
Breakdown
for(;$d++<$n=$argv[1];
$x&$a[$d]<1?:print"\n".chunk_split(join($a),$n*$l))
#after loop print the grid if $d = 1 or is prime
for($i=$d*$x=$d>1;$n**2>=$i+=$d;)
$a[$i]=str_pad($x|$i<2?"":$i,$l=strlen($n**2)+1);
#fills the array at first run and replace positions with space in the next runs

Previous Version 174 Bytes
for(;$d++<=$n=$argv[1];!($d<2||$a[$d]>0)?:print chunk_split(join($a),$n*$l)."\n")for($i=$d<2?1:2*$d;$i<=$m=$n**2;$i+=$d)$a[$i]=str_pad($d<2?($i<2?"":$i):" ",$l=strlen($m)+1);

-3 bytes changing the condition : !($d<2||$a[$d]>0) => $d>1&&$a[$d]<1

-1 byte using this trick to get integer length $l=strlen($m)+1 to $l=log10($m)+2

@Crypto Nice Thank You your ideas and my last ideas works well together. You have improve the parts I have not improve

wordwrap instead of chunk_split should save a few bytes.

@Titus Use wordwrap with values for example 17 and you can see that the values are moved. chunk_split is safe in comparision.

-3 bytes: $i=$d*$x=$d>1 instead of $i=$d<2?0:$d and $x for the other two occurences of $d>1

-2 bytes: $n*$n>=$i+=$d instead of ($i+=$d)<=$m=$n**2 and $n*$n for the other occurence of $m

-1 byte: leading instead of trailing newline

@Titus I admire you that you see this

R, 195 191 185 204 bytes
f=function(N){a=b=1:N^2;i=1;a[1]="";S=sprintf;while(i<=N){for(j in b)cat(a[j]<-S(S("%%-%is",nchar(N^2)),if(j==i|j%%i|i<2)a[j]else ""),if(j%%N)"" else"\n");cat("\n");i=(grep("\\d",a[-(1:i)],v=T)[1]:1)[1]}}

Thanks to @Billywob for 6 extra bytes saved!
Indented, with newlines:
f=function(N){
   a=b=1:N^2 #Initial array
   i=1 #Turn counter
   a[1]="" #1 never shown
   S=sprintf
   while(i<=N){
      for(j in b)
         cat(a[j]<-S(S("%%-%is",nchar(N^2)),if(j==i|j%%i|i<2)a[j]else ""),
             if(j%%N)"" else"\n") #Newline at end of row
      cat("\n") #Newline between turns
      i=(grep("\\d",a[-(1:i)],v=T)[1]:1)[1] #Select next prime as next i
   }
}

Usage:
> f(2)
  2
3 4

  2
3

> f(3)
  2 3
4 5 6
7 8 9

  2 3
  5
7   9

  2 3
  5
7

> f(9)
   2  3  4  5  6  7  8  9
10 11 12 13 14 15 16 17 18
19 20 21 22 23 24 25 26 27
28 29 30 31 32 33 34 35 36
37 38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54
55 56 57 58 59 60 61 62 63
64 65 66 67 68 69 70 71 72
73 74 75 76 77 78 79 80 81

   2  3     5     7     9
   11    13    15    17
19    21    23    25    27
   29    31    33    35
37    39    41    43    45
   47    49    51    53
55    57    59    61    63
   65    67    69    71
73    75    77    79    81

   2  3     5     7
   11    13          17
19          23    25
   29    31          35
37          41    43
   47    49          53
55          59    61
   65    67          71
73          77    79

   2  3     5     7
   11    13          17
19          23
   29    31
37          41    43
   47    49          53
            59    61
         67          71
73          77    79

   2  3     5     7
   11    13          17
19          23
   29    31
37          41    43
   47                53
            59    61
         67          71
73                79

> f(12)
    2   3   4   5   6   7   8   9   10  11  12
13  14  15  16  17  18  19  20  21  22  23  24
25  26  27  28  29  30  31  32  33  34  35  36
37  38  39  40  41  42  43  44  45  46  47  48
49  50  51  52  53  54  55  56  57  58  59  60
61  62  63  64  65  66  67  68  69  70  71  72
73  74  75  76  77  78  79  80  81  82  83  84
85  86  87  88  89  90  91  92  93  94  95  96
97  98  99  100 101 102 103 104 105 106 107 108
109 110 111 112 113 114 115 116 117 118 119 120
121 122 123 124 125 126 127 128 129 130 131 132
133 134 135 136 137 138 139 140 141 142 143 144

    2   3       5       7       9       11
13      15      17      19      21      23
25      27      29      31      33      35
37      39      41      43      45      47
49      51      53      55      57      59
61      63      65      67      69      71
73      75      77      79      81      83
85      87      89      91      93      95
97      99      101     103     105     107
109     111     113     115     117     119
121     123     125     127     129     131
133     135     137     139     141     143

    2   3       5       7               11
13              17      19              23
25              29      31              35
37              41      43              47
49              53      55              59
61              65      67              71
73              77      79              83
85              89      91              95
97              101     103             107
109             113     115             119
121             125     127             131
133             137     139             143

    2   3       5       7               11
13              17      19              23
                29      31
37              41      43              47
49              53                      59
61                      67              71
73              77      79              83
                89      91
97              101     103             107
109             113                     119
121                     127             131
133             137     139             143

    2   3       5       7               11
13              17      19              23
                29      31
37              41      43              47
                53                      59
61                      67              71
73                      79              83
                89
97              101     103             107
109             113
121                     127             131
                137     139             143

    2   3       5       7               11
13              17      19              23
                29      31
37              41      43              47
                53                      59
61                      67              71
73                      79              83
                89
97              101     103             107
109             113
                        127             131
                137     139

Nice, I can never figure out how to properly print matrices to comply to codegolfing requirements never mind left justifying them. You can save a few bytes by though. The exponentiation operator ^ is the only one that isn't vectorized when generating sequences using : which means you can use e.g. 1:2^2 to get 1 2 3 4. Secondly if you define a=b=1:n^2 you can later use for(j in b) instead of defining another vector to loop over. Should save you a couple of bytes.

Indeed! Thanks! Can never remember the exact order of operator precedence...

Why are there three spaces between the numbers in f(2) and f(3) and two spaces in f(9)? It should always be one space.

Oh right I set up 3 characters as the norm because i was testing with N=10, let me correct that.

Groovy, 201 195 191 Bytes
{n->a=(1..n*n).toArray();y={a.collect{(it?"$it":"").padRight((""+n*n).size())}.collate(n).each{println it.join(" ")}};a[0]=0;y(a);(2..n).each{b->(b+1..n*n).each{if(it%b==0){a[it-1]=0}};y(a)}}

This is an absolute cluster... The left-align murdered my byte count. But hey, it works. Here's the output for 4:
   2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

   2  3
5     7
9     11
13    15

   2  3
5     7
      11
13

   2  3
5     7
      11
13

Ungolfed:
{
    n->
    a = (1..n*n).toArray();                           // Create initial array.
    y = {                                             // Createa  printing utility closure.
        a.collect {                                   // Create an array collection of...
            (it ? "$it":"").padRight((""+n*n).size()) // If 0, store "", else store number & right pad it.
        }.collate(n).each{                            // Collate by n (break into nxn grid).
            println it.join(" ")                      // print each separated by spaces.
        }
    };
    a[0]=0;                                           // Remove first element.
    y(a);                                             // Print initial status.
    (2..n).each{                                      // From 2 to n...
        b->
        (b+1..n*n).each{                              // From current number + 1 to end of grid...
            if(it%b==0){                              // If current grid position is divisible...
                a[it-1]=0                             // Replace with 0.
            }
        }
        y(a)                                          // Print it.
    }
}

This doesn't look left-aligned to me.

Fixed... I just didn't get a chance to edit it until now...

@Dennis I actually saw your comments and thought he had changed it based on your comment.

Python 2, 199 202 201 bytes
+3 bytes (I wasn't stopping early)
-1 byte thanks to @Oliver (missed a space)
def f(n,p={()}):
 m=n*n;g=['']+[[i,''][any(i>n and i%n<1for n in p)]for i in range(2,m+1)];x=min(set(g)-p);i=0
 while i<m+n:print' '.join('%%%ds'%-len(`m`)%v for v in g[i:i+n]);i+=n
 if x<=n:f(n,p|{x})

repl.it

You can remove a space between 1 and for

Perl, 115 114 113 112 bytes
Includes +1 for -a
Run with input number on STDIN:
perl -M5.010 sieving.pl <<< 7

sieving.pl:
#!/usr/bin/perl -a
$_*=$_;$a.="$_"x$|++|$"x"@+".($_%"@F"?$":$/)for/\d+/..$_;*_=a;s^^$$_++||say;$.++;s//$&%$.|$&==$.?$&:$&&$_/eg^eg

Needs a recent enough perl so that -a implies -n. If your perl is too old add a -n option.
Prints a trailing newline which is allowed.

JavaScript (ES6), 190 189 bytes
Directly prints to the console.
f=(w,k=1,a=[...Array(w*w)].map((_,n)=>n&&n+1))=>k++<=w&&(k==2|a[k-2]&&console.log(a.map((n,x)=>`${n||''}    `.slice(0,`_${w*w}`.length)+(++x%w?'':`
`)).join``),f(w,k,a.map(n=>n==k|n%k&&n)))

Demo

f=(w,k=1,a=[...Array(w*w)].map((_,n)=>n&&n+1))=>k++<=w&&(k==2|a[k-2]&&console.log(a.map((n,x)=>`${n||''}    `.slice(0,`_${w*w}`.length)+(++x%w?'':`
`)).join``),f(w,k,a.map(n=>n==k|n%k&&n)))

f(5)

Batch, 464 bytes
@echo off
set/an=%1,s=n*n,t=s,c=1
set p=
:l
set/ac+=1,t/=10
set p= %p%
if %t% gtr 0 goto l
for /l %%i in (1,1,%1)do call:i %%i
exit/b
:i
set l=
set/af=0
call:f %1 %1
if %f%==0 for /l %%j in (1,1,%s%)do call:j %1 %%j
exit/b
:j
set/am=%2,f=!(m-1),g=%2%%n
call:f %1 %2
if %f% gtr 0 set m=
set m=%m% %p%
call set l=%%l%%%%m:~0,%c%%%
if %g%==0 echo(%l%&set l=
if %2==%s% echo(
exit/b
:f
for /l %%l in (2,1,%1)do if %%l neq %2 set/af+=!(%2%%%%l)

This was somewhat laborious. Explanation: Starts by squaring n so that it can calculate the desired column width c, and the appropriate amount of padding p, using the loop :l. The outer loop from 1 to n then runs once for each grid, calling the subroutine :i. First the value is checked to see whether it is 1 or prime; if not then that grid is skipped. The inner loop from 1 to n*n then handles the rows and columns of the grid, calling the subroutine :j. Each value is checked to see whether it is one of the prime numbers found so far, or if none of the prime numbers found so far divide it. If so then the value is concatenated to the output buffer, which is then padded to the desired column width. The buffer is printed and cleared every n lines, and an extra blank line is added at the end of the grid. The :f label denotes the factor-checking subroutine; f(x,y) adds 1 to f for each integer between 2 and x that divides y, excluding y itself.

J, 125 bytes
p=:3 :'}."1,./('' '',.>)"1|:(-%:#y)]\((a:"_)`(<@":)@.*)"+y'
3 :'p@>~.|.(]*](*@|~+.=)({[:I.*){])&.>/\.(<"+i.-y),<]`>:@.*i.*:y'

This is explicit, not tacit J, but there should be a way to golf it tacitly.
Usage
   p =: 3 :'}."1,./('' '',.>)"1|:(-%:#y)]\((a:"_)`(<@":)@.*)"+y'
   f =: 3 :'p@>~.|.(]*](*@|~+.=)({[:I.*){])&.>/\.(<"+i.-y),<]`>:@.*i.*:y'
   f 2
  2
3 4

  2
3
   f 3
  2 3
4 5 6
7 8 9

  2 3
  5
7   9

  2 3
  5
7
   f 4
   2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

   2  3
5     7
9     11
13    15

   2  3
5     7
      11
13
   f 5
   2  3  4  5
6  7  8  9  10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25

   2  3     5
   7     9
11    13    15
   17    19
21    23    25

   2  3     5
   7
11    13
   17    19
      23    25

   2  3     5
   7
11    13
   17    19
      23

Mathematica, 133 bytes
Grid[#,Alignment->Left]~Print~"
"&/@FoldList[#/.(##|1&@@(2~r~i#2)->Null)&,(r=Range)[i=#^2]~Partition~#/.Rule[1,],Prime@r@PrimePi@#];&

PHP, 155 150 147 145 142 140 bytes
for(;$k++<$n=$argv[1];)if($k<2||$a[$k]){for($i=0;$i++<$n*$n;)echo$a[$i]=$k>1?$i>$k&$i%$k<1?"":$a[$i]:($i<2?"":$i),"\t\n"[$i%$n<1];echo"\n";}

breakdown
for(;$k++<$n=$argv[1];)
    if($k<2||$a[$k])    // if first iteration or number unprinted ...
{
    for($i=0;$i++<$n*$n;)
        echo
            $a[$i]=$k>1
                ?$i>$k&$i%$k<1
                    ?""         // sieve
                    :$a[$i]     // or copy value
                :($i<2?"":$i)   // first iteration: init grid
            ,
            // append tab, linebreak every $n columns
            "\t\n"[$i%$n<1]
        ;
    // blank line after each iteration
    echo"\n";
}

$a[$i]=""; instead of unset($a[$i]); should save 4 Bytes

$i%$k<1 instead of !($i%$k) save one Byte


text:
Codegolf the permanent
The challenge is to write codegolf for the permanent of a matrix.
The permanent of an \$n\times n\$ matrix \$A = a_{i,j}\$) is defined as
$$\text{perm}(A) = \sum_{\sigma \in S_n} \prod^n_{i=1} a_{i,\sigma(i)}$$
Here \$S_n\$ represents the set of all permutations of \$[1, n]\$.
As an example (from the wiki):
$$\text{perm} \left( \begin{matrix}
a & b & c \\
d & e & f \\
g & h & i \\
\end{matrix} \right) = aei + bfg + cdh + ceg + bdi + afh$$
Your code can take input however it wishes and give output in any sensible format but please include in your answer a full worked example including clear instructions for how to supply input to your code. To make the challenge a little more interesting, the matrix may include complex numbers.
The input matrix is always square and will be at most 6 by 6.  You will also need to be able to handle the empty matrix which has permanent 1. There is no need to be able to handle the empty matrix (it was causing too many problems).
Examples
Input:
[[ 0.36697048+0.02459455j,  0.81148991+0.75269667j,  0.62568185+0.95950937j],
 [ 0.67985923+0.11419187j,  0.50131790+0.13067928j,  0.10330161+0.83532727j],
 [ 0.71085747+0.86199765j,  0.68902048+0.50886302j,  0.52729463+0.5974208j ]]

Output:
-1.7421952844303492+2.2476833142265793j

Input:
[[ 0.83702504+0.05801749j,  0.03912260+0.25027115j,  0.95507961+0.59109069j],
 [ 0.07330546+0.8569899j ,  0.47845015+0.45077079j,  0.80317410+0.5820795j ],
 [ 0.38306447+0.76444045j,  0.54067092+0.90206306j,  0.40001631+0.43832931j]]

Output:
-1.972117936608412+1.6081325306004794j

Input:
 [[ 0.61164611+0.42958732j,  0.69306292+0.94856925j,
     0.43860930+0.04104116j,  0.92232338+0.32857505j,
     0.40964318+0.59225476j,  0.69109847+0.32620144j],
   [ 0.57851263+0.69458731j,  0.21746623+0.38778693j,
     0.83334638+0.25805241j,  0.64855830+0.36137045j,
     0.65890840+0.06557287j,  0.25411493+0.37812483j],
   [ 0.11114704+0.44631335j,  0.32068031+0.52023283j,
     0.43360984+0.87037973j,  0.42752697+0.75343656j,
     0.23848512+0.96334466j,  0.28165516+0.13257001j],
   [ 0.66386467+0.21002292j,  0.11781236+0.00967473j,
     0.75491373+0.44880959j,  0.66749636+0.90076845j,
     0.00939420+0.06484633j,  0.21316223+0.4538433j ],
   [ 0.40175631+0.89340763j,  0.26849809+0.82500173j,
     0.84124107+0.23030393j,  0.62689175+0.61870543j,
     0.92430209+0.11914288j,  0.90655023+0.63096257j],
   [ 0.85830178+0.16441943j,  0.91144755+0.49943801j,
     0.51010550+0.60590678j,  0.51439995+0.37354955j,
     0.79986742+0.87723514j,  0.43231194+0.54571625j]]

Output:
-22.92354821347135-90.74278997288275j

You may not use any pre-existing functions to compute the permanent.

Is the matrix always a 3x3? Or are the dimensions arbitrary?

@L.Steer Updated question. Thank you.

Do we need to handle an empty matrix?

@JonathanAllan Yes. Great question.

Could you please remove the complex requirement? I think it ruins an otherwise nice challenge. Every language that doesn't have built-in complex arithmetic now has to do a totally separate task.

If we need to handle the empty matrix, you should add it as a test case. The fact that you cannot really represent the 0x0 matrix with lists makes this a bit difficult. Personally, I'd just remove that requirement.

It would also be nice to explain what S_n is for the benefit of those who don't know.

The empty matrix has permanent 1, not 0, though I agree with Dennis about just not including it.

@xnor Argh.. I knew I would get that wrong. Thank you.

There's no point putting something in the sandbox for 3 hours. Give it 3 days and people have a chance to give feedback.

@PeterTaylor I hear you.  There is also the issue that I just have some preferences for codegolf questions which not everyone agrees with.  For example, I don't feel the need to make every question as easy for restricted esolangs as for higher level languages.

1. It's not just esolangs. Bash, e.g., can't even natively deal with floats. Excluding a language from the competition just because it lacks a certain numeric type, even if can effortlessly implement the desired algorithm, is just being picky for no good reason. 2. I'm still not sure about the empty matrix. Would it be [[]] (has one row, the empty matrix doesn't) or [] (doesn't have depth 2, matrices do) in list form?

@Dennis 2. I think a 1d empty array is [] and a 2d one is [[]].  I suppose equivalently we could define it to have one empty column. This is just an oddity of how 2d arrays are represented I think.  1. I love bash more than most people but surely almost all challenges have a set of languages that are suited to it and a set that aren't.  I also don't think we should compare solutions in different languages in codegolf.  I am interested in the best one in each language for which there is a submitted answer.

@Dennis http://unix.stackexchange.com/a/40787 has various fun ways of handling floating point numbers.

1. I'm not daying that it's impossible to solve this challenge in Bash, but if the lion share of the code is used to deal with complex number arithmetic, it stops being a challenge about permanents. 2. Most if not all current answers is languages without a matrix type break for input [[]].

[[]] is clearly a 1x0 matrix. My recursive function needs the empty matrix as base case, and it comes naturally down to []. - BTW, I think an example that is easy to type (low dimension, simple numbers) would have been very helpful.

@ChristianSievers you are right on both counts.

It's a shame this otherwise-great question is burdened by these difficulties. Like Peter said - leave challenges in the sandbox longer if you want good feedback. 3 hours is way too short.

@Mego I removed the empty matrix requirement. I hope that helps.

My objection wasn't related to the empty matrix requirement (I made it after the requirement was removed). I am objecting to requiring complex number support (which doesn't really add anything to the challenge other than incredible complication for languages without native complex number support), the lack of simple test cases, and the lack of explanation for your equations (not everyone knows that S_n represents the set of all permutations of [1, n]).

@Mego I have now added an explanation for S_n (thank you. I used yours).  Can we just disagree about the complex number requirement? I think it's interesting and it's an extra interesting challenge (in my view) to golf code in a language that doesn't have complex number support. No one should be comparing the length of such code with something in a language that does.  In general, my preference is for challenges that are closer to real life problems and I feel there is room on codegolf for a wide variety of question types.

@Lembik The issue is, as Dennis mentioned, by requiring complex number support, this challenge is more about complex number arithmetic than it is about the permanent of a matrix in languages without native complex number support. It's essentially two different challenges, depending on the choice of language.

@Mego the same argument is valid for the tons of challenges on this site based on operation on prime numbers.  Every esolang has a 1 byte builtin for the primality test, while using general purpose languages you have to add a bunch of code just to do the test

@edc65 Those challenges include operations on prime numbers because they actually add something to the challenge (or are the core of the challenge). Requiring complex support in this challenge is adding unnecessary fluff by requiring the use of unnecessarily complicated number types, which causes it to be a chameleon challenge. Three hits on the "don't do these things" list is not good.

@Mego example: http://codegolf.stackexchange.com/questions/89726/golf-a-brain-flak-integer/90608#90608

@edc65 Trying to say "well why didn't you complain about X challenge" isn't constructive - I don't read every challenge that gets posted.

@Mego Don't you? You said "those challenges...". I did not complain about them (trust me, they are a lot) even if I don't like them, and I don't complain about this one.

J, 5 bytes
+/ .*

J does not offer builtins for the permanent or determinant but instead offers a conjunction u . v y which recursively expands y along the minors and calculates dyadic u . v between the cofactors and the output of the recursive call on the minors. The choices of u and v can vary. For example, using u =: -/ and v =: * is -/ .* which is the determinant. Choices can even by %/ .! where u=: %/, reduce by division, and v =: ! which is binomial coefficient. I'm not sure what that output signifies but you're free to choose your verbs.
An alternative implementation for 47 bytes using the same method in my Mathematica answer.
_1{[:($@]$[:+//.*/)/0,.;@(<@(,0#~<:)"+2^i.@#)"{

This simulates a polynomial with n variables by creating a polynomial with one variable raised to powers of 2. This is held as a coefficient list and polynomial multiplication is performed using convolution, and the index at 2n will contain the result.
Another implementation for 31 bytes is
+/@({.*1$:\.|:@}.)`(0{,)@.(1=#)

which is a slightly golfed version based on Laplace expansion taken from the J essay on determinants.
Usage
   f =: +/ .*
   f 0 0 $ 0 NB. the empty matrix, create a shape with dimensions 0 x 0
1
   f 0.36697048j0.02459455 0.81148991j0.75269667 0.62568185j0.95950937 , 0.67985923j0.11419187  0.50131790j0.13067928 0.10330161j0.83532727 ,: 0.71085747j0.86199765 0.68902048j0.50886302 0.52729463j0.5974208
_1.7422j2.24768
   f 0.83702504j0.05801749 0.03912260j0.25027115 0.95507961j0.59109069 , 0.07330546j0.8569899 0.47845015j0.45077079 0.80317410j0.5820795 ,: 0.38306447j0.76444045 0.54067092j0.90206306 0.40001631j0.43832931
_1.97212j1.60813
   f 0.61164611j0.42958732 0.69306292j0.94856925 0.4386093j0.04104116 0.92232338j0.32857505 0.40964318j0.59225476 0.69109847j0.32620144 , 0.57851263j0.69458731 0.21746623j0.38778693 0.83334638j0.25805241 0.6485583j0.36137045 0.6589084j0.06557287 0.25411493j0.37812483 , 0.11114704j0.44631335 0.32068031j0.52023283 0.43360984j0.87037973 0.42752697j0.75343656 0.23848512j0.96334466 0.28165516j0.13257001 , 0.66386467j0.21002292 0.11781236j0.00967473 0.75491373j0.44880959 0.66749636j0.90076845 0.0093942j0.06484633 0.21316223j0.4538433 , 0.40175631j0.89340763 0.26849809j0.82500173 0.84124107j0.23030393 0.62689175j0.61870543 0.92430209j0.11914288 0.90655023j0.63096257 ,: 0.85830178j0.16441943 0.91144755j0.49943801 0.5101055j0.60590678 0.51439995j0.37354955 0.79986742j0.87723514 0.43231194j0.54571625
_22.9235j_90.7428

Wow is all I can say.

Haskell, 59 bytes
a#((b:c):r)=b*p(a++map tail r)+(c:a)#r
_#_=0
p[]=1
p l=[]#l

This does a Laplace-like development along the first column, and uses that the order of the rows doesn't matter. It works for any numeric type.
Input is as list of lists:
Prelude> p [[1,2],[3,4]]
10

Always welcome a Haskell solution!

Jelly, 10 9 bytes
Œ!ŒDḢ€P€S

Try it online!
How it works
Œ!ŒDḢ€P€S  Main link. Argument: M (matrix / 2D array)

Œ!         Generate all permutations of M's rows.
  ŒD       Compute the permutations' diagonals, starting with the main diagonal.
    Ḣ€     Head each; extract the main diagonal of each permutation.
      P€   Product each; compute the products of the main diagonals.
        S  Compute the sum of the products.

It's just too good!

Python 2, 75 bytes
Seems clunky... should be beatable.
P=lambda m,i=0:sum([r[i]*P(m[:j]+m[j+1:],i+1)for j,r in enumerate(m)]or[1])

05AB1E, 19 14 13 bytes
œvyvyNè}Pˆ}¯O

Try it online!
Explanation
œ              # get all permutations of rows
 v        }    # for each permutation
  yv   }       # for each row in the permutation
    yNè        # get the element at index row-index
        P      # product of elements
         ˆ     # add product to global array
           ¯O  # sum the products from the global array

A slightly shockingly sized answer! Could you provide some explanation?

@Lembik: Feels like it could be shorter still. I have a second solution of the same size so far.

Handling empty matrices is no longer required.

8 bytes by using maps. Too bad the new 05AB1E doesn't support imaginary numbers (or I simply don't know how), since we now have a main diagonal builtin and this could have been 6 bytes: œ€Å\PO.

Python 2, 139 bytes
from itertools import*
def p(a):c=complex;r=range(len(a));return sum(reduce(c.__mul__,[a[j][p[j]]for j in r],c(1))for p in permutations(r))

repl.it
Implements the naïve algorithm which blindly follows the definition.

Ruby, 74 63 bytes
->a{p=0;a.permutation{|b|n=1;i=-1;a.map{n*=b[i+=1][i]};p+=n};p}

A straightforward translation of the formula. Several bytes saved thanks to ezrast.
Explanation
->a{
    # Initialize the permanent to 0
    p=0
    # For each permutation of a's rows...
    a.permutation{|b|
        # ... initialize the product to 1,
        n=1
        # initialize the index to -1; we'll use this to go down the main diagonal
        # (i starts at -1 because at each step, the first thing we do is increment i),
        i=-1
        # iteratively calculate the product,
        a.map{
            n*=b[i+=1][i]
        }
        # increase p by the main diagonal's product.
        p+=n
    }
    p
}

reduce actually hurts your byte count compared to aggregating manually: ->a{m=0;a.permutation{|b|n=1;a.size.times{|i|n*=b[i][i]};m+=n};m}

@ezrast Thanks! Managed to golf down that times loop as well.

MATL, 1714 bytes
tZyt:tY@X])!ps

Try it Online
Explanation
t       % Implicitly grab input and duplicate
Zy      % Compute the size of the input. Yields [rows, columns]
t:      % Compute an array from [1...rows]
tY@     % Duplicate this array and compute all permutations (these are the columns)
X]      % Convert row/column to linear indices into the input matrix
)       % Index into the input matrix where each combination is a row
!p      % Take the product of each row
s       % Sum the result and implicitly display

Very impressive.

Ruby 2.4.0, 59 61 bytes
Recursive Laplace expansion:
f=->a{a.pop&.map{|n|n*f[a.map{|r|r.rotate![0..-2]}]}&.sum||1}

Less golfed:
f=->a{
  # Pop a row off of a
  a.pop&.map{ |n|
    # For each element of that row, multiply by the permanent of the minor
    n * f[a.map{ |r| r.rotate![0..-2]}]
  # Add all the results together
  }&.sum ||
  # Short circuit to 1 if we got passed an empty matrix
  1
}

Ruby 2.4 is not officially released. On earlier versions, .sum will need to be replaced with .reduce(:+), adding 7 bytes.

Julia 0.4, 73 bytes
f(a,r=1:size(a,1))=sum([prod([a[i,p[i]] for i=r]) for p=permutations(r)])

In newer versions of julia you can drop the [] around the comprehensions, but need using Combinatorics for the permutations function. Works with all Number types in Julia, including Complex. r is a UnitRange object defined as a default function argument, which can depend on previous function arguments.
Try it online!

JavaScript (ES6), 82 bytes
f=a=>a[0]?a.reduce((t,b,i)=>t+b[0]*f(a.filter((_,j)=>i-j).map(c=>c.slice(1))),0):1

Works with the empty matrix too, of course.

@ETHproductions I never learn...

Exactly my code, just published 14 hours before, I'll try to add complex numbers

Mathematica, 54 bytes
Coefficient[Times@@(#.(v=x~Array~Length@#)),Times@@v]&

Now that the empty matrices are no longer considered, this solution is valid. It originates from the MathWorld page on permanents.

@alephalpha That's a neat idea to use the rows to identify coefficients but wouldn't it break if the rows were not unique?

Pari/GP, 44 bytes
p(m)=if(#m,sum(n=1,#m,m[1,n]*p(m[^1,^n])),1)

Try it online!

Pari/GP, 50 bytes
m->polcoef(vecprod([x^2^i|i<-[0..#m-1]]*m),2^#m-1)

Based on @miles's Mathematica answer.
According to Wolfram MatheWorld, the permanent of a matrix \$A = (a_{ij})\$ is the coefficient of \$x_1 \cdots x_n\$ in the polynomial \$\prod_{i=1}^{n}\sum_{j=1}^na_{ij}x_j\$. This is exactly what miles's answer does.
But in PARI/GP there isn't an easy way to generate an arbitrary number of new variables. So instead of a list variables \$[x_1, \dots, x_n]\$, I use the \$2^i\$'th powers of a single variable \$x\$, i.e., \$[x^1, \dots, x^{2^{n-1}}]\$, and take the coefficient of \$x^1 \cdots x^{2^{n-1}} = x^{2^n-1}\$.
Try it online!

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


text:
A regex to satisfy the grammar police (there vs. their vs they're)
We've all been burned by the grammar police on the internet. What we need is a regex that can be used in place of "there", "their", and "they're". This would shift burden of grammar parsing from the writer to the reader (a sort of "client-side" grammar, if we you will). So, here's what I have to start with:
the([re]|[ir]|[y're]).
...but I'm positive there's room for optimization.
What's the shortest regex that could be used in place of any variation or the aforementioned homohpones?

Your regex isn't correct. It matches ther, thee, thei, they and the'. Can't dig up a link right now, but look up "character classes". (Followed by any character if the . is supposed to be part of the regex, but that seems like a formatting mistake.)

Bit off-topic with no objective winning criterion, but could actually be a cool challenge.

@carusocomputing I believe it's a golfing tips question which is definitely on topic.

Knot ay gud eye deal too mi. Gust rite it rite.

As worded the correct answer to the question is .*, but I'm sure that's not what you intended to ask. Also, spelling is not grammar. You should be complaining about the orthography police, not the grammar police.

There isn't a lot of room for optimisation here. This seems to be optimal:
the(y're|re|ir)

The only alternative I can think of avoids the duplication of re but ends up at the same byte count (and it's potentially worse in flavours where meta characters need to be escaped to work):
the((y')?re|ir)


text:
Shortest possible JS (ES5) code to get ids of all elements of a given tag
Using the shortest JS (ES5) code possible, as measured in number of characters, gather all the ids on a page for foobar elements into a comma-delimited string.  For example:

  <foobar id="456"></foobar>
  <foobar id="aaa"></foobar>
  <foobar id="987"></foobar>

Should give "456,aaa,987"
You cannot use ES6 or any libraries. The foobar elements will not ever be nested.
My current shortest solution is
[].map.call(document.querySelectorAll("foobar"),function(a){return a.id}).join()

Can anyone beat it?

Note that challenges that require answers to be in a specific language are generally discouraged.

@Oliver although since this challenge is based on the DOM, an argument could be made for it being JS-only

+"" saves 4 bytes over .join().

You can remove the space in between document. and querySelectorAll.

May I post a Python 2 solution just for the fun of it? I'll even flag it as non-competing :-)

@Oliver happy to make it language-independent, as long as the language can be parsed by all major browsers ;)

@Cyoke I take your point but should a good question really be that specific as to the technology to be used? There are plenty of other ways to manipulate HTML (admittedly most with external libraries) and it may have been more interesting to see how it was done in other languages and would probably have encouraged more answers. In my opinion it is not a bad challenge if it was more open and I have not downvoted. Maybe could have spent some time in the sandbox? (I didn't see it there but I may have missed it).

I don't think it's going to get shorter than this:
[].map.call(document.querySelectorAll("foobar"),function(a){return a.id})+""

Hopefully someone can prove me wrong!

You can lose the semicolon at the end to save 1

Of course -- just updated.  Thanks!