Questa sfida è una semplice arte ascii-art . Dati due input, che descrivono l'altezza e la larghezza di un pezzo di Lego, hai stampato una rappresentazione di arte ASCII di esso.

Ecco come dovrebbero apparire i pezzi di 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

Se non si capisce dai casi di prova, la parte superiore e inferiore sono width*2+3sottolineature e trattini e ogni riga ha i tubi per i lati, oè per le piccole cose e tutto è separato da spazi.

L'unica eccezione è questa (1, 1), che è solo una singola o.

Non otterrai mai 0nessuna delle dimensioni.

Questo è code-golf , quindi vince il codice più breve in byte !

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+^
>:    #^_@

Non tanto spazio bianco come prima, ma ci sono ancora lacune. Il principio è lo stesso della soluzione precedente, ma il layout è diverso. Questa volta, per verificare se entrambi i numeri sono 1, sto solo prendendo il loro prodotto e vedo se il risultato è maggiore di 1.

Vecchia soluzione (227 byte)

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

Potrebbe essere possibile giocare a golf di più. Guarda tutto quello spazio bianco!

Ecco il mio scarso tentativo di spiegazione nel formato di immagine di MSPaint: il codice scorre nella direzione della freccia.

V , 43, 40, 38 36 byte

Una delle risposte V più lunghe che abbia mai scritto ...

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

Provalo online!

Poiché questo contiene caratteri unicode e non stampabili, ecco un hexdump reversibile:

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_

Questa sfida riguarda la manipolazione del testo, quindi perfetta per V! D'altra parte, V è terribile in condizionali e matematica, quindi l'output diverso per (1, 1) l'ha davvero rovinata ... :(

Spiegazione:

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

Ora abbiamo linee di "altezza" di o con spazi tra loro.

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

Versione non competitiva (31 byte):

Provalo online!

Questa versione utilizza diverse funzionalità più recenti di questa sfida di 5 byte in meno!

Seconda spiegazione:

ddÀP

che è "Elimina riga e incollalo n volte" è sostituito da ÀÄ"Ripeti questa riga n volte". (-2 byte)

óo î½o
u

che era "Sostituisci la prima corrispondenza di questa regex; Annulla" è stata sostituita con

/o î½o

Che è solo "Cerca una corrispondenza di questa regex" (-1 byte)

E, infine, Òè solo un semplice sinonimo di Vr, che "Sostituisce ogni carattere su questa riga con 'x'". (-2 byte)

32 codice macchina x86 little-endian a 16 bit, 57 54 51 byte

3 byte in meno grazie a @ninjalj.

Ho riscritto pesantemente il codice e sono riuscito a radere via altri 3 byte

In esadecimale

FCBA6F208D48FFE20492AAEB2389D941D1E14151B05FF3AAEB0BB87C20AB89D992F3AB92AAB00AAA4E7DEF59B02DF3AA91AAC3

Input: BX = larghezza, SI = altezza, DI punta al buffer che riceve il risultato come una stringa terminata NULL con linee separate da "\ n"

Smontaggio:

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]

Restituisce una stringa, con un condizionale per gestire il blocco 1,1.

Grazie a Lynn e Chepner per due byte

CJam, 34

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

Provalo online

Spiegazione:

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

Rubino, 59 56 byte

Funzione anonima, restituisce una stringa multilinea. Provalo online!

-3 byte grazie a prendere in prestito un trucco da @ El'endiaStarman

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

Java, 318 312 297 294 260 258 byte

Risparmiato 15 byte grazie a 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);}}

Funziona con argomenti da riga di comando.

Ungolfed in una forma leggibile dall'uomo:

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

Sì, è ancora difficile capire cosa sta succedendo anche quando il programma non è salvato. Quindi ecco una spiegazione dettagliata:

static void main(String[] A)

I primi due argomenti della riga di comando, che useremo per ottenere le dimensioni, possono essere usati nel programma come A[0]e A[1](rispettivamente).

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

bè il numero di colonne, Bè il numero di righe ed Cè una variabile dedicata all'uso nei forloop.

cè il pezzo di Lego. Le aggiungeremo delle righe e le stamperemo alla fine.

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

Se il pezzo da stampare è 1x1, allora sia b(numero di colonne) e B(numero di righe) deve essere inferiore a 2. Così abbiamo semplicemente fissato cad un singolo oe poi saltare al l'affermazione che System.out.prints il pezzo, se questo è il caso.

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

Qui, aggiungiamo caratteri di (integerValueOfA[0] * 2) + 3sottolineatura a c. Questa è la riga più in alto sopra tutti i buchi.

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

Questo è il ciclo in cui costruiamo il pezzo una fila alla volta. Quello che succede dentro è impossibile da spiegare senza esempi. Diciamo che il pezzo è 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 += "-";

Qui, aggiungiamo (integerValueOfA[0] * 2) + 3trattini al pezzo. Questa è la fila in fondo, sotto tutti i buchi.

Il pezzo 4x4 che ho usato per spiegare il forloop in cui il pezzo è effettivamente costruito ora appare così:

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

E infine, stampiamo il pezzo!

Minkolang 0,15 , 58 57 56 byte

Sì, è giusto. Ho giocato a golf fuori uno due puzzolente piccoli byte ...

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

Provalo qui!

Spiegazione

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.

Va bene, sono due riscritture significative della spiegazione per due byte salvati. Non credo di poter golf o di golf qualcosa di più da questo. : P

Brainfuck, 391 byte

So che si può giocare di più, ma a questo punto sono contento che funzioni. Continuerò a lavorare per giocare a golf.

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

L'input deve essere dato come solo due cifre. Come in, per fare (8, 2)sarebbe solo entrare 82.

Provalo online!

Abbattersi:

Innanzitutto inserisci i caratteri necessari nel nastro: (newline)| o_-

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

Quindi raccogliere l'input in due celle e sottrarre 48 da ciascuna (per ottenere il valore numerico e non il carattere numerico)

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

Quindi, controlla il caso speciale di (1, 1)(Nota che solo questo controllo rappresenta 109 byte del codice). Come se ifnon fosse abbastanza difficile da fare in Brainfuck, abbiamo un nidificato if:

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

Di seguito è riportata la struttura per verificare se una cella x è zero o diversa da zero:

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

Tuttavia, in un nidificato if, dobbiamo avere 4 celle temporanee.

Ora arriviamo alla stampa effettiva dei personaggi:

Stampa la barra superiore e una nuova riga:

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

Stampa a |, una riga di o, un'altra |e una nuova riga un numero di volte uguale all'altezza:

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

E stampa la barra in basso (non è necessaria una nuova riga qui):

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

Retina , 52 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1. Si noti che la sesta riga dovrebbe contenere un singolo spazio.

\G1?
$_¶
1* 



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

Provalo online!

L'input è in unario, usando 1come cifra unaria, spazio come separatore e altezza seguita da larghezza.

Spiegazione

Tutte le fasi di questo programma sono sostituzioni semplici, occasionalmente con un modificatore regex regolare (nessuna ripetizione o loop, nessun altro tipo di fasi). Non utilizza nemmeno le funzionalità di sostituzione specifiche di Retina, a parte il solito ¶alias per gli avanzamenti di riga.

\G1?
$_¶

Lo scopo di questo è "moltiplicare" i due ingressi. Il nostro obiettivo è quello di creare h+2righe con w 1s ciascuna (in h+2modo che possiamo trasformare la parte superiore e inferiore in _e -successive). L' \Gancora richiede che la partita inizi da dove era stata interrotta l'ultima. Cioè, se non riusciamo mai ad abbinare un carattere nella stringa, anche altri caratteri non corrisponderanno. Usiamo questo per abbinare solo le 1s in h, ma non in wperché la regex non consente di abbinare lo spazio che le separa. Tuttavia, creiamo anche l' 1opzione opzionale, in modo da ottenere una corrispondenza vuota aggiuntiva alla fine di h. Sono h+1partite. Ognuno di questi viene sostituito con l'intero input ( $_) seguito da un avanzamento riga.wstesso rimane intatto che ci dà la h+2copia n. Supponiamo che l'input sia stato 11 1111, quindi ora abbiamo:

11 1111
11 1111
11 1111
 1111

È piuttosto buono. Abbiamo delle cose extra, ma le h+2copie di wci sono.

1* 

Nota che c'è uno spazio alla fine della prima riga. Questo rimuove quei prefissi dalle linee in modo da avere solo le ws in seguito.

Ah bene, non funziona davvero con la formattazione di SE ... la prima riga è vuota e la seconda riga dovrebbe contenere un singolo spazio. Ciò inserisce gli spazi in ogni posizione possibile, cioè all'inizio e alla fine di ogni riga e tra ogni coppia di 1s:

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

Li trasformeremo in os più tardi

.+
|$&|

Questo semplicemente avvolge ogni riga in una coppia di |:

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

Ora ci occupiamo della parte superiore e inferiore:

\G.
_

È tempo \Gdi risplendere. Questo corrisponde a ciascun personaggio della prima riga e lo trasforma in a _.

r`.\G
-

Stessa cosa, ma a causa del rmodificatore (modalità da destra a sinistra), questo corrisponde ai caratteri dell'ultima riga e li trasforma in -. Quindi ora abbiamo:

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

Sono rimaste solo due cose da fare ora: trasformale 1in os e, se l'input è stato, 1 1trasforma l'intera cosa in oinvece. Siamo in grado di gestire entrambi quelli con un unico stadio:

s`^.{17}$|1
o

sè una normale modalità a linea singola (cioè fa .corrispondere le alimentazioni). Se l'input è stato 1 1il risultato avrà la dimensione minima di 17 caratteri in modo che possiamo abbinarlo ^.{17}$e sostituirlo con o. Altrimenti, se fallisce, abbineremo semplicemente tutti 1i se sostituiremo quelli con o.

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, non competitivo

Bene, ho realizzato un box incorporato migliore.

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

Jolf, 38 37 byte

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

Roba semplice, davvero. Ho salvato un byte osservando che !Ζ(matematica zeta, o devianza dello stand) è solo 0 quando entrambi gli argomenti sono 1, ed è falso altrimenti (per il nostro caso).

05AB1E , 33 byte

Codice:

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

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! .

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`

Modifica: salvato 3 byte grazie a @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

Avrei preferito commentare questo post, ma non ho ancora la reputazione, quindi sto mettendo una mia risposta, che funziona in modo simile, ma è leggermente più compatta

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

puoi testare il codice qui

Reng v.4, 82 byte, non competitivo

Ho inserito una correzione di bug che risolve le funzioni che vengono sovrascritte da sole (per favore non chiedere; la mia roba è infestata)

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

Accetta input come numeri uniti nello spazio, come 4 2. Provalo qui!

PowerShell v2 +, 76 byte

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

Accetta input, quindi controlla ifun'istruzione. Poiché i valori diversi da zero sono veritieri in PowerShell, purché almeno uno $xe $ynon siano uguali 1, il valore ifsarà vero.

All'interno di if, c'è una serie di moltiplicazioni di stringa. Innanzitutto, costruiamo la nostra serie di caratteri di sottolineatura, risparmiando $zper dopo. Questo viene messo in cantiere. Successivamente costruiamo la nostra serie di lati e pioli (con i pioli moltiplicati per $x), i $ytempi fatti e concateniamo i $ztempi con i nostri trattini . Quella stringa viene quindi posizionata sulla pipeline e noi exit. La pipeline viene scaricata e la stampa è implicita. Si noti che otteniamo la nuova riga tra i trattini bassi e la prima riga di pioli gratuitamente, poiché il .ToString()separatore predefinito per l'output dell'array è `n(e stiamo producendo un array di stringhe).

Se il valore ifè falso, siamo nel 1 1caso speciale , quindi ci limitiamo a metterlo "o"da solo sulla pipeline e ad uscire, con la stampa di nuovo implicita.

Esempi

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
}

Nota: se hai davvero bisogno del lego per avere trattini per l'ultima riga, cambia l'ultima stampa in

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

e aggiungi due 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. Con l'aiuto di 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();}

Grazie a @Lince Assassino per aver salvato 11 byte!

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

Gomma alla cannella, 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..."_.}.

Fuori concorso. Provalo online. L'input deve essere esattamente nella forma [width,height]senza spazio tra la virgola e l'altezza.

Spiegazione

La stringa si decomprime a questo:

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

Il primo lstadio è mappato [1,1]al o(caso speciale) e tutto il resto alla stringa

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

Il backtick segnala quindi l'inizio di un secondo stadio; invece di emettere quella stringa, CG taglia via il backtick ed esegue la stringa. La pmodalità ripete quindi tutti i caratteri all'interno delle tilde il primo parametro (larghezza) volte e poi ripete i caratteri all'interno dei segni del secondo parametro (altezza) volte. Quindi per [4,2]questo si trasforma in questo:

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

e poi in:

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

Lotto, 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=--%

Modifica: salvato 2 byte grazie a @ CᴏɴᴏʀO'Bʀɪᴇɴ @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.

Posso salvare 7 byte se posso supporre che l'espansione ritardata sia abilitata.

Vim, 56 battute

Sembra un'attività di modifica del testo, quindi Vim è la scelta ovvia! Prendo l'input come file di testo con due numeri interi separati da spazio e output la risposta nello stesso file. Inoltre, ti odio per avere il caso speciale 1x1 ... Comunque:

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

e se non ci fosse stato per il caso speciale, 35 battute

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

Una ripartizione per persone sane:

"adt l"bD

Elimina i numeri dal buffer in @a e @b (spazio conservato)

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

Sostituisci lo spazio con "o" e, in caso speciale, salva ed esci

                                Di| |<esc>

Cancella la linea e scrivi i bordi del lego block

                                          @aio <esc>

Inserisci @a un sacco di "o" per ottenere una parte centrale finita

                                                    yy@bP

Yank line e fai @b copie extra (una in più)

                                                         Vr_

Siamo in cima al buffer, sostituiamo la riga aggiuntiva con caratteri di sottolineatura

                                                            Gp

Vai alla fine del buffer, tira la linea che abbiamo strappato in precedenza

                                                              Vr-ZZ

Sostituisci la linea con trattini, salva ed esci

Pyth, 38 byte

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

Suite di test.

Haskell, 76 byte

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

Esempio di utilizzo: 3 # 2ti dà una stringa multilinea per un mattone 3 per 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}

test:

(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

So che esistono già diverse soluzioni Befunge, ma ero abbastanza sicuro che avrebbero potuto essere migliorate adottando un approccio diverso al layout del codice. Sospetto che questa risposta possa essere ulteriormente approfondita, ma è già un po 'più piccola di una delle voci precedenti.

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

Provalo online!

APL, 46 byte

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

La guardia: ⍵≡1 1:'o'per il caso speciale. Altrimenti 'o '⍴⍨1 2×⌽⍵costruisce il contenuto. E il resto è solo la boxe.

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

veloce e sporco

Ho dovuto scrivere una funzione che moltiplica le stringhe

ungolfed (per suggerimenti)

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

Ottava, 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}

Ho usato il metodo di @atlasologist in Python per testare (1, 1):(...,'o')[x<2>y]

Grazie a @Luis Mendo per aver salvato 7 byte: a=ones(1,w*2+3)*'_'da a=~(1:w*2+3)+95e a./a*'-'verso~a+45

Grazie a @pajonk per aver salvato 2 byte:f=