Ich möchte plötzlich wirklich Tennis spielen, aber leider habe ich keinen Platz!

Überraschung! Hier kommst du rein.

Sie müssen einen Tennisplatz für mich drucken, aber Sie müssen es aus vertraulichen Gründen in den wenigsten möglichen Bytes tun.

Tennisplatz

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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Canvas , 13 Bytes

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

Probieren Sie es hier aus!

Python 2, 65 Bytes

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

Flp.Tkc hat ein Byte gespeichert.

05AB1E ,29 27 26 Bytes

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

Probieren Sie es 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='')

Gutschrift geht an flp-tkc . Dankeschön :)

Versuch es hier!

/// , 64 56 Bytes

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

Probieren Sie es online!

Eine weitere 56-Byte-Lösung:

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

V , 25 Bytes

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

Probieren Sie es online!

Das sollten 23 Bytes sein:

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

Aber ich bin beim Erstellen auf mehrere Bugs gestoßen. :(

Gelee , 25 Bytes

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

TryItOnline!

Ich hatte gehofft, die 1,3,1-Viertel-Gerichtswiederholung zu verwenden, kann das aber nicht in weniger zusammenfassen (eine rohe Version ist 28:) “ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY.

Wie?

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

Dank Zgarb ein Byte gespart!

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

Einige Standardkomprimierungstechniken unter Verwendung eines komprimierten RLE.

   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.

Bash / Unix-Tools, 58 57 Bytes

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

In der gewünschten Ausgabe werden nur vier andere Zeichen als Zeilenvorschub angezeigt, sodass jede Zeile als Zahl zur Basis 4 codiert werden kann. Der Kürze halber werden diese Zahlen dann im Skript hexadezimal geschrieben.

Der Unix-Rechner dc wird sowohl für die Konvertierung von Base-16 nach Base-4 als auch für die Stapelmanipulation verwendet, um eine einfache Wiederholung von Zeilen an den richtigen Stellen zu ermöglichen.

Bearbeiten: Ein Byte weniger durch Vertauschen von zwei der vier Basisziffern, die zum Codieren von Zeichen verwendet werden, wodurch der Befehl tr ein Byte kürzer als die vorherige Version sein kann.

JavaScript, 85 Bytes

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

JavaScript (ES6), 86 84 83 81 Bytes

2 Bytes gespart, dank Neil

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

Alternative Methode # 1, 93 Bytes

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

Alternative Methode 2, 86 Byte

Vorgeschlagen von Neil:

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

Alternative Methode Nr. 3, 91 Bytes

Ein rekursiver Ansatz:

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

SOGL 0.5 , 24 23 20 Bytes (nicht konkurrierend)

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

Erläuterung:

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

Wie funktioniert die komprimierte Zeichenfolge?

Die von base250 nach binary konvertierte Zeichenfolge lautet 1000000100111110010100001110100000001100010001

und ungefähr, was es tut:

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

nicht konkurrierend, weil die Sprache die Herausforderung datiert. Und diese Herausforderung ist erst einen Tag alt. Ich wusste, dass ich gestern etwas hätte aufstellen sollen. Ich habe dies als Test für meine Sprache durchgeführt und es endete zu gut, um nichts zu posten. Ich bin mir ziemlich sicher, dass dies auch mehr zum Golfen ist.

/// 59 Bytes

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

Probieren Sie es online!

Outgolfed ...

Javascript (ES6), 86 Byte:

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

Hier testen:

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

05AB1E , 26 Bytes

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

PHP, 66 62 Bytes

Dies ist die ursprüngliche Antwort (66 Bytes):

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

Aufgrund der unbekannten Konstante wird ein Hinweis generiert x. Der Hinweis kann durch Setzen error_reporting=0in php.inioder in der Kommandozeile unterdrückt werden :

$ php -d error_reporting=0 tennis.php

Die letzte Zeile der Ausgabe endet nicht mit einem Zeilenumbruch.

Die aktualisierte Antwort (62 Byte), die eine von @Titus vorgeschlagene Verbesserung verbessert:

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

Führen Sie es ohne Konfigurationsdatei aus (standardmäßig auf error_reporting=0diese Weise):

$ php -n tennis.php

Beide Versionen des Codes enthalten wörtliche neue Zeilen, die in die Zeichenfolge eingebettet sind (1 Byte kürzer als \n) und die nicht entpackt werden können.

PHP, 72 Bytes

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

Ich hasse es fast, wenn es so kürzer ist als ein bisschen zu rechnen.

Ruby, 52 Bytes

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

Unter Verwendung der Doppelsimmetrie sind die Zeilen: 0-1-0 / 2-3-2 / 0-1-0Die Schleife kann leicht abgerollt werden und die verschachtelte Liste wird bei der Ausgabe abgeflacht.

Pyke, 28 26 25 Bytes

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

Probieren Sie es hier aus!

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Erläuterung:

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

Dadurch wird der Tennisplatz in einen Vim-Puffer gedruckt. ^Mrepräsentiert die Eingabetaste (0x0d) und ^[ist die Escape-Taste (0x1b). Sie können diese Tastenanschläge / Code ausführen, indem Sie sie in einer Datei speichern und ausführen

vim -s <filename> -u NONE

Drucken nach Standard

Wenn es stattdessen auf stdout gedruckt werden soll, können Sie den Puffer in einer Datei speichern (ich habe "a" verwendet) und die jeweils eingestellte Shell vim(ich habe sie verwendet bash) sowie das catProgramm zum Drucken des Tennisplatzes verwenden stdout (51 bytes):

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

Es ist das gleiche wie die frühere Version, aber mit :w!a|sil !cat %^M:q^Mam Ende hinzugefügt

J, 36 Bytes

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

Dies funktioniert auf der REPL, der Standardmethode für die Verwendung von J:

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

Mit 41 Bytes kann ich das Ergebnis auf STDOUT ausgeben:

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

Probieren Sie es online!

Erläuterung

Ich baue den Tennisplatz nacheinander.

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

Probieren Sie es online!

Nur ein paar Zeichenfolgen multiplizieren, Variablen setzen und sicherstellen, dass sie in Parens eingeschlossen sind, um Kopien in der Pipeline zu platzieren. Die Standardeinstellung Write-Outputbei Programmabschluss gibt uns Zeilenumbrüche zwischen kostenlos.

Vielen Dank an @ConnorLSW für das Speichern eines offensichtlichen Bytes.

Python 2, 75 Bytes

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

Verwendet Variablen, die von @GurupadMamadapur entlehnt wurden

Alternative auch für 75

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

Emacs, 43 35 Tastenanschläge

M-9 x RET: neun x, return
C-SPC: set mark
| M-3 SPC | M-3 SPC | RET: pipe, drei Leerzeichen, pipe, drei Leerzeichen, pipe, return
M-9 - RET: neun Bindestriche, return
| M-7 SPC | RET: pipe, sieben Leerzeichen, pipe, return
M-9 - RET: neun Bindestriche, return
C-x C-x: exchange point and mark, select region
M-w: Bereich kopieren
C-p: vorherige Zeile
C-y: Ruck kopierter Text
M-x rev-r RET: reverse-regionBefehl ausführen

Lua, 82 Bytes.

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

Ich habe viele Methoden ausprobiert, und doch hat diese den Sieg davon getragen.

Aufdringlich , 33 Bytes

Diese Frage hatte 33 Upvotes und es gab 33 Antworten, also musste ich nur eine 33-Byte-Lösung posten ...

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

Probieren Sie es online!

Erläuterung

Der Code kann in mehrere Teile aufgeteilt werden, um das Verständnis zu erleichtern. Der erste Teil funktioniert so:

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

Der Stack ist jetzt:

---------
|

Der Spiegeloperator wspiegelt dann den gesamten Stapel und erzeugt:

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

Dann:

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

Der Stapel fängt jetzt an, wie der Tennisplatz auszusehen:

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

Zum Abschluss verwenden wir noch einmal den Spiegeloperator w, der diese Zeichenfolge widerspiegelt, um den vollständigen Tennisplatz zu erzeugen.

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

Jetzt muss nur noch gedruckt werden, und das erledigt der "Charakter.

Unix Shell; mit dc und tr; 55 Bytes: (Optimierung der Mitchell Spector Lösung)

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

Andere Lösungen: Verwenden von sed; 81 Bytes;

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

Gleichstrom in Funktion verwenden: 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

oder

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 

Verwendung von bc in Funktion: 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]

Erklärung: unkomplizierte Gerichtshälfte

Alternativ 68 Bytes

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

Erläuterung: Für die Anzeige von Zeilen und Spalten werden die gleichen Indizes verwendet