Improvvisamente voglio davvero giocare a tennis, ma purtroppo non ho un campo!

Sorpresa! Questo è dove entri.

Devi stampare un campo da tennis per me, ma devi farlo nel minor numero di byte possibile a causa di motivi confidenziali.

Campo da tennis

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

Questo è code-golf , quindi vince il codice più breve in byte!

— Daniel
fonte

1

Trailing newline consentito?

— Erik the Outgolfer,

1

Le grandi lacune nella riga 2 e 8 possono essere eseguite utilizzando le schede?

— FlipTack

3

@ Flp.Tkc, non credo. Penso che poiché nessuno nelle sei risposte già pubblicate lo sapeva, sarebbe ingiusto.

— Daniel,

2

Questa è una sfida sorprendentemente complicata per una stringa di output così breve! Mi piace. :)

— Lynn,

7

Puoi semplicemente chiamare questa sfida un "campo da

— tennis

1

Tela , 13 byte

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

Provalo qui!

— dzaima
fonte

13

Python 2, 65 byte

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

Flp.Tkc ha salvato un byte.

— Lynn
fonte

Questa è un'affettatura folle. Bello!

— Gurupad Mamadapur,

Puoi usare '|'+' '*7la seconda stringa sper salvare un byte!

— FlipTack

12

05AB1E ,29 27 26 byte

'-9×©'|ð4×«Dûs®s¨¨ûû'x5×»û

Provalo 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

— Osable
fonte

9'-×D'|4ð×«©ûs®¨'|«û5'x×»ûha provato a refactoring un po ', non può rompere il 26.

— Magic Octopus Urn il

Un'altra alternativa di 26 byte .

— Kevin Cruijssen,

7

Python 3 - 73 72 byte

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

Python 3.6 - 75 byte

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

Il merito va a flp-tkc . Grazie :)

Prova qui!

— Gurupad Mamadapur
fonte

6

/// , 64 56 byte

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

Provalo online!

Un'altra soluzione a 56 byte:

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

— acrolito
fonte

6

V , 25 byte

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

Provalo online!

Dovrebbero essere 23 byte:

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

Ma ho incontrato diversi bug durante la creazione. :(

— DJMcMayhem
fonte

6

Gelatina , 25 byte

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

TryItOnline!

Avevo sperato di usare la ripetizione del tribunale di 1,3,1 quarti, ma non posso comprimerlo in meno (una versione grezza è 28:) “ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY.

Come?

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

5

J, 70 54 51 50 byte

Hai salvato un byte grazie a Zgarb!

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

Qualche tecnica di compressione standard, usando un RLE compresso.

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

— Conor O'Brien
fonte

Riordina e salva un byte:9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050

— Zgarb

@Zgarb ah, bello!

— Conor O'Brien,

4

Rubino, 60 byte

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

— Level River St
fonte

4

strumenti bash / Unix, 58 57 byte

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

Nell'output desiderato vengono visualizzati solo quattro caratteri diversi da newline, che consente di codificare ciascuna riga come numero base-4. Questi numeri vengono quindi scritti in esadecimale nello script, per brevità.

Il calcolatore Unix dc viene utilizzato sia per la conversione da base 16 a base 4 sia per la manipolazione dello stack per consentire una facile ripetizione delle linee nei punti giusti.

Modifica: eliminazione di un byte scambiando due delle cifre di base 4 utilizzate per codificare i caratteri, consentendo al comando tr di essere più corto di un byte rispetto alla versione precedente.

— Mitchell Spector
fonte

4

JavaScript, 85 byte

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

— Neil
fonte

4

JavaScript (ES6), 86 84 83 81 byte

Salvato 2 byte, grazie a Neil

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

Espandi frammento

Metodo alternativo n. 1, 93 byte

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

Metodo alternativo n. 2, 86 byte

Suggerito da Neil:

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

Metodo alternativo n. 3, 91 byte

Un approccio ricorsivo:

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

— Arnauld
fonte

È possibile rendere questa una funzione per salvare alcuni byte.

— Conor O'Brien,

@ ConorO'Brien Non sono sicuro che sia consentito restituire l'output qui: devi stampare un campo da tennis

— Arnauld,

La semplice codifica della lunghezza della corsa è un byte più breve del tuo metodo 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])))(sostituisci \novviamente con newline).

— Neil,

Un'altra formulazione 92-byte: console.log('-\n |\n-\n |\nx\n |\n-\n |\n-'.replace(/.*/g,s=>s.repeat(9).slice(-9))).

— Neil,

Spiacenti, si suppone che ci siano 7 o 3 spazi prima di ognuno, a |seconda dei casi, anziché il singolo spazio che appare nel mio commento.

— Neil,

4

SOGL 0,5 , 24 23 20 byte (non concorrenti)

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

Spiegazione:

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

Quindi, come funziona la stringa compressa?

La stringa convertita da base250 in binario è 1000000100111110010100001110100000001100010001

e approssimativamente cosa fa:

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

non competitivo, perché la lingua postdatizza la sfida. E questa sfida ha solo un giorno. Sapevo che avrei dovuto mettere su qualcosa ieri. L'ho fatto come test per la mia lingua ed è finito troppo bene per non postare. Abbastanza sicuro anche questo è golfable.

— dzaima
fonte

3

/// , 59 byte

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

Provalo online!

Outgolfed ...

— Erik the Outgolfer
fonte

3

Javascript (ES6), 86 byte:

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

Prova qui:

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

Espandi frammento

— n4melyh4xor
fonte

È possibile salvare 4 byte aggiungendo una nuova riga all'inizio di b, poiché ciò significa che è possibile rimuovere la nuova riga dopo xxxxxxxxxe quella che si aggiunge tra ae b. È possibile salvare altri 3 byte impostando asu ---------first e quindi concatenando la seconda riga e a a se stessa.

— Neil,

3

05AB1E , 26 byte

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

Utilizza la codifica CP-1252 . Provalo online!

— Adnan
fonte

Meglio giocare a golf più in basso!

— Oliver Ni,

3

PHP, 66 62 byte

Questa è la risposta originale (66 byte):

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

Genera un avviso a causa della costante sconosciuta x. L'avviso può essere soppresso impostando error_reporting=0in php.inio nella riga di comando:

$ php -d error_reporting=0 tennis.php

L'ultima riga dell'output non termina con un carattere di nuova riga.

La risposta aggiornata (62 byte), migliorando un miglioramento suggerito da @Titus:

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

Eseguilo senza un file di configurazione (per impostazione predefinita in error_reporting=0questo modo):

$ php -n tennis.php

Entrambe le versioni del codice contengono letteralmente nuove righe incorporate nella stringa (1 byte più corta di \n) e non possiamo scartarle.

— axiac
fonte

1

Gli avvisi sono disattivati nella configurazione predefinita; non serve -d error_reporting=0, basta usare -n.

— Tito

Conto 66. Puoi farne 65 con <?=$a=($b="---------\n|")."....

— Tito

@Titus Mi piace il tuo suggerimento. -nè molto più breve di -d error_reporting=0:-) Ci sono, infatti, solo 66 caratteri utili nella risposta. Li ho contati usando ls -le ho dimenticato che il mio viè configurato per garantire che il file termina con una nuova riga. Ho migliorato il tuo miglioramento e spremuto altri 3 byte. Grazie.

— axiac il

2

PHP, 72 byte

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

Quasi lo odio quando è più corto di questo che con un po 'di calcolo.

— Titus
fonte

2

Rubino, 52 byte

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

Usando la doppia simmetria, le linee sono 0-1-0 / 2-3-2 / 0-1-0:, il loop può essere facilmente srotolato e l'elenco nidificato viene appiattito sull'output.

— GB
fonte

2

Pyke, 28 26 25 byte

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

Provalo qui!

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

— Blu
fonte

2

05AB1E, 25 byte

'-9×©'|ð4×«û®…|  ûû'x5×»û

Utilizza la codifica CP-1252 . Provalo online!

Spiegazione:

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

2

Vim, 32 byte

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

Questo stamperà il campo da tennis in un buffer vim. ^Mrappresenta il tasto Invio (0x0d) ed ^[è il tasto Esc (0x1b). È possibile eseguire questi tasti / codice salvandoli in un file ed eseguendoli

vim -s <filename> -u NONE

Stampa su stdout

Se invece deve essere stampato su stdout, è possibile salvare il buffer in un file (ho usato "a") e utilizzare qualsiasi shell vimimpostata per l'uso (che ho usato bash), nonché il catprogramma per stampare il campo da tennis su stdout (51 byte):

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

È lo stesso della versione precedente ma con l' :w!a|sil !cat %^M:q^Maggiunta alla fine

— sam
fonte

2

J, 36 byte

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

Funziona su REPL, che è il modo standard di usare J:

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

Con 41 byte , posso stampare il risultato su STDOUT:

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

Provalo online!

Spiegazione

Costruisco il campo da tennis una fila alla volta.

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
fonte

2

PowerShell , 67 66 byte

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

Provalo online!

Solo un po 'di moltiplicazione di stringhe, impostazione di variabili e garanzia che siano incapsulate in parentesi per posizionare copie sulla pipeline. L'impostazione predefinita Write-Outputal completamento del programma ci offre nuove linee tra quelle gratuite.

Grazie a @ConnorLSW per aver salvato un byte ovvio.

— AdmBorkBork
fonte

$(' '*7)è in realtà 8 caratteri, sarebbe più breve da fare solo | |come spazi.

— domenica

@ConnorLSW Oh, haha. Grazie per l'ovvio golf! : D

— AdmBorkBork,

ti ToLower()sto solo ripagando per il salvataggio sull'altra mia risposta;)

— domenica

1

Python 2, 75 byte

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

Utilizza le variabili prese in prestito da @GurupadMamadapur

Alternativa anche per 75

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

— ElPedro
fonte

1

Emacs, 43 35 sequenze di tasti

M-9 x RET: nove x, ritorno
C-SPC: imposta segno
| M-3 SPC | M-3 SPC | RET: tubo, tre spazi, tubo, tre spazi, tubo, ritorno
M-9 - RET: nove trattini, ritorno
| M-7 SPC | RET: tubo, sette spazi, tubo, ritorno
M-9 - RET: nove trattini, ritorno
C-x C-x: scambia punto e segno, selezionando regione
M-w: copia regione
C-p: riga precedente
C-y: yank testo copiato
M-x rev-r RET: esegui reverse-regioncomando

— Sean
fonte

1

Lua, 82 byte.

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

Ho provato molti metodi, eppure questo ha dimostrato il vincitore.

— ATACO
fonte

1

Pushy , 33 byte

Questa domanda aveva 33 voti positivi e c'erano 33 risposte, quindi dovevo solo pubblicare una soluzione da 33 byte ...

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

Provalo online!

Spiegazione

Il codice può essere suddiviso in più parti, per facilitarne la comprensione. La prima parte funziona così:

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

Lo stack è ora:

---------
|

L'operatore mirror w, quindi rispecchia l'intero stack, producendo:

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

Poi:

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

Lo stack ora inizia a sembrare il campo da tennis:

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

Per finire, usiamo wancora una volta l' operatore mirror , che riflette questa stringa per produrre il campo da tennis completo.

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

Tutto ciò che rimane ora è stampare, che è fatto dal "personaggio.

— FlipTack
fonte

1

Unix Shell; usando dc e tr; 55 byte: (ottimizzazione della soluzione di Mitchell Spector)

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

Altre soluzioni: utilizzo di sed; 81 byte;

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

Utilizzo di cc nella funzione: 88 byte

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

Utilizzando bc in funzione: 99 byte

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
fonte

1

Powershell, 56 byte

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

Spiegazione: metà campo semplice

Alternativa, 68 byte

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

Spiegazione: un quarto del campo utilizza gli stessi indici per la visualizzazione di righe e colonne

— Mazzy
fonte

Andiamo a giocare a tennis

Campo da tennis

Questo è code-golf , quindi vince il codice più breve in byte!

Tela , 13 byte

Python 2, 65 byte

05AB1E ,29 27 26 byte

Python 3 - 73 72 byte

/// , 64 56 byte

V , 25 byte

Gelatina , 25 byte

Come?

J, 70 54 51 50 byte

Rubino, 60 byte

strumenti bash / Unix, 58 57 byte

JavaScript, 85 byte

JavaScript (ES6), 86 84 83 81 byte

Metodo alternativo n. 1, 93 byte

Metodo alternativo n. 2, 86 byte

Metodo alternativo n. 3, 91 byte

SOGL 0,5 , 24 23 20 byte (non concorrenti)

/// , 59 byte

Javascript (ES6), 86 byte:

05AB1E , 26 byte

PHP, 66 62 byte

PHP, 72 byte

Rubino, 52 byte

Pyke, 28 26 25 byte

05AB1E, 25 byte

Vim, 32 byte

Stampa su stdout

J, 36 byte

Spiegazione

PowerShell , 67 66 byte

Python 2, 75 byte

Emacs, 43 35 sequenze di tasti

Lua, 82 byte.

Pushy , 33 byte

Spiegazione

Powershell, 56 byte

Alternativa, 68 byte