이 도전은 단순한 예술 입니다. 레고 조각의 높이와 너비를 설명하는 두 개의 입력이 주어지면 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어떤 치수도 얻지 못할 것 입니다.

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

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>

비 펀지 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 그림 형식의 설명에 대한 잘못된 시도입니다. 코드가 화살표 방향으로 흐릅니다.

V , 43, 40, 38 36 바이트

내가 쓴 가장 긴 V 답변 중 하나입니다 ...

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

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

여기에는 유니 코드 및 인쇄 할 수없는 문자가 포함되어 있으므로 뒤집을 수있는 16 진수 덤프는 다음과 같습니다.

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_

이 과제는 텍스트 조작에 관한 것이므로 V에 완벽합니다! 반면에 V는 조건과 수학에서 끔찍하므로 (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 바이트)

그리고 마지막으로, "이 줄의 모든 문자를 'x' Ò로 바꾸십시오 Vr" 라는 간단한 동의어입니다 . (-2 바이트)

32 비트 16 비트 리틀 엔디안 x86 머신 코드, 57 54 51 바이트

@ninjalj 덕분에 3 바이트가 줄었습니다.

코드를 크게 다시 작성하고 다른 3 바이트를 면도했습니다.

16 진수로

FCBA6F208D48FFE20492AAEB2389D941D1E14151B05FF3AAEB0BB87C20AB89D992F3AB92AAB00AAA4E7DEF59B02DF3AA91AAC3

입력 : BX = width, SI = height, DI는 "\ n"으로 구분 된 행을 가진 NULL로 끝나는 문자열로 결과를받는 버퍼를 가리 킵니다.

분해 :

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

파이썬 2, 75 73 72 바이트

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

1,1 블록을 처리 할 조건이있는 문자열을 반환합니다.

Lynn과 Chepner에게 2 바이트 감사

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

루비, 59 56 바이트

익명 함수, 여러 줄 문자열을 반환합니다. 온라인으로 사용해보십시오!

@ El'endiaStarman의 트릭을 빌려서 -3 바이트

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

자바, 318 312 297 294 260 258 바이트

cliffroot 덕분에 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);}}

명령 행 인수와 함께 작동합니다.

Ungolfed 사람이 읽을 수있는 형태 :

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 {

인쇄 할 수있는 작품은 1 × 1, 다음 두 경우 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조각에 하이픈을 추가 합니다. 이것은 모든 구멍 아래의 맨 아래에있는 행입니다.

for조각이 실제로 구성된 루프 를 설명하는 데 사용한 4x4 조각 은 이제 다음과 같습니다.

___________\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);

그리고 마지막으로 조각을 인쇄합니다!

Minkolang 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.

자, 그것은 2 바이트가 절약 된 것에 대한 설명을 크게 다시 쓴 것입니다. 나는 이것에서 더 많은 것을 할 수 있거나 골프를 칠 것이라고 생각하지 않습니다. :피

brainfuck, 391 바이트

나는 이것이 더 골프화 될 수 있다는 것을 알고 있지만,이 시점에서 나는 그것이 기쁘다. 나는 골프를 계속하기 위해 노력할 것입니다.

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

입력은 두 자리 숫자로 주어져야합니다. 에서와 (8, 2)같이을 입력하면 82됩니다.

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

고장:

먼저 필요한 문자를 테이프에 넣으십시오. (newline)| o_-

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

그런 다음 입력을 두 셀로 수집하고 각 셀에서 48을 뺍니다 (숫자가 아닌 숫자 값을 얻기 위해)

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

다음으로 특별한 경우를 (1, 1)점검하십시오 (이 점검 만 코드의 109 바이트를 차지함). 마치 ifs가 brainfuck에서 할만 큼 힘들지 않은 것처럼 중첩 된 것이 있습니다 if.

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

다음은 셀 x가 0인지 아닌지 확인하는 구조입니다.

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

그러나 nested if에는 4 개의 임시 셀이 있어야합니다.

이제 실제 문자 인쇄에 도달했습니다.

상단 표시 줄과 줄 바꿈을 인쇄하십시오.

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

인쇄 |, 행 o의 다른 |과 줄 바꿈 높이와 같은 여러 번 :

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

그리고 하단 표시 줄을 인쇄하십시오 (여기에서 줄 바꿈이 필요하지 않음).

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

레티 나 , 52 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다. 여섯 번째 줄에는 단일 공백이 있어야합니다.

\G1?
$_¶
1* 



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

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

입력은 1단항 자릿수로 사용 되며, 분리 자로 공간을 사용하고 높이는 너비를 따릅니다.

설명

이 프로그램의 모든 단계는 때때로 정규 정규 표현식 수정 자 (반복 또는 루프가없고 다른 유형의 단계가 없음)를 사용하여 대체됩니다. ¶줄 바꿈을위한 일반적인 별칭 외에 Retina 고유의 ​​대체 기능도 사용하지 않습니다 .

\G1?
$_¶

이것의 목적은 두 입력을 "곱하기"입니다. 우리의 목표는 만드는 것입니다 h+2함께 행 w 1의 각 ( h+2우리가에 상단과 하단을 설정 할 수 있도록 _하고 -이상). \G앵커는 마지막 그만두고 시작하는 경기를해야합니다. 즉, 문자열의 문자와 일치하지 않으면 추가 문자도 일치하지 않습니다. 우리는 이것을 1s in 만 일치시키기 위해 사용 h하지만 w정규 표현식은 그것들을 구분하는 공백이 일치하지 않기 때문에 사용하지 않습니다. 그러나 또한 1선택 사항을 작성하여 의 끝에 빈 일치 항목이 추가로 표시되도록합니다 h. 그h+1 일치. 이들 각각은 전체 입력 ( $_)과 줄 바꿈으로 바뀝니다 .w그 자체는 그대로 남아 우리에게 두 h+2번째 사본 을 제공합니다 . 입력이이라고 말하면 11 1111이제 다음을 얻습니다.

11 1111
11 1111
11 1111
 1111

꽤 좋습니다. 추가 자료가 있지만 h+2사본 w이 있습니다.

1* 

첫 번째 줄 끝에 공백이 있습니다. 이렇게하면 해당 접두사가 줄에서 제거되므로 w나중에 s 만 표시됩니다 .

아, 글쎄, 그것은 실제로 SE의 형식으로 작동하지 않습니다 ... 첫 번째 줄은 비어 있고 두 번째 줄에는 단일 공백이 있어야합니다. 이렇게하면 가능한 모든 위치, 즉 각 줄의 시작과 끝 및 모든 쌍 사이에 공백이 삽입됩니다 1.

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

우리는 이것을 o나중에 s 로 바꿀 것입니다

.+
|$&|

이것은 단순히 모든 라인을 한 쌍으로 묶습니다 |.

| 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을 os 1 1로 바꾸고, 입력이 있다면 전체를 o대신 바꾸십시오 . 하나의 스테이지로 두 가지를 모두 처리 할 수 ​​있습니다.

s`^.{17}$|1
o

s일반 단일 라인 모드입니다 (즉, .일치하는 줄 바꿈을 만듭니다 ). 입력 1 1결과가 최소 17 자이므로 결과를로 ^.{17}$바꾸고로 바꿀 수 있습니다 o. 그렇지 않으면, 그것이 실패하면, 우리는 모든 것을 일치 1시키고 o대신에 대체 합니다.

줄프, 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"

Jolf, 24 바이트, 비경쟁

글쎄, 나는 더 나은 상자 내장을 만들었습니다.

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

줄프, 38 37 바이트

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

정말 간단한 것입니다. !Ζ두 인수가 모두 1 일 때 (수학 제타 또는 스탠드 이탈)이 0 일 뿐이고 그렇지 않은 경우 (우리의 경우) 거짓 임을 지적하여 바이트를 저장했습니다 .

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 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

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

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

편집 : @Shaggy 덕분에 3 바이트가 절약되었습니다.

파이썬 2, 71 바이트

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

베 펀지, 144 바이트

이 게시물 에 댓글을 달기를 원했지만 아직 평판이 없으므로 비슷한 방식으로 작동하지만 약간 더 컴팩트 한 내 답변을 드리겠습니다.

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

여기 에서 코드를 테스트 할 수 있습니다

Reng 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받습니다. 여기 사용해보십시오!

PowerShell v2 +, 76 바이트

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

입력 한 다음 if명령문 을 확인합니다 . 비 - 제로 값이므로 truthy 너무 긴 적어도 하나의 파워 쉘에서 $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 |
-------------

배쉬, 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를 다음으로 변경하십시오.

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

두 바이트를 추가하십시오.

펄 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 바이트 Dom Hastings의 도움으로

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

C, 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 에게 감사 합니다!

언 골프 드 :

#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();
}

계피 껌, 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]쉼표와 높이 사이에 공백이없는 형식이어야합니다 .

설명

문자열은 다음과 같이 압축 해제됩니다.

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

배치, 172170 바이트

@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=--%

편집 : @ CᴏɴᴏʀO'Bʀɪᴇɴ 덕분에 2 바이트를 절약했습니다. @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ 절약했습니다.

지연 확장이 활성화되었다고 가정하면 7 바이트를 절약 할 수 있습니다.

Vim, 56 번의 ​​키 스트로크

이것은 텍스트 편집 작업처럼 보이므로 Vim이 확실한 선택입니다! 공백으로 구분 된 두 개의 정수가있는 텍스트 파일로 입력을 받아서 같은 파일에 답을 출력합니다. 또한, 나는 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 및 @b로 숫자 삭제 (공백 문자 유지)

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

공간을 "o"로 바꾸고 특별한 경우 저장하고 종료하십시오.

                                Di| |<esc>

라인을 지우고 레고 블록의 가장자리를 씁니다.

                                          @aio <esc>

완성 된 중간 부분을 얻으려면 @ "o"를 많이 삽입하십시오.

                                                    yy@bP

양키 라인과 @b 여분의 사본 (하나가 너무 많음)

                                                         Vr_

버퍼의 맨 위에 있습니다. 추가 줄을 밑줄로 바꿉니다.

                                                            Gp

완충기의 바닥으로 뛰고, 우리가 이전에 잡아 당긴 선을 당깁니다.

                                                              Vr-ZZ

줄을 대시로 바꾸고 저장하고 종료하십시오.

Pyth, 38 바이트

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

테스트 스위트.

하스켈, 76 바이트

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

사용 예 : 3 # 2 3x2 브릭에 대한 여러 줄 문자열을 제공합니다.

언 골프 드 :

(#) :: 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

그루비, 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 |
-----

비 펀지, 114 (113) 108 101 바이트

이미 많은 Befunge 솔루션이 있다는 것을 알고 있지만 코드 레이아웃에 다른 접근 방식을 사용하여 개선 될 수 있다고 확신했습니다. 나는이 답변이 더 골프를 칠 수 있다고 생각하지만 이미 이전 항목 중 어느 것보다 약간 작습니다.

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

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

APL, 46 바이트

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

경비원 : ⍵≡1 1:'o'특별한 경우. 그렇지 않으면 'o '⍴⍨1 2×⌽⍵컨텐츠를 빌드합니다. 그리고 나머지는 단지 권투입니다.

C #, 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());}

빠르고 더러운

문자열을 곱하는 함수를 작성해야했습니다.

ungolfed (제안 사항)

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());
}

옥타브, 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 Mendo 에게 감사드립니다 .a=ones(1,w*2+3)*'_' 에 a=~(1:w*2+3)+95와 a./a*'-'에~a+45

2 바이트를 절약 한 @pajonk 에게 감사드립니다 .f=