Этот вызов простой ascii-art . Учитывая два входа, описывающих высоту и ширину фрагмента Lego, вы распечатываете его в ASCII-представлении.

Вот как должны выглядеть части Lego:

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

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: Код течет в направлении стрелки.

V , 43, 40, 38 36 байтов

Один из самых длинных V ответов, которые я когда-либо писал ...

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

Попробуйте онлайн!

Так как он содержит Unicode и непечатаемые символы, вот обратимый hexdump:

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 байт).

И, наконец, Òэто просто простой синоним для Vr, который «Заменить каждый символ в этой строке на« х »». (-2 байта)

32 16-разрядный машинный код с прямым порядком байтов x86, 57 54 51 байт

На 3 байта меньше благодаря @ninjalj.

Тяжело переписал код и сумел сбрить еще 3 байта

В шестнадцатеричном

FCBA6F208D48FFE20492AAEB2389D941D1E14151B05FF3AAEB0BB87C20AB89D992F3AB92AAB00AAA4E7DEF59B02DF3AA91AAC3

Ввод: BX = ширина, SI = высота, DI указывает на буфер, который получает результат в виде строки с нулевым символом в конце со строками, разделенными "\ n"

Разборка:

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 байта

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

Возвращает строку с условной обработкой для блока 1,1.

Спасибо Линн и Чепнер за два байта

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 байт

Анонимная функция, возвращает многострочную строку. Попробуйте онлайн!

-3 байта благодаря заимствованию трюка у @ El'endiaStarman

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

Java, 318 312 297 294 260 258 байт

Сохранено 15 байтов благодаря 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);}}

Работает с аргументами командной строки.

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это часть Lego. Мы добавим к нему строки, а затем напечатаем его в конце.

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

Это цикл, в котором мы строим фигуру по одной строке за раз. То, что происходит внутри, невозможно объяснить без примеров. Допустим, что кусок 4х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 += "-";

Здесь мы добавляем (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);

И, наконец, мы печатаем кусок!

Минколанг 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.

Хорошо, это два существенных переписывания объяснения для двух сохраненных байтов. Я не думаю, что смогу или буду играть в гольф что-то еще из этого. :П

брейкфук, 391 байт

Я знаю, что это может быть в гольфе больше, но на данный момент я просто рад, что это работает. Я буду продолжать работать, чтобы играть в гольф.

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

Ввод должен быть представлен только двумя цифрами. Как и в, (8, 2)вы бы просто войти 82.

Попробуйте онлайн!

Сломать:

Сначала поместите необходимые символы в ленту: (newline)| o_-

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

Затем соберите данные в две ячейки и вычтите 48 из каждой (чтобы получить числовое значение, а не цифровой символ)

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

Далее, проверьте для особого случая (1, 1)(Обратите внимание, что только эта проверка составляет 109 байт кода). Как будто это ifне было достаточно сложно сделать в мозге, у нас есть вложенное if:

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

Ниже приведена структура для проверки, является ли ячейка х нулевой или ненулевой:

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

Однако во вложенном ifнам нужно иметь 4 временных ячейки.

Теперь перейдем к фактической печати символов:

Напечатайте верхнюю строку и новую строку:

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

Выведите a |, ряд os, еще один |и новую строку , количество раз равное высоте:

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

И выведите нижнюю строку (здесь не требуется перевод строки):

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

Сетчатка , 52 байта

Число байтов предполагает кодировку ISO 8859-1. Обратите внимание, что шестая строка должна содержать один пробел.

\G1?
$_¶
1* 



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

Попробуйте онлайн!

Ввод выполняется в одинарном 1формате с использованием в качестве унарной цифры пробела в качестве разделителя и высоты, за которой следует ширина.

объяснение

Все этапы в этой программе являются голыми заменами, иногда с регулярным модификатором регулярных выражений (без повторений или циклов, без других типов этапов). Он даже не использует специфичные для Retina функции замещения, кроме обычного ¶псевдонима для перевода строки.

\G1?
$_¶

Цель этого состоит в том, чтобы «умножить» два входа. Наша цель - создать h+2строки с w 1каждой из s ( h+2чтобы мы могли повернуть верх и низ в _и -позже). \GЯкорь требует матча , чтобы начать , где последний остановился. То есть, если нам не удастся сопоставить символ в строке, другие символы тоже не будут совпадать. Мы используем это для сопоставления только 1s in h, но не in, wпотому что регулярное выражение не позволяет найти пространство, разделяющее их. Тем не менее, мы также делаем 1необязательные, так что мы получаем дополнительное пустое совпадение в конце h. Это h+1совпадает. Каждый из них заменяется на весь input ( $_), за которым следует перевод строки.wсам остается нетронутым, что дает нам h+2nd копию. Скажем, ввод был 11 1111, тогда мы получили:

11 1111
11 1111
11 1111
 1111

Это очень хорошо. У нас есть кое-что еще, но h+2копии wесть.

1* 

Обратите внимание, что в конце первой строки есть пробел. Это удаляет эти префиксы из строк, так что у нас есть только ws после.

Ну, это не очень работает с форматированием SE ... первая строка пуста, а вторая строка должна содержать один пробел. Это вставляет пробелы в каждую возможную позицию, то есть в начале и конце каждой строки и между каждой парой 1s:

 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в os, а если вводить, 1 1то oвместо этого превратить всю вещь в . Мы можем справиться с обоими с одной стадией:

s`^.{17}$|1
o

sявляется обычным однострочным режимом (т. е. .соответствует строковым переводам). Если ввод был 1 1результатом, минимальный размер будет 17 символов, поэтому мы можем сопоставить его с ^.{17}$и заменить его o. В противном случае, если это не удастся, мы просто сопоставим все 1s и заменим их на 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"

Джольф, 24 байта, неконкурентный

Ну, я сделал лучшую встроенную коробку.

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

Джольф, 38 37 байт

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

Простые вещи, правда. Сохраните байт, отметив, что !Ζ(математическая дзета, или отклонение от нормы) равно только 0, когда оба аргумента равны 1, и неверно в противном случае (для нашего случая).

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 . Попробуйте онлайн! ,

JavaScript (ES6), 89 86 байт

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

Редактировать: 3 байта сохранены благодаря @Shaggy.

Python 2, 71 байт

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

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_@,
>:"-"^

Вы можете проверить код здесь

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 в PowerShell, что, по меньшей мере , один из , $xи $yне равны 1, то ifбудет верно.

Внутри ifесть ряд умножений строк. Сначала мы строим нашу строку подчеркивания, сохраняя $zдля дальнейшего. Это размещается на конвейере. Затем мы строим нашу строку сторон и колышков (с умноженными колышками $x), делаем $yвремя и объединяем это с нашими штрихами $z. Эта строка затем помещается на конвейер, и мы exit. Трубопровод сбрасывается и печать неявна. Обратите внимание, что мы получаем новую строку между подчеркиванием и первой строкой колышков бесплатно, так как по умолчанию .ToString()для вывода массива используется разделитель `n(и мы выводим массив строк).

Если значение ifравно false, мы находимся в особом 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
}

Примечание: если вам действительно нужно, чтобы в lego были дефисы для последней строки, измените последний printf на

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

и добавить два байта.

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

Спасибо @Lince Assassino за сохранение 11 байтов!

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

Корица, 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 |
-----------

Пакет, 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ᴏɴᴏʀO'Bʀɪᴇɴ @ 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>

Очистите линию и напишите края блока lego

                                          @aio <esc>

Вставьте @a много «o», чтобы получить законченную среднюю часть

                                                    yy@bP

Вырви линию и сделай @b лишних копий (слишком много)

                                                         Vr_

Мы находимся на вершине буфера, замените лишнюю строку подчеркиванием

                                                            Gp

Перейти к нижней части буфера, вытянуть линию, которую мы выдернули ранее

                                                              Vr-ZZ

Заменить строку тире, сохранить и выйти

Pyth, 38 байт

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

Тестирование.

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

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

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

быстро и грязно

Мне пришлось написать функцию, которая умножает строки

безволосый (для предложений)

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 в Python для проверки (1, 1):(...,'o')[x<2>y]

Благодаря @Luis Mendo для экономии 7 байт: a=ones(1,w*2+3)*'_'до a=~(1:w*2+3)+95и a./a*'-'в~a+45

Спасибо @pajonk за сохранение 2 байтов:f=