Давай сыграем в теннис

45

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

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

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

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

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

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

code-golf  string  ascii-art  kolmogorov-complexity 
— Даниил
источник
1
Трейлинг новой строки разрешен?
— Эрик Outgolfer
1
Можно ли сделать большие пропуски в строках 2 и 8 с помощью вкладок?
— FlipTack
3
@ Flp.Tkc, я так не думаю. Думаю, поскольку никто из шести уже опубликованных ответов не знал об этом, это было бы несправедливо.
— Даниэль
2
Это удивительно сложная задача для такой короткой строки вывода! Мне это нравится. :)
— Линн
7
Вы можете просто назвать этот вызов «Деннис корт», так как все знают, кто все равно победит ... :)
— RudolfJelin

Ответы:

13

Python 2, 65 байт

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

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

— Линн
источник
Это какая-то сумасшедшая нарезка. Приятно!
— Гурупад Мамадапур
Вы можете использовать '|'+' '*7для второй строки, sчтобы сохранить байт!
— FlipTack
12

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
— Osable
источник
9'-×D'|4ð׫©ûs®¨'|«û5'x×»ûпопробовал рефакторинг немного, не могу сломать 26.
— Волшебная урна осьминога
— Кевин Круйссен
6

Желе , 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
— Джонатан Аллан
источник
5

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
|   |   |
---------
|       |
---------
— Конор О'Брайен
источник
Переупорядочить и сохранить байт:9 9$'-| |-| | |x| | |'#~3 9 1 7{~4#.inv 1851926050
— Zgarb
@ Zgarb ах, приятно!
— Конор О'Брайен
4

Рубин, 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.
— Уровень реки St
источник
4

инструменты bash / Unix, 58 57 байт

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

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

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

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

— Митчелл Спектор
источник
4

JavaScript, 85 байт

console.log('---|  ---| |xxx| |---|  ---'.replace(/(.)((.).)/g,'$1$3$3$2$3$3$3$1\n'))
— Нил
источник
4

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))
— Arnauld
источник
Вы можете сделать это функцией, чтобы сохранить несколько байтов.
— Конор О'Брайен
@ ConorO'Brien Я не уверен, что здесь разрешено просто возвращать результат: вы должны напечатать теннисный корт
— Арно
Простое кодирование длины строки на байт короче вашего альтернативного метода: 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])))( \nочевидно, замените его на символ новой строки).
— Нил
Другая формулировка 92-байтовый: console.log('-\n |\n-\n |\nx\n |\n-\n |\n-'.replace(/.*/g,s=>s.repeat(9).slice(-9))).
— Нил
Извините, должно быть 7 или 3 пробела перед каждым, |в зависимости от ситуации, вместо одного пробела, который появляется в моем комментарии.
— Нил
4

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

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

— dzaima
источник
3

Javascript (ES6), 86 байт:

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

Тест здесь:

a=`---------
|       |
---------`;b=`|   |   |
`;console.log(a+`
`+b+`xxxxxxxxx
`+b+a)
Развернуть фрагмент

— n4melyh4xor
источник
Вы можете сохранить 4 байта, добавив символ новой строки в начале b, поскольку это означает, что вы можете удалить символ новой строки после xxxxxxxxxи тот, который вы добавили между aи b. Вы можете сэкономить еще 3 байта, установив aв ---------первом , а затем сцеплению второй строки и к самому себе.
— Нил
3

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), и мы не можем развернуть их.

— axiac
источник
1
Уведомления отключены в конфигурации по умолчанию; не нужно -d error_reporting=0, просто используйте -n.
— Тит
Я считаю 66. Вы можете сделать их 65 с <?=$a=($b="---------\n|")."....
— Тит
@ Титус, мне нравится твое предложение. -nнамного короче -d error_reporting=0:-) В ответе всего 66 полезных символов. Я посчитал их, используя ls -lи забыл, что мой viнастроен, чтобы файл заканчивался новой строкой. Я улучшил ваше улучшение и сжал еще 3 байта. Спасибо.
— Аксиак
2

PHP, 72 байта

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

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

— Titus
источник
2

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

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

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

— гигабайт
источник
2

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
— Оливер Ни
источник
2

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добавлением в конце

— Сэм
источник
2

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.
— Zgarb
источник
2

PowerShell , 67 66 байт

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

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

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

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

— AdmBorkBork
источник
$(' '*7)на самом деле 8 символов, было бы короче просто | |как пробелы.
— colsw
@ConnorLSW О, ха-ха. Спасибо за очевидный гольф! : D
— AdmBorkBork
просто возвращаю тебе ToLower()
— colsw
1

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])
— ElPedro
источник
1

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команду

— Шон
источник
1

Луа, 82 байта.

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

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

— Ataco
источник
1

Напористый , 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
|   |   |
---------
|       |
---------

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

— FlipTack
источник
1

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
— Али ИССА
источник
1

Powershell, 56 байт

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

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

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

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

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

— Mazzy
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.