Lass uns Tennis spielen

45

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 , also gewinnt der kürzeste Code in Bytes!

Daniel
quelle
1
Zeilenumbruch erlaubt?
Erik der Outgolfer
1
Können die großen Lücken in Reihe 2 und 8 mit Tabulatoren geschlossen werden?
FlipTack
3
@ Flp.Tkc, ich glaube nicht. Ich denke, da niemand sonst in den sechs bereits geposteten Antworten wusste, dass es unfair wäre.
Daniel
2
Dies ist eine überraschend knifflige Herausforderung für eine so kurze Ausgabezeichenfolge! Ich mag das. :)
Lynn
7
Sie können diese Herausforderung einfach als "Dennis Court" bezeichnen, da jeder weiß, wer sowieso gewinnt ... :)
RudolfJelin

Antworten:

13

Python 2, 65 Bytes

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

Flp.Tkc hat ein Byte gespeichert.

Lynn
quelle
Das ist verrücktes Schneiden. Nett!
Gurupad Mamadapur
Sie können '|'+' '*7für die zweite Zeichenfolge in sein Byte speichern!
FlipTack
12

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
Osable
quelle
9'-×D'|4ð׫©ûs®¨'|«û5'x×»ûversuchte ein wenig umzugestalten, kann nicht brechen 26.
Magic Octopus Urn
Weitere 26 Bytes Alternative .
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='')

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

Versuch es hier!

Gurupad Mamadapur
quelle
6

/// , 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
Akrolith
quelle
6

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

DJMcMayhem
quelle
6

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

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
|   |   |
---------
|       |
---------
Conor O'Brien
quelle
9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050
Neu anordnen
@ Zgarb ah, schön!
Conor O'Brien
4

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

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.

Mitchell Spector
quelle
4

JavaScript, 85 Bytes

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

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))
Arnauld
quelle
Sie können dies zu einer Funktion machen, um ein paar Bytes zu sparen.
Conor O'Brien
@ ConorO'Brien Ich bin nicht sicher, ob es erlaubt ist, nur die Ausgabe hier zurückzugeben: Sie müssen einen Tennisplatz drucken
Arnauld
Die einfache Lauflängencodierung ist ein Byte kürzer als Ihre alternative Methode: 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])))( \nOffensichtlich durch Zeilenvorschub ersetzen ).
Neil
Eine weitere 92-Byte - Formulierung: console.log('-\n |\n-\n |\nx\n |\n-\n |\n-'.replace(/.*/g,s=>s.repeat(9).slice(-9))).
Neil
Entschuldigung, es sollten 7 oder 3 Leerzeichen vor jedem vorhanden sein, |anstatt des einzelnen Leerzeichens, das in meinem Kommentar erscheint.
Neil
4

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.

dzaima
quelle
3

Javascript (ES6), 86 Byte:

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

Hier testen:

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

n4melyh4xor
quelle
Sie können 4 Bytes einsparen, indem Sie am Anfang eine neue Zeile einfügen. bDies bedeutet, dass Sie die neue Zeile nach xxxxxxxxxund zwischen aund entfernen können b. Sie können , indem Sie weitere 3 Bytes speichern , aum ---------erste und dann die zweite Reihe und ein an sich verketten.
Neil
3

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.

Axiac
quelle
1
Benachrichtigungen sind in der Standardkonfiguration deaktiviert. keine Notwendigkeit -d error_reporting=0, nur zu verwenden -n.
Titus
Ich zähle 66. Du kannst sie mit 65 machen <?=$a=($b="---------\n|")."....
Titus
@ Titus Ich mag Ihren Vorschlag. -nist viel kürzer als -d error_reporting=0:-) Die Antwort enthält in der Tat nur 66 nützliche Zeichen. Ich habe sie mit gezählt ls -lund vergessen, dass my viso konfiguriert ist, dass die Datei mit einer neuen Zeile endet. Ich habe deine Verbesserung verbessert und 3 weitere Bytes zusammengedrückt. Danke.
Axiac
2

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.

Titus
quelle
2

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.

GB
quelle
2

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(^)
Blau
quelle
2

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

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

Sam
quelle
2

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

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.

AdmBorkBork
quelle
$(' '*7)ist eigentlich 8 Zeichen, wäre kürzer, nur | |als Leerzeichen zu tun .
Colsw
@ConnorLSW Oh, haha. Vielen Dank für das offensichtliche Golf! : D
AdmBorkBork
ToLower()
Ich zahle
1

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

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

Sean
quelle
1

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.

Ein Taco
quelle
1

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.

FlipTack
quelle
1

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 
Ali IVSS
quelle
1

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

mazzy
quelle