De repente, quero muito jogar tênis, mas infelizmente não tenho quadra!

Surpresa! É aqui que você entra.

Você precisa imprimir uma quadra de tênis para mim, mas precisa fazê-lo no menor número possível de bytes por motivos confidenciais.

Quadra de tênis

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

Isso é código-golfe , então o código mais curto em bytes vence!

Tela , 13 bytes

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

Experimente aqui!

Python 2, 65 bytes

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

Flp.Tkc salvou um byte.

05AB1E ,29 27 26 bytes

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

Experimente online!

'-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='')

O crédito vai para flp-tkc . Obrigado :)

Tente aqui!

/// , 64 56 bytes

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

Experimente online!

Outra solução de 56 bytes:

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

V , 25 bytes

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

Experimente online!

Isso deve ter 23 bytes:

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

Mas encontrei vários erros ao criá-lo. :(

Gelatina , 25 bytes

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

TryItOnline!

Eu esperava usar a repetição de 1,3,1 quarto de quadra, mas não posso comprimir isso em menos (uma versão bruta é 28:) “ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY.

Quão?

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

Guardou um byte graças ao Zgarb!

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

Alguma técnica de compactação padrão, usando um RLE compactado.

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

Ruby, 60 bytes

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

Ungolfed

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

ferramentas bash / Unix, 58 57 bytes

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

Apenas quatro caracteres diferentes de nova linha aparecem na saída desejada, permitindo que cada linha seja codificada como um número base-4. Esses números são então escritos em hexadecimal no script, por questões de brevidade.

A calculadora Unix dc é usada para a conversão de base 16 em base 4 e para manipulação de pilha, para permitir fácil repetição de linhas nos lugares certos.

Editar: Raspe um byte, trocando dois dos dígitos da base 4 usados ​​para codificar caracteres, permitindo que o comando tr seja um byte menor que a versão 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

Economizou 2 bytes, graças 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

Uma abordagem recursiva:

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

SOGL 0,5 , 24 23 20 bytes (não concorrente)

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

Explicaçã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

Então, como a string compactada funciona?

A sequência convertida de base250 em binário é 1000000100111110010100001110100000001100010001

e aproximadamente o que faz:

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

não concorrente, porque o idioma é posterior ao desafio. E esse desafio tem apenas um dia de vida. Eu sabia que deveria ter colocado algo ontem. Fiz isso como um teste para o meu idioma e acabou bom demais para não ser publicado. Certamente isso também é mais jogável.

/// , 59 bytes

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

Experimente online!

Outgolfed ...

Javascript (ES6), 86 bytes:

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

Teste aqui:

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

05AB1E , 26 bytes

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

Usa a codificação CP-1252 . Experimente online!

PHP, 66 62 bytes

Esta é a resposta original (66 bytes):

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

Ele gera um aviso por causa da constante desconhecida x. O aviso pode ser suprimida, definindo error_reporting=0em php.iniou na linha de comando:

$ php -d error_reporting=0 tennis.php

A última linha da saída não termina com um caractere de nova linha.

A resposta atualizada (62 bytes), melhorando uma melhoria sugerida por @Titus:

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

Execute-o sem um arquivo de configuração (o padrão é o error_reporting=0seguinte):

$ php -n tennis.php

Ambas as versões do código contêm novas linhas literais incorporadas na string (1 byte menor que \n) e não podemos desembrulhar.

PHP, 72 bytes

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

Eu quase odeio quando é mais curto assim do que com um pouco de cálculo.

Ruby, 52 bytes

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

Usando a simetria dupla, as linhas são:, 0-1-0 / 2-3-2 / 0-1-0o loop pode ser facilmente desenrolado e a lista aninhada é achatada na saída.

Pyke, 28 26 25 bytes

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

Experimente aqui!

       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×»û

Usa a codificação CP-1252 .Experimente online!

Explicação:

'-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^[

Isso imprimirá a quadra de tênis em um buffer vim. ^Mrepresenta a tecla Enter (0x0d) e ^[é a tecla Escape (0x1b). Você pode executar essas teclas / códigos salvando-os em um arquivo e executando

vim -s <filename> -u NONE

Imprimir em stdout

Se tiver que ser impresso no stdout, você poderá salvar o buffer em um arquivo (eu usei "a") e usar o shell que vimestiver configurado para usar (eu usei bash), bem como o catprograma para imprimir a quadra de tênis para stdout (51 bytes):

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

É o mesmo que a versão anterior, mas :w!a|sil !cat %^M:q^Madicionada ao final

J, 36 bytes

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

Isso funciona no REPL, que é a maneira padrão de usar J:

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

Com 41 bytes , posso imprimir o resultado em STDOUT:

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

Experimente online!

Explicação

Construo a quadra de tênis uma linha de cada 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

Experimente online!

Apenas uma multiplicação de cadeias, definindo variáveis ​​e garantindo que elas sejam encapsuladas em parênteses para colocar cópias no pipeline. O padrãoWrite-Output na conclusão do programa nos fornece novas linhas de graça.

Agradecemos ao @ConnorLSW por salvar um byte óbvio.

Python 2, 75 bytes

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

Usa variáveis ​​emprestadas de @GurupadMamadapur

Alternativa também para 75

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

Emacs, 43 35 pressionamentos de teclas

M-9 x RET: nove x's, return
C-SPC: set mark
| M-3 SPC | M-3 SPC | RET: pipe, três espaços, pipe, três espaços, pipe, return
M-9 - RET: nove hífens, return
| M-7 SPC | RET: pipe, sete espaços, pipe, return
M-9 - RET: nove hífens, return
C-x C-x: exchange point and mark, selecionando a região
M-w: copiar região
C-p: linha anterior
C-y: arrancar texto copiado
M-x rev-r RET: executar reverse-regioncomando

Lua, 82 bytes.

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

Eu tentei muitos métodos, e ainda assim este foi o vencedor.

Pushy , 33 bytes

Essa pergunta teve 33 votos positivos e houve 33 respostas, então eu apenas tive que postar uma solução de 33 bytes ...

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

Experimente online!

Explicação

O código pode ser dividido em várias partes, para facilitar a compreensão. A primeira parte funciona assim:

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

A pilha está agora:

---------
|

O operador de espelho w, em seguida, espelha toda a pilha, produzindo:

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

Então:

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

A pilha agora está começando a se parecer com a quadra de tênis:

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

Para finalizar, usamos o operador de espelho wmais uma vez, o que reflete essa corda para produzir a quadra de tênis completa.

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

Tudo o que resta agora é imprimir, o que é feito pelo "personagem.

Shell Unix; usando dc e tr; 55 bytes: (Otimização da solução Mitchell Spector)

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

Outras soluções: Using sed; 81 bytes;

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

Usando a função dc: 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

ou

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 a função bc: 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]

Explicação: meia-quadra direta

Alternativa, 68 bytes

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

Explicação: o quarto de quadra usa os mesmos índices para a exibição de linhas e colunas