Thử thách này là một nghệ thuật đơn giản . Đưa ra hai đầu vào, mô tả chiều cao và chiều rộng của một mảnh Lego, bạn đã in một biểu diễn nghệ thuật ASCII của nó.

Đây là cách các mảnh Lego được cho là trông:

(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

Nếu bạn không thể biết từ các trường hợp thử nghiệm, trên cùng và dưới cùng là width*2+3dấu gạch dưới và dấu gạch ngang, và mỗi hàng có các đường ống cho các mặt, odành cho những thứ nhỏ nhặt và mọi thứ được ngăn cách bởi các khoảng trắng.

Ngoại lệ duy nhất cho điều này là (1, 1), chỉ là một o.

Bạn sẽ không bao giờ có được 0cho bất kỳ kích thước.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

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>

Befunge , 165 227 byte

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

Không còn nhiều khoảng trắng như trước, nhưng vẫn còn những khoảng trống. Nguyên tắc giống như trong giải pháp trước, nhưng cách bố trí khác nhau. Lần này, để kiểm tra xem cả hai số có phải là 1 hay không, tôi chỉ lấy sản phẩm của họ và xem kết quả có lớn hơn 1 không.

Giải pháp cũ (227 byte)

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

Có thể chơi golf nhiều hơn. Chỉ cần nhìn vào tất cả khoảng trắng đó!

Đây là nỗ lực kém của tôi trong một lời giải thích dưới dạng hình ảnh MSPaint: Mã chảy theo hướng mũi tên.

V , 43, 40, 38 36 byte

Một trong những câu trả lời V dài nhất tôi từng viết ...

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

Hãy thử trực tuyến!

Vì phần này chứa các ký tự unicode và không thể in được, nên đây là một hexdump có thể đảo ngược:

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_

Thử thách này là về thao tác văn bản, rất hoàn hảo cho V! Mặt khác, V rất tệ ở các điều kiện và toán học, do đó, đầu ra khác nhau cho (1, 1) thực sự làm hỏng nó ... :(

Giải trình:

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

Bây giờ chúng ta có các dòng chữ 'Chiều cao' với khoảng cách giữa chúng.

ñ                   "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 '_'

Phiên bản không cạnh tranh (31 byte):

Hãy thử trực tuyến!

Phiên bản này sử dụng một số tính năng mới hơn sau đó thử thách này ngắn hơn 5 byte!

Giải thích thứ hai:

ddÀP

đó là "Xóa dòng và dán nó n lần" được thay thế bằng ÀÄ"Lặp lại dòng này n lần". (-2 byte)

óo î½o
u

đó là "Thay thế trận đấu đầu tiên của regex này; Hoàn tác" đã được thay thế bằng

/o î½o

Đó chỉ là "Tìm kiếm sự trùng khớp của biểu thức chính quy này" (-1 byte)

Và cuối cùng, Òchỉ là một từ đồng nghĩa đơn giản cho Vrcả hai "Thay thế mọi ký tự trên dòng này bằng 'x'". (-2 byte)

32 mã máy x86 16 bit nhỏ endian, 57 54 51 byte

3 byte ít hơn nhờ @ninjalj.

Viết lại mã một cách nặng nề và đã tìm cách loại bỏ 3 byte khác

Trong hex

FCBA6F208D48FFE20492AAEB2389D941D1E14151B05FF3AAEB0BB87C20AB89D992F3AB92AAB00AAA4E7DEF59B02DF3AA91AAC3

Đầu vào: BX = width, SI = height, DI trỏ tới bộ đệm nhận kết quả dưới dạng chuỗi kết thúc NULL với các dòng được phân tách bằng "\ n"

Tháo gỡ:

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

Python 2, 75 73 72 byte

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

Trả về một chuỗi, với một điều kiện để xử lý khối 1,1.

Cảm ơn Lynn và Chepner cho hai byte

CJam, 34

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

Dùng thử trực tuyến

Giải trình:

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

Ruby, 59 56 byte

Hàm ẩn danh, trả về một chuỗi nhiều dòng. Hãy thử trực tuyến!

-3 byte nhờ mượn một mẹo từ @ El'endiaStarman

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

Java, 318 312 297 294 260 258 byte

Đã lưu 15 byte nhờ cliffroot !

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

Nó hoạt động với các đối số dòng lệnh.

Ungolfed ở dạng người có thể đọc đượ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);
    }
}

Vâng, vẫn còn khó hiểu những gì đang diễn ra ngay cả khi chương trình không được cung cấp. Vì vậy, đây là một lời giải thích từng bước:

static void main(String[] A)

Hai đối số dòng lệnh đầu tiên - chúng ta sẽ sử dụng để lấy kích thước - có thể được sử dụng trong chương trình như A[0]và A[1](tương ứng).

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

blà số lượng cột, Blà số lượng hàng và Clà biến chuyên dụng để sử dụng trong forcác vòng lặp.

clà mảnh Lego. Chúng tôi sẽ nối các hàng với nó và sau đó in nó ở cuối.

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

Nếu mảnh được in là 1x1, sau đó cả hai b(số cột) và B(số hàng) nên nhỏ hơn 2. Vì vậy, chúng ta chỉ cần đặt cmột đơn ovà sau đó bỏ qua để tuyên bố rằng System.out.printlà mảnh nếu đó là trường hợp.

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

Ở đây, chúng tôi nối thêm (integerValueOfA[0] * 2) + 3dấu gạch dưới vào c. Đây là hàng trên cùng trên tất cả các lỗ.

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

Đây là vòng lặp nơi chúng ta xây dựng một mảnh mỗi lần. Những gì đang diễn ra bên trong là không thể giải thích mà không có ví dụ. Hãy nói rằng tác phẩm là 4 x 4:

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

Ở đây, chúng tôi nối các (integerValueOfA[0] * 2) + 3dấu gạch nối vào mảnh. Đây là hàng ở dưới cùng, bên dưới tất cả các lỗ.

Phần 4 x 4 tôi đã sử dụng để giải thích forvòng lặp trong đó phần thực sự được xây dựng bây giờ trông như thế này:

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

Và cuối cùng, chúng tôi in mảnh!

Chồn 0,15 , 58 57 56 byte

Vâng đúng vậy. Tôi đã đánh gôn một hai byte nhỏ ...

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

Hãy thử nó ở đây!

Giải trình

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.

Được rồi, đó là hai bản viết lại đáng kể của lời giải thích cho hai byte được lưu. Tôi không nghĩ rằng tôi có thể hoặc sẽ chơi bất cứ thứ gì khác ngoài cái này. : P

Brainfuck, 391 byte

Tôi biết điều này có thể được chơi golf nhiều hơn, nhưng tại thời điểm này tôi chỉ vui mừng vì nó hoạt động. Tôi sẽ tiếp tục làm việc để đánh nó xuống.

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

Đầu vào cần phải được đưa ra chỉ là hai chữ số. Như trong, để làm (8, 2)bạn sẽ chỉ cần nhập 82.

Hãy thử trực tuyến!

Phá vỡ:

Đầu tiên đặt các ký tự cần thiết vào băng: (newline)| o_-

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

Sau đó thu thập đầu vào thành hai ô và trừ 48 từ mỗi ô (để lấy giá trị số chứ không phải ký tự số)

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

Tiếp theo, hãy kiểm tra trường hợp đặc biệt của (1, 1)(Lưu ý rằng chỉ kiểm tra này chiếm 109 byte mã). Như thể ifchúng ta không đủ sức để làm trong brainfuck, chúng ta có một cái lồng if:

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

Sau đây là cấu trúc để kiểm tra xem một ô x bằng 0 hay khác không:

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

Tuy nhiên, trong một lồng if, chúng ta cần phải có 4 ô tạm thời.

Bây giờ chúng ta đến phần in thực tế của các ký tự:

In thanh trên cùng và một dòng mới:

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

In một |, một hàng, một dòng okhác |và một dòng mới một số lần bằng chiều cao:

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

Và in thanh dưới cùng (không cần dòng mới ở đây):

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

Võng mạc , 52 byte

Số lượng byte giả định mã hóa ISO 8859-1. Lưu ý rằng dòng thứ sáu được cho là chứa một khoảng trắng.

\G1?
$_¶
1* 



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

Hãy thử trực tuyến!

Đầu vào là đơn nhất, sử dụng 1là chữ số đơn, không gian làm dấu phân cách và chiều cao theo sau là chiều rộng.

Giải trình

Tất cả các giai đoạn trong chương trình này là sự thay thế hoàn toàn, đôi khi có một công cụ sửa đổi regex thông thường (không lặp lại hoặc lặp, không có các loại giai đoạn khác). Nó thậm chí không sử dụng các tính năng thay thế dành riêng cho Retina, ngoài các ¶bí danh thông thường cho các nguồn cấp dữ liệu.

\G1?
$_¶

Mục đích của việc này là "nhân" hai đầu vào. Mục tiêu của chúng tôi là tạo h+2các hàng với w 1mỗi s ( h+2để chúng tôi có thể biến đỉnh và đáy thành _và -sau). Các \Gneo đòi hỏi trận đấu bắt đầu từ đâu người cuối cùng rời đi. Đó là, nếu chúng ta không khớp với một ký tự trong chuỗi, các ký tự tiếp theo sẽ không khớp. Chúng tôi sử dụng điều này để chỉ khớp với 1s trong h, nhưng không phải wvì regex không cho phép không gian ngăn cách chúng được khớp. Tuy nhiên, chúng tôi cũng đưa ra 1tùy chọn để chúng tôi nhận được một trận đấu trống bổ sung vào cuối h. Đó là h+1trận đấu. Mỗi cái được thay thế bằng toàn bộ đầu vào ( $_) theo sau là một dòng cấp.wbản thân nó vẫn còn nguyên vẹn cho chúng ta h+2bản sao thứ hai. Giả sử đầu vào là 11 1111, sau đó chúng ta đã có:

11 1111
11 1111
11 1111
 1111

Đó là khá tốt. Chúng tôi đã có một số công cụ bổ sung, nhưng các h+2bản sao wở đó.

1* 

Lưu ý rằng có một khoảng trắng ở cuối dòng đầu tiên. Điều này loại bỏ các tiền tố đó khỏi các dòng để chúng ta chỉ có ws sau đó.

À, điều đó không thực sự hoạt động với định dạng của SE ... dòng đầu tiên trống và dòng thứ hai được cho là chứa một khoảng trắng. Điều này sẽ chèn khoảng trắng vào mọi vị trí có thể, tức là ở đầu và cuối của mỗi dòng và giữa mỗi cặp 1s:

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

Chúng tôi sẽ biến chúng thành os sau

.+
|$&|

Điều này chỉ đơn giản là bao bọc mọi dòng trong một cặp |:

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

Bây giờ chúng tôi chăm sóc trên cùng và dưới cùng:

\G.
_

Thời gian \Gđể tỏa sáng một lần nữa. Điều này phù hợp với từng nhân vật trên dòng đầu tiên và biến nó thành một _.

r`.\G
-

Điều tương tự, nhưng do công cụ rsửa đổi (chế độ từ phải sang trái), điều này khớp với các ký tự trên dòng cuối cùng và biến chúng thành -. Vì vậy, bây giờ chúng tôi đã có:

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

Bây giờ chỉ còn hai việc phải làm: biến chúng 1thành os và nếu đầu vào là 1 1thay thế toàn bộ o. Chúng tôi có thể xử lý cả hai trong một giai đoạn:

s`^.{17}$|1
o

slà chế độ singleline thông thường (nghĩa là nó tạo ra các dòng .phù hợp). Nếu đầu vào là 1 1kết quả sẽ có kích thước tối thiểu 17 ký tự để chúng tôi có thể khớp với ^.{17}$và thay thế bằng o. Mặt khác, nếu điều đó không thành công, chúng ta sẽ chỉ khớp tất cả các 1s và thay thế chúng bằng othay thế.

Jolf, 36 byte

?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 byte, không biên dịch

Vâng, tôi đã làm một hộp dựng sẵn tốt hơn.

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

Jolf, 38 37 byte

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

Những thứ đơn giản, thực sự. Đã lưu một byte bằng cách lưu ý rằng !Ζ(zeta toán học hoặc độ lệch đứng) chỉ bằng 0 khi cả hai đối số là 1 và ngược lại là falsey (đối với trường hợp của chúng tôi).

05AB1E , 33 byte

Mã số:

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

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

JavaScript (ES6), 89 86 byte

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

Chỉnh sửa: Đã lưu 3 byte nhờ @Shaggy.

Python 2, 71 byte

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

Befunge, 144 byte

Tôi muốn bình luận về bài đăng này , nhưng tôi chưa có tiếng tăm, vì vậy tôi đang đặt câu trả lời cho riêng mình, hoạt động theo cách tương tự, nhưng nhỏ gọn hơn một chút

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

bạn có thể kiểm tra mã ở đây

Reng v.4, 82 byte, không lọc

Tôi đã sửa một bản sửa lỗi để sửa các chức năng bị ghi đè lên chính họ (xin đừng hỏi; công cụ của tôi bị ma ám)

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

Lấy đầu vào là số tham gia không gian, như 4 2. Hãy thử nó ở đây!

PowerShell v2 +, 76 byte

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

Đưa đầu vào, sau đó kiểm tra một iftuyên bố. Vì các giá trị khác không là trung thực trong PowerShell, miễn là ít nhất một trong số đó $xvà $ykhông bằng 1, thì điều đó ifsẽ đúng.

Bên trong if, có một loạt các chuỗi nhân. Đầu tiên, chúng tôi xây dựng chuỗi ký tự gạch dưới của chúng tôi, $zđể dành cho lần sau. Điều đó được đặt trên đường ống dẫn. Tiếp theo, chúng tôi xây dựng chuỗi các cạnh và chốt của chúng tôi (với các chốt được nhân với $x), $ythời gian thực hiện và nối chuỗi đó với $zthời gian gạch ngang của chúng tôi . Chuỗi đó sau đó được đặt trên đường ống và chúng tôi exit. Các đường ống được tuôn ra và in ấn là ẩn. Lưu ý rằng chúng tôi nhận được dòng mới giữa dấu gạch dưới và hàng chốt đầu tiên miễn phí, vì .ToString()dấu phân cách mặc định cho đầu ra mảng là `n(và chúng tôi xuất ra một chuỗi các chuỗi).

Nếu ifsai, chúng ta sẽ ở trong 1 1trường hợp đặc biệt , vì vậy chúng ta chỉ cần đặt "o"nó vào đường ống và thoát, với việc in lại ẩn.

Ví dụ

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

Bash, 186 , 163 , 156 , 148 , 131 , 130 byte

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

Lưu ý: Nếu bạn thực sự cần lego để có dấu gạch nối cho dòng cuối cùng, thì hãy thay đổi printf cuối cùng thành

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

và thêm hai byte.

Perl 5 - 84 77 byte

84 byte

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

77 byte. Với sự giúp đỡ của 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 byte

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

Cảm ơn @Lince Assassino lưu 11 byte!

Ung dung:

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

Quế Gum, 32 byte

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..."_.}.

Không cạnh tranh. Hãy thử trực tuyến. Đầu vào phải chính xác trong mẫu[width,height] không có khoảng trắng ở giữa dấu phẩy và chiều cao.

Giải trình

Chuỗi giải nén điều này:

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

lGiai đoạn đầu tiên ánh xạ [1,1]tới o(trường hợp đặc biệt) và mọi thứ khác vào chuỗi

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

Backtick sau đó báo hiệu bắt đầu giai đoạn thứ hai; thay vì xuất chuỗi đó ra, CG cắt bỏ backtick và thực thi chuỗi. Sau pđó, chế độ lặp lại tất cả các ký tự bên trong dấu ngã (chiều rộng) lần đầu tiên và sau đó lặp lại các ký tự bên trong phần trăm dấu hiệu tham số thứ hai (chiều cao) lần. Vì vậy, [4,2]nó biến thành thế này:

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

và sau đó vào:

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

Mẻ, 172 170 byte

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

Chỉnh sửa: Đã lưu 2 byte nhờ @ CᴏɴᴏʀO'Bʀɪᴇɴ @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.

Tôi có thể lưu 7 byte nếu tôi có thể giả sử mở rộng bị trì hoãn được kích hoạt.

Vim, 56 tổ hợp phím

Đây có vẻ như là một nhiệm vụ chỉnh sửa văn bản, vì vậy Vim là sự lựa chọn rõ ràng! Tôi lấy đầu vào là một tệp văn bản với hai số nguyên được phân tách bằng dấu cách và xuất câu trả lời vào cùng một tệp. Ngoài ra, tôi ghét bạn vì có trường hợp đặc biệt 1x1 ... Dù sao đi nữa:

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

và nếu không có trường hợp đặc biệt, 35 lần nhấn phím

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

Một sự cố cho những người tỉnh táo:

"adt l"bD

Xóa số từ bộ đệm vào @a và @b (không gian char được giữ)

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

Thay thế không gian bằng "o" và nếu trường hợp đặc biệt, hãy lưu và thoát

                                Di| |<esc>

Xóa dòng và viết các cạnh của khối lego

                                          @aio <esc>

Chèn @a nhiều "o" để có phần giữa hoàn thành

                                                    yy@bP

Dòng Yank và tạo thêm @b bản sao (quá nhiều)

                                                         Vr_

Chúng tôi đang ở đầu bộ đệm, thay thế dòng bổ sung với dấu gạch dưới

                                                            Gp

Nhảy xuống dưới cùng của bộ đệm, kéo dòng mà chúng ta đã kéo trước đó

                                                              Vr-ZZ

Thay thế dòng bằng dấu gạch ngang, lưu và thoát

Bình thường, 38 byte

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

Bộ thử nghiệm.

Haskell, 76 byte

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

Ví dụ sử dụng: 3 # 2 mang đến cho bạn một chuỗi multiline cho một 3-by-2 gạch.

Ung dung:

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

Groovy, 107 , 98 , 70 , 64

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

Kiểm tra:

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

Befunge, 114 113 108 101 byte

Tôi biết đã có một số giải pháp Befunge, nhưng tôi khá chắc chắn rằng chúng có thể được cải thiện bằng cách sử dụng một cách tiếp cận khác để bố trí mã. Tôi nghi ngờ câu trả lời này cũng có thể được đánh gôn, nhưng nó đã nhỏ hơn một chút so với các mục trước.

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

Hãy thử trực tuyến!

APL, 46 byte

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

Người bảo vệ: ⍵≡1 1:'o'cho trường hợp đặc biệt. Nếu không thì 'o '⍴⍨1 2×⌽⍵xây dựng nội dung. Và phần còn lại chỉ là quyền anh.

C #, 198 byte

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

nhanh chóng và hèn hạ

Tôi đã phải viết một hàm nhân chuỗi

không có ý kiến ​​(cho các đề xuất)

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

Octave, 97 95 86 byte

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

Tôi đã sử dụng phương pháp của @atlasologist trong Python để kiểm tra (1, 1):(...,'o')[x<2>y]

Nhờ @Luis Mendo để tiết kiệm 7 byte: a=ones(1,w*2+3)*'_'đến a=~(1:w*2+3)+95và a./a*'-'để~a+45

Cảm ơn @pajonk vì đã lưu 2 byte:f=