Nagle bardzo chcę grać w tenisa, ale niestety nie mam kortu!

Niespodzianka! Właśnie tam wchodzisz.

Musisz wydrukować dla mnie kort tenisowy, ale musisz to zrobić w jak najmniejszej liczbie bajtów z powodów poufnych.

Kort tenisowy

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

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach!

Płótno , 13 bajtów

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

Wypróbuj tutaj!

Python 2, 65 bajtów

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

Flp.Tkc zapisał bajt.

05AB1E ,29 27 26 bajtów

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

Wypróbuj 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 bajty

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

Python 3.6 - 75 bajtów

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

Kredyt trafia do flp-tkc . Dziękuję Ci :)

Wypróbuj tutaj!

/// , 64 56 bajtów

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

Wypróbuj online!

Kolejne rozwiązanie 56-bajtowe:

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

V , 25 bajtów

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

Wypróbuj online!

Powinno to być 23 bajty:

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

Ale podczas tworzenia natknąłem się na kilka błędów. :(

Galaretka , 25 bajtów

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

TryItOnline!

Miałem nadzieję, że zastosuję powtórzenie 1,3,1 kwartału, ale nie mogę tego wycisnąć na mniej (wersja surowa to 28:) “ßṂuB’b4s3x“¢¤¢‘ị“- x|”ŒBŒḄY.

W jaki sposób?

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

Oszczędność bajtu dzięki Zgarb!

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

Niektóre standardowe techniki kompresji przy użyciu skompresowanego pliku RLE.

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

Rubinowy, 60 bajtów

-4.upto(4){|i|puts''.rjust(9,%w{x |%3s - |%7s -}[i.abs]%'')}

Bez golfa

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

narzędzia bash / Unix, 58 57 bajtów

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

Na żądanym wyjściu pojawiają się tylko cztery znaki inne niż nowa linia, co pozwala na zakodowanie każdej linii jako liczby podstawowej 4. Liczby te są następnie zapisywane w skrypcie w systemie szesnastkowym, dla zwięzłości.

Kalkulator unix dc służy zarówno do konwersji base-16 do base-4, jak i do manipulacji stosami, aby umożliwić łatwe powtarzanie linii w odpowiednich miejscach.

Edycja: Ogolono jeden bajt, zamieniając dwie z 4 podstawowych cyfr używanych do kodowania znaków, dzięki czemu komenda tr może być o jeden bajt krótsza niż poprzednia wersja.

JavaScript, 85 bajtów

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

JavaScript (ES6), 86 84 83 81 bajtów

Zaoszczędzono 2 bajty dzięki Neilowi

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

Alternatywna metoda # 1, 93 bajty

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

Alternatywna metoda # 2, 86 bajtów

Sugerowane przez Neila:

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

Alternatywna metoda # 3, 91 bajtów

Podejście rekurencyjne:

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

SOGL 0,5 , 24 23 20 bajtów (niekonkurencyjny)

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

Wyjaśnienie:

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

Jak działa skompresowany ciąg?

Łańcuch przekonwertowany z base250 na binarny to 1000000100111110010100001110100000001100010001

i w przybliżeniu to, co robi:

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

niekonkurujące, ponieważ język jest datą na wyzwanie. A to wyzwanie ma dopiero jeden dzień. Wiedziałam, że powinnam coś wczoraj postawić. Zrobiłem to jako test dla mojego języka, który okazał się zbyt dobry, aby nie publikować. Jestem pewien, że jest to również bardziej do gry w golfa.

/// , 59 bajtów

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

Wypróbuj online!

Outgolfed ...

JavaScript (ES6), 86 bajtów:

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

Przetestuj tutaj:

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

05AB1E , 26 bajtów

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

PHP, 66 62 bajtów

Oto oryginalna odpowiedź (66 bajtów):

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

Generuje zawiadomienie z powodu nieznanej stałej x. Powiadomienie można ukryć, ustawiając error_reporting=0w php.iniwierszu poleceń lub w wierszu poleceń:

$ php -d error_reporting=0 tennis.php

Ostatni wiersz wyniku nie kończy się znakiem nowej linii.

Zaktualizowana odpowiedź (62 bajty), poprawiająca ulepszenie sugerowane przez @Titus:

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

Uruchom go bez pliku konfiguracyjnego (domyślnie w error_reporting=0ten sposób):

$ php -n tennis.php

Obie wersje kodu zawierają dosłownie nowe wiersze osadzone w ciągu (1 bajt krótszy niż \n) i nie możemy go rozpakować.

PHP, 72 bajty

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

Prawie nienawidzę tego, gdy jest tak krótszy niż przy odrobinie kalkulacji.

Ruby, 52 bajty

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

Korzystając z podwójnej symetrii, następujące linie: 0-1-0 / 2-3-2 / 0-1-0pętla może być łatwo rozwinięta, a lista zagnieżdżona jest spłaszczana na wyjściu.

Pyke, 28 26 25 bajtów

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

Wypróbuj tutaj!

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

05AB1E, 25 bajtów

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Wyjaśnienie:

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

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

Spowoduje to wydrukowanie kortu tenisowego w buforze vim. ^Mreprezentuje klawisz Enter (0x0d) i ^[jest klawiszem Escape (0x1b). Możesz uruchomić te naciśnięcia klawiszy / kod, zapisując je do pliku i uruchamiając

vim -s <filename> -u NONE

Drukowanie na standardowe wyjście

Jeśli zamiast tego trzeba go wydrukować na standardowym wyjściu, możesz zapisać bufor do pliku (użyłem „a”) i użyć dowolnej powłoki, która vimma być używana (użyłem bash), a także catprogramu, aby wydrukować kort tenisowy do standardowe wyjście (51 bajtów):

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

Jest taki sam jak wcześniejsza wersja, ale z :w!a|sil !cat %^M:q^Mdodanym na końcu

J, 36 bajtów

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

Działa to na REPL, który jest standardowym sposobem używania J:

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

Z 41 bajtami mogę wydrukować wynik do STDOUT:

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

Wypróbuj online!

Wyjaśnienie

Kort tenisowy buduję jeden rząd na raz.

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 bajtów

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

Wypróbuj online!

Wystarczy pomnożenie ciągu, ustawienie zmiennych i upewnienie się, że są one otoczone parenami w celu umieszczenia kopii w potoku. Domyślne ustawienie Write-Outputpo zakończeniu programu daje nam nowe linie pomiędzy za darmo.

Dzięki @ConnorLSW za zapisanie oczywistego bajtu.

Python 2, 75 bajtów

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

Wykorzystuje zmienne zapożyczone z @GurupadMamadapur

Alternatywa również dla 75

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

Emacs, 43 35 klawiszy

M-9 x RET: dziewięć x, powrót
C-SPC: set mark
| M-3 SPC | M-3 SPC | RET: rura, trzy spacje, rura, trzy spacje, rura, powrót
M-9 - RET: dziewięć łączników, powrót
| M-7 SPC | RET: rura, siedem spacji, rura, powrót
M-9 - RET: dziewięć łączników, powrót
C-x C-x: punkt wymiany i znak, wybór regionu
M-w: kopiuj region
C-p: poprzedni wiersz
C-y: yank skopiowany tekst
M-x rev-r RET: wykonaj reverse-regionpolecenie

Lua, 82 bajty.

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

Próbowałem wielu metod, a jednak ta okazała się zwycięzcą.

Pushy , 33 bajty

To pytanie miało 33 pozytywne głosy i były 33 odpowiedzi, więc musiałem tylko opublikować 33-bajtowe rozwiązanie ...

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

Wypróbuj online!

Wyjaśnienie

Kod można podzielić na kilka części, aby ułatwić jego zrozumienie. Pierwsza część działa tak:

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

Stos jest teraz:

---------
|

Operator wlustra następnie odzwierciedla cały stos, wytwarzając:

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

Następnie:

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

Stos zaczyna teraz wyglądać jak kort tenisowy:

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

Aby to zakończyć, ponownie używamy operatora lustra w, który odbija ten sznurek, aby uzyskać pełny kort tenisowy.

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

Teraz pozostaje tylko wydrukować, co robi "postać.

Powłoka Unix; używając dc i tr; 55 bajtów: (Optymalizacja rozwiązania Mitchell Spector)

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

Inne rozwiązania: Korzystanie z sed; 81 bajtów;

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

Korzystanie z funkcji DC w funkcji: 88 bajtów

b(){ dc<<<2o16i1${1}p|tr '01' ' '$2;};(b FF -;b 01 \|;b FF -;b 11 \|)>f;cat f;b FF X;tac f

lub

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 

Używanie bc w funkcji: 99 bajtów

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 bajtów

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

Wyjaśnienie: prosta połowa sądu

Alternatywnie, 68 bajtów

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

Objaśnienie: Sędzia stosuje te same indeksy do wyświetlania wierszy i kolumn