我突然真的很想打网球，可惜我没有球场！

惊喜！这是您进来的地方。

您必须为我打印一个网球场，但是由于机密原因，您必须以最少的字节数进行打印。

网球场

---------
|       |
---------
|   |   |
xxxxxxxxx
|   |   |
---------
|       |
---------

这是代码高尔夫球，因此以字节为单位的最短代码胜出！

画布，13 字节

Ａ←⁹ｗ５+7ｑ⁴‟５ｎ┼

在这里尝试！

Python 2，65个字节

s='-','|'+' '*7,'-','|   ','x'
for i in s+s[3::-1]:print(i*9)[:9]

Flp.Tkc保存了一个字节。

05AB1E，29 27 26个字节

'-9ש'|ð4׫Dûs®s¨¨ûû'x5×»û

在线尝试！

'-9ש                      Push "---------" and store it as temporary value
     '|ð4׫Dûs             Push palindromized("|    ") = "|       |"
                           and push "|    "
              ®            Push "---------" again
               s¨¨û        Strip the last 2 characters from "|    " and push palindromized("|  ") = "|   |"
                   û       Palindromize last item -> "|   |   |"
                    'x5×   Push "xxxxx"
                        »  Join everything with newlines
                         û Palindromize the result and implicitly display it

Python 3-73 72字节

d=b,a,c='|       |','-'*9,'|   |   |'
print(a,*d,'x'*9,c,a,b,a,sep='\n')

Python 3.6-75字节

x=f"{'-'*9}\n|{' '*7}|\n{'-'*9}\n|   |   |\n"
print(x,'x'*9,x[::-1],sep='')

功劳归于flp-tkc。谢谢 ：）

试试这里！

///，64 56字节

/f/---//e/   //a/fff
|ee |
fff
//d/|e|e|
/adxxxxxxxxx
da

在线尝试！

另一个56字节的解决方案：

/f/---//e/|   //a/fff
e    |
fff
//d/ee|
/adxxxxxxxxx
da

V，25个字节

9é-ÄÙÒ r|$.4äGMãlr|jj.kÒX

在线尝试！

这应该是23个字节：

9é-ÄÙÒ r|$.4äMÒXãkr|jj.

但是在创建它时遇到了一些错误。:(

果冻，25 个字节

“¡⁵÷ḞȯḤɼ’b4ị“- x|”s5ŒBŒḄY

TryItOnline！

我本来希望使用1,3,1季度的重复，但是不能将其压缩得更少（原始版本为28：）“ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY。

怎么样？

“¡⁵÷ḞȯḤɼ’b4ị“- x|”s5ŒBŒḄY - Main link: no arguments
“¡⁵÷ḞȯḤɼ’                 - base 250 number: 375116358919167
         b4               - convert to base 4:
                                [1,1,1,1,1,0,2,2,2,2,1,1,1,1,1,0,2,2,2,0,3,3,3,3,3]
           ị“- x|”        - index into character list "- x|" (1-based):
                                "-----|    -----|   |xxxxx"
                  s5      - split into chunks of length 5:
                               ["-----","|    ","-----","|   |","xxxxx"]
                    ŒB    - bounce (vectorises):
                               ["---------","|        |","---------","|   |   |","xxxxxxxxx"]
                      ŒḄ  - bounce (non-vectorising version):
                               ["---------","|        |","---------","|   |   |","xxxxxxxxx","|   |   |","---------","|        |","---------"]
                        Y - join with line feeds:
                          - implicit print

J，70 54 51 50字节

感谢Zgarb，节省了一个字节！

9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050

一些标准的压缩技术，使用压缩的RLE。

   9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050
---------
|       |
---------
|   |   |
xxxxxxxxx
|   |   |
---------
|       |
---------

Ruby，60个字节

-4.upto(4){|i|puts''.rjust(9,%w{x |%3s - |%7s -}[i.abs]%'')}

不打高尔夫球

-4.upto(4){|i|                    #iterate -4 to 4.
   puts''.rjust(9,                #Print the null string right justified to length 9 padded by repititions of
   %w{x |%3s - |%7s -}[i.abs]%'') #the string from the %w{} array modified like sprintf by the % operator
}                                 #so that %Ns is replaced by N spaces.

bash / Unix工具，58 57字节

dc<<<4o16i3FFFFp20002prp20202p15555pszpszfp|tr 0-3 ' x|-'

除换行符外，仅四个字符出现在所需的输出中，从而使每一行都可以编码为以4为底的数字。为了简洁起见，然后将这些数字以十六进制形式写入脚本中。

Unix计算器dc既可用于从16到4的转换，也可用于堆栈操作，以方便在正确的位置重复行。

编辑：通过交换用于编码字符的两个以4为基数的数字，将字节减少了一个字节，从而允许tr命令比以前的版本短一个字节。

JavaScript，85个字节

console.log('---|  ---| |xxx| |---|  ---'.replace(/(.)((.).)/g,'$1$3$3$2$3$3$3$1\n'))

JavaScript（ES6），86 84 83 81字节

由于尼尔，节省了2个字节

a=`---------
`;a+=`|       |
`+a;b=`|   |   |
`;console.log(a+b+`xxxxxxxxx
`+b+a)

备用方法＃1，93个字节

console.log('01232101242421512424210123210'.replace(/./g,n=>`-
|  x`[n].repeat('911739'[n])))

备用方法＃2，86个字节

尼尔建议：

console.log(`-${s=`
       |
-
   |
`}x${s}-`.replace(/.*/g,s=>s.repeat(9).slice(-9)))

备用方法＃3，91字节

递归方法：

console.log((f=(n,c=`xxxx
|   |   |
---------
|       |
`[n]||'-')=>~n--?c+f(n)+c:'x')(43))

SOGL 0.5，24个 23 20 字节（非竞争）

 -9*"D√⅜‘⁴"Hοr‘¹q x9*o±

说明：

"'|⁶.f,‘9n_h¹q x9*o±
"'|⁶.f,‘              pushes "------------------|       ||   |   |"
        9n            splits into chunks of 9
                       stack: [["---------","---------","|       |","|   |   |"]]
          _           puts all the contents of the array into the stack
                       stack: ["---------","|       |","---------","|   |   |"]
           h          swaps the 2nd from top with 3rd from top
            ¹         turns back into array
                       stack: [["---------","|       |","---------","|   |   |"]]
             q        outputs the array without popping it from stack
               x      push "x"
                       stack: [["---------","|       |","---------","|   |   |"], "x"]
                9*    repeat it 9 times
                       stack: [["---------","|       |","---------","|   |   |"], "xxxxxxxxx"]
                  o   output that
                   ±  reverse the array
implicitly output the reversed array

那么压缩字符串如何工作？

从base250转换为二进制的字符串是 1000000100111110010100001110100000001100010001

大概是做什么的：

100 boxstring (a custom dictionary string with chars " -/\|_\n")
000010 choose only the "-"s
01111 with length of 15+(different chars used)+2 = 18 chars
there is only 1 char type, so results in "------------------"
100 another boxsting
101000 choosing " " and "|"
01110 with length of 14+(different chars used)+2 = 18 chars
100000001100010001 the data; 0 = " " and 1 = "|"
has "------------------" and "|       ||   |   |" and just joins them together

非竞争性的，因为语言是挑战的后期。而这一挑战只有一天之久。我知道我昨天应该放点东西。我这样做是为了测试我的语言，但最终结果太好了，无法发布。可以肯定的是，它也可以打高尔夫球。

///，59个字节

/_/---------
//s/   /_|ss |
_|s|s|
xxxxxxxxx
|s|s|
_|ss |
_

在线尝试！

外出...

Javascript（ES6），86个字节：

a =`---------
| |
---------`; b =`| | |
`; console.log（a +`
`+ b +`xxxxxxxxx
`+ b + a）

在这里测试：

a=`---------
|       |
---------`;b=`|   |   |
`;console.log(a+`
`+b+`xxxxxxxxx
`+b+a)

05AB1E，26个字节

'-5ש'|4úD®sÂðñ)í€û»'x5×»û

使用CP-1252编码。在线尝试！

PHP，66 62字节

这是原始答案（66个字节）：

<?=$a="---------
|       |
---------
|   |   |
xxxx",x,strrev($a);

由于未知常数，它会发出通知x。可以通过在命令行error_reporting=0中php.ini或在命令行中设置来取消该通知：

$ php -d error_reporting=0 tennis.php

输出的最后一行不以换行符结尾。

更新后的答案（62个字节），改进了@Titus提出的改进：

<?=$a=($b="---------
|   ")."    |
$b|   |
xxxx",x,strrev($a);

在没有配置文件的情况下运行它（默认使用error_reporting=0这种方式）：

$ php -n tennis.php

这两个版本的代码都包含嵌入在字符串中的文字换行（比短1个字节\n），我们无法解包。

PHP，72字节

<?=$a="---------
",$b="|       |
$a",$c="|   |   |
","xxxxxxxxx
$c$a$b";

我几乎不喜欢它比这样的计算要短一些。

Ruby，52个字节

puts [b=[a=?-*9,"|%8s"%?|,a],c="|   |   |",?x*9,c,b]

使用double simmetry，这些行是：0-1-0 / 2-3-2 / 0-1-0，可以轻松展开循环，并且将嵌套列表在输出上展平。

Pyke，28 26 25字节

\|ddsssd7*.X--||"R\x5*nJs

在这里尝试！

       d7*                -    " " * 7
          .X--||"         -   grid(^, corners="-", sides="-", left="|", right="|")
\|dds                     -     "|  "
     s                    -    palindromise(^)
      s                   -   palindromise(^)
                  \x5*    -   "x" * 5
                      nJ  -  "\n".join(^)
                        s - palindromise(^)

05AB1E，25个字节

'-9ש'|ð4׫û®…|  ûû'x5×»û

使用CP-1252编码。在线尝试！

说明：

'-9×                       # Push "---------"
    ©                      # Store in register_c
     '|ð4׫                # Push "|    "
           û               # Palindromize, giving "|       |"
            ®              # Retrieve from register_c
             …|            # Push "|  "
                 ûû        # Palindromize twice, giving "|   |   |"
                   'x5×    # Push "xxxxx"
                       »   # Join by newlines
                        û  # Palindromize
                           # Implicit print

Vim，32个字节

9i-^[Y3pO||^[7i ^[YGPkP4lr|YpO^[9ix^[

这将把网球场打印到vim缓冲区中。^M代表Enter键（0x0d），^[是Escape键（0x1b）。您可以通过将它们保存到文件中并运行来运行这些击键/代码

vim -s <filename> -u NONE

打印到标准输出

如果必须将其打印到stdout，则可以将缓冲区保存到文件（我使用“ a”），并使用vim设置为要使用的任何外壳程序（我使用bash）以及cat程序来将网球场打印到标准输出（51字节）：

9i-^[Y3pO||^[7i ^[YGPkP4lr|YpO^[9ix^[:w!a|sil !cat %^M:q^M

与早期版本相同，但:w!a|sil !cat %^M:q^M添加到末尾

J，36个字节

9$'-'([,(' '4}]),[,],'x',:])9$'|   '

这适用于REPL，这是使用J的标准方法：

   9$'-'([,(' '4}]),[,],'x',:])9$'|   '
---------
|       |
---------
|   |   |
xxxxxxxxx
|   |   |
---------
|       |
---------

使用41个字节，我可以将结果打印到STDOUT：

echo 9$'-'([,(' '4}]),[,],'x',:])9$'|   '

在线尝试！

说明

我一次建造网球场。

9$'-'([,(' '4}]),[,],'x',:])9$'|   '
                            9$'|   '  The string repeated to length 9: y = '|   |   |'
  '-'(                     )          Apply this verb to x = '-' and y:
                     'x',:]            y with a row of 'x'-chars above it.
                                       This is a 2x9 matrix, and "," now works by
                                       prepending new rows to it.
                   ],                  Prepend another y.
                 [,                    Prepend x, which is repeated to a row of length 9.
        (' '4}]),                      Prepend y with 4th character replaced by a space.
      [,                               Prepend x again.
                                      Now we have this 6x9 matrix:
                                       ---------
                                       |       |
                                       ---------
                                       |   |   |
                                       xxxxxxxxx
                                       |   |   | 
9$                                    Repeat it to have 9 rows.

PowerShell，67 66字节

($a='-'*9)
($b="|       |")
$a
($c="|   "*2+"|")
'x'*9
$c
$a
$b
$a

在线尝试！

只是一些字符串乘法，设置变量并确保将它们封装在括号中以将副本放置在管道上。Write-Output程序完成时的默认设置使我们之间免费换行。

感谢@ConnorLSW保存了明显的字节。

Python 2，75个字节

a,b,c='-'*9,'|       |','|   |   |'
for e in[a,b,a,c,'x'*9,c,a,b,a]:print e

使用从@GurupadMamadapur借来的变量

另选75

a,b,c='-'*9,'|       |','|   |   |'
print'\n'.join([a,b,a,c,'x'*9,c,a,b,a])

Emacs，43个 35击键

M-9 x RET：九个x，返回
C-SPC：设置标记
| M-3 SPC | M-3 SPC | RET：管道，三个空格，管道，三个空格，管道，返回
M-9 - RET：九个连字符，返回
| M-7 SPC | RET：管道，七个空格，管道，返回
M-9 - RET：九个连字符，返回
C-x C-x：交换点和标记，选择区域
M-w：复制区域
C-p：前一行
C-y：猛拉复制文本
M-x rev-r RET：执行reverse-region命令

Lua，82字节。

y=[[---------
|       |
---------
]]z="|   |   |\n"io.write(y,z,"xxxxxxxxx\n",z,y)

我尝试了许多方法，但这一方法证明是胜利者。

Pushy，33个字节

这个问题有33个投票，有33个答案，所以我只需要发布一个33字节的解决方案...

9:45;T`|    `wT`|   |`4dT5:120;w"

在线尝试！

说明

该代码可以分为几部分，以使其更易于理解。第一部分的工作方式如下：

9:45;    \ Push the char '-' 9 times
T        \ Push 10, which is a linefeed
`|    `  \ Push these charcodes

现在的堆栈是：

---------
|

镜像运算符，w然后镜像整个堆栈，生成：

---------
|       |
---------

然后：

T        \ Push a linefeed
`|   |`  \ Push these chars
4d       \ Copy the last 4 characters
T        \ Push a linefeed
5:120;   \ Push the char 'x', 5 times

现在，堆栈开始看起来像网球场：

---------
|       |
---------
|   |   |
xxxxx

为了完成它，我们w再次使用镜子操作器，它可以反射此字符串以产生完整的网球场。

---------
|       |
---------
|   |   |
xxxxxxxxx
|   |   |
---------
|       |
---------

现在剩下的就是打印，这是由"角色完成的。

Unix Shell；使用dc和tr; 55字节： （Mitchell Spector解决方案的优化）

dc<<<4o16i3FFFFp20002prp20202p15555psrfrp|tr 0-3 ' x|-'

其他解决方案：使用sed; 81字节

echo "---|  ---| |xxx| |---|  ---"|sed "s/\(.\)\(.\)\(.\)/\1\2\2\2\3\2\2\2\1\n/g"

在功能中使用dc：88字节

b(){ dc<<<2o16i1${1}p|tr '01' ' '$2;};(b FF -;b 01 \|;b FF -;b 11 \|)>f;cat f;b FF X;tac f

要么

b(){ echo "obase=2;$1"|bc|tr '01' ' '$2;};(b 511 -;b 257 \|;b 511 -;b 273 \|)>f;cat f;b 511 X;tac f 

在功能中使用bc：99个字节

b(){ echo "obase=2;$1"|bc|tr '01' ' '$2;};(b 511 -;b 257 \|;b 511 -;b 273 \|)>f;cat f;b 511 X;tac f 

Powershell，56个字节

(('-'*9),'|       |'+'-'*9+'|   |   |'+'x'*9)[0..4+3..0]

说明：球场上半场

备用，68个字节

('-----','|    '+'-'*5+'|   |'+'x'*5)[($r=0..4+3..0)]|%{-join$_[$r]}

说明：季度季度对行和列显示使用相同的索引