I suddenly really want to play tennis, but alas I do not have a court!
Surprise! This is where you come in.
You have to print a tennis court for me, but you have to do it in the fewest bytes possible because of confidential reasons.
---------
| |
---------
| | |
xxxxxxxxx
| | |
---------
| |
---------
s='-','|'+' '*7,'-','| ','x'
for i in s+s[3::-1]:print(i*9)[:9]
Flp.Tkc saved a byte.
'|'+' '*7 for the second string in s to save a byte!
\$\endgroup\$
'-9ש'|ð4׫Dûs®s¨¨ûû'x5×»û
'-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
9'-×D'|4ð׫©ûs®¨'|«û5'x×»û tried refactoring a little, can't break 26.
\$\endgroup\$
Commented
Dec 22, 2016 at 15:25
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='')
Credit goes to flp-tkc. Thank you :)
/f/---//e/ //a/fff
|ee |
fff
//d/|e|e|
/adxxxxxxxxx
da
Another 56 byte solution:
/f/---//e/| //a/fff
e |
fff
//d/ee|
/adxxxxxxxxx
da
9é-ÄÙÒ r|$.4äGMãlr|jj.kÒX
This should be 23 bytes:
9é-ÄÙÒ r|$.4äMÒXãkr|jj.
But I ran into several bugs while creating it. :(
“¡⁵÷ḞȯḤɼ’b4ị“- x|”s5ŒBŒḄY
I had hoped to use the 1,3,1 quarter court repetition, but can't squeeze that into less (a raw version being 28: “ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY).
“¡⁵÷ḞȯḤɼ’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
Saved a byte thanks to Zgarb!
9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050
Some standard compression technique, using a compressed RLE.
9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050
---------
| |
---------
| | |
xxxxxxxxx
| | |
---------
| |
---------
9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050
\$\endgroup\$
-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.
dc<<<4o16i3FFFFp20002prp20202p15555pszpszfp|tr 0-3 ' x|-'
Only four characters other than newline appear in the desired output, allowing each line to be coded as a base-4 number. These numbers are then written in hexadecimal in the script, for brevity.
The Unix calculator dc is used both for the base-16 to base-4 conversion and for stack manipulation to allow easy repetition of lines in the right places.
Edit: Shaved one byte off by swapping two of the base-4 digits used to code characters, permitting the tr command to be one byte shorter than the previous version.
console.log('---| ---| |xxx| |---| ---'.replace(/(.)((.).)/g,'$1$3$3$2$3$3$3$1\n'))
Saved 2 bytes, thanks to Neil
a=`---------
`;a+=`| |
`+a;b=`| | |
`;console.log(a+b+`xxxxxxxxx
`+b+a)console.log('01232101242421512424210123210'.replace(/./g,n=>`-
| x`[n].repeat('911739'[n])))
Suggested by Neil:
console.log(`-${s=`
|
-
|
`}x${s}-`.replace(/.*/g,s=>s.repeat(9).slice(-9)))
A recursive approach:
console.log((f=(n,c=`xxxx
| | |
---------
| |
`[n]||'-')=>~n--?c+f(n)+c:'x')(43))
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]))) (replace \n with newline obviously).
\$\endgroup\$
console.log('-\n |\n-\n |\nx\n |\n-\n |\n-'.replace(/.*/g,s=>s.repeat(9).slice(-9))).
\$\endgroup\$
| as appropriate instead of the single space that appears in my comment.
\$\endgroup\$
-9*"D√⅜‘⁴"Hοr‘¹q x9*o±
Explanation:
"'|⁶.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
So how does the compressed string work?
The string converted from base250 to binary is
1000000100111110010100001110100000001100010001
and approxametally what it does:
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-competing, because language postdates the challenge. And this challenge is only a day old. I knew I should've put something up yesterday. I did this as a test for my language and it ended up too good not to post. Pretty sure this is golfable more too.
a=`--------- | | ---------`;b=`| | | `;console.log(a+` `+b+`xxxxxxxxx `+b+a)
Test here:
a=`---------
| |
---------`;b=`| | |
`;console.log(a+`
`+b+`xxxxxxxxx
`+b+a)b, as this means that you can remove the newline after xxxxxxxxx and the one that you add between a and b. You can save a further 3 bytes by setting a to --------- first and then concatenating the second row and a to itself.
\$\endgroup\$
This is the original answer (66 bytes):
<?=$a="---------
| |
---------
| | |
xxxx",x,strrev($a);
It generates a notice because of the unknown constant x. The notice can be suppressed by setting error_reporting=0 in php.ini or in the command line:
$ php -d error_reporting=0 tennis.php
The last line of the output doesn't end with a newline character.
The updated answer (62 bytes), improving an improvement suggested by @Titus:
<?=$a=($b="---------
| ")." |
$b| |
xxxx",x,strrev($a);
Run it without a configuration file (it defaults with error_reporting=0 this way):
$ php -n tennis.php
Both versions of the code contain literal new lines embedded in the string (1 byte shorter than \n) and cannot we unwrapped.
-d error_reporting=0, just use -n.
\$\endgroup\$
<?=$a=($b="---------\n|")."....
\$\endgroup\$
-n is much shorter than -d error_reporting=0 :-) There are, indeed, only 66 useful chars in the answer. I counted them using ls -l and forgot my vi is configured to ensure the file ends with a new line. I improved your improvement and squeezed 3 more bytes. Thank you.
\$\endgroup\$
<?=$a="---------
",$b="| |
$a",$c="| | |
","xxxxxxxxx
$c$a$b";
I almost hate it when it´s shorter like this than with calculating a little.
puts [b=[a=?-*9,"|%8s"%?|,a],c="| | |",?x*9,c,b]
Using the double simmetry, the lines are: 0-1-0 / 2-3-2 / 0-1-0, the loop can be easily unrolled and the nested list is flattened on output.
\|ddsssd7*.X--||"R\x5*nJs
d7* - " " * 7
.X--||" - grid(^, corners="-", sides="-", left="|", right="|")
\|dds - "| "
s - palindromise(^)
s - palindromise(^)
\x5* - "x" * 5
nJ - "\n".join(^)
s - palindromise(^)
'-9ש'|ð4׫û®…| ûû'x5×»û
Uses the CP-1252 encoding. Try it online!
Explanation:
'-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
9i-^[Y3pO||^[7i ^[YGPkP4lr|YpO^[9ix^[
This will print the tennis court into a vim buffer. ^M represents the Enter key (0x0d) and ^[ is the Escape key (0x1b). You can run these keystrokes/code by saving them to a file and running
vim -s <filename> -u NONE
If it has to be printed to stdout instead, you could save the buffer to a file (I used "a") and use whichever shell vim is set to use (I used bash) as well as the cat program in order to print the tennis court to stdout (51 bytes):
9i-^[Y3pO||^[7i ^[YGPkP4lr|YpO^[9ix^[:w!a|sil !cat %^M:q^M
It's the same as the earlier version but with :w!a|sil !cat %^M:q^M added onto the end
9$'-'([,(' '4}]),[,],'x',:])9$'| '
This works on the REPL, which is the standard way of using J:
9$'-'([,(' '4}]),[,],'x',:])9$'| '
---------
| |
---------
| | |
xxxxxxxxx
| | |
---------
| |
---------
With 41 bytes, I can print the result to STDOUT:
echo 9$'-'([,(' '4}]),[,],'x',:])9$'| '
I construct the tennis court one row at a time.
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.
($a='-'*9)
($b="| |")
$a
($c="| "*2+"|")
'x'*9
$c
$a
$b
$a
Just some string multiplication, setting variables, and ensuring they're encapsulated in parens to place copies on the pipeline. The default Write-Output at program completion gives us newlines between for free.
Thanks to @ConnorLSW for saving an obvious byte.
$(' '*7) is actually 8 chars, would be shorter to just do | | as spaces.
\$\endgroup\$
ToLower() save on my other answer ;)
\$\endgroup\$
a,b,c='-'*9,'| |','| | |'
for e in[a,b,a,c,'x'*9,c,a,b,a]:print e
Uses variables borrowed from @GurupadMamadapur
Alternative also for 75
a,b,c='-'*9,'| |','| | |'
print'\n'.join([a,b,a,c,'x'*9,c,a,b,a])
M-9 x RET : nine x's, return
C-SPC : set mark
| M-3 SPC | M-3 SPC | RET : pipe, three spaces, pipe, three spaces, pipe, return
M-9 - RET : nine hyphens, return
| M-7 SPC | RET : pipe, seven spaces, pipe, return
M-9 - RET : nine hyphens, return
C-x C-x : exchange point and mark, selecting region
M-w : copy region
C-p : previous line
C-y : yank copied text
M-x rev-r RET : execute reverse-region command
y=[[---------
| |
---------
]]z="| | |\n"io.write(y,z,"xxxxxxxxx\n",z,y)
I tried many methods, and yet this one proved the victor.
This question had 33 upvotes, and there were 33 answers, so I just had to post a 33 byte solution...
9:45;T`| `wT`| |`4dT5:120;w"
The code can be split into several parts, to make it easier to understand. The first part works like so:
9:45; \ Push the char '-' 9 times
T \ Push 10, which is a linefeed
`| ` \ Push these charcodes
The stack is now:
---------
|
The mirror operator, w, then mirrors the whole stack, producing:
---------
| |
---------
Then:
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
The stack is now beginning to look like the tennis court:
---------
| |
---------
| | |
xxxxx
To finish it, we use the mirror operator w once more, which reflects this string to produce the full tennis court.
---------
| |
---------
| | |
xxxxxxxxx
| | |
---------
| |
---------
All that's left now is to print, which is done by the " character.
Unix Shell; using dc and tr; 55 Bytes: ( Optimization of Mitchell Spector solution )
dc<<<4o16i3FFFFp20002prp20202p15555psrfrp|tr 0-3 ' x|-'
Others Solutions : Using sed; 81 Bytes;
echo "---| ---| |xxx| |---| ---"|sed "s/\(.\)\(.\)\(.\)/\1\2\2\2\3\2\2\2\1\n/g"
Using dc in function : 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
or
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
Using bc in function : 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
(('-'*9),'| |'+'-'*9+'| | |'+'x'*9)[0..4+3..0]
Explanation: straightforward half-of-the-court
('-----','| '+'-'*5+'| |'+'x'*5)[($r=0..4+3..0)]|%{-join$_[$r]}
Explanation: quarter-of-the-court uses the same indexes for both row and column display
