나는 갑자기 테니스를하고 싶지만 아아, 나는 법원이 없다!

놀라다! 이곳은 당신이 들어오는 곳입니다.

테니스 코트를 인쇄해야하지만 기밀로 인해 가능한 한 적은 바이트로 인쇄해야합니다.

테니스 코트

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

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

캔버스 , 13 바이트

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

여기 사용해보십시오!

파이썬 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

파이썬 3-73 72 바이트

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

파이썬 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]%'')}

언 골프

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

개행 문자 이외의 네 문자 만 원하는 출력에 표시되어 각 행을 기본 4 숫자로 코딩 할 수 있습니다. 이 숫자는 간결성을 위해 스크립트에서 16 진수로 기록됩니다.

Unix 계산기 dc는 base-16에서 base-4 로의 변환과 스택 조작에 모두 사용되어 올바른 위치에서 라인을 쉽게 반복 할 수 있습니다.

편집 : 문자를 코딩하는 데 사용되는 기본 4 자리 숫자 중 2 개를 교체하여 tr 명령을 이전 버전보다 1 바이트 더 짧게하여 1 바이트를 줄였습니다.

자바 스크립트, 85 바이트

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

자바 스크립트 (ES6), 86 84 83 81 바이트

Neil 덕분에 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 바이트

Neil이 제안한 내용 :

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

온라인으로 사용해보십시오!

아웃 고 프드 ...

자바 스크립트 (ES6), 86 바이트 :

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

여기에서 테스트하십시오.

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

출력의 마지막 줄은 개행 문자로 끝나지 않습니다.

@Titus가 제안한 개선 사항을 개선 한 업데이트 된 답변 (62 바이트) :

<?=$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 버퍼에 인쇄합니다. ^MEnter 키 (0x0d)를 나타내며 ^[Esc 키 (0x1b)입니다. 이 키 스트로크 / 코드를 파일에 저장하고 실행하여 실행할 수 있습니다.

vim -s <filename> -u NONE

표준 출력으로 인쇄

대신 stdout으로 인쇄 해야하는 경우 버퍼를 파일에 저장하고 ( "a"를 vim사용 bash) cat테니스 코트를 인쇄하기 위해 프로그램 뿐만 아니라 사용하도록 설정된 쉘 (I 사용 ) 을 사용할 수 있습니다 표준 출력 (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$'|   '

이것은 J를 사용하는 표준 방법 인 REPL에서 작동합니다.

   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에게 감사합니다.

파이썬 2, 75 바이트

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

@Gurupad에서 빌린 변수를 사용합니다

75에 대한 대안

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

이맥스, 43 35 키 스트로크

M-9 x RET: 9 개의 x, 리턴
C-SPC: 세트 마크
| M-3 SPC | M-3 SPC | RET: 파이프, 3 개의 스페이스, 파이프, 3 개의 스페이스, 파이프, 리턴
M-9 - RET: 9 개의 하이픈, 리턴
| M-7 SPC | RET: 파이프, 7 개의 스페이스, 파이프, 리턴
M-9 - RET: 9 개의 하이픈, 리턴
C-x C-x: 교환 점 및 마크, 선택 영역
M-w: 복사 영역
C-p: 이전 행
C-y: yank 복사 텍스트
M-x rev-r RET: reverse-region명령 실행

루아, 82 바이트.

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

나는 많은 방법을 시도했지만 이것이 승리자를 증명했다.

Pushy , 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
|   |   |
---------
|       |
---------

이제 남은 것은 "캐릭터 가 수행하는 인쇄 입니다.

유닉스 쉘; 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 

파워 쉘, 56 바이트

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

설명 : 간단한 법원

대안, 68 바이트

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

설명 : 법원은 행 및 열 표시에 동일한 색인을 사용합니다.