Juguemos tenis

45

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 , por lo que gana el código más corto en bytes.

Daniel
fuente
1
¿Nueva línea final permitida?
Erik the Outgolfer
1
¿Se pueden hacer los espacios grandes en las filas 2 y 8 usando pestañas?
FlipTack
3
@ Flp.Tkc, no lo creo. Creo que como nadie más en las seis respuestas ya publicadas lo sabía, sería injusto.
Daniel
2
¡Este es un desafío sorprendentemente complicado para una cadena de salida tan corta! Me gusta. :)
Lynn
77
Puedes llamar a este desafío una "cancha de Dennis" ya que todos saben quién ganará de todos modos ... :)
RudolfJelin

Respuestas:

13

Python 2, 65 bytes

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

Flp.Tkc guardó un byte.

Lynn
fuente
Eso es un corte loco. ¡Agradable!
Gurupad Mamadapur
¡Puedes usar '|'+' '*7la segunda cadena spara guardar un byte!
FlipTack
12

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
Osable
fuente
9'-×D'|4ð׫©ûs®¨'|«û5'x×»ûtrató de refactorizar un poco, no se puede romper 26.
Urna de pulpo mágico
Otra alternativa de 26 bytes .
Kevin Cruijssen
7

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í!

Gurupad Mamadapur
fuente
6

/// , 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
acrolito
fuente
6

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

DJMcMayhem
fuente
6

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
Jonathan Allan
fuente
5

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
|   |   |
---------
|       |
---------
Conor O'Brien
fuente
Reordenar y guardar un byte:9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050
Zgarb
@ Zgarb ah, ¡bien!
Conor O'Brien
4

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.
Level River St
fuente
4

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.

Mitchell Spector
fuente
4

JavaScript, 85 bytes

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

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))
Arnauld
fuente
Puede hacer que esta sea una función para guardar algunos bytes.
Conor O'Brien
@ ConorO'Brien No estoy seguro de que solo se pueda devolver el resultado aquí: tienes que imprimir una cancha de tenis
Arnauld
La codificación de longitud de ejecución simple es un byte más corto que su método alternativo: console.log('-9\n| 7|\n-9\n| 3| 3|\nx9\n| 3| 3|\n-9\n| 7|\n-9'.replace(/.\d/g,s=>s[0].repeat(s[1])))(reemplazar \ncon nueva línea obviamente).
Neil
Otra formulación 92 bytes: console.log('-\n |\n-\n |\nx\n |\n-\n |\n-'.replace(/.*/g,s=>s.repeat(9).slice(-9))).
Neil
Lo sentimos, se supone que deben haber 7 o 3 espacios antes de cada uno, |según corresponda, en lugar del espacio único que aparece en mi comentario.
Neil
4

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.

dzaima
fuente
3

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)

n4melyh4xor
fuente
Puede guardar 4 bytes agregando una nueva línea al comienzo de b, ya que esto significa que puede eliminar la nueva línea después xxxxxxxxxy la que agrega entre ay b. Puede guardar otros 3 bytes mediante el establecimiento ade ---------primero y luego la concatenación de la segunda fila y una a sí misma.
Neil
3

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.

axiac
fuente
1
Los avisos están desactivados en la configuración predeterminada; no es necesario -d error_reporting=0, solo úsalo -n.
Titus
Cuento 66. Puedes hacer que sean 65 con <?=$a=($b="---------\n|")."....
Titus
@Titus Me gusta tu sugerencia. -nes mucho más corto que -d error_reporting=0:-) De hecho, solo hay 66 caracteres útiles en la respuesta. Los conté usando ls -ly olvidé que mi viestá configurado para garantizar que el archivo termine con una nueva línea. Mejoré tu mejora y exprimí 3 bytes más. Gracias.
axiac
2

PHP, 72 bytes

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

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

Titus
fuente
2

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.

GB
fuente
2

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(^)
Azul
fuente
2

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
Oliver Ni
fuente
2

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

sam
fuente
2

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.
Zgarb
fuente
2

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.

AdmBorkBork
fuente
$(' '*7)es en realidad 8 caracteres, sería más corto para hacer solo | |como espacios.
colsw
@ConnorLSW Oh, jaja. Gracias por el obvio golf! : D
AdmBorkBork
solo te ToLower()
devuelvo
1

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])
ElPedro
fuente
1

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

Sean
fuente
1

Lua, 82 bytes.

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

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

Un taco
fuente
1

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.

FlipTack
fuente
1

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 
Ali ISSA
fuente
1

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

mazzy
fuente