J'ai soudainement très envie de jouer au tennis, mais hélas je n'ai pas de court!

Surprise! C'est là que tu entres.

Vous devez imprimer un court de tennis pour moi, mais vous devez le faire le moins d'octets possible pour des raisons de confidentialité.

Court de tennis

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

C'est du code-golf , donc le code le plus court en octets gagne!

Toile , 13 octets

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

Essayez-le ici!

Python 2, 65 octets

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

Flp.Tkc a sauvegardé un octet.

05AB1E ,29 27 26 octets

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

Essayez-le en ligne!

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

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

Python 3.6 - 75 octets

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

Le crédit va à flp-tkc . Merci :)

Essayez ici!

/// , 64 56 octets

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

Essayez-le en ligne!

Une autre solution de 56 octets:

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

V , 25 octets

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

Essayez-le en ligne!

Cela devrait être 23 octets:

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

Mais j'ai rencontré plusieurs bugs lors de sa création. :(

Gelée , 25 octets

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

TryItOnline!

J'avais espéré utiliser la répétition d'audience 1,3,1 quart, mais je ne peux pas réduire cela en moins (une version brute étant 28:) “ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY.

Comment?

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

Enregistré un octet grâce à Zgarb!

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

Une technique de compression standard, utilisant un RLE compressé.

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

Ruby, 60 octets

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

Outils bash / Unix, 58 57 octets

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

Seuls quatre caractères autres que nouvelle ligne apparaissent dans la sortie souhaitée, ce qui permet de coder chaque ligne en tant que nombre base 4. Ces chiffres sont ensuite écrits en hexadécimal dans le script, par souci de brièveté.

La calculatrice Unix dc est utilisée à la fois pour la conversion de la base 16 à la base 4 et pour la manipulation de pile afin de permettre la répétition facile des lignes aux bons endroits.

Edit: coupez un octet en remplaçant deux des 4 chiffres de la base utilisés pour coder les caractères, permettant ainsi à la commande tr d’être plus courte d’un octet que la version précédente.

JavaScript, 85 octets

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

JavaScript (ES6), 86 84 83 81 octets

2 octets sauvés, merci à Neil

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

Méthode alternative n ° 1, 93 octets

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

Méthode alternative n ° 2, 86 octets

Proposé par Neil:

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

Méthode alternative n ° 3, 91 octets

Une approche récursive:

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

SOGL 0,5 , 24 23 20 octets (non concurrents)

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

Explication:

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

Alors, comment fonctionne la chaîne compressée?

La chaîne convertie de base250 en binaire est 1000000100111110010100001110100000001100010001

et approximativement ce qu'il fait:

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-concurrent, parce que la langue postdate le défi. Et ce défi n'a qu'un jour. Je savais que j'aurais dû mettre quelque chose en place hier. Je l’ai fait comme test pour ma langue et cela a été trop beau pour ne pas être posté. Je suis sûr que c'est golfable plus aussi.

/// , 59 octets

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

Essayez-le en ligne!

Outgolfed ...

Javascript (ES6), 86 octets:

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

Testez ici:

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

05AB1E , 26 octets

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

Utilise le codage CP-1252 . Essayez-le en ligne!

PHP, 66 62 octets

C'est la réponse originale (66 octets):

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

Il génère un avis en raison de la constante inconnue x. La notification peut être supprimée en définissant error_reporting=0dans php.iniou dans la ligne de commande:

$ php -d error_reporting=0 tennis.php

La dernière ligne de la sortie ne se termine pas par un caractère de nouvelle ligne.

La réponse mise à jour (62 octets), améliorant une amélioration suggérée par @Titus:

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

Exécutez-le sans fichier de configuration (par défaut de error_reporting=0cette façon):

$ php -n tennis.php

Les deux versions du code contiennent de nouvelles lignes littérales incorporées dans la chaîne (1 octet plus court que \n) et ne peuvent pas être décompressées.

PHP, 72 octets

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

Je déteste presque quand il est plus court comme ça que de calculer un peu.

Ruby, 52 octets

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

En utilisant la double simétrie, les lignes sont:, 0-1-0 / 2-3-2 / 0-1-0la boucle peut être facilement déroulée et la liste imbriquée est aplatie en sortie.

Pyke, 28 26 25 octets

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

Essayez-le ici!

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

05AB1E, 25 octets

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

Utilise le codage CP-1252 . Essayez-le en ligne!

Explication:

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

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

Cela imprimera le court de tennis dans un tampon vim. ^Mreprésente la touche Entrée (0x0d) et ^[la touche Échap (0x1b). Vous pouvez exécuter ces séquences de touches / code en les enregistrant dans un fichier et en les exécutant.

vim -s <filename> -u NONE

Impression sur stdout

S'il doit être imprimé sur stdout à la place, vous pouvez enregistrer le tampon dans un fichier (j'ai utilisé "a") et utiliser le shell vimutilisé (j'ai utilisé bash) ainsi que le catprogramme permettant d'imprimer le court de tennis. stdout (51 bytes):

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

C'est la même chose que la version précédente mais avec :w!a|sil !cat %^M:q^Majouté à la fin

J, 36 octets

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

Cela fonctionne sur le REPL, qui est le moyen standard d’utiliser J:

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

Avec 41 octets , je peux imprimer le résultat sur STDOUT:

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

Essayez-le en ligne!

Explication

Je construis le court de tennis une rangée à la fois.

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 octets

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

Essayez-le en ligne!

Juste une certaine multiplication de chaînes, la définition de variables et la garantie qu'elles sont encapsulées entre parenthèses afin de placer des copies sur le pipeline. La valeur par défaut Write-Outputà l'achèvement du programme nous donne les nouvelles lignes entre elles gratuitement.

Merci à @ConnorLSW pour avoir sauvegardé un octet évident.

Python 2, 75 octets

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

Utilise des variables empruntées à @GurupadMamadapur

Alternative aussi pour 75

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

Emacs, 43 35 frappes au clavier

M-9 x RET: neuf x, retour
C-SPC: marque de repère
| M-3 SPC | M-3 SPC | RET: tuyau, trois espaces, tuyau, trois espaces, tuyau, retour
M-9 - RET: neuf traits d'union, retour
| M-7 SPC | RET: tuyau, sept espaces, tuyau, retour de
M-9 - RETneuf traits d'union, retour
C-x C-x: point d'échange et marque, région de sélection
M-w: région de copie
C-p: ligne précédente
C-y: yank texte copié
M-x rev-r RET: reverse-regioncommande execute

Lua, 82 octets.

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

J'ai essayé beaucoup de méthodes, et pourtant celle-ci a prouvé le vainqueur.

Pushy , 33 octets

Cette question a eu 33 votes positifs, et il y a eu 33 réponses. Il me suffisait donc de publier une solution à 33 octets ...

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

Essayez-le en ligne!

Explication

Le code peut être divisé en plusieurs parties pour faciliter la compréhension. La première partie fonctionne comme suit:

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

La pile est maintenant:

---------
|

L'opérateur de miroir w, puis met en miroir l'ensemble de la pile, en produisant:

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

Ensuite:

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 pile commence maintenant à ressembler au court de tennis:

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

Pour terminer, nous utilisons encore wune fois l’ opérateur de miroir , qui reflète cette corde pour produire le court de tennis complet.

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

Il ne reste plus qu'à imprimer, ce qui est fait par le "personnage.

Unix Shell; en utilisant dc et tr; 55 octets: (optimisation de la solution Mitchell Spector)

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

Autres solutions: Utiliser sed; 81 octets;

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

Utilisation de dc en fonction: 88 octets

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 

Utilisation de bc dans la fonction: 99 octets

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 octets

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

Explication: simple moitié du court

Alternative, 68 octets

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

Explication: le quart de la cour utilise les mêmes index pour l'affichage des lignes et des colonnes