Ce défi est simple, celui de l’ art ASCII . Étant donné deux entrées, décrivant la hauteur et la largeur d’une pièce Lego, vous en imprimez une représentation artistique au format ASCII.

Voici à quoi doivent ressembler les morceaux de 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

Si vous ne pouvez pas le savoir à partir des cas de test, le haut et le bas sont des width*2+3tirets bas et des tirets, et chaque ligne a des tuyaux pour les côtés, opour les petites choses, et tout est séparé par des espaces.

La seule exception à cette règle est (1, 1)qu'il ne s'agit que d'un seul o.

Vous n'obtiendrez jamais 0aucune des dimensions.

C'est du code-golf , donc le code le plus court en octets gagne!

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 octets

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

Pas autant d'espaces qu'avant, mais il reste des lacunes. Le principe est le même que dans la solution précédente, mais la disposition est différente. Cette fois, pour vérifier si les deux nombres sont égaux à 1, je prends simplement leur produit et vérifie si le résultat est supérieur à 1.

Ancienne solution (227 octets)

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

Il serait peut-être possible de jouer au golf plus souvent. Il suffit de regarder tout cet espace!

Voici ma mauvaise tentative d'explication sous forme d'image MSPaint: Le code coule dans le sens de la flèche.

V , 43, 40, 38 36 octets

Une des plus longues réponses V que j'ai jamais écrites ...

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

Essayez-le en ligne!

Comme il contient des caractères unicode et non imprimables, voici un hexdump réversible:

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_

Ce défi consiste à manipuler du texte, donc parfait pour V! D'un autre côté, V est terrible en conditions et en mathématiques, donc le résultat différent pour (1, 1) l'a vraiment foiré ... :(

Explication:

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

Nous avons maintenant des lignes de «hauteur» de o avec des espaces entre elles.

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

Version non concurrente (31 octets):

Essayez-le en ligne!

Cette version utilise plusieurs fonctionnalités qui sont plus récentes que ce défi d'être plus courtes de 5 octets!

Deuxième explication:

ddÀP

qui est "Supprimer la ligne et la coller n fois" est remplacé par ÀÄ"Répéter cette ligne n fois". (-2 octets)

óo î½o
u

qui était "Remplacer le premier match de cette regex; Annuler" a été remplacé par

/o î½o

Ce qui est juste "Rechercher une correspondance de cette expression rationnelle" (-1 octet)

Enfin, Òn’est qu’un synonyme simple pour Vrlequel "Remplace chaque caractère de cette ligne par un" x "". (-2 octets)

32 code machine x86 little-endian 16 bits, 57 54 51 octets

3 octets de moins grâce à @ninjalj.

Fortement réécrit le code et ont réussi à raser 3 autres octets

En hex

FCBA6F208D48FFE20492AAEB2389D941D1E14151B05FF3AAEB0BB87C20AB89D992F3AB92AAB00AAA4E7DEF59B02DF3AA91AAC3

Entrée: BX = largeur, SI = hauteur, DI pointe vers la mémoire tampon qui reçoit le résultat sous forme de chaîne terminée par une valeur NULL avec des lignes séparées par "\ n"

Démontage:

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 octets

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

Retourne une chaîne, avec une condition pour gérer le bloc 1,1.

Merci à Lynn et Chepner pour deux octets

CJam, 34 ans

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

Essayez-le en ligne

Explication:

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

Fonction anonyme, renvoie une chaîne multiligne. Essayez-le en ligne!

-3 octets grâce à l'emprunt d'un tour de @ El'endiaStarman

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

Java, 318 312 297 294 260 258 octets

Sauvegardé 15 octets grâce à 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);}}

Cela fonctionne avec des arguments en ligne de commande.

Ungolfed Sous une forme lisible par l'homme:

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

Oui, il est encore difficile de comprendre ce qui se passe même lorsque le programme n'est pas joué. Donc, voici une explication étape par étape:

static void main(String[] A)

Les deux premiers arguments de la ligne de commande, que nous utiliserons pour obtenir des dimensions, peuvent être utilisés dans le programme en tant que A[0]et A[1](respectivement).

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

best le nombre de colonnes, Best le nombre de lignes et Cest une variable dédiée à une utilisation dans les forboucles.

cest la pièce de Lego. Nous y ajouterons des lignes puis l’imprimerons à la fin.

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

Si la pièce à imprimer est 1x1, les deux b(nombre de colonnes) et B(nombre de lignes) doivent être inférieurs à 2. Nous définissons donc simplement cune seule o, puis passons à la déclaration qui correspond à System.out.printla pièce si tel est le cas.

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

Ici, nous annexons des (integerValueOfA[0] * 2) + 3underscores à c. C'est la rangée la plus haute au-dessus de tous les trous.

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

C'est la boucle où nous construisons la pièce une rangée à la fois. Ce qui se passe à l'intérieur est impossible à expliquer sans exemples. Disons que la pièce est 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 += "-";

Ici, nous ajoutons des (integerValueOfA[0] * 2) + 3traits d'union à la pièce. C'est la rangée tout en bas, en dessous de tous les trous.

Le morceau 4x4 que j'ai utilisé pour expliquer la forboucle où le morceau est réellement construit ressemble maintenant à ceci:

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

Et finalement, nous imprimons la pièce!

Minkolang 0.15 , 58 57 56 octets

Oui c'est vrai. Je hors joué au golf un à deux petits puants octets ...

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

Essayez-le ici!

Explication

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.

Ok, ce sont deux réécritures significatives de l'explication pour deux octets sauvegardés. Je ne pense pas que je peux ou vais jouer au golf plus que celui-ci. : P

brainfuck, 391 octets

Je sais que cela peut être joué plus souvent, mais à ce stade, je suis content que cela fonctionne. Je continuerai à travailler pour le réduire.

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

L'entrée doit être donnée sous forme de deux chiffres seulement. Comme dans, (8, 2)vous entrez simplement 82.

Essayez-le en ligne!

Panne:

Commencez par insérer les caractères nécessaires dans la bande: (newline)| o_-

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

Ensuite, collectez l'entrée dans deux cellules et soustrayez 48 de chacune (pour obtenir la valeur numérique et non le caractère numérique)

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

Ensuite, vérifiez le cas particulier de (1, 1)(Notez que cela ne concerne que la vérification de 109 octets du code). Comme si ce ifn’était pas assez difficile à faire en brainfuck, nous avons un imbriqué if:

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

Voici la structure pour vérifier si une cellule x est zéro ou non nulle:

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

Cependant, dans un imbriqué if, nous avons besoin de 4 cellules temporaires.

Nous arrivons maintenant à l'impression réelle des caractères:

Imprimer la barre du haut et une nouvelle ligne:

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

Imprimer un |, un rang de o', un autre |et un saut de ligne plusieurs fois de la même hauteur:

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

Et imprimez la barre du bas (pas de nouvelle ligne nécessaire ici):

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

Retina , 52 octets

Le nombre d'octets suppose un codage ISO 8859-1. Notez que la sixième ligne est supposée contenir un seul espace.

\G1?
$_¶
1* 



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

Essayez-le en ligne!

L'entrée est unaire, en utilisant 1comme chiffre unaire, l'espace comme séparateur et la hauteur suivie de la largeur.

Explication

Toutes les étapes de ce programme sont des substitutions nues, parfois avec un modificateur de regex régulier (pas de répétition ni de boucles, pas d'autres types d'étapes). Il n'utilise même pas les fonctionnalités de substitution spécifiques à Retina, à l'exception de l' ¶alias habituel pour les sauts de ligne.

\G1?
$_¶

Le but de ceci est de "multiplier" les deux entrées. Notre objectif est de créer des h+2lignes avec w 1s chacune ( h+2afin que nous puissions transformer le haut et le bas en _et -plus tard). L' \Gancre nécessite que le match commence là où le dernier s'est arrêté. Autrement dit, si nous ne parvenons jamais à faire correspondre un caractère de la chaîne, les autres caractères ne correspondront pas non plus. Nous utilisons cela pour ne faire correspondre que le 1s in h, mais pas wparce que la regex ne permet pas de faire correspondre l'espace qui les sépare. Cependant, nous faisons aussi l' 1option, afin d'obtenir une correspondance vide supplémentaire à la fin de h. C'est des h+1allumettes. Chacune de celles-ci est remplacée par l'entrée entière ( $_) suivie d'un saut de ligne.welle-même reste intacte, ce qui nous donne la h+2nd copie. Disons que l'entrée était 11 1111, alors nous avons maintenant:

11 1111
11 1111
11 1111
 1111

C'est plutôt bien. Nous avons quelques trucs en plus, mais les h+2copies wsont là.

1* 

Notez qu'il y a un espace à la fin de la première ligne. Cela supprime ces préfixes des lignes afin que nous n'ayons que le ws après.

Eh bien, cela ne fonctionne pas vraiment avec le formatage de SE ... la première ligne est vide et la deuxième ligne est supposée contenir un seul espace. Cela insère des espaces dans toutes les positions possibles, c'est-à-dire au début et à la fin de chaque ligne et entre chaque paire de 1s:

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

Nous allons les transformer en os plus tard

.+
|$&|

Ceci enveloppe simplement chaque ligne dans une paire de |:

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

Maintenant on s'occupe du haut et du bas:

\G.
_

Il est temps \Gde briller à nouveau. Cela correspond à chaque caractère de la première ligne et le transforme en _.

r`.\G
-

Même chose, mais en raison du rmodificateur (mode de droite à gauche), cela correspond aux caractères de la dernière ligne et les transforme en -. Alors maintenant nous avons:

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

Il ne reste plus que deux choses à faire maintenant: transformez-les 1en os, et si l'entrée était 1 1alors, transformez le tout en oplace. Nous pouvons gérer les deux avec une seule étape:

s`^.{17}$|1
o

sest le mode simple ligne ordinaire (c’est-à-dire qu’il fait .correspondre les sauts de ligne). Si la saisie a été effectuée, 1 1le résultat aura une taille minimale de 17 caractères, ce qui nous permet de le faire correspondre ^.{17}$et de le remplacer o. Sinon, si cela échoue, nous allons simplement faire correspondre tous les 1s et les remplacer par o.

Jolf, 36 octets

?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 octets, sans compétition

Eh bien, j'ai fait une meilleure boîte intégrée.

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

Jolf, 38 37 octets

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

Des choses simples, vraiment. Sauvegardé un octet en notant que !Ζ(zeta mathématique, ou la déviance de stand) n’est que 0 lorsque les deux arguments valent 1, et est sinon falsey (dans notre cas).

05AB1E , 33 octets

Code:

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

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne! .

JavaScript (ES6), 89 86 octets

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

Edit: 3 octets enregistrés grâce à @Shaggy.

Python 2, 71 octets

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

Befunge, 144 octets

J'aurais préféré commenter cet article, mais je n'ai pas encore la réputation, alors je pose moi-même une réponse, qui fonctionne de la même manière, mais qui est légèrement plus compacte.

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

vous pouvez tester le code ici

Reng v.4, 82 octets, sans compétition

J'ai mis en place un correctif qui corrige les fonctions écrasées par eux-mêmes (veuillez ne pas demander, mes données sont hantées)

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

Prend les entrées sous forme de nombres joints par des espaces, comme 4 2. Essayez-le ici!

PowerShell v2 +, 76 octets

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

Prend les entrées, puis vérifie une ifdéclaration. Étant donné que les valeurs non nulles sont truthy dans PowerShell, tant au moins un $xet $yne sont pas égaux 1, le ifsera vrai.

À l'intérieur du if, il y a une série de multiplications de chaînes. Premièrement, nous construisons notre chaîne de caractères de soulignement, en conservant $zpour plus tard. Cela est placé sur le pipeline. Ensuite, nous construisons notre chaîne de côtés et de chevilles (multipliée par les chevilles $x), les $ytemps réalisés et concaténons cela avec nos $ztemps de tirets . Cette chaîne est ensuite placée sur le pipeline et nous exit. Le pipeline est vidé et l'impression est implicite. Notez que nous obtenons gratuitement la nouvelle ligne entre les traits de soulignement et la première ligne de chevilles, car le .ToString()séparateur par défaut pour la sortie de tableau est `n(et nous produisons un tableau de chaînes).

Si la valeur ifest false, nous sommes dans le 1 1cas spécial , nous nous mettons donc seuls "o"sur le pipeline et sortons, avec une nouvelle impression implicite.

Exemples

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 octets

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

Remarque: Si vous avez vraiment besoin que le lego ait des traits d'union pour la dernière ligne, remplacez le dernier printf par

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

et ajoutez deux octets.

Perl 5 - 84 77 octets

84 octets

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

77 octets. Avec l'aide de 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 octets

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

Merci à @Lince Assassino d' avoir économisé 11 octets!

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

Cannelle, 32 octets

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

Non en compétition. Essayez-le en ligne. La saisie doit être exactement sous la forme, [width,height]sans espace entre la virgule et la hauteur.

Explication

La chaîne décompresse à ceci:

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

La première létape mappe [1,1]sur o(le cas particulier) et tout le reste sur la chaîne

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

Le backtick signale alors le début d'une deuxième étape; au lieu de sortir cette chaîne, CG découpe le backtick et l'exécute. Le pmode répète ensuite tous les caractères à l'intérieur du premier paramètre de largeur (largeur) tildes, puis à nouveau les caractères à l'intérieur du deuxième paramètre (hauteur) des signes de pourcentage. Donc pour [4,2]cela se transforme en ceci:

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

et ensuite dans:

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

Lot, 172 170 octets

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

Edit: 2 octets sauvés grâce à @ CᴏɴᴏʀO'Bʀɪᴇɴ @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.

Je peux économiser 7 octets si je peux supposer que l’expansion différée est activée.

Vim, 56 frappes

Cela ressemble à une tâche d'édition de texte, alors Vim est le choix évident! Je prends l'entrée comme un fichier texte avec deux entiers séparés par des espaces et la réponse dans le même fichier. Aussi, je vous déteste pour avoir le cas spécial 1x1 ... Quoi qu'il en soit:

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

et s'il n'y avait pas eu le cas spécial, 35 frappes

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

Une ventilation pour les personnes sensées:

"adt l"bD

Supprimer les numéros de la mémoire tampon dans @a et @b (caractère espace gardé)

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

Remplacez l'espace par "o" et si c'est le cas, sauvegardez et quittez

                                Di| |<esc>

Effacer la ligne et écrire les bords du bloc lego

                                          @aio <esc>

Insérer @ beaucoup de "o" pour obtenir une partie intermédiaire finie

                                                    yy@bP

Tirez ligne et faites @b copies supplémentaires (une de trop)

                                                         Vr_

Nous sommes en haut de la mémoire tampon, remplaçons la ligne supplémentaire par des traits de soulignement

                                                            Gp

Aller au bas de la mémoire tampon, tirer la ligne que nous avons tirée plus tôt

                                                              Vr-ZZ

Remplacer la ligne par des tirets, enregistrer et quitter

Pyth, 38 octets

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

Suite de tests.

Haskell, 76 octets

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

Exemple d'utilisation: 3 # 2vous donne une chaîne multiligne pour une brique 3 par 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}

Essai:

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

Je sais qu'il existe déjà un certain nombre de solutions Befunge, mais j'étais assez certain qu'elles pourraient être améliorées en adoptant une approche différente de la présentation du code. Je pense que cette réponse peut également être utilisée, mais elle est déjà un peu plus petite que l’une des entrées précédentes.

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

Essayez-le en ligne!

APL, 46 octets

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

La garde: ⍵≡1 1:'o'pour le cas particulier. Sinon, 'o '⍴⍨1 2×⌽⍵construit le contenu. Et le reste n'est que la boxe.

C #, 198 octets

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

rapide et sale

Je devais écrire une fonction qui multiplie les chaînes

non golfé (pour suggestions)

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 octets

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

J'ai utilisé la méthode de @atlasologist en Python pour tester (1, 1):(...,'o')[x<2>y]

Merci à @ Luis Mendo pour la sauvegarde de 7 octets: a=ones(1,w*2+3)*'_'àa=~(1:w*2+3)+95 et a./a*'-'à~a+45

Merci à @pajonk pour la sauvegarde de 2 octets:f=