एक लेगो टुकड़ा प्रिंट करें

Question

यह चुनौती एक सरल आस्की-कला है। दो आदानों को देखते हुए, एक लेगो टुकड़े की ऊंचाई और चौड़ाई का वर्णन करते हुए, आपके पास इसका ASCII कला प्रतिनिधित्व है।

यहाँ देखा गया है कि लेगो के टुकड़े कैसे दिखते हैं:

(4, 2)

___________
| o o o o |
| o o o o |
-----------

(8, 2)

___________________
| o o o o o o o o |
| o o o o o o o o |
-------------------

(4, 4)

___________
| o o o o |
| o o o o |
| o o o o |
| o o o o |
-----------

(3, 2)

_________
| o o o |
| o o o |
---------

(1, 1)

o

यदि आप परीक्षण-मामलों से नहीं बता सकते हैं, तो ऊपर और नीचे width*2+3अंडरस्कोर और डैश हैं, और प्रत्येक पंक्ति में पक्षों के लिए पाइप oहैं, छोटी चीज़ों के लिए, और सब कुछ रिक्त स्थान द्वारा अलग किया गया है।

इसके लिए एकमात्र अपवाद है (1, 1), जो सिर्फ एक है o।

आप 0किसी भी आयाम के लिए कभी नहीं मिलेंगे ।

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

var QUESTION_ID=84050,OVERRIDE_USER=31343;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Comments

क्या यह संभव है कि चौड़ाई या ऊंचाई 10 से अधिक होगी? हमें किस रेंज का समर्थन करना चाहिए?

— DJMcMayhem

विशेष मामला एक असली बमर है।

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

अगले कुछ वर्षों में, मैं एक और "प्रिंट ए लेगो पीस" चुनौती देखना चाहता हूं जिसमें लेगो का उत्पादन करने के लिए एक 3 डी प्रिंटर बताने के लिए कोड लिखने की आवश्यकता है।

— केविन -

रुको, "जो भी पूर्णांक आपकी भाषा का समर्थन करता है"? कि लेगो कैसे काम नहीं करता है। ईंटें केवल कुछ विशिष्ट आयामों में उपलब्ध हैं। यहां तक ​​कि अगर आप प्लेटों में जोड़ते हैं, तो आपको केवल एक जोड़ी मिलती है। कोई भी स्क्रिप्ट जो इनपुट को नहीं छोड़ती है जैसे (1,7) या (5,3) पूरा कचरा।

— रेगडाइट

सिंगल पीस (1,1) के किनारे क्यों नहीं हैं? क्यूब के ऊपर एक सिंगल निप्पल के साथ एक वास्तविक लेगो टुकड़ा है।

— tcrosley

Answer 1

Befunge , 165 227 बाइट्स

&::&*:1` v
v+3*2:\/\_"o",@
v       _$ v<
>"_",1-:^  2
v:,,"| ",*5<
v         _v
>" o",,1-:^$
>*v>\     #\^
5 #|:-1,"|"<
^2$<
v1, *95<
- >2*3+^
>:    #^_@

पहले जितना व्हाट्सएप नहीं था, लेकिन अभी भी अंतराल हैं। सिद्धांत पिछले समाधान के समान है, लेकिन लेआउट अलग है। इस बार, यह जांचने के लिए कि क्या दोनों संख्याएं 1 हैं, मैं सिर्फ उनका उत्पाद ले रहा हूं और देख रहा हूं कि परिणाम 1 से अधिक है या नहीं।

---

पुराना समाधान (227 बाइट्स)

v           v       <
&   >>\:2*3+>"_",1-:|
>&:1`|v ,,"| ",*52:$<   :\<
    #\v         <
     :>" o",,1-:|
     1          >"|",$\1-:|
    \`            @       $
    ^_"o",@>:!    |       2
           ^-1,*95<+3*2,*5<

इसे और अधिक गोल्फ करना संभव हो सकता है। जरा वो सब व्हाट्सएप तो देखो!

यहाँ MSPaint चित्र के रूप में एक स्पष्टीकरण में मेरा खराब प्रयास है: तीर की दिशा में कोड बहता है।

Comments

ओह। मेरे। परमेश्वर। मेरे दिमाग को उड़ा देता है

— lukas.pukenis

Answer 2

वी , 43, 40, 38 36 बाइट्स

मेरे द्वारा लिखे गए सबसे लंबे V उत्तरों में से एक ...

Àio ddÀPñóo î½o
u2Pí.«/| °|
Vr-HVr_

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

चूँकि इसमें यूनिकोड और unprintable अक्षर शामिल हैं, यहाँ एक प्रतिवर्ती हेक्सडंप है:

0000000: c069 6f20 1b64 64c0 50f1 f36f 20ee bd6f  .io .dd.P..o ..o
0000010: 0d0a 7532 50ed 2eab 2f7c 20b0 7c0d 0a56  ..u2P.../| .|..V
0000020: 722d 4856 725f                           r-HVr_

यह चुनौती पाठ में हेरफेर करने के बारे में है, इसलिए वी के लिए एकदम सही है! दूसरी ओर, वी सशर्त और गणित में भयानक है, इसलिए (1, 1) के लिए अलग-अलग आउटपुट ने वास्तव में इसे खराब कर दिया ... ...

स्पष्टीकरण:

À                   "Arg1 times:
 io <esc>           "Insert 'o '
         dd         "Delete this line, and
           À        "Arg2 times:
            P       "Paste it

अब हमारे पास उनके बीच रिक्त स्थान के साथ ओ की 'ऊँचाई' रेखाएँ हैं।

ñ                   "Wrap all of the next lines in a macro. This makes it so that if any 
                    "Search fails, execution will stop (to handle for the [1, 1] case)
 ó                  "Search and replace
  o î½o             "'o'+space+0 or 1 newlines+another 'o'

u                   "Undo this last search/replace
 2P                 "Paste twice
   í                "Search and replace on every line
    .«/| °|         "A compressed regex. This surrounds every non-empty line with bars.

Vr-                 "Replace the current (last) line with '-'
   H                "Move to line one
    Vr_             "Replace this line with '_'

गैर-प्रतिस्पर्धात्मक संस्करण (31 बाइट्स):

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

यह संस्करण कई विशेषताओं का उपयोग करता है जो नए हैं तो यह चुनौती 5 बाइट्स से कम है!

दूसरा स्पष्टीकरण:

ddÀP

जो "डिलीट लाइन है, और इसे n बार पेस्ट करें " को बदल दिया जाता है, ÀÄजिसके साथ "यह लाइन n बार दोहराएं " है। (-2 बाइट्स)

óo î½o
u

जो इस रेगेक्स के पहले मैच को "पूर्ववत करें" को बदल दिया गया था

/o î½o

जो कि "इस रेगेक्स के एक मैच के लिए खोज" है (-1 बाइट)

और अंत में, Òबस एक सरल पर्यायवाची है Vr, जो दोनों "इस लाइन पर प्रत्येक वर्ण को 'x' से प्रतिस्थापित करते हैं।" (-2 बाइट्स)

Comments

यह कैसे आता है नीचे इस v.tryitonline.net/… के

— मीटर

@ मैं एक सच में पता नहीं है। यह 50x959 पर काम करता है लेकिन यदि आप इसकी चौड़ाई या ऊँचाई बढ़ाते हैं तो यह काम करना बंद कर देता है। मैं यह अनुमान लगा रहा हूं कि यह बहुत संभावना है कि बेहद बड़े कार्यक्रमों को चलाने से रोकने के लिए जानबूझकर वेबसाइट पर प्रतिबंध लगाया गया है।

— डीजेएमसीमेम

TIO आउटपुट को 100 KB तक सीमित करता है , मुख्य रूप से आपके ब्राउज़र को क्रैश होने से रोकने के लिए।

— डेनिस

Answer 3

32 16-बिट लिटिल-एंडियन x86 मशीन कोड, 57 54 51 बाइट्स

3 बाइट्स @ninjalj को कम धन्यवाद।

भारी कोड फिर से लिखा और एक और 3 बाइट्स दाढ़ी बनाने में कामयाब रहे

हेक्स में

FCBA6F208D48FFE20492AAEB2389D941D1E14151B05FF3AAEB0BB87C20AB89D992F3AB92AAB00AAA4E7DEF59B02DF3AA91AAC3

इनपुट: बीएक्स = चौड़ाई, एसआई = ऊंचाई, डीआई उस बफर को इंगित करता है जो "N \" द्वारा अलग लाइनों के साथ एक पूर्ण-समाप्त स्ट्रिंग के रूप में परिणाम प्राप्त करता है।

disassembly:

fc            cld
ba 6f 20      mov    dx,0x206f      ;Storing ' o' in DX for later use
8d 48 ff      lea    cx,[bx+si-0x1] ;CX=width+height-1
e2 04         loop   _main0         ;--CX & brahch if not zero
92            xchg   dx,ax          ;(1,1) case, swap DX & AX
aa            stosb                 ;AL == 'o', CX == 0
eb 23         jmp    _end
_main0:
89 d9         mov    cx,bx
41            inc    cx
d1 e1         shl    cx,1
41            inc    cx           ;Calculate (width+1)*2+1
51            push   cx           ;and save it for future use
b0 5f         mov    al,0x5f      ;'_'
f3 aa         rep    stosb        ;Output the whole line of them
eb 0b         jmp    _loopstart   ;Jump into the loop
_loop:
b8 7c 20      mov    ax,0x207c    ;' |'
ab            stosw               ;Output it once (left bar + space)
89 d9         mov    cx,bx        ;Copy width
92            xchg   dx,ax        ;AX == ' o'
f3 ab         rep    stosw        ;Output it CX times
92            xchg   dx,ax        ;Swap values back, AL == '|'
aa            stosb               ;Output only the right bar
_loopstart:
b0 0a         mov    al,0x0a      ;Newline. Can be replaced with mov ax,0x0a0d for windows newline
aa            stosb               ;convention (at the cost of 1 byte), with stosb replaced with stosw
4e            dec    si           ;Height--
7d ef         jge    _loop        ;Continue if si >= 0 (this accounts for the dummy first pass)
59            pop    cx
b0 2d         mov    al,0x2d      ;'-'
f3 aa         rep    stosb        ;Output bottom line
_end:
91            xchg   cx,ax        ;CX == 0, so swap to get zero in AL
aa            stosb               ;NULL-terminate output
c3            retn

Comments

16-बिट के रूप में छोटा होगा: 3 66h उपसर्गों के लिए -3 बाइट्स, "\ r \ n" लाइन समाप्ति के लिए +1 बाइट।

— नंजलज

आपको पठनीयता के लिए, बाइट-आउट संख्याओं और वर्तमान संख्याओं के बीच रिक्त स्थान रखना चाहिए।

— वैल्यू इंक।

Answer 4

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

lambda x,y:(x*'__'+'___\n'+('| '+'o '*x+'|\n')*y+'-'*(x*2+3),'o')[x<2>y]

1,1 ब्लॉक को संभालने के लिए एक सशर्त के साथ एक स्ट्रिंग लौटाता है।

दो बाइट्स के लिए लिन और चेपनर को धन्यवाद

Comments

lambda x,y:('_'*x*2+'___\n'+आदि एक बाइट बचाता है।

— लिन

के x*'__'बजाय एक और बाइट से दस्तक 2*x*'_'।

— शेपनर

बस इस Comunity से जुड़ें, पूछने के लिए क्षमा करें। मैं इसे कैसे देख सकता हूं? मैं इसे टर्मिनल में पेस्ट करता हूं और सिर्फ प्रिंट करता हूं <function <lambda> at 0x......>। मैं यह कैसे परीक्षण कर सकते हैं?

— मिगेल

@ मिगेल ने इसे एक वैरिएबल को असाइन किया। यह समारोह का मान f=lambda x:x+1; print(f(9))

— लौटाएगा

एक और सवाल अगर जवाब देने के लिए जटिल नहीं है। आप बिट्स को इतनी सटीकता से कैसे पहचान सकते हैं?

— मिगेल

Answer 5

सीजेएम, 34

'_q~'o*"||"\*S*f*f+'-f+zN*_,H='o@?

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

स्पष्टीकरण:

'_        push a '_' character
q~        read and evaluate the input (height and width)
'o*       repeat the 'o' character <width> times
"||"\*    join the "||" string by the string of o's (putting them in between)
S*        join with spaces (inserting a space between every 2 characters)
f*        repeat each character <height> times, making it a separate string
f+        prepend '_' to each string
'-f+      append '-' to each string
z         transpose the array of strings
N*        join with newlines; lego piece is ready, special case to follow
_,        duplicate the string and get its length
H=        compare with H=17
'o        push 'o' for the true case
@         bring the lego piece to the top for the false case
?         if the length was 17, use 'o' else use the lego piece

Answer 6

रूबी, 59 56 बाइट्स

बेनामी फ़ंक्शन, एक बहुस्तरीय स्ट्रिंग लौटाता है। इसे ऑनलाइन आज़माएं!

-3 बाइट्स @ El'endiaStarman से एक चाल उधार लेने के लिए धन्यवाद

->w,h{w*h<2??o:?_*(x=2*w+3)+$/+(?|+' o'*w+" |
")*h+?-*x}

Answer 7

जावा, 318 312 297 294 260 258 बाइट्स

15 बाइट्स को बचाने के लिए धन्यवाद क्लिफरॉट !

interface a{static void main(String[]A){int b=Byte.valueOf(A[0]),B=Byte.valueOf(A[1]),C=3+b*2;String c="";if(b<2&B<2)c="o";else{for(;C-->0;)c+="_";for(;B-->0;){c+="\n|";for(C=b;C-->0;)c+=" o";c+=" |";}c+="\n";for(C=3+b*2;C-->0;)c+="-";}System.out.print(c);}}

यह कमांड लाइन तर्कों के साथ काम करता है।

मानव-पठनीय रूप में अनगुल्फेड :

interface a {
    static void main(String[] A) {
        int b = Byte.valueOf(A[0]),
            B = Byte.valueOf(A[1]),
            C = 3 + b*2;
        String c = "";
        if (b < 2 & B < 2)
            c = "o";
        else {
            for (; C-- > 0;)
                c += "_";
            for (; B-- > 0;) {
                c += "\n|";
                for (C = b; C-- >0;)
                    c += " o";
                c += " |";
            }
            c += "\n";
            for(C = 3 + b*2; C-- >0;)
                c += "-";
        }
        System.out.print(c);
    }
}

---

हां, यह समझना अभी भी मुश्किल है कि कार्यक्रम के अनफॉलो होने पर भी क्या हो रहा है। तो यहाँ चरण दर चरण स्पष्टीकरण दिया गया है:

static void main(String[] A)

पहले दो कमांड लाइन तर्क-जो हम आयाम प्राप्त करने के लिए उपयोग करेंगे- को प्रोग्राम में A[0]और A[1](क्रमशः) में उपयोग किया जा सकता है ।

int b = Byte.valueOf(A[0]),
    B = Byte.valueOf(A[1]),
    C = 3 + b*2;
String c = "";

bस्तंभों Bकी संख्या है, पंक्तियों की संख्या है और लूप Cमें उपयोग के लिए समर्पित एक चर forहै।

cलेगो टुकड़ा है। हम इसे पंक्तियों को जोड़ देंगे और फिर इसे अंत में प्रिंट करेंगे।

if (b < 2 & B < 2)
    c = "o";
else {

यदि मुद्रित किया जाने वाला टुकड़ा 1x1 है, तो दोनों b(स्तंभों की संख्या) और B(पंक्तियों की संख्या) 2 से छोटा होना चाहिए। इसलिए हम बस cएक ही सेट करते हैं oऔर फिर कथन को छोड़ देते हैं कि System.out.printयदि मामला है तो।

for (; C-- > 0; C)
    c += "_";

यहाँ, हम को (integerValueOfA[0] * 2) + 3रेखांकित करते हैं c। यह सभी छेदों के ऊपर सबसे ऊपरी पंक्ति है।

for (; B > 0; B--) {
    c += "\n|";
    for(C = b; C-- > 0;)
        c+=" o";
    c += " |";
}

यह लूप है जहां हम एक बार में एक पंक्ति का निर्माण करते हैं। अंदर क्या चल रहा है बिना उदाहरण के समझाना असंभव है। मान लीजिए कि टुकड़ा 4x4 है:

Before entering the loop, c looks like this:
___________

After the first iteration (\n denotes a line feed):
___________\n
| o o o o |

After the second iteration:
___________\n
| o o o o |\n
| o o o o |

After the third iteration:
___________\n
| o o o o |\n
| o o o o |\n
| o o o o |

।

c += "\n";
for (C = 3 + b*2; C-- > 0;)
    c += "-";

यहां, हम (integerValueOfA[0] * 2) + 3टुकड़े को हाइफ़न जोड़ते हैं । यह सभी छेदों के नीचे, बहुत नीचे की पंक्ति है।

4x4 टुकड़ा जिसका उपयोग मैंने उस forलूप को समझाने के लिए किया था जहाँ वास्तव में इस टुकड़े का निर्माण किया गया था अब इस तरह दिखता है:

___________\n
| o o o o |\n
| o o o o |\n
| o o o o |\n
| o o o o |\n
-----------

System.out.print(c);

और अंत में, हम टुकड़ा प्रिंट करते हैं!

Comments

संभवतः संशोधन 3 ने इसे सबसे लंबा पोस्ट बनाया है जो मैंने स्टैक एक्सचेंज पर बनाया है।

— दोरुखान

आप लूप Cसे चर को स्थानांतरित कर सकते हैं । आपके सभी छोरों में यह भी लगता है जैसे आप चेक का उपयोग कर सकते हैं , इसे 298, pastebin.com/uj42JueLforint b=Byte.valueOf(A[0]),B=Byte.valueOf(A[1]),CC-->0;

— cliffroot

कुछ forबाइट्स के लिए लूप्स के कुछ रचनात्मक उपयोग सहेजे गए - pastebin.com/dhNCpi6n

— cliffroot

यदि आप अपने तर्कों को पहले बाइट्स में परिवर्तित करते हैं, तो आपकी जांच ईंट का आकार 1x1 है, if(b==1&B==1)जो आपको 20 बाइट्स को बचाने की अनुमति देगा

— user902383

इसके अलावा मामले के लिए 1x1 करने के बजाय System.out.print('o');return;, आप c='o'अन्य ब्लॉक में अलग-अलग ईंटों के लिए तर्क सेट और रख सकते हैं । तब सिंगल प्रिंट स्टेटमेंट और नो रिटर्न आपको कुछ अतिरिक्त बाइट्स बचाने की अनुमति देता है

— user902383

Answer 8

मिंकोलंग 0.15 , 58 57 56 बाइट्स

हाँ य़ह सही हैं। मैं एक दो बदबूदार 'छोटे बाइट्स ...

nn$d*1-5&"o"O.rd2*3+$z1$([" o"]" ||"2Rlkr$Dlz["-_"0G]$O.

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

व्याख्या

nn                Take two numbers from input (stack is now [w h])

                  C special case C
  $d              Duplicate stack
    *1-           Multiply and subtract 1
       5&         Jump 5 spaces if truthy
         "o"O.    Top of stack was 1*1-1=0, so output "o" and stop.

                     C precalculates width of top and bottom lines for later use C
         r           Reverse stack (now [h w])
          d          Duplicate top of stack
           2*3+      Multiply top of stack by 2 and add 3
               $z    Pop this and store in register (z = 2*w+3)

                                       C generates the row C
                 1$(                   Open while loop prepopulated with top of stack
                    [" o"]             w times, push "o "
                          " ||"        Push "|| "
                               2R      Rotate twice to the right
                                 l     Push newline (10)
                                  k    Break out of while loop

                                           C duplicates the row h times C
                                   r       Reverse stack
                                    $D     Duplicate whole stack h times
                                      l    Push newline

                     C this is for the top and bottom lines C
        z[           Open for loop that repeats z times
          "-_"       Push "_-"
              0G     Relocate top of stack to bottom of stack
                ]    Close for loop

                 $O.    Output whole stack as characters and stop.

ठीक है, दो बाइट्स के लिए स्पष्टीकरण के दो महत्वपूर्ण पुनर्लेखन हैं जो सहेजे गए हैं। मुझे नहीं लगता कि मैं इसमें से कुछ भी निकाल सकता हूं या नहीं। : पी

Comments

पहला बाइट सबसे मुश्किल कदम है ... 1000 बाइट की शुरुआत एक ही बिट से होती है ...

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

Answer 9

ब्रेनफक, 391 बाइट्स

मुझे पता है कि यह और नीचे गिराया जा सकता है, लेकिन इस बिंदु पर मुझे खुशी है कि यह काम करता है। मैं इसे नीचे गोल्फ के लिए काम करना जारी रखूंगा।

+++++[-<+++[-<+++<++++++<+++++++<++<++++++++>>>>>]<<+<+<<+<++>>>>>>>]<<<<+<++<->>>>>>,<,>>++++++[<--------<-------->>-]<<->>+<<[>>-<<[>>>+<<<-]]>>>[<<<+>>>-]<[<->>>+<<<[>>>-<<<[>>>>+<<<<-]]>>>>[<<<<+>>>>-]<[<<<<<<<.[-].]<<<+>-]<<+>[->++>+<<]>+++[-<<<<.>>>>]>[-<<+>>]<<<<<<<<<.>>>>>>><[->[->+>+<<]<<<<<<.>>>>>>>[<<<<<<.>.>>>>>-]>[-<<+>>]<<<<<<<.<.<.>>>>>>]>[->++>+<<]>+++[-<<<.>>>]>[-<<+>>]<<

इनपुट को केवल दो अंकों के रूप में दिए जाने की आवश्यकता है। के रूप में करने के लिए, (8, 2)आप बस में प्रवेश करेंगे 82।

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

टूट - फूट:

पहले आवश्यक पात्रों को टेप में डालें: (newline)| o_-

+++++[-<+++[-<+++<++++++<+++++++<++<++++++++>>>>>]<<+<+<<+<++>>>>>>>]<<<<+<++<->>>>>

फिर इनपुट को दो कोशिकाओं में इकट्ठा करें और प्रत्येक से 48 घटाएं (संख्यात्मक मान प्राप्त करने के लिए और अंक वर्ण नहीं)

>,<,>>++++++[<--------<-------->>-]<<

अगला, विशेष मामले के लिए जांचें (1, 1)(ध्यान दें कि यह चेक कोड के 109 बाइट्स के लिए खाता है)। जैसे कि ifब्रेनफक में करना मुश्किल नहीं था, हमारे पास एक नेस्टेड है if:

->>+<<[>>-<<[>>>+<<<-]]>>>[<<<+>>>-]<[<->>>+<<<[>>>-<<<[>>>>+<<<<-]]>>>>[<<<<+>>>>-]<[<<<<<<<.[-].]<<<+>-]<<+

निम्नलिखित जांचने के लिए संरचना है कि क्या सेल x शून्य है या नॉनजरो:

temp0[-]+
temp1[-]
x[
 code1
 temp0-
 x[temp1+x-]
]
temp1[x+temp1-]
temp0[
 code2
temp0-]

हालाँकि, एक नेस्टेड में if, हमें 4 अस्थायी कोशिकाएँ चाहिए।

अब हम पात्रों के वास्तविक मुद्रण के लिए आते हैं:

शीर्ष बार और एक नई रेखा प्रिंट करें:

>[->++>+<<]>+++[-<<<<.>>>>]>[-<<+>>]<<<<<<<<<.>>>>>>>

प्रिंट करें |, एक पंक्ति o, दूसरी |और एक नई पंक्ति कई बार ऊंचाई के बराबर होती है:

<[->[->+>+<<]<<<<<<.>>>>>>>[<<<<<<.>.>>>>>-]>[-<<+>>]<<<<<<<.<.<.>>>>>>] 

और नीचे पट्टी प्रिंट (कोई नई लाइन यहाँ की जरूरत है):

>[->++>+<<]>+++[-<<<.>>>]>[-<<+>>]<<

Answer 10

रेटिना , 52 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। ध्यान दें कि छठी पंक्ति में एकल स्थान होना चाहिए।

\G1?
$_¶
1* 



.+
|$&|
\G.
_
r`.\G
-
s`^.{17}$|1
o

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

इनपुट यूनीरी में है, 1यूनिरी डिजिट के रूप में, एक विभाजक के रूप में स्थान और ऊंचाई के बाद ऊंचाई।

व्याख्या

इस कार्यक्रम के सभी चरण नंगे प्रतिस्थापन हैं, कभी-कभी एक नियमित रेगेक्स संशोधक (कोई पुनरावृत्ति या छोरों, अन्य प्रकार के चरणों) के साथ नहीं। यह रेटिना-विशिष्ट प्रतिस्थापन सुविधाओं का उपयोग नहीं करता है, इसके अलावा ¶लाइनफीड्स के लिए सामान्य उपनाम से भी ।

\G1?
$_¶

इसका उद्देश्य दोनों इनपुट को "गुणा" करना है। हमारा लक्ष्य प्रत्येक के h+2साथ पंक्तियाँ बनाना है w 1( h+2ताकि हम ऊपर और नीचे _और -बाद में बदल सकें )। \Gलंगर शुरू करने के लिए जहां पिछले एक दूर छोड़ दिया मैच की आवश्यकता है। यही है, अगर हम कभी भी स्ट्रिंग में एक चरित्र से मेल खाने में विफल होते हैं, तो आगे के वर्ण या तो मेल नहीं खाएंगे। हम इसका उपयोग केवल 1s से मेल खाने के लिए करते हैं h, लेकिन wइसलिए नहीं क्योंकि रेगेक्स उस स्थान की अनुमति नहीं देता है जो उन्हें मिलान करने के लिए अलग करता है। हालाँकि, हम 1वैकल्पिक भी बनाते हैं , ताकि अंत में हमें एक अतिरिक्त खाली मैच मिले h। वह h+1मैच है। उनमें से प्रत्येक को पूरे इनपुट ( $_) के बाद एक लाइनफीड के साथ बदल दिया जाता है।wखुद अछूता रहता है जो हमें h+2nd कॉपी देता है । कहते हैं कि इनपुट था 11 1111, तो अब हमें मिल गया है:

11 1111
11 1111
11 1111
 1111

वह बहुत बढिया है। हमें कुछ अतिरिक्त चीजें मिली हैं, लेकिन h+2प्रतियां wवहां मौजूद हैं।

1* 

ध्यान दें कि पहली पंक्ति के अंत में एक जगह है। यह उन उपसर्गों को लाइनों से हटा देता है ताकि हमारे पास wबाद में केवल एस हो।

आह ठीक है, यह वास्तव में एसई के प्रारूपण के साथ काम नहीं करता है ... पहली पंक्ति खाली है और दूसरी पंक्ति में एक एकल स्थान होना चाहिए। यह हर संभव स्थिति में स्थान सम्मिलित करता है, अर्थात प्रत्येक पंक्ति के आरंभ और अंत में और प्रत्येक जोड़ी के बीच 1:

 1 1 1 1 
 1 1 1 1 
 1 1 1 1 
 1 1 1 1 

हम इन्हें oबाद में बदल देंगे

.+
|$&|

यह बस प्रत्येक पंक्ति को एक जोड़ी में लपेटता है |:

| 1 1 1 1 |
| 1 1 1 1 |
| 1 1 1 1 |
| 1 1 1 1 |

अब हम ऊपर और नीचे की देखभाल करते हैं:

\G.
_

\Gफिर से चमकने का समय । यह पहली पंक्ति में प्रत्येक वर्ण से मेल खाता है और इसे एक में बदल देता है _।

r`.\G
-

एक ही बात है, लेकिन rसंशोधक (दाएं से बाएं मोड) के कारण, यह अंतिम पंक्ति के पात्रों से मेल खाता है और उन्हें चालू करता है -। तो अब हमें मिल गया है:

___________
| 1 1 1 1 |
| 1 1 1 1 |
-----------

अब केवल दो चीजें बची हैं: उन लोगों 1को चालू करें o, और यदि इनपुट 1 1तब पूरी चीज को oबदले में बदले। हम दोनों को एक मंच से संभाल सकते हैं:

s`^.{17}$|1
o

sनियमित रूप से एकल मोड है (यानी यह .मैच लाइनफीड बनाता है )। यदि इनपुट था 1 1, तो परिणाम में 17 अक्षरों का न्यूनतम आकार होगा, इसलिए हम इसे मेल कर सकते हैं ^.{17}$और इसे बदल सकते हैं o। अन्यथा, यदि वह विफल हो जाता है, तो हम बस सभी 1s से मेल खाएंगे और oइसके बजाय उन लोगों की जगह लेंगे ।

Answer 11

जोल्फ, 36 बाइट्स

?w*jJρΡ,a+3ώj+2J'-"-+"d*'_lH"  ' o'o
?w*jJ                             'o   return "o" if j * J - 1
       ,a                              make a box
         +3ώj                           of width +3ώj = 3+2*j
             +2J                        of height +2J = 2+J
                '-                      specifying corners as "-"
      Ρ           "-+"                 replacing the first run of "-"s
                      d*'_lH            with a run of "_"s of equal length
     ρ                      "  '       replacing all "  "
                               ' o      with " o"

जोल्फ, 24 बाइट्स, नॉन-कम्यूटिंग

खैर, मैंने एक बेहतर बॉक्स बनाया।

?w*jJ,AhώjJ"_-'_-'|' o'o

जोल्फ, 38 37 बाइट्स

?w*jJΆ+*'_γ+3ώjS*JΆ'|*j" o' |
"*'-γ'o

सरल सामान, वास्तव में। एक बाइट को ध्यान में रखते हुए सहेजा जाता है कि !Ζ(गणित ज़ेटा, या स्टैंड डिविज़न) केवल 0 है जब दोनों तर्क 1 हैं, और अन्यथा (हमारे मामले के लिए) गलत है।

Answer 12

05AB1E , 33 बाइट्स

कोड:

*i'oë¹·3+©'_׶²F'|„ o¹×„ |¶}®'-×J

स्पष्टीकरण:

*i'o                               # If both input equal 1, push "o"
    ë                              # Else, do...
     ¹·3+                          # Push input_1 × 2 + 3
         ©                         # Copy this number to the register
          '_×                      # Multiply by "_"
             ¶                     # Push a newline character
              ²F           }       # Do the following input_2 times:
                '|                 # Push "|"
                  „ o              # Push " o"
                     ¹×            # Multiply this by input_1
                       „ |         # Push " |"
                          ¶        # Push a newline character
                            ®      # Retrieve the value from the register
                             '-×   # Multiply by "-"
                                J  # Join everything and implicitly print.

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

Answer 13

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

(x,y,g=c=>c[r=`repeat`](x*2+3))=>x*y-1?g(`_`)+`
`+`| ${`o `[r](x)}|
`[r](y)+g(`-`):`o`

संपादित करें: @ बस्ती के लिए 3 बाइट्स सहेजे गए।

Comments

अलियासिंग द्वारा 3 बाइट्स बचाएं repeat।

— झबरा

Answer 14

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

lambda x,y:('o',x*'__'+'___\n'+'| %s|\n'%('o '*x)*y+'-'*(x*2+3))[x+y>2]

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— R

Answer 15

Befunge, 144 बाइट्स

मैंने इस पोस्ट पर टिप्पणी करना पसंद किया है , लेकिन मेरे पास अभी तक प्रतिष्ठा नहीं है, इसलिए मैं अपना खुद का उत्तर दे रहा हूं, जो इसी तरह से काम करता है, लेकिन थोड़ा और अधिक कॉम्पैक्ट है

&::&*:1`v
v3*2:\/\_"o",@
>+:  v   >52*," |",, v
>,1-:vLEG O MAKERv::\<
^"_" _$\:|<v "o "_v
v52:+3*2$<,>,,1-:^$
>*,v <    ^"|":-1\<
v-1_@,
>:"-"^

आप यहां कोड का परीक्षण कर सकते हैं

Answer 16

रेंग v.4, 82 बाइट्स, नॉन-कंपेटिंग

मैंने एक बग फिक्स को धकेला जो फ़ंक्शंस को स्वयं द्वारा अधिलेखित किया जा रहा है (कृपया पूछें नहीं; मेरा सामान प्रेतवाधित है)

i#wi#hhw+2e1+ø ~*x}o:{"-"ö<
"_"{:o}w2*3+#xx*2ø
"o"o~
ö"|"o"o"{Wo:o}w*"| "ooh1-?^#h

अंतरिक्ष में शामिल संख्या के रूप में इनपुट लेता है, जैसे 4 2। यहाँ कोशिश करो!

Comments

I pushed a bug fix that fixes functions being overwritten by themselves... खैर, यह एक दिलचस्प बग है

— MKII

Answer 17

PowerShell v2 +, 76 बाइट्स

param($x,$y)if($x+$y-2){"_"*($z=$x*2+3);"|$(" o"*$x) |`n"*$y+'-'*$z;exit}"o"

इनपुट लेता है, फिर एक ifस्टेटमेंट चेक करता है । चूंकि गैर-शून्य मान पावरशेल में सत्य हैं , इसलिए जब तक कम से कम एक $xऔर $yइसके बराबर नहीं है 1, तब तक ifयह सच होगा।

अंदर if, वहाँ स्ट्रिंग गुणन की एक श्रृंखला है। पहले, हम अंडरस्कोर के अपने स्ट्रिंग का निर्माण करते हैं, $zबाद में बचत करते हैं। जो कि पाइपलाइन पर रखा जाता है। इसके बाद हम अपने स्ट्रिंग ऑफ़ साइड्स एंड पेग्स (कई गुना पेग के साथ $x), किया $yबार, और अपने डैशिंग $zसमय के साथ समेटते हैं। उस तार को तब पाइप लाइन पर रखा जाता है और हम exit। पाइप लाइन फ़्लश हो गई है और मुद्रण निहित है। ध्यान दें कि हमें अंडरस्कोर और खूंटे की पहली पंक्ति के बीच नई लाइन मिलती है, क्योंकि .ToString()सरणी आउटपुट के लिए डिफ़ॉल्ट विभाजक है `n(और हम स्ट्रिंग्स की एक सरणी का उत्पादन कर रहे हैं)।

यदि ifगलत है, 1 1तो हम विशेष मामले में हैं, इसलिए हम "o"पाइप लाइन पर खुद से डालते हैं और बाहर निकलते हैं, फिर से छापा जाता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\print-a-lego-piece.ps1 1 1
o

PS C:\Tools\Scripts\golfing> .\print-a-lego-piece.ps1 5 3
_____________
| o o o o o |
| o o o o o |
| o o o o o |
-------------

Answer 18

बैश, 186 , 163 , 156 , 148 , 131 , 130 बाइट्स

 ## Arg1 - Lego width
 ## Arg2 - Lego height 
function print_lego() { 
(($1+$2>2))&&{
printf _%.0s `seq -1 $1`
echo
for((i=$2;i--;)){ 
 printf \|
 for((j=$1;j--;)){
  printf o
 }
 echo \| 
}
printf =%.0s `seq -1 $1`
echo 
}||echo o
}

नोट: यदि आपको वास्तव में लेगो को अंतिम पंक्ति के लिए हाइफ़न की आवश्यकता है, तो अंतिम प्रिंटफ़ को बदल दें

printf -- -%.0s `seq -1 $1`

और दो बाइट्स जोड़ें।

Comments

यदि यह एक समारोह में लपेटा नहीं गया था तो क्या यह थोड़ा कम नहीं होगा? इसके अलावा, मैं बैश में विशेषज्ञ नहीं हूं, लेकिन ऐसा लगता है कि इसे कुछ अतिरिक्त व्हाट्सएप मिल गया है।

— DJMcMayhem

यह एक लाइनर के रूप में ~ 170 होगा:(($x+$y==2))&&echo o||{ printf _%.0s $(seq -1 $x);echo;for((i=0;i<$y;i++));do printf \|;for((j=0;j<$x;j++));do printf o;done;echo \|;done;printf =%.0s $(seq -1 $x);echo;}

यदि आप उपयोग करते हैं (), तो आपको functionफ़ंक्शन घोषित करने के लिए कीवर्ड की आवश्यकता नहीं है । forब्रेसिज़ का उपयोग करते हुए एक वैकल्पिक वाक्यविन्यास है, जैसे for((j=$1;j--;));{ printf o;}:। जैसा कि पिछले उदाहरण में दिखाया गया है, आप कुछ पात्रों को forदूसरी अभिव्यक्ति में घटाकर और परीक्षण करके बचा सकते हैं । आप इसके बजाय बैकटिक्स का उपयोग कर सकते हैं $(cmd)।

— नवजाल

@njjalj धन्यवाद, मैं कोड गोल्फ में नया हूँ - जो एक और ~ 17 बाइट्स को दूर करता है, एक-लाइनर अब 152 है:(($x+$y==2))&&echo o||{ printf _%.0s `seq -1 $x`;echo;for((i=$y;i--;)){ printf \|;for((j=$x;j--;)){ printf o;};echo \|;};printf =%.0s `seq -1 $x`;echo;}

डॉलर के संकेत गणित संदर्भ में वैकल्पिक हैं, तो आप को बदल कर कुछ और बाइट्स दाढ़ी कर सकते हैं (($something))करने के लिए ((something))भर में। ( $1अभी भी इसे शाब्दिक से अलग करने के लिए डॉलर के संकेत की आवश्यकता है 1।)

— ट्रिपलआई

Answer 19

पर्ल 5 - 84 77 बाइट्स

84 बाइट्स

sub l{($x,$y)=@_;$w=3+2*$x;warn$x*$y<2?"o":'_'x$w.$/.('| '.'o 'x$x."|\n")x$y.'-'x$w}

77 बाइट्स। डोम हेस्टिंग्स की कुछ मदद से

sub l{($x,$y)=@_;$x*$y<2?o:'_'x($w=3+2*$x).('
| '.'o 'x$x."|")x$y.$/.'-'x$w}

Comments

पहले मैं उलझन में था कि कोई warnगोल्फ कार्यक्रम में उपयोग करने के प्रयास में क्यों जाएगा , लेकिन तब मुझे एहसास हुआ कि आप इसका उपयोग कर रहे हैं क्योंकि यह इससे छोटा है print। अच्छा!

— पाइप

हाँ, मुझे लगता है कि पर्ल 6 में आप चेतावनी के बजाय

— कहकर

आप पर्ल 5 में भी ऐसा कर सकते हैं, बस यह डिफ़ॉल्ट रूप से सक्षम नहीं है। मुझे लगता है कि आप सभी एक्सटेंशन को सक्षम करने के -Eबजाय कमांड लाइन से अपनी स्क्रिप्ट को कॉल करके कोड-गोल्फ में उस के आसपास प्राप्त कर सकते हैं -e। मैं इस स्थान पर नया हूं इसलिए मुझे ठीक से पता नहीं है कि यह कहां निर्दिष्ट किया गया है कि स्कोर को कैसे गिना जाए।

— पाइप

ओह वास्तव में, मुझे नहीं पता था कि। मैं यहाँ नया हूँ और इसलिए मुझे यकीन भी नहीं है

— Kaundur

मुझे लगता है कि आप इसे 76 बाइट्स के लिए छोटा कर सकते हैं ... यदि आप एक फ़ंक्शन का उपयोग कर रहे हैं, तो मेरा मानना ​​है कि स्ट्रिंग वापस करना स्वीकार्य है (जेएस जवाब देखें, आपके लिए 4 बाइट्स बचाते हुए warn), आपको "o"(आप कर सकते हैं ) उद्धरण की आवश्यकता नहीं है एक और -2 के लिए एक बेयरवर्ड का उपयोग करें), यदि आप गणना करते हैं तो आपको $wएक और बाइट ( '_'x($w=3+2*$x)बनाम $w=3+2*$x;... '_'x$w) को बचाना चाहिए और अंतिम रूप से, आप \nएक शाब्दिक नई रेखा के लिए बदल सकते हैं । उम्मीद है की वो मदद करदे!

— डोम हेस्टिंग्स

Answer 20

सी, 202 191 बाइट्स

#define p printf
i,w,h;t(char*c){for(i=0;p(c),++i<w*2+3;);p("\n");}f(){t("_");for(i=0;i<w*h;)i%w<1?p("| o "):p("o "),i++%w>w-2&&p("|\n");t("-");}main(){scanf("%d %d",&w,&h);w*h<2?p("o"):f();}

11 बाइट्स बचाने के लिए @Lince Assassino को धन्यवाद !

Ungolfed:

#include <stdio.h>
#define p printf

int i, w, h;

void t(char *c)
{
    for(i=0; p(c), ++i<w*2+3;);
    p("\n");
}

void f()
{
    t("_");
    for(i=0; i<w*h;)
    {
        i%w<1 ? p("| o ") : p("o ");
        i++%w>w-2 && p("|\n");
    }
    t("-");
}

int main()
{
    scanf("%d %d", &w, &h);
    w*h<2 ? p("o") : f();
}

Comments

आप के लिए अपनी पहली लाइन को बदल सकते हैंp(char*A){printf(A);}

— लीन असैसिनो

वास्तव में धन्यवाद! लेकिन इसके साथ संभव है कि#define p printf

— Marco

Answer 21

दालचीनी गोंद, 32 बाइट्स

0000000: 6c07 d5f5 7a5d 9cdf 5ae6 52ae 4050 0c35  l...z]..Z.R.@P.5
0000010: 18d9 052f 0082 9b42 e7c8 e422 5fe4 7d9f  .../...B..."_.}.

गैर-प्रतिस्पर्धा। इसे ऑनलाइन आज़माएं। [width,height]कॉमा और ऊंचाई के बीच में कोई जगह नहीं होने के साथ इनपुट बिल्कुल फॉर्म में होना चाहिए

व्याख्या

स्ट्रिंग इस के लिए decompresses:

l[1,1]&o;?&`p___~__~
%| ~o ~|
%---~--~

पहले lचरण के नक्शे [1,1]के लिए o(विशेष मामला) और स्ट्रिंग के लिए सब कुछ

`p___~__~
%| ~o ~|
%---~--~

बैकटिक फिर एक दूसरे चरण की शुरुआत का संकेत देता है; उस स्ट्रिंग को आउटपुट करने के बजाय, CG, बैकटिक को बंद कर देता है और स्ट्रिंग को निष्पादित करता है। इसके pबाद मोड पहले वर्णों के अंदर सभी वर्णों को पहले पैरामीटर (चौड़ाई) बार दोहराता है और फिर बाद में वर्णों को दूसरे पैरामीटर (ऊंचाई) के प्रतिशत प्रतिशत के अंदर दोहराता है। तो [4,2]यह इस में बदल जाता है:

___________
%| o o o o |
%-----------

और फिर में:

___________
| o o o o |
| o o o o |
-----------

Answer 22

बैच, 172 170 बाइट्स

@echo off
if "%*"=="1 1" echo o&exit/b
set o=
for /l %%i in (1,1,%1)do call set o=%%o%% o
echo ---%o: o=--%
for /l %%i in (1,1,%2)do echo ^|%o% ^|
echo ---%o: o=--%

संपादित करें: 2 बाइट्स @ C SavO'Bʀɪᴋᴛʜᴇ @ E'G by के लिए धन्यवाद ।

मैं 7 बाइट्स बचा सकता हूं अगर मैं मान सकता हूं कि विलंबित विस्तार सक्षम है।

Comments

%%o%%के बजाय %o%?

— आउटगोल्फर

@ E @G time %o%को oहर बार मूल मूल्य के साथ बदल दिया जाएगा , इसलिए यह oकेवल कभी बराबर होगा " o"। %%o%%के तर्क के रूप में जाता callहै %o%, जो तब के वर्तमान मूल्य का उपयोग करता है o।

— नील

क्यों नहीं ... बस do set o=%o% o?

— आउटगोल्फ जूल

@ E @Ged लूप पार्स %o%होने से पहले विस्तारित हो जाता forहै, इसलिए लूप पढ़ता है for /l %i in (1,1,8) do call set o= oजो स्पष्ट रूप से व्यर्थ है।

— नील

do set o=%%o%% oतब आप (-5) क्यों नहीं ?

— आउटगोल्फ जूल

Answer 23

विम, 56 कीस्ट्रोक्स

यह एक पाठ संपादन कार्य की तरह लगता है, इसलिए विम स्पष्ट पसंद है! मैं एक पाठ फ़ाइल के रूप में दो अंतरिक्ष अलग पूर्णांकों के साथ इनपुट लेता हूं और उत्तर को उसी फ़ाइल में आउटपुट करता हूं। इसके अलावा, मैं आपको 1x1 विशेष मामले से नफरत करता हूं ... वैसे भी:

"adt l"bDro:if@a*@b==1|wq|en<cr>Di| |<esc>@aio <esc>yy@bPVr_GpVr-ZZ

और अगर वहाँ विशेष मामले के लिए नहीं किया गया था, 35 कीस्ट्रोक्स

"adt x"bDi| |<esc>@aio <esc>yy@bPVr_GpVr-ZZ

समझदार लोगों के लिए एक विराम:

"adt l"bD

बफर से @a और @ बी (अंतरिक्ष चार रखा) में संख्या हटाएं

         ro:if@a*@b==1|wq|en<cr>

अंतरिक्ष को "ओ" से बदलें और यदि विशेष मामला है, तो सहेजें और छोड़ दें

                                Di| |<esc>

लाइन को साफ करें और लेगो ब्लॉक के किनारों को लिखें

                                          @aio <esc>

समाप्त मध्य भाग प्राप्त करने के लिए "ओ" के बहुत सारे डालें

                                                    yy@bP

Yank लाइन और @ बी अतिरिक्त प्रतियां (एक बहुत अधिक)

                                                         Vr_

हम बफर के शीर्ष पर हैं, अतिरिक्त लाइन को अंडरस्कोर के साथ बदलें

                                                            Gp

बफ़र के नीचे कूदो, उस रेखा को खींचो जिसे हमने पहले झेला था

                                                              Vr-ZZ

डैश के साथ लाइन बदलें, सहेजें और छोड़ें

Answer 24

पायथ, 38 बाइट्स

?t*QJEjb+sm\_K+\|+j\o*dhQ\|+mKJsm\-K\o

परीक्षण सूट।

Answer 25

हास्केल, 76 बाइट्स

1#1="o"
w#h|f<-w*2+3=f!"_"++'\n':h!('|':w!" o"++" |\n")++f!"-"
n!s=[1..n]>>s

उपयोग का उदाहरण: 3 # 2आपको 3-बाई -2 ईंट के लिए एक बहुस्तरीय स्ट्रिंग देता है।

Ungolfed:

(#) :: Int -> Int -> String
1     #   1    = "o"
width # height = let longWidth = 2 * width + 3 in -- golfed as 'f'
                      (        longWidth `times` "_"  ++   "\n" )
  ++ height   `times` ( "|" ++     width `times` " o" ++ " |\n" )
  ++                  (        longWidth `times` "-"            )

-- | golfed as (!)
times :: Int -> [a] -> [a]
times n s = concat $ replicate n s

Comments

पहली नज़र में ऐसा लग रहा था कि यह कम होना चाहिए unlines, लेकिन ऐसा नहीं है।

— बैलेस्टा 25

Answer 26

ग्रूवी, 107 , 98 , 70 , 64

{x,y->t=x*2+3;x<2&&y<2?"o":'_'*t+"\n"+"|${' o'*x} |\n"*y+'-'*t}

परिक्षण:

(2,2)
(1,1)
(8,2)
(1,4)
_______
| o o |
| o o |
-------
o
___________________
| o o o o o o o o |
| o o o o o o o o |
-------------------
_____
| o |
| o |
| o |
| o |
-----

Answer 27

Befunge, 114 113 108 101 बाइट्स

मुझे पता है कि पहले से ही बहुत सारे Befunge समाधान हैं, लेकिन मुझे काफी निश्चित था कि कोड के लेआउट के लिए एक अलग दृष्टिकोण लेकर उन्हें बेहतर बनाया जा सकता है। मुझे संदेह है कि इस उत्तर को और भी आगे बढ़ाया जा सकता है, लेकिन यह पहले की प्रविष्टियों की तुलना में काफी छोटा है।

&::&+:2`^|,+55_"_",^
-4:,,"| "<\_|#:+1\,,"|"+55$_2#$-#$" o",#!,#:<
  ,"-"_@#:-1<
 :*2+2\-_"o",@v!:-1<

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

Comments

क्या आप समझा सकते हैं कि तार :<|की आवश्यकता क्यों है?

— Zacharý

@ Zacharý कि पहली पंक्ति पर खड़ी शाखा वास्तव में कभी नहीं शाखाओं। स्टैक का शीर्ष हमेशा उस बिंदु पर शून्य होता है, इसलिए यह स्टैक टॉप को छोड़ने और एक ही समय में नीचे शाखा करने के लिए एक शॉर्टकट है - अनिवार्य रूप से यह टिप ।

— जेम्स होल्डरनेस

Answer 28

एपीएल, 46 बाइट्स

{⍵≡1 1:'o'⋄'-'⍪⍨'_'⍪'|',' ','|',⍨'o '⍴⍨1 2×⌽⍵}

गार्ड: ⍵≡1 1:'o'विशेष मामले के लिए। अन्यथा 'o '⍴⍨1 2×⌽⍵सामग्री बनाता है। और बाकी सिर्फ बॉक्सिंग है।

Answer 29

सी #, 198 बाइट्स

void f(int x,int y){int l=x*2+3;Console.Write(y==x&&x==1?"o":s("_",l)+"\n"+s("|"+s(" o",x)+" |\n",y)+s("-",l));}string s(string m,int u){return string.Join("",new string[u].Select(n=>m).ToArray());}

जल्दी और गन्दी

मुझे एक फ़ंक्शन लिखना था जो स्ट्रिंग्स को गुणा करता है

अघोषित (सुझावों के लिए)

public static void f(int x,int y)
{
    int l=x*2+3;
    Console.Write(y == x && x == 1 ? "o" : s("_",l)+"\n"+ s("|" + s(" o", x) + " |\n", y) + s("-",l));

}
public static string s(string m,int u)
{
    return string.Join("", new string[u].Select(n => m).ToArray());
}

Comments

मैंने देखा कि आपके कार्य को अनुकूलित किया जा सकता है string s(string m,int u){return string.Join("",new int[u].Select(n => m));}- .ToArray () निरर्थक है और स्ट्रिंग [] साथ ही एक int [] हो सकता है। लेकिन स्ट्रिंग के बजाय।जब आप कुल मिलाकर उपयोग कर सकते हैं:string s(string m, int u){return new int[u].Aggregate("",(t,i)=>t+m);}

— ओलिवर

आप इस तरह से कुछ बाइट्स शेव कर सकते हैं ... (191)void f(int x,int y){Func<char,int,string>s=(c,i)=>new string(c,i);int l=x*2+3;Console.Write((y&x)==1?"o":s('_',l)+"\n"+s('y',y).Replace("y","| "+s('x', x)+"|\n").Replace("x","o ")+s('-',l));}

— मैथ्यू Whited

Answer 30

ऑक्टेव, 97 95 86 बाइट्स

@(w,h){[a=~(1:w*2+3)+95;repmat(['| ' repmat('o ',1,w) '|'],h,1);~a+45],'o'}{(w*h<2)+1}

मैंने परीक्षण करने के लिए पायथन में @atlasologist की विधि का उपयोग किया (1, 1):(...,'o')[x<2>y]

7 बाइट बचाने के लिए @Luis मेंडू को धन्यवाद : a=ones(1,w*2+3)*'_'टू a=~(1:w*2+3)+95और a./a*'-'टू~a+45

2 बाइट्स बचाने के लिए @ पाजोंक को धन्यवाद :f=

Comments

यह मान्य माटलब कोड नहीं है। आपको केवल "ऑक्टेव" के रूप में लेबल करना चाहिए। इसके अलावा, a./a*'-'क्या आप उपयोग कर सकते हैं ~~a*'-'? या भी ~a+45?

— लुइस मेंडो

इसके अलावा, शायद आप इसे एक अनाम फ़ंक्शन (बिना f=)

— पाजोंक