Монопольна рада

Для цієї проблеми з кодовим гольфом ми будуватимемо настільну гру Monopoly.

Правила:

• Не беруть ніяких даних.
• Виведіть дошку 11х11, де кожен символ 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

Редагувати Вау! ви, впевнені, сподобався цей! :)

Сітківка , 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_`(._.)

Це розділена стадія, яка розбиває рядок навколо збігів регулярного виразів (._.)(тобто будь-яких трьох символів із символом _у середині). Причина, по якій ми ставимо цілий регекс в групу, полягає в тому, що розділені стадії також повертають результати захоплення груп. Напр. Розщеплення 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тут використовуємо s замість пробілів, полягає в тому, що це полегшує вставлення пробілів поруч.

\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

Потім прибираємо залишилися прогалини і замінити символи нового рядка з буквою 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

Потім ми перетворюємо цей цифровий масив з біективної бази 23 в ціле число.

54580410997367796180315467139871590480817875551696951051609467717521

Тепер ми перетворюємо це ціле число в біективну базу 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

Нарешті, ми використовуємо ці цифри для індексації на кодовій сторінці Jelly .

£ċ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 байт

Дякуємо Еміньї за збереження байта!

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

Пояснення:

Спочатку деяке стиснення. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•- стислий варіант наступного номера:

120860198958186421497710412212513392855208073968557051584380118734764403017

Після цього це перетворюється в базу 33 , що призводить до наступного рядка:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Нулі замінюються 9 пробілами , використовуючи наступний код ¾9ð×:. Після цього Sрозбиваємо рядок на символи і нарізаємо їх на шматочки з 11 елементів (зроблено з 11ô). Ми отримуємо такий двовимірний масив:

[['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 примірників літер плюс-пробіл, потім новий рядок. Він також використовується для першого та останнього рядка. У ньому є простір.
• Внутрішня лінія символу, потім символ перед 19 символами пробілів, потім новий рядок. Копіюється 9 разів для центральних ліній.

Python 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 просторів і невелике повторення, інакше не вистачало місця для їх гольфу. Ця рядок залишається на конвеєрі, а вихід через неявне 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 реплєї , 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 

Спробуйте в Інтернеті!

З якоїсь загадкової причини, здається, є відсталі місця після Gс. Без них мій код був би 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
òÍ./& 

Спробуйте в Інтернеті!

Оскільки цей кодекс містить символи, що не належать до ASCII, ось шестнадцятковий:

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

Тепер ми використовуємо стислий вираз, щоб замінити кожен символ цим символом і пробілом. Ось та Í./&частина. Це перекладається на наступний вираз vim:

:%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 байт

Трохи інший, ніж інші відповіді python, не використовуючи жодної заміни, приєднується лише рядок.

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'

Джольф, 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 .

Невикористаний і тестовий код:

Спробуйте тут.

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"#@%

Спробуйте в Інтернеті!

Ця програма працює за тим самим основним принципом, що і відповідь Python 2 xnor .

Пояснення (нові рядки замінені \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 байт

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 

Перший і останній рядки виводу мають пробіли. Код використовує заміни регулярних виразів і те, що якщо об'єкти не визначені, вони інтерпретуються як рядки (наприклад, FKCIIBAVWMG трактується як "FKCIIBAVWMG". Не вдалося взяти лапки з останнього рядка через попередній рядок, який Я не міг фіксувати більше ніде.

Edit 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 байт

Пітон 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, 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 "

Піп , 64 байти

63 байти коду, +1 для -Sпрапора.

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

Спробуйте в Інтернеті!

Пояснення

Використовувані оператори:

• . (бінарні) конкатенати (оперує пунктами в списках).
• X(двійкові) рядкові множиться. ( sє змінною, попередньо ініціалізованою до" " .)
• ^ (unary) розбиває рядок на список символів.
• .*це ще один спосіб розділити рядок на символи. Він складається з унарного ., який є *неоперативним рядком у парі з метаоператором, який відображає одинарний оператор на кожен елемент у його (ітерабельному) операнді. Використання .*"..."дозволяє нам зберегти байт на (^"...")- скобки будуть потрібні, оскільки .пріоритет вище, ніж^ .
• 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 байт завдяки Даді

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

Використання sprintf, підкладка та оператор повторення струн x.

Haskell, 128 125 114 байт

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

Спробуйте тут

• ((:" ")=<<)є concatMap (\a -> [a,' '])- колодки, додаючи пробіл за кожною буквою у своєму введенні

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