Я вдруг очень хочу поиграть в теннис, но увы у меня нет корта!

Сюрприз! Это где вы входите.

Вы должны напечатать теннисный корт для меня, но вы должны сделать это в наименьшем количестве байтов из соображений конфиденциальности.

Теннисный корт

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

Это код-гольф , поэтому выигрывает самый короткий код в байтах!

Холст , 13 байт

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

Попробуй это здесь!

Python 2, 65 байт

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

Flp.Tkc сохранил байт.

05AB1E ,29 27 26 байт

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

Python 3 - 73 72 байта

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

Python 3,6 - 75 байт

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

Кредит идет на flp-tkc . Спасибо :)

Попробуй здесь!

/// , 64 56 байт

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

Попробуйте онлайн!

Еще одно 56-байтовое решение:

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

V , 25 байтов

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

Попробуйте онлайн!

Это должно быть 23 байта:

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

Но я столкнулся с несколькими ошибками при создании. :(

Желе , 25 байт

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

TryItOnline!

Я надеялся использовать повторение в суде за 1,3,1 квартала, но не могу втиснуть это в меньшее (исходная версия - 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

J 70 54 51 50 байт

Спас Байт благодаря Zgarb!

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

Некоторая стандартная техника сжатия, использующая сжатый RLE.

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

Рубин, 60 байт

-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, 58 57 байт

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

Только четыре символа, кроме новой строки, появляются в желаемом выводе, что позволяет кодировать каждую строку как число base-4. Эти числа затем пишутся в шестнадцатеричном виде в сценарии, для краткости.

Unix калькулятор dc используется как для преобразования base-16 в base-4, так и для работы со стеком, что позволяет легко повторять строки в нужных местах.

Редактирование: сбрил один байт, поменяв местами две из четырех основных цифр, используемых для кодирования символов, что позволило команде tr быть на один байт короче, чем в предыдущей версии.

JavaScript, 85 байт

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

JavaScript (ES6), 86 84 83 81 байт

Сохранено 2 байта, благодаря Нейлу

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

Альтернативный метод № 1, 93 байта

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

Альтернативный метод № 2, 86 байт

Предложил Нил:

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

Альтернативный метод № 3, 91 байт

Рекурсивный подход:

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

SOGL 0,5 , 24 23 20 байт (не конкурирует)

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

Объяснение:

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

Так как же работает сжатая строка?

Строка, преобразованная из base250 в двоичную, 1000000100111110010100001110100000001100010001

и примерно то, что он делает:

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

неконкурентоспособен, потому что язык ставит перед нами задачу. И этому вызову всего один день. Я знал, что должен был что-то выложить вчера. Я сделал это в качестве теста для моего языка, и это оказалось слишком хорошо, чтобы не публиковать. Уверен, это еще и игра для гольфа.

/// , 59 байт

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

Попробуйте онлайн!

Outgolfed ...

Javascript (ES6), 86 байт:

а = `---------
| |
--------- `б =` | | |
`; Console.log (а +`
`+ B +` XXXXXXXXX
`+ Ь + а)

Тест здесь:

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

05AB1E , 26 байт

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

Использует кодировку CP-1252 . Попробуйте онлайн!

PHP, 66 62 байта

Это оригинальный ответ (66 байт):

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

Он генерирует уведомление из-за неизвестной константы x. Уведомление может быть подавлено путем установки error_reporting=0в php.iniили в командной строке:

$ php -d error_reporting=0 tennis.php

Последняя строка вывода не заканчивается символом новой строки.

Обновленный ответ (62 байта), улучшающий улучшение, предложенное @Titus:

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

Запустите его без файла конфигурации (по умолчанию error_reporting=0это так):

$ php -n tennis.php

Обе версии кода содержат буквально новые строки, встроенные в строку (на 1 байт короче \n), и мы не можем развернуть их.

PHP, 72 байта

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

Я почти ненавижу это, когда оно короче, чем немного подсчитать.

Рубин, 52 байта

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

Используя двойную симметрию, строки выглядят следующим образом: 0-1-0 / 2-3-2 / 0-1-0цикл можно легко развернуть, а вложенный список сгладится на выходе.

Пайк, 28 26 25 байт

\|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(^)

05AB1E, 25 байтов

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

Использует кодировку CP-1252 . Попробуйте онлайн!

Объяснение:

'-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 байта

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

Это распечатает теннисный корт в буфер vim. ^Mпредставляет клавишу ввода (0x0d) и ^[является клавишей Escape (0x1b). Вы можете запустить эти сочетания клавиш / код, сохранив их в файл и запустив

vim -s <filename> -u NONE

Печать на стандартный вывод

Если вместо этого он должен быть напечатан в stdout, вы можете сохранить буфер в файл (я использовал «a») и использовать любую установленную оболочку vim(я использовал bash), а также catпрограмму для печати теннисного корта в стандартный вывод (51 байт):

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

Это так же, как и в предыдущей версии, но с :w!a|sil !cat %^M:q^Mдобавлением в конце

J, 36 байт

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

Это работает на REPL, который является стандартным способом использования J:

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

С 41 байтом я могу напечатать результат в STDOUT:

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

Попробуйте онлайн!

объяснение

Я строю теннисный корт по одному ряду.

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 байт

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

Попробуйте онлайн!

Просто некоторое умножение строк, установка переменных и обеспечение их инкапсуляции в скобках для размещения копий в конвейере. Значение по умолчанию Write-Outputпри завершении программы дает нам новые строки между бесплатно.

Спасибо @ConnorLSW за сохранение очевидного байта.

Python 2, 75 байт

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

Использует переменные, заимствованные из @GurupadMamadapur

Альтернатива также для 75

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

Emacs, 43 35 нажатий клавиш

M-9 x RET: девять x, возврат
C-SPC: установка метки
| M-3 SPC | M-3 SPC | RET: pipe, три пробела, pipe, три пробела, pipe, возврат
M-9 - RET: девять дефисов, return
| M-7 SPC | RET: труба, семь пробелов, pipe, возврат
M-9 - RET: девять дефисов, return
C-x C-x: обменная точка и отметка, выбор региона
M-w: область копирования
C-p: предыдущая строка
C-y: скопировать текст
M-x rev-r RET: выполнить reverse-regionкоманду

Луа, 82 байта.

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

Я перепробовал много методов, и все же этот оказался победителем.

Напористый , 33 байта

На этот вопрос было 33 ответа, и было 33 ответа, поэтому мне просто пришлось опубликовать 33-байтовое решение ...

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

Попробуйте онлайн!

объяснение

Код может быть разбит на несколько частей, чтобы его было легче понять. Первая часть работает так:

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

Стек теперь:

---------
|

Затем зеркальный оператор, wзатем зеркалирует весь стек, создавая

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

Затем:

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

Стек теперь начинает выглядеть как теннисный корт:

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

Чтобы закончить это, мы wснова используем оператор зеркала , который отражает эту строку, чтобы получить полный теннисный корт.

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

Все, что осталось сейчас, это распечатать, что делает "персонаж.

Unix Shell; используя dc и tr; 55 байт: (Оптимизация решения Mitchell Spector)

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

Другие решения: использование sed; 81 байт;

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

Использование dc в функции: 88 байт

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

или же

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 

Использование bc в функции: 99 байт

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 байт

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

Объяснение: прямая половина дела

Альтернатива, 68 байт

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

Объяснение: четверть двора использует одинаковые индексы для отображения строк и столбцов