História de fundo

_{^{Não é realmente real, sshh!}}

Tudo começou um dia quando um colega de trabalho trouxe um pedaço de pão caseiro para o aniversário do meu chefe.

Meu chefe gostava muito desse pão e queria outro. Infelizmente, meu colega de trabalho parou, então meu chefe precisa que eu dê outro pão para ele.

O problema é que não tenho ideia de como fazer pão. Então eu disse ao meu chefe que não sou chef e que deveria procurar mais alguém que seja.

Ele disse: "Claro ... mas você perde o emprego se não puder me fazer um pão".

Então eu tive uma ideia.

Eu faria dele uma arte ascii pão de com meu skilz de codificação! Ele disse que sim, sob uma condição: "Você deve fazê-lo em menos de 351 bytes". Infelizmente para mim, meu melhor código de golfe me levou a 375 bytes. Ah, oh.

Em seguida, meu chefe acrescentou duas coisas: "Você deve me dar esse pão em uma semana (13/4) e, se o fizer, recebe um aumento de salário. Quanto menor a quantidade de bytes que você usa, melhor o salário. Mas lembre-se: se você ultrapassar os 349, perde o emprego ".

Então, preciso da sua ajuda no seu idioma de escolha para me ajudar a manter meu emprego!

Regras

Eu estava prestes a fazer um curl ... | shTinyURL, mas meu chefe me disse que não posso usar uma lista de brechas . Eu provavelmente poderia burlar as regras, mas meu trabalho está em jogo, então não é uma boa ideia.

O que conta como pão

Seu programa ou função deve receber 3 números inteiros positivos como entrada. Se o seu idioma tiver uma lista ou matriz, você poderá obter uma lista ou matriz desses números. Você também pode levá-los como argumentos para uma função ou programa ou como uma seqüência de números separada por espaço para STDIN, um argumento de linha de comando ou função, etc.

O primeiro número é a largura do seu pão

O segundo número é a altura do seu pão.

O terceiro número é a profundidade do seu pão.

Aqui está um pão com largura 3, altura 2e profundidade de1 :

 / --- \
/ --- \ |
| ||
| ___ | /

Parece estranho? Aqui está um 3x2x2:

  / --- \
 / |
/ --- \ |
| | /
| ___ | /

Que tal um 3x3x3:

   / --- \
  / |
 / |
/ --- \ |
| | /
| | /
| ___ | /

Um 4x1x2:

  / ---- \
 / |
/ ---- \ /
| ____ | /

Espero que entenda! Veja minha resposta JS (ES6) abaixo para um exemplo.

Veja também casos de teste completos

Notas:

• Não se preocupe com informações válidas. Todos os tamanhos serão inteiros positivos.
• Você deve aceitar quaisquer números inteiros positivos que seu idioma possa suportar.
• Se os números forem tão altos, seu idioma falhará no StackOverflow, no estouro máximo do comprimento da string etc.

Menor resposta em bytes ganha!

Carvão , 35 33 30 bytes

Economizou 2 bytes graças a @ ASCII-only

Economizou 3 bytes graças a @Neil reorganizando a ordem em que as linhas foram desenhadas

ＮωＮηＮδ↓η↗→×_ω↑η←\←ω↗δ→/ω↓\↓η↙δ

Experimente online!

Esta é a minha primeira tentativa no carvão. Ouvi dizer que era bom em ascii-art , então tentei.

Explicação (desatualizada)

ＮωＮηＮδ                  # Take the width, height and depth as input
↗¹                        # Write 1 /
↗δ                        # Write depth times /
¶ω                        # Move the cursor down and write - width times
\                         # Write \
↙↓η                       # Move the cursor one down and one left, and then write | height times
↙δ                        # Write / depth times

Agora a parte de trás do pão está completa. Agora vem a face frontal.

↑↑η                       # Go up and write | height times
←\                        # Write a \ and move 1 to the left
←ω                        # Write - width times
↓↓η                       # Go down and write | height times
↗Ｐ×_ω                    # Go northeast and write _ width times

C, 270 290 320 320 328 bytes

#define P printf(
p(n,s)char*s;{P s,--n&&p(n,s));}i,j,k;f(w,h,d){P "%*c",d+1,47);p(w,"-");P "\\\n");for(i=d,j=h,k=0;--i;)P "%*c%*c\n",i+1,47,w+d+1-i-k+!!k,j-->0?124:(++k>0)*47);P "/");p(w,"-");P "\\%*c\n",d-k,j-->0?124:47);for(k&&k++;++i<h;)P "|%*c%*c\n",w+1,124,d-k>!k?d+1-k-!k:0,j-->0?124:(++k>0)*47);P "|");p(w,"_");P "|/");}

Finalmente (depois de duas três versões incorretas), também funciona corretamente com tamanhos grandes.

Experimente online!

JS (ES6), 375 bytes

s=(s,t)=>s.repeat(t);(d,c,e)=>{z=" ",y=`
`,x="\\",w="/",v="|",u="-";a=s(z,e--);a=a+w+s(u,d);a+=x+y;for(b=0;b<e;b++)a+=s(z,e-b),b<c?(a+=w,a+=s(z,d+b+1),a+=v):(a+=w,a+=s(z,d+c+1),a+=w),a+=y;a=a+w+s(u,d);a+=x;f=0;b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w);b++;f++;a+=y;for(g=0;g<c;g++)a+=v,a+=s((g==c-1?"_":z),d),a+=v,b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w),b++,f++,a+=y;return a}

Ungolfed:

var proc = function(width, height, depth){
    var str = "";

    //Back of loaf (depth)
    str += " ".repeat(depth);//initial padding before start of back of loaf
    str += "/";//top left corner of back of loaf
    str += "-".repeat(width);//top edge of back of loaf
    str += "\\";//top left corner of back of loaf
    str += "\n";//end line

    //Depth lines
    for(var i = 0; i < depth - 1; i++){
        console.log(i)
        str += " ".repeat(depth - i - 1);//space padding before start of left middle edge
        if(i < height){
            //str += " ".repeat(depth - i - 2);
            str += "/";//left middle edge
            str += " ".repeat(width + i + 1);//middle of loaf
            str += "|";//end that edge
            str += "\n";//end line
        }else{
            str += "/";//left middle edge
            str += " ".repeat(width + height + 1);//between two /s
            str += "/";//right middle edge
            str += "\n";//end line
        }
    }

    //front top edge of loaf
    str += "/";//top left corner
    str += "-".repeat(width);//top edge
    str += "\\";//top right corner

    var i3 = 0;

    if(i < height){
        str += " ".repeat(depth - 1);//space for the incoming far right edge
        str += "|";//far right edge
        i++;
        i3++;
    }else{
        str += " ".repeat(height - i3);//space for the incoming far right edge
        str += "/";//far right edge
        i++;
        i3++;
    }

    str += "\n";//newline


    for(var i2 = 0; i2 < height; i2++){
        str += "|";//left edge
        str += (i2 === height - 1 ? "_" : " ").repeat(width);//if we are at the bottom, use underscores to mark that, otherwise spaces.
        str += "|";
        if(i < height){
            str += " ".repeat(depth - 1);//space for the incoming far right edge
            str += "|";//far right edge
            i++;
            i3++;
        }else{
            str += " ".repeat(height - i3);//space for the incoming far right edge
            str += "/";//far right edge
            i++;
            i3++;
        }
        str += "\n";//newline
    }

    return str;
};

s=(s,t)=>s.repeat(t);
var bakeBread = (d,c,e)=>{z=" ",y=`
`,x="\\",w="/",v="|",u="-";a=s(z,e--);a=a+w+s(u,d);a+=x+y;for(b=0;b<e;b++)a+=s(z,e-b),b<c?(a+=w,a+=s(z,d+b+1),a+=v):(a+=w,a+=s(z,d+c+1),a+=w),a+=y;a=a+w+s(u,d);a+=x;f=0;b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w);b++;f++;a+=y;for(g=0;g<c;g++)a+=v,a+=s((g==c-1?"_":z),d),a+=v,b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w),b++,f++,a+=y;return a}

<input type = "number" id = "a1">
<br/>
<input type = "number" id = "a2">
<br/>
<input type = "number" id = "a3">
<br/>
<button onclick = "document.getElementById('textarea').innerText = bakeBread(+(document.getElementById('a1').value), +(document.getElementById('a2').value), +(document.getElementById('a3').value))">Bake Bread!</button>
<br/>
<textarea id = "textarea"></textarea>

Python 2 , 234 216 210 bytes

w,h,d=input()
f,g='|','/';z,s=g+'-'*w+'\\',' '
print'\n'.join([s*d+z]+[s*(d-c)+g+s*(w+c)+(f,g)[c>h]for c in range(1,d)]+[z+s*(d-1)+(f,g)[d>h]]+[f+s*w+f+s*(h-e-1)+(f,s+g)[d>=h]for e in range(1,h)]+[f+'_'*w+f+g])

Experimente online!

Claro que pode ser jogado muito mais, mas é um começo. 210 fará por mim por enquanto.

PHP, 420 bytes

<?php $a=$_GET["a"];$b=$_GET["b"];$c=$_GET["c"];$w="<br>";$s="&nbsp;";$u="&#95";$p="|";$k="/";$t=str_repeat;$l='';$r=$t($s,$c).$k.$t("-",$a)."\\".$w;for($i=0;$i<$c+$b-1;$i++){$i<=$b-1?($i<$c-1?$l=$t($s,$a+$i+1).$p:$l=$t($s,$c-1).$p):($i<$c-1?$l=$t($s,$a+$b+1).$k:$l=$t($s,$c+$b-$i-1).$k);$i<$c-1?$r.=$t($s,$c-$i-1).$k.$l.$w:($i==$c-1?$r.=$k.$t("-",$a)."\\".$l.$w:$r.=$p.$t($s,$a).$p.$l.$w);};echo$r.=$p.$t($u,$a).$p.$k?>

Parece que alguém foi demitido - talvez tente convencer seu chefe de que é muito mais legal no back-end.

A entrada está anexada à string do URL: ?a=[width]&b=[height]&c=[depth] - você pode experimentá-lo on-line no meu host barato. Nessas situações, eu realmente amo usar solicitações GET.

Ungolfed for transparent:

<?php 
$a=$_GET["a"];$b=$_GET["b"];$c=$_GET["c"];
$w="<br>";$s="&nbsp;";$u="&#95"; $p="|";$k="/";$t=str_repeat;$f=$v=$m=$l='';
//first line
$r=$t($s,$c).$k.$t("-",$a)."\\".$w;


for($i=0;$i<$c+$b-1;$i++){

    //right side of the loaf
    $i <= $b-1 
    ? ($i < $c-1 ? $l=$t($s,$a+$i+1).$p : $l=$t($s,$c-1).$p)  
    : ($i < $c-1 ? $l=$t($s,$a+$b+1).$k : $l=$t($s,$c+$b-$i-1).$k) ;

    //left side, with the right side attached
    $i<$c-1 
        ? $r.=$t($s,$c-$i-1).$k.$f.$l.$w
        : ($i==$c-1 
            ? $r.=$k.$t("-",$a)."\\".$f.$l.$w
            : $r.=$p.$t($s,$a).$p.$f.$l.$w);

};
    //final line
    echo $r.=$p.$t($u,$a).$p.$k;

?>

JavaScript (ES6), 204 bytes

(w,h,d)=>[...Array(h-~d)].map((_,y)=>[...Array(w-~d)].map((_,x)=>x+y==d|x+y==h+w-~d?`/`:x==w+d&y<=h&&y||!x|x==w&&y>d?`|`:y==h+d&x<w?`_`:!y|y==d?x+y==w+d?`\\`:x+y>d&x+y<w+d?`-`:` `:` `).join``,++w).join`\n`

Onde \nrepresenta o caractere literal de nova linha.

Em vez de mexer com caracteres repetidos, isso apenas cria uma matriz de tamanho adequado e calcula qual caractere aparece em cada célula.