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

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

Правила:

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

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

code-golf string ascii-art kolmogorov-complexity board-game jacksonecac
источник

7

Я не хочу быть приверженцем, но ... как пройти Го, продвигаясь к Boardwalk?

Sp3000

4

Если вы на променаде :)

jacksonecac

8

Который вы не можете получить шанс карты, если вы находитесь на променаде :(

jacksonecac

27

Я подвел вас всех

jacksonecac

3

Разрешены ли пробелы?

Аднан

36

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

Помните, что во второй строке есть пробел. Это вставляет пробел в каждую позицию, которая не является границей слова, то есть везде, кроме начала и конца строк.

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

Мартин Эндер
источник

1

Хорошая работа! Это было быстро!

Jacksonecac

39

+1 за (._.).

Разрушаемый Лимон

^ собирался сказать, что ахха

джазбой

25

Желе , 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.

Деннис
источник

5

Спасибо за подробное объяснение. Всегда интересно наблюдать за процессом ответов на вопросы по коду. :)

XtraSimplicity

11

Код Гольф - там, где совершенно нормально видеть число в базе 250 и в базе 23.

corsiKa

Хорошая техника сжатия. Почему транспонирование необходимо?

ETHproductions

@ETHproductions У Jelly нет атома заполнения, поэтому я могу либо вручную дополнить все строки пробелами одинаковой длины, либо использовать двоичный zip ( z) с заполнителем.

Деннис

16

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 . Попробуйте онлайн!

Аднан
источник

3

Сжатие с 0 вместо D сохраняет байт•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»

Emigna

@ Emigna Ах, это умно! Благодарность :).

Аднан

12

Python 2, 89 байт

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

Создает шаблон

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

подставить в буквы через форматирование строки. Шаблон использует два типа линий:

Внешняя строка lиз 11 копий буквы-плюс-пробел, затем новая строка . Это также используется для первой и последней строки. У него есть пробел.
Внутренняя строка символа, затем символ, которому предшествуют 19 символов пробела, а затем символ новой строки. Это скопировано 9 раз для центральных линий.

Python 3.5 может сохранить байт с распаковкой кортежа (*'...',).

XNOR
источник

1

Переход на Python 3.5 должен сохранить байт.

Деннис

9

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

AdmBorkBork
источник

9

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>

Развернуть фрагмент

Bassdrop Cumberwubwubwub
источник

Я не думаю, что REPL разрешено.

NoOneIsHere

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

Мартин Эндер,

1

Мне удалось сбрить еще один байт. Замените 1s пробелами и используйте вместо этого следующее регулярное выражение:.replace(/.( ?)/g,`$& `+`$1`.repeat(17))

Neil

Другой способ избавиться от другого байта - заменить 1s пробелами и использовать вместо этого эту функцию:a=>a-1?a.repeat(18):a+' '

ETHproductions

@ Нейл спасибо, люблю твой подход!

Bassdrop Cumberwubwubwub

7

/// , 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 байта каждый!

Эрик Outgolfer
источник

@ETHproductions Возможно, неправильная ссылка? Я не могу сохранить ни одного такого байта.

Эрик Outgolfer

Разве это не 98 байт, если вы удалите пробел после Gs в первой и последней строке?

Emigna

1

@Emigna Целая дискуссия о лишних

Эрик Outgolfer

1

@ Emigna Я знаю, но точный вывод содержит их, поэтому я не буду их удалять.

Эрик Outgolfer

Мой плохой, попробуй это .

ETHproductions

6

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"пишет строки на сетке. последний "был приемлемым

Разрушаемый Лимон
источник

5

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

DJMcMayhem
источник

4

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-скрипка

Billywob
источник

4

Python 2, 108 байт

Немного отличается от другого ответа Python, не используя замен, только строковые объединения.

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

TFeld
источник

1

Я знал, что почтовый индекс - это путь вперед! Было почти то же самое решение до 118 ранее и собирался сыграть в гольф этим вечером. Я скучал по карте. Думаю, ты побил меня этим. +1

ElPedro

4

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'

Дом Гастингс
источник

2 байт короче (но в основном тот же код , как вы): perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'. (Замените \nбуквальными символами новой строки, чтобы получить 90).

Дада

@ Dada Ааа, намного лучше! Благодарность!

Дом Гастингс

"очень приятно" было бы найти 40-байтовое решение, но спасибо: D

Dada

4

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

Это дает желаемую строку.

Конор О'Брайен
источник

3

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

Кевин Круйссен
источник

1

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

за 150 (обратите внимание, что stackexchange удаляет лишние пробелы)

Bassdrop Cumberwubwubwub

@BassdropCumberwubwubwub Умм ... это выводит только 3 пробела между «вертикальными стенами» вместо 19 .. Вот идеон вашего кода.

Кевин Круйссен

Отсюда мое примечание, в нем должно быть больше пробелов, sно stackexchange удалил их. Вот идеон , теперь даже на 142 байта

Bassdrop Cumberwubwubwub

@BassdropCumberwubwubwub А, хорошо. Не знал, что вы между s=" ". В этом случае это действительно короче. И .‌replace(""," ").replace("_",s);может быть .replace("_",s).‌replace(""," ");вместо этого для дополнительных -8 байтов

Кевин Круйссен

1

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

( 131 байт )

Numberknot

3

Befunge, 120 байт

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

Первая строка содержит строку, которая должна быть напечатана в обратном порядке (похоже, что это не так, но код идет в обратном направлении в этой строке). Вторая строка печатает верхний и нижний ряды. Третья строка и левая сторона четвертой строки печатают средние строки, а небольшой фрагмент в правом нижнем углу делает интересную вещь: он перемещает курсор назад во вторую строку, чтобы распечатать последнюю строку, но после ее завершения он квиты.

Как видно из первой строки, строки разделены пробелами, чтобы различать первую, среднюю и последнюю строки. Пробелы могут быть чем угодно, и если бы я использовал символы ASCII 0-9, я бы легко сохранил 4 байта. $, Который вы видите - это просто символ мусора, который должен быть там и может быть заменен на что угодно, кроме пробела.

источник

3

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

миль
источник

Лучшее, что я мог бы получить, используя обычное сжатие строк, составляет 90 байт:(' ',@,.~]);._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 Да, сложно сжать струны гольфа в J, когда в других языках есть словари и встроенное сжатие.

миль

@ ConorO'Brien Я попробовал немного поиграть в твою идею и довел ее до 76 байт_11,@,.&' '\'FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG'rplc'_';9#' '

миль

3

На самом деле , 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)

Мего
источник

3

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символ новой строки.

Ссылка Ng
источник

3

Руби, 92

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

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

Всего 40 сюжетов. Буквы с 10 по 28 чередуются между последующим переводом строки или ' '*19. Более ранние и поздние буквы разделены пробелами.

Уровень реки St
источник

3

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и добавления пробела после этого (чтобы их .не интерпретировали как десятичную)

Габриэль Бенами
источник

Вы все еще можете сохранить несколько байтов: s/(.)/\1 /можно заменить на s/./$& /. Оставьте последнюю точку с запятой. Используйте sayвместо print(для этого вам нужно либо добавить, -M5.010либо использовать -Eвместо -e, но оба они бесплатны (см. Здесь )). Буквальные переводы строк вместо \n.

Дада

3

Древесный уголь , 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 байт

ASCII-только
источник

2

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)

Када
источник

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)также 116 байтов без использования соединения, если вы хотите быть более простым. Альтернативно, 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)это 115 байт, если разрешены пробелы в конце. (Аргумент для замены - «!» Вместо «!».)

MichaelS

2

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

Нил
источник

2

Язык 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 "

Timtech
источник

1

Спасибо @NiCkNewman, но я уже несколько раз использовал его на этом сайте - codegolf.stackexchange.com/search?q=GameMaker

Timtech

Понятно, я думал о том, чтобы сделать что-то на GDScriptязыке Godotигрового движка. Но, не уверен, что это будет хорошо :)

NiCk Newman

Ах, если бы только доска была больше; string_repeat(" ",19)такой же длины, как " ".

u54112

1

@NiCkNewman Это должно быть хорошо, скажи мне, если ты напишешь :)

Timtech

@lastresort Я знаю ... GML позволяет трюки с разбиванием вещей вместе, но его команды настолько многословны ...

Timtech

2

Пип , 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флаг объединяет подсписки в пробелах и основной список в новых строках, давая желаемый результат.

DLosc
источник

2

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

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

cleblanc
источник

2

Perl 5, 92 86 байт

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

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

Использует sprintf, заполнение и оператор повтора строки x.

simbabque
источник

Хорошее решение. Однако вы можете сохранить несколько байтов: заменяет \nбуквальными символами новой строки, вам не нужны пробелы между xоператором и последующим числом, и, наконец, заменяете split//,xxxна xxx=~/./g.

Дада

1

Haskell, 128 125 114 байтов

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

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

((:" ")=<<)is concatMap (\a -> [a,' '])- дополняет, добавляя пробел после каждой буквы в своем входе

Angs
источник

1

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

Mazzy
источник

Прокатитесь на Рединге, если вы сдадите Go, соберите $ 200

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

Правила:

Ответы:

Сетчатка , 74 байта

объяснение

Желе , 44 байта

идея

Код

05AB1E , 48 47 байт

Python 2, 89 байт

PowerShell v2 +, 131 123 114 110 99 байт

Javascript ES6 REPL , 105 102 101 байт

/// , 100 98 байт

Turtlèd , 72 байта

V , 75, 62 , 59 байтов

R 149 146 байт

Python 2, 108 байт

Perl, 90 байт

использование

Джольф, 72 байта

Java 7, 177 165 142 131 байт

Befunge, 120 байт

J, 77 73 байта

объяснение

На самом деле , 74 байта

C # 6, 192 190 байт

Руби, 92

Perl, 115 112 байт

Древесный уголь , 66 байт

Python 2, 116 байт

Пакет, 171 байт

Язык GameMaker, 148 байт

Пип , 64 байта

объяснение

C 171 156 Bytes

Perl 5, 92 86 байт

Haskell, 128 125 114 байтов

Powershell, 95 байт

объяснение