乘坐Reading，如果您通过Go，则可获得$ 200

39

垄断委员会

对于此代码高尔夫球挑战，我们将构建棋盘游戏Monopoly。

规则：

  • 不输入任何内容。
  • 输出一个11x11电路板，其中构成该电路板的每个ASCII字符是美国版Monopoly电路板每个空格的第一个字母。
  • 字符必须用空格分隔。
  • 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
source
7
我并不是说要坚持做下去，但是……前进到木板路时如何通过围棋？
— Sp3000
4
如果您在木板路上：)
— jacksonecac
8
如果您在木板路上，那将无法获得机会卡：(
— jacksonecac
27
我让所有人都失败了
— jacksonecac
3
是否允许尾随空格？
— 阿德南

Answers:

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_`(._.)

这是拆分阶段，它将字符串分割为正则表达式的匹配项(._.)（即，_中间有a的任何三个字符）。我们将整个正则表达式放在一个组中的原因是，分割阶段也会返回捕获组的结果。如分裂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$*

这将每个下划线替换为9 1s。我们1在这里使用s而不是立即使用空格的原因是，它使接下来插入填充空格更加容易。

\B

请记住，第二行上有一个空格。这会在不是单词边界的每个位置插入一个空格，即在行的开头和结尾之外的所有位置。

1

最后，我们也将所有这些替换1为空格。

— 马丁·恩德
source
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.
— 丹尼斯
source
5
感谢您的详细解释。看到对高尔夫问题进行编码的答案背后的过程总是很有趣的。:)
— XtraSimplicity
11
代码高尔夫球-它是完全正常的，看到了一些在底座250和基地23
— corsiKa
好的压缩技术。为什么需要移调？
— ETHproductions '16
@ETHproductions Jelly没有填充原子，因此我可以手动将所有行的空格都填充为相同的长度，或者使用z带填充符的二进位zip（）。
— 丹尼斯
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ô）。我们得到以下二维数组：

[['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编码。在线尝试！

— 阿德南
source
3
用0而不是D压缩会保存一个字节•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»
— Emigna '16
@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可以通过元组拆包节省一个字节(*'...',)。

— 异或
source
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
source
9

的Javascript ES6 REPL，105个 102 101字节

这里没有发生什么有趣的事情。粘贴在控制台中以查看所需结果

@Arnauld节省了3个字节@Neil
节省了1个字节

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

显示代码段

— 低音提琴（Bassdrop Cumberwubwubwub）
source
我认为REPL不被允许。
— NoOneIsHere
— 马丁·恩德
1
我设法剃了另一个字节。1用空格替换s并使用此正则表达式代替：.replace(/.( ?)/g,`$& `+`$1`.repeat(17))
— Neil 2016年
1a=>a-1?a.repeat(18):a+' '
— 删除
@尼尔，谢谢，爱你的方法！
— 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个字节！

— 暴民埃里克
source
@ETHproductions链接错误？我不能保存任何这样的字节。
— 暴民埃里克（Erik the Outgolfer）
如果您删除G第一行和最后一行中s 之后的空格，这不是98个字节吗？
— Emigna
1
— 暴民埃里克（Erik the Outgolfer）
1
我知道@Emigna，但是确切的输出包含它们，所以我不会删除它们。
— 暴民埃里克（Erik the Outgolfer）
不好，试试这个。
— ETHproductions
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>回到正常模式。此时，光标在last的第三行上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 regex：

:%s/./& /g

意思是：

:%          " On any line
  s/        " Substitute
    ./      " Any character with
      & /   " That same character and a space
         g  " Allow for multiple substitutions on the same line
— DJMcMayhem
source
4

R，149146字节

不太令人印象深刻，但也不确定如何打高尔夫球。利用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")

小提琴

— 比利沃伯
source
4

Python 2，108个字节

与其他python答案略有不同，不使用替换，仅使用字符串连接。

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))
— 场
source
1
我知道拉链是前进的方向！早在118之前就已经有几乎相同的解决方案，并且打算在今晚打高尔夫球。我错过了地图。猜猜你击败了我。+1
— ElPedro '16
4

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'
— 唐·黑斯廷斯
source
2字节更短的（但基本上是相同的代码作为你）： perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'。（用\n字面换行符替换为90）。
— 达达
@Dada Ahhh，好多了！谢谢！
— Dom Hastings
“好极了”本来可以找到一个40字节的解决方案，但非常感谢：D
— Dada
4

Jolf，72个字节

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

全部替换♣为\x05，或在这里尝试！

Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."..."wΖhζ♣
Ζ0                                   ζ = 0
   ,ahtht"111"                       a box of width&height 11, with borders "1"
  ρ           '.d                    replace each char in that string with...
                 ?=H♣                 is it a space?
                     Q♣                if so, return two spaces.
                                      otherwise
                        ."..."         get the Nth member of this string
                              wΖhζ      where N = (++ζ) - 1
                       +          ♣      and add a space to the end

这给出了所需的字符串。

— 科纳·奥布莱恩
source
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。

取消测试代码：

在这里尝试。

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
— 凯文·克鲁伊森
source
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
@BassdropCumberwubwubwub嗯，这在“垂直墙”之间仅输出3个空格，而不是19 。
— 凯文·克鲁伊森
因此，我的笔记中应该有更多空间，s但是stackexchange删除了它们。这是ideone，现在甚至是142字节
— Bassdrop Cumberwubwubwub 16-10-19
@BassdropCumberwubwubwub好的。不知道你在两人之间进行了交流s=" "。在这种情况下，它确实更短。并且.‌​replace(""," ").replace("_",s);可以.replace("_",s).‌​replace(""," ");改为额外的-8个字节
— Kevin Cruijssen
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个字节）
— 数字结
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
— 英里
source
使用通用字符串压缩所能获得的最好结果是90个字节：(' ',@,.~]);._1';FKCIIBAVWMG;N_P;T_N;C_C;S_P;P_S;V_C;S_P;E_L;S_B;JCVCORIBCMG'rplc'_';9#' '
— Conor O'Brien
@ 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 Answer相同。

说明（\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)
— Mego
source
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（inner Select）。在每个字符后附加一个空格，然后Join返回11个字符串。最后一个Join换行符。

— 吴连杰
source
3

露比（92）

完整程序，使用以下命令打印到标准输出 $> <<

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

总共有40个字母要绘制。字母10到28在换行符或' '*19。之后交替出现。之前和之后的字母由单个空格分隔。

— 水准河圣
source
3

Perl，115112字节

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并在其后添加了空格（因此.不会被解释为十进制）

— 加布里埃尔·贝纳米（Gabriel Benamy）
source
您仍然可以节省一些字节：s/(.)/\1 /可以替换为s/./$& /。删除最后的分号。使用say而不是print（为此，您需要添加-M5.010或使用-E而不是-e，但是两者都是免费的（请参阅此处））。文字换行符，而不是\n。
— 达达
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)
— 卡德
source
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)如果您想更简单一点，也可以使用不使用join的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个字节。（replace的参数是'！'，而不是'！'。）
— 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
— 尼尔
source
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 "
— 添泰
source
1
感谢@NiCkNewman，但我实际上已经在此站点上使用了很多次-codegolf.stackexchange.com/search?q=GameMaker
— Timtech，2016年
我想，我正在考虑GDScript从Godot游戏引擎以某种语言进行操作。但是，不确定是否可以：)
— NiCk Newman
嗯，如果董事会更大的话；string_repeat(" ",19)与的长度相同" "。
— u54112 16-10-23
1
@NiCkNewman应该可以，请告诉我您是否写了一些:)
— Timtech '16
@lastresort我知道... GML允许将事物粉碎在一起的技巧，但是它的命令太冗长了……
— Timtech '16
2

点，64字节

63个字节的代码，+ 1表示-S标志。

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

在线尝试！

说明

使用的运算符：

  • . （二进制）连接（在列表上逐项操作）。
  • X（二进制）字符串乘法。（s是一个预初始化为的变量" "。）
  • ^ （一元）将字符串拆分为字符列表。
  • .*是将字符串拆分为字符的另一种方法。它由unary组成.，后者是字符串上的*空操作，与meta-operator 配对，后者将一元运算符映射到其（可迭代）操作数中的每个项目。使用.*"..."可以使我们节省一个字节(^"...")-括号将是必需的，因为.它的优先级高于^。
  • 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
source
2

C，171156字节

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

也输出尾随换行符...可能还可以打高尔夫球。

— 克莱布朗
source
2

Perl 5，92 86字节

  • 多亏了达达，节省了6个字节

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

使用sprintf，填充和字符串重复运算符x。

— 辛巴克
source
不错的解决方案。您可以保存几个字节，虽然：替换\n用文字换行，你不需要之间的空间x操作和后面的号码，最后替换split//,xxx用xxx=~/./g。
— 达达
1

Haskell中，128个 125 114字节

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

在这里尝试

  • ((:" ")=<<)是concatMap (\a -> [a,' '])-通过在输入的每个字母后面添加空格来填充
— 昂斯
source
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
— 疯狂的
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.