Hội đồng độc quyền

Đối với thử thách chơi gôn mã này, chúng tôi sẽ xây dựng trò chơi cờ Monopoly.

Quy tắc:

• Không có đầu vào.
• Xuất ra một bảng 11x11 trong đó mỗi ký tự ASCII tạo thành bảng là chữ cái đầu tiên của mỗi không gian của phiên bản Hoa Kỳ của bảng Monopoly.
• Các ký tự phải được phân cách bằng dấu cách.
• Go nên bắt đầu ở phía dưới bên phải.

Chuỗi chính xác để sản xuất là

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 

Lưu ý rằng từ dưới cùng bên phải xuống dưới bên trái hình vuông như sau:

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

Chỉnh sửa Wow! Các bạn chắc chắn thích cái này! :)

Võng mạc , 74 byte

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

1

Dòng thứ ba đến cuối cùng và cuối cùng nên chứa một khoảng trắng.

Hãy thử trực tuyến!

Giải trình

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Điều này thay thế đầu vào (trống) bằng chuỗi trên dòng thứ hai.

S_`(._.)

Đây là giai đoạn phân chia, phân tách chuỗi xung quanh các kết quả khớp của biểu thức chính quy (._.)(nghĩa là, bất kỳ ba ký tự nào có một _ở giữa). Lý do chúng tôi đặt toàn bộ regex trong một nhóm là các giai đoạn phân chia cũng trả về kết quả của các nhóm bắt giữ. Ví dụ, chia tách abcdxung quanh bccho [a, d], nhưng chia nó xung quanh b(c)cho [a, c, d]. Bằng cách này, chúng tôi nhận được tất cả các ._.phần trên các dòng riêng biệt nhưng cũng có các phần 11 ký tự ở đầu và cuối. Chúng tôi sử dụng _tùy chọn để bỏ qua các kết quả trống giữa các ._.trận đấu riêng lẻ . Kết quả sẽ là thế này:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Tiếp theo chúng tôi xử lý dấu gạch dưới:

_
9$*

Điều này thay thế mỗi dấu gạch dưới bằng chín 1s. Lý do chúng tôi sử dụng 1s ở đây thay vì khoảng trắng ngay lập tức là vì nó giúp dễ dàng chèn các khoảng trống đệm tiếp theo.

\B

Hãy nhớ rằng có một khoảng trống trên dòng thứ hai. Điều này chèn một khoảng trắng ở mọi vị trí không phải là ranh giới từ, nghĩa là ở mọi nơi ngoại trừ ở đầu và cuối dòng.

1

Và cuối cùng, chúng tôi cũng thay thế tất cả những thứ đó 1bằng không gian.

Thạch , 44 byte

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

Hãy thử trực tuyến!

Ý kiến

Nếu chúng ta loại bỏ mỗi cột thứ hai và hoán chuyển các hàng bằng các cột, chúng ta sẽ nhận được bảng sau.

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

Bây giờ, chúng ta có thể xoay mỗi cột một đơn vị sang phải, di chuyển tất cả các không gian còn lại sang phải.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Sau đó, chúng tôi loại bỏ các không gian còn lại và thay thế linefeeds bằng chữ D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Bây giờ, chúng tôi thay thế mỗi chữ cái bằng chỉ mục dựa trên 1 trong bảng chữ cái.

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

Sau đó, chúng tôi chuyển đổi mảng chữ số này từ cơ sở tính toán 23 sang số nguyên.

54580410997367796180315467139871590480817875551696951051609467717521

Bây giờ, chúng tôi chuyển đổi số nguyên này thành cơ sở sinh học 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

Cuối cùng, chúng tôi sử dụng các chữ số này để lập chỉ mục vào trang mã của Jelly .

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

Đây là dữ liệu được mã hóa mà chúng tôi sẽ đưa vào chương trình ( 29 byte ). Để tạo ra đầu ra mong muốn, chúng ta chỉ cần đảo ngược các bước trên.

Mã

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

Cảm ơn Emigna vì đã tiết kiệm một byte!

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

Giải trình:

Đầu tiên một số nén. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•là phiên bản nén của số sau:

120860198958186421497710412212513392855208073968557051584380118734764403017

Sau đó, điều này được chuyển đổi thành cơ sở 33 , kết quả là chuỗi sau:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Các số 0 được thay thế bằng 9 khoảng trắng , sử dụng đoạn mã sau ¾9ð×:. Sau đó, chúng tôi Sghép chuỗi thành các ký tự và cắt chúng thành các phần của 11 phần tử (được thực hiện với 11ô). Chúng tôi nhận được mảng 2 chiều sau:

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

Chúng tôi tạo lưới cho mảng này với »và xuất nó hoàn toàn.

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Python 2, 89 byte

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

Tạo mẫu

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

để thay thế trong các chữ cái thông qua định dạng chuỗi. Mẫu sử dụng hai loại dòng:

• Dòng ngoài lcủa 11 bản sao của dấu cộng, sau đó là một dòng mới. Nó cũng được sử dụng cho dòng đầu tiên và cuối cùng. Nó có một không gian dấu.
• Dòng bên trong của một nhân vật, sau đó là một nhân vật đi trước 19 ký tự của không gian đệm, sau đó là một dòng mới. Nó được sao chép 9 lần cho các đường trung tâm.

Python 3.5 có thể lưu một byte với bộ giải nén tuple (*'...',).

PowerShell v2 +, 131 123 114 110 99 byte

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

Đây chỉ là một chuỗi chữ với dòng mới đặt trên đường ống, với một chút -replaceở cuối để biến 0thành 19không gian. Các dòng đầu tiên và cuối cùng chỉ là nguyên văn. Chỉ với 10 không gian và ít sự lặp lại, không có đủ chỗ để chơi gôn. Chuỗi này được để lại trên đường ống và đầu ra thông qua ẩn Write-Outputxảy ra khi hoàn thành chương trình.

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

REPL ES6 , 105 102 101 byte

Không có nhiều điều thú vị xảy ra ở đây. Dán vào bàn điều khiển để xem kết quả mong muốn

Đã lưu 3 byte nhờ @Arnauld
Đã lưu thêm 1 byte nhờ @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 byte

/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 

Hãy thử trực tuyến!

Vì một lý do bí ẩn nào đó, dường như có những khoảng trống sau Gs. Không có chúng, mã của tôi sẽ là 96 byte.

Cảm ơn 42545 (ETHproductions) và 56258 (daHugLenny) vì đã giảm 1 byte mỗi!

Turtlèd , 72 byte

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

Dùng thử trực tuyến

>xoay rùa, "foo"viết chuỗi trên lưới. cuối cùng "là tuyệt vời

V , 75, 62 , 59 byte

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

Hãy thử trực tuyến!

Vì codel này chứa các ký tự không phải ASCII, nên đây là một 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..../& 

Giải trình. Đầu tiên, chúng tôi nhập văn bản sau:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Sau đó, chúng tôi <esc>trở lại chế độ bình thường. Tại thời điểm này, con trỏ nằm trên dòng thứ ba trên dòng cuối cùng G. Thuận tiện, có một lệnh để đặt chúng tôi trên cột đầu tiên của dòng ngay phía trên con trỏ. Lệnh đó là -. Sau đó, khi chúng tôi kết thúc trên dòng thứ hai (trên N), chúng tôi chạy vòng lặp sau:

ò9á lli
ò

Giải trình:

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

Bây giờ, bộ đệm trông như thế này:

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

Bây giờ chúng tôi sử dụng regex nén để thay thế từng ký tự bằng ký tự đó và khoảng trắng. Đó là Í./&một phần. Điều này dịch sang regex vim sau:

:%s/./& /g

Nghĩa là:

:%          " 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 byte

Không quá ấn tượng nhưng cũng không chắc chắn làm thế nào điều này sẽ được chơi golf. Khai thác pastebằng cách nào đó là phỏng đoán đầu tiên của tôi. So sánh với văn bản thô là 241 byte.

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

Python 2, 108 byte

Khác một chút so với câu trả lời trăn khác, không sử dụng thay thế, chỉ tham gia chuỗi.

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

Perl, 90 byte

Cách tiếp cận khá nhàm chán, không thể nghĩ ra cách nào tốt hơn để giảm ... Yêu cầu -Ekhông mất thêm chi phí. Xuất ra một không gian bổ sung ở cuối mỗi dòng. -2 byte nhờ @Dada !

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

Sử dụng

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

Jolf, 72 byte

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

Thay thế tất cả ♣bằng\x05 , hoặc thử nó ở đây!

Ζ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

Điều này cho chuỗi mong muốn.

Java 7, 177 165 142 131 byte

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 byte nhờ @BassdropCumberwubwubwub .
-11 byte nhờ @Numberjack .

Mã thử nghiệm & mã hóa:

Hãy thử nó ở đây.

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

Đầu ra:

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 byte

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

Dòng đầu tiên có chuỗi được in ngược lại (có vẻ như không phải vậy, nhưng mã đang đi ngược lại trên dòng đó). Dòng thứ hai in các hàng trên cùng và dưới cùng. Dòng thứ ba và bên trái của dòng thứ tư in các hàng ở giữa và phần nhỏ ở dưới cùng bên phải thực hiện một điều thú vị: nó di chuyển con trỏ trở lại hàng thứ hai để in ra dòng cuối cùng, nhưng sau khi hoàn thành nó, nó bỏ cuộc.

Như bạn có thể thấy trên dòng đầu tiên, các chuỗi được phân tách bằng khoảng trắng để phân biệt giữa các hàng đầu tiên, giữa và cuối cùng. Các khoảng trắng có thể là bất cứ thứ gì khác và nếu tôi sử dụng các ký tự ASCII 0-9, tôi có thể dễ dàng lưu 4 byte. $ Bạn thấy chỉ là một ký tự rác phải ở đó và có thể được thay thế bằng bất cứ thứ gì ngoại trừ một khoảng trắng.

J, 77 73 byte

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

Lưu ý rằng 43 byte, hơn một nửa tổng số, được sử dụng chỉ cho chuỗi ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'.

Giải trình

Đầu tiên, lập danh sách

   |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

Sau đó thực hiện bảng thời gian của nó

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

Sau đó kiểm tra sự bằng nhau bằng không

   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

Làm phẳng nó, tìm các khoản tiền tích lũy và nhân số nguyên tố

   ,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

Sau đó tham gia với các số không, chia nó thành các danh sách con có độ dài 22, thả phần đầu của mỗi danh sách con và sử dụng các giá trị làm chỉ mục trong chuỗi ' 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

Trên thực tế , 74 byte

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

Hãy thử trực tuyến!

Chương trình này hoạt động theo nguyên tắc cơ bản giống như câu trả lời Python 2 của xnor .

Giải thích (dòng mới thay thế \ncho rõ ràng):

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

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

Không có dấu vết không gian; mà không theo dõi dòng mới.

Một giải pháp đơn giản. Bắt đầu với chuỗi ký tự. Replace !bằng 9 dấu cách. Sau đó Splitthành 11 chuỗi bởi ~và hơn nữa charlà s (bên trong Select). Nối một khoảng trắng cho mỗi ký tự, sau đó Joinquay lại 11 chuỗi. Cuối cùng khác Joinbởi nhân vật dòng mới.

Ruby, 92

Chương trình đầy đủ, in ra thiết bị xuất chuẩn $> <<

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

Có 40 chữ cái để cốt truyện. Chữ 10 đến 28 xen kẽ giữa được theo sau bởi một dòng mới hoặc ' '*19. Các chữ cái trước và sau được phân tách bằng khoảng trắng đơn.

Perl, 115 112 byte

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

Tạo đầu ra sau:

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 

Các hàng đầu tiên và cuối cùng của đầu ra có một khoảng trắng ở cuối. Mã này sử dụng thay thế regex và thực tế là nếu các đối tượng không được xác định, chúng được hiểu là các chuỗi (ví dụ: FKCIIBAVWMG được coi là "FKCIIBAVWMG". Tôi không thể làm hỏng bất cứ nơi nào khác.

Chỉnh sửa 1: Đã lưu 3 byte bằng cách thay thế " "bằng $", xóa dấu ngoặc ngoài và chèn khoảng trắng sau khi in và xóa dấu ngoặc đơn xung quanh $"x19và thêm khoảng trắng sau đó (vì vậy .sẽ không được hiểu là số thập phân)

Than , 66 byte

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

Hãy thử trực tuyến!

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

Không lọc, 36 byte

Python 2, 116 byte

Khá đơn giản, vì bất kỳ lý do gì mặc dù việc thay thế chuỗi quá dài dòng, đó là điều tốt nhất tôi có thể nghĩ ra. Có thể sử dụng recó thể ngắn hơn.

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)

Mẻ, 171 byte

@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

Ngôn ngữ GameMaker, 148 byte

Tôi biết nó khá cơ bản, nhưng tôi không nghĩ rằng điều này có thể đánh bại trong 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 byte

63 byte mã, +1 cho -Scờ.

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

Hãy thử trực tuyến!

Giải trình

Toán tử sử dụng:

• . (nhị phân) concatenates (vận hành item-khôn ngoan trong danh sách).
• X(nhị phân) chuỗi bội. ( slà một biến được preinitialized thành " ".)
• ^ (unary) chia một chuỗi thành một danh sách các ký tự.
• .*là một cách khác để chia một chuỗi thành các ký tự. Nó bao gồm unary ., là một chuỗi không có op, được ghép nối với *toán tử meta, ánh xạ một toán tử đơn nguyên cho từng mục trong toán hạng (lặp lại) của nó. Việc sử dụng .*"..."cho phép chúng tôi lưu một byte qua (^"...")- các dấu ngoặc đơn sẽ được yêu cầu vì .có độ ưu tiên cao hơn ^.
• PEchuẩn bị một yếu tố cho một danh sách. AEnối một phần tử vào danh sách

Với nền tảng đó, đây là mã từng bước:

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

Khi kết quả này được tự động in, -Scờ sẽ tham gia danh sách phụ trên khoảng trắng và danh sách chính trên dòng mới, đưa ra đầu ra mong muốn.

C, 171 156 byte

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

Cũng tạo ra một nhân vật dòng mới theo dõi ... Có lẽ có thể bị đánh gôn thêm một chút.

Perl 5, 92 86 byte

• đã lưu 6 byte nhờ Dada

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

Sử dụng sprintf, đệm và toán tử lặp lại chuỗi x.

Haskell, 128 125 114 byte

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

Hãy thử nó ở đây

• ((:" ")=<<)là concatMap (\a -> [a,' '])- các miếng đệm bằng cách thêm một khoảng trắng đằng sau mỗi chữ cái trong đầu vào của nó

Powershell, 95 byte

Lấy cảm hứng từ câu trả lời của @ admBorkBork .

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

Giải trình

Toán tử thay thế đầu tiên làm cho hình chữ nhật 11x11.

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

Toán tử thay thế thứ hai chèn một khoảng trắng sau mỗi ký tự. Kết quả có dấu cách.

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