मैं अचानक टेनिस खेलना चाहता हूं, लेकिन अफसोस कि मेरे पास कोर्ट नहीं है!

आश्चर्य! यह वो जगह है जहां आप आते हैं।

आपको मेरे लिए एक टेनिस कोर्ट छापना होगा, लेकिन आपको गोपनीय कारणों के कारण इसे कम से कम बाइट्स में करना होगा।

टेनिस कोर्ट

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

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड है!

— डैनियल
स्रोत

1

अनुगामी न्यूलाइन की अनुमति है?

— को आउटगोल्फर को एरिक करें

1

पंक्ति 2 और 8 में बड़े अंतराल को टैब का उपयोग करके किया जा सकता है?

— FlipTack

3

@ Flp.Tkc, मुझे ऐसा नहीं लगता। मुझे लगता है कि पहले से पोस्ट किए गए छह जवाबों में कोई और नहीं जानता था कि, यह अनुचित होगा।

— डैनियल

2

यह इतने कम आउटपुट स्ट्रिंग के लिए आश्चर्यजनक रूप से मुश्किल चुनौती है! मुझें यह पसंद है। :)

— लिन

7

आप इस चुनौती को एक "डेनिस कोर्ट" कह सकते हैं क्योंकि हर कोई जानता है कि कौन जीतेगा ... :)

— रुडोल्फजेलिन

1

कैनवस , 13 बाइट्स

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

यहाँ कोशिश करो!

— dzaima
स्रोत

13

पायथन 2, 65 बाइट्स

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

Flp.Tkc ने एक बाइट को बचाया।

— लिन
स्रोत

यह कुछ पागल टुकड़ा करने की क्रिया है। अच्छा!

— गुरुपाद ममदापुर

आप एक बाइट को बचाने के '|'+' '*7लिए दूसरी स्ट्रिंग के लिए उपयोग कर सकते हैं s!

— दिसबंर

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 को नहीं तोड़ सकते।

— मैजिक ऑक्टोपस Urn

एक और 26 बाइट्स विकल्प ।

— केविन क्रूज़सेन

7

पायथन 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-tcc को जाता है । धन्यवाद :)

यहाँ कोशिश करो!

— गुरुपाद ममदापुर
स्रोत

6

/// , 64 56 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक और 56 बाइट समाधान:

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

— acrolith
स्रोत

6

वी , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह 23 बाइट्स होना चाहिए:

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

लेकिन मैं इसे बनाते समय कई बग में भाग गया। :(

— DJMcMayhem
स्रोत

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

जे, 70 54 51 50 बाइट्स

ज़र्ब के लिए एक बाइट धन्यवाद बचा लिया!

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 आह, अच्छा!

— कॉनर ओ'ब्रायन

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.

— स्तर नदी सेंट
स्रोत

4

बैश / यूनिक्स उपकरण, 58 57 बाइट्स

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

न्यूलाइन के अलावा केवल चार वर्ण वांछित आउटपुट में दिखाई देते हैं, जिससे प्रत्येक पंक्ति को आधार -4 नंबर के रूप में कोडित किया जा सकता है। इन नंबरों को स्क्रिप्ट में हेक्साडेसिमल में संक्षिप्तता के लिए लिखा जाता है।

यूनिक्स कैलकुलेटर डीसी को बेस -16 से बेस -4 रूपांतरण के लिए और स्टैक हेरफेर के लिए सही स्थानों पर लाइनों के आसान पुनरावृत्ति की अनुमति देने के लिए उपयोग किया जाता है।

संपादित करें: पिछले वर्णों की तुलना में एक बाइट कम होने के लिए tr कमांड को अनुमति देते हुए, वर्णों को कोड करने के लिए उपयोग किए गए आधार -4 अंकों में से दो को स्वैप करके एक बाइट को बंद कर दिया।

— मिशेल स्पेक्टर
स्रोत

4

जावास्क्रिप्ट, 85 बाइट्स

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

— नील
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 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 मुझे यकीन नहीं है कि इसे यहां केवल आउटपुट वापस करने की अनुमति है: आपको एक टेनिस कोर्ट प्रिंट करना होगा

— Arnauld

सरल रन लंबाई एन्कोडिंग आपके वैकल्पिक विधि की तुलना में बाइट से छोटी है: 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

एसओजीएल 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

तो संकुचित स्ट्रिंग कैसे काम करती है?

बेस 250 से बाइनरी में परिवर्तित स्ट्रिंग है 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

/// , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Outgolfed ...

— आउटग्रॉफर को एरिक करें
स्रोत

3

जावास्क्रिप्ट (ES6), 86 बाइट्स:

एक = `---------
| |
--------- `; ख =` | | |
`; Console.log (अ +`
`+ बी +` XXXXXXXXX
`+ बी + क)

यहाँ परीक्षण:

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

स्निपेट का विस्तार करें

— n4melyh4xor
स्रोत

की शुरुआत में एक नई पंक्ति जोड़कर आप 4 बाइट्स बचा सकते हैं b, क्योंकि इसका मतलब है कि आप उस नई पंक्ति को हटा सकते हैं जिसके बाद xxxxxxxxxआप aऔर जोड़ते हैं b। आप की स्थापना करके एक और 3 बाइट्स बचा सकते हैं aकरने के लिए ---------पहले और उसके बाद ही दूसरी पंक्ति और एक श्रृंखलाबद्ध।

— नील

3

05AB1E , 26 बाइट्स

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

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

बेहतर गोल्फ यह नीचे और अधिक!

— ओलिवर नी

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";

जब मैं थोड़ा गणना करके इस तरह से छोटा होता हूं तो मुझे लगभग इससे नफरत होती है।

— टाइटस
स्रोत

2

रूबी, 52 बाइट्स

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

डबल समरूपता का उपयोग करते हुए, लाइनें हैं: 0-1-0 / 2-3-2 / 0-1-0लूप को आसानी से अनियंत्रित किया जा सकता है और आउटपुट पर नेस्टेड सूची को चपटा किया जाता है।

— जीबी
स्रोत

2

पाइके, 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(^)

— नीला
स्रोत

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

विम, 32 बाइट्स

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

यह टेनिस कोर्ट को एक विमा बफर में प्रिंट करेगा। ^MEnter कुंजी (0x0d) का प्रतिनिधित्व करता ^[है और एस्केप कुंजी (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

जे, 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

पॉवरशेल , 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

पायथन 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

एमएसीएस, 43 35 कीस्ट्रोक्स

M-9 x RET: नौ x's, रिटर्न
C-SPC: सेट मार्क
| M-3 SPC | M-3 SPC | RET: पाइप, तीन रिक्त स्थान, पाइप, तीन रिक्त स्थान, पाइप, वापसी
M-9 - RET: नौ हाइफ़न, वापसी
| M-7 SPC | RET: पाइप, सात रिक्त स्थान, पाइप, वापसी
M-9 - RET: नौ हाइफ़न, वापसी
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

यूनिक्स शैल; डीसी और ट्रे का उपयोग करना; 55 बाइट्स: (मिशेल स्पेक्टर समाधान का अनुकूलन)

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

अन्य समाधान: sed का उपयोग करना; 81 बाइट्स;

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

फ़ंक्शन में डीसी का उपयोग करना: 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

फ़ंक्शन में बीसी का उपयोग करना: 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

— अली ISSA
स्रोत

1

पॉवरशेल, 56 बाइट्स

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

स्पष्टीकरण: सीधा आधा-अधूरा अदालत

वैकल्पिक, 68 बाइट्स

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

स्पष्टीकरण: क्वार्टर-ऑफ़-द-कोर्ट पंक्ति और स्तंभ प्रदर्शन दोनों के लिए समान अनुक्रमित का उपयोग करता है

— Mazzy
स्रोत

चलो टैनिस खेलते है

टेनिस कोर्ट

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड है!

कैनवस , 13 बाइट्स

पायथन 2, 65 बाइट्स

05AB1E ,29 27 26 बाइट्स

पायथन 3 - 73 72 बाइट्स

/// , 64 56 बाइट्स

वी , 25 बाइट्स

जेली , 25 बाइट्स

कैसे?

जे, 70 54 51 50 बाइट्स

रूबी, 60 बाइट्स

बैश / यूनिक्स उपकरण, 58 57 बाइट्स

जावास्क्रिप्ट, 85 बाइट्स

जावास्क्रिप्ट (ईएस 6), 86 84 83 81 बाइट्स

वैकल्पिक विधि # 1, 93 बाइट्स

वैकल्पिक विधि # 2, 86 बाइट्स

वैकल्पिक विधि # 3, 91 बाइट्स

एसओजीएल 0.5 , 24 23 20 बाइट्स (गैर-प्रतिस्पर्धात्मक)

/// , 59 बाइट्स

जावास्क्रिप्ट (ES6), 86 बाइट्स:

05AB1E , 26 बाइट्स

PHP, 66 62 बाइट्स

PHP, 72 बाइट्स

रूबी, 52 बाइट्स

पाइके, 28 26 25 बाइट्स

05AB1E, 25 बाइट्स

विम, 32 बाइट्स

स्टडआउट के लिए मुद्रण

जे, 36 बाइट्स

व्याख्या

पॉवरशेल , 67 66 बाइट्स

पायथन 2, 75 बाइट्स

एमएसीएस, 43 35 कीस्ट्रोक्स

लूआ, 82 बाइट्स।

पुष्य , 33 बाइट्स

व्याख्या

पॉवरशेल, 56 बाइट्स

वैकल्पिक, 68 बाइट्स