De repente tengo muchas ganas de jugar al tenis, ¡pero por desgracia no tengo cancha!

¡Sorpresa! Aquí es donde tu entras.

Debes imprimir una cancha de tenis para mí, pero debes hacerlo en la menor cantidad de bytes posible por razones confidenciales.

Pista de tenis

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

Este es el código de golf , por lo que gana el código más corto en bytes.

Lienzo , 13 bytes.

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

Pruébalo aquí!

Python 2, 65 bytes

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

Flp.Tkc guardó un byte.

05AB1E ,29 27 26 bytes

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

Pruébalo en línea!

'-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 bytes

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

Python 3.6 - 75 bytes

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

El crédito va a flp-tkc . Gracias :)

¡Intenta aquí!

/// , 64 56 bytes

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

Pruébalo en línea!

Otra solución de 56 bytes:

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

V , 25 bytes

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

Pruébalo en línea!

Esto debería ser de 23 bytes:

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

Pero me encontré con varios errores al crearlo. :(

Jalea , 25 bytes

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

TryItOnline!

Tenía la esperanza de usar la repetición de la cancha de 1,3,1 cuartos, pero no puedo exprimirlo en menos (una versión en bruto es 28:) “ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY.

¿Cómo?

“¡⁵÷ḞȯḤɼ’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 bytes

¡Ahorré un byte gracias a Zgarb!

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

Alguna técnica de compresión estándar, utilizando un RLE comprimido.

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

Rubí, 60 bytes.

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

Sin golf

-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.

herramientas bash / Unix, 58 57 bytes

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

Solo aparecen cuatro caracteres distintos de la nueva línea en la salida deseada, lo que permite que cada línea se codifique como un número base-4. Estos números se escriben en hexadecimal en el guión, por brevedad.

La calculadora Unix dc se usa tanto para la conversión de base 16 a base 4 como para la manipulación de la pila para permitir una fácil repetición de líneas en los lugares correctos.

Editar: se eliminó un byte intercambiando dos de los dígitos de base 4 utilizados para codificar caracteres, lo que permite que el comando tr sea un byte más corto que la versión anterior.

JavaScript, 85 bytes

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

JavaScript (ES6), 86 84 83 81 bytes

Guardado 2 bytes, gracias a Neil

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

Método alternativo # 1, 93 bytes

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

Método alternativo # 2, 86 bytes

Sugerido por Neil:

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

Método alternativo # 3, 91 bytes

Un enfoque recursivo:

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

SOGL 0.5 , 24 23 20 bytes (no competidor)

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

Explicación:

"'|⁶.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

Entonces, ¿cómo funciona la cadena comprimida?

La cadena convertida de base250 a binario es 1000000100111110010100001110100000001100010001

y aproximadamente lo que hace:

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

no competitiva, porque el lenguaje es posterior al desafío. Y este desafío tiene solo un día. Sabía que debería haber puesto algo ayer. Hice esto como prueba de mi idioma y resultó demasiado bueno para no publicar. Estoy bastante seguro de que esto es más golfable también.

/// , 59 bytes

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

Pruébalo en línea!

Superado ...

Javascript (ES6), 86 bytes:

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

Prueba aquí:

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

05AB1E , 26 bytes

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

PHP, 66 62 bytes

Esta es la respuesta original (66 bytes):

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

Genera un aviso debido a la constante desconocida x. El aviso se puede suprimir mediante el establecimiento error_reporting=0de php.inio en la línea de comandos:

$ php -d error_reporting=0 tennis.php

La última línea de la salida no termina con un carácter de nueva línea.

La respuesta actualizada (62 bytes), mejorando una mejora sugerida por @Titus:

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

Ejecútelo sin un archivo de configuración (por defecto error_reporting=0es así):

$ php -n tennis.php

Ambas versiones del código contienen nuevas líneas literales incrustadas en la cadena (1 byte más corto que \n) y no podemos desenvolverlas.

PHP, 72 bytes

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

Casi odio cuando es más corto así que con calcular un poco.

Ruby, 52 bytes

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

Usando la doble simetría, las líneas son: 0-1-0 / 2-3-2 / 0-1-0el bucle se puede desenrollar fácilmente y la lista anidada se aplana en la salida.

Pyke, 28 26 25 bytes

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

Pruébalo aquí!

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

05AB1E, 25 bytes

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Explicación:

'-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 bytes

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

Esto imprimirá la cancha de tenis en un búfer vim. ^Mrepresenta la tecla Enter (0x0d) y ^[es la tecla Escape (0x1b). Puede ejecutar estas pulsaciones de teclas / código guardándolos en un archivo y ejecutando

vim -s <filename> -u NONE

Imprimir en stdout

Si tiene que imprimirse en stdout en su lugar, puede guardar el búfer en un archivo (usé "a") y usar el shell vimconfigurado para usar (usé bash) así como el catprograma para imprimir la cancha de tenis en stdout (51 bytes):

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

Es lo mismo que la versión anterior pero con :w!a|sil !cat %^M:q^Magregado al final

J, 36 bytes

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

Esto funciona en REPL, que es la forma estándar de usar J:

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

Con 41 bytes , puedo imprimir el resultado en STDOUT:

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

Pruébalo en línea!

Explicación

Construyo la cancha de tenis una fila a la vez.

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 bytes

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

Pruébalo en línea!

Solo un poco de multiplicación de cadenas, configuración de variables y garantía de que están encapsuladas en parens para colocar copias en la tubería. El valor predeterminado Write-Outputal finalizar el programa nos proporciona nuevas líneas de forma gratuita.

Gracias a @ConnorLSW por guardar un byte obvio.

Python 2, 75 bytes

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

Utiliza variables prestadas de @GurupadMamadapur

Alternativa también para 75

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

Emacs, 43 35 pulsaciones de teclas

M-9 x RET: nueve x, retorno
C-SPC: marca establecida
| M-3 SPC | M-3 SPC | RET: tubería, tres espacios, tubería, tres espacios, tubería, retorno
M-9 - RET: nueve guiones, retorno
| M-7 SPC | RET: tubería, siete espacios, tubería, retorno
M-9 - RET: nueve guiones, retorno
C-x C-x: punto de cambio y marca, selección de región
M-w: copiar región
C-p: línea anterior
C-y: extraer texto copiado
M-x rev-r RET: ejecutar reverse-regioncomando

Lua, 82 bytes.

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

Probé muchos métodos, pero este resultó ser el vencedor.

Pushy , 33 bytes

Esta pregunta tenía 33 votos a favor, y había 33 respuestas, así que solo tuve que publicar una solución de 33 bytes ...

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

Pruébalo en línea!

Explicación

El código se puede dividir en varias partes, para que sea más fácil de entender. La primera parte funciona así:

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

La pila es ahora:

---------
|

El operador espejo w, luego refleja toda la pila, produciendo:

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

Entonces:

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

La pila ahora comienza a parecerse a la cancha de tenis:

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

Para terminar, usamos el operador de espejo wuna vez más, que refleja esta cuerda para producir la cancha de tenis completa.

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

Todo lo que queda ahora es imprimir, lo que hace el "personaje.

Unix Shell; usando dc y tr; 55 Bytes: (Optimización de la solución Mitchell Spector)

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

Otras soluciones: Uso de sed; 81 bytes;

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

Usando dc en función: 88 Bytes

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

o

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 

Usando bc en función: 99 Bytes

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 bytes

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

Explicación: la mitad de la cancha directa

Alternativa, 68 bytes

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

Explicación: el cuarto de la cancha utiliza los mismos índices para la visualización de filas y columnas