Монопольный совет

Для этого испытания кода-гольфа мы будем строить настольную игру «Монополия».

Правила:

• Не принимайте никаких данных.
• Выведите доску 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

Редактировать Вау! вам, ребята, наверняка понравился этот! :)

Сетчатка , 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

И, наконец, мы заменяем все эти 1s пробелами.

Желе , 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 байт

Спасибо Emigna за сохранение байта!

•(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ô). Мы получаем следующий 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 копий буквы-плюс-пробел, затем новая строка . Это также используется для первой и последней строки. У него есть пробел.
• Внутренняя строка символа, затем символ, которому предшествуют 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 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
òÍ./& 

Попробуйте онлайн!

Поскольку этот кодекс содержит не-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 байта благодаря @ Дада !

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 .

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

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

Полная программа, печать в стандартный вывод $> <<

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». Не удалось извлечь кавычки из последней строки из-за предшествующей новой строки, которая Я не мог найти где-нибудь еще.

Редактировать 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, 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переменная, предварительно инициализированная для " ".)
• ^ (Унарный) разбивает строку в список символов.
• .*это еще один способ разбить строку на символы. Он состоит из унарных символов ., которые не могут использоваться в строках в паре с *мета-оператором, который отображает унарный оператор для каждого элемента в его (повторяемом) операнде. Использование .*"..."позволяет сохранить байт поверх (^"...")- скобки потребуются, поскольку .приоритет выше, чем ^.
• 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 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++);}

Выводит также и нового персонажа новой строки ... Возможно, это еще немного.

Perl 5, 92 86 байт

• спасло 6 байтов благодаря Dada

$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"]

Попробуй здесь

• ((:" ")=<<)is 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