คณะกรรมการการผูกขาด

สำหรับความท้าทายของรหัส - กอล์ฟเราจะสร้างเกมกระดานผูกขาด

กฎ:

• ไม่มีการป้อนข้อมูล
• เอาท์พุทบอร์ด 11x11 โดยที่แต่ละตัวอักขระ ASCII ที่สร้างบอร์ดเป็นตัวอักษรตัวแรกของแต่ละช่องว่างของบอร์ดผูกขาดเวอร์ชั่นอเมริกา
• อักขระต้องถูกคั่นด้วยช่องว่าง
• Go ควรเริ่มที่ด้านล่างขวา

สตริงที่แน่นอนในการผลิตคือ

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 

โปรดทราบว่าจากล่างขวาไปซ้ายล่างของช่องสี่เหลี่ยมมีดังนี้:

G --> Go
M --> Mediterranean Avenue
C --> Community Chest
B --> Baltic Avenue
I --> Income Tax
...
J --> Jail

แก้ไข Wow! พวกคุณแน่ใจว่าชอบอันนี้! :)

เรติน่า 74 ไบต์

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG
S_`(._.)
_
9$*
\B

1

บรรทัดที่สามถึงสุดท้ายและบรรทัดสุดท้ายควรมีเว้นวรรคเดียว

ลองออนไลน์!

คำอธิบาย

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

สิ่งนี้แทนที่อินพุต (ว่าง) ด้วยสตริงบนบรรทัดที่สอง

S_`(._.)

นี่คือสเตจแยกซึ่งแยกสตริงรอบ ๆ การแข่งขันของ regex (._.)(นั่นคืออักขระสามตัวใด ๆ ที่มี a _ตรงกลาง) เหตุผลที่เราใส่ regex ทั้งหมดลงในกลุ่มก็คือสเตจแยกจะส่งคืนผลลัพธ์ของกลุ่มการดักจับ เช่นแยกabcdไปรอบ ๆbcให้[a, d]แต่แยกไปรอบ ๆให้b(c) [a, c, d]ด้วยวิธีนี้เราจะได้รับ._.ชิ้นส่วนทั้งหมดในบรรทัดแยกต่างหาก แต่ยังรวมถึงชิ้นส่วน 11 ตัวอักษรที่จุดเริ่มต้นและจุดสิ้นสุด เราใช้_ตัวเลือกเพื่อละเว้นผลลัพธ์ที่ว่างเปล่าระหว่างการ._.แข่งขันแต่ละรายการ ผลลัพธ์จะเป็นดังนี้:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

ต่อไปเราจะประมวลผลขีดล่าง:

_
9$*

สิ่งนี้จะแทนที่ขีดล่างแต่ละอันด้วยเก้า1วิ เหตุผลที่เราใช้1ที่นี่แทนช่องว่างในทันทีคือทำให้ง่ายต่อการแทรกช่องว่างภายในต่อไป

\B

โปรดจำไว้ว่ามีช่องว่างในบรรทัดที่สอง สิ่งนี้จะแทรกช่องว่างในทุกตำแหน่งที่ไม่ใช่ขอบเขตของคำเช่นที่ใดก็ได้ยกเว้นที่จุดเริ่มต้นและจุดสิ้นสุดของบรรทัด

1

และในที่สุดเราก็แทนที่1ช่องว่างทั้งหมดด้วย

เยลลี่ขนาด 44 ไบต์

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

ลองออนไลน์!

ความคิด

หากเราลบทุก ๆ คอลัมน์ที่สองและสลับแถวด้วยคอลัมน์เราจะได้บอร์ดต่อไปนี้

FNTCSPVSESJ
K         C
C         V
I         C
I         O
B         R
A         I
V         B
W         C
M         M
GPNCPSCPLBG

ตอนนี้เราสามารถหมุนแต่ละคอลัมน์หนึ่งหน่วยไปทางขวาย้ายช่องว่างที่เหลือทั้งหมดไปทางขวา

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

จากนั้นเราจะเอาช่องว่างที่เหลืออยู่และแทนที่ linefeeds ด้วยตัวอักษรD

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

ตอนนี้เราแทนที่ตัวอักษรแต่ละตัวด้วยดัชนี 1 ตัวในตัวอักษร

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

จากนั้นเราแปลงอาเรย์หลักจากฐาน bijective 23เป็นจำนวนเต็ม

54580410997367796180315467139871590480817875551696951051609467717521

ตอนนี้เราแปลงจำนวนเต็มนี้ไปยังฐาน bijective 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

สุดท้ายเราใช้ตัวเลขเหล่านี้เพื่อดัชนีลงในหน้ารหัสของวุ้น

£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ

นี่คือข้อมูลที่เข้ารหัสที่เราจะรวมไว้ในโปรแกรม ( 29 ไบต์ ) ในการสร้างผลลัพธ์ที่ต้องการเราเพียงแค่ย้อนกลับขั้นตอนข้างต้น

รหัส

“£ċ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.

05AB1E , 48 47 ไบต์

ขอบคุณEmigna ที่บันทึกไบต์!

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

คำอธิบาย:

ก่อนการบีบอัดบางอย่าง •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•เป็นรุ่นที่บีบอัดของหมายเลขต่อไปนี้:

120860198958186421497710412212513392855208073968557051584380118734764403017

หลังจากนั้นสิ่งนี้จะถูกแปลงเป็นฐาน 33ซึ่งส่งผลให้เป็นสตริงต่อไปนี้:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

zeroes จะถูกแทนที่ด้วย9 ช่องว่าง¾9ð×:การใช้รหัสต่อไปนี้ หลังจากนั้นเราจะSแปลงสตริงเป็นตัวอักษรและแบ่งออกเป็นชิ้นส่วนของ11องค์ประกอบ (ทำด้วย11ô) เราได้อาร์เรย์ 2 มิติดังต่อไปนี้:

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

เราจัดตารางอาร์เรย์นี้ด้วย»และเอาท์พุทมันโดยปริยาย

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!

Python 2, 89 ไบต์

l='%s '*11+'\n'
print(l+'%s%20s\n'*9+l)%tuple("FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG")

สร้างเทมเพลต

? ? ? ? ? ? ? ? ? ? ? 
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
? ? ? ? ? ? ? ? ? ? ? 

เพื่อแทนที่ตัวอักษรผ่านการจัดรูปแบบสตริง เทมเพลตใช้บรรทัดสองประเภท:

• บรรทัดด้านนอกlจำนวน 11 สำเนาของ letter-plus-space แล้วขึ้นบรรทัดใหม่ มันยังใช้สำหรับบรรทัดแรกและบรรทัดสุดท้าย มันมีพื้นที่ต่อท้าย
• บรรทัดภายในของอักขระจากนั้นอักขระนำหน้าด้วยช่องว่างการเว้นวรรค 19 อักขระจากนั้นบรรทัดใหม่ มันถูกคัดลอก 9 ครั้งสำหรับเส้นกึ่งกลาง

งูหลาม 3.5 (*'...',)สามารถบันทึกไบต์ที่มีการเปิดออก

PowerShell v2 +, 131 123 114 110 99 ไบต์

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

นี่เป็นเพียงสตริงตัวอักษรที่มีบรรทัดใหม่วางอยู่บนไพพ์ไลน์และ-replaceท้ายที่สุดจะเปลี่ยน0เป็น19ช่องว่าง บรรทัดแรกและบรรทัดสุดท้ายเป็นเพียงคำต่อคำ ด้วยพื้นที่ว่างเพียง 10 แห่งและการทำซ้ำเล็ก ๆ น้อย ๆ เป็นอย่างอื่นจึงไม่มีที่ว่างพอสำหรับเล่นกอล์ฟ สตริงนี้ถูกปล่อยไว้ที่ไพพ์ไลน์และเอาต์พุตผ่านทาง implicit Write-Outputเกิดขึ้นเมื่อโปรแกรมเสร็จสิ้น

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 ไบต์

ไม่น่าสนใจมากที่เกิดขึ้นที่นี่ วางในคอนโซลเพื่อดูผลลัพธ์ที่ต้องการ

บันทึกแล้ว 3 ไบต์ขอบคุณ @Arnauld
บันทึกอีก 1 ไบต์ขอบคุณ @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>

/// , 100 98 ไบต์

/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 

ลองออนไลน์!

ด้วยเหตุผลลึกลับบางอย่างดูเหมือนจะมีช่องว่างต่อท้ายหลังจากGs หากไม่มีรหัสของฉันจะมีขนาด 96 ไบต์

ขอบคุณ42545 (ETHproductions)และ56258 (daHugLenny)สำหรับการลด 1 ไบต์ต่อครั้ง!

Turtlèd , 72 ไบต์

"K C I I B A V W M G">"GPNCPSCPLBG">"G M C B I R O C V C J">"JSESVPSCTNF

ลองออนไลน์

>หมุนเต่า"foo"เขียนสตริงบนกริด สุดท้าย"เป็นที่น่าสงสัย

V , 75, 62 , 59 ไบต์

iFKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG-ò9á lli
òÍ./& 

ลองออนไลน์!

เนื่องจาก codel นี้มีอักขระที่ไม่ใช่ ASCII นี่คือ 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..../& 

คำอธิบาย อันดับแรกเราป้อนข้อความต่อไปนี้:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

จากนั้นเรา<esc>กลับสู่โหมดปกติ ณ จุดนี้เคอร์เซอร์จะอยู่ที่บรรทัดที่สามในGที่สุด สะดวกมีคำสั่งให้เราอยู่ในคอลัมน์แรกของบรรทัดด้านบนเคอร์เซอร์ -คำสั่งที่ จากนั้นเมื่อเราสิ้นสุดในบรรทัดที่สอง (บนN) เราจะเรียกใช้ลูปต่อไปนี้:

ò9á lli
ò

คำอธิบาย:

ò           " 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

ตอนนี้บัฟเฟอร์มีลักษณะดังนี้:

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG

ตอนนี้เราใช้ regex ที่ถูกบีบอัดเพื่อแทนที่อักขระแต่ละตัวด้วยอักขระและช่องว่าง นั่นเป็นÍ./&ส่วนหนึ่ง นี่แปลเป็น vim regex ต่อไปนี้:

:%s/./& /g

ซึ่งหมายความว่า:

:%          " 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 ไบต์

ไม่ค่อยประทับใจเท่าไหร่นัก แต่ก็ไม่แน่ใจเหมือนกันว่าจะเป็นอย่างไร การเอารัดเอาเปรียบpasteเป็นการคาดเดาครั้งแรกของฉัน เปรียบเทียบกับข้อความแบบดิบของ 241 ไบต์

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-ซอ

Python 2, 108 ไบต์

แตกต่างเล็กน้อยจากคำตอบของงูหลามอื่น ๆ โดยไม่ใช้แทนที่เพียงสตริงเข้าร่วม

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))

Perl, 90 ไบต์

วิธีการที่น่าเบื่อไม่สามารถคิดวิธีที่ดีกว่าในการลด ... ต้อง-Eไม่มีค่าใช้จ่ายเพิ่มเติม ส่งออกพื้นที่เพิ่มเติมในตอนท้ายของทุกบรรทัด -2 ไบต์ขอบคุณ@Dada !

say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr

การใช้

perl -E 'say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'

Jolf, 72 ไบต์

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

แทนที่ทั้งหมด♣ด้วย\x05หรือลองที่นี่!

Ζ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

สิ่งนี้จะทำให้สตริงที่ต้องการ

Java 7, 177 165 142 131 ไบต์

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 ไบต์ขอบคุณที่@BassdropCumberwubwubwub
-11 ไบต์ขอบคุณที่@Numberknot

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

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());
  }
}

เอาท์พุท:

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

Befunge ขนาด 120 ไบต์

<v"FKCIIBAVWMG NPTNCCSPPSVCSPELSB $JCVCORIBCMG "
:<,*48 ,_v#-*48<
>1-:#v_\,>$52*, :48*-!#v_,54*
^,*84<         ^p19*88$<

บรรทัดแรกมีสตริงที่จะพิมพ์แบบย้อนกลับ (ดูเหมือนว่ามันจะไม่ แต่รหัสจะย้อนกลับในบรรทัดนั้น) บรรทัดที่สองพิมพ์แถวบนและแถวล่าง บรรทัดที่สามและด้านซ้ายของบรรทัดที่สี่พิมพ์แถวกลางและอันเล็ก ๆ ที่ด้านล่างขวาทำสิ่งที่น่าสนใจ: มันเลื่อนเคอร์เซอร์กลับไปที่แถวที่สองเพื่อพิมพ์บรรทัดสุดท้าย แต่หลังจากจบมัน ลาออก

อย่างที่คุณเห็นในบรรทัดแรกสตริงจะถูกคั่นด้วยช่องว่างเพื่อแยกความแตกต่างระหว่างแถวแรกกลางและแถวสุดท้าย ช่องว่างสามารถเป็นอย่างอื่นได้และถ้าฉันใช้อักขระ ASCII 0-9 ฉันสามารถบันทึกได้ 4 ไบต์อย่างง่ายดาย $ ที่คุณเห็นเป็นเพียงอักขระขยะที่ต้องอยู่ที่นั่นและสามารถแทนที่ด้วยอะไรก็ได้ยกเว้นที่ว่าง

J, 77 73 ไบต์

' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5

โปรดทราบว่า 43 ไบต์ซึ่งมากกว่าครึ่งหนึ่งของทั้งหมดถูกใช้สำหรับสตริง' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'เท่านั้น

คำอธิบาย

ก่อนอื่นทำรายการ

   |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

จากนั้นทำตารางเวลา

   */~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

จากนั้นทดสอบความเสมอภาคด้วยศูนย์

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

จากนั้นเข้าร่วมกับศูนย์แยกเป็นรายการย่อยที่มีความยาว 22 วางส่วนหัวของแต่ละรายการย่อยและใช้ค่าเป็นดัชนีในสตริง ' 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

ที่จริงแล้ว 74 ไบต์

"%s"9⌐α' j;"%s%20s"9α'
j(k'
j"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%

ลองออนไลน์!

โปรแกรมนี้จะทำงานออกจากหลักการพื้นฐานเดียวกับ XNOR ของงูหลาม 2 คำตอบ

คำอธิบาย (บรรทัดใหม่ถูกแทนที่ด้วย\nเพื่อความชัดเจน):

"%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)

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))));

ไม่มีพื้นที่ต่อท้าย ขึ้นบรรทัดใหม่

ทางออกที่ตรงไปตรงมา เริ่มต้นด้วยสตริงตัวอักษร Replace !โดย 9 ช่องว่าง จากนั้นSplitเป็น 11 สายโดย~และต่อไปยังchars (ภายในSelect) ต่อท้ายช่องว่างกับอักขระแต่ละตัวจากนั้นJoinกลับไปที่ 11 สตริง ในที่สุดก็อีกJoinตัวละครขึ้นบรรทัดใหม่

ทับทิม, 92

โปรแกรมเต็มรูปแบบพิมพ์เพื่อ stdout โดยใช้ $> <<

40.times{|i|$><<"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"[i]+(i%29>9?[$/,' '*19][i%2]:' ')}

มีตัวอักษรทั้งหมด 40 ตัวที่จะลงจุด จดหมาย 10-28 ' '*19สลับกันระหว่างถูกตามด้วยการขึ้นบรรทัดใหม่หรือ ตัวอักษรก่อนหน้าและหลังจะแยกด้วยช่องว่างเดียว

Perl, 115 112 ไบต์

print FKCIIBAVWMG=~s/(.)/\1 /gr.NPTNCCSPPSVCSPELSB=~s/(.)(.)/"\n$1".$"x19 .$2/gre."\nJCVCORIBCMG"=~s/(.)/\1 /gr;

สร้างเอาต์พุตต่อไปนี้:

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 

แถวแรกและแถวสุดท้ายของเอาต์พุตมีช่องว่างต่อท้าย รหัสใช้ประโยชน์จากการแทนที่ regex และความจริงที่ว่าถ้าวัตถุไม่ได้กำหนดไว้พวกเขาจะถูกตีความว่าเป็นสตริง (เช่น FKCIIBAVWMG จะถือว่าเป็น "FKCIIBAVWMG" ไม่สามารถนำเครื่องหมายคำพูดออกจากแถวสุดท้ายเนื่องจากการขึ้นบรรทัดใหม่ ฉันไม่สามารถฟิงเกิ้ลที่อื่น

แก้ไข 1: บันทึก 3 ไบต์โดยแทนที่" "ด้วย$"ลบวงเล็บด้านนอกและแทรกช่องว่างหลังจากพิมพ์และลบวงเล็บรอบ ๆ$"x19และเพิ่มช่องว่างหลังจากนั้น (ดังนั้น.จะไม่ถูกตีความว่าเป็นทศนิยม)

ถ่าน , 66 ไบต์

Ｂ²¹¦¹¹F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN

ลองออนไลน์!

Box(21, 11, 'F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN').

ไม่ใช่การแข่งขันขนาด 36 ไบต์

Python 2, 116 ไบต์

ค่อนข้างตรงไปตรงมาไม่ว่าด้วยเหตุผลอะไรก็ตามถึงแม้ว่าการเปลี่ยนสายจะเป็นสิ่งที่ดีที่สุดที่ฉันจะได้รับ อาจใช้reอาจจะสั้นกว่า

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)

แบตช์ 171 ไบต์

@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

GameMaker Language, 148 ไบต์

ฉันรู้ว่ามันค่อนข้างธรรมดา แต่ฉันไม่คิดว่าจะสามารถเอาชนะได้ใน 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 "

Pip , 64 ไบต์

รหัส 63 ไบต์ +1 สำหรับการ-Sตั้งค่าสถานะ

.*"NTCSPVSES".sX19.^"PNCPSCPLB"PE^"FKCIIBAVWMG"AE^"JCVCORIBCMG"

ลองออนไลน์!

คำอธิบาย

ผู้ประกอบการที่ใช้:

• . (ไบนารี) ต่อกัน (ดำเนินรายการตามรายการ)
• X(ไบนารี) สตริงคูณ ( sเป็นตัวแปรที่กำหนดค่า" "เริ่มต้นเป็น)
• ^ (unary) แยกสตริงออกเป็นรายการอักขระ
• .*เป็นอีกวิธีในการแบ่งสตริงเป็นอักขระ ประกอบด้วย unary .ซึ่งเป็น no-op บนสตริงที่จับคู่กับตัวดำเนินการ*meta ซึ่งแมปตัวดำเนินการ unary กับแต่ละรายการในตัวถูกดำเนินการ (iterable) ใช้.*"..."ช่วยให้เราประหยัดไบต์มากกว่า(^"...")วงเล็บ --the จะต้องเพราะเป็นลำดับความสำคัญสูงกว่า.^
• PEผนวกองค์ประกอบเข้ากับรายการ AEผนวกองค์ประกอบเข้ากับรายการ

ด้วยพื้นหลังนั้นนี่คือรหัสทีละขั้นตอน:

.*"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]]

เมื่อผลลัพธ์นี้ถูกพิมพ์โดยอัตโนมัติการ-Sตั้งค่าสถานะจะรวมรายการย่อยในช่องว่างและรายการหลักในการขึ้นบรรทัดใหม่โดยให้ผลลัพธ์ที่ต้องการ

C, 171 156 ไบต์

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++);}

ส่งออกอักขระขึ้นบรรทัดใหม่ที่ต่อท้ายเช่นกัน ... อาจจะลงสนามได้มากกว่านี้อีกเล็กน้อย

Perl 5, 92 86 ไบต์

• บันทึกไปแล้ว 6 ไบต์ด้วย Dada

$a="%s "x11;printf"$a
"."%s%20s
"x9 .$a,FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG=~/./g

ใช้รองและผู้ประกอบการสตริงซ้ำsprintfx

Haskell, 128 125 114 ไบต์

mapM(putStrLn.((:" ")=<<))$"FKCIIBAVWMG":zipWith(\a b->a:"         "++[b])"NTCSPVSES""PNCPSCPLB"++["JCVCORIBCMG"]

ลองที่นี่

• ((:" ")=<<)is concatMap (\a -> [a,' '])- pads โดยการเพิ่มช่องว่างด้านหลังตัวอักษรทุกตัวในอินพุต

Powershell, 95 ไบต์

แรงบันดาลใจจาก @ AdmBorkBork ของคำตอบ

'FKCIIBAVWMG
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
JCVCORIBCMG'-replace0,(' '*9)-replace'.','$0 '

คำอธิบาย

11x11ผู้ประกอบการครั้งแรกแทนที่ทำให้สี่เหลี่ยมผืนผ้า

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
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